Last active
July 29, 2023 09:35
-
-
Save Nall-chan/3adf2344cba926b7978e37b66ce9ceee to your computer and use it in GitHub Desktop.
Functions for IP-Symcon 6.4 with comment
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <?php | |
| $_IPS = array( | |
| 'SELF' => 0, | |
| 'SENDER' => '', | |
| 'VALUE' => 0, | |
| 'OLDVALUE' => 0, | |
| 'VARIABLE' => 0, | |
| 'EVENT' => 0, | |
| 'TRIGGER' => 0, | |
| 'TARGET' => 0, | |
| 'ACTION' => 0, | |
| 'INSTANCE' => 0, | |
| 'THREAD' => 0, | |
| 'FORM' => 0, | |
| 'COMPONENT' => '', | |
| 'DIRECTION' => 0, | |
| 'DURATION' => 0, | |
| 'INSTANCE2' => 0, | |
| 'STATUS' => 0, | |
| 'STATUSTEXT' => '', | |
| 'CONNECTION' => 0, | |
| 'DATA' => '', | |
| 'CONFIGURATOR' => '', | |
| 'INSTANCES' => | |
| array( | |
| ), | |
| 'INVERTS' => | |
| array( | |
| ), | |
| 'CLIENTIP' => '', | |
| 'CLIENTPORT' => 0, | |
| ); | |
| define('MODULETYPE_CORE', 0); | |
| define('MODULETYPE_IO', 1); | |
| define('MODULETYPE_SPLITTER', 2); | |
| define('MODULETYPE_DEVICE', 3); | |
| define('MODULETYPE_CONFIGURATOR', 4); | |
| define('MODULETYPE_DISCOVERY', 5); | |
| define('OBJECTTYPE_CATEGORY', 0); | |
| define('OBJECTTYPE_INSTANCE', 1); | |
| define('OBJECTTYPE_VARIABLE', 2); | |
| define('OBJECTTYPE_SCRIPT', 3); | |
| define('OBJECTTYPE_EVENT', 4); | |
| define('OBJECTTYPE_MEDIA', 5); | |
| define('OBJECTTYPE_LINK', 6); | |
| define('VARIABLETYPE_BOOLEAN', 0); | |
| define('VARIABLETYPE_INTEGER', 1); | |
| define('VARIABLETYPE_FLOAT', 2); | |
| define('VARIABLETYPE_STRING', 3); | |
| define('SCRIPTTYPE_PHP', 0); | |
| define('EVENTTYPE_TRIGGER', 0); | |
| define('EVENTTYPE_CYCLIC', 1); | |
| define('EVENTTYPE_SCHEDULE', 2); | |
| define('EVENTTRIGGERTYPE_ONUPDATE', 0); | |
| define('EVENTTRIGGERTYPE_ONCHANGE', 1); | |
| define('EVENTTRIGGERTYPE_ONLIMITEXCEED', 2); | |
| define('EVENTTRIGGERTYPE_ONLIMITDROP', 3); | |
| define('EVENTTRIGGERTYPE_ONVALUE', 4); | |
| define('EVENTCYCLICDATETYPE_NONE', 0); | |
| define('EVENTCYCLICDATETYPE_ONCE', 1); | |
| define('EVENTCYCLICDATETYPE_DAY', 2); | |
| define('EVENTCYCLICDATETYPE_WEEK', 3); | |
| define('EVENTCYCLICDATETYPE_MONTH', 4); | |
| define('EVENTCYCLICDATETYPE_YEAR', 5); | |
| define('EVENTCYCLICTIMETYPE_ONCE', 0); | |
| define('EVENTCYCLICTIMETYPE_SECOND', 1); | |
| define('EVENTCYCLICTIMETYPE_MINUTE', 2); | |
| define('EVENTCYCLICTIMETYPE_HOUR', 3); | |
| define('EVENTCONDITIONCOMPARISON_EQUAL', 0); | |
| define('EVENTCONDITIONCOMPARISON_NOTEQUAL', 1); | |
| define('EVENTCONDITIONCOMPARISON_GREATER', 2); | |
| define('EVENTCONDITIONCOMPARISON_GREATEROREQUAL', 3); | |
| define('EVENTCONDITIONCOMPARISON_SMALLER', 4); | |
| define('EVENTCONDITIONCOMPARISON_SMALLEROREQUAL', 5); | |
| define('MEDIATYPE_DASHBOARD', 0); | |
| define('MEDIATYPE_IMAGE', 1); | |
| define('MEDIATYPE_SOUND', 2); | |
| define('MEDIATYPE_STREAM', 3); | |
| define('MEDIATYPE_CHART', 4); | |
| define('MEDIATYPE_DOCUMENT', 5); | |
| define('IPS_BASE', 10000); | |
| define('IPS_MODULEBASE', 20000); | |
| define('IPS_KERNELSTARTED', 10001); | |
| define('IPS_KERNELSHUTDOWN', 10002); | |
| define('IPS_KERNELMESSAGE', 10100); | |
| define('KR_CREATE', 10101); | |
| define('KR_INIT', 10102); | |
| define('KR_READY', 10103); | |
| define('KR_UNINIT', 10104); | |
| define('KR_SHUTDOWN', 10105); | |
| define('IPS_LOGMESSAGE', 10200); | |
| define('KL_MESSAGE', 10201); | |
| define('KL_SUCCESS', 10202); | |
| define('KL_NOTIFY', 10203); | |
| define('KL_WARNING', 10204); | |
| define('KL_ERROR', 10205); | |
| define('KL_DEBUG', 10206); | |
| define('KL_CUSTOM', 10207); | |
| define('IPS_MODULEMESSAGE', 10300); | |
| define('ML_LOAD', 10301); | |
| define('ML_UNLOAD', 10302); | |
| define('IPS_OBJECTMESSAGE', 10400); | |
| define('OM_REGISTER', 10401); | |
| define('OM_UNREGISTER', 10402); | |
| define('OM_CHANGEPARENT', 10403); | |
| define('OM_CHANGENAME', 10404); | |
| define('OM_CHANGEINFO', 10405); | |
| define('OM_CHANGETYPE', 10406); | |
| define('OM_CHANGESUMMARY', 10407); | |
| define('OM_CHANGEPOSITION', 10408); | |
| define('OM_CHANGEREADONLY', 10409); | |
| define('OM_CHANGEHIDDEN', 10410); | |
| define('OM_CHANGEICON', 10411); | |
| define('OM_CHILDADDED', 10412); | |
| define('OM_CHILDREMOVED', 10413); | |
| define('OM_CHANGEIDENT', 10414); | |
| define('OM_CHANGEDISABLED', 10415); | |
| define('IPS_INSTANCEMESSAGE', 10500); | |
| define('IM_CREATE', 10501); | |
| define('IM_DELETE', 10502); | |
| define('IM_CONNECT', 10503); | |
| define('IM_DISCONNECT', 10504); | |
| define('IM_CHANGESTATUS', 10505); | |
| define('IM_CHANGESETTINGS', 10506); | |
| define('IM_CHANGEATTRIBUTE', 10507); | |
| define('IM_SEARCHMESSAGE', 10510); | |
| define('IM_SEARCHSTART', 10511); | |
| define('IM_SEARCHSTOP', 10512); | |
| define('IM_SEARCHUPDATE', 10513); | |
| define('IPS_VARIABLEMESSAGE', 10600); | |
| define('VM_CREATE', 10601); | |
| define('VM_DELETE', 10602); | |
| define('VM_UPDATE', 10603); | |
| define('VM_CHANGEPROFILENAME', 10604); | |
| define('VM_CHANGEPROFILEACTION', 10605); | |
| define('IPS_SCRIPTMESSAGE', 10700); | |
| define('SM_CREATE', 10701); | |
| define('SM_DELETE', 10702); | |
| define('SM_CHANGEFILE', 10703); | |
| define('SM_BROKEN', 10704); | |
| define('SM_UPDATE', 10705); | |
| define('IPS_EVENTMESSAGE', 10800); | |
| define('EM_CREATE', 10801); | |
| define('EM_DELETE', 10802); | |
| define('EM_UPDATE', 10803); | |
| define('EM_CHANGEACTIVE', 10804); | |
| define('EM_CHANGELIMIT', 10805); | |
| define('EM_CHANGESCRIPT', 10806); | |
| define('EM_CHANGETRIGGER', 10807); | |
| define('EM_CHANGETRIGGERVALUE', 10808); | |
| define('EM_CHANGETRIGGEREXECUTION', 10809); | |
| define('EM_CHANGECYCLIC', 10810); | |
| define('EM_CHANGECYCLICDATEFROM', 10811); | |
| define('EM_CHANGECYCLICDATETO', 10812); | |
| define('EM_CHANGECYCLICTIMEFROM', 10813); | |
| define('EM_CHANGECYCLICTIMETO', 10814); | |
| define('EM_ADDSCHEDULEACTION', 10815); | |
| define('EM_REMOVESCHEDULEACTION', 10816); | |
| define('EM_CHANGESCHEDULEACTION', 10817); | |
| define('EM_ADDSCHEDULEGROUP', 10818); | |
| define('EM_REMOVESCHEDULEGROUP', 10819); | |
| define('EM_CHANGESCHEDULEGROUP', 10820); | |
| define('EM_ADDSCHEDULEGROUPPOINT', 10821); | |
| define('EM_REMOVESCHEDULEGROUPPOINT', 10822); | |
| define('EM_CHANGESCHEDULEGROUPPOINT', 10823); | |
| define('EM_ADDCONDITION', 10824); | |
| define('EM_REMOVECONDITION', 10825); | |
| define('EM_CHANGECONDITION', 10826); | |
| define('EM_ADDCONDITIONVARIABLERULE', 10827); | |
| define('EM_REMOVECONDITIONVARIABLERULE', 10828); | |
| define('EM_CHANGECONDITIONVARIABLERULE', 10829); | |
| define('EM_ADDCONDITIONDATERULE', 10830); | |
| define('EM_REMOVECONDITIONDATERULE', 10831); | |
| define('EM_CHANGECONDITIONDATERULE', 10832); | |
| define('EM_ADDCONDITIONTIMERULE', 10833); | |
| define('EM_REMOVECONDITIONTIMERULE', 10834); | |
| define('EM_CHANGECONDITIONTIMERULE', 10835); | |
| define('IPS_MEDIAMESSAGE', 10900); | |
| define('MM_CREATE', 10901); | |
| define('MM_DELETE', 10902); | |
| define('MM_CHANGEFILE', 10903); | |
| define('MM_AVAILABLE', 10904); | |
| define('MM_UPDATE', 10905); | |
| define('MM_CHANGECACHED', 10906); | |
| define('IPS_LINKMESSAGE', 11000); | |
| define('LM_CREATE', 11001); | |
| define('LM_DELETE', 11002); | |
| define('LM_CHANGETARGET', 11003); | |
| define('IPS_FLOWMESSAGE', 11100); | |
| define('FM_CONNECT', 11101); | |
| define('FM_DISCONNECT', 11102); | |
| define('FM_CHILDADDED', 11103); | |
| define('FM_CHILDREMOVED', 11104); | |
| define('IPS_ENGINEMESSAGE', 11200); | |
| define('SE_UPDATE', 11201); | |
| define('SE_EXECUTE', 11202); | |
| define('SE_RUNNING', 11203); | |
| define('IPS_PROFILEMESSAGE', 11300); | |
| define('PM_CREATE', 11301); | |
| define('PM_DELETE', 11302); | |
| define('PM_CHANGETEXT', 11303); | |
| define('PM_CHANGEVALUES', 11304); | |
| define('PM_CHANGEDIGITS', 11305); | |
| define('PM_CHANGEICON', 11306); | |
| define('PM_ASSOCIATIONADDED', 11307); | |
| define('PM_ASSOCIATIONREMOVED', 11308); | |
| define('PM_ASSOCIATIONCHANGED', 11309); | |
| define('IPS_TIMERMESSAGE', 11400); | |
| define('TM_REGISTER', 11401); | |
| define('TM_UNREGISTER', 11402); | |
| define('TM_CHANGEINTERVAL', 11403); | |
| define('TM_CHANGEPROGRESS', 11404); | |
| define('TM_MESSAGE', 11405); | |
| define('IS_SBASE', 100); | |
| define('IS_CREATING', 101); | |
| define('IS_ACTIVE', 102); | |
| define('IS_DELETING', 103); | |
| define('IS_INACTIVE', 104); | |
| define('IS_NOTCREATED', 105); | |
| define('IS_EBASE', 200); | |
| define('IF_UNKNOWN', 0); | |
| define('IF_NEW', 1); | |
| define('IF_OLD', 2); | |
| define('IF_CURRENT', 3); | |
| define('IF_UNSUPPORTED', 4); | |
| /** @mainpage Reference list of available IPSymcon functions | |
| * | |
| * This file has been generated using IPSFunktionsDoku.php | |
| */ | |
| /** | |
| * @file | |
| * @brief generated ipsymcon function reference using IPSFunktionsDoku.php | |
| */ | |
| /** | |
| * fügt einer geloggten Variable weitere Datensätze hinzu | |
| * | |
| * <p>Diese Funktion fügt den geloggten Rohdaten der Variable mit der ID <b>VariableID</b> die Datensätze <b>Datensaetze</b> hinzu.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-addloggedvalues/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der Variable, welcher die Datensätze hinzugefügt werden sollen</p> | |
| * @param array $Values <p>Ein Array mit Datensätzen, wobei jeder Datensatz ein Array mit folgenden <b>key => value</b> Paaren ist:</p><li>TimeStampIntegerZeitpunkt des neuen Datensatzes als Unix Timestamp</li><li>Valuenach VariableDer Wert des neuen Datensatzes - Der Typ des Wertes muss hierbei zum Typen der Variable passen</li> | |
| */ | |
| function AC_AddLoggedValues(int $InstanceID, int $VariableID, array $Values) { | |
| } | |
| /** | |
| * migriert Daten einer Variable in eine bisher nicht geloggte Variable | |
| * | |
| * <p>Diese Funktion migriert die Daten der Variable mit der ID <b>OldVariableID</b> in die Variable mit der ID <b>NewVariableID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-changevariableid/ | |
| * @returns bool <p><b>True</b> wenn erfolgreich, sonst <b>False</b></p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $OldVariableID <p>ID der zu migrierenden Variable</p> | |
| * @param int $NewVariableID <p>ID der neuen Variable</p> | |
| */ | |
| function AC_ChangeVariableID(int $InstanceID, int $OldVariableID, int $NewVariableID) { | |
| } | |
| /** | |
| * löscht in einem bestimmten Zeitraum alle Datensätze einer geloggten Variable | |
| * | |
| * <p>Diese Funktion löscht alle geloggten Datensätze der Variable mit der ID <b>VariablenID</b> im Zeitraum von <b>Startzeit</b> bis inklusive <b>Endzeit</b>. Sollte Die Startzeit als auch die Endzeit = 0 sein, wird zusätzlich das Logging der Variable deaktiviert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-deletevariabledata/ | |
| * @returns int <p>gibt die Anzahl der gelöschten Datensätze zurück</p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der Variable in der die Datensätze gelöscht werden sollen</p> | |
| * @param int $StartTime <p>Datum/Zeit als Unix Zeitstempel (0 = von Anfang an)</p> | |
| * @param int $EndTime <p>Datum/Zeit als Unix Zeitstempel (0 = bis jetzt)</p> | |
| */ | |
| function AC_DeleteVariableData(int $InstanceID, int $VariableID, int $StartTime, int $EndTime) { | |
| } | |
| /** | |
| * AC_FetchChartData | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $ObjectID | |
| * @param int $StartTime | |
| * @param int $TimeSpan | |
| * enum[0=tsHour, 1=tsDay, 2=tsWeek, 3=tsMonth, 4=tsYear, 5=tsDecade] | |
| * @param int $Density | |
| * enum[0=gdNormal, 1=gdHD, 2=gdRaw] | |
| */ | |
| function AC_FetchChartData(int $InstanceID, int $ObjectID, int $StartTime, int $TimeSpan, int $Density) { | |
| } | |
| /** | |
| * AC_FetchChartDataEx | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $ObjectID | |
| * @param int $StartTime | |
| * @param int $TimeSpan | |
| * enum[0=tsHour, 1=tsDay, 2=tsWeek, 3=tsMonth, 4=tsYear, 5=tsDecade] | |
| * @param int $Density | |
| * enum[0=gdNormal, 1=gdHD, 2=gdRaw] | |
| * @param array $Visibility | |
| */ | |
| function AC_FetchChartDataEx(int $InstanceID, int $ObjectID, int $StartTime, int $TimeSpan, int $Density, array $Visibility) { | |
| } | |
| /** | |
| * holt aggregierte Daten aus dem Archiv | |
| * | |
| * <p>Dieser Befehlt gibt die aggregierten Daten zurück, die über das Archiv für eine Variable mit der <b>VariablenID</b> mitprotokolliert und berechnet wurden. Dabei können die <b>Start-</b> und <b>Endzeit</b> als Parameter angegeben werden. Der Parameter <b>Limit</b> limitiert die maximale Anzahl der zurückgegebenen Datensätze, wobei das Limit von 10000 Datensätzen pro Abfrage nie überschritten werden kann. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-getaggregatedvalues/ | |
| * @returns array <p>Ein Array mit folgenden <b>key => value</b> Paaren. </p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der abzufragenden Variablen</p> | |
| * @param int $AggregationSpan <li>0Stündliche Aggregation <br> (00:00 - 59:59)</li><li>1Tägliche Aggregation <br> (00:00:00 - 23:59:59)</li><li>2Wöchentliche Aggregation <br> (Montag 00:00:00 - Sonntag 23:59:59)</li><li>3Monatliche Aggregation <br> (Erster Monatstag 00:00:00 - Letzter Monatstag 23:59:59)</li><li>4Jährliche Aggregation <br> (01.01. 00:00:00 - 31.12. 23:59:59)</li><li>55-Minütige Aggregation (Aus Rohdaten berechnet)</li><li>61-Minütige Aggregation (Aus Rohdaten berechnet)</li> | |
| * enum[0=agHour, 1=agDay, 2=agWeek, 3=agMonth, 4=agYear, 5=ag5Minutes, 6=ag1Minute, 7=agChanges] | |
| * @param int $StartTime <p>Datum/Zeit als Unix Zeitstempel (0 = von Anfang an)</p> | |
| * @param int $EndTime <p>Datum/Zeit als Unix Zeitstempel (0 = bis jetzt)</p> | |
| * @param int $Limit <p>Maximale Anzahl an Datensätzen. (0 = Kein Limit, 10000 ist das harte Limit, welches immer greift)</p> | |
| */ | |
| function AC_GetAggregatedValues(int $InstanceID, int $VariableID, int $AggregationSpan, int $StartTime, int $EndTime, int $Limit) { | |
| } | |
| /** | |
| * gibt den Aggregationstyp einer Variable wieder | |
| * | |
| * <p>Diese Funktion fragt den Aggregationstyp der Variable mit der ID <b>VariablenID</b> ab und gibt diesen als Integer zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-getaggregationtype/ | |
| * @returns int <p>Ein Integer der den Typ der Aggregation wiedergibt. </p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der abzufragenden Variablen</p> | |
| */ | |
| function AC_GetAggregationType(int $InstanceID, int $VariableID) { | |
| } | |
| /** | |
| * gibt ein Array aller geloggten Variablen zurück | |
| * | |
| * <p>Ab Version 4.0 wird der angegebene Parameter <b>DatenbankAbfrage</b> nicht mehr genutzt. Für Abwärtskompatibilität muss dieser aber mit angegeben werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-getaggregationvariables/ | |
| * @returns array <p>Ein Array mit folgenden <b>key => value</b> Paaren. </p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param bool $CalculateStatistics <p>True, wenn zusätzliche Informationen angezeigt werden sollen, sonst False (ab Version 4.0 unwichtig, Angabe aber nötig)</p> | |
| */ | |
| function AC_GetAggregationVariables(int $InstanceID, bool $CalculateStatistics) { | |
| } | |
| /** | |
| * AC_GetCompaction | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $VariableID | |
| */ | |
| function AC_GetCompaction(int $InstanceID, int $VariableID) { | |
| } | |
| /** | |
| * holt den Status ob Nullen und negative Werte ignoriert werden | |
| * | |
| * <p>Diese Funktion fragt ab, ob die Variable mit der ID <b>VariablenID</b> im Archiv Control mit der ID <b>InstanzID</b> Nullen und negative Werte ignoriert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-getcounterignorezeros/ | |
| * @returns bool <p>True wenn Ignorieren von Nullen und negative Werte für die Variable aktiv ist, sonst False</p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der abzufragenden Variable</p> | |
| */ | |
| function AC_GetCounterIgnoreZeros(int $InstanceID, int $VariableID) { | |
| } | |
| /** | |
| * fragt ab ob eine Variable visualisiert wird | |
| * | |
| * <p>Diese Funktion fragt ab, ob die Variable mit der ID <b>VariablenID</b> in der Visualisierung angezeigt wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-getgraphstatus/ | |
| * @returns bool <p><b>True</b> wenn die Visualisierung der Variable aktiv ist, sonst <b>False</b></p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der abzufragenden Variablen</p> | |
| */ | |
| function AC_GetGraphStatus(int $InstanceID, int $VariableID) { | |
| } | |
| /** | |
| * holt Rohdaten aus dem Archiv Control | |
| * | |
| * <p>Dieser Befehlt gibt die Rohdaten zurück, die über das Archiv Control für eine Variable mit der <b>VariablenID</b> mitprotokolliert wurden. Dabei können die <b>Start-</b> und <b>Endzeit</b> als Parameter angegeben werden. Der Parameter <b>Limit</b> limitiert die maximale Anzahl der zurückgegebenen Datensätze, wobei das Limit von 10000 Datensätzen pro Abfrage nie überschritten werden kann.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-getloggedvalues/ | |
| * @returns array <p>Ein Array mit folgenden <b>key => value</b> Paaren. </p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der abzufragenden Variablen</p> | |
| * @param int $StartTime <p>Datum/Zeit als Unix Zeitstempel. (0 = von Anfang an)</p> | |
| * @param int $EndTime <p>Datum/Zeit als Unix Zeitstempel. (0 = bis jetzt)</p> | |
| * @param int $Limit <p>Maximale Anzahl an Datensätzen. (0 = Kein Limit, 10000 ist das harte Limit, welches immer greift)</p> | |
| */ | |
| function AC_GetLoggedValues(int $InstanceID, int $VariableID, int $StartTime, int $EndTime, int $Limit) { | |
| } | |
| /** | |
| * fragt ab ob eine Variable geloggt wird | |
| * | |
| * <p>Diese Funktion fragt ab, ob die Variable mit der ID <b>VariablenID</b> geloggt wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-getloggingstatus/ | |
| * @returns bool <p><b>True</b> wenn Logging für die Variable aktiv ist, sonst <b>False</b></p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der abzufragenden Variablen</p> | |
| */ | |
| function AC_GetLoggingStatus(int $InstanceID, int $VariableID) { | |
| } | |
| /** | |
| * startet die Reaggregation einer Variable | |
| * | |
| * <p>Diese Funktion startet die Reaggregation der Variable mit der ID <b>VariablenID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-reaggregatevariable/ | |
| * @returns bool <p><b>True</b> wenn erfolgreich, sonst <b>False</b></p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der zu reaggregierenden Variable</p> | |
| */ | |
| function AC_ReAggregateVariable(int $InstanceID, int $VariableID) { | |
| } | |
| /** | |
| * AC_RenderChart | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param int $ObjectID | |
| * @param int $StartTime | |
| * @param int $TimeSpan | |
| * enum[0=tsHour, 1=tsDay, 2=tsWeek, 3=tsMonth, 4=tsYear, 5=tsDecade] | |
| * @param int $Density | |
| * enum[0=gdNormal, 1=gdHD, 2=gdRaw] | |
| * @param bool $IsExtrema | |
| * @param bool $IsDyn | |
| * @param int $Width | |
| * @param int $Height | |
| */ | |
| function AC_RenderChart(int $InstanceID, int $ObjectID, int $StartTime, int $TimeSpan, int $Density, bool $IsExtrema, bool $IsDyn, int $Width, int $Height) { | |
| } | |
| /** | |
| * AC_RenderChartEx | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param int $ObjectID | |
| * @param int $StartTime | |
| * @param int $TimeSpan | |
| * enum[0=tsHour, 1=tsDay, 2=tsWeek, 3=tsMonth, 4=tsYear, 5=tsDecade] | |
| * @param int $Density | |
| * enum[0=gdNormal, 1=gdHD, 2=gdRaw] | |
| * @param bool $IsExtrema | |
| * @param bool $IsDyn | |
| * @param int $Width | |
| * @param int $Height | |
| * @param array $Visibility | |
| */ | |
| function AC_RenderChartEx(int $InstanceID, int $ObjectID, int $StartTime, int $TimeSpan, int $Density, bool $IsExtrema, bool $IsDyn, int $Width, int $Height, array $Visibility) { | |
| } | |
| /** | |
| * setzt den Aggregationstyp einer Variable | |
| * | |
| * <p>Diese Funktion setzt den Aggregationstyp <b>Aggregationstyp</b> bei der Variable mit der ID <b>VariablenID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-setaggregationtype/ | |
| * @returns bool <p><b>True</b> wenn erfolgreich, sonst <b>False</b></p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der Variable bei der der Aggregationstyp gesetzt werden soll</p> | |
| * @param int $AggregationType <li>0Standard</li><li>1Counter</li> | |
| * enum[0=asGauge, 1=asCounter] | |
| */ | |
| function AC_SetAggregationType(int $InstanceID, int $VariableID, int $AggregationType) { | |
| } | |
| /** | |
| * AC_SetCompaction | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $VariableID | |
| * @param int $MonthOffset | |
| * @param int $CompactionType | |
| * enum[0=ctNoCompaction, 1=ct1Minute, 2=ct5Minutes, 3=ctHour, 4=ctDay, 5=ctWeek, 6=ctMonth, 7=ctYear, 8=ctDelete] | |
| */ | |
| function AC_SetCompaction(int $InstanceID, int $VariableID, int $MonthOffset, int $CompactionType) { | |
| } | |
| /** | |
| * setzt den Status ob Nullen und negative Werte ignoriert werden | |
| * | |
| * <p>Diese Funktion ändert die Eigenschaft zum Ignorieren von Nullen und negative Werte der Variable mit der ID <b>VariablenID</b> im Archiv Control mit der ID <b>InstanzID</b> auf Aktiv.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-setcounterignorezeros/ | |
| * @returns bool | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der abzufragenden Variable</p> | |
| * @param bool $IgnoreZeros <p>True, wenn Nullen und negative Werte ignoriert werden sollen, sonst False.</p> | |
| */ | |
| function AC_SetCounterIgnoreZeros(int $InstanceID, int $VariableID, bool $IgnoreZeros) { | |
| } | |
| /** | |
| * setzt die Eigenschaft zur Visualisierung einer Variable | |
| * | |
| * <p>Diese Funktion ändert die Eigenschaft zur Visualisierung der Variable mit der ID <b>VariablenID</b> auf <b>Aktiv</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-setgraphstatus/ | |
| * @returns bool <p><b>True</b> wenn erfolgreich, sonst <b>False</b></p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der abzufragenden Variablen</p> | |
| * @param bool $Active <p>True, wenn das Anzeigen der Variable in der Visualisierung aktiviert werden soll, sonst False.</p> | |
| */ | |
| function AC_SetGraphStatus(int $InstanceID, int $VariableID, bool $Active) { | |
| } | |
| /** | |
| * setzt die Eigenschaft zum Loggen einer Variable | |
| * | |
| * <p>Diese Funktion ändert die Eigenschaft zum Loggen der Variable mit der ID <b>VariablenID</b> auf <b>Aktiv</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/archive-control/ac-setloggingstatus/ | |
| * @returns bool <p><b>True</b> wenn erfolgreich, sonst <b>False</b></p> | |
| * @param int $InstanceID <p>ID zum Archiv</p> | |
| * @param int $VariableID <p>ID der abzufragenden Variablen</p> | |
| * @param bool $Active <p>True, wenn das Logging der Variable aktiviert werden soll, sonst False.</p> | |
| */ | |
| function AC_SetLoggingStatus(int $InstanceID, int $VariableID, bool $Active) { | |
| } | |
| /** | |
| * AFT_ArrayInput | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param array $data | |
| */ | |
| function AFT_ArrayInput(int $InstanceID, array $data) { | |
| } | |
| /** | |
| * AFT_ArrayResult | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function AFT_ArrayResult(int $InstanceID) { | |
| } | |
| /** | |
| * ALL_ReadConfiguration | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ALL_ReadConfiguration(int $InstanceID) { | |
| } | |
| /** | |
| * setzt den Analogwert eines Kanals | |
| * | |
| * <p>Setzt den Wert des Kanals mit der KanalID <b>Kanal</b> des Geräts mit der ID <b>InstanzID</b> auf den Wert <b>Wert</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/allnet/all-setanalog/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $ChannelID <p>ID des zu schaltenden Kanals</p> | |
| * @param float $Value <p>Wert auf den der Kanal gesetzt werden soll</p> | |
| */ | |
| function ALL_SetAnalog(int $InstanceID, int $ChannelID, float $Value) { | |
| } | |
| /** | |
| * schaltet ein ALLNET Aktor ein/aus | |
| * | |
| * <p>Schaltet den Aktor mit der Geräte ID <b>InstanzID</b> auf dem Kanal <b>KanalID</b> auf den Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/allnet/all-switchactor/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $ChannelID <p>ID des zu schaltenden Kanals</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function ALL_SwitchActor(int $InstanceID, int $ChannelID, bool $DeviceOn) { | |
| } | |
| /** | |
| * schaltet ein ALLNET Gerät ein/aus | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/allnet/all-switchmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function ALL_SwitchMode(int $InstanceID, bool $DeviceOn) { | |
| } | |
| /** | |
| * sende eine Aktualisierungsanfrage an das ALLnet Gerät | |
| * | |
| * <p>Führt eine Aktualisierungsanfrage für das Gerät mit der ID <b>InstanzID</b> aus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/allnet/all-updatevalues/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function ALL_UpdateValues(int $InstanceID) { | |
| } | |
| /** | |
| * ALMANAC_DateInfo | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param int $ts | |
| */ | |
| function ALMANAC_DateInfo(int $InstanceID, int $ts) { | |
| } | |
| /** | |
| * ALMANAC_Notify | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param string $days | |
| */ | |
| function ALMANAC_Notify(int $InstanceID, string $days) { | |
| } | |
| /** | |
| * ALMANAC_Update | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function ALMANAC_Update(int $InstanceID) { | |
| } | |
| /** | |
| * ATSE_BumpAndShow | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function ATSE_BumpAndShow(int $InstanceID) { | |
| } | |
| /** | |
| * BAC_RelinquishPresetValue | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function BAC_RelinquishPresetValue(int $InstanceID) { | |
| } | |
| /** | |
| * BAC_RequestDeviceList | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function BAC_RequestDeviceList(int $InstanceID) { | |
| } | |
| /** | |
| * BAC_RequestStatus | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function BAC_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * BAC_RequestStatusAll | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function BAC_RequestStatusAll(int $InstanceID) { | |
| } | |
| /** | |
| * BAC_WritePresetValue | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param mixed $Value | |
| */ | |
| function BAC_WritePresetValue(int $InstanceID, mixed $Value) { | |
| } | |
| /** | |
| * BDT_ClearDevices | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function BDT_ClearDevices(int $InstanceID) { | |
| } | |
| /** | |
| * BDT_LoadDevices | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function BDT_LoadDevices(int $InstanceID) { | |
| } | |
| /** | |
| * BETT_FillBuffers | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function BETT_FillBuffers(int $InstanceID) { | |
| } | |
| /** | |
| * CC_ActivateServer | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function CC_ActivateServer(int $InstanceID) { | |
| } | |
| /** | |
| * CC_GetConnectURL | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| */ | |
| function CC_GetConnectURL(int $InstanceID) { | |
| } | |
| /** | |
| * CC_GetGoogleAssistantLimitCount | |
| * | |
| * @returns int | |
| * @param int $InstanceID | |
| */ | |
| function CC_GetGoogleAssistantLimitCount(int $InstanceID) { | |
| } | |
| /** | |
| * CC_GetQRCodeSVG | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param int $WebFrontID | |
| */ | |
| function CC_GetQRCodeSVG(int $InstanceID, int $WebFrontID) { | |
| } | |
| /** | |
| * CC_GetRequestLimitCount | |
| * | |
| * @returns int | |
| * @param int $InstanceID | |
| */ | |
| function CC_GetRequestLimitCount(int $InstanceID) { | |
| } | |
| /** | |
| * CC_GetTrafficCounter | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function CC_GetTrafficCounter(int $InstanceID) { | |
| } | |
| /** | |
| * CC_GetTrafficStatistics | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function CC_GetTrafficStatistics(int $InstanceID) { | |
| } | |
| /** | |
| * CC_MakeRequest | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param string $Endpoint | |
| * @param string $RequestData | |
| */ | |
| function CC_MakeRequest(int $InstanceID, string $Endpoint, string $RequestData) { | |
| } | |
| /** | |
| * CC_SendGoogleAssistantStateReport | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $States | |
| */ | |
| function CC_SendGoogleAssistantStateReport(int $InstanceID, string $States) { | |
| } | |
| /** | |
| * CGEM24_RequestRead | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function CGEM24_RequestRead(int $InstanceID) { | |
| } | |
| /** | |
| * CIT_UpdateVisible | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $Visible | |
| */ | |
| function CIT_UpdateVisible(int $InstanceID, mixed $Visible) { | |
| } | |
| /** | |
| * CMI_UpdateValues | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function CMI_UpdateValues(int $InstanceID) { | |
| } | |
| /** | |
| * sendet einen String auf den I/O | |
| * | |
| * <p>Sendet den String <b>Text</b> auf dem Client Socket mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/clientsocket/csck-sendtext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden Client Sockets</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| */ | |
| function CSCK_SendText(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * CSCK_UpdateFormUseSSL | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $UseSSL | |
| */ | |
| function CSCK_UpdateFormUseSSL(int $InstanceID, bool $UseSSL) { | |
| } | |
| /** | |
| * löscht den Buffer der Cutter Instanz | |
| * | |
| * <p>Diese Funktion löscht den Zwischenspeicher (Buffer) der Cutter Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/cutter/cutter-clearbuffer/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID zum Cutter</p> | |
| */ | |
| function Cutter_ClearBuffer(int $InstanceID) { | |
| } | |
| /** | |
| * DLLT_UpdateLabel | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $Text | |
| */ | |
| function DLLT_UpdateLabel(int $InstanceID, mixed $Text) { | |
| } | |
| /** | |
| * DLLT_UpdateLink | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $Link | |
| */ | |
| function DLLT_UpdateLink(int $InstanceID, mixed $Link) { | |
| } | |
| /** | |
| * dimmt einen Kanal auf einen bestimmten Wert in einer bestimmten Zeit | |
| * | |
| * <p>Dimmt den <b>Kanal</b> des Geräts mit der ID <b>InstanzID</b> auf <b>Wert</b> mit einer bestimmten <b>Überblendzeit</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dmx-artnet/dmx-fadechannel/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Channel <p>0 = alle Instanz-Kanäle, 1 – 512 je nach Konfiguration</p> | |
| * @param int $Value <p>0-255 / 0-65535 (8/16 bit)</p> | |
| * @param float $FadingSeconds <p>Zeit in Sekunden</p> | |
| */ | |
| function DMX_FadeChannel(int $InstanceID, int $Channel, int $Value, float $FadingSeconds) { | |
| } | |
| /** | |
| * dimmt einen Kanal nach einer Verzögerung auf einen bestimmten Wert | |
| * | |
| * <p>Dimmt den Kanal des Geräts mit der ID InstanzID auf Wert mit einer bestimmten Überblendzeit. Es kann eine Verzögerungszeit angegeben werden, nach der der Dimmvorgang gestartet wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dmx-artnet/dmx-fadechanneldelayed/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Channel <p>0 = alle Instanz-Kanäle, 1 – 512 je nach Konfiguration</p> | |
| * @param int $Value <p>0-255 / 0-65535 (8/16 bit)</p> | |
| * @param float $FadingSeconds <p>Zeit in Sekunden</p> | |
| * @param float $DelayedSeconds <p>Zeit in Sekunden</p> | |
| */ | |
| function DMX_FadeChannelDelayed(int $InstanceID, int $Channel, int $Value, float $FadingSeconds, float $DelayedSeconds) { | |
| } | |
| /** | |
| * dimmt den RGB-Kanal mit einer Überblendzeit | |
| * | |
| * <p>Dimmt den Rot-, Grün- und Blaukanal der ID <b>InstanzID</b> mit einer bestimmten <b>Überblendzeit</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dmx-artnet/dmx-fadergb/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $R <p>Helligkeitswert 0 (aus) bis 255/65535 (8/16 bit) (an, maximale Helligkeit)</p> | |
| * @param int $G <p>Helligkeitswert 0 (aus) bis 255/65535 (8/16 bit) (an, maximale Helligkeit)</p> | |
| * @param int $B <p>Helligkeitswert 0 (aus) bis 255/65535 (8/16 bit) (an, maximale Helligkeit)</p> | |
| * @param float $FadingSeconds <p>Zeit in Sekunden</p> | |
| */ | |
| function DMX_FadeRGB(int $InstanceID, int $R, int $G, int $B, float $FadingSeconds) { | |
| } | |
| /** | |
| * dimmt verzögert den RGB-Kanal mit einer Überblendzeit | |
| * | |
| * <p>Dimmt den Rot-, Grün- und Blaukanal der ID <b>InstanzID</b> mit einer bestimmten <b>Überblendzeit</b>. Es kann eine Verzögerungszeit angegeben werden, nach der der Dimmvorgang gestartet wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dmx-artnet/dmx-fadergbdelayed/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $R <p>Helligkeitswert 0 (aus) bis 255/65535 (8/16 bit) (an, maximale Helligkeit)</p> | |
| * @param int $G <p>Helligkeitswert 0 (aus) bis 255/65535 (8/16 bit) (an, maximale Helligkeit)</p> | |
| * @param int $B <p>Helligkeitswert 0 (aus) bis 255/65535 (8/16 bit) (an, maximale Helligkeit)</p> | |
| * @param float $FadingSeconds <p>Zeit in Sekunden</p> | |
| * @param float $DelayedSeconds <p>Zeit in Sekunden</p> | |
| */ | |
| function DMX_FadeRGBDelayed(int $InstanceID, int $R, int $G, int $B, float $FadingSeconds, float $DelayedSeconds) { | |
| } | |
| /** | |
| * Fragt die Informationen einer DMX Instanz ab | |
| * | |
| * <p>Fragt die Informationen der DMX Instanz mit der ID <b>InstanzID</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dmx-artnet/dmx-requestinfo/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der DMX Splitter Instanz</p> | |
| */ | |
| function DMX_RequestInfo(int $InstanceID) { | |
| } | |
| /** | |
| * setzt ein DMX Interface zurück | |
| * | |
| * <p>Setzt das DMX Splitter Interface mit der ID <b>InstanzID</b> zurück. Es empfiehlt sich, bei Problemen, ein Skript mit diesem Befehl zu erstellen und als Start-Skript zu deklarieren.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dmx-artnet/dmx-resetinterface/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der DMX Splitter Instanz</p> | |
| */ | |
| function DMX_ResetInterface(int $InstanceID) { | |
| } | |
| /** | |
| * setzt alle 512 Kanäle auf 0 oder den alten Wert | |
| * | |
| * <p>Setzt alle Kanäle des DMX Interfaces auf Wert <b>Status</b>. Die ID <b>InstanzID</b> ist dabei die InstanzID der Splitter-Instanz. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dmx-artnet/dmx-setblackout/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der DMX Splitter Instanz</p> | |
| * @param bool $BlackoutOn <p><b>TRUE</b> für alter Wert, <b>FALSE</b> für 0</p> | |
| */ | |
| function DMX_SetBlackOut(int $InstanceID, bool $BlackoutOn) { | |
| } | |
| /** | |
| * setzt einen Kanal auf einen bestimmten Wert | |
| * | |
| * <p>Schaltet den Kanal vom Gerät mit der ID <b>InstanzID</b> auf Wert <b>Wert</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dmx-artnet/dmx-setchannel/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Channel <p>0 = alle Instanz-Kanäle, 1 – 512 je nach Konfiguration</p> | |
| * @param int $Value <p>0-255 / 0-65535 (8/16 bit)</p> | |
| */ | |
| function DMX_SetChannel(int $InstanceID, int $Channel, int $Value) { | |
| } | |
| /** | |
| * setzt den RGB Kanal auf einen bestimmten Wert | |
| * | |
| * <p>Sendet den Rot-, Grün- und Blaukanal der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dmx-artnet/dmx-setrgb/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $R <p>Helligkeitswert 0 (aus) bis 255/65535 (8/16 bit) (an, maximale Helligkeit)</p> | |
| * @param int $G <p>Helligkeitswert 0 (aus) bis 255/65535 (8/16 bit) (an, maximale Helligkeit)</p> | |
| * @param int $B <p>Helligkeitswert 0 (aus) bis 255/65535 (8/16 bit) (an, maximale Helligkeit)</p> | |
| */ | |
| function DMX_SetRGB(int $InstanceID, int $R, int $G, int $B) { | |
| } | |
| /** | |
| * ruft eine Szene auf | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Szene</b>.<br>Weitere Informationen zu den Serverszenen</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/digitalstrom/ds-callscene/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $SceneID <p>Szenen von 0 bis 127</p> | |
| */ | |
| function DS_CallScene(int $InstanceID, int $SceneID) { | |
| } | |
| /** | |
| * dimmt eine digitalSTROM Klemme auf einen bestimmten Wert | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Intensität</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/digitalstrom/ds-dimset/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Intensity <p>Wert von 0-255</p> | |
| */ | |
| function DS_DimSet(int $InstanceID, int $Intensity) { | |
| } | |
| /** | |
| * DS_GetKnownDevices | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function DS_GetKnownDevices(int $InstanceID) { | |
| } | |
| /** | |
| * sendet einen digitalSTROM Befehl direkt an den dSS | |
| * | |
| * <p>Sendet an das Gerät mit der ID <b>InstanzID</b> die Anfrage <b>Request</b> mit dem Parameter <b>Data</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/digitalstrom/ds-makerequest/ | |
| * @returns string <p>JSON kodierter String</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Request <p>Anfrage welche aufgerufen werden soll</p> | |
| * @param string $Data <p>Parameter für Anfrage</p> | |
| */ | |
| function DS_MakeRequest(int $InstanceID, string $Request, string $Data) { | |
| } | |
| /** | |
| * DS_RequestBinaryInputs | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function DS_RequestBinaryInputs(int $InstanceID) { | |
| } | |
| /** | |
| * DS_RequestSensorInputs | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function DS_RequestSensorInputs(int $InstanceID) { | |
| } | |
| /** | |
| * ruft den Status ab | |
| * | |
| * <p>Fragt den Status für das Gerät mit der ID <b>InstanzID</b> ab. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/digitalstrom/ds-requeststatus/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| */ | |
| function DS_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * DS_RequestToken | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Username | |
| * @param string $Password | |
| */ | |
| function DS_RequestToken(int $InstanceID, string $Username, string $Password) { | |
| } | |
| /** | |
| * DS_SaveScene | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $SceneID | |
| */ | |
| function DS_SaveScene(int $InstanceID, int $SceneID) { | |
| } | |
| /** | |
| * bewegt den Rolladen bis zu einer gewünschten Position/Stop | |
| * | |
| * <p>Bewegt den Rolladen/Markise/Jalousie mit der ID <b>InstanzID</b> auf die Position <b>Position</b>, bis DS_ShutterStop ausgeführt wird oder die Zielposition erreicht wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/digitalstrom/ds-shuttermove/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Position <p>Position von 0-255</p> | |
| */ | |
| function DS_ShutterMove(int $InstanceID, int $Position) { | |
| } | |
| /** | |
| * bewegt den Rolladen nach unten bis zur Endposition/Stop | |
| * | |
| * <p>Bewegt den Rolladen/Markise/Jalousie mit der ID <b>InstanzID</b> nach unten, bis DS_ShutterStop ausgeführt wird oder die Endposition erreicht wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/digitalstrom/ds-shuttermovedown/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function DS_ShutterMoveDown(int $InstanceID) { | |
| } | |
| /** | |
| * bewegt den Rolladen nach oben bis zur Endposition/Stop | |
| * | |
| * <p>Bewegt den Rolladen/Markise/Jalousie mit der ID <b>InstanzID</b> nach oben, bis DS_ShutterStop ausgeführt wird oder die Endposition erreicht wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/digitalstrom/ds-shuttermoveup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function DS_ShutterMoveUp(int $InstanceID) { | |
| } | |
| /** | |
| * DS_ShutterStepDown | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function DS_ShutterStepDown(int $InstanceID) { | |
| } | |
| /** | |
| * DS_ShutterStepUp | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function DS_ShutterStepUp(int $InstanceID) { | |
| } | |
| /** | |
| * stoppt einen Bewegungsvorgang | |
| * | |
| * <p>Stoppt eine aktuelle Bewegung des/der Rolladens/Markise/Jalousie.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/digitalstrom/ds-shutterstop/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function DS_ShutterStop(int $InstanceID) { | |
| } | |
| /** | |
| * schaltet eine digitalSTROM Klemme an/aus | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Status</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/digitalstrom/ds-switchmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function DS_SwitchMode(int $InstanceID, bool $DeviceOn) { | |
| } | |
| /** | |
| * DS_UndoScene | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $SceneID | |
| */ | |
| function DS_UndoScene(int $InstanceID, int $SceneID) { | |
| } | |
| /** | |
| * DT_ArrayInput | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param array $data | |
| */ | |
| function DT_ArrayInput(int $InstanceID, array $data) { | |
| } | |
| /** | |
| * DT_MySendDebug | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function DT_MySendDebug(int $InstanceID) { | |
| } | |
| /** | |
| * DT_Reload | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function DT_Reload(int $InstanceID) { | |
| } | |
| /** | |
| * DT_SetInvalid | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function DT_SetInvalid(int $InstanceID) { | |
| } | |
| /** | |
| * DT_UpdateParameter | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $Field | |
| * @param mixed $Parameter | |
| * @param mixed $Value | |
| */ | |
| function DT_UpdateParameter(int $InstanceID, mixed $Field, mixed $Parameter, mixed $Value) { | |
| } | |
| /** | |
| * DWT_Send | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function DWT_Send(int $InstanceID) { | |
| } | |
| /** | |
| * DWT_Wait | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function DWT_Wait(int $InstanceID) { | |
| } | |
| /** | |
| * EDDT_Test | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function EDDT_Test(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * EIB_BladePosition | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Position | |
| */ | |
| function EIB_BladePosition(int $InstanceID, int $Position) { | |
| } | |
| /** | |
| * Sendet einen einzelnen Buchstaben | |
| * | |
| * <p>Sendet einen einzelnen Buchstaben <b>Buchstabe</b> an das Gerät mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-char/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Value <p>Einzelner Buchstabe</p> | |
| */ | |
| function EIB_Char(int $InstanceID, string $Value) { | |
| } | |
| /** | |
| * EIB_Counter16bit | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function EIB_Counter16bit(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * EIB_Counter32bit | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function EIB_Counter32bit(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * EIB_Counter8bit | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function EIB_Counter8bit(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * sendet den Datumswert | |
| * | |
| * <p>Sendet den Datumswert <b>Datum</b> an das Gerät mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-date/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Value <p>Standard = yyyymmdd</p> | |
| */ | |
| function EIB_Date(int $InstanceID, string $Value) { | |
| } | |
| /** | |
| * sendet eine Dimmwertverstellung | |
| * | |
| * <p>Sendet eine Dimmwertverstellung um <b>Wert</b> an das Gerät mit der ID <b>InstanzID</b>. Je nach Konfiguration kann 0..15 (Standard) oder -7..7 (Enhanced) gesendet werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-dimcontrol/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>Dimmwertverstellung zwischen 0..15 oder -7..7</p> | |
| */ | |
| function EIB_DimControl(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * sendet einen Dimmwert als Zahl oder Prozent | |
| * | |
| * <p>Sendet den Dimmwert <b>Wert</b> an das Gerät mit der ID <b>InstanzID</b>. Je nach Konfiguration kann 0..255 (Standard) oder 0..100 (Percent) als Wert Parameter übergeben werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-dimvalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>Wert 0..255, 0..100%</p> | |
| */ | |
| function EIB_DimValue(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * sendet einen Positionswert als Zahl oder Prozent | |
| * | |
| * <p>Sendet den Positionswert <b>Wert</b> an das Gerät mit der ID <b>InstanzID</b>. Je nach Konfiguration kann 0..255 (Standard) oder 0..100 (Percent) als Wert Parameter übergeben werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-drivebladevalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>Wert 0..255, 0..100%</p> | |
| */ | |
| function EIB_DriveBladeValue(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * bewegt ein Gerät Hoch oder Runter | |
| * | |
| * <p>Bewegt das Gerät mit ID <b>InstanzID</b> in eine bestimmt <b>Richtung</b>. Je nach Konfiguration kann die Bewegungsrichtung invertiert werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-drivemove/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $Value <p>Standart</p> | |
| */ | |
| function EIB_DriveMove(int $InstanceID, bool $Value) { | |
| } | |
| /** | |
| * sendet einen Positionswert als Zahl oder Prozent | |
| * | |
| * <p>Sendet den Positionswert <b>Wert</b> an das Gerät mit der ID <b>InstanzID</b>. Je nach Konfiguration kann 0..255 (Standard) oder 0..100 (Percent) als Wert Parameter übergeben werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-driveshuttervalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>Wert 0..255, 0..100%</p> | |
| */ | |
| function EIB_DriveShutterValue(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * bewegt ein Gerät schrittweise | |
| * | |
| * <p>Bewegt das Gerät <em>schrittweise</em> mit ID <b>InstanzID</b> in eine bestimmt <b>Richtung</b> in Bewegung. Je nach Konfiguration kann die Bewegungsrichtung invertiert werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-drivestep/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $Value <p>Standard</p> | |
| */ | |
| function EIB_DriveStep(int $InstanceID, bool $Value) { | |
| } | |
| /** | |
| * sendet einen Floatwert | |
| * | |
| * <p>Sendet den Wert <b>Wert</b> an das Gerät mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-floatvalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Value <p>Fließkommawert</p> | |
| */ | |
| function EIB_FloatValue(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * EIB_GetDecryptedKeyring | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function EIB_GetDecryptedKeyring(int $InstanceID) { | |
| } | |
| /** | |
| * bewegt einen Rolladen | |
| * | |
| * <p>Bewegt den Rolladen mit der <b>InstanzID</b> in die gewünschte <b>Richtung</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-move/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der KNX Shutter Instanz</p> | |
| * @param int $Command <p>0 = Hoch, 1 = Schritt (Hoch), 2 = Stop, 3 = Schritt (Runter), 4 = Runter</p> | |
| * enum[0=emcOpen, 1=emcStepOpen, 2=emcStop, 3=emcStepClose, 4=emcClose] | |
| */ | |
| function EIB_Move(int $InstanceID, int $Command) { | |
| } | |
| /** | |
| * bewegt einen Rolladen auf eine Position | |
| * | |
| * <p>Bewegt den Rolladen mit der <b>InstanzID</b> auf die gewünschte <b>Position</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-position/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der KNX Shutter Instanz</p> | |
| * @param int $Position <p>0-100%</p> | |
| */ | |
| function EIB_Position(int $InstanceID, int $Position) { | |
| } | |
| /** | |
| * setzt einen Gerätezustand | |
| * | |
| * <p>Setzt das Gerät mit ID <b>InstanzID</b> auf einen bestimmten <b>Zustand</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-prioritycontrol/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>Standard</p> | |
| */ | |
| function EIB_PriorityControl(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt ein Gerät in eine bestimmte Richtung | |
| * | |
| * <p>Setzt das Gerät mit ID <b>InstanzID</b> auf eine bestimmte <b>Richtung</b>. Je nach Konfiguration kann die Richtung invertiert werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-priorityposition/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $Value <p>Standard</p> | |
| */ | |
| function EIB_PriorityPosition(int $InstanceID, bool $Value) { | |
| } | |
| /** | |
| * EIB_RequestInfo | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function EIB_RequestInfo(int $InstanceID) { | |
| } | |
| /** | |
| * schickt eine Leseanfrage für EIB-Instanzen auf den Bus | |
| * | |
| * <p>Schickt eine Lesenanfrage für Gerät mit der ID <b>InstanzID</b> auf den Bus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-requeststatus/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| */ | |
| function EIB_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * sendet einen Zahl-, Prozent- oder Gradwert. | |
| * | |
| * <p>Sendet den Wert <b>Wert</b> an das Gerät mit der ID <b>InstanzID</b>. Je nach Konfiguration kann 0..255 (Standard), 0..100 (Percent) oder 0..360 (Degree) als Wert Parameter übergeben werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-scale/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>Wert 0..255, 0..100, 0..360</p> | |
| */ | |
| function EIB_Scale(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * EIB_SetProgrammingMode | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $Enable | |
| */ | |
| function EIB_SetProgrammingMode(int $InstanceID, bool $Enable) { | |
| } | |
| /** | |
| * setzt einen RGB Stripe auf einen bestimmten Farbton | |
| * | |
| * <p>Setzt den RGB Stripe des Geräts mit der ID <b>InstanzID</b> auf den Rotwert <b>Rot</b>, den Grünwert <b>Grün</b> und den Blauwert <b>Blau</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-setrgb/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $R <p>0 .. 255 (0 = aus, 255 = hell)</p> | |
| * @param int $G <p>0 .. 255 (0 = aus, 255 = hell)</p> | |
| * @param int $B <p>0 .. 255 (0 = aus, 255 = hell)</p> | |
| */ | |
| function EIB_SetRGB(int $InstanceID, int $R, int $G, int $B) { | |
| } | |
| /** | |
| * setzt einen RGBW Stripe auf einen bestimmten Farbton | |
| * | |
| * <p>Setzt den RGBW Stripe des Geräts mit der ID <b>InstanzID</b> auf den Rotwert <b>Rot</b>, den Grünwert <b>Grün</b>, den Blauwert <b>Blau</b> und den Weißanteil auf <b>Weiss</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-setrgbw/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $R <p>0 .. 255 (0 = aus, 255 = hell)</p> | |
| * @param int $G <p>0 .. 255 (0 = aus, 255 = hell)</p> | |
| * @param int $B <p>0 .. 255 (0 = aus, 255 = hell)</p> | |
| * @param int $W <p>0 .. 255 (0 = aus, 255 = hell)</p> | |
| */ | |
| function EIB_SetRGBW(int $InstanceID, int $R, int $G, int $B, int $W) { | |
| } | |
| /** | |
| * sendet einen Text | |
| * | |
| * <p>Sendet einen Text <b>Zeichenkette</b> an das Gerät mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-str/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Value <p>Zu sendender Text (maximal 14 Zeichen)</p> | |
| */ | |
| function EIB_Str(int $InstanceID, string $Value) { | |
| } | |
| /** | |
| * schaltet ein Gerät Ein/Aus | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-switch/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $Value <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function EIB_Switch(int $InstanceID, bool $Value) { | |
| } | |
| /** | |
| * sendet einen Zeitwert | |
| * | |
| * <p>Sendet den Zeitwert <b>Zeit</b> an das Gerät mit der ID <b>InstanzID</b>. Der d Wert ist dabei zwischen 1 (Montag) und 7 (Sonntag).</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-time/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Value <p>Standard = dhhmmss; TimeOnly = hhmmss</p> | |
| */ | |
| function EIB_Time(int $InstanceID, string $Value) { | |
| } | |
| /** | |
| * EIB_UIUpdateGatewayMode | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $GatewayMode | |
| */ | |
| function EIB_UIUpdateGatewayMode(int $InstanceID, int $GatewayMode) { | |
| } | |
| /** | |
| * EIB_UpdateFormExportMode | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $ExportMode | |
| */ | |
| function EIB_UpdateFormExportMode(int $InstanceID, int $ExportMode) { | |
| } | |
| /** | |
| * sendet einen Floatwert | |
| * | |
| * <p>Sendet den Wert <b>Wert</b> an das Gerät mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/eib-value/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Value <p>-671088,63 .. 670760,96</p> | |
| */ | |
| function EIB_Value(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * ENO_ConfigureEnergyMeasurement | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $AutoReporting | |
| * @param int $ReportingDeltaWh | |
| * @param int $ReportingMinInterval | |
| * @param int $ReportingMaxInterval | |
| * @param bool $ResetCounter | |
| */ | |
| function ENO_ConfigureEnergyMeasurement(int $InstanceID, bool $AutoReporting, int $ReportingDeltaWh, int $ReportingMinInterval, int $ReportingMaxInterval, bool $ResetCounter) { | |
| } | |
| /** | |
| * ENO_ConfigurePowerMeasurement | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $AutoReporting | |
| * @param int $ReportingDeltaW | |
| * @param int $ReportingMinInterval | |
| * @param int $ReportingMaxInterval | |
| */ | |
| function ENO_ConfigurePowerMeasurement(int $InstanceID, bool $AutoReporting, int $ReportingDeltaW, int $ReportingMinInterval, int $ReportingMaxInterval) { | |
| } | |
| /** | |
| * ENO_DimColdWhite | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Intensity | |
| */ | |
| function ENO_DimColdWhite(int $InstanceID, int $Intensity) { | |
| } | |
| /** | |
| * ENO_DimColor | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Color | |
| */ | |
| function ENO_DimColor(int $InstanceID, int $Color) { | |
| } | |
| /** | |
| * dimmt ein EnOcean Gerät auf eine bestimmte Helligkeit | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> auf den Wert <b>Intensität</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-dimset/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param int $Intensity <p>1..100</p> | |
| */ | |
| function ENO_DimSet(int $InstanceID, int $Intensity) { | |
| } | |
| /** | |
| * ENO_DimWarmWhite | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Intensity | |
| */ | |
| function ENO_DimWarmWhite(int $InstanceID, int $Intensity) { | |
| } | |
| /** | |
| * ENO_DimWhite | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $White | |
| */ | |
| function ENO_DimWhite(int $InstanceID, int $White) { | |
| } | |
| /** | |
| * ENO_RequestStatus | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ENO_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * ENO_SendCST | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $value | |
| */ | |
| function ENO_SendCST(int $InstanceID, bool $value) { | |
| } | |
| /** | |
| * ENO_SendCTM | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $value | |
| */ | |
| function ENO_SendCTM(int $InstanceID, int $value) { | |
| } | |
| /** | |
| * ENO_SendCV | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $value | |
| */ | |
| function ENO_SendCV(int $InstanceID, float $value) { | |
| } | |
| /** | |
| * ENO_SendERH | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $value | |
| */ | |
| function ENO_SendERH(int $InstanceID, bool $value) { | |
| } | |
| /** | |
| * ENO_SendFANOR | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $value | |
| */ | |
| function ENO_SendFANOR(int $InstanceID, int $value) { | |
| } | |
| /** | |
| * ENO_SendFANOR_2 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $value | |
| */ | |
| function ENO_SendFANOR_2(int $InstanceID, bool $value) { | |
| } | |
| /** | |
| * ENO_SendLearn | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ENO_SendLearn(int $InstanceID) { | |
| } | |
| /** | |
| * ENO_SendLearnEx | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ENO_SendLearnEx(int $InstanceID) { | |
| } | |
| /** | |
| * ENO_SendRO | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $value | |
| */ | |
| function ENO_SendRO(int $InstanceID, int $value) { | |
| } | |
| /** | |
| * ENO_SendSPS | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $value | |
| */ | |
| function ENO_SendSPS(int $InstanceID, float $value) { | |
| } | |
| /** | |
| * setzt eine bestimmte Message aktiv | |
| * | |
| * <p>Setzt eine Message mit dem Wert <b>Message</b> auf der Instanz mit der ID <b>InstanzID</b> aktiv.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-setactivemessage/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param int $Message <p>0..8</p> | |
| */ | |
| function ENO_SetActiveMessage(int $InstanceID, int $Message) { | |
| } | |
| /** | |
| * ENO_SetButtonLock | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $Active | |
| */ | |
| function ENO_SetButtonLock(int $InstanceID, bool $Active) { | |
| } | |
| /** | |
| * setzt die FanStage auf einen bestimmten Wert | |
| * | |
| * <p>Setzt die FanStage des Geräts mit der ID <b>InstanzID</b> auf den Wert <b>Fanstage</b>. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-setfanstage/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param int $FanStage <p>0..4</p> | |
| */ | |
| function ENO_SetFanStage(int $InstanceID, int $FanStage) { | |
| } | |
| /** | |
| * dimmt den Opus-Dimmer auf eine bestimmte Helligkeit | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> auf den Wert <b>Intensität</b>. Der Wert <b>Status</b> gibt an, ob das Gerät an/aus geschaltet werden soll.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-setintensity/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| * @param int $Intensity <p>1..20, 1 = 5%, 20 = 100%</p> | |
| */ | |
| function ENO_SetIntensity(int $InstanceID, bool $DeviceOn, int $Intensity) { | |
| } | |
| /** | |
| * locked die FanStage | |
| * | |
| * <p>Locked die FanStage des Gerätes mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-setlockfanstage/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param bool $Locked <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function ENO_SetLockFanStage(int $InstanceID, bool $Locked) { | |
| } | |
| /** | |
| * locked die Occupancy | |
| * | |
| * <p>Locked die Occupancy des Gerätes mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-setlockroomoccupancy/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param bool $Locked <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function ENO_SetLockRoomOccupancy(int $InstanceID, bool $Locked) { | |
| } | |
| /** | |
| * setzt den Stellantrieb in einen bestimmten Modus | |
| * | |
| * <p>Setzt den Modus vom Stellantrieb mit der ID <b>InstanzID</b> auf den Wert <b>Value</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-setmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param int $Mode <p>0..5</p> | |
| */ | |
| function ENO_SetMode(int $InstanceID, int $Mode) { | |
| } | |
| /** | |
| * ENO_SetOverride | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Override | |
| */ | |
| function ENO_SetOverride(int $InstanceID, int $Override) { | |
| } | |
| /** | |
| * setzt die Position des Stellantriebes | |
| * | |
| * <p>Setzt die Position des Stellantriebes mit der ID <b>InstanzID</b> auf den Wert <b>Value</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-setposition/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param int $Position <p>1..100</p> | |
| */ | |
| function ENO_SetPosition(int $InstanceID, int $Position) { | |
| } | |
| /** | |
| * setzt die Occupancy auf True/False | |
| * | |
| * <p>Setzt die Occupancy ("Raumbelegung") des Gerätes mit der ID <b>InstanzID</b> auf den Wert <b>Occupied</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-setroomoccupancy/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param bool $Occupied <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function ENO_SetRoomOccupancy(int $InstanceID, bool $Occupied) { | |
| } | |
| /** | |
| * ENO_SetSmartAckLearn | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $Enabled | |
| */ | |
| function ENO_SetSmartAckLearn(int $InstanceID, bool $Enabled) { | |
| } | |
| /** | |
| * setzt den Stellantrieb auf eine bestimmte Soll-Temperatur | |
| * | |
| * <p>Setzt den Soll-Temperaturwert des Stellantriebes mit der ID <b>InstanzID</b> auf den Wert <b>Value</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-settemperature/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param float $Temperature <p>1...100</p> | |
| */ | |
| function ENO_SetTemperature(int $InstanceID, float $Temperature) { | |
| } | |
| /** | |
| * setzt das Gerät auf eine bestimmte Temperatur | |
| * | |
| * <p>Setzt den Temperaturwert des Gerätes mit der ID <b>InstanzID</b> auf den Wert <b>Temperature</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-settemperature1/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param float $Temperature <p>1..100</p> | |
| */ | |
| function ENO_SetTemperature1(int $InstanceID, float $Temperature) { | |
| } | |
| /** | |
| * bewegt den Rolladen nach unten bis zur Endposition/Stop | |
| * | |
| * <p>Bewegt den Rolladen mit der ID InstanzID nach unten, bis ENO_ShutterStop ausgeführt oder die Endposition erreicht wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-shuttermovedown/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| */ | |
| function ENO_ShutterMoveDown(int $InstanceID) { | |
| } | |
| /** | |
| * bewegt den Rolladen für eine bestimmte Zeit | |
| * | |
| * <p>Bewegt den Rolladen mit der ID InstanzID nach unten, bis ENO_ShutterStop ausgeführt oder die Laufzeit <b>Laufzeit</b> abgelaufen ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-shuttermovedownex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param float $Seconds <p>Sekunden wielange der Rolladen laufen soll. (0 - 6535.5)</p> | |
| */ | |
| function ENO_ShutterMoveDownEx(int $InstanceID, float $Seconds) { | |
| } | |
| /** | |
| * bewegt den Rolladen nach oben bis zur Endposition/Stop | |
| * | |
| * <p>Bewegt den Rolladen mit der ID InstanzID nach oben, bis ENO_ShutterStop ausgeführt oder die Endposition erreicht wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-shuttermoveup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| */ | |
| function ENO_ShutterMoveUp(int $InstanceID) { | |
| } | |
| /** | |
| * bewegt den Rolladen für eine bestimmte Zeit | |
| * | |
| * <p>Bewegt den Rolladen mit der ID InstanzID nach unten, bis ENO_ShutterStop ausgeführt oder die Laufzeit <b>Laufzeit</b> abgelaufen ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-shuttermoveupex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param float $Seconds <p>Sekunden wielange das Rollo laufen soll.</p> | |
| */ | |
| function ENO_ShutterMoveUpEx(int $InstanceID, float $Seconds) { | |
| } | |
| /** | |
| * ENO_ShutterStepDown | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ENO_ShutterStepDown(int $InstanceID) { | |
| } | |
| /** | |
| * ENO_ShutterStepUp | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ENO_ShutterStepUp(int $InstanceID) { | |
| } | |
| /** | |
| * stoppt einen Bewegungsvorgang | |
| * | |
| * <p>Stoppt eine aktuelle Bewegung des Rolladens.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-shutterstop/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| */ | |
| function ENO_ShutterStop(int $InstanceID) { | |
| } | |
| /** | |
| * ENO_SwitchLockingMode | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function ENO_SwitchLockingMode(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * schaltet ein EnOcean Gerät ein/aus | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf den Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-switchmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param bool $Value <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function ENO_SwitchMode(int $InstanceID, bool $Value) { | |
| } | |
| /** | |
| * sendet einen erweiterten Schaltbefehl | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf den Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/enocean/eno-switchmodeex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| * @param int $SendMode <p>0 = NMessage, 1 = UMessage, 2 = Beide ( Wie ENO_SwitchMode )</p> | |
| * enum[0=smNMessage, 1=smUMessage, 2=smBoth] | |
| */ | |
| function ENO_SwitchModeEx(int $InstanceID, bool $DeviceOn, int $SendMode) { | |
| } | |
| /** | |
| * ENO_SwitchRotationAngle | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function ENO_SwitchRotationAngle(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * ENO_SwitchShutterAction | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function ENO_SwitchShutterAction(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * ENO_SwitchVacationMode | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $Value | |
| */ | |
| function ENO_SwitchVacationMode(int $InstanceID, bool $Value) { | |
| } | |
| /** | |
| * ENO_SwitchVerticalPosition | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function ENO_SwitchVerticalPosition(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * ENO_UpdateFreeDeviceIDInForm | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ENO_UpdateFreeDeviceIDInForm(int $InstanceID) { | |
| } | |
| /** | |
| * ET_SetError | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param bool $Error | |
| */ | |
| function ET_SetError(int $InstanceID, bool $Error) { | |
| } | |
| /** | |
| * FHT_RequestData | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function FHT_RequestData(int $InstanceID) { | |
| } | |
| /** | |
| * FHT_SetDay | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function FHT_SetDay(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * FHT_SetHour | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function FHT_SetHour(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * FHT_SetMinute | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function FHT_SetMinute(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * sendet einen neuen Soll-Modus an den FHT | |
| * | |
| * <p>Setzt den neuen Soll-Modus für den FHT mit der ID <b>InstanzID</b> auf Wert <b>Modus</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/fhz1x00pc/fht/fht-setmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Mode <p><b>0</b> = Automatisch, <b>1</b> = Manuell</p> | |
| */ | |
| function FHT_SetMode(int $InstanceID, int $Mode) { | |
| } | |
| /** | |
| * FHT_SetMonth | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function FHT_SetMonth(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * sendet eine neue Soll-Temperatur an den FHT | |
| * | |
| * <p>Setzt die neue Soll-Temperatur für den FHT mit der ID <b>InstanzID</b> auf Wert <b>Temperatur</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/fhz1x00pc/fht/fht-settemperature/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Temperature <p>Temperaturwert in 0,5°C Schritten</p> | |
| */ | |
| function FHT_SetTemperature(int $InstanceID, float $Temperature) { | |
| } | |
| /** | |
| * FHT_SetYear | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function FHT_SetYear(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * FHZ_GetFHTQueue | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function FHZ_GetFHTQueue(int $InstanceID) { | |
| } | |
| /** | |
| * FHZ_GetFreeBuffer | |
| * | |
| * @returns int | |
| * @param int $InstanceID | |
| */ | |
| function FHZ_GetFreeBuffer(int $InstanceID) { | |
| } | |
| /** | |
| * dimmt ein FS20 Gerät eine Stufe runter | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> eine Stufe runter.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/fhz1x00pc/fs20/fs20-dimdown/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function FS20_DimDown(int $InstanceID) { | |
| } | |
| /** | |
| * dimmt ein FS20 Gerät ein Stufe höher | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> eine Stufe höher.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/fhz1x00pc/fs20/fs20-dimup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function FS20_DimUp(int $InstanceID) { | |
| } | |
| /** | |
| * dimmt ein FS20 Gerät in einer bestimmten Zeitspanne | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Intensität</b> in <b>Dauer</b> Sekunden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/fhz1x00pc/fs20/fs20-setintensity/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Intensity <p>0-16 (0=0%, 16=100%)</p> | |
| * @param int $Duration <p>Dauer des Dimmvorgangs</p> | |
| */ | |
| function FS20_SetIntensity(int $InstanceID, int $Intensity, int $Duration) { | |
| } | |
| /** | |
| * schaltet ein FS20 Gerät für eine bestimmte Zeit ein/aus | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Status</b> für <b>Dauer</b> Sekunden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/fhz1x00pc/fs20/fs20-switchduration/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| * @param int $Duration <p>Ein-/Ausschaltdauer in Sekunden</p> | |
| */ | |
| function FS20_SwitchDuration(int $InstanceID, bool $DeviceOn, int $Duration) { | |
| } | |
| /** | |
| * schaltet ein FS20 Gerät ein/aus | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Status</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/fhz1x00pc/fs20/fs20-switchmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function FS20_SwitchMode(int $InstanceID, bool $DeviceOn) { | |
| } | |
| /** | |
| * holt den Wert einer IP-Symcon Variable unabhängig des Typs | |
| * | |
| * <p>Die Funktion liefert als Ergebnis den Inhalt der IP-Symcon-Variablen mit der ID <b>VariablenID</b>. Der zurückgelieferte Variablentyp ist derjenige, der beim Anlegen der Variablen (IPS_CreateVariable) gewählt wurde. Wurde die Variable als String angelegt, liefert die Funktion also immer einen String.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/getvalue/ | |
| * @returns mixed <p>Wert der angegebenen Variable im Typ der angegebenen Variable</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| */ | |
| function GetValue(int $VariableID) { | |
| } | |
| /** | |
| * holt den Wert einer IP-Symcon Variable vom Typ Boolean | |
| * | |
| * <p>Die Funktion liefert als Ergebnis den Inhalt der IP-Symcon Variablen mit der ID <b>VariablenID</b>. Die gewählte Variable muss vom Typ Boolean sein. Wenn nicht, bricht die Funktion mit einem Fehler ab. Eine Konvertierung wird nicht vorgenommen. Für eine typunsichere Abfrage kann die Funktion GetValue genutzt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/getvalueboolean/ | |
| * @returns bool <p>Wert der angegebenen Variable</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| */ | |
| function GetValueBoolean(int $VariableID) { | |
| } | |
| /** | |
| * holt den Wert einer IP-Symcon Variable vom Typ Float | |
| * | |
| * <p>Die Funktion liefert als Ergebnis den Inhalt der IP-Symcon-Variablen mit der ID <b>VariablenID</b>. Die gewählte Variable muss vom Typ Float sein. Wenn nicht, bricht die Funktion mit einem Fehler ab. Eine Konvertierung wird nicht vorgenommen. Für eine typunsichere Abfrage können Sie die GetValue Funktion nutzen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/getvaluefloat/ | |
| * @returns float <p>Wert der angegebenen Variable</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| */ | |
| function GetValueFloat(int $VariableID) { | |
| } | |
| /** | |
| * holt den Wert einer IP-Symcon Variable und formatiert ihn anhand des Profils | |
| * | |
| * <p>Die Funktion liefert als Ergebnis den Inhalt der IP-Symcon Variablen mit der ID <b>VariablenID</b>, nachdem er passend zum Variablenprofil formatiert wurde. Der zurückgelieferte Variablentyp ist dabei durch die Formatierung immer String.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/getvalueformatted/ | |
| * @returns string <p>Wert der angegebenen Variable passend zum Profil formatiert</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| */ | |
| function GetValueFormatted(int $VariableID) { | |
| } | |
| /** | |
| * gibt einen Wert formatiert anhand des Profils einer Variable zurück | |
| * | |
| * <p>Die Funktion liefert als Ergebnis den Inhalt Wert <b>Wert</b>, nachdem er passend zum Variablenprofil der Variable mit der ID <b>VariablenID</b> formatiert wurde. Der tatsächliche Wert der Variable mit der ID <b>VariablenID</b> ist dabei unerheblich. Der zurückgelieferte Variablentyp ist durch die Formatierung immer String.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/getvalueformattedex/ | |
| * @returns string <p>Wert passend zum Profil der Variable formatiert</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| * @param mixed $Value <p>Wert, welcher formatiert werden soll</p> | |
| */ | |
| function GetValueFormattedEx(int $VariableID, mixed $Value) { | |
| } | |
| /** | |
| * holt den Wert einer IP-Symcon Variable vom Typ Integer | |
| * | |
| * <p>Die Funktion liefert als Ergebnis den Inhalt der IP-Symcon Variablen mit der ID <b>VariablenID</b>. Die gewählte Variable muss vom Typ Integer sein. Wenn nicht, bricht die Funktion mit einem Fehler ab. Eine Konvertierung wird nicht vorgenommen. Für eine typunsichere Abfrage kann die Funktion GetValue genutzt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/getvalueinteger/ | |
| * @returns int <p>Wert der angegebenen Variable</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| */ | |
| function GetValueInteger(int $VariableID) { | |
| } | |
| /** | |
| * holt den Wert einer IP-Symcon Variable vom Typ String | |
| * | |
| * <p>Die Funktion liefert als Ergebnis den Inhalt der IP-Symcon Variablen mit der ID <b>VariablenID</b>. Die gewählte Variable muss vom Typ String sein. Wenn nicht, bricht die Funktion mit einem Fehler ab. Eine Konvertierung wird nicht vorgenommen. Für eine typunsichere Abfrage kann die Funktion GetValue genutzt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/getvaluestring/ | |
| * @returns string <p>Wert der angegebenen Variable</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| */ | |
| function GetValueString(int $VariableID) { | |
| } | |
| /** | |
| * HC_CheckServerEvents | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function HC_CheckServerEvents(int $InstanceID) { | |
| } | |
| /** | |
| * HC_InitializeDevice | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function HC_InitializeDevice(int $InstanceID) { | |
| } | |
| /** | |
| * HC_Register | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function HC_Register(int $InstanceID) { | |
| } | |
| /** | |
| * HC_RegisterServerEvents | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function HC_RegisterServerEvents(int $InstanceID) { | |
| } | |
| /** | |
| * sendet einen Soll Wert an das Heating-Modul | |
| * | |
| * <p>Sendet über die Instanz mit der ID <b>InstanzID</b> einen Soll-Wert an das Heating-Modul.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/heating-control/hc-targetvalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Value <p>Neuer Soll-Wert</p> | |
| */ | |
| function HC_TargetValue(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * HC_deleteRequest | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param string $endpoint | |
| */ | |
| function HC_deleteRequest(int $InstanceID, string $endpoint) { | |
| } | |
| /** | |
| * HC_getRequest | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param string $endpoint | |
| */ | |
| function HC_getRequest(int $InstanceID, string $endpoint) { | |
| } | |
| /** | |
| * HC_putRequest | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param string $endpoint | |
| * @param string $payload | |
| */ | |
| function HC_putRequest(int $InstanceID, string $endpoint, string $payload) { | |
| } | |
| /** | |
| * sendet einen String auf den I/O | |
| * | |
| * <p>Sendet den String <b>Text</b> und dem Datensatztyp <b>ReportID</b> auf dem HID mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/hid/hid-sendevent/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden HIDs</p> | |
| * @param int $ReportID <p>ID der zu sendenen ReportID</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| */ | |
| function HID_SendEvent(int $InstanceID, int $ReportID, string $Text) { | |
| } | |
| /** | |
| * löst den FI Schalter aus | |
| * | |
| * <p>Löst den FI Trenner über das HMS Gerät mit der ID <b>InstanzID</b> aus. Der <b>Auslöseverzögerung</b> Parameter wird in Sekunden angegeben.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/fhz1x00pc/hms/hms-releasefi/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Delay <p>Verzögerung in Sekunden</p> | |
| */ | |
| function HMS_ReleaseFI(int $InstanceID, int $Delay) { | |
| } | |
| /** | |
| * liest die Service-Meldungen aus | |
| * | |
| * <p>Liest die Service-Meldungen des CCU/LAN-Adapters mit der ID <b>InstanzID</b> aus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/homematic/hm-readservicemessages/ | |
| * @returns array <p>Folgende Informationen stehen als <b>key => value</b> Paare zur Verfügung:</p> | |
| * @param int $InstanceID <p>ID der HomeMatic Socket Instanz</p> | |
| */ | |
| function HM_ReadServiceMessages(int $InstanceID) { | |
| } | |
| /** | |
| * fragt den Ist-Wert vom Gerät ab | |
| * | |
| * <p>Fragt die Statusvariable mit dem Namen <b>Parameter</b> des Gerätes mit der ID <b>InstanzID</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/homematic/hm-requeststatus/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param string $Parameter <li>STATEStatus eines Aktors</li><li>LEVELDimmwert</li><li>...Eine Übersicht aller abfragbaren "lesend" Parameter kann der Dokumentation der Homematic Datenpunkte unter Tipps & Tricks entnommen werden.</li> | |
| */ | |
| function HM_RequestStatus(int $InstanceID, string $Parameter) { | |
| } | |
| /** | |
| * sendet einen neuen Soll-Wert vom Typ Boolean an die CCU | |
| * | |
| * <p>Setzt den <b>Parameter</b> des Gerätes mit der ID <b>InstanzID</b> auf den Wert <b>Wert</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/homematic/hm-writevalueboolean/ | |
| * @returns bool <p>default</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param string $Parameter <p>Parameter welcher gesetzt werden soll. Der Name des Parameters kann in der Datenpunktliste oder als "Ident" im Reiter "Statusvariablen" in IP-Symcon nachgesehen werden.</p> | |
| * @param bool $Value <p>true oder false</p> | |
| */ | |
| function HM_WriteValueBoolean(int $InstanceID, string $Parameter, bool $Value) { | |
| } | |
| /** | |
| * sendet einen neuen Soll-Wert vom Typ Float an die CCU | |
| * | |
| * <p>Setzt den <b>Parameter</b> des Gerätes mit der ID <b>InstanzID</b> auf Wert <b>Wert</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/homematic/hm-writevaluefloat/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param string $Parameter <p>Parameter welcher gesetzt werden soll. Der Name des Parameters kann in der Datenpunktliste oder als "Ident" im Reiter "Statusvariablen" in IP-Symcon gefunden werden.</p> | |
| * @param float $Value <p>Fließkommazahl die gesetzt werden soll.</p> | |
| */ | |
| function HM_WriteValueFloat(int $InstanceID, string $Parameter, float $Value) { | |
| } | |
| /** | |
| * sendet einen neuen Soll-Wert vom Typ Integer an die CCU | |
| * | |
| * <p>Setzt den <b>Parameter</b> des Gerätes mit der ID <b>InstanzID</b> auf Wert <b>Wert</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/homematic/hm-writevalueinteger/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param string $Parameter <p>Parameter welcher gesetzt werden soll. Der Name des Parameters kann in der Datenpunktliste oder als "Ident" im Reiter "Statusvariablen" in IP-Symcon gefunden werden.</p> | |
| * @param int $Value <p>Ganzzahliger Wert der gesetzt werden soll.</p> | |
| */ | |
| function HM_WriteValueInteger(int $InstanceID, string $Parameter, int $Value) { | |
| } | |
| /** | |
| * sendet einen neuen Soll-Wert vom Typ String an die CCU | |
| * | |
| * <p>Setzt den <b>Parameter</b> des Gerätes mit der ID <b>InstanzID</b> auf Wert <b>Wert</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/homematic/hm-writevaluestring/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| * @param string $Parameter <p>Parameter welcher gesetzt werden soll. Der Name des Parameters kann in der Datenpunktliste oder als "Ident" im Reiter "Statusvariablen" in IP-Symcon gefunden werden.</p> | |
| * @param string $Value <p>String der gesetzt werden soll.</p> | |
| */ | |
| function HM_WriteValueString(int $InstanceID, string $Parameter, string $Value) { | |
| } | |
| /** | |
| * prüft, ob eine Aktion definiert ist | |
| * | |
| * <p>Die Funktion prüft die Variable mit der ID <b>VariablenID</b> auf eine vorhandene Aktion. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/hasaction/ | |
| * @returns bool <p><b>TRUE</b>, falls die Variable eine Aktion hat, andernfalls <b>FALSE</b></p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| */ | |
| function HasAction(int $VariableID) { | |
| } | |
| /** | |
| * I2TConfigurator_GetStationInstanceID | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param string $StationID | |
| */ | |
| function I2TConfigurator_GetStationInstanceID(int $InstanceID, string $StationID) { | |
| } | |
| /** | |
| * I2TListe_GetDataUpdate | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function I2TListe_GetDataUpdate(int $InstanceID) { | |
| } | |
| /** | |
| * I2TStation_GetDataUpdate | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function I2TStation_GetDataUpdate(int $InstanceID) { | |
| } | |
| /** | |
| * I2TStation_SetDataUpdate | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param string $Brand | |
| * @param string $Name | |
| * @param string $Street | |
| * @param string $HouseNumber | |
| * @param string $PostCode | |
| * @param string $Place | |
| */ | |
| function I2TStation_SetDataUpdate(int $InstanceID, string $Brand, string $Name, string $Street, string $HouseNumber, string $PostCode, string $Place) { | |
| } | |
| /** | |
| * aktualisiert das Bild der Instanz | |
| * | |
| * <p>Aktualisiert das Bild des Gerätes mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/image-grabber/ig-updateimage/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz des zu schaltenden Gerätes</p> | |
| */ | |
| function IG_UpdateImage(int $InstanceID) { | |
| } | |
| /** | |
| * löscht eine Mail mit einer bestimmten E-Mail(UID) | |
| * | |
| * <p>Der Befehl löscht eine E-Mail mit der UID <b>UID</b> aus der IMAP-Instanz mit der ID <b>InstanzID</b>. Sollte die Instanz oder eine E-Mail mit der übergebenen UID nicht existieren, wird eine Warnung generiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/imap/imap-deletemail/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der IMAP-Instanz</p> | |
| * @param string $UID <p>UID der zu löschenden E-Mail</p> | |
| */ | |
| function IMAP_DeleteMail(int $InstanceID, string $UID) { | |
| } | |
| /** | |
| * gibt ein Array zu den gecachten E-Mails zurück | |
| * | |
| * <p>Der Befehl gibt ein Array mit Informationen über die gecacheten E-Mails einer IMAP-Instanz mit der ID <b>InstanzID</b> zurück. Sollte die Instanz nicht existieren, wird eine Warnung generiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/imap/imap-getcachedmails/ | |
| * @returns array <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis ein Array mit Daten zu den gecacheten E-Mails, andernfalls ein Boolean mit dem Wert <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der IMAP-Instanz</p> | |
| */ | |
| function IMAP_GetCachedMails(int $InstanceID) { | |
| } | |
| /** | |
| * liefert ein Array mit Informationen zu einer bestimmten E-Mail(UID) wieder | |
| * | |
| * <p>Der Befehl lädt eine E-Mail mit der UID <b>UID</b> über die IMAP-Instanz mit der ID <b>InstanzID</b> und gibt ein Array mit den Daten der E-Mail zurück. Sollte die Instanz oder eine E-Mail mit der übergebenen UID nicht existieren, wird eine Warnung generiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/imap/imap-getmailex/ | |
| * @returns array <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis ein Array mit Daten zu den gecacheten E-Mails, andernfalls ein Boolean mit dem Wert <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der IMAP-Instanz</p> | |
| * @param string $UID <p>UID der zu ladenden E-Mail</p> | |
| */ | |
| function IMAP_GetMailEx(int $InstanceID, string $UID) { | |
| } | |
| /** | |
| * IMAP_UpdateCache | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function IMAP_UpdateCache(int $InstanceID) { | |
| } | |
| /** | |
| * IMAP_UpdateFormUseSSL | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $UseSSL | |
| */ | |
| function IMAP_UpdateFormUseSSL(int $InstanceID, bool $UseSSL) { | |
| } | |
| /** | |
| * IOT_Send | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $Text | |
| */ | |
| function IOT_Send(int $InstanceID, mixed $Text) { | |
| } | |
| /** | |
| * IPSInfo_Update | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function IPSInfo_Update(int $InstanceID) { | |
| } | |
| /** | |
| * IPS_AbortScript | |
| * | |
| * @returns bool | |
| * @param int $ScriptID | |
| */ | |
| function IPS_AbortScript(int $ScriptID) { | |
| } | |
| /** | |
| * IPS_ActionExists | |
| * | |
| * @returns bool | |
| * @param string $ActionID | |
| */ | |
| function IPS_ActionExists(string $ActionID) { | |
| } | |
| /** | |
| * übernimmt eine veränderte Konfiguration | |
| * | |
| * <p>Die Funktion übernimmt die neue Soll-Konfiguration als aktuelle Ist-Konfiguration und initialisiert bei Bedarf entsprechende Modulkomponenten neu. (Z.B. wird bei einem Socket Modul die Netzwerkverbindung getrennt und neu aufgebaut.)</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/konfiguration/ips-applychanges/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| */ | |
| function IPS_ApplyChanges(int $InstanceID) { | |
| } | |
| /** | |
| * prüft, ob eine Kategorie bereits existiert | |
| * | |
| * <p>Die Funktion prüft, ob die Kategorie mit der ID <b>KategorienID</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/kategorieverwaltung/ips-categoryexists/ | |
| * @returns bool <p>Falls die KategorieID im System existiert, wird <b>TRUE</b> zurückgemeldet, andernfalls <b>FALSE</b>.</p> | |
| * @param int $CategoryID <p>ID der zu prüfenden Kategorie</p> | |
| */ | |
| function IPS_CategoryExists(int $CategoryID) { | |
| } | |
| /** | |
| * erstellt eine (Daten-)Verbindung zwischen zwei Instanzen | |
| * | |
| * <p>Die Funktion verbindet die Instanz <b>InstanzID</b> mit der Instanz <b>ConnectionID</b> von der Hardwaresicht (physikalisch) gesehen aus, so dass Daten ausgetauscht werden können. Beispiel wäre in FS20 Gerät, dass mit einem FHZ Splitter verbunden wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/verbindungen/ips-connectinstance/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| * @param int $ParentID <p>ID der neu zu verbindenen Instanz</p> | |
| */ | |
| function IPS_ConnectInstance(int $InstanceID, int $ParentID) { | |
| } | |
| /** | |
| * legt eine neue Kategorie an | |
| * | |
| * <p>Die Funktion legt eine neue Kategorie an. Es wird kein Parameter benötigt. Nach Ausführung der Funktion erscheint im Kategorienbaum von IP-Symcon eine neue Kategorie mit der Bezeichnung z.B. ”Unnamed Object (ID: 48490)”. Mit Hilfe der Funktion IPS_SetName kann der Kategorie ein aussagefähiger Name gegeben werden. Der Name sollte nicht für die Identifikation verwendet werden. Hierfür ist die ID zuständig. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/kategorieverwaltung/ips-createcategory/ | |
| * @returns int <p>ID der neu erstellten Kategorie</p> | |
| */ | |
| function IPS_CreateCategory() { | |
| } | |
| /** | |
| * legt ein neues Ereignis an | |
| * | |
| * <p>Die Funktion legt ein Ereignisobjekt vom Typ <b>EreignisTyp</b> an.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-createevent/ | |
| * @returns int <p>ID des neu erstellten Ereignisses</p> | |
| * @param int $EventType <li>0Legt ein <b>“ausgelöstes”</b> Ereignis an</li><li>1Legt ein <b>“zyklisches”</b> Ereignis an</li><li>2Legt ein <b>“Wochenplan”</b> Ereignis an</li> | |
| * enum[0=etTrigger, 1=etCyclic, 2=etSchedule] | |
| */ | |
| function IPS_CreateEvent(int $EventType) { | |
| } | |
| /** | |
| * legt eine Instanz an | |
| * | |
| * <p>Die Funktion legt eine unkonfigurierte Instanz der ID <b>ModulID</b> an. Zulässige Werte für <b>ModulID</b> können über die Funktion IPS_GetModuleList ermittelt werden. Die ModulID ist eine GUID.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/ips-createinstance/ | |
| * @returns int <p>ID der neu erstellten Instanz</p> | |
| * @param string $ModuleID <p>ModulID ( GUID ) des zu erstellenden Objekts</p> | |
| */ | |
| function IPS_CreateInstance(string $ModuleID) { | |
| } | |
| /** | |
| * legt einen neuen Link an | |
| * | |
| * <p>Die Funktion legt eine neuen Link an. Er benötigt keine Parameter. Nach Ausführung der Funktion erscheint im Kategorienbaum von IP-Symcon ein neues Objekt mit der Bezeichnung z.B. ”Unnamed Object (ID: 48490)”. Mit Hilfe der Funktion IPS_SetName kann dem Objekt (hier der Link) ein aussagefähiger Name gegeben werden. Der Name ist jedoch für die Identifikation irrelevant. Hierfür ist immer die ID zuständig.<br>Weiterhin sollte der Link mit einem anderen Objekt verknüpft werden. Dies kann über die Funktion IPS_SetLinkTargetID gemacht werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/linkverwaltung/ips-createlink/ | |
| * @returns int <p>ID des neu erstellten Links</p> | |
| */ | |
| function IPS_CreateLink() { | |
| } | |
| /** | |
| * legt ein neues Medienobjekt im MedienPool an | |
| * | |
| * <p>Die Funktion legt ein leeres Medienobjekt vom Typ <b>MedienTyp</b> an.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-createmedia/ | |
| * @returns int <p>ID des neu erstellten Medienobjekts</p> | |
| * @param int $MediaType <li>0Legt ein <b>IPSView Formular</b> an</li><li>1Legt ein <b>Image Objekt</b> an</li><li>2Legt ein <b>Sound Objekt</b> an</li><li>3Legt ein <b>Stream Objekt</b> an</li><li>4Legt ein <b>Chart Objekt</b> an</li><li>5Legt ein <b>Dokument Objekt</b> an</li> | |
| * enum[0=mtForm, 1=mtImage, 2=mtSound, 3=mtStream, 4=mtChart, 5=mtDocument] | |
| */ | |
| function IPS_CreateMedia(int $MediaType) { | |
| } | |
| /** | |
| * legt ein neues Skript an | |
| * | |
| * <p>Die Funktion legt ein Skript vom Typ <b>SkriptTyp</b> an.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-createscript/ | |
| * @returns int <p>ID des neu erstellten Skripts</p> | |
| * @param int $ScriptType <li>0Erzeugt ein <b>PHP Skript</b></li><li>1Erzeugt einen <b>Ablaufplan</b></li> | |
| * enum[0=stPHPScript, 1=stFlowScript, 2=stWorkflow] | |
| */ | |
| function IPS_CreateScript(int $ScriptType) { | |
| } | |
| /** | |
| * IPS_CreateTemporaryMediaStreamToken | |
| * | |
| * @returns string | |
| * @param int $MediaID | |
| * @param int $ValidForSeconds | |
| */ | |
| function IPS_CreateTemporaryMediaStreamToken(int $MediaID, int $ValidForSeconds) { | |
| } | |
| /** | |
| * IPS_CreateTemporaryToken | |
| * | |
| * @returns string | |
| * @param int $ValidForSeconds | |
| */ | |
| function IPS_CreateTemporaryToken(int $ValidForSeconds) { | |
| } | |
| /** | |
| * legt eine Variable an | |
| * | |
| * <p>Die Funktion legt eine neue IPS-Variable vom Typ VariablenTyp an.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/ips-createvariable/ | |
| * @returns int <p>ID der neu erstellten Variable</p> | |
| * @param int $VariableType <li>0Legt eine Variable vom Typ <b>Boolean</b> an</li><li>1Legt eine Variable vom Typ <b>Integer</b> an</li><li>2Legt eine Variable vom Typ <b>Float</b> an</li><li>3Legt eine Variable vom Typ <b>String</b> an</li> | |
| * enum[0=vtBoolean, 1=vtInteger, 2=vtFloat, 3=vtString] | |
| */ | |
| function IPS_CreateVariable(int $VariableType) { | |
| } | |
| /** | |
| * legt ein Variablenprofil an | |
| * | |
| * <p>Die Funktion legt ein neues Variablenprofile für den Typ <b>VariablenTyp</b> an.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-createvariableprofile/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ProfileName <p>Name des Profils. Erlaubt sind A-Z, a-z, Punkt, Komma, Unterstrich</p> | |
| * @param int $ProfileType <li>0Legt ein Variablenprofil für VariablenTyp <b>Boolean</b> an</li><li>1Legt ein Variablenprofil für VariablenTyp <b>Integer</b> an</li><li>2Legt ein Variablenprofil für VariablenTyp <b>Float</b> an</li><li>3Legt ein Variablenprofil für VariablenTyp <b>String</b> an</li> | |
| * enum[0=vtBoolean, 1=vtInteger, 2=vtFloat, 3=vtString] | |
| */ | |
| function IPS_CreateVariableProfile(string $ProfileName, int $ProfileType) { | |
| } | |
| /** | |
| * löscht eine bestehende Kategorie | |
| * | |
| * <p>Die Funktion löscht die vorhandene Kategorie mit der ID <b>KategorienID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/kategorieverwaltung/ips-deletecategory/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $CategoryID <p>ID der zu löschenden Kategorie</p> | |
| */ | |
| function IPS_DeleteCategory(int $CategoryID) { | |
| } | |
| /** | |
| * löscht eine bestehendes Ereignis | |
| * | |
| * <p>Die Funktion löscht ein vorhandenes Ereignis mit der ID <b>EreignisID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-deleteevent/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu löschenden Ereignisses</p> | |
| */ | |
| function IPS_DeleteEvent(int $EventID) { | |
| } | |
| /** | |
| * löscht eine Instanz | |
| * | |
| * <p>Die Funktion löscht eine vorhandene Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/ips-deleteinstance/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu löschenden Instanz</p> | |
| */ | |
| function IPS_DeleteInstance(int $InstanceID) { | |
| } | |
| /** | |
| * löscht einen bestehenden Link | |
| * | |
| * <p>Die Funktion löscht den Link mit der ID <b>LinkID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/linkverwaltung/ips-deletelink/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $LinkID <p>ID des zu löschenden Links</p> | |
| */ | |
| function IPS_DeleteLink(int $LinkID) { | |
| } | |
| /** | |
| * löscht ein Medienobjekt aus dem MedienPool | |
| * | |
| * <p>Die Funktion entfernt das Medienobjekt mit der ID <b>MedienID</b> aus dem MedienPool.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-deletemedia/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $MediaID <p>ID des zu löschenden Medienobjekts</p> | |
| * @param bool $DeleteFile <p><b>TRUE</b>, wenn Datei gelöscht werden soll; <b>FALSE</b>, wenn die Datei in den ‘deleted’ Ordner verschoben werden soll</p> | |
| */ | |
| function IPS_DeleteMedia(int $MediaID, bool $DeleteFile) { | |
| } | |
| /** | |
| * entfernt eine bestehendes Skript aus der Skriptliste | |
| * | |
| * <p>Die Funktion entfernt das Skript mit der ID <b>SkriptID</b> aus der internen Skriptliste. Das Skript erscheint nicht mehr im Strukturbaum und kann auch nicht mehr bearbeitet werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-deletescript/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ScriptID <p>ID des zu löschenden Skripts</p> | |
| * @param bool $DeleteFile <p><b>TRUE</b>, wenn Datei endgültig gelöscht werden soll; <b>FALSE</b>, wenn die Datei in den ‘deleted’ Ordner verschoben werden soll</p> | |
| */ | |
| function IPS_DeleteScript(int $ScriptID, bool $DeleteFile) { | |
| } | |
| /** | |
| * löscht eine Variable | |
| * | |
| * <p>Die Funktion löscht eine vorhandene Variable mit der ID VariablenID.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/ips-deletevariable/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der zu löschenden Variable</p> | |
| */ | |
| function IPS_DeleteVariable(int $VariableID) { | |
| } | |
| /** | |
| * löscht ein Variablenprofil | |
| * | |
| * <p>Die Funktion löscht ein vorhandenes Variablenprofil mit dem Namen <b>ProfilName</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-deletevariableprofile/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ProfileName <p>Name des zu löschenden Profils</p> | |
| */ | |
| function IPS_DeleteVariableProfile(string $ProfileName) { | |
| } | |
| /** | |
| * IPS_DisableDebug | |
| * | |
| * @returns bool | |
| * @param int $ID | |
| */ | |
| function IPS_DisableDebug(int $ID) { | |
| } | |
| /** | |
| * IPS_DisableDebugFile | |
| * | |
| * @returns bool | |
| * @param int $ID | |
| */ | |
| function IPS_DisableDebugFile(int $ID) { | |
| } | |
| /** | |
| * löst eine (Daten-)Verbindung zwischen zwei Instanzen | |
| * | |
| * <p>Die Funktion löst eine verbundene Instanz <b>InstanzID</b> von der übergeordneten Instanz. Die Angabe der übergeordneten Instanz ist nicht notwendig, da es nur eine geben kann und somit die zu lösende Verbindung eindeutig ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/verbindungen/ips-disconnectinstance/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| */ | |
| function IPS_DisconnectInstance(int $InstanceID) { | |
| } | |
| /** | |
| * IPS_EnableDebug | |
| * | |
| * @returns bool | |
| * @param int $ID | |
| * @param int $Duration | |
| */ | |
| function IPS_EnableDebug(int $ID, int $Duration) { | |
| } | |
| /** | |
| * aktiviert das Schreiben von Debug-Logs in eine Datei | |
| * | |
| * <p>Die Funktion aktiviert das Schreiben von Debug-Logs in eine Datei von der Instanz mit der ID <b>InstanzID</b>.<br>Die Debugdatei befindet sich im Logs Ordner (z.B. /var/log/symcon/debug_<InstanzID>.log).</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/debug/ips-enabledebugfile/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ID <p>ID der Instanz</p> | |
| */ | |
| function IPS_EnableDebugFile(int $ID) { | |
| } | |
| /** | |
| * prüft, ob ein Ereignis bereits existiert | |
| * | |
| * <p>Die Funktion überprüft ob ein Ereignis mit der ID <b>EreignisID</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-eventexists/ | |
| * @returns bool <p>Falls die EreignisID im System existiert, wird <b>TRUE</b> zurückgemeldet, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu prüfenden Ereignisses</p> | |
| */ | |
| function IPS_EventExists(int $EventID) { | |
| } | |
| /** | |
| * startet ein externes Programm | |
| * | |
| * <p>Die Funktion veranlasst den Start des externen Programms mit dem Namen <b>ProgrammName</b>. Dem Programm wird der <b>String</b>-Parameter als Aufrufparameter übergeben. Der Boolean-Wert <b>Warten</b> legt fest, ob das Programmende abgewartet oder das aufrufende Skript sofort fortgesetzt werden soll. Wird auf das Ergebnis gewartet, erscheint dieses, falls vorhanden, als String im Rückgabewert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-execute/ | |
| * @returns string <p>Den Rückgabewert von stderr/stdout, wenn der <b>Warten</b> Parameter auf True ist, sonst ist die Rückgabe ein leerer String.</p> | |
| * @param string $Filename <p>Vollständiger Pfad zum Programm</p> | |
| * @param string $Parameter <p>An das Programm zu übergebende Parameter (optional)</p> | |
| * @param bool $ShowWindow <p>V1 Parameter. Wird in der V2 nicht ausgewertet.</p> | |
| * @param bool $WaitResult <p>Gibt an, ob auf das Programmende gewartet werden soll.</p> | |
| */ | |
| function IPS_Execute(string $Filename, string $Parameter, bool $ShowWindow, bool $WaitResult) { | |
| } | |
| /** | |
| * startet ein externes Programm im Userkontext | |
| * | |
| * <p>Die Funktion veranlasst den Start des externen Programms mit dem Namen <b>ProgrammName</b>. Dem Programm wird der String-<b>Parameter</b> als Aufrufparameter übergeben. Der Boolean-Wert <b>Warten</b> legt fest, ob das Programmende abgewartet oder das aufrufende Skript sofort fortgesetzt werden soll.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-executeex/ | |
| * @returns string <p>Leerstring</p> | |
| * @param string $Filename <p>Vollständiger Pfad zum Programm</p> | |
| * @param string $Parameter <p>An das Programm zu übergebende Parameter (optional)</p> | |
| * @param bool $ShowWindow <p><b>True</b>, wenn das Fenster angezeigt werden soll; <b>False</b>, wenn das Fenster unsichbar bleiben soll</p> | |
| * @param bool $WaitResult <p>Gibt an, ob aus das Programmende gewartet werden soll.</p> | |
| * @param int $SessionID <p>Die User Session ID, die genutzt werden soll (Unter XP ab 0, 2003/Vista ab 1), < 0 für automatische Auswahl</p> | |
| */ | |
| function IPS_ExecuteEx(string $Filename, string $Parameter, bool $ShowWindow, bool $WaitResult, int $SessionID) { | |
| } | |
| /** | |
| * prüft, ob eine bestimmte Funktion existiert | |
| * | |
| * <p>Die Funktion prüft, ob die Funktion mit dem Namen Funktionsname innerhalb von IP-Symcon registriert ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-functionexists/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $FunctionName <p>Name, der zu prüfenden Funktion</p> | |
| */ | |
| function IPS_FunctionExists(string $FunctionName) { | |
| } | |
| /** | |
| * IPS_GetActionForm | |
| * | |
| * @returns string | |
| * @param string $ActionID | |
| * @param array $Parameters | |
| */ | |
| function IPS_GetActionForm(string $ActionID, array $Parameters) { | |
| } | |
| /** | |
| * IPS_GetActionReadableCode | |
| * | |
| * @returns string | |
| * @param string $ActionID | |
| * @param array $Parameters | |
| */ | |
| function IPS_GetActionReadableCode(string $ActionID, array $Parameters) { | |
| } | |
| /** | |
| * IPS_GetActions | |
| * | |
| * @returns string | |
| */ | |
| function IPS_GetActions() { | |
| } | |
| /** | |
| * IPS_GetActionsByEnvironment | |
| * | |
| * @returns string | |
| * @param int $TargetID | |
| * @param string $Environment | |
| * @param bool $IncludeDefault | |
| */ | |
| function IPS_GetActionsByEnvironment(int $TargetID, string $Environment, bool $IncludeDefault) { | |
| } | |
| /** | |
| * IPS_GetActiveProxyConnections | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetActiveProxyConnections() { | |
| } | |
| /** | |
| * IPS_GetActiveWebServerConnections | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetActiveWebServerConnections() { | |
| } | |
| /** | |
| * IPS_GetActiveWebSocketConnections | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetActiveWebSocketConnections() { | |
| } | |
| /** | |
| * IPS_GetAvailableUpdates | |
| * | |
| * @returns array | |
| */ | |
| function IPS_GetAvailableUpdates() { | |
| } | |
| /** | |
| * IPS_GetCategory | |
| * | |
| * @returns array | |
| * @param int $CategoryID | |
| */ | |
| function IPS_GetCategory(int $CategoryID) { | |
| } | |
| /** | |
| * sucht und liefert die ID einer bestehenden Kategorie über dessen Namen | |
| * | |
| * <p>Die Funktion versucht die ID der Kategorie mit dem Namen <b>KategorienName</b>, deren übergeordnetes Objekt die ID <b>ÜbergeordneteID</b> besitzt, zu ermitteln. Es wird die ID der ersten gefundenen Kategorie verwendet, deren Name mit <b>KategorienName</b> übereinstimmt. Falls eine solche Kategorie gefunden wurde, wird deren ID zurückgemeldet, andernfalls FALSE.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/kategorieverwaltung/ips-getcategoryidbyname/ | |
| * @returns int <p>ID der gefundenen Kategorie, sonst FALSE</p> | |
| * @param string $Name <p>Zu suchender KategorieName</p> | |
| * @param int $ParentID <p>Objekt, in deren direkten Unterobjekten gesucht werden soll</p> | |
| */ | |
| function IPS_GetCategoryIDByName(string $Name, int $ParentID) { | |
| } | |
| /** | |
| * liefert eine Liste aller existierenden Kategorien | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller in IP-Symcon eingerichteten Kategorien. Die IDs werden in einem Array aufgelistet. Falls keine Kategorie existiert, ist das Array leer.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/kategorieverwaltung/ips-getcategorylist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Kategorien in IP-Symcon</p> | |
| */ | |
| function IPS_GetCategoryList() { | |
| } | |
| /** | |
| * liefert eine Aufstellung aller untergeordneten Objekte | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller Unterobjekte von Objekt <b>ObjektID</b>. Die IDs werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-getchildrenids/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Unterobjekte von Objekt <b>ObjektID</b></p> | |
| * @param int $ID <p>ID für die die Unterobjekte zurückgegeben werden sollen</p> | |
| */ | |
| function IPS_GetChildrenIDs(int $ID) { | |
| } | |
| /** | |
| * liefert kompatible Instanzen zu einer Instanz | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller in IP-Symcon verfügbaren Instanzen, die zur <b>InstanzID</b> kompatibel sind. Die IDs werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/verbindungen/ips-getcompatibleinstances/ | |
| * @returns array <p>Array von Integer-Werten aller kompatiblen InstanzIDs zur <b>InstanzID</b></p> | |
| * @param int $InstanceID <p>ID der zu prüfenden Instanz</p> | |
| */ | |
| function IPS_GetCompatibleInstances(int $InstanceID) { | |
| } | |
| /** | |
| * liefert alle Kompatiblen Module zu einem bestimmten Modul | |
| * | |
| * <p>Die Funktion ermittelt die GUIDs aller in IP-Symcon verfügbaren Module, die zur <b>ModulID</b> kompatibel sind. Die IDs werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/modulverwaltung/ips-getcompatiblemodules/ | |
| * @returns array <p>Array von String-Werten aller kompatiblen ModulIDs zu <b>ModulID</b></p> | |
| * @param string $ModuleID <p>GUID</p> | |
| */ | |
| function IPS_GetCompatibleModules(string $ModuleID) { | |
| } | |
| /** | |
| * liest eine Konfiguration aus | |
| * | |
| * <p>Die Funktion gibt die Konfiguration der Instanz mit der ID <b>InstanzID</b> als String zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/konfiguration/ips-getconfiguration/ | |
| * @returns string <p>Konnte die Funktion erfolgreich ausgeführt werden, liefert er als Ergebnis die Konfiguration der Instanz als String.</p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| */ | |
| function IPS_GetConfiguration(int $InstanceID) { | |
| } | |
| /** | |
| * IPS_GetConfigurationForParent | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| */ | |
| function IPS_GetConfigurationForParent(int $InstanceID) { | |
| } | |
| /** | |
| * liest eine Konfigurationseite aus | |
| * | |
| * <p>Die Funktion gibt die Konfigurationseite der Instanz mit der ID <b>InstanzID</b> als JSON-kodierter String zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/konfiguration/ips-getconfigurationform/ | |
| * @returns string <p>Konnte die Funktion erfolgreich ausgeführt werden, liefert er als Ergebnis die Konfigurationseite der Instanz als JSON-kodierter String.</p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| */ | |
| function IPS_GetConfigurationForm(int $InstanceID) { | |
| } | |
| /** | |
| * IPS_GetConfigurationsFromChildren | |
| * | |
| * @returns array | |
| * @param array $Parameter | |
| */ | |
| function IPS_GetConfigurationsFromChildren(array $Parameter) { | |
| } | |
| /** | |
| * IPS_GetConnectionList | |
| * | |
| * @returns array | |
| */ | |
| function IPS_GetConnectionList() { | |
| } | |
| /** | |
| * IPS_GetDemoExpiration | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetDemoExpiration() { | |
| } | |
| /** | |
| * liefert umfassende Informationen über ein Ereignis | |
| * | |
| * <p>Die Funktion liefert ein Array mit Informationen über Ereignis mit der ID <b>EreignisID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-getevent/ | |
| * @returns array <p>Folgende Informationen stehen als <b>key => value</b> Paare zur Verfügung:</p> | |
| * @param int $EventID <p>Die zu zeigende EreignisID</p> | |
| */ | |
| function IPS_GetEvent(int $EventID) { | |
| } | |
| /** | |
| * ermittelt die ID eines Ereignisses anhand des Namens | |
| * | |
| * <p>Die Funktion versucht die ID des Ereignisses mit dem Namen <b>EreignisName</b>, dessen übergeordnetes Objekt die ID <b>ÜbergeordneteID</b> besitzt, zu ermitteln. Es wird die ID des ersten gefundenen Ereignisses verwendet, dessen Name mit <b>EreignisName</b> übereinstimmt. Falls ein solches Ereignis gefunden wurde, wird dessen ID zurückgemeldet, andernfalls FALSE.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-geteventidbyname/ | |
| * @returns int <p>ID des gefundenen Ereignisses, sonst FALSE</p> | |
| * @param string $Name <p>Zu suchender EreignisName</p> | |
| * @param int $ParentID <p>Objekt, in dessen direkten Unterobjekten gesucht werden soll</p> | |
| */ | |
| function IPS_GetEventIDByName(string $Name, int $ParentID) { | |
| } | |
| /** | |
| * liefert eine Liste aller existierenden Ereignisse | |
| * | |
| * <p>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.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-geteventlist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Ereignisse in IP-Symcon</p> | |
| */ | |
| function IPS_GetEventList() { | |
| } | |
| /** | |
| * liefert eine Liste aller Ereignisse eines bestimmten Typs | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller Ereignisse eines bestimmten <b>EreignisTyps</b>. Die IDs werden in einem Array aufgelistet. Falls kein Ereignis des angeforderten Typs existiert, ist das Array leer.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-geteventlistbytype/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Ereignisse vom Typ EreignisTyp in IP-Symcon</p> | |
| * @param int $EventType <li>0<b>Ausgelöstes Ereignis</b></li><li>1<b>Zyklisches Ereignis</b></li><li>2<b>Wochenplan Ereignis</b></li> | |
| * enum[0=etTrigger, 1=etCyclic, 2=etSchedule] | |
| */ | |
| function IPS_GetEventListByType(int $EventType) { | |
| } | |
| /** | |
| * IPS_GetFlowScriptStatistic | |
| * | |
| * @returns array | |
| * @param int $ScriptID | |
| */ | |
| function IPS_GetFlowScriptStatistic(int $ScriptID) { | |
| } | |
| /** | |
| * liefert umfassende Informationen über eine Funktion | |
| * | |
| * <p>Die Funktion liefert weitere Informationen zu einer in IP-Symcon registrierten Funktion. Der Parameter Funktionsname gibt an, welche Funktion inspiziert werden soll.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getfunction/ | |
| * @returns array <p>Ein Array mit folgenden <b>key => value</b> Paaren</p> | |
| * @param string $FunctionName <p>Name, der zu prüfenden Funktion</p> | |
| */ | |
| function IPS_GetFunction(string $FunctionName) { | |
| } | |
| /** | |
| * liefert eine Liste mit allen Verfügbaren Funktionsnamen | |
| * | |
| * <p>Die Funktion ermittelt alle in der aktuellen Konfiguration von IP-Symcon verfügbaren IPS-Funktionen. Die Funktionen werden in einem Array aufgelistet. Die Anzahl der Funktionen ist abhängig von der derzeitigen Konfiguration von IP-Symcon. Wenn z.B. eine Instanz des TTS-Moduls (Text-To-Speech) konfiguriert ist, dann werden zusätzlich auch alle TTS-Funktionen aufgeführt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getfunctionlist/ | |
| * @returns array <p>Ein Array von Strings aller Funktionsnamen</p> | |
| * @param int $InstanceID <p>InstanzID, für zu suchende Funktion. 0, um alle zu suchen.</p> | |
| */ | |
| function IPS_GetFunctionList(int $InstanceID) { | |
| } | |
| /** | |
| * liefert eine Liste mit allen verfügbaren Funktionen eines Moduls | |
| * | |
| * <p>Die Funktion ermittelt alle verfügbaren Funktionen des Moduls mit der GUID <b>ModuleID</b>. Die Funktionen werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getfunctionlistbymoduleid/ | |
| * @returns array <p>Ein Array von Strings aller Funktionen</p> | |
| * @param string $ModuleID <p>GUID des Moduls</p> | |
| */ | |
| function IPS_GetFunctionListByModuleID(string $ModuleID) { | |
| } | |
| /** | |
| * IPS_GetFunctions | |
| * | |
| * @returns array | |
| * @param array $InstanceIDs | |
| */ | |
| function IPS_GetFunctions(array $InstanceIDs) { | |
| } | |
| /** | |
| * IPS_GetFunctionsMap | |
| * | |
| * @returns array | |
| * @param array $InstanceIDs | |
| */ | |
| function IPS_GetFunctionsMap(array $InstanceIDs) { | |
| } | |
| /** | |
| * IPS_GetIcons | |
| * | |
| * @returns array | |
| * @param array $Parameter | |
| */ | |
| function IPS_GetIcons(array $Parameter) { | |
| } | |
| /** | |
| * liefert umfassende Informationen zu einer bestimmten Instanz | |
| * | |
| * <p>Die Funktion liefert ein Array mit Informationen über die Instanz mit der ID <b>InstanzID</b>. Sollte die Instanz nicht vorhanden sein, wird eine Warnung generiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/ips-getinstance/ | |
| * @returns array <p>Folgende Informationen stehen als key => value Paare zur Verfügung:</p> | |
| * @param int $InstanceID <p>Die zu zeigende InstanzID</p> | |
| */ | |
| function IPS_GetInstance(int $InstanceID) { | |
| } | |
| /** | |
| * IPS_GetInstanceDataFlowStatistics | |
| * | |
| * @returns array | |
| */ | |
| function IPS_GetInstanceDataFlowStatistics() { | |
| } | |
| /** | |
| * liefert die ID einer Instanz anhand des Namens | |
| * | |
| * <p>Die Funktion versucht die ID der Instanz mit dem Namen <b>InstanzName</b>, deren übergeordnetes Objekt die ID <b>ÜbergeordneteID</b> besitzt, zu ermitteln. Es wird die ID der ersten gefundenen Instanz verwendet, deren Name mit <b>InstanzName</b> übereinstimmt. Falls eine solche Instanz gefunden wurde, wird deren ID zurückgemeldet, andernfalls FALSE.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/ips-getinstanceidbyname/ | |
| * @returns int <p>ID der gefundenen Instanz, sonst FALSE</p> | |
| * @param string $Name <p>Zu suchender InstanzName</p> | |
| * @param int $ParentID <p>Objekt, in deren direkten Unterobjekten gesucht werden soll</p> | |
| */ | |
| function IPS_GetInstanceIDByName(string $Name, int $ParentID) { | |
| } | |
| /** | |
| * liefert eine Aufstellung aller existierenden Instanzen | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller in IP-Symcon registrierten IPS-Instanzen. Die IDs werden in einem Array aufgelistet. Falls keine Instanz existiert, ist das Array leer.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/ips-getinstancelist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Instanzen in IP-Symcon</p> | |
| */ | |
| function IPS_GetInstanceList() { | |
| } | |
| /** | |
| * liefert alle Instanzen die von einer bestimmten ModulID sind | |
| * | |
| * <p>Die Funktion gibt alle Instanzen, die der angegebenen ModulID (GUID) entsprechen, in einem Array zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/ips-getinstancelistbymoduleid/ | |
| * @returns array <p>Ein Array von Integer-Werten aller gefundenen IDs</p> | |
| * @param string $ModuleID <p>GUID</p> | |
| */ | |
| function IPS_GetInstanceListByModuleID(string $ModuleID) { | |
| } | |
| /** | |
| * liefert eine Liste aller Instanzen eines bestimmten Typs | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller Instanzen eines bestimmten <b>ModulTyps</b>. Die IDs werden in einem Array aufgelistet. Falls keine Instanz des angeforderten Typs existiert, ist das Array leer.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/ips-getinstancelistbymoduletype/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Instanzen vom Typ <b>InstanzTyp</b> in IP-Symcon</p> | |
| * @param int $ModuleType <li>0Kern</li><li>1I/O</li><li>2Splitter</li><li>3Geräte</li><li>4Konfigurator</li><li>5Discovery</li><li>6Visualisierung</li> | |
| * enum[0=mtCore, 1=mtIO, 2=mtSplitter, 3=mtDevice, 4=mtConfigurator, 5=mtDiscovery, 6=mtVisualization] | |
| */ | |
| function IPS_GetInstanceListByModuleType(int $ModuleType) { | |
| } | |
| /** | |
| * IPS_GetInstanceMessageQueueSize | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetInstanceMessageQueueSize() { | |
| } | |
| /** | |
| * IPS_GetInstanceMessageStatistics | |
| * | |
| * @returns array | |
| */ | |
| function IPS_GetInstanceMessageStatistics() { | |
| } | |
| /** | |
| * liefert die Architektur für die IP-Symcon erstellt wurde | |
| * | |
| * <p>Die Funktion liefert einen String mit der Architektur für die IP-Symcon erstellt wurde</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getkernelarchitecture/ | |
| * @returns string <p>Die Architektur für die IP-Symcon erstellt wurde</p> | |
| */ | |
| function IPS_GetKernelArchitecture() { | |
| } | |
| /** | |
| * liefert das Datum der Erstellung des Kernels | |
| * | |
| * <p>Die Funktion liefert einen Integerwert, welcher als UnixTimeStamp das Erstelldatum des Kernels ausgibt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getkerneldate/ | |
| * @returns int <p>Das Erstelldatum in UnixTimeStamp</p> | |
| */ | |
| function IPS_GetKernelDate() { | |
| } | |
| /** | |
| * liefert den Pfad zum IP-Symcon Programmverzeichnis | |
| * | |
| * <p>Die Funktion liefert einen String mit dem vollständigen Pfad zum IP-Symcon Programmverzeichnis (Settings, Skripte, Medien...). Je nach Betriebssystem enthält der Pfad ein abschließendes Slash (“/”) oder Backslash (“\”).</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getkerneldir/ | |
| * @returns string <p>Der vollständige Pfad zum IP-Symcon Programmverzeichnis</p> | |
| */ | |
| function IPS_GetKernelDir() { | |
| } | |
| /** | |
| * liefert den Pfad zum IP-Symcon Installationsverzeichnis | |
| * | |
| * <p>Die Funktion liefert einen String mit dem vollständigen Pfad zu den IP-Symcon Installationsverzeichnis. Je nach Betriebssystem enthält der Pfad ein abschließendes Slash (“/”) oder Backslash (“\”).</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getkerneldirex/ | |
| * @returns string <p>Der vollständige Pfad zum IP-Symcon Installationsverzeichnis</p> | |
| */ | |
| function IPS_GetKernelDirEx() { | |
| } | |
| /** | |
| * Liefert freien/verfügbaren/gesamt Speicherplatz auf dem Laufwerk, auf dem alle Daten von IP-Symcon gespeichert werden | |
| * | |
| * <p>Die Funktion liefert ein Array mit den Keys Total/Free/Available. Diese geben den gesamten/freien/verfügbaren Speicherplatz von dem Laufwerk an, auf dem alle Daten von IP-Symcon gespeichert werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getkerneldirspace/ | |
| * @returns array <p>Liefert gesamten/freien/verfügbaren Speicherplatz</p> | |
| */ | |
| function IPS_GetKernelDirSpace() { | |
| } | |
| /** | |
| * liefert das Betriebssystem auf dem IP-Symcon läuft | |
| * | |
| * <p>Die Funktion liefert einen String mit dem Betriebssystem auf dem der IP-Symcon Server läuft</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getkernelplatform/ | |
| * @returns string <p>Das Betriebssystem auf dem IP-Symcon läuft</p> | |
| */ | |
| function IPS_GetKernelPlatform() { | |
| } | |
| /** | |
| * liefert eine eindeutige Revisionskennung | |
| * | |
| * <p>Die Funktion liefert einen String mit einer eindeutigen Revisionskennung.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getkernelrevision/ | |
| * @returns string <p>Eindeutige Revisionskennung</p> | |
| */ | |
| function IPS_GetKernelRevision() { | |
| } | |
| /** | |
| * liefert den Runlevel des Kernels | |
| * | |
| * <p>Die Funktion liefert den Runlevel des Systems zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getkernelrunlevel/ | |
| * @returns int <p>Runlevel des Kernels.</p> | |
| */ | |
| function IPS_GetKernelRunlevel() { | |
| } | |
| /** | |
| * liefert den Zeitpunkt, an dem IP-Symcon gestartet wurde | |
| * | |
| * <p>Die Funktion liefert Datum und Uhrzeit des Startzeitpunkts von IP-Symcon als Unix Timestamp.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getkernelstarttime/ | |
| * @returns int <p>Zeitpunkt, an dem IP-Symcon gestartet wurde</p> | |
| */ | |
| function IPS_GetKernelStartTime() { | |
| } | |
| /** | |
| * liefert die Versionsnummer des verwendeten Kernels | |
| * | |
| * <p>Die Funktion liefert einen String mit der Nummer der IP-Symcon Programmversion. Durch Abfrage der Programmversion kann entschieden werden, ob ein Skript unter der gemeldeten Version lauffähig ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getkernelversion/ | |
| * @returns string <p>Programmversion. Major/Minorversion durch Punkt (".") getrennt.</p> | |
| */ | |
| function IPS_GetKernelVersion() { | |
| } | |
| /** | |
| * IPS_GetLibraries | |
| * | |
| * @returns array | |
| * @param array $LibraryIDs | |
| */ | |
| function IPS_GetLibraries(array $LibraryIDs) { | |
| } | |
| /** | |
| * gibt Details zu einer Bibliothek | |
| * | |
| * <p>Die Funktion liefert ein Array mit Informationen über die Bibliothek mit der GUID <b>BibliothekID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/modulverwaltung/ips-getlibrary/ | |
| * @returns array <p>Folgende Informationen stehen als <b>key => value</b> Paare zur Verfügung:</p> | |
| * @param string $LibraryID <p>Die zu zeigende BibliothekID (GUIDs)</p> | |
| */ | |
| function IPS_GetLibrary(string $LibraryID) { | |
| } | |
| /** | |
| * liefert eine Liste der Bibliotheken | |
| * | |
| * <p>Die Funktion ermittelt die GUIDs aller in IP-Symcon verfügbaren Bibliotheken. Die IDs werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/modulverwaltung/ips-getlibrarylist/ | |
| * @returns array <p>Ein Array von String-Werten aller GUIDs der Bibliotheken in IP-Symcon</p> | |
| */ | |
| function IPS_GetLibraryList() { | |
| } | |
| /** | |
| * gibt eine Liste der Module einer Bibliothek | |
| * | |
| * <p>Die Funktion ermittelt die GUIDs der verfügbaren Module in einer angegebenen Bibliothek. Die IDs werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/modulverwaltung/ips-getlibrarymodules/ | |
| * @returns array <p>Ein Array von String-Werten aller GUIDs der Module in einer Bibliothek in IP-Symcon</p> | |
| * @param string $LibraryID <p>Die zu zeigende BibliothekID</p> | |
| */ | |
| function IPS_GetLibraryModules(string $LibraryID) { | |
| } | |
| /** | |
| * IPS_GetLicensee | |
| * | |
| * @returns string | |
| */ | |
| function IPS_GetLicensee() { | |
| } | |
| /** | |
| * IPS_GetLimitDemo | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetLimitDemo() { | |
| } | |
| /** | |
| * IPS_GetLimitFeatures | |
| * | |
| * @returns array | |
| */ | |
| function IPS_GetLimitFeatures() { | |
| } | |
| /** | |
| * IPS_GetLimitServer | |
| * | |
| * @returns string | |
| */ | |
| function IPS_GetLimitServer() { | |
| } | |
| /** | |
| * IPS_GetLimitVariables | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetLimitVariables() { | |
| } | |
| /** | |
| * IPS_GetLimitWebFront | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetLimitWebFront() { | |
| } | |
| /** | |
| * liefert umfassende Informationen über einen Link | |
| * | |
| * <p>Die Funktion liefert ein Array mit Informationen über den Link mit der ID <b>LinkID</b>. Sollte der Link nicht vorhanden sein, wird eine Warnung generiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/linkverwaltung/ips-getlink/ | |
| * @returns array <p>Folgende Informationen stehen als <b>key => value</b> Paare zur verfügung:</p> | |
| * @param int $LinkID <p>Die zu zeigende LinkID</p> | |
| */ | |
| function IPS_GetLink(int $LinkID) { | |
| } | |
| /** | |
| * ermittelt die ID eines Links anhand des Namens | |
| * | |
| * <p>Die Funktion versucht die ID des Links mit dem Namen <b>LinkName</b>, deren übergeordnetes Objekt die ID <b>ÜbergeordneteID</b> besitzt, zu ermitteln. Es wird die ID des ersten gefundenen Links verwendet, deren Name mit <b>LinkName</b> übereinstimmt. Falls ein solcher Link gefunden wurde, wird deren ID zurückgemeldet, andernfalls FALSE.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/linkverwaltung/ips-getlinkidbyname/ | |
| * @returns int <p>ID des gefundenen Links, sonst FALSE</p> | |
| * @param string $Name <p>Zu suchender LinkName</p> | |
| * @param int $ParentID <p>Objekt, in deren direkten Unterobjekten gesucht werden soll</p> | |
| */ | |
| function IPS_GetLinkIDByName(string $Name, int $ParentID) { | |
| } | |
| /** | |
| * liefert eine Liste aller existierenden Links | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller in IP-Symcon eingerichteten Links . Die IDs werden in einem Array aufgelistet. Falls kein Link existiert, ist das Array leer.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/linkverwaltung/ips-getlinklist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Links in IP-Symcon</p> | |
| */ | |
| function IPS_GetLinkList() { | |
| } | |
| /** | |
| * IPS_GetLiveUpdateVersion | |
| * | |
| * @returns string | |
| */ | |
| function IPS_GetLiveUpdateVersion() { | |
| } | |
| /** | |
| * liefert den kompletten Pfad des Objekts | |
| * | |
| * <p>Diese Funktion dient dazu den kompletten Pfad inklusive Namen eines Objektes zu erhalten</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-getlocation/ | |
| * @returns string <p>Pfad/Name des Objekts im logischen Objektbaum</p> | |
| * @param int $ID <p>ID für die der Pfad/Namen erstellt werden soll</p> | |
| */ | |
| function IPS_GetLocation(int $ID) { | |
| } | |
| /** | |
| * liefert den Pfad zum IP-Symcon Logverzeichnis | |
| * | |
| * <p>Die Funktion liefert einen String mit dem vollständigen Pfad zum IP-Symcon Logverzeichnis. Je nach Betriebssystem enthält der Pfad ein abschließendes Slash (“/”) oder Backslash (“\”).</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getlogdir/ | |
| * @returns string <p>Der vollständige Pfad zum IP-Symcon Logverzeichnis</p> | |
| */ | |
| function IPS_GetLogDir() { | |
| } | |
| /** | |
| * liefert umfassende Information über ein bestimmtes Medienobjekt | |
| * | |
| * <p>Die Funktion liefert ein Array mit Informationen über Medien mit der ID <b>MedienID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-getmedia/ | |
| * @returns array <p>Folgende Informationen stehen als <b>key => value</b> Paare zur Verfügung:</p> | |
| * @param int $MediaID <p>Die zu zeigende MedienID</p> | |
| */ | |
| function IPS_GetMedia(int $MediaID) { | |
| } | |
| /** | |
| * liefert den Inhalt eines Medienobjekts | |
| * | |
| * <p>Diese Funktion liefert den Base64 kodierten Inhalt für das Medienobjekt mit der ID <b>MedienID</b>. Dabei wird der Inhalt aus der im Medienobjekt definierten Datei ausgelesen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-getmediacontent/ | |
| * @returns string <p>Der Inhalt des Medienobjekts in Base64 kodiert</p> | |
| * @param int $MediaID <p>ID des Medienobjekts, dessen Inhalt geliefert werden soll</p> | |
| */ | |
| function IPS_GetMediaContent(int $MediaID) { | |
| } | |
| /** | |
| * ermittelt die ID eines Medienobjekts anhand der Datei | |
| * | |
| * <p>Die Funktion versucht, die ID von Medien mit dem Pfad <b>MedienPfad</b> zu finden. Sollte der MediePfad in IP-Symcon nicht vorhanden sein, wird eine Warnung generiert. Diese kann mit dem @ Operator abgefangen werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-getmediaidbyfile/ | |
| * @returns int <p>ID des gefundenen Medienobjekts, sonst 0 und Warning</p> | |
| * @param string $FilePath <p>Relativer MedienPfad vom KernelDir gesehen</p> | |
| */ | |
| function IPS_GetMediaIDByFile(string $FilePath) { | |
| } | |
| /** | |
| * ermittelt die ID eines Medienobjekts anhand des Namens | |
| * | |
| * <p>Die Funktion versucht die ID von Median mit dem Namen <b>MediaName</b>, dessen übergeordnetes Objekt die ID <b>ÜbergeordneteID</b> besitzt, zu ermitteln. Es wird die ID des ersten gefundenen Medien verwendet, dessen Name mit <b>MediaName</b> übereinstimmt. Falls ein solches Medium gefunden wurde, wird dessen ID zurückgemeldet, andernfalls FALSE.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-getmediaidbyname/ | |
| * @returns int <p>ID des gefundenen Medienobjekts, sonst FALSE</p> | |
| * @param string $Name <p>Zu suchender MedienName</p> | |
| * @param int $ParentID <p>Objekt, in deren direkten Unterobjekten gesucht werden soll</p> | |
| */ | |
| function IPS_GetMediaIDByName(string $Name, int $ParentID) { | |
| } | |
| /** | |
| * liefert eine Liste aller Medienobjekte im MedienPool | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller im MedienPool registrierten Medienobjekte. Die IDs werden in einem Array aufgelistet. Falls kein Medienobjekt existiert, ist das Array leer.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-getmedialist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Medienobjekte in IP-Symcon</p> | |
| */ | |
| function IPS_GetMediaList() { | |
| } | |
| /** | |
| * liefert eine Liste aller Medienobjekte eines bestimmten Typs | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller im MedienPool registrierten Medienobjekte eines bestimmten <b>MedienTyps</b>. Die IDs werden in einem Array aufgelistet. Falls kein Medienobjekt des angeforderten Typs existiert, ist das Array leer.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-getmedialistbytype/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Medienobjekt vom Typ <b>MedienTyp</b> in IP-Symcon</p> | |
| * @param int $MediaType <li>0IPSView Formular</li><li>1Image Objekt</li><li>2Sound Objekt</li><li>3Stream Objekt</li><li>4Chart Objekt</li><li>5Dokument Objekt</li> | |
| * enum[0=mtForm, 1=mtImage, 2=mtSound, 3=mtStream, 4=mtChart, 5=mtDocument] | |
| */ | |
| function IPS_GetMediaListByType(int $MediaType) { | |
| } | |
| /** | |
| * gibt Details zu einem Modul | |
| * | |
| * <p>Die Funktion liefert ein Array mit Informationen über das Modul mit der GUID <b>ModulID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/modulverwaltung/ips-getmodule/ | |
| * @returns array <p>Folgende Informationen stehen als <b>key => value</b> Paare zur Verfügung:</p> | |
| * @param string $ModuleID <p>Die zu zeigende ModulID (GUIDs)</p> | |
| */ | |
| function IPS_GetModule(string $ModuleID) { | |
| } | |
| /** | |
| * gibt eine Liste aller Module | |
| * | |
| * <p>Die Funktion ermittelt die GUIDs aller in IP-Symcon verfügbaren Module. Die IDs werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/modulverwaltung/ips-getmodulelist/ | |
| * @returns array <p>Ein Array von String-Werten aller GUIDs der Module in IP-Symcon</p> | |
| */ | |
| function IPS_GetModuleList() { | |
| } | |
| /** | |
| * gibt eine Liste aller Module des typs | |
| * | |
| * <p>Die Funktion ermittelt die GUIDs aller in IP-Symcon verfügbaren Module des Typs <b>ModulTyp</b>. Die IDs werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/modulverwaltung/ips-getmodulelistbytype/ | |
| * @returns array <p>Ein Array von String-Werten aller GUIDs der Module in IP-Symcon mit dem angegebenen Typ</p> | |
| * @param int $ModuleType <li>0Kern</li><li>1I/O</li><li>2Splitter</li><li>3Gerät</li><li>4Konfigurator</li><li>5Discovery</li><li>6Visualisierung</li> | |
| * enum[0=mtCore, 1=mtIO, 2=mtSplitter, 3=mtDevice, 4=mtConfigurator, 5=mtDiscovery, 6=mtVisualization] | |
| */ | |
| function IPS_GetModuleListByType(int $ModuleType) { | |
| } | |
| /** | |
| * IPS_GetModules | |
| * | |
| * @returns array | |
| * @param array $ModuleIDs | |
| */ | |
| function IPS_GetModules(array $ModuleIDs) { | |
| } | |
| /** | |
| * liefert den Namen des Objekts | |
| * | |
| * <p>Die Funktion gibt den Namen eines Objektes zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-getname/ | |
| * @returns string <p>Name des Objekts im logischen Objektbaum</p> | |
| * @param int $ID <p>ID für die der Namen zurückgegeben werden soll</p> | |
| */ | |
| function IPS_GetName(int $ID) { | |
| } | |
| /** | |
| * liefert umfassende Informationen über ein Objekt | |
| * | |
| * <p>Die Funktion liefert ein Array mit Informationen über das Objekt mit der ID <b>ObjektID</b>. Sollte das Objekt nicht vorhanden sein, wird eine Warnung generiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-getobject/ | |
| * @returns array <p>Folgende Informationen stehen als <b>key => value</b> Paare zur Verfügung:</p> | |
| * @param int $ID <p>Die zu zeigende ObjektID</p> | |
| */ | |
| function IPS_GetObject(int $ID) { | |
| } | |
| /** | |
| * liefert die ID eines Objekts anhand des Identifikators | |
| * | |
| * <p>Die Funktion versucht die ID des Objekts mit dem Identifikator <b>ObjektIdent</b>, dessen übergeordnetes Objekt die ID <b>ÜbergeordneteID</b> besitzt, zu ermitteln. Falls ein solches Objekt gefunden wurde, wird dessen ID zurückgegeben, andernfalls FALSE.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-getobjectidbyident/ | |
| * @returns int <p>ID des gefundenen Objekts, sonst FALSE</p> | |
| * @param string $Ident <p>Zu suchender ObjektIdentifikator</p> | |
| * @param int $ParentID <p>Objekt, in dessen direkten Unterobjekten gesucht werden soll</p> | |
| */ | |
| function IPS_GetObjectIDByIdent(string $Ident, int $ParentID) { | |
| } | |
| /** | |
| * liefert die ID eines Objekts anhand des Namens | |
| * | |
| * <p>Die Funktion versucht die ID des Objekts mit dem Namen <b>ObjektName</b>, dessen übergeordnetes Objekt die ID <b>ÜbergeordneteID</b> besitzt, zu ermitteln. Es wird die ID des ersten gefundenen Objekts verwendet, dessen Name mit <b>ObjektName</b> übereinstimmt. Falls ein solches Objekt gefunden wurde, wird dessen ID zurückgemeldet, andernfalls FALSE.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-getobjectidbyname/ | |
| * @returns int <p>ID des gefundenen Objekts, sonst FALSE</p> | |
| * @param string $Name <p>Zu suchender ObjektName</p> | |
| * @param int $ParentID <p>Objekt, in dessen direkten Unterobjekten gesucht werden soll</p> | |
| */ | |
| function IPS_GetObjectIDByName(string $Name, int $ParentID) { | |
| } | |
| /** | |
| * liefert eine Aufstellung aller existierenden Objekte | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller in IP-Symcon registrierten Objekte. Die IDs werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-getobjectlist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs in IP-Symcon</p> | |
| */ | |
| function IPS_GetObjectList() { | |
| } | |
| /** | |
| * IPS_GetOption | |
| * | |
| * @returns mixed | |
| * @param string $Option | |
| */ | |
| function IPS_GetOption(string $Option) { | |
| } | |
| /** | |
| * IPS_GetOptionEx | |
| * | |
| * @returns array | |
| * @param string $Option | |
| */ | |
| function IPS_GetOptionEx(string $Option) { | |
| } | |
| /** | |
| * IPS_GetOptionList | |
| * | |
| * @returns array | |
| */ | |
| function IPS_GetOptionList() { | |
| } | |
| /** | |
| * liefert die ParentID des Objekts | |
| * | |
| * <p>Die Funktion gibt die ParentID eines Objektes zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-getparent/ | |
| * @returns int <p>ParentID des Objekts im logischen Objektbaum</p> | |
| * @param int $ID <p>ID für die die ParentID zurückgegeben werden soll</p> | |
| */ | |
| function IPS_GetParent(int $ID) { | |
| } | |
| /** | |
| * liest den aktuellen Wert einer Eigenschaft | |
| * | |
| * <p>Die Funktion liest für die <b>InstanzID</b> den Ist-Wert der <b>Eigenschaft</b> ein. Eine genaue Auflistung der möglichen Eigenschaften für die einzelnen Instanzen kann in der Beschreibung der Funktion IPS_SetProperty gefunden werden.<br>Es kann ein neuer Soll-Wert mit IPS_SetProperty übergeben und mit IPS_ApplyChanges übernommen werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/konfiguration/ips-getproperty/ | |
| * @returns mixed <p>Aktueller Wert der Eigenschaft</p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| * @param string $Name <p>Name der Eigenschaft</p> | |
| */ | |
| function IPS_GetProperty(int $InstanceID, string $Name) { | |
| } | |
| /** | |
| * gibt die IDs aller Referenzen wieder | |
| * | |
| * <p>Diese Funktion gibt ein Array der IDs aller referenzierten Objekte der Instanz mit der ID <b>InstanzID</b> wieder. Falls keine Referenz existiert, ist das Array leer. (z.B. das "Archive Control" referenziert alle Variablen dir dort geloggt werden)</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/referenzen/ips-getreferencelist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der referenzierten Objekte</p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| */ | |
| function IPS_GetReferenceList(int $InstanceID) { | |
| } | |
| /** | |
| * IPS_GetReplicationConfiguration | |
| * | |
| * @returns string | |
| */ | |
| function IPS_GetReplicationConfiguration() { | |
| } | |
| /** | |
| * IPS_GetReplicationSyncTime | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetReplicationSyncTime() { | |
| } | |
| /** | |
| * liefert umfassende Informationen über ein Skript | |
| * | |
| * <p>Die Funktion liefert ein Array mit Informationen über das Skript mit der ID <b>SkriptID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-getscript/ | |
| * @returns array <p>Folgende Informationen stehen als <b>key => value</b> Paare zur verfügung:</p> | |
| * @param int $ScriptID <p>Die zu zeigende SkriptID</p> | |
| */ | |
| function IPS_GetScript(int $ScriptID) { | |
| } | |
| /** | |
| * liefert den Inhalt eines Skripts | |
| * | |
| * <p>Diese Funktion liefert den Inhalt für das Skript mit der ID <b>SkriptID</b>. Dabei wird der Inhalt aus der im Skript-Objekt definierten Datei ausgelesen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-getscriptcontent/ | |
| * @returns string <p>Der Inhalt des Skripts</p> | |
| * @param int $ScriptID <p>ID des Skripts, dessen Inhalt geliefert werden soll</p> | |
| */ | |
| function IPS_GetScriptContent(int $ScriptID) { | |
| } | |
| /** | |
| * liefert alle Ereignisse die einem Skript zugeordnet sind | |
| * | |
| * <p>Die Funktion liefert ein Array, dessen Elemente jeweils die IDs zu den Ereignissen des Skripts mit der ID <b>SkriptID</b> enthalten. Die Ereignisse können dann mit der Funktion IPS_GetEvent weiterverarbeitet werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-getscripteventlist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller EreignisIDs, die mit dem Skript <b>SkriptID</b> verknüpft sind</p> | |
| * @param int $ScriptID <p>SkriptID, zu der verknüpfte Ereignisse gesucht werden sollen</p> | |
| */ | |
| function IPS_GetScriptEventList(int $ScriptID) { | |
| } | |
| /** | |
| * ermittelt den Dateinamen zur SkriptID | |
| * | |
| * <p>Die Funktion gibt den Dateinamen vom Skript mit der ID <b>SkriptID</b> zurück. Dadurch kann die Datei z.B. direkt in andere Skripte inkludiert werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-getscriptfile/ | |
| * @returns string <p>Der Dateiname des Skripts</p> | |
| * @param int $ScriptID <p>ID des Skripts, dem der Dateiname zugeordnet werden soll</p> | |
| */ | |
| function IPS_GetScriptFile(int $ScriptID) { | |
| } | |
| /** | |
| * liefert die ID eines Skripts andhand der Datei | |
| * | |
| * <p>Die Funktion versucht die ID des Skripts herausfinden, welches zur Skriptdatei <b>Dateipfad</b> zugeordnet ist. Falls ein solches Skript gefunden wurde, wird dessen ID zurückgemeldet, andernfalls FALSE.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-getscriptidbyfile/ | |
| * @returns int <p>ID des gefundenen Skripts, sonst FALSE</p> | |
| * @param string $FilePath <p>Relativer Dateipfad vom script-Order gesehen</p> | |
| */ | |
| function IPS_GetScriptIDByFile(string $FilePath) { | |
| } | |
| /** | |
| * liefert die ID eines Skripts andhand des Namens | |
| * | |
| * <p>Die Funktion versucht die ID des Skripts mit dem Namen <b>SkriptName</b>, dessen übergeordnetes Objekt die ID <b>ÜbergeordneteID</b> besitzt, zu ermitteln. Es wird die ID des ersten gefundenen Skripts verwendet, dessen Name mit <b>SkriptName</b> übereinstimmt. Falls ein solches Skript gefunden wurde, wird dessen ID zurückgemeldet, andernfalls FALSE.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-getscriptidbyname/ | |
| * @returns int <p>ID des gefundenen Skripts, sonst FALSE</p> | |
| * @param string $Name <p>zu suchender SkriptName</p> | |
| * @param int $ParentID <p>Objekt in deren direkten Unterobjekten gesucht werden soll</p> | |
| */ | |
| function IPS_GetScriptIDByName(string $Name, int $ParentID) { | |
| } | |
| /** | |
| * liefert eine Aufstellung aller existierenden Skripte | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller in IP-Symcon registrierten Skripte. Die IDs werden in einem Array aufgelistet. Falls kein Skript existiert, ist das Array leer.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-getscriptlist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Skripte in IP-Symcon</p> | |
| */ | |
| function IPS_GetScriptList() { | |
| } | |
| /** | |
| * IPS_GetScriptThread | |
| * | |
| * @returns array | |
| * @param int $ThreadID | |
| */ | |
| function IPS_GetScriptThread(int $ThreadID) { | |
| } | |
| /** | |
| * IPS_GetScriptThreadList | |
| * | |
| * @returns array | |
| */ | |
| function IPS_GetScriptThreadList() { | |
| } | |
| /** | |
| * IPS_GetScriptThreads | |
| * | |
| * @returns array | |
| * @param array $ThreadIDs | |
| */ | |
| function IPS_GetScriptThreads(array $ThreadIDs) { | |
| } | |
| /** | |
| * ermittelt den Startwert des ScriptTimers | |
| * | |
| * <p>Die Funktion liefert einen Integer-Wert mit dem Startwert des ScriptTimers des Skripts mit der ID <b>SkriptID</b>. Der Wert wird in Sekunden angegeben. Mit dieser Funktion kann man prüfen, auf welchen Wert der ScriptTimer eines Skripts gesetzt ist und ob dieser korrekt ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-getscripttimer/ | |
| * @returns int <p>Zeit in Sekunden, die der Timer das Skript zyklisch aufruft. (Es ist nicht die Restzeit.)</p> | |
| * @param int $ScriptID <p>ID des Skripts, dessen Timer ausgelesen werden soll</p> | |
| */ | |
| function IPS_GetScriptTimer(int $ScriptID) { | |
| } | |
| /** | |
| * IPS_GetSecurityMode | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetSecurityMode() { | |
| } | |
| /** | |
| * IPS_GetSnapshot | |
| * | |
| * @returns array | |
| */ | |
| function IPS_GetSnapshot() { | |
| } | |
| /** | |
| * IPS_GetSnapshotChanges | |
| * | |
| * @returns array | |
| * @param int $LastTimestamp | |
| */ | |
| function IPS_GetSnapshotChanges(int $LastTimestamp) { | |
| } | |
| /** | |
| * IPS_GetSubscriptionExpiration | |
| * | |
| * @returns int | |
| */ | |
| function IPS_GetSubscriptionExpiration() { | |
| } | |
| /** | |
| * liefert die Sytemsprache des Betriebssystems auf dem IP-Symcon läuft | |
| * | |
| * <p>Die Funktion liefert einen String mit der Systemsprache des Betriebssystems auf dem der IP-Symcon Server läuft zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getsystemlanguage/ | |
| * @returns string <p>Die Systemsprache des Betriebssystems auf dem IP-Symcon läuft</p> | |
| */ | |
| function IPS_GetSystemLanguage() { | |
| } | |
| /** | |
| * IPS_GetTimer | |
| * | |
| * @returns array | |
| * @param int $TimerID | |
| */ | |
| function IPS_GetTimer(int $TimerID) { | |
| } | |
| /** | |
| * IPS_GetTimerList | |
| * | |
| * @returns array | |
| */ | |
| function IPS_GetTimerList() { | |
| } | |
| /** | |
| * IPS_GetTimers | |
| * | |
| * @returns array | |
| * @param array $TimerIDs | |
| */ | |
| function IPS_GetTimers(array $TimerIDs) { | |
| } | |
| /** | |
| * liefert den aktuellen konfigurierten Update-Kanal zurück | |
| * | |
| * <p>Die Funktion liefert einen String mit dem aktuell konfigurierten Update-Kanal zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-getupdatechannel/ | |
| * @returns string <p>aktuell konfigurierter Update-Kanal</p> | |
| */ | |
| function IPS_GetUpdateChannel() { | |
| } | |
| /** | |
| * liefert umfassende Informationen zu einer bestimmten Variablen | |
| * | |
| * <p>Die Funktion liefert ein Array mit Informationen über die Variable mit der ID <b>VariablenID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/ips-getvariable/ | |
| * @returns array <p>Folgende Informationen stehen als <b>key => value</b> Paare zur Verfügung:</p> | |
| * @param int $VariableID <p>Die zu zeigende VariablenID</p> | |
| */ | |
| function IPS_GetVariable(int $VariableID) { | |
| } | |
| /** | |
| * liefert alle Ereignisse die einer Variable zugeordnet sind | |
| * | |
| * <p>Die Funktion liefert ein Array, dessen Elemente jeweils die IDs zu den Ereignissen sind, in der die Variable <b>VariableID</b> verwendet wird. Die Ereignisse können dann mit der Funktion IPS_GetEvent weiterverarbeitet werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/ips-getvariableeventlist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller EreignisIDs, die mit der Variable <b>VariablenID</b> verknüpft sind</p> | |
| * @param int $VariableID <p>VariablenID, zu der verknüpfte Ereignisse gesucht werden sollen</p> | |
| */ | |
| function IPS_GetVariableEventList(int $VariableID) { | |
| } | |
| /** | |
| * liefert die ID einer Variablen anhand des Namens | |
| * | |
| * <p>Die Funktion versucht die ID der Variablen mit dem Namen <b>VariablenName</b>, deren übergeordnetes Objekt die ID <b>ÜbergeordneteID</b> besitzt, zu ermitteln. Es wird die ID der ersten gefundenen Variablen verwendet, deren Name mit <b>VariablenName</b> übereinstimmt. Falls eine solche Variable gefunden wurde, wird deren ID zurückgemeldet, andernfalls FALSE.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/ips-getvariableidbyname/ | |
| * @returns int <p>ID der gefundenen Variable, sonst FALSE</p> | |
| * @param string $Name <p>Zu suchender VariablenName</p> | |
| * @param int $ParentID <p>Objekt, in deren direkten Unterobjekten gesucht werden soll</p> | |
| */ | |
| function IPS_GetVariableIDByName(string $Name, int $ParentID) { | |
| } | |
| /** | |
| * liefert eine Liste aller existierenden Variablen | |
| * | |
| * <p>Die Funktion ermittelt die IDs aller in IP-Symcon registrierten IPS-Variablen. Die IDs werden in einem Array aufgelistet. Falls keine Variable existiert, ist das Array leer.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/ips-getvariablelist/ | |
| * @returns array <p>Ein Array von Integer-Werten aller IDs der Variablen in IP-Symcon</p> | |
| */ | |
| function IPS_GetVariableList() { | |
| } | |
| /** | |
| * liefert umfassende Informationen zu einem bestimmten Variablenprofil | |
| * | |
| * <p>Die Funktion liefert ein Array mit Informationen über das Variableprofil mit dem Namen <b>ProfilName</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-getvariableprofile/ | |
| * @returns array <p>Folgende Informationen stehen als <b>key => value</b> Paare zur Verfügung:</p> | |
| * @param string $ProfileName <p>Name des Variablenprofils</p> | |
| */ | |
| function IPS_GetVariableProfile(string $ProfileName) { | |
| } | |
| /** | |
| * liefert eine Liste aller existierenden Variablenprofile | |
| * | |
| * <p>Die Funktion ermittelt in IP-Symcon vorhandenen Variablenprofile. Die Namen werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-getvariableprofilelist/ | |
| * @returns array <p>Ein Array von String-Werten aller Namen der Variablenprofile</p> | |
| */ | |
| function IPS_GetVariableProfileList() { | |
| } | |
| /** | |
| * liefert eine Liste aller existierenden Variablenprofile eines bestimmten Typs | |
| * | |
| * <p>Die Funktion ermittelt in IP-Symcon vorhandenen Variablenprofile vom Typ <b>Variablentyp</b>. Die Namen werden in einem Array aufgelistet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-getvariableprofilelistbytype/ | |
| * @returns array <p>Ein Array von String-Werten aller Namen der Variablenprofile</p> | |
| * @param int $ProfileType <li>0Sucht vom Typ <b>Boolean</b></li><li>1Sucht vom Typ <b>Integer</b></li><li>2Sucht vom Typ <b>Float</b></li><li>3Sucht vom Typ <b>String</b></li> | |
| * enum[0=vtBoolean, 1=vtInteger, 2=vtFloat, 3=vtString] | |
| */ | |
| function IPS_GetVariableProfileListByType(int $ProfileType) { | |
| } | |
| /** | |
| * prüft, ob eine Konfiguration verändert wurde | |
| * | |
| * <p>Die Funktion überprüft, ob bei einer Instanz Änderungen an der Konfiguration vorgenommen wurden, die als aktuelle Ist-Konfiguration übernommen werden soll.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/konfiguration/ips-haschanges/ | |
| * @returns bool <p><b>TRUE</b>, wenn es Änderungen gibt, sonst <b>FALSE</b></p> | |
| * @param int $InstanceID <p>ID der zu überprüfenden Instanz</p> | |
| */ | |
| function IPS_HasChanges(int $InstanceID) { | |
| } | |
| /** | |
| * prüft, ob Objekt untergeordnete Objekte hat | |
| * | |
| * <p>Die Funktion prüft, ob ein Objekt mit der ID <b>ObjektID</b> untergeordnete Objekte hat.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-haschildren/ | |
| * @returns bool <p><b>TRUE</b>, falls das Objekte Unterobjekte hat, andernfalls <b>FALSE</b></p> | |
| * @param int $ID <p>ID des zu prüfenden Objekts</p> | |
| */ | |
| function IPS_HasChildren(int $ID) { | |
| } | |
| /** | |
| * prüft, ob eine bestimmte Instanz existiert | |
| * | |
| * <p>Die Funktion prüft, ob die Instanz mit der ID <b>InstanzID</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/ips-instanceexists/ | |
| * @returns bool <p>Falls die InstanzID im System existiert, wird <b>TRUE</b> zurückgemeldet, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu prüfenden Instanz</p> | |
| */ | |
| function IPS_InstanceExists(int $InstanceID) { | |
| } | |
| /** | |
| * prüft, ob Objekt einem anderen Objekt untergeordnet ist | |
| * | |
| * <p>Die Funktion prüft, ob ein Objekt mit der ID <b>ObjektID</b> dem Objekt <b>ParentID</b> untergeordnet ist. Ist der Parameter <b>Rekursiv</b> aktiviert, werden alle untergeordneten Objekte auf allen untergeordneten Ebenen überprüft. Andernfalls werden nur die direkt untergeordneten Objekte überprüft.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-ischild/ | |
| * @returns bool <p><b>TRUE</b>, wenn ObjektID Kind von ParentID ist, sonst <b>FALSE</b></p> | |
| * @param int $ID <p>ID des zu prüfenden Objekts</p> | |
| * @param int $ParentID <p>ID des vermeintlichen Elternobjekts</p> | |
| * @param bool $Recursive <p>False, wenn nur eine Ebene geprüft werden soll, sonst True</p> | |
| */ | |
| function IPS_IsChild(int $ID, int $ParentID, bool $Recursive) { | |
| } | |
| /** | |
| * prüft ob eine Bedingung erfüllt ist | |
| * | |
| * <p>Diese Funktion prüft, ob die JSON-codierte Bedingung <b>Bedingung</b> erfüllt ist. Typischerweise wird dies im Kontext eines Moduls mit dem Formularfeld SelectCondition verwendet.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-isconditionpassing/ | |
| * @returns bool <p><b>TRUE</b>, falls die Bedingung erfüllt ist, andernfalls <b>FALSE</b></p> | |
| * @param string $Conditions <p>Eine Liste von JSON-codierten Bedingungen im Format von SelectCondition</p> | |
| */ | |
| function IPS_IsConditionPassing(string $Conditions) { | |
| } | |
| /** | |
| * prüft, ob eine Verbindung zwischen zwei Instanzen möglich ist | |
| * | |
| * <p>Die Funktion ermittelt, ob die Instanz mit der ID <b>ÜbergeordneteID</b> eine valide übergeordnete Instanz zu der Instanz mit der ID <b>InstanzID</b> ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/verbindungen/ips-isinstancecompatible/ | |
| * @returns bool <p><b>TRUE</b>, wenn die Instanz kompatibel sind, sonst <b>FALSE</b></p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| * @param int $ParentInstanceID <p>ID der potentiellen übergeordneten Instanz</p> | |
| */ | |
| function IPS_IsInstanceCompatible(int $InstanceID, int $ParentInstanceID) { | |
| } | |
| /** | |
| * IPS_IsLicenseChangePending | |
| * | |
| * @returns bool | |
| */ | |
| function IPS_IsLicenseChangePending() { | |
| } | |
| /** | |
| * überprüft, ob zwei Modul miteinander Kompatibel sind | |
| * | |
| * <p>Die Funktion ermittelt, ob das Modul mit der GUID <b>ÜbergeordneteID</b> ein valides übergeordnetes Modul des Moduls mit der GUID <b>ModulID</b> ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/modulverwaltung/ips-ismodulecompatible/ | |
| * @returns bool <p><b>TRUE</b>, wenn die Module kompatibel sind, sonst <b>FALSE</b></p> | |
| * @param string $ModuleID <p>GUIDs</p> | |
| * @param string $ParentModuleID <p>GUIDs</p> | |
| */ | |
| function IPS_IsModuleCompatible(string $ModuleID, string $ParentModuleID) { | |
| } | |
| /** | |
| * IPS_IsReplicationActive | |
| * | |
| * @returns bool | |
| */ | |
| function IPS_IsReplicationActive() { | |
| } | |
| /** | |
| * IPS_IsReplicationMaster | |
| * | |
| * @returns bool | |
| */ | |
| function IPS_IsReplicationMaster() { | |
| } | |
| /** | |
| * IPS_IsReplicationOnStandBy | |
| * | |
| * @returns bool | |
| */ | |
| function IPS_IsReplicationOnStandBy() { | |
| } | |
| /** | |
| * IPS_IsSearching | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function IPS_IsSearching(int $InstanceID) { | |
| } | |
| /** | |
| * überprüft, ob Bibliothek existiert | |
| * | |
| * <p>Die Funktion prüft, ob die Bibliothek mit der GUID <b>BibliothekID</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/modulverwaltung/ips-libraryexists/ | |
| * @returns bool <p>Falls die BibliothekID im System existiert, wird <b>TRUE</b> zurückgemeldet, andernfalls <b>FALSE</b>.</p> | |
| * @param string $LibraryID <p>GUIDs</p> | |
| */ | |
| function IPS_LibraryExists(string $LibraryID) { | |
| } | |
| /** | |
| * prüft, ob ein Link bereits existiert | |
| * | |
| * <p>Die Funktion prüft, ob der Link mit der ID <b>LinkID</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/linkverwaltung/ips-linkexists/ | |
| * @returns bool <p>Falls die LinkID im System existiert, wird <b>TRUE</b> zurückgemeldet, andernfalls <b>FALSE</b>.</p> | |
| * @param int $LinkID <p>ID der zu prüfenden Links</p> | |
| */ | |
| function IPS_LinkExists(int $LinkID) { | |
| } | |
| /** | |
| * schreibt eine benutzerdefinierte Meldung in die Log-Datei | |
| * | |
| * <p>Die Funktion schreibt unter Angabe des Absenders <b>Sender</b> den String <b>Meldung</b> in die IP-Symcon Log-Datei. Der String <b>Sender</b> gibt dabei den Verursacher der Meldung an, z.B. den Namen des Skripts. Die Ausgabe der Meldung kann als “Custom Message” live im Meldungsfenster beobachtet werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/programminformationen/ips-logmessage/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $Sender <p>Der angezeigte Absender der Meldung</p> | |
| * @param string $Message <p>Die anzuzeigende Meldung</p> | |
| */ | |
| function IPS_LogMessage(string $Sender, string $Message) { | |
| } | |
| /** | |
| * IPS_MakeCrash | |
| * | |
| * @returns bool | |
| */ | |
| function IPS_MakeCrash() { | |
| } | |
| /** | |
| * IPS_MakeLeak | |
| * | |
| * @returns bool | |
| */ | |
| function IPS_MakeLeak() { | |
| } | |
| /** | |
| * prüft, ob sich ein bestimmtes Medienobjekt bereits im MedienPool befindet | |
| * | |
| * <p>Die Funktion prüft, ob das Medienobjekt mit der ID <b>MediaID</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-mediaexists/ | |
| * @returns bool <p>Falls die MedienID im System existiert, wird <b>TRUE</b> zurückgemeldet, andernfalls <b>FALSE</b>.</p> | |
| * @param int $MediaID <p>ID des zu rüfenden Medienobjekts</p> | |
| */ | |
| function IPS_MediaExists(int $MediaID) { | |
| } | |
| /** | |
| * überprüft, ob Modul existiert | |
| * | |
| * <p>Die Funktion prüft, ob das Modul mit der GUID <b>ModulID</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/modulverwaltung/ips-moduleexists/ | |
| * @returns bool <p>Falls die ModulID im System existiert, wird <b>TRUE</b> zurückgemeldet, andernfalls <b>FALSE</b></p> | |
| * @param string $ModuleID <p>GUIDs</p> | |
| */ | |
| function IPS_ModuleExists(string $ModuleID) { | |
| } | |
| /** | |
| * prüft, ob ein bestimmtes Objekt existiert | |
| * | |
| * <p>Die Funktion prüft, ob ein Objekt mit der ID <b>ObjektID</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-objectexists/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ID <p>Die zu prüfende ObjektID</p> | |
| */ | |
| function IPS_ObjectExists(int $ID) { | |
| } | |
| /** | |
| * IPS_RequestAction | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $VariableIdent | |
| * @param mixed $Value | |
| */ | |
| function IPS_RequestAction(int $InstanceID, string $VariableIdent, mixed $Value) { | |
| } | |
| /** | |
| * setzt eine veränderte Konfiguration auf die aktuelle zurück | |
| * | |
| * <p>Die Funktion überschreibt die neue Soll-Konfiguration durch die aktuelle Ist-Konfiguration.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/konfiguration/ips-resetchanges/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu ändernden Instanz</p> | |
| */ | |
| function IPS_ResetChanges(int $InstanceID) { | |
| } | |
| /** | |
| * führt eine einzelne Aktion aus | |
| * | |
| * <p>Die Funktion veranlasst die Ausführung der Aktion mit der ID <b>AktionsID</b> und den Parametern <b>AktionsParameter</b>. Die Ausführung läuft parallel (gleichzeitig) zum aufrufenden Skript.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-runaction/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ActionID <p>ID der auszuführenden Aktion</p> | |
| * @param array $Parameters <p>Liste der Parameter der auszuführenden Aktion</p> | |
| */ | |
| function IPS_RunAction(string $ActionID, array $Parameters) { | |
| } | |
| /** | |
| * führt eine einzelne Aktion aus und wartet auf das Resultat | |
| * | |
| * <p>Die Funktion veranlasst die Ausführung der Aktion mit der ID <b>AktionsID</b> und den Parametern <b>AktionsParameter</b>. Die Aktion wird ausgeführt und wartet auf das Ende um ggfs. eine Fehlermeldung zurückzugeben. Lief die Ausführung fehlerfrei, so gibt die Funktion einen leeren String zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-runactionwait/ | |
| * @returns string <p>Fehlermeldung der Ausführung</p> | |
| * @param string $ActionID <p>ID der auszuführenden Aktion</p> | |
| * @param array $Parameters <p>Liste der Parameter der auszuführenden Aktion</p> | |
| */ | |
| function IPS_RunActionWait(string $ActionID, array $Parameters) { | |
| } | |
| /** | |
| * startet ein anderes IP-Symcon Skript | |
| * | |
| * <p>Die Funktion veranlasst den Start des Skripts mit der ID <b>SkriptID</b>. Das aufgerufene Skript läuft parallel (gleichzeitig) zum aufrufenden Skript.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-runscript/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ScriptID <p>Eindeutige ID des Skriptes</p> | |
| */ | |
| function IPS_RunScript(int $ScriptID) { | |
| } | |
| /** | |
| * startet ein anderes IP-Symcon Skript und übergibt Variablen | |
| * | |
| * <p>Die Funktion veranlasst den Start des Skripts mit der ID <b>SkriptID</b> und übergibt dabei das Array Parameter als Argument. Das aufgerufene Skript läuft parallel (gleichzeitig) zum aufrufenden Skript. Auch hier gelten die bei IPS_RunScript beschriebenen Hinweise.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-runscriptex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ScriptID <p>Eindeutige ID des Skriptes</p> | |
| * @param array $Parameters <p>Key (string) => Value (variant) Paar auf die im neu ausgeführten Skript zu gegriffen werden kann.</p> | |
| */ | |
| function IPS_RunScriptEx(int $ScriptID, array $Parameters) { | |
| } | |
| /** | |
| * startet einen Text als IP-Symcon Skript | |
| * | |
| * <p>Die Funktion startet ein Skript mit dem Inhalt <b>SkriptText</b>. Es ist nicht nötig PHP-Tags mit anzugeben.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-runscripttext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ScriptText <p>String welcher als Skript aufgerufen werden soll.</p> | |
| */ | |
| function IPS_RunScriptText(string $ScriptText) { | |
| } | |
| /** | |
| * startet einen Text als IP-Symcon Skript und übergibt Variablen | |
| * | |
| * <p>Die Funktion startet ein Skript mit dem Inhalt <b>SkriptText</b>. Es ist nicht nötig PHP-Tags mit anzugeben.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-runscripttextex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ScriptText <p>String welcher als Skript aufgerufen werden soll.</p> | |
| * @param array $Parameters <p>Key (string) => Value (variant) Paar auf die im neu ausgeführten Skript zugegriffen werden kann.</p> | |
| */ | |
| function IPS_RunScriptTextEx(string $ScriptText, array $Parameters) { | |
| } | |
| /** | |
| * startet einen Text als IP-Symcon Skript | |
| * | |
| * <p>Die Funktion startet ein Skript mit dem Inhalt <b>SkriptText</b> und wartet auf das Ende der Skriptausführung, um das Resultat als Rückgabewert zu übergeben. Es ist nicht nötig PHP-Tags mit anzugeben.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-runscripttextwait/ | |
| * @returns string <p>Resultat des ausgeführten Skripts</p> | |
| * @param string $ScriptText <p>String welcher als Skript aufgerufen werden soll.</p> | |
| */ | |
| function IPS_RunScriptTextWait(string $ScriptText) { | |
| } | |
| /** | |
| * startet einen Text als IP-Symcon Skript und übergibt Variablen | |
| * | |
| * <p>Die Funktion startet ein Skript mit dem Inhalt <b>SkriptText</b>, übergibt dabei das Array Parameter als Argument und wartet auf das Ende der Skriptausführung, um das Resultat als Rückgabewert zu übergeben.. Es ist nicht nötig PHP-Tags mit anzugeben.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-runscripttextwaitex/ | |
| * @returns string <p>Resultat des ausgeführten Skripts</p> | |
| * @param string $ScriptText <p>String welcher als Skript aufgerufen werden soll.</p> | |
| * @param array $Parameters <p>Key (string) => Value (variant) Paar auf die im neu ausgeführten Skript zugegriffen werden kann.</p> | |
| */ | |
| function IPS_RunScriptTextWaitEx(string $ScriptText, array $Parameters) { | |
| } | |
| /** | |
| * startet ein anderes IP-Symcon Skript und wartet auf das Resultat | |
| * | |
| * <p>Die Funktion veranlasst den Start des Skripts mit der ID <b>SkriptID</b>. Das Skript wird aufgerufen und wartet auf das Ende, um das Resultat als Rückgabewert zu übergeben. Auch hier gelten die bei IPS_RunScript beschriebenen Hinweise.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-runscriptwait/ | |
| * @returns string <p>Resultat des ausgeführten Skripts</p> | |
| * @param int $ScriptID <p>Eindeutige ID des Skriptes</p> | |
| */ | |
| function IPS_RunScriptWait(int $ScriptID) { | |
| } | |
| /** | |
| * startet ein anderes IP-Symcon Skript und übergibt Variablen | |
| * | |
| * <p>Die Funktion veranlasst den Start des Skripts mit der ID <b>SkriptID</b>, übergibt dabei das Array Parameter als Argument und wartet auf das Ende der Skriptausführung, um das Resultat als Rückgabewert zu übergeben. Auch hier gelten die bei IPS_RunScript beschriebenen Hinweise.<br>Das Array <b>Parameter</b> kann beliebig viele <b>“Key => Value”</b> Paare enthalten (siehe PHP Arrays). Jedes Paar erscheint im aufgerufenen Skript als Variable <b>Key</b> mit ihrem Inhalt <b>Value</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-runscriptwaitex/ | |
| * @returns string <p>Resultat des ausgeführten Skripts</p> | |
| * @param int $ScriptID <p>Eindeutige ID des Skriptes</p> | |
| * @param array $Parameters <p>Key (string) => Value (variant) Paar auf die im neu ausgeführten Skript zugegriffen werden kann.</p> | |
| */ | |
| function IPS_RunScriptWaitEx(int $ScriptID, array $Parameters) { | |
| } | |
| /** | |
| * prüft, ob ein bestimmtes Skript existiert | |
| * | |
| * <p>Die Funktion prüft, ob das Skript mit der ID <b>SkriptID</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-scriptexists/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ScriptID <p>ID der zu prüfenden Skripte</p> | |
| */ | |
| function IPS_ScriptExists(int $ScriptID) { | |
| } | |
| /** | |
| * IPS_ScriptThreadExists | |
| * | |
| * @returns bool | |
| * @param int $ThreadID | |
| */ | |
| function IPS_ScriptThreadExists(int $ThreadID) { | |
| } | |
| /** | |
| * erlaubt die Synchronisation mit anderen, gleichzeitig laufenden Skripts | |
| * | |
| * <p>Diese Funktion setzt ein <b>Semaphor</b> (ein Zeichen mit Signalwirkung), das dazu verwendet werden kann, einen Teil des Skriptes exklusiv auszuführen und diesen vor konkurrierenden Skripten zu schützen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-semaphoreenter/ | |
| * @returns bool <p><b>TRUE</b>, wenn die Semaphore betreten wurde. <b>FALSE</b>, wenn die Semaphore vor Ablauf der Wartezeit nicht betreten werden konnte</p> | |
| * @param string $Name <p>Name, der die Semaphore beschreibt</p> | |
| * @param int $Milliseconds <p>Millisekunden, die gewartet wird, bis die Funktion abbricht</p> | |
| */ | |
| function IPS_SemaphoreEnter(string $Name, int $Milliseconds) { | |
| } | |
| /** | |
| * erlaubt die Synchronisation mit anderen, gleichzeitig laufenden Skripts | |
| * | |
| * <p>Diese Funktion löscht das zuvor mit IPS_SemaphoreEnter gesetzte Semaphor.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-semaphoreleave/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $Name <p>Name, der die Semaphore beschreibt.</p> | |
| */ | |
| function IPS_SemaphoreLeave(string $Name) { | |
| } | |
| /** | |
| * IPS_SendDebug | |
| * | |
| * @returns bool | |
| * @param int $SenderID | |
| * @param string $Message | |
| * @param string $Data | |
| * @param int $Format | |
| * enum[0=dfText, 1=dfBinary] | |
| */ | |
| function IPS_SendDebug(int $SenderID, string $Message, string $Data, int $Format) { | |
| } | |
| /** | |
| * sendet eine Mitteilung, dass ein Medienobjekt sich geändert hat | |
| * | |
| * <p>Die Funktion sendet eine Mitteilung, dass sich das Medienobjekt mit der ID <b>MedienID</b> verändert hat. Diese Nachricht wird z.B. verwendet, um ein Bild/Forumular zu aktualisieren.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-sendmediaevent/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $MediaID <p>ID des zu prüfenden Medienobjekts</p> | |
| */ | |
| function IPS_SendMediaEvent(int $MediaID) { | |
| } | |
| /** | |
| * setzt eine neue Konfiguration | |
| * | |
| * <p>Die Funktion setzt für die <b>InstanzID</b> die Konfiguration <b>Konfiguration</b> ein.<br>Um diese zu speichern und wirksam werden zu lassen, muss im Anschluss IPS_ApplyChanges ausgeführt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/konfiguration/ips-setconfiguration/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| * @param string $Configuration <p>Die Konfiguration als String</p> | |
| */ | |
| function IPS_SetConfiguration(int $InstanceID, string $Configuration) { | |
| } | |
| /** | |
| * Setzt ein Objekt für das WebFront inaktiv | |
| * | |
| * <p>Die Funktion setzt das Objekt mit der ID <b>ObjektID</b> inaktiv, d.h. es ist noch in den Visualisierungen sichtbar aber nicht mehr klick-/nutzbar.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-setdisabled/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ID <p>ID des zu verändernden Objekts</p> | |
| * @param bool $Disabled <p>TRUE wenn das Objekt inaktiv gesetzt werden soll; FALSE wenn es aktiv gesetzt werden soll.</p> | |
| */ | |
| function IPS_SetDisabled(int $ID, bool $Disabled) { | |
| } | |
| /** | |
| * setzt die auszuführende Aktion | |
| * | |
| * <p>Die Aktion des Ereignisses mit der ID <b>EreignisID</b> wird auf die Aktion mit der ID <b>AktionsID</b> gesetzt. Die Parameter dieser Aktion werden als <b>AktionsParameter</b> definiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventaction/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param string $ActionID <p>ID der auszuführenden Aktion</p> | |
| * @param array $ActionParameters <p>Liste der Parameter der auszuführenden Aktion</p> | |
| */ | |
| function IPS_SetEventAction(int $EventID, string $ActionID, array $ActionParameters) { | |
| } | |
| /** | |
| * aktiviert/deaktiviert ein Ereignis | |
| * | |
| * <p>Nach dem Aktiveren/Deaktiveren kann über IPS_GetEvent der neue Status ausgelesen werden. Bei aktiven, zyklischen Ereignissen ist es möglich, den nächsten Ausführungszeitpunkt zu bestimmen. Bei einem deaktivierten Ereignis ist der NextRun Wert gleich null.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventactive/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param bool $Active <p>Gibt an, ob das Ereignis aktiviert (<b>TRUE</b>) / deaktiviert (<b>FALSE</b>) werden soll.</p> | |
| */ | |
| function IPS_SetEventActive(int $EventID, bool $Active) { | |
| } | |
| /** | |
| * modifiziert die Bedingung eines Ereignisses | |
| * | |
| * <p>Diese Funktion modifiziert die Bedingung mit der ID <b>BedingungsID</b> des Ereignisses mit der ID <b>EreignisID</b>. Die Bedingung wird der Bedingung mit der ID <b>ÜbergeordneteID</b> untergeordnet und verwendet die Operation <b>Operation</b>. Wenn keine Bedingung mit der ID <b>BedingungsID</b> existiert, wird eine erstellt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcondition/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $ConditionID <p>Eindeutige ID für diese Bedingung. Die Wurzelbedingung hat die ID 0. IDs müssen nur für dieses Ereignis eindeutig sein.</p> | |
| * @param int $ParentID <p>ID der übergeordneten Bedingung. Bei der Erstellung der Wurzelbedingung muss dieser Parameter 0 sein.</p> | |
| * @param int $Operation <li>0AND</li><li>1OR</li><li>2NAND (noch nicht implementiert)</li><li>3NOR (noch nicht implementiert)</li> | |
| * enum[0=eoAND, 1=eoOR, 2=eoNAND, 3=eoNOR] | |
| */ | |
| function IPS_SetEventCondition(int $EventID, int $ConditionID, int $ParentID, int $Operation) { | |
| } | |
| /** | |
| * modifiziert die Regel einer Bedingung eines Ereignisses für Datumsvergleiche | |
| * | |
| * <p>Diese Funktion modifiziert die Regel mit der ID <b>RegelID</b> der Bedingung mit der ID <b>BedingungsID</b> des Ereignisses mit der ID <b>EreignisID</b>. Die Regel vergleicht das aktuelle Datum mit den <b>Tag</b>, <b>Monat</b> und <b>Jahr</b>, entsprechend der Vergleichsoperation <b>Vergleich</b>. Falls keine Regel mit der ID <b>RegelID</b> existiert, wird eine erstellt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventconditiondaterule/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $ConditionID <p>ID der Bedingung, welche die Regel beinhaltet</p> | |
| * @param int $RuleID <p>Eindeutige ID für diese Regel. IDs müssen nur für dieses Bedingung eindeutig sein.</p> | |
| * @param int $Comparison <p>Tag mit dem das aktuelle Datum verglichen wird</p> | |
| * enum[0=ecEqual, 1=ecNotEqual, 2=ecGreater, 3=ecGreaterOrEqual, 4=ecSmaller, 5=ecSmallerOrEqual] | |
| * @param int $Day <p>Monat mit dem das aktuelle Datum verglichen wird</p> | |
| * @param int $Month <p>Jahr mit dem das aktuelle Datum verglichen wird</p> | |
| * @param int $Year | |
| */ | |
| function IPS_SetEventConditionDateRule(int $EventID, int $ConditionID, int $RuleID, int $Comparison, int $Day, int $Month, int $Year) { | |
| } | |
| /** | |
| * modifiziert die Regel einer Bedingung eines Ereignisses für Wochentagsvergleiche | |
| * | |
| * <p>Diese Funktion modifiziert die Regel mit der ID <b>RegelID</b> der Bedingung mit der ID <b>BedingungsID</b> des Ereignisses mit der ID <b>EreignisID</b>. Die Regel vergleicht den aktuellen Wochentag mit dem <b>Wochentag</b>, entsprechend der Vergleichoperation <b>Vergleich</b>. Falls keine Regel mit der ID <b>RegelID</b> existiert, wird eine erstellt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventconditiondayoftheweekrule/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $ConditionID <p>ID der Bedingung, welche die Regel beinhaltet</p> | |
| * @param int $RuleID <p>Eindeutige ID für diese Regel. IDs müssen nur für dieses Bedingung eindeutig sein.</p> | |
| * @param int $Comparison <li>0==</li><li>1!=</li><li>2></li><li>3>=</li><li>4<</li><li>5<=</li> | |
| * enum[0=ecEqual, 1=ecNotEqual, 2=ecGreater, 3=ecGreaterOrEqual, 4=ecSmaller, 5=ecSmallerOrEqual] | |
| * @param int $Value <li>0Löschen</li><li>1Montag</li><li>2Dienstag</li><li>3Mittwoch</li><li>4Donnerstag</li><li>5Freitag</li><li>6Samstag</li><li>7Sonntag</li> | |
| */ | |
| function IPS_SetEventConditionDayOfTheWeekRule(int $EventID, int $ConditionID, int $RuleID, int $Comparison, int $Value) { | |
| } | |
| /** | |
| * modifiziert die Regel einer Bedingung eines Ereignisses für Uhrzeitvergleiche | |
| * | |
| * <p>Diese Funktion modifiziert die Regel mit der ID <b>RegelID</b> der Bedingung mit der ID <b>BedingungsID</b> des Ereignisses mit der ID <b>EreignisID</b>. Die Regel vergleicht die aktuelle Uhrzeit mit den <b>Stunden</b>, <b>Minuten</b> und <b>Sekunden</b>, entsprechend der Vergleichsoperation <b>Vergleich</b>. Falls keine Regel mit der ID <b>RegelID</b> existiert, wird eine erstellt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventconditiontimerule/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $ConditionID <p>ID der Bedingung, welche die Regel beinhaltet</p> | |
| * @param int $RuleID <p>Eindeutige ID für diese Regel. IDs müssen nur für dieses Bedingung eindeutig sein.</p> | |
| * @param int $Comparison <p>Stundenwert (0..23) mit dem die aktuelle Zeit verglichen wird</p> | |
| * enum[0=ecEqual, 1=ecNotEqual, 2=ecGreater, 3=ecGreaterOrEqual, 4=ecSmaller, 5=ecSmallerOrEqual] | |
| * @param int $Hour <p>Minutenwert (0..59) mit dem die aktuelle Zeit verglichen wird</p> | |
| * @param int $Minute <p>Sekundenwert (0..59) mit dem die aktuelle Zeit verglichen wird</p> | |
| * @param int $Second | |
| */ | |
| function IPS_SetEventConditionTimeRule(int $EventID, int $ConditionID, int $RuleID, int $Comparison, int $Hour, int $Minute, int $Second) { | |
| } | |
| /** | |
| * IPS_SetEventConditionVariableDynamicRule | |
| * | |
| * @returns bool | |
| * @param int $EventID | |
| * @param int $ConditionID | |
| * @param int $RuleID | |
| * @param int $VariableID | |
| * @param int $Comparison | |
| * enum[0=ecEqual, 1=ecNotEqual, 2=ecGreater, 3=ecGreaterOrEqual, 4=ecSmaller, 5=ecSmallerOrEqual] | |
| * @param int $CompareVariableID | |
| */ | |
| function IPS_SetEventConditionVariableDynamicRule(int $EventID, int $ConditionID, int $RuleID, int $VariableID, int $Comparison, int $CompareVariableID) { | |
| } | |
| /** | |
| * modifiziert die Regel einer Bedingung eines Ereignisses für Variablenvergleiche | |
| * | |
| * <p>Diese Funktion modifiziert die Regel mit der ID <b>RegelID</b> der Bedingung mit der ID <b>BedingungsID</b> des Ereignisses mit der ID <b>EreignisID</b>. Die Regel vergleicht die Variable mit der ID <b>VariablenID</b> mit dem Wert <b>Wert</b> entsprechend der Vergleichsoperation <b>Vergleich</b>. Falls keine Regel mit der ID <b>RegelID</b> existiert, wird eine erstellt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventconditionvariablerule/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $ConditionID <p>ID der Bedingung welche die Regel beinhaltet</p> | |
| * @param int $RuleID <p>Eindeutige ID für diese Regel. IDs müssen nur für dieses Bedingung eindeutig sein.</p> | |
| * @param int $VariableID <p>ID der geprüften Variable</p> | |
| * @param int $Comparison <p>Wert mit dem die geprüfte Variable verglichen wird</p> | |
| * enum[0=ecEqual, 1=ecNotEqual, 2=ecGreater, 3=ecGreaterOrEqual, 4=ecSmaller, 5=ecSmallerOrEqual] | |
| * @param mixed $Value | |
| */ | |
| function IPS_SetEventConditionVariableRule(int $EventID, int $ConditionID, int $RuleID, int $VariableID, int $Comparison, mixed $Value) { | |
| } | |
| /** | |
| * IPS_SetEventConditionVariableStaticRule | |
| * | |
| * @returns bool | |
| * @param int $EventID | |
| * @param int $ConditionID | |
| * @param int $RuleID | |
| * @param int $VariableID | |
| * @param int $Comparison | |
| * enum[0=ecEqual, 1=ecNotEqual, 2=ecGreater, 3=ecGreaterOrEqual, 4=ecSmaller, 5=ecSmallerOrEqual] | |
| * @param mixed $Value | |
| */ | |
| function IPS_SetEventConditionVariableStaticRule(int $EventID, int $ConditionID, int $RuleID, int $VariableID, int $Comparison, mixed $Value) { | |
| } | |
| /** | |
| * konfiguriert ein zyklisches Ereignis | |
| * | |
| * <p>Um ein zyklisches Ereignis zu konfigurieren, muss festgelegt werden, in welchen Intervallen dieses ausgeführt werden soll. Dazu gehört ein <b>Datumsintervall</b>, welches das Intervall in einem bestimmten Tages-, Wochen-, Monats- oder Jahresrythmus festlegt und ein Zeitintervall, welches an dem jeweiligen Tag ein sekunden-, minuten- oder stundenbasierendes Intervall festlegt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclic/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $DateType <li>0Kein Datumstyp. Tägliche Ausführung.</li><li>1Einmalig. IPS_SetEventCyclicDateFrom für Zieldatum</li><li>2Täglich</li><li>3Wöchentlich</li><li>4Monatlich</li><li>5Jährlich</li> | |
| * enum[0=cdtNone, 1=cdtOnce, 2=cdtDay, 3=cdtWeek, 4=cdtMonth, 5=cdtYear] | |
| * @param int $DateValue <li>00 (Keine Auswertung)</li><li>10 (Keine Auswertung)</li><li>2Alle <b>X</b> Tage</li><li>3Alle <b>X</b> Wochen</li><li>4Alle <b>X</b> Monate</li><li>51 = Januar … 12 = Dezember</li> | |
| * @param int $DateDay <li>00 (Keine Auswertung)</li><li>10 (Keine Auswertung)</li><li>20 (Keine Auswertung)</li><li>3siehe Tabelle: Tageswerte (gewünschte Tageswerte müssen addiert werden)</li><li>4siehe Tabelle: Tageswerte oder 0 für jeden <b>X</b> Tag im Monat</li><li>50 (Keine Auswertung)</li><p><em>Tabelle: Tageswerte</em></p><li>Montag1</li><li>Dienstag2</li><li>Mittwoch4</li><li>Donnerstag8</li><li>Freitag16</li><li>Samstag32</li><li>Sonntag64</li> | |
| * @param int $DateDayValue <li>00 (Keine Auswertung)</li><li>10 (Keine Auswertung)</li><li>20 (Keine Auswertung)</li><li>30 (Keine Auswertung)</li><li>4Jeden <b>X Datumstag</b> im Monat oder jeden <b>X</b> Tag im Monat, falls <b>Datumstag</b> = 0</li><li>5Jeden <b>X</b> Tag im angegebenen Monat</li> | |
| * @param int $TimeType <li>0Einmalig IPS_SetEventCyclicTimeFrom für Zielzeit</li><li>1Sekündlich</li><li>2Minütlich</li><li>3Stündlich</li> | |
| * enum[0=cttOnce, 1=cttSecond, 2=cttMinute, 3=cttHour] | |
| * @param int $TimeValue <li>00 (Keine Auswertung)</li><li>1Alle <b>X</b> Sekunden</li><li>2Alle <b>X</b> Minuten</li><li>3Alle <b>X</b> Stunden</li> | |
| */ | |
| function IPS_SetEventCyclic(int $EventID, int $DateType, int $DateValue, int $DateDay, int $DateDayValue, int $TimeType, int $TimeValue) { | |
| } | |
| /** | |
| * konfiguriert das Startdatum | |
| * | |
| * <p>Die Funktion definiert das Startdatum für ein Ereignis.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclicdatefrom/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $Day <p>Start-Tag (0, 1..31)</p> | |
| * @param int $Month <p>Start-Monat (0, 1..12)</p> | |
| * @param int $Year <p>Start-Jahr (0, 1970..2038)</p> | |
| */ | |
| function IPS_SetEventCyclicDateFrom(int $EventID, int $Day, int $Month, int $Year) { | |
| } | |
| /** | |
| * konfiguriert das Enddatum | |
| * | |
| * <p>Die Funktion definiert das Enddatum für ein Ereignis.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclicdateto/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $Day <p>End-Tag (0, 1..31)</p> | |
| * @param int $Month <p>End-Monat (0, 1..12)</p> | |
| * @param int $Year <p>End-Jahr (0, 1970..2038)</p> | |
| */ | |
| function IPS_SetEventCyclicDateTo(int $EventID, int $Day, int $Month, int $Year) { | |
| } | |
| /** | |
| * konfiguriert die Startzeit | |
| * | |
| * <p>Die Funktion definiert die Startzeit für ein Ereignis. Die Startzeit definiert den ersten Zeitpunkt der Ausführung.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclictimefrom/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $Hour <p>Start-Stunde (0..23)</p> | |
| * @param int $Minute <p>Start-Minute (0..59)</p> | |
| * @param int $Second <p>Start-Sekunde (0..59)</p> | |
| */ | |
| function IPS_SetEventCyclicTimeFrom(int $EventID, int $Hour, int $Minute, int $Second) { | |
| } | |
| /** | |
| * konfiguriert die Endzeit | |
| * | |
| * <p>Die Funktion definiert die Endzeit für ein Ereignis. Die Endzeit definiert den letzten Zeitpunkt der Ausführung.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclictimeto/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $Hour <p>End-Stunde (0..23)</p> | |
| * @param int $Minute <p>End-Minute (0..59)</p> | |
| * @param int $Second <p>End-Sekunde (0..59)</p> | |
| */ | |
| function IPS_SetEventCyclicTimeTo(int $EventID, int $Hour, int $Minute, int $Second) { | |
| } | |
| /** | |
| * limitiert die Anzahl der Ereignissaufrufe | |
| * | |
| * <p>Die Funktion limitiert die Anzahl der Ereignisaufrufe des Ereignisses mit der ID <b>EreignisID</b>.<br>Die Limitierung auf <b>Anzahl</b> bewirkt, dass das Ereignis nur <b>Anzahl</b> Male ausgeführt wird. Danach ist die Anzahl gleich null und das Ereignis ist deaktiviert. Die Einstellung Anzahl = 0 hebt die Limitierung auf.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventlimit/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $Count <p>Die Anzahl der Ausführung, bevor das Ereignis deaktiviert wird. 0 = Keine Limitierung</p> | |
| */ | |
| function IPS_SetEventLimit(int $EventID, int $Count) { | |
| } | |
| /** | |
| * modifiziert die Aktionsstabelle eines Wochenplans und setzt die Aktion dabei auf "Führe PHP Code aus" | |
| * | |
| * <p>Die Funktion setzt den <b>Namen</b>, die <b>Farbe</b> und auszuführende Aktion auf "Führe PHP Code aus" mit dem Code <b>Skriptinhalt</b> für die Wochenplanaktion mit der ID <b>WochenplanAktionsID</b> eines Wochenplan Ereignisses mit der ID <b>EreignisID</b>. Die Systemvariable $_IPS['ACTION'] wird definiert. Es stehen für die Skriptinhalte die Systemvariablen zur Verfügung.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventscheduleaction/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $ScheduleActionID <p>Eindeutige ID für diese Wochenplanaktion. Die Sortierung wird anhand der ID vorgenommen. IDs müssen nur für dieses Ereignis eindeutig sein.</p> | |
| * @param string $Name <p>Name zur angegebenen Wochenplanaktion</p> | |
| * @param int $Color <p>Farbwert im HTML Farbcode (z.b. 0x0000FF für Blau)</p> | |
| * @param string $ScriptText <p>PHP Skript ohne PHP Tags (<? … ?>)</p> | |
| */ | |
| function IPS_SetEventScheduleAction(int $EventID, int $ScheduleActionID, string $Name, int $Color, string $ScriptText) { | |
| } | |
| /** | |
| * modifiziert die Aktionsstabelle eines Wochenplans | |
| * | |
| * <p>Die Funktion setzt den <b>Namen</b>, die <b>Farbe</b> und auszuführende Aktion mit der ID <b>AktionsID</b> mit Parametern <b>AktionsParameter</b> für die Wochenplanaktion mit der ID <b>WochenplanAktionsID</b> eines Wochenplan Ereignisses mit der ID <b>EreignisID</b>. Falls über die Aktion ein PHP-Skript ausgeführt wird, ist die Systemvariable $_IPS['ACTION'] definiert. Es stehen für die Skriptinhalte die Systemvariablen zur Verfügung.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventscheduleactionex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $ScheduleActionID <p>Eindeutige ID für diese Wochenplanaktion. Die Sortierung wird anhand der ID vorgenommen. IDs müssen nur für dieses Ereignis eindeutig sein.</p> | |
| * @param string $Name <p>Name zur angegebenen Wochenplanaktion</p> | |
| * @param int $Color <p>Farbwert im HTML Farbcode (z.b. 0x0000FF für Blau)</p> | |
| * @param string $ActionID <p>ID der auszuführenden Aktion</p> | |
| * @param array $ActionParameters <p>Liste der Parameter der auszuführenden Aktion</p> | |
| */ | |
| function IPS_SetEventScheduleActionEx(int $EventID, int $ScheduleActionID, string $Name, int $Color, string $ActionID, array $ActionParameters) { | |
| } | |
| /** | |
| * modifiziert die Gruppierung der Tage eines Wochenplans | |
| * | |
| * <p>Die Funktion setzt die Bitmaske <b>Tage</b> für die <b>GruppenID</b> eines Wochenplan Ereignisses mit der ID <b>EreignisID</b>. Es können in einer Gruppe beliebige Tage kombiniert werden. Dabei ist zu beachten, dass ein bestimmter Tag nur zu einer Gruppe zugehörig sein kann. In einer Gruppe können auch alle Tage (Wert = 127) oder nur ein einzelner Tag definiert sein. (z.B. 1 für Montag) Wenn für ein Ereignis nicht alle Tage in Gruppen aufgeteilt wurden, so können für diese Tage keine Schaltpunkte definiert werden und der letzte ausgeführte Schaltpunkt bleibt bestehen. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventschedulegroup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $GroupID <p>Eindeutige ID für diese Gruppe. Die Sortierung wird anhand der ID vorgenommen. IDs müssen nur für dieses Ereignis eindeutig sein.</p> | |
| * @param int $Days <p>Addition der Tageswerte, die zur Gruppe gehören. Die Tageswerte können der Tabelle bei IPS_SetEventCyclic entnommen werden.</p> | |
| */ | |
| function IPS_SetEventScheduleGroup(int $EventID, int $GroupID, int $Days) { | |
| } | |
| /** | |
| * modifiziert einen Schaltpunkt der Gruppe eines Wochenplans | |
| * | |
| * <p>Die Funktion setzt den Schaltpunkt mit der Kombination aus <b>StartStunde</b>, <b>StartMinute</b> und <b>StartSekunde</b> für die <b>SchaltpunktID</b> der Gruppe mit <b>GruppenID</b> eines Wochenplan Ereignisses mit der ID <b>EreignisID</b>. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventschedulegrouppoint/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $GroupID <p>Eindeutige ID für diese Gruppe. Die Sortierung wird anhand der ID vorgenommen. IDs müssen nur für dieses Ereignis eindeutig sein.</p> | |
| * @param int $PointID <p>Eindeutige ID für diesen Schaltpunkt. IDs müssen nur für diese Gruppe eindeutig sein.</p> | |
| * @param int $StartHour <p>Start-Stunde (0..23)</p> | |
| * @param int $StartMinute <p>Start-Minute (0..59)</p> | |
| * @param int $StartSecond <p>Start-Sekunde (0..59)</p> | |
| * @param int $ActionID <p>ID der Aktion, welche zum Zeitpunkt ausgeführt werden soll. Die ID muss gültig sein.</p> | |
| */ | |
| function IPS_SetEventScheduleGroupPoint(int $EventID, int $GroupID, int $PointID, int $StartHour, int $StartMinute, int $StartSecond, int $ActionID) { | |
| } | |
| /** | |
| * setzt die Aktion auf "Führe PHP Code aus" und definiert den auszuführenden Code | |
| * | |
| * <p>Die auszuführende Aktion des Ereignisses wird auf "Führe PHP Code aus" gesetzt und der Code auf <b>Skriptinhalt</b> gesetzt. Der PHP Code wird direkt ohne die PHP Tags (<? … ?>) angegeben.<br>Die Auflistung der Systemvariablen zeigt, welche speziellen Variablen verfügbar sind.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventscript/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param string $EventScript <p>PHP Code ohne PHP Tags (<? … ?>)</p> | |
| */ | |
| function IPS_SetEventScript(int $EventID, string $EventScript) { | |
| } | |
| /** | |
| * konfiguriert ein ausgelöstes Ereignis | |
| * | |
| * <p>Die Funktion konfiguriert ein auslösendes Ereignis, auf welchen <b>Auslösertyp</b> das Ereignis reagieren und welche <b>Variable</b> das Ereignis beobachten soll.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventtrigger/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param int $TriggerType <p>VariablenID, auf dessen Änderung/Aktualisierung reagiert werden soll</p> | |
| * enum[0=evtOnUpdate, 1=evtOnChange, 2=evtOnLimitExceed, 3=evtOnLimitDrop, 4=evtOnValue] | |
| * @param int $TriggerVariableID | |
| */ | |
| function IPS_SetEventTrigger(int $EventID, int $TriggerType, int $TriggerVariableID) { | |
| } | |
| /** | |
| * konfiguriert, ob Ereignis bei gleichem Wert erneut ausgelöst wird | |
| * | |
| * <p>Die Funktion gibt an, ob das Ereignis erneut ausgeführt werden soll, wenn eine Grenzüberschreitung/-unterschreitung zum zweiten Mal ausgelöst wird. Andernfalls wird das Ereignis erst wieder ausgeführt, wenn der Variablenwert innerhalb des Grenzwertbereichs gewesen ist und erneut überschritten wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventtriggersubsequentexecution/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param bool $AllowSubsequentExecutions <p><b>TRUE</b> für Erlaubt, sonst <b>FALSE</b></p> | |
| */ | |
| function IPS_SetEventTriggerSubsequentExecution(int $EventID, bool $AllowSubsequentExecutions) { | |
| } | |
| /** | |
| * konfiguriert den Wert bei dem Ausgelöst werden sol | |
| * | |
| * <p>Die Funktion konfiguriert einen Wert, welcher beim Vergleich genutzt werden soll.<br>Der Auslösertyp des Ereignisses kann wie folgt eingestellt sein:</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventtriggervalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $EventID <p>ID des zu verändernden Ereignisses</p> | |
| * @param mixed $TriggerValue <p>Abhänger Wert/Typ je nach VariablenID vom Auslöser</p> | |
| */ | |
| function IPS_SetEventTriggerValue(int $EventID, mixed $TriggerValue) { | |
| } | |
| /** | |
| * setzt die Sichtbarkeit eines beliebigen Objekts | |
| * | |
| * <p>Die Funktion setzt die Sichtbarkeit des Objekts mit der ID <b>ObjektID</b>. Unsichtbare Objekte werden samt Unterobjekten von der Visualisierung ausgeschlossen und in der Konfiguration als grau hinterlegt dargestellt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-sethidden/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ID <p>ID des zu verändernden Objekts</p> | |
| * @param bool $Hidden <p>TRUE, wenn unsichtbar</p> | |
| */ | |
| function IPS_SetHidden(int $ID, bool $Hidden) { | |
| } | |
| /** | |
| * ordnet einem beliebigen Objekt ein Icon zu | |
| * | |
| * <p>Die Funktion ordnet dem Objekt mit der ID <b>ObjektID</b> ein Icon zu. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-seticon/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ID <p>ID des zu verändernden Objekts</p> | |
| * @param string $Icon <p>Dateiname des Icons ohne Pfad/Erweiterung</p> | |
| */ | |
| function IPS_SetIcon(int $ID, string $Icon) { | |
| } | |
| /** | |
| * ordnet einem beliebigen Objekt einen Identifikator zu | |
| * | |
| * <p>Die Funktion ordnet dem Objekt mit der ID <b>ObjektID</b> den Identifikator <b>Ident</b> zu. Der Identifikator ist ein für den Endbenutzer nicht sichtbarer String. Erlaubte Zeichen sind "a..z","A..Z","0..9","_". Dieser kann genutzt werden, um Objekte innerhalb einer Ebene auffindbar zu machen, ohne die eindeutige und systemabhängige ID zu nutzen. Über den Identifikator werden z.B. alle Statusvariablen der Instanzen realisiert. Die Funktion kann auf alle Objekte angewandt werden, die eine ID zur Identifikation besitzen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-setident/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ID <p>ID des zu verändernden Objekts</p> | |
| * @param string $Ident <p>Neuer Identifikator für das Objekt</p> | |
| */ | |
| function IPS_SetIdent(int $ID, string $Ident) { | |
| } | |
| /** | |
| * ordnet einem beliebigen Objekt erweiterte Informationen zu | |
| * | |
| * <p>Die Funktion ordnet dem Objekt mit der ID <b>ObjektID</b> die Beschreibung <b>Info</b> zu. Diese können benutzt werden, um z.B. spezifische Konfigurationen oder spezielle Informationen pro Objekt zu hinterlegen, die zu einem späteren Zeitpunkt wiederverwendet werden können.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-setinfo/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ID <p>ID des zu verändernden Objekts</p> | |
| * @param string $Info <p>Neuer Beschreibungstext für das Objekt</p> | |
| */ | |
| function IPS_SetInfo(int $ID, string $Info) { | |
| } | |
| /** | |
| * IPS_SetLicense | |
| * | |
| * @returns bool | |
| * @param string $Licensee | |
| * @param string $LicenseContent | |
| */ | |
| function IPS_SetLicense(string $Licensee, string $LicenseContent) { | |
| } | |
| /** | |
| * setzt die Verknüpfung für den Link | |
| * | |
| * <p>Die Funktion verknüpft ein bestimmtes Objekt <b>VerknüpftesObjekt</b> mit dem Link <b>LinkID</b>, sodass der Link auf dieses Objekt zeigt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/linkverwaltung/ips-setlinktargetid/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $LinkID <p>ID des zu verändernden Links</p> | |
| * @param int $TargetID <p>ID des zu verknüpfenden Objekts</p> | |
| */ | |
| function IPS_SetLinkTargetID(int $LinkID, int $TargetID) { | |
| } | |
| /** | |
| * aktiviert, dass ein Medienobjekt nur im Arbeitsspeicher bearbeitet wird | |
| * | |
| * <p>Die Funktion aktiviert das Cachen für ein Medienobjekt mit der ID <b>MedienID</b>. Das Medienobjekt wird im Arbeitsspeicher verändert wenn die Funktionen IPS_SetMediaContent und IPS_GetMediaContent genutzt werden. Beim Herunterfahren von IP-Symcon wird das Medienobjekt automatisch auf den physikalischen Speicher geschrieben und somit persistent.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-setmediacached/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $MediaID <p>ID des zu verändernden Medienobjekts</p> | |
| * @param bool $Cached <p><b>TRUE</b>, wenn das Medienobjekt nur im Cache verarbeitet werden soll, sonst <b>FALSE</b></p> | |
| */ | |
| function IPS_SetMediaCached(int $MediaID, bool $Cached) { | |
| } | |
| /** | |
| * setzt den Inhalt eines Medienobjekts | |
| * | |
| * <p>Diese Funktion setzt den Inhalt für das Medienobjekt mit der ID <b>MedienID</b>. Dabei wird der Dateiname, der vorher per IPS_SetMediaFile definiert wurde, genutzt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-setmediacontent/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $MediaID <p>ID des Medienobjekts, dem der Inhalt zugeordnet werden soll</p> | |
| * @param string $Content <p>Base64 kodierter Inhalt</p> | |
| */ | |
| function IPS_SetMediaContent(int $MediaID, string $Content) { | |
| } | |
| /** | |
| * bindet eine Mediendatei an ein Medienobjekt | |
| * | |
| * <p>Die Funktion bindet den Dateinamen <b>DateiName</b> an das Medienobjekt mit der ID <b>MedienID</b>. Der Parameter <b>DateiMussExistieren</b> gibt an, ob intern geprüft werden soll, ob die Datei vorhanden ist. Die zuzuordnende Mediendatei muss zum Medientyp des Medienobjekts passen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/medienverwaltung/ips-setmediafile/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $MediaID <p>ID des zu verändernden Medienobjekts</p> | |
| * @param string $FilePath <p><b>TRUE</b>, wenn Existenz geprüft werden soll, sonst <b>FALSE</b></p> | |
| * @param bool $FileMustExists | |
| */ | |
| function IPS_SetMediaFile(int $MediaID, string $FilePath, bool $FileMustExists) { | |
| } | |
| /** | |
| * ordnet einem beliebigen Objekt einen Namen zu | |
| * | |
| * <p>Die Funktion ordnet dem Objekt mit der ID <b>ObjektID</b> den Namen <b>Name</b> zu. Der Name ersetzt im Strukturbaum den bisherigen Namen (Standard: unbekanntes Objekt: #12345) und kann so zur besseren Lesbarkeit beitragen. Die Funktion kann auf alle Objekte angewandt werden, die eine ID zur Identifikation besitzen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-setname/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ID <p>ID des zu verändernden Objekts</p> | |
| * @param string $Name <p>Neuer Name für das Objekt</p> | |
| */ | |
| function IPS_SetName(int $ID, string $Name) { | |
| } | |
| /** | |
| * IPS_SetOption | |
| * | |
| * @returns bool | |
| * @param string $Option | |
| * @param mixed $Value | |
| */ | |
| function IPS_SetOption(string $Option, mixed $Value) { | |
| } | |
| /** | |
| * verschiebt ein Objekt im logischen Strukturbaum | |
| * | |
| * <p>Die Funktion verschiebt das Objekt mit der ID <b>ObjektID</b> im IP-Symcon Strukturbaum unter das Objekt mit der ID <b>ÜbergeordneteID</b>. Das Objekt ist danach dem Übergeordneten-Objekt optisch untergeordnet. Die neue Zuordnung wird im logischen Strukturbaum (Logical Treeview) sichtbar. Auf diese Weise kann die logische Ansicht so angepasst werden, dass sie bestmöglich die Zusammengehörigkeit und/oder Abhängigkeit verschiedener Komponenten widerspiegelt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-setparent/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ID <p>ID des zu verändernden Objekts</p> | |
| * @param int $ParentID <p>ID des neuen übergeordneten Objekts im logischen Objektbaum</p> | |
| */ | |
| function IPS_SetParent(int $ID, int $ParentID) { | |
| } | |
| /** | |
| * ordnet einem beliebigen Objekt eine Position zu | |
| * | |
| * <p>Die Funktion ordnet dem Objekt mit der ID <b>ObjektID</b> eine <b>Position</b> zu. Die Position wird in der Visualisierung und Verwaltungskonsole verwendet, um die Objekte in der gewünschten Reihenfolge anzuzeigen. Defaultwert ist Null. Der Positionswert muss nicht eindeutig sein. Sollten zwei Positionen denselben Wert haben, wird primär nach Typ und dann nach Namen sortiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/objektverwaltung/ips-setposition/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ID <p>ID des zu verändernden Objekts</p> | |
| * @param int $Position <p>Positionswert des Objekts</p> | |
| */ | |
| function IPS_SetPosition(int $ID, int $Position) { | |
| } | |
| /** | |
| * setzt einen neuen Wert für eine Eigenschaft | |
| * | |
| * <p>Die Funktion setzt für die <b>InstanzID</b> den Soll-Wert der <b>Eigenschaft</b> ein.<br>Es kann ein neuer Soll-Wert mit IPS_SetProperty übergeben und mit IPS_ApplyChanges übernommen werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/instanzenverwaltung/konfiguration/ips-setproperty/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| * @param string $Name <p>Name der Eigenschaft</p> | |
| * @param mixed $Value <p>Neuer Wert der Eigenschaft</p> | |
| */ | |
| function IPS_SetProperty(int $InstanceID, string $Name, mixed $Value) { | |
| } | |
| /** | |
| * IPS_SetReplicationConfiguration | |
| * | |
| * @returns bool | |
| * @param string $Configuration | |
| */ | |
| function IPS_SetReplicationConfiguration(string $Configuration) { | |
| } | |
| /** | |
| * setzt den Inhalt eines Skripts | |
| * | |
| * <p>Diese Funktion setzt den Inhalt für das Skript mit der ID <b>SkriptID</b>. Dabei wird der Dateiname, der standardmäßig definiert ist, genutzt, sofern kein anderer per IPS_SetScriptFile definiert wurde.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-setscriptcontent/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ScriptID <p>ID des Skripts, dem der Inhalt zugeordnet werden soll</p> | |
| * @param string $Content <p>Inhalt inklusive PHP Tags (<? und ?>)</p> | |
| */ | |
| function IPS_SetScriptContent(int $ScriptID, string $Content) { | |
| } | |
| /** | |
| * ordnet einem Skript einen Dateinamen zu | |
| * | |
| * <p>Die Funktion bindet den Dateinamen <b>DateiName</b> an das Skript mit der ID <b>SkriptID</b>. Normalerweise besteht der Dateiname eines Skripts nur aus dessen ID mit der Extension “.ips.php”. Mit dieser Funktion ist es möglich einen anderen Dateinamen zu verwenden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-setscriptfile/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ScriptID <p>ID des Skripts, dem der Dateiname zugeordnet werden soll</p> | |
| * @param string $FilePath <p>Dateiname des PHP Skripts (relativ zum “/scripts” Ordner)</p> | |
| */ | |
| function IPS_SetScriptFile(int $ScriptID, string $FilePath) { | |
| } | |
| /** | |
| * setzt den Startwert des ScriptTimers | |
| * | |
| * <p>Die Funktion setzt den Integer-Startwert des ScriptTimers des Skripts mit der ID <b>SkriptID</b> auf den Wert <b>TimerWert</b> in Sekunden. Mit dieser Funktion kann man den ScriptTimer auf einen bestimmten Wert setzen. Der Wert wird in Sekundenschritten heruntergezählt. Beim Erreichen des Werts 0 wird das Skript gestartet und der ScriptTimer erneut auf den Startwert gesetzt. Dieser Vorgang wiederholt sich bis der Timer explizit gelöscht (auf 0 gesetzt) wurde.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/skriptverwaltung/ips-setscripttimer/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $ScriptID <p>ID des Skripts, dessen Timer eingestellt werden solll</p> | |
| * @param int $Interval <p>Zeit in Sekunden, in denen das Skript zyklisch aufgerufen werden soll</p> | |
| */ | |
| function IPS_SetScriptTimer(int $ScriptID, int $Interval) { | |
| } | |
| /** | |
| * IPS_SetSecurity | |
| * | |
| * @returns bool | |
| * @param int $Mode | |
| * @param string $Password | |
| */ | |
| function IPS_SetSecurity(int $Mode, string $Password) { | |
| } | |
| /** | |
| * ordnet der Variable ein benutzerdefiniertes Aktionsskript zu | |
| * | |
| * <p>Die Funktion vergibt der Variable <b>VariablenID</b> eine benutzerdefinierte Aktion, die in der Visualisierung benutzt wird, um eine Änderung der Variable an die richtige Funktion des Moduls weiterzuleiten. Ein Beispiel für ein Aktionsskript kann hier gefunden werden: Aktionsskripte</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/ips-setvariablecustomaction/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der Variable, der die Aktion zugeordnet werden soll</p> | |
| * @param int $ScriptID <p>ID eines Skriptes, das als Aktions aufgeführt werden soll. Sofern eine vorhandene Standardaktion deaktiviert werden soll, kann die nichtvorhandene SkriptID Eins (1) angegeben werden, wodurch die Standardaktion ausgeschaltet wird. Wenn eine gültige SkriptID angegebenen wird, so hat diese Vorrang vor der Standardaktion. Soll die Standardaktion, sofern verfügbar, aktiviert werden, so muss die SkriptID Null (0) angegeben werden.</p> | |
| */ | |
| function IPS_SetVariableCustomAction(int $VariableID, int $ScriptID) { | |
| } | |
| /** | |
| * ordnet der Variable ein benutzerdefiniertes Profil zu | |
| * | |
| * <p>Die Funktion vergibt der Variable <b>VariablenID</b> das benutzerdefinierte Profil <b>ProfilName</b>. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/ips-setvariablecustomprofile/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der Variable, der das Profil zugeordnet werden soll</p> | |
| * @param string $ProfileName <p>Name des Profils. Verfügbare Profile können über IPS_GetVariableProfileList abgefragt werden. Wenn ein Leerstring übergeben wird, dann wird das benutzerdefinierte Profil deaktiviert.</p> | |
| */ | |
| function IPS_SetVariableCustomProfile(int $VariableID, string $ProfileName) { | |
| } | |
| /** | |
| * modifiziert die Assoziationstabelle eines Variablenprofils | |
| * | |
| * <p>Die Funktion setzt den <b>Namen</b>, das <b>Icon</b> und die <b>Farbe</b> für einen <b>Wert</b> eines Variablenprofils mit Namen <b>ProfilName</b>. Die Farbe wird nicht angezeigt für Profile vom Typ Wertanzeige/Slider (siehe Objekt-Darstellung).</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-setvariableprofileassociation/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ProfileName <p>Name des Profils. Verfügbare Profile können über IPS_GetVariableProfileList abgefragt werden.</p> | |
| * @param mixed $AssociationValue <p>Wert, zu dem der Name, das Icon und die Farbe verknüpft werden sollen</p> | |
| * @param string $AssociationName <p>Name zum angegebenen Wert</p> | |
| * @param string $AssociationIcon <p>Icon zum angegebenen Wert</p> | |
| * @param int $AssociationColor <p>Farbwert im HTML Farbcode (z.b. 0x0000FF für Blau). Sonderfall</p> | |
| */ | |
| function IPS_SetVariableProfileAssociation(string $ProfileName, mixed $AssociationValue, string $AssociationName, string $AssociationIcon, int $AssociationColor) { | |
| } | |
| /** | |
| * setzt die Anzahl der Nachkommastellen eines Variablenprofils | |
| * | |
| * <p>Die Funktion setzt die Anzahl der <b>Nachkommastellen</b> eines Variablenprofils mit Namen <b>ProfilName</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-setvariableprofiledigits/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ProfileName <p>Name des Profils. Verfügbare Profile können über IPS_GetVariableProfileList abgefragt werden.</p> | |
| * @param int $Digits <p>Anzahl der in der Visualisierung angezeigten Nachkommastellen</p> | |
| */ | |
| function IPS_SetVariableProfileDigits(string $ProfileName, int $Digits) { | |
| } | |
| /** | |
| * setzt das Icon eines Variablenprofils | |
| * | |
| * <p>Die Funktion setzt das standardmäßig genutzte Icon eines Variablenprofils mit Namen <b>ProfilName</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-setvariableprofileicon/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ProfileName <p>Name des Profils. Verfügbare Profile können über IPS_GetVariableProfileList abgefragt werden.</p> | |
| * @param string $Icon <p>Icon zum angegebenen Wert</p> | |
| */ | |
| function IPS_SetVariableProfileIcon(string $ProfileName, string $Icon) { | |
| } | |
| /** | |
| * setzt das Prefix und Suffix eines Variablenprofils | |
| * | |
| * <p>Die Funktion setzt den Präfix und Suffix eines Variablenprofils mit Namen <b>ProfilName</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-setvariableprofiletext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ProfileName <p>Name des Profils. Verfügbare Profile können über IPS_GetVariableProfileList abgefragt werden.</p> | |
| * @param string $Prefix <p>Prefix für den Wert</p> | |
| * @param string $Suffix <p>Suffix für den Wert</p> | |
| */ | |
| function IPS_SetVariableProfileText(string $ProfileName, string $Prefix, string $Suffix) { | |
| } | |
| /** | |
| * setzt den Minimalwert, Maximalwert und die Schrittweite eines Variablenprofils | |
| * | |
| * <p>Die Funktion setzt den <b>MinimalWert</b>, <b>MaximalWert</b> und die <b>Schrittweite</b> eines Variablenprofils mit Namen <b>ProfilName</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-setvariableprofilevalues/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ProfileName <p>Name des Profils. Verfügbare Profile können über IPS_GetVariableProfileList abgefragt werden.</p> | |
| * @param float $MinValue <p>Der für die Visualisierung genutzte Minimalwert. Diese Soft-Limitation beeinflusst nicht den Variablenwert.</p> | |
| * @param float $MaxValue <p>Der für die Visualisierung genutzte Maximalwert. Diese Soft-Limitation beeinflusst nicht den Variablenwert.</p> | |
| * @param float $StepSize <p>Die für die Visualisierung genutzte Schrittweite zur Erstellung der Sollwert-Veränderngsleiste. Eine Schrittweite von <b>0</b> aktiviert die Assoziationsliste.</p> | |
| */ | |
| function IPS_SetVariableProfileValues(string $ProfileName, float $MinValue, float $MaxValue, float $StepSize) { | |
| } | |
| /** | |
| * verzögert ein Skript um ein bestimme zeit | |
| * | |
| * <p>Die Funktion setzt die Abarbeitung des Skripts für <b>Wartezeit</b> Millisekunden aus. Nach Ablauf dieser Zeit wird das Skript fortgesetzt. Mit Hilfe dieser Funktion lassen sich <b>kurze</b> (!) Wartezeiten realisieren. Längere Wartezeiten sollten nicht durch die Sleep Funktion realisiert, sondern über geeignete <b>Ereignisse</b> gesteuert werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ablaufsteuerung/ips-sleep/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $Milliseconds <p>Gibt die Wartezeit in Millisekunden an</p> | |
| */ | |
| function IPS_Sleep(int $Milliseconds) { | |
| } | |
| /** | |
| * IPS_StartSearch | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function IPS_StartSearch(int $InstanceID) { | |
| } | |
| /** | |
| * IPS_StopKernel | |
| * | |
| * @returns bool | |
| */ | |
| function IPS_StopKernel() { | |
| } | |
| /** | |
| * IPS_StopSearch | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function IPS_StopSearch(int $InstanceID) { | |
| } | |
| /** | |
| * IPS_SupportsSearching | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function IPS_SupportsSearching(int $InstanceID) { | |
| } | |
| /** | |
| * IPS_TimerExists | |
| * | |
| * @returns bool | |
| * @param int $TimerID | |
| */ | |
| function IPS_TimerExists(int $TimerID) { | |
| } | |
| /** | |
| * IPS_Translate | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param string $Text | |
| */ | |
| function IPS_Translate(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * IPS_TrimKernel | |
| * | |
| * @returns bool | |
| */ | |
| function IPS_TrimKernel() { | |
| } | |
| /** | |
| * IPS_UpdateFormField | |
| * | |
| * @returns bool | |
| * @param string $Name | |
| * @param string $Parameter | |
| * @param mixed $Value | |
| * @param string $SessionID | |
| */ | |
| function IPS_UpdateFormField(string $Name, string $Parameter, mixed $Value, string $SessionID) { | |
| } | |
| /** | |
| * IPS_UpdateSubscriptionExpiration | |
| * | |
| * @returns bool | |
| */ | |
| function IPS_UpdateSubscriptionExpiration() { | |
| } | |
| /** | |
| * prüft, ob eine bestimmte Variable existiert | |
| * | |
| * <p>Die Funktion prüft, ob die Variable mit der ID <b>VariablenID</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/ips-variableexists/ | |
| * @returns bool <p>Falls die VariablenID im System existiert, wird <b>TRUE</b> zurückgemeldet, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der zu prüfenden Variable</p> | |
| */ | |
| function IPS_VariableExists(int $VariableID) { | |
| } | |
| /** | |
| * prüft, ob ein bestimmtes Variablenprofil existiert | |
| * | |
| * <p>Die Funktion prüft, ob das Variablenprofil mit dem Namen <b>ProfilName</b> existiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenverwaltung/variablenprofile/ips-variableprofileexists/ | |
| * @returns bool <p>Falls das Profil mit dem Namen <b>ProfilName</b> im System existiert, wird <b>TRUE</b> zurückgemeldet, andernfalls <b>FALSE</b>.</p> | |
| * @param string $ProfileName <p>Name des gesuchten Variablenprofils</p> | |
| */ | |
| function IPS_VariableProfileExists(string $ProfileName) { | |
| } | |
| /** | |
| * IRT_ListButtons | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Remote | |
| */ | |
| function IRT_ListButtons(int $InstanceID, string $Remote) { | |
| } | |
| /** | |
| * IRT_ListRemotes | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function IRT_ListRemotes(int $InstanceID) { | |
| } | |
| /** | |
| * sendet einen IR Befehl | |
| * | |
| * <p>Sendet einen Fernbedienungsbefehl über die Instanz mit der ID <b>InstanzID</b> ab. Die Werte Fernbedienung und Knopf geben an, welcher Befehl gesendet werden soll. Diese müssen in der Client Software (IRTrans Tray) entsprechend eingerichtet worden sein.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/irtrans/irt-sendonce/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Remote <p>Name der Fernbedienung, der in der Fernbedienungsdatenbank eingetragen ist/wurde.</p> | |
| * @param string $Button <p>Name der Fernbedienungsfunktion, die in der Fernbedienungsdatenbank eingetragen ist/wurde.</p> | |
| */ | |
| function IRT_SendOnce(int $InstanceID, string $Remote, string $Button) { | |
| } | |
| /** | |
| * IRT_UpdateFormButtons | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Remote | |
| */ | |
| function IRT_UpdateFormButtons(int $InstanceID, string $Remote) { | |
| } | |
| /** | |
| * IRT_UpdateFormRemotes | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function IRT_UpdateFormRemotes(int $InstanceID) { | |
| } | |
| /** | |
| * KNX_DoWrite | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param mixed $Value | |
| */ | |
| function KNX_DoWrite(int $InstanceID, mixed $Value) { | |
| } | |
| /** | |
| * KNX_RenameVariables | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function KNX_RenameVariables(int $InstanceID) { | |
| } | |
| /** | |
| * schickt eine Leseanfrage für DPT-Instanzen auf den Bus | |
| * | |
| * <p>Schickt eine Lesenanfrage für Gerät mit der ID <b>InstanzID</b> auf den Bus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/knx/knx-requeststatus/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| */ | |
| function KNX_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * KNX_WriteDPT1 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $B | |
| */ | |
| function KNX_WriteDPT1(int $InstanceID, bool $B) { | |
| } | |
| /** | |
| * KNX_WriteDPT10 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $WeekDay | |
| * @param int $TimeOfDay | |
| */ | |
| function KNX_WriteDPT10(int $InstanceID, int $WeekDay, int $TimeOfDay) { | |
| } | |
| /** | |
| * KNX_WriteDPT11 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Date | |
| */ | |
| function KNX_WriteDPT11(int $InstanceID, int $Date) { | |
| } | |
| /** | |
| * KNX_WriteDPT12 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function KNX_WriteDPT12(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT13 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function KNX_WriteDPT13(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT14 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Value | |
| */ | |
| function KNX_WriteDPT14(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT15 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $D1 | |
| * @param int $D2 | |
| * @param int $D3 | |
| * @param int $D4 | |
| * @param int $D5 | |
| * @param int $D6 | |
| * @param bool $E | |
| * @param bool $P | |
| * @param bool $D | |
| * @param bool $C | |
| * @param int $Index | |
| */ | |
| function KNX_WriteDPT15(int $InstanceID, int $D1, int $D2, int $D3, int $D4, int $D5, int $D6, bool $E, bool $P, bool $D, bool $C, int $Index) { | |
| } | |
| /** | |
| * KNX_WriteDPT16 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Value | |
| */ | |
| function KNX_WriteDPT16(int $InstanceID, string $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT17 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function KNX_WriteDPT17(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT18 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $C | |
| * @param int $SceneNumber | |
| */ | |
| function KNX_WriteDPT18(int $InstanceID, bool $C, int $SceneNumber) { | |
| } | |
| /** | |
| * KNX_WriteDPT19 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Time | |
| * @param int $WeekDay | |
| * @param bool $F | |
| * @param bool $WD | |
| * @param bool $NWD | |
| * @param bool $NY | |
| * @param bool $ND | |
| * @param bool $NDOW | |
| * @param bool $NT | |
| * @param bool $SUTI | |
| * @param bool $CLQ | |
| */ | |
| function KNX_WriteDPT19(int $InstanceID, int $Time, int $WeekDay, bool $F, bool $WD, bool $NWD, bool $NY, bool $ND, bool $NDOW, bool $NT, bool $SUTI, bool $CLQ) { | |
| } | |
| /** | |
| * KNX_WriteDPT2 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $C | |
| * @param bool $V | |
| */ | |
| function KNX_WriteDPT2(int $InstanceID, bool $C, bool $V) { | |
| } | |
| /** | |
| * KNX_WriteDPT20 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function KNX_WriteDPT20(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT200 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Z | |
| * @param bool $B | |
| */ | |
| function KNX_WriteDPT200(int $InstanceID, int $Z, bool $B) { | |
| } | |
| /** | |
| * KNX_WriteDPT201 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Z | |
| * @param int $N | |
| */ | |
| function KNX_WriteDPT201(int $InstanceID, int $Z, int $N) { | |
| } | |
| /** | |
| * KNX_WriteDPT202 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $U | |
| * @param int $Z | |
| */ | |
| function KNX_WriteDPT202(int $InstanceID, int $U, int $Z) { | |
| } | |
| /** | |
| * KNX_WriteDPT203 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $U | |
| * @param int $Z | |
| */ | |
| function KNX_WriteDPT203(int $InstanceID, float $U, int $Z) { | |
| } | |
| /** | |
| * KNX_WriteDPT204 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Value | |
| * @param int $Z | |
| */ | |
| function KNX_WriteDPT204(int $InstanceID, float $Value, int $Z) { | |
| } | |
| /** | |
| * KNX_WriteDPT205 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Value | |
| * @param int $Z | |
| */ | |
| function KNX_WriteDPT205(int $InstanceID, float $Value, int $Z) { | |
| } | |
| /** | |
| * KNX_WriteDPT206 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Time | |
| * @param int $Mode | |
| */ | |
| function KNX_WriteDPT206(int $InstanceID, int $Time, int $Mode) { | |
| } | |
| /** | |
| * KNX_WriteDPT207 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| * @param bool $Attr0 | |
| * @param bool $Attr1 | |
| * @param bool $Attr2 | |
| * @param bool $Attr3 | |
| * @param bool $Attr4 | |
| * @param bool $Attr5 | |
| * @param bool $Attr6 | |
| * @param bool $Attr7 | |
| */ | |
| function KNX_WriteDPT207(int $InstanceID, int $Value, bool $Attr0, bool $Attr1, bool $Attr2, bool $Attr3, bool $Attr4, bool $Attr5, bool $Attr6, bool $Attr7) { | |
| } | |
| /** | |
| * KNX_WriteDPT209 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Temperature | |
| * @param bool $Attr0 | |
| * @param bool $Attr1 | |
| * @param bool $Attr2 | |
| * @param bool $Attr3 | |
| * @param bool $Attr4 | |
| */ | |
| function KNX_WriteDPT209(int $InstanceID, float $Temperature, bool $Attr0, bool $Attr1, bool $Attr2, bool $Attr3, bool $Attr4) { | |
| } | |
| /** | |
| * KNX_WriteDPT21 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $Bit0 | |
| * @param bool $Bit1 | |
| * @param bool $Bit2 | |
| * @param bool $Bit3 | |
| * @param bool $Bit4 | |
| * @param bool $Bit5 | |
| * @param bool $Bit6 | |
| * @param bool $Bit7 | |
| */ | |
| function KNX_WriteDPT21(int $InstanceID, bool $Bit0, bool $Bit1, bool $Bit2, bool $Bit3, bool $Bit4, bool $Bit5, bool $Bit6, bool $Bit7) { | |
| } | |
| /** | |
| * KNX_WriteDPT210 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Temperature | |
| * @param bool $Attr0 | |
| * @param bool $Attr1 | |
| * @param bool $Attr2 | |
| * @param bool $Attr3 | |
| * @param bool $Attr4 | |
| * @param bool $Attr5 | |
| * @param bool $Attr6 | |
| * @param bool $Attr7 | |
| * @param bool $Attr8 | |
| * @param bool $Attr9 | |
| * @param bool $Attr10 | |
| * @param bool $Attr11 | |
| */ | |
| function KNX_WriteDPT210(int $InstanceID, float $Temperature, bool $Attr0, bool $Attr1, bool $Attr2, bool $Attr3, bool $Attr4, bool $Attr5, bool $Attr6, bool $Attr7, bool $Attr8, bool $Attr9, bool $Attr10, bool $Attr11) { | |
| } | |
| /** | |
| * KNX_WriteDPT211 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Demand | |
| * @param int $ControllerMode | |
| */ | |
| function KNX_WriteDPT211(int $InstanceID, int $Demand, int $ControllerMode) { | |
| } | |
| /** | |
| * KNX_WriteDPT212 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $TempSetpoint1 | |
| * @param float $TempSetpoint2 | |
| * @param float $TempSetpoint3 | |
| */ | |
| function KNX_WriteDPT212(int $InstanceID, float $TempSetpoint1, float $TempSetpoint2, float $TempSetpoint3) { | |
| } | |
| /** | |
| * KNX_WriteDPT213 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $TempSetpoint1 | |
| * @param float $TempSetpoint2 | |
| * @param float $TempSetpoint3 | |
| * @param float $TempSetpoint4 | |
| */ | |
| function KNX_WriteDPT213(int $InstanceID, float $TempSetpoint1, float $TempSetpoint2, float $TempSetpoint3, float $TempSetpoint4) { | |
| } | |
| /** | |
| * KNX_WriteDPT214 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Temperature | |
| * @param int $Demand | |
| * @param bool $Attr0 | |
| * @param bool $Attr1 | |
| * @param bool $Attr2 | |
| * @param bool $Attr3 | |
| * @param bool $Attr4 | |
| * @param bool $Attr5 | |
| */ | |
| function KNX_WriteDPT214(int $InstanceID, float $Temperature, int $Demand, bool $Attr0, bool $Attr1, bool $Attr2, bool $Attr3, bool $Attr4, bool $Attr5) { | |
| } | |
| /** | |
| * KNX_WriteDPT215 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Temperature | |
| * @param int $Power | |
| * @param bool $Attr0 | |
| * @param bool $Attr1 | |
| * @param bool $Attr2 | |
| * @param bool $Attr3 | |
| * @param bool $Attr4 | |
| * @param bool $Attr5 | |
| * @param bool $Attr6 | |
| * @param bool $Attr7 | |
| * @param bool $Attr8 | |
| * @param bool $Attr9 | |
| * @param bool $Attr10 | |
| * @param bool $Attr11 | |
| */ | |
| function KNX_WriteDPT215(int $InstanceID, float $Temperature, int $Power, bool $Attr0, bool $Attr1, bool $Attr2, bool $Attr3, bool $Attr4, bool $Attr5, bool $Attr6, bool $Attr7, bool $Attr8, bool $Attr9, bool $Attr10, bool $Attr11) { | |
| } | |
| /** | |
| * KNX_WriteDPT216 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Pnom | |
| * @param int $BstageLimit | |
| * @param int $BurnerType | |
| * @param bool $OilSupport | |
| * @param bool $GasSupport | |
| * @param bool $SolidSupport | |
| */ | |
| function KNX_WriteDPT216(int $InstanceID, int $Pnom, int $BstageLimit, int $BurnerType, bool $OilSupport, bool $GasSupport, bool $SolidSupport) { | |
| } | |
| /** | |
| * KNX_WriteDPT217 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Magic | |
| * @param int $Version | |
| * @param int $Revision | |
| */ | |
| function KNX_WriteDPT217(int $InstanceID, int $Magic, int $Version, int $Revision) { | |
| } | |
| /** | |
| * KNX_WriteDPT218 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Volume | |
| * @param int $Z | |
| */ | |
| function KNX_WriteDPT218(int $InstanceID, float $Volume, int $Z) { | |
| } | |
| /** | |
| * KNX_WriteDPT219 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $LogNumber | |
| * @param int $AlarmPriority | |
| * @param int $ApplicationArea | |
| * @param int $ErrorClass | |
| * @param bool $Attribut0 | |
| * @param bool $Attribut1 | |
| * @param bool $Attribut2 | |
| * @param bool $Attribut3 | |
| * @param bool $AlarmStatus0 | |
| * @param bool $AlarmStatus1 | |
| * @param bool $AlarmStatus2 | |
| */ | |
| function KNX_WriteDPT219(int $InstanceID, int $LogNumber, int $AlarmPriority, int $ApplicationArea, int $ErrorClass, bool $Attribut0, bool $Attribut1, bool $Attribut2, bool $Attribut3, bool $AlarmStatus0, bool $AlarmStatus1, bool $AlarmStatus2) { | |
| } | |
| /** | |
| * KNX_WriteDPT22 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $Bit0 | |
| * @param bool $Bit1 | |
| * @param bool $Bit2 | |
| * @param bool $Bit3 | |
| * @param bool $Bit4 | |
| * @param bool $Bit5 | |
| * @param bool $Bit6 | |
| * @param bool $Bit7 | |
| * @param bool $Bit8 | |
| * @param bool $Bit9 | |
| * @param bool $Bit10 | |
| * @param bool $Bit11 | |
| * @param bool $Bit12 | |
| * @param bool $Bit13 | |
| * @param bool $Bit14 | |
| * @param bool $Bit15 | |
| */ | |
| function KNX_WriteDPT22(int $InstanceID, bool $Bit0, bool $Bit1, bool $Bit2, bool $Bit3, bool $Bit4, bool $Bit5, bool $Bit6, bool $Bit7, bool $Bit8, bool $Bit9, bool $Bit10, bool $Bit11, bool $Bit12, bool $Bit13, bool $Bit14, bool $Bit15) { | |
| } | |
| /** | |
| * KNX_WriteDPT220 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $DelayTime | |
| * @param float $Temp | |
| */ | |
| function KNX_WriteDPT220(int $InstanceID, int $DelayTime, float $Temp) { | |
| } | |
| /** | |
| * KNX_WriteDPT221 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $ManufacturerCode | |
| * @param int $IncrementedNumber | |
| */ | |
| function KNX_WriteDPT221(int $InstanceID, int $ManufacturerCode, int $IncrementedNumber) { | |
| } | |
| /** | |
| * KNX_WriteDPT222 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Comfort | |
| * @param float $Standby | |
| * @param float $Economy | |
| */ | |
| function KNX_WriteDPT222(int $InstanceID, float $Comfort, float $Standby, float $Economy) { | |
| } | |
| /** | |
| * KNX_WriteDPT223 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $EnergyDem | |
| * @param int $ControllerMode | |
| * @param int $EmergencyMode | |
| */ | |
| function KNX_WriteDPT223(int $InstanceID, int $EnergyDem, int $ControllerMode, int $EmergencyMode) { | |
| } | |
| /** | |
| * KNX_WriteDPT224 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Cooling | |
| * @param float $Heating | |
| * @param int $ControllerMode | |
| * @param int $EmergencyMode | |
| */ | |
| function KNX_WriteDPT224(int $InstanceID, float $Cooling, float $Heating, int $ControllerMode, int $EmergencyMode) { | |
| } | |
| /** | |
| * KNX_WriteDPT225 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value0 | |
| * @param int $Value1 | |
| */ | |
| function KNX_WriteDPT225(int $InstanceID, int $Value0, int $Value1) { | |
| } | |
| /** | |
| * KNX_WriteDPT229 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $V | |
| * @param int $Z | |
| */ | |
| function KNX_WriteDPT229(int $InstanceID, int $V, int $Z) { | |
| } | |
| /** | |
| * KNX_WriteDPT23 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function KNX_WriteDPT23(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT230 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $ManufactID | |
| * @param int $IdentNumber | |
| * @param int $Version | |
| * @param int $Medium | |
| */ | |
| function KNX_WriteDPT230(int $InstanceID, int $ManufactID, int $IdentNumber, int $Version, int $Medium) { | |
| } | |
| /** | |
| * KNX_WriteDPT231 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Language | |
| * @param string $Region | |
| */ | |
| function KNX_WriteDPT231(int $InstanceID, string $Language, string $Region) { | |
| } | |
| /** | |
| * KNX_WriteDPT232 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $R | |
| * @param int $G | |
| * @param int $B | |
| */ | |
| function KNX_WriteDPT232(int $InstanceID, int $R, int $G, int $B) { | |
| } | |
| /** | |
| * KNX_WriteDPT234 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $LanguageCode | |
| */ | |
| function KNX_WriteDPT234(int $InstanceID, string $LanguageCode) { | |
| } | |
| /** | |
| * KNX_WriteDPT235 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $ActiveElectricalEnergy | |
| * @param int $Tariff | |
| * @param bool $E | |
| * @param bool $T | |
| */ | |
| function KNX_WriteDPT235(int $InstanceID, int $ActiveElectricalEnergy, int $Tariff, bool $E, bool $T) { | |
| } | |
| /** | |
| * KNX_WriteDPT236 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $D | |
| * @param int $P | |
| * @param int $M | |
| */ | |
| function KNX_WriteDPT236(int $InstanceID, bool $D, int $P, int $M) { | |
| } | |
| /** | |
| * KNX_WriteDPT237 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $CE | |
| * @param bool $BF | |
| * @param bool $LF | |
| * @param bool $RR | |
| * @param bool $AI | |
| * @param int $Addr | |
| */ | |
| function KNX_WriteDPT237(int $InstanceID, bool $CE, bool $BF, bool $LF, bool $RR, bool $AI, int $Addr) { | |
| } | |
| /** | |
| * KNX_WriteDPT238 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $B7 | |
| * @param bool $B6 | |
| * @param int $Value | |
| */ | |
| function KNX_WriteDPT238(int $InstanceID, bool $B7, bool $B6, int $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT239 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $SetValue | |
| * @param bool $ChannelActivation | |
| */ | |
| function KNX_WriteDPT239(int $InstanceID, int $SetValue, bool $ChannelActivation) { | |
| } | |
| /** | |
| * KNX_WriteDPT240 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $HeightPos | |
| * @param int $SlatsPos | |
| * @param bool $ValidHeightPos | |
| * @param bool $ValidSlatsPos | |
| */ | |
| function KNX_WriteDPT240(int $InstanceID, int $HeightPos, int $SlatsPos, bool $ValidHeightPos, bool $ValidSlatsPos) { | |
| } | |
| /** | |
| * KNX_WriteDPT241 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $HeightPos | |
| * @param int $SlatsPos | |
| * @param bool $A | |
| * @param bool $B | |
| * @param bool $C | |
| * @param bool $D | |
| * @param bool $E | |
| * @param bool $F | |
| * @param bool $G | |
| * @param bool $H | |
| * @param bool $I | |
| * @param bool $J | |
| * @param bool $K | |
| * @param bool $L | |
| * @param bool $M | |
| * @param bool $N | |
| * @param bool $O | |
| * @param bool $P | |
| */ | |
| function KNX_WriteDPT241(int $InstanceID, int $HeightPos, int $SlatsPos, bool $A, bool $B, bool $C, bool $D, bool $E, bool $F, bool $G, bool $H, bool $I, bool $J, bool $K, bool $L, bool $M, bool $N, bool $O, bool $P) { | |
| } | |
| /** | |
| * KNX_WriteDPT242 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $XAxis | |
| * @param int $YAxis | |
| * @param int $Brightness | |
| * @param bool $C | |
| * @param bool $B | |
| */ | |
| function KNX_WriteDPT242(int $InstanceID, int $XAxis, int $YAxis, int $Brightness, bool $C, bool $B) { | |
| } | |
| /** | |
| * KNX_WriteDPT249 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $TimePeriod | |
| * @param int $AbsoluteColourTemperature | |
| * @param int $AbsoluteBrightness | |
| * @param bool $B0 | |
| * @param bool $B1 | |
| * @param bool $B2 | |
| */ | |
| function KNX_WriteDPT249(int $InstanceID, int $TimePeriod, int $AbsoluteColourTemperature, int $AbsoluteBrightness, bool $B0, bool $B1, bool $B2) { | |
| } | |
| /** | |
| * KNX_WriteDPT25 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Busy | |
| * @param int $Nak | |
| */ | |
| function KNX_WriteDPT25(int $InstanceID, int $Busy, int $Nak) { | |
| } | |
| /** | |
| * KNX_WriteDPT251 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $R | |
| * @param int $G | |
| * @param int $B | |
| * @param int $W | |
| * @param bool $ValidR | |
| * @param bool $ValidG | |
| * @param bool $ValidB | |
| * @param bool $ValidW | |
| */ | |
| function KNX_WriteDPT251(int $InstanceID, int $R, int $G, int $B, int $W, bool $ValidR, bool $ValidG, bool $ValidB, bool $ValidW) { | |
| } | |
| /** | |
| * KNX_WriteDPT26 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $SceneNumber | |
| * @param bool $B | |
| */ | |
| function KNX_WriteDPT26(int $InstanceID, int $SceneNumber, bool $B) { | |
| } | |
| /** | |
| * KNX_WriteDPT27 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $S0 | |
| * @param bool $S1 | |
| * @param bool $S2 | |
| * @param bool $S3 | |
| * @param bool $S4 | |
| * @param bool $S5 | |
| * @param bool $S6 | |
| * @param bool $S7 | |
| * @param bool $S8 | |
| * @param bool $S9 | |
| * @param bool $S10 | |
| * @param bool $S11 | |
| * @param bool $S12 | |
| * @param bool $S13 | |
| * @param bool $S14 | |
| * @param bool $S15 | |
| * @param bool $M0 | |
| * @param bool $M1 | |
| * @param bool $M2 | |
| * @param bool $M3 | |
| * @param bool $M4 | |
| * @param bool $M5 | |
| * @param bool $M6 | |
| * @param bool $M7 | |
| * @param bool $M8 | |
| * @param bool $M9 | |
| * @param bool $M10 | |
| * @param bool $M11 | |
| * @param bool $M12 | |
| * @param bool $M13 | |
| * @param bool $M14 | |
| * @param bool $M15 | |
| */ | |
| function KNX_WriteDPT27(int $InstanceID, bool $S0, bool $S1, bool $S2, bool $S3, bool $S4, bool $S5, bool $S6, bool $S7, bool $S8, bool $S9, bool $S10, bool $S11, bool $S12, bool $S13, bool $S14, bool $S15, bool $M0, bool $M1, bool $M2, bool $M3, bool $M4, bool $M5, bool $M6, bool $M7, bool $M8, bool $M9, bool $M10, bool $M11, bool $M12, bool $M13, bool $M14, bool $M15) { | |
| } | |
| /** | |
| * KNX_WriteDPT29 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function KNX_WriteDPT29(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT3 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $C | |
| * @param int $StepCode | |
| */ | |
| function KNX_WriteDPT3(int $InstanceID, bool $C, int $StepCode) { | |
| } | |
| /** | |
| * KNX_WriteDPT30 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $Bit0 | |
| * @param bool $Bit1 | |
| * @param bool $Bit2 | |
| * @param bool $Bit3 | |
| * @param bool $Bit4 | |
| * @param bool $Bit5 | |
| * @param bool $Bit6 | |
| * @param bool $Bit7 | |
| * @param bool $Bit8 | |
| * @param bool $Bit9 | |
| * @param bool $Bit10 | |
| * @param bool $Bit11 | |
| * @param bool $Bit12 | |
| * @param bool $Bit13 | |
| * @param bool $Bit14 | |
| * @param bool $Bit15 | |
| * @param bool $Bit16 | |
| * @param bool $Bit17 | |
| * @param bool $Bit18 | |
| * @param bool $Bit19 | |
| * @param bool $Bit20 | |
| * @param bool $Bit21 | |
| * @param bool $Bit22 | |
| * @param bool $Bit23 | |
| */ | |
| function KNX_WriteDPT30(int $InstanceID, bool $Bit0, bool $Bit1, bool $Bit2, bool $Bit3, bool $Bit4, bool $Bit5, bool $Bit6, bool $Bit7, bool $Bit8, bool $Bit9, bool $Bit10, bool $Bit11, bool $Bit12, bool $Bit13, bool $Bit14, bool $Bit15, bool $Bit16, bool $Bit17, bool $Bit18, bool $Bit19, bool $Bit20, bool $Bit21, bool $Bit22, bool $Bit23) { | |
| } | |
| /** | |
| * KNX_WriteDPT31 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function KNX_WriteDPT31(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT4 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Value | |
| */ | |
| function KNX_WriteDPT4(int $InstanceID, string $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT5 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $U | |
| */ | |
| function KNX_WriteDPT5(int $InstanceID, int $U) { | |
| } | |
| /** | |
| * KNX_WriteDPT6 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $A | |
| * @param bool $B | |
| * @param bool $C | |
| * @param bool $D | |
| * @param bool $E | |
| * @param int $F | |
| */ | |
| function KNX_WriteDPT6(int $InstanceID, bool $A, bool $B, bool $C, bool $D, bool $E, int $F) { | |
| } | |
| /** | |
| * KNX_WriteDPT7 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function KNX_WriteDPT7(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT8 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Value | |
| */ | |
| function KNX_WriteDPT8(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * KNX_WriteDPT9 | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param float $Value | |
| */ | |
| function KNX_WriteDPT9(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * fügt ein Gerät zu einer Gruppe hinzu | |
| * | |
| * <p>Fügt das Gerät mit der ID <b>InstanzID</b> in die Gruppe mit der Gruppennummer <b>Gruppe</b> hinzu.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-addgroup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz; die ID der Splitter-Instanz, nicht der Geräte-Instanz</p> | |
| * @param int $Group <p>Gruppennummer (1..255)</p> | |
| */ | |
| function LCN_AddGroup(int $InstanceID, int $Group) { | |
| } | |
| /** | |
| * erhöht die Leuchtintensität ein Gerät | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> um den Wert <b>Intensität</b> heller.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-addintensity/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Intensity <p>0-100%</p> | |
| */ | |
| function LCN_AddIntensity(int $InstanceID, int $Intensity) { | |
| } | |
| /** | |
| * addiert Schwellwert zu aktuellen Wert | |
| * | |
| * <p>Addiert den Wert <b>Wert</b> des Schwellwerts <b>Schwellwert</b> im Register <b>Register</b> relativ zu dem aktuellen Wert des LCN-Moduls mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-addthresholdcurrent/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Register <p>Register des zu schaltenden Schwellwerts (1x5</p> | |
| * @param int $Threshold <p>zu setzender Schwellwert (1x5</p> | |
| * @param float $Value <p>Wert des Schwellwerts (0..1000)</p> | |
| */ | |
| function LCN_AddThresholdCurrent(int $InstanceID, int $Register, int $Threshold, float $Value) { | |
| } | |
| /** | |
| * addiert Schwellwert zu vordefinierten Wert | |
| * | |
| * <p>Addiert den Wert <b>Wert</b> des Schwellwerts <b>Schwellwert</b> im Register <b>Register</b> relativ zu dem programmierten Wert des LCN-Moduls mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-addthresholddefined/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Register <p>Register des zu schaltenden Schwellwerts (1x5</p> | |
| * @param int $Threshold <p>zu setzender Schwellwert (1x5</p> | |
| * @param float $Value <p>Wert des Schwellwerts</p> | |
| */ | |
| function LCN_AddThresholdDefined(int $InstanceID, int $Register, int $Threshold, float $Value) { | |
| } | |
| /** | |
| * lässt ein Gerät piepen | |
| * | |
| * <p>Lässt die Instanz mit der ID <b>InstanzID</b> piepen</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-beep/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz; die ID der Splitter-Instanz, nicht der Geräte-Instanz</p> | |
| * @param bool $SpecialTone <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| * @param int $Count <p>Anzahl zwischen 1..15</p> | |
| */ | |
| function LCN_Beep(int $InstanceID, bool $SpecialTone, int $Count) { | |
| } | |
| /** | |
| * veringert die Leuchtintensität ein Gerät | |
| * | |
| * <p>Dimmt das Gerät mit der ID InstanzID um den Wert Intensität dunkler.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-deductintensity/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Intensity <p>0-100%</p> | |
| */ | |
| function LCN_DeductIntensity(int $InstanceID, int $Intensity) { | |
| } | |
| /** | |
| * subtrahiert Schwellwert zu aktuellen Wert | |
| * | |
| * <p>Subtrahiert den Wert <b>Wert</b> des Schwellwerts <b>Schwellwert</b> im Register <b>Register</b> relativ zu dem aktuellen Wert des LCN-Moduls mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-deductthresholdcurrent/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Register <p>Register des zu schaltenden Schwellwerts (1x5</p> | |
| * @param int $Threshold <p>zu setzender Schwellwert (1x5</p> | |
| * @param float $Value <p>Wert des Schwellwerts (0..1000)</p> | |
| */ | |
| function LCN_DeductThresholdCurrent(int $InstanceID, int $Register, int $Threshold, float $Value) { | |
| } | |
| /** | |
| * subtrahiert Schwellwert zu vordefinierten Wert | |
| * | |
| * <p>Subtrahiert den Wert <b>Wert</b> des Schwellwerts <b>Schwellwert</b> im Register <b>Register</b> relativ zu dem programmierten Wert des LCN-Moduls mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-deductthresholddefined/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Register <p>Register des zu schaltenden Schwellwerts (1x5</p> | |
| * @param int $Threshold <p>zu setzender Schwellwert (1x5</p> | |
| * @param float $Value <p>Wert des Schwellwerts</p> | |
| */ | |
| function LCN_DeductThresholdDefined(int $InstanceID, int $Register, int $Threshold, float $Value) { | |
| } | |
| /** | |
| * LCN_Fadeout | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Intensity | |
| * @param int $Ramp | |
| */ | |
| function LCN_Fadeout(int $InstanceID, int $Intensity, int $Ramp) { | |
| } | |
| /** | |
| * schaltet ein Relais um | |
| * | |
| * <p>Schaltet das Relais mit der ID <b>InstanzID</b> um</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-fliprelay/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Relais</p> | |
| */ | |
| function LCN_FlipRelay(int $InstanceID) { | |
| } | |
| /** | |
| * LCN_GetKnownDevices | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function LCN_GetKnownDevices(int $InstanceID) { | |
| } | |
| /** | |
| * begrenzt einen Ausgang für einen bestimmten Zeitraum | |
| * | |
| * <p>Begrenzt den Ausgang mit der ID <b>InstanzID</b> für den Zeitraum <b>Zeit</b> und Zeittyp <b>ZeitTyp</b> auf den Wert <b>Wert</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-limitoutput/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Ausgangs</p> | |
| * @param int $Value <p>Prozentualer Wert auf den begrenzt werden soll (0..100)</p> | |
| * @param int $Time <p>Zeitraum wielange der Ausgang begrenzt werden soll</p> | |
| * @param string $TimeType <p>Gibt an ob die Begrenzung für Sekunden, Minuten, Stunden oder Tage gelten soll</p> | |
| */ | |
| function LCN_LimitOutput(int $InstanceID, int $Value, int $Time, string $TimeType) { | |
| } | |
| /** | |
| * ruft eine Szene für einen Ausgang auf | |
| * | |
| * <p>Ruft die Szene <b>Szene</b> des Ausgangs mit der ID <b>InstanzID</b> auf.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-loadscene/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Ausgangs</p> | |
| * @param int $Scene <p>Welche Szene geladen werden soll (0..9, 15)</p> | |
| */ | |
| function LCN_LoadScene(int $InstanceID, int $Scene) { | |
| } | |
| /** | |
| * sperrt einen Regler des Geräts | |
| * | |
| * <p>Sperrt den Regler <b>Ziel</b> des Geräts mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-locktargetvalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Target <p>Welcher Regler gesperrt werden soll (0,1,2,3)</p> | |
| * enum[0=ltR1, 1=ltR2, 2=ltS1, 3=ltS2] | |
| */ | |
| function LCN_LockTargetValue(int $InstanceID, int $Target) { | |
| } | |
| /** | |
| * stoppt einen Dimmvorgang | |
| * | |
| * <p>Stoppt den Dimmvorgang von Gerät mit der ID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-rampstop/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function LCN_RampStop(int $InstanceID) { | |
| } | |
| /** | |
| * entsperrt einen Regler des Geräts | |
| * | |
| * <p>Entsperrt den Regler <b>Ziel</b> des Geräts mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-releasetargetvalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Target <p>Welcher Regler entsperrt werden soll (0,1,2,3)</p> | |
| * enum[0=ltR1, 1=ltR2, 2=ltS1, 3=ltS2] | |
| */ | |
| function LCN_ReleaseTargetValue(int $InstanceID, int $Target) { | |
| } | |
| /** | |
| * entfernt ein Gerät aus einer Gruppe | |
| * | |
| * <p>Entfernt das Gerät mit der ID <b>InstanzID</b> aus der Gruppe mit der Gruppennummer <b>Gruppe</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-removegroup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz; die ID der Splitter-Instanz, nicht der Geräte-Instanz</p> | |
| * @param int $Group <p>Gruppennummer (0..255)</p> | |
| */ | |
| function LCN_RemoveGroup(int $InstanceID, int $Group) { | |
| } | |
| /** | |
| * fragt die LEDs des Tableaus ab | |
| * | |
| * <p>Fragt die LEDs (Tableaulämpchen) des Tableau mit der ID <b>InstanzID</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-requestlights/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des abzufragenden Tableaus</p> | |
| */ | |
| function LCN_RequestLights(int $InstanceID) { | |
| } | |
| /** | |
| * fragt die Werte ab | |
| * | |
| * <p>Fragt die Variablen, Targets und Zähler der Temperatur-Instanz mit der ID <b>InstanzID</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-requestread/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des abzufragenden Geräts</p> | |
| */ | |
| function LCN_RequestRead(int $InstanceID) { | |
| } | |
| /** | |
| * fragt alle Status des Moduls ab | |
| * | |
| * <p>Fragt des Status aller Ausgänge, Relais und binären Sensoren des Moduls mit der ID <b>InstanzID</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-requeststatus/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des abzufragenden Moduls</p> | |
| */ | |
| function LCN_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * fragt Schwellenwerte und Hysterese ab | |
| * | |
| * <p>Fragt die Schwellenwerte und Hysterese ID <b>InstanzID</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-requestthresholds/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des abzufragenden Thresholds</p> | |
| */ | |
| function LCN_RequestThresholds(int $InstanceID) { | |
| } | |
| /** | |
| * speichert eine Szene für einen Ausgang | |
| * | |
| * <p>Speichert die Szene <b>Szene</b> für den Ausgang mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-savescene/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Ausgangs</p> | |
| * @param int $Scene <p>In welcher Szene gespeichert werden soll (0..9, 15)</p> | |
| */ | |
| function LCN_SaveScene(int $InstanceID, int $Scene) { | |
| } | |
| /** | |
| * LCN_SearchDevices | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Segment | |
| */ | |
| function LCN_SearchDevices(int $InstanceID, int $Segment) { | |
| } | |
| /** | |
| * wählt ein Register aus | |
| * | |
| * <p>Wählt das Register mit der Nummer <b>Register</b> des Geräts mit der ID <b>InstanzID</b> aus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-selectsceneregister/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Register <p>welches Register ausgewählt werden soll (0..9)</p> | |
| */ | |
| function LCN_SelectSceneRegister(int $InstanceID, int $Register) { | |
| } | |
| /** | |
| * sendet einen benutzerdefinierten Befehl | |
| * | |
| * <p>Sendet einen benutzerdefinierten Befehl an die Instanz der ID <b>InstanzID</b>. Mögliche Befehle entnehmen Sie bitte der PCHK Dokumentation. Falls Sie diese nicht besitzen, können Sie diese u.U. von Ihrem Fachhändler beziehen. Wir haben leider keine Möglichkeit diese bereitzustellen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-sendcommand/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz; die ID der Splitter-Instanz, nicht der Geräte-Instanz</p> | |
| * @param string $Function <p>Die ersten beiden (2) Zeichen des PCHK Befehls (z.B. A1)</p> | |
| * @param string $Data <p>Die restlichen Zeichen des PCHK Befehls (z.B. DI000000). Eventuelle Zahlen müssen in der dezimalen Darstellung (3 Zeichen) gesendet werden.</p> | |
| */ | |
| function LCN_SendCommand(int $InstanceID, string $Function, string $Data) { | |
| } | |
| /** | |
| * Zeigt einen Text auf einer Zeile des Displays an | |
| * | |
| * <p>Zeigt den Text <b>Text</b> auf Zeile <b>Zeile</b> des Displays mit der ID <b>InstanzID</b> an.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-setdisplaytext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Row <p>Displayzeile zwischen 1..4</p> | |
| * @param string $Text <p>Text mit maximal 60 Zeichen</p> | |
| */ | |
| function LCN_SetDisplayText(int $InstanceID, int $Row, string $Text) { | |
| } | |
| /** | |
| * setzt die Anzeigedauer einer Zeile im Display | |
| * | |
| * <p>Konfiguriert die Zeile <b>Zeile</b> des Displays mit der ID <b>InstanzID</b> auf die Anzeigedauer <b>Anzeigedauer</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-setdisplaytime/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Row <p>Displayzeile zwischen 1..4</p> | |
| * @param int $Duration <p>Zeiteinheiten zwischen 1..30</p> | |
| */ | |
| function LCN_SetDisplayTime(int $InstanceID, int $Row, int $Duration) { | |
| } | |
| /** | |
| * dimmt ein Gerät in einer bestimmten Zeit | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Intensität</b> in <b>Rampe</b> Sekunden</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-setintensity/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Intensity <p>0-100%</p> | |
| * @param int $Ramp <p>0 = Sofort; n = Sekunden</p> | |
| */ | |
| function LCN_SetIntensity(int $InstanceID, int $Intensity, int $Ramp) { | |
| } | |
| /** | |
| * schalten einer LED | |
| * | |
| * <p>Schaltet das Tableau-Lämpchen <b>Lampe</b> der Instanz mit der ID <b>InstanzID</b> auf den Wert <b>Aktion</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-setlamp/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz; die ID der Splitter-Instanz, nicht der Geräte-Instanz</p> | |
| * @param int $Lamp <p>Auswahl der zu schaltenden Tableau-Lämpchen (1..12)</p> | |
| * @param string $Action <p>Welche Aktion ausgeführt werden soll.</p> | |
| */ | |
| function LCN_SetLamp(int $InstanceID, int $Lamp, string $Action) { | |
| } | |
| /** | |
| * setzt eine Instanz auf einen RGBW Farbwert | |
| * | |
| * <p>Setzt den Farbwert und Weißwert der Instanz mit der ID <b>InstanzID</b> auf <b>Rot</b>, <b>Grün</b> und <b>Blau</b>, sowie die Intensität auf <b>Weiß</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-setrgbw/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $R <p>Intensität zwischen 1..100</p> | |
| * @param int $G <p>Intensität zwischen 1..100</p> | |
| * @param int $B <p>Intensität zwischen 1..100</p> | |
| * @param int $W <p>Intensität zwischen 1..100</p> | |
| */ | |
| function LCN_SetRGBW(int $InstanceID, int $R, int $G, int $B, int $W) { | |
| } | |
| /** | |
| * setzt alle Relais in einem Modul (8Bit) | |
| * | |
| * <p>Setzt alle Relais der Instanz mit der ID <b>InstanzID</b> auf <b>Wert</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-setrelay/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz; die ID der Splitter-Instanz, nicht der Geräte-Instanz</p> | |
| * @param string $Value <p>8fache Zeichenkombination der folgenden Werte</p> | |
| */ | |
| function LCN_SetRelay(int $InstanceID, string $Value) { | |
| } | |
| /** | |
| * setzt einen Regler auf einen bestimmten Wert | |
| * | |
| * <p>Setzt den Regler <b>Ziel</b> der Instanz mit der ID <b>InstanzID</b> auf den Wert <b>Wert</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-settargetvalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Instanz</p> | |
| * @param int $Target <p>0 = Regler R1; 1 = Regler R2; 2 = Regler S1; 3 = Regler S2</p> | |
| * enum[0=ltR1, 1=ltR2, 2=ltS1, 3=ltS2] | |
| * @param float $Value <p>Wert</p> | |
| */ | |
| function LCN_SetTargetValue(int $InstanceID, int $Target, float $Value) { | |
| } | |
| /** | |
| * Shiftet den aktuellen Sollwert | |
| * | |
| * <p>Shiftet den aktuellen Sollwert des Reglers <b>Ziel</b> des Geräts mit der ID <b>InstanzID</b> um den Wert <b>RelativerWert</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-shifttargetvalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Target <p>Welcher Regler geshiftet werden soll (0,1,2,3)</p> | |
| * enum[0=ltR1, 1=ltR2, 2=ltS1, 3=ltS2] | |
| * @param float $RelativeValue <p>Wert um den geshiftet werden soll</p> | |
| */ | |
| function LCN_ShiftTargetValue(int $InstanceID, int $Target, float $RelativeValue) { | |
| } | |
| /** | |
| * startet eine Rollladenbewegung auf prozentuale Position | |
| * | |
| * <p>Startet die Bewegung des Rollladen mit der ID <b>InstanzID</b> auf die Position <b>Position</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-shuttermove/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Position <p>Prozentuale Position des Rolladen (0-100%)</p> | |
| */ | |
| function LCN_ShutterMove(int $InstanceID, int $Position) { | |
| } | |
| /** | |
| * startet eine Rollladenbewegung nach unten | |
| * | |
| * <p>Startet die Bewegung des Rollladen mit der ID <b>InstanzID</b> nach unten.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-shuttermovedown/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function LCN_ShutterMoveDown(int $InstanceID) { | |
| } | |
| /** | |
| * startet eine Rollladenbewegung nach oben | |
| * | |
| * <p>Startet die Bewegung des Rollladen mit der ID <b>InstanzID</b> nach oben.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-shuttermoveup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function LCN_ShutterMoveUp(int $InstanceID) { | |
| } | |
| /** | |
| * stoppt eine Rollladenbewegung | |
| * | |
| * <p>Stoppt die Bewegung des Rollladen mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-shutterstop/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function LCN_ShutterStop(int $InstanceID) { | |
| } | |
| /** | |
| * ein Gerät flackern lassen | |
| * | |
| * <p>Das Gerät mit der ID <b>InstanzID</b> auf Flackern lassen</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-startflicker/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Depth <p>G = Gering; M = Mittel; S = Start</p> | |
| * @param string $Speed <p>L = Langsam (ca. 0,5x / Sek); M = Mittel (ca. 1x / Sek); S = Schnell (ca. 2x / Sek)</p> | |
| * @param int $Count <p>Anzahl zwischen 1..15</p> | |
| */ | |
| function LCN_StartFlicker(int $InstanceID, string $Depth, string $Speed, int $Count) { | |
| } | |
| /** | |
| * stoppt das Flackern eines Geräts | |
| * | |
| * <p>Flackern des Geräts mit der InstanzID sofort beenden</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-stopflicker/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function LCN_StopFlicker(int $InstanceID) { | |
| } | |
| /** | |
| * nach wievielen Minuten abgedimmt werden soll | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> nach Minuten <b>Minuten</b> heller. Weitere Optionen sind die Dimmgeschwindigkeit <b>Abdimmzeit</b> und ob es <b>Erhaltend</b> ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-switchdurationmin/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Minutes <p>Nach wievielen Minuten Abgedimmt werden soll</p> | |
| * @param string $Fadeout <p>Wie schnell abgedimmt werden soll</p> | |
| * @param bool $Retentive <p>Das Gerät wird nach Ablauf der Zeit nur ausgeschaltet, wenn vorher noch nicht an war</p> | |
| */ | |
| function LCN_SwitchDurationMin(int $InstanceID, int $Minutes, string $Fadeout, bool $Retentive) { | |
| } | |
| /** | |
| * nach wie vielen Sekunden abgedimmt werden soll | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> nach Sekunden <b>Sekunden</b> heller. Weitere Optionen sind die Dimmgeschwindigkeit <b>Abdimmzeit</b> und ob es <b>Erhaltend</b> ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-switchdurationsec/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Seconds <p>Nach wie vielen Sekunden Abgedimmt werden soll</p> | |
| * @param string $Fadeout <p>Wie schnell abgedimmt werden soll</p> | |
| * @param bool $Retentive <p>Das Gerät wird nach Ablauf der Zeit nur ausgeschaltet, wenn vorher noch nicht an war</p> | |
| */ | |
| function LCN_SwitchDurationSec(int $InstanceID, int $Seconds, string $Fadeout, bool $Retentive) { | |
| } | |
| /** | |
| * setzt das Gerät auf einen gespeicherten Wert | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf einen abgespeicherten Wert</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-switchmemory/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Ramp <p>Anzahl Sekunden, 0 = Sofort</p> | |
| */ | |
| function LCN_SwitchMemory(int $InstanceID, int $Ramp) { | |
| } | |
| /** | |
| * schaltet ein Gerät an/aus | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> um.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-switchmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Ramp <p>Anzahl Sekunden, 0 = Sofort</p> | |
| */ | |
| function LCN_SwitchMode(int $InstanceID, int $Ramp) { | |
| } | |
| /** | |
| * schaltet ein Relais An/Aus | |
| * | |
| * <p>Schaltet das Relais mit der ID <b>InstanzID</b> auf Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-switchrelay/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $SwitchOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function LCN_SwitchRelay(int $InstanceID, bool $SwitchOn) { | |
| } | |
| /** | |
| * schaltet ein Relais auf einen Zeitfaktor | |
| * | |
| * <p>Schaltet das Relais mit der ID <b>InstanzID</b> auf Zeitfaktor <b>Zeitfaktor</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/lcn/lcn-switchrelaytimer/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Timerfactor <p>Zeitfaktor zwischen 1..255</p> | |
| */ | |
| function LCN_SwitchRelayTimer(int $InstanceID, int $Timerfactor) { | |
| } | |
| /** | |
| * LCOT_SetChangeOrder | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param bool $ChangeOrder | |
| */ | |
| function LCOT_SetChangeOrder(int $InstanceID, bool $ChangeOrder) { | |
| } | |
| /** | |
| * LDT_SetEnabled | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $enabled | |
| */ | |
| function LDT_SetEnabled(int $InstanceID, mixed $enabled) { | |
| } | |
| /** | |
| * LT_UpdateBold | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $bold | |
| */ | |
| function LT_UpdateBold(int $InstanceID, mixed $bold) { | |
| } | |
| /** | |
| * LT_UpdateColor | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $color | |
| */ | |
| function LT_UpdateColor(int $InstanceID, mixed $color) { | |
| } | |
| /** | |
| * LT_UpdateItalic | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $italic | |
| */ | |
| function LT_UpdateItalic(int $InstanceID, mixed $italic) { | |
| } | |
| /** | |
| * LT_UpdateUnderline | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $underline | |
| */ | |
| function LT_UpdateUnderline(int $InstanceID, mixed $underline) { | |
| } | |
| /** | |
| * LUT_UpdateValue | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function LUT_UpdateValue(int $InstanceID) { | |
| } | |
| /** | |
| * MBUS_SearchDevices | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function MBUS_SearchDevices(int $InstanceID) { | |
| } | |
| /** | |
| * MBUS_UpdateFormAddressing | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $UseSecondaryAddress | |
| */ | |
| function MBUS_UpdateFormAddressing(int $InstanceID, bool $UseSecondaryAddress) { | |
| } | |
| /** | |
| * aktualisiert alle gerätespezifischen Werte | |
| * | |
| * <p>Aktualisiert die Werte mit der ID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mbus/mbus-updatevalues/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden Geräts</p> | |
| */ | |
| function MBUS_UpdateValues(int $InstanceID) { | |
| } | |
| /** | |
| * MC_CreateModule | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $ModuleURL | |
| */ | |
| function MC_CreateModule(int $InstanceID, string $ModuleURL) { | |
| } | |
| /** | |
| * MC_DeleteModule | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_DeleteModule(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_GetModule | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_GetModule(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_GetModuleList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function MC_GetModuleList(int $InstanceID) { | |
| } | |
| /** | |
| * MC_GetModuleRepositoryInfo | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_GetModuleRepositoryInfo(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_GetModuleRepositoryLocalBranchList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_GetModuleRepositoryLocalBranchList(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_GetModuleRepositoryRemoteBranchList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_GetModuleRepositoryRemoteBranchList(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_IsModuleClean | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_IsModuleClean(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_IsModuleUpdateAvailable | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_IsModuleUpdateAvailable(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_IsModuleValid | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_IsModuleValid(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_ReloadModule | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_ReloadModule(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_RevertModule | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_RevertModule(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_UpdateModule | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Module | |
| */ | |
| function MC_UpdateModule(int $InstanceID, string $Module) { | |
| } | |
| /** | |
| * MC_UpdateModuleRepositoryBranch | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Module | |
| * @param string $Branch | |
| */ | |
| function MC_UpdateModuleRepositoryBranch(int $InstanceID, string $Module, string $Branch) { | |
| } | |
| /** | |
| * MQTT_ClearRetainedMessages | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function MQTT_ClearRetainedMessages(int $InstanceID) { | |
| } | |
| /** | |
| * MQTT_ClearTopics | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function MQTT_ClearTopics(int $InstanceID) { | |
| } | |
| /** | |
| * MQTT_GetKnownDevices | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function MQTT_GetKnownDevices(int $InstanceID) { | |
| } | |
| /** | |
| * MQTT_GetRetainedMessage | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Topic | |
| */ | |
| function MQTT_GetRetainedMessage(int $InstanceID, string $Topic) { | |
| } | |
| /** | |
| * MQTT_GetRetainedMessageTopicList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function MQTT_GetRetainedMessageTopicList(int $InstanceID) { | |
| } | |
| /** | |
| * MQTT_RemoveRetainedMessage | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Topic | |
| */ | |
| function MQTT_RemoveRetainedMessage(int $InstanceID, string $Topic) { | |
| } | |
| /** | |
| * MSCK_SendPacket | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Text | |
| * @param string $ClientIP | |
| * @param int $ClientPort | |
| */ | |
| function MSCK_SendPacket(int $InstanceID, string $Text, string $ClientIP, int $ClientPort) { | |
| } | |
| /** | |
| * sendet einen String auf den I/O | |
| * | |
| * <p>Sendet den String <b>Text</b> auf dem Multicast Socket mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/multicastsocket/msck-sendtext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden Multicast Sockets</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| */ | |
| function MSCK_SendText(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * MST_Dump | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function MST_Dump(int $InstanceID) { | |
| } | |
| /** | |
| * MT_UpdateMultiline | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param bool $multiline | |
| */ | |
| function MT_UpdateMultiline(int $InstanceID, bool $multiline) { | |
| } | |
| /** | |
| * fängt einen Dimmvorgang auf eine hellere Stufe an | |
| * | |
| * <p>Beginnt den Dimmvorgang für Gerät mit der ID <b>InstanzID</b> auf einer höheren Helligkeitsstufe. Der Vorgang kann mit dem Befehl MXC_DimStop beendet werden. Wird die maximale Stufe erreicht, stoppt der Vorgang automatisch. Die Statusmeldung wird von dem Gerät gesendet, sobald der Vorgang beendet wurde. Es werden keine Meldungen zwischendurch versandt. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-dimbrighter/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function MXC_DimBrighter(int $InstanceID) { | |
| } | |
| /** | |
| * fängt einen Dimmvorgang auf eine dunklere Stufe an | |
| * | |
| * <p>Beginnt den Dimmvorgang für Gerät mit der ID InstanzID auf einer niedrigeren Helligkeitsstufe. Der Vorgang kann mit dem Befehl MXC_DimStop beendet werden. Wird die maximale Stufe erreicht, stoppt der Vorgang automatisch. Die Statusmeldung wird von dem Gerät gesendet, sobald der Vorgang beendet wurde. Es werden keine Meldungen zwischendurch versandt. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-dimdarker/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function MXC_DimDarker(int $InstanceID) { | |
| } | |
| /** | |
| * dimmt ein xComfort Gerät auf eine bestimmte Stufe | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Intensität</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-dimset/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Intensity <p>Wert von 0-100 (in %)</p> | |
| */ | |
| function MXC_DimSet(int $InstanceID, int $Intensity) { | |
| } | |
| /** | |
| * hält einen Dimmvorgang an | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-dimstop/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function MXC_DimStop(int $InstanceID) { | |
| } | |
| /** | |
| * MXC_GetKnownDevices | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function MXC_GetKnownDevices(int $InstanceID) { | |
| } | |
| /** | |
| * MXC_RequestInfo | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function MXC_RequestInfo(int $InstanceID) { | |
| } | |
| /** | |
| * sende eine Statusmeldungsanfrage an ein Gerät | |
| * | |
| * <p>Fordert ein erneutes Senden der Statusmeldungen für Gerät mit der ID <b>InstanzID</b> an.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-requeststatus/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| */ | |
| function MXC_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * sendet einen Boolean-Wert an den Room-Mananger | |
| * | |
| * <p>Sendet einen booleanischen Wert an die Instanz mit der <b>InstanzID</b>, welche an einen Room-Manager angeschlossen ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-sendboolean/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $Value <p>True für An, False für Aus</p> | |
| */ | |
| function MXC_SendBoolean(int $InstanceID, bool $Value) { | |
| } | |
| /** | |
| * sendet einen Float-Wert an den Room-Mananger | |
| * | |
| * <p>Sendet eine Gleitkommazahl an die Instanz mit der <b>InstanzID</b>, welche an einen Room-Manager angeschlossen ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-sendfloat/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Value <p>Zahlenwert mit Nachkommastelle</p> | |
| */ | |
| function MXC_SendFloat(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * sendet einen Integer-Wert an den Room-Mananger | |
| * | |
| * <p>Sendet einen booleanischen Wert an die Instanz mit der <b>InstanzID</b>, welche an einen Room-Manager angeschlossen ist.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-sendinteger/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>Zahlenwert ohne Nachkommastellen</p> | |
| */ | |
| function MXC_SendInteger(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * sendet einen Sollwert an den Stellantrieb | |
| * | |
| * <p>Setzt die neue Soll-Temperatur des Stellventils mit der <b>InstanzID</b> InstanzID auf die neue <b>Temperatur</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-settemperature/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Temperature <p>Temperatur in °C</p> | |
| */ | |
| function MXC_SetTemperature(int $InstanceID, float $Temperature) { | |
| } | |
| /** | |
| * bewegt den Rolladen nach unten bis zur Endposition/Stop | |
| * | |
| * <p>Bewegt den Rolladen mit der ID <b>InstanzID</b> nach unten, bis MXC_ShutterStop ausgeführt wird oder die Endposition erreicht wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-shuttermovedown/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function MXC_ShutterMoveDown(int $InstanceID) { | |
| } | |
| /** | |
| * bewegt den Rolladen nach oben bis zur Endposition/Stop | |
| * | |
| * <p>Bewegt den Rolladen mit der ID <b>InstanzID</b> nach oben, bis MXC_ShutterStop ausgeführt wird oder die Endposition erreicht wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-shuttermoveup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function MXC_ShutterMoveUp(int $InstanceID) { | |
| } | |
| /** | |
| * bewegt den Rolladen ein Stück nach unten | |
| * | |
| * <p>Bewegt den Rolladen mit der ID <b>InstanzID</b> einen Schritt nach unten.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-shutterstepdown/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function MXC_ShutterStepDown(int $InstanceID) { | |
| } | |
| /** | |
| * bewegt den Rolladen ein Stück nach oben | |
| * | |
| * <p>Bewegt den Rolladen mit der ID <b>InstanzID</b> einen Schritt nach oben.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-shutterstepup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function MXC_ShutterStepUp(int $InstanceID) { | |
| } | |
| /** | |
| * stoppt einen Bewegungsvorgang | |
| * | |
| * <p>Stoppt eine aktuelle Bewegung des Rolladens.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-shutterstop/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function MXC_ShutterStop(int $InstanceID) { | |
| } | |
| /** | |
| * schaltet ein xComfort Gerät an/aus | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xcomfort/mxc-switchmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function MXC_SwitchMode(int $InstanceID, bool $DeviceOn) { | |
| } | |
| /** | |
| * führt einen Lesevorgang auf einem Gerät aus | |
| * | |
| * <p>Führt einen erneuten Lesevorgang für das Gerät mit der ID <b>InstanzID</b> aus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-requestread/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function ModBus_RequestRead(int $InstanceID) { | |
| } | |
| /** | |
| * ModBus_UIUpdate | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $DataType | |
| */ | |
| function ModBus_UIUpdate(int $InstanceID, int $DataType) { | |
| } | |
| /** | |
| * setzt eine Adresse auf An/Aus | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse (Schreiben) der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writecoil/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $Value <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function ModBus_WriteCoil(int $InstanceID, bool $Value) { | |
| } | |
| /** | |
| * schreibt einen Wert in die Schreiben-Adresse | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse (Schreiben) der Instanz mit der ID <b>InstanzID</b>, ohne den genauen Datentyp zu wissen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregister/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Value <p>32Bit Gleitkommawert nach IEEE754 oder Ganzzahlig</p> | |
| */ | |
| function ModBus_WriteRegister(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Byte-Wert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse (Schreiben) der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregisterbyte/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>0-255</p> | |
| */ | |
| function ModBus_WriteRegisterByte(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Char-Wert | |
| * | |
| * <p>Die Funktion hieß bis einschließlich Version 4.3 __ModBus_WriteRegisterShortInt__</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregisterchar/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>-128 bis 127</p> | |
| */ | |
| function ModBus_WriteRegisterChar(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten DWord-Wert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse (Schreiben) der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregisterdword/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>0-4294967295</p> | |
| */ | |
| function ModBus_WriteRegisterDWord(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Int64-Wert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse (Schreiben) der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregisterint64/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Value <p>-9223372036854775808 bis 9223372036854775807</p> | |
| */ | |
| function ModBus_WriteRegisterInt64(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Integer-Wert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse (Schreiben) der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregisterinteger/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>-2147483648 bis 2147483647</p> | |
| */ | |
| function ModBus_WriteRegisterInteger(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Float-Wert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse (Schreiben) der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregisterreal/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Value <p>32Bit Gleitkommawert nach IEEE754</p> | |
| */ | |
| function ModBus_WriteRegisterReal(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Float-Wert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse (Schreiben) der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregisterreal64/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Value <p>64Bit Gleitkommawert nach IEEE754</p> | |
| */ | |
| function ModBus_WriteRegisterReal64(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Short-Wert | |
| * | |
| * <p>Die Funktion hieß bis einschließlich Version 4.3 __ModBus_WriteRegisterSmallInt__</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregistershort/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>-32768 bis 32767</p> | |
| */ | |
| function ModBus_WriteRegisterShort(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten String | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse (Schreiben) der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregisterstring/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Value <p>String, welcher auf Register geschrieben werden soll</p> | |
| */ | |
| function ModBus_WriteRegisterString(int $InstanceID, string $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Word-Wert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse (Schreiben) der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/modbus-rtu-tcp/modbus-writeregisterword/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>0-65535</p> | |
| */ | |
| function ModBus_WriteRegisterWord(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * NC_ActivateServer | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function NC_ActivateServer(int $InstanceID) { | |
| } | |
| /** | |
| * NC_AddDevice | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param string $Token | |
| * @param string $Provider | |
| * @param string $DeviceID | |
| * @param string $Name | |
| * @param int $WebFrontID | |
| */ | |
| function NC_AddDevice(int $InstanceID, string $Token, string $Provider, string $DeviceID, string $Name, int $WebFrontID) { | |
| } | |
| /** | |
| * NC_GetDevices | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function NC_GetDevices(int $InstanceID) { | |
| } | |
| /** | |
| * NC_GetRequestLimitCount | |
| * | |
| * @returns int | |
| * @param int $InstanceID | |
| */ | |
| function NC_GetRequestLimitCount(int $InstanceID) { | |
| } | |
| /** | |
| * NC_PushNotification | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $WebFrontID | |
| * @param string $Title | |
| * @param string $Body | |
| * @param string $Sound | |
| */ | |
| function NC_PushNotification(int $InstanceID, int $WebFrontID, string $Title, string $Body, string $Sound) { | |
| } | |
| /** | |
| * NC_PushNotificationEx | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $WebFrontID | |
| * @param string $Title | |
| * @param string $Body | |
| * @param string $Sound | |
| * @param int $CategoryID | |
| * @param int $TargetID | |
| */ | |
| function NC_PushNotificationEx(int $InstanceID, int $WebFrontID, string $Title, string $Body, string $Sound, int $CategoryID, int $TargetID) { | |
| } | |
| /** | |
| * NC_RemoveDevice | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $DeviceID | |
| */ | |
| function NC_RemoveDevice(int $InstanceID, int $DeviceID) { | |
| } | |
| /** | |
| * NC_RemoveDeviceConfigurator | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $DeviceID | |
| * @param int $WebFrontID | |
| */ | |
| function NC_RemoveDeviceConfigurator(int $InstanceID, int $DeviceID, int $WebFrontID) { | |
| } | |
| /** | |
| * NC_SetDeviceConfigurator | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $DeviceID | |
| * @param int $WebFrontID | |
| * @param bool $Enabled | |
| */ | |
| function NC_SetDeviceConfigurator(int $InstanceID, int $DeviceID, int $WebFrontID, bool $Enabled) { | |
| } | |
| /** | |
| * NC_SetDeviceName | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $DeviceID | |
| * @param string $Name | |
| */ | |
| function NC_SetDeviceName(int $InstanceID, int $DeviceID, string $Name) { | |
| } | |
| /** | |
| * NC_TestDevice | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $DeviceID | |
| */ | |
| function NC_TestDevice(int $InstanceID, int $DeviceID) { | |
| } | |
| /** | |
| * NC_UpdateFormList | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function NC_UpdateFormList(int $InstanceID) { | |
| } | |
| /** | |
| * sende eine Leseanfragen an das OneWire Gerät | |
| * | |
| * <p>Führt einen erneuten Lesevorgang für das Gerät mit der ID <b>InstanzID</b> aus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/1-wire/ow-requeststatus/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function OW_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * setzt einen Pin vom DS2450 auf an/aus | |
| * | |
| * <p>Setzt den Zustand vom Pin <b>Pin</b> des Geräts mit der ID <b>InstanzID</b> auf Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/1-wire/ds2450/ow-setpin/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Pin <p>0-3 (A-D)</p> | |
| * @param bool $SwitchOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function OW_SetPin(int $InstanceID, int $Pin, bool $SwitchOn) { | |
| } | |
| /** | |
| * setzt den kompletten Port vom DS2408 auf Wert | |
| * | |
| * <p>Setzt den Zustand von allen acht Pins auf den Wert von <b>Bitmaske</b> des Geräts mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/1-wire/ds2408/ow-setport/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>0-255 (Bit0 = Pin0 … Bit7 = Pin7)</p> | |
| */ | |
| function OW_SetPort(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt die Position vom DS2490 auf an/aus | |
| * | |
| * <p>Setzt das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Wert</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/1-wire/ds2890/ow-setposition/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>0-255</p> | |
| */ | |
| function OW_SetPosition(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * schaltet den Strobe vom DS2408 an/aus | |
| * | |
| * <p>Ermöglicht es, den RSTZ-Pin des DS2408 des Geräts mit der ID <b>InstanzID</b> auf Wert <b>Status</b> zu setzten</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/1-wire/ds2408/ow-setstrobe/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $Status <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function OW_SetStrobe(int $InstanceID, bool $Status) { | |
| } | |
| /** | |
| * setzt den Pin vom DS2405 auf an/aus | |
| * | |
| * <p>Setzt den Zustand des Geräts mit der ID <b>InstanzID</b> auf Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/1-wire/ds2405/ow-switchmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $SwitchOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function OW_SwitchMode(int $InstanceID, bool $SwitchOn) { | |
| } | |
| /** | |
| * toggelt den Pin vom DS2405 | |
| * | |
| * <p>Wechselt den Zustand des Geräts mit der ID <b>InstanzID</b>. Der aktuelle Wert kann nach dem Vorgang in der Status Variable abgefragt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/1-wire/ds2405/ow-togglemode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function OW_ToggleMode(int $InstanceID) { | |
| } | |
| /** | |
| * sendet mehrere Bytes an den DS2408 | |
| * | |
| * <p>Setzt eine Abfolge von Bytes (<b>Daten</b>) über alle Pins des Geräts mit der ID <b>InstanzID</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/1-wire/ds2408/ow-writebytes/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Data <p>Folge von Bytes, die versendet werden sollen</p> | |
| */ | |
| function OW_WriteBytes(int $InstanceID, string $Data) { | |
| } | |
| /** | |
| * sendet mehrere Bytes an den DS2408 unter Berücksichtigung einer Bitmaske | |
| * | |
| * <p>Setzt eine Abfolge von Bytes (<b>Daten</b>)unter Berücksichtung einer Bitmaske <b>Maske</b> über alle Pins des Geräts mit der ID <b>InstanzID</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/1-wire/ds2408/ow-writebytesmasked/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Data <p>Folge von Bytes, die versendet werden sollen</p> | |
| * @param int $Mask <p>Bitmaske der Bit die gesetzt werden sollen</p> | |
| */ | |
| function OW_WriteBytesMasked(int $InstanceID, string $Data, int $Mask) { | |
| } | |
| /** | |
| * OZW_GetKnownDevices | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function OZW_GetKnownDevices(int $InstanceID) { | |
| } | |
| /** | |
| * OZW_GetKnownItems | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function OZW_GetKnownItems(int $InstanceID) { | |
| } | |
| /** | |
| * fragt den Status eines Geräts ab | |
| * | |
| * <p>Fragt den Status des Geräts mit InstanzID <b>InstanzID</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/siemens-ozw/ozw-requeststatus/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des abzufragenden Geräts</p> | |
| */ | |
| function OZW_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * OZW_UpdateItems | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function OZW_UpdateItems(int $InstanceID) { | |
| } | |
| /** | |
| * schreibt einen bestimmten Wert in einen Datenpunkt | |
| * | |
| * <p>Setzt den Wert des Datenpunktes mit der ID <b>InstanzID</b> auf angegebenen Wert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/siemens-ozw/ozw-writedatapoint/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu verändernden Geräts</p> | |
| * @param mixed $Value <p>z.B. 23.5</p> | |
| */ | |
| function OZW_WriteDataPoint(int $InstanceID, mixed $Value) { | |
| } | |
| /** | |
| * OZW_WriteDataPointEx | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $DataPoint | |
| * @param mixed $Value | |
| */ | |
| function OZW_WriteDataPointEx(int $InstanceID, string $DataPoint, mixed $Value) { | |
| } | |
| /** | |
| * PAT_Stop | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function PAT_Stop(int $InstanceID) { | |
| } | |
| /** | |
| * PAT_Update | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function PAT_Update(int $InstanceID) { | |
| } | |
| /** | |
| * setzt die Anwesenheit auf true | |
| * | |
| * <p>Der Befehl setzt die Anwesenheitvariable der Instanz mit der ID <b>InstanzID</b> auf true.<br>Darüber hinaus wird die Anwesenheit für die im Modul eingestellte Totzeit festgesetzt und ändert sich nicht durch Status- oder Impulsvariablen. Während der Totzeit werden Impulse auf Impulsvariablen und Änderungen von Zustandsvariablen komplett ignoriert. Nach der Totzeit wird die Anweseheit initial auf Basis der Zustandsvariablen gesetzt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/presence-control/pc-enter/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Presence-Control-Instanz</p> | |
| */ | |
| function PC_Enter(int $InstanceID) { | |
| } | |
| /** | |
| * setzt die Anwesenheit auf false | |
| * | |
| * <p>Der Befehl setzt die Anwesenheitvariable der Instanz mit der ID <b>InstanzID</b> auf false.<br>Darüber hinaus wird die Anwesenheit für die im Modul eingestellte Totzeit festgesetzt und ändert sich nicht durch Status- oder Impulsvariablen. Während der Totzeit werden Impulse auf Impulsvariablen und Änderungen von Zustandsvariablen komplett ignoriert. Nach der Totzeit wird die Anweseheit initial auf Basis der Zustandsvariablen gesetzt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/presence-control/pc-leave/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Presence-Control-Instanz</p> | |
| */ | |
| function PC_Leave(int $InstanceID) { | |
| } | |
| /** | |
| * schaltet die Displaybeleuchtung An oder Aus | |
| * | |
| * <p>Schaltet die Displaybeleuchtung im FD-868 mit der ID <b>InstanzID</b> an oder aus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/fd-868/pj-backlight/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $Status <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function PJ_Backlight(int $InstanceID, bool $Status) { | |
| } | |
| /** | |
| * gibt ein Tonsignal aus | |
| * | |
| * <p>Gibt ein Tonsignal im FD-868 mit der ID <b>InstanzID</b> aus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/fd-868/pj-beep/ | |
| * @returns bool <p>default</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $TenthOfASecond <p>Länge des Tones in 1/10 Sekunden</p> | |
| */ | |
| function PJ_Beep(int $InstanceID, int $TenthOfASecond) { | |
| } | |
| /** | |
| * dimmt einen LED Stripe | |
| * | |
| * <p>Dimmt einen <b>RGB</b>-Farbwert mit der Helligkeit <b>W</b> mit individueller Zeitspanne in Sekunden an dem RGBW-868 Controller mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/rgbw-868/pj-dimrgbw/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $R <p>Helligkeitswert 0 (aus) bis 255 (an, maximale Helligkeit)</p> | |
| * @param int $RTime <p>In Sekunden in die der gewünschte Helligkeitswert erreicht werden soll</p> | |
| * @param int $G <p>Helligkeitswert 0 (aus) bis 255 (an, maximale Helligkeit)</p> | |
| * @param int $GTime <p>In Sekunden in die der gewünschte Helligkeitswert erreicht werden soll</p> | |
| * @param int $B <p>Helligkeitswert 0 (aus) bis 255 (an, maximale Helligkeit)</p> | |
| * @param int $BTime <p>In Sekunden in die der gewünschte Helligkeitswert erreicht werden soll</p> | |
| * @param int $W <p>Helligkeitswert 0 (aus) bis 255 (an, maximale Helligkeit)</p> | |
| * @param int $WTime <p>In Sekunden in die der gewünschte Helligkeitswert erreicht werden soll</p> | |
| */ | |
| function PJ_DimRGBW(int $InstanceID, int $R, int $RTime, int $G, int $GTime, int $B, int $BTime, int $W, int $WTime) { | |
| } | |
| /** | |
| * setzt Schrittweise einen Servo-Wert | |
| * | |
| * <p>Setzt einen Servo-Kanal <b>Kanal</b> an dem Controller mit der ID <b>InstanzID</b> auf den Wert <b>Wert</b> in der Geschwindigkeit <b>Schritte</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/servo-868/pj-dimservo/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Channel <p>Servo-Kanal 1..4</p> | |
| * @param int $Value <p>Wert von 0..255</p> | |
| * @param int $Steps <p>Schritte von 0 (sofort) über 1 (langsam) bis 255 (schnell)</p> | |
| */ | |
| function PJ_DimServo(int $InstanceID, int $Channel, int $Value, int $Steps) { | |
| } | |
| /** | |
| * sendet einen Text an das Display | |
| * | |
| * <p>Sendet einen Text an das FD-868 der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/fd-868/pj-lcdtext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Line <p>Zeilennummer des Display (1 oder 2)</p> | |
| * @param string $Text <p>Zeilentext, maximal 16 Zeichen – der Rest wird abgeschnitten</p> | |
| */ | |
| function PJ_LCDText(int $InstanceID, int $Line, string $Text) { | |
| } | |
| /** | |
| * Frage den Status von Variablen ab und setzt diese | |
| * | |
| * <p>Fragt die aktuellen Werte für das Gerät mit der ID <b>InstanzID</b> ab und schreibt diese in die entsprechenden Status-Variablen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/lgs-868/pj-requeststatus/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| */ | |
| function PJ_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * startet ein Lichtprogramm | |
| * | |
| * <p>Startet ein Lichtprogramm <b>Programm</b> an dem RGBW-868 Controller mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/rgbw-868/pj-runprogram/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Type <p>0 – alle RGBW auf Aus; 1 – alle RGBW auf den letzten Helligkeits-Wert; 2- Blinken langsam; 3- Blinken schnell; 4- Blitzen (Flash) langsam; 5- Blitzen (Flash) schnell; 6- An- u. Abschwellen (Fade) langsam</p> | |
| */ | |
| function PJ_RunProgram(int $InstanceID, int $Type) { | |
| } | |
| /** | |
| * schaltet LEDs am LuftGüteSensor | |
| * | |
| * <p>Schaltet die LEDs an dem Controller mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/lgs-868/pj-setleds/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $Green <p>Schaltet die grüne LED</p> | |
| * @param bool $Yellow <p>Schaltet die gelbe LED</p> | |
| * @param bool $Red <p>Schaltet die rote LED</p> | |
| */ | |
| function PJ_SetLEDs(int $InstanceID, bool $Green, bool $Yellow, bool $Red) { | |
| } | |
| /** | |
| * setzt einen Farbwert | |
| * | |
| * <p>Setzt einen <b>RGB</b>-Farbwert mit der Helligkeit <b>W</b> an dem Controller mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/rgbw-868/pj-setrgbw/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $R <p>Helligkeitswert 0 (aus) bis 255 (an, maximale Helligkeit)</p> | |
| * @param int $G <p>Helligkeitswert 0 (aus) bis 255 (an, maximale Helligkeit)</p> | |
| * @param int $B <p>Helligkeitswert 0 (aus) bis 255 (an, maximale Helligkeit)</p> | |
| * @param int $W <p>Gesamthelligkeitswert 0 (aus) bis 255 (an, maximale Helligkeit)</p> | |
| */ | |
| function PJ_SetRGBW(int $InstanceID, int $R, int $G, int $B, int $W) { | |
| } | |
| /** | |
| * setzt einen Servo Kanal | |
| * | |
| * <p>Setzt einen Servo-Kanal <b>Kanal</b> an dem Controller mit der ID <b>InstanzID</b> auf den <b>Wert</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/servo-868/pj-setservo/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Channel <p>Servo-Kanal 1..4</p> | |
| * @param int $Value <p>Wert von 0..255</p> | |
| */ | |
| function PJ_SetServo(int $InstanceID, int $Channel, int $Value) { | |
| } | |
| /** | |
| * Setzt den Ausgang auf eine bestimmte Spannung | |
| * | |
| * <p>Setzt für das Gerät mit der ID <b>InstanzID</b> den Ausgang auf die Spannung <b>Volt</b>. Höhere Werte als 10V werden automatisch begrenzt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/ana-868/pj-setvoltage/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param float $Voltage <p>Spannung auf den der Ausgang gesetzt werden soll</p> | |
| */ | |
| function PJ_SetVoltage(int $InstanceID, float $Voltage) { | |
| } | |
| /** | |
| * schaltet ein Relais | |
| * | |
| * <p>Schaltet das Relais vom WDT mit der ID <b>InstanzID</b> auf Wert <b>Status</b> für <b>Dauer</b> Sekunden</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/wdt-868/pj-switchduration/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| * @param int $Duration <p>Ein- oder Ausschaltdauer in Sekunden</p> | |
| */ | |
| function PJ_SwitchDuration(int $InstanceID, bool $DeviceOn, int $Duration) { | |
| } | |
| /** | |
| * schaltet einen LED vom Display | |
| * | |
| * <p>Schaltet eine Leuchtdiode vom FD-868 mit der ID <b>InstanzID</b> ein oder aus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/fd-868/pj-switchled/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $LED <p>1</p> | |
| * @param bool $Status <p>True = Ein / False = Aus</p> | |
| */ | |
| function PJ_SwitchLED(int $InstanceID, int $LED, bool $Status) { | |
| } | |
| /** | |
| * sendet einen Schaltbefehl | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf Wert Status.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ips-868/wdt-868/pj-switchmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function PJ_SwitchMode(int $InstanceID, bool $DeviceOn) { | |
| } | |
| /** | |
| * löscht eine Mail mit einer bestimmten E-Mail(UID) | |
| * | |
| * <p>Der Befehl löscht eine E-Mail mit der UID <b>UID</b> aus der POP3-Instanz mit der ID <b>InstanzID</b>. Sollte die Instanz oder eine E-Mail mit der übergebenen UID nicht existieren, wird eine Warnung generiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/pop3/pop3-deletemail/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der POP3-Instanz</p> | |
| * @param string $UID <p>UID der zu löschenden E-Mail</p> | |
| */ | |
| function POP3_DeleteMail(int $InstanceID, string $UID) { | |
| } | |
| /** | |
| * gibt ein Array zu den gecachten E-Mails zurück | |
| * | |
| * <p>Der Befehl gibt ein Array mit Informationen über die gecacheten E-Mails einer POP3-Instanz mit der ID <b>InstanzID</b> zurück. Sollte die Instanz nicht existieren, wird eine Warnung generiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/pop3/pop3-getcachedmails/ | |
| * @returns array <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis ein Array mit Daten zu den gecacheten E-Mails, andernfalls ein Boolean mit dem Wert <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der POP3-Instanz</p> | |
| */ | |
| function POP3_GetCachedMails(int $InstanceID) { | |
| } | |
| /** | |
| * liefert ein Array mit Informationen zu einer bestimmten E-Mail(UID) wieder | |
| * | |
| * <p>Der Befehl lädt eine E-Mail mit der UID <b>UID</b> über die POP3-Instanz mit der ID <b>InstanzID</b> und gibt ein Array mit den Daten der E-Mail zurück. Sollte die Instanz oder eine E-Mail mit der übergebenen UID nicht existieren, wird eine Warnung generiert.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/pop3/pop3-getmailex/ | |
| * @returns array <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis ein Array mit den Daten der E-Mail, andernfalls ein Boolean mit <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der POP3-Instanz</p> | |
| * @param string $UID <p>UID der zu ladenden E-Mail</p> | |
| */ | |
| function POP3_GetMailEx(int $InstanceID, string $UID) { | |
| } | |
| /** | |
| * POP3_UpdateCache | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function POP3_UpdateCache(int $InstanceID) { | |
| } | |
| /** | |
| * POP3_UpdateFormUseSSL | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $UseSSL | |
| */ | |
| function POP3_UpdateFormUseSSL(int $InstanceID, bool $UseSSL) { | |
| } | |
| /** | |
| * liest den internen Puffer | |
| * | |
| * <p>Liest den internen Puffer der Instanz mit ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/registervariable/regvar-getbuffer/ | |
| * @returns string <p>String des aktuellen Puffers</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function RegVar_GetBuffer(int $InstanceID) { | |
| } | |
| /** | |
| * sendet ein Event an die übergeordnete HID-Instanz | |
| * | |
| * <p>Sendet einen String <b>Text</b> über die Instanz mit der ID <b>InstanzID</b> als Datensatztyp <b>ReportID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/registervariable/regvar-sendevent/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der RegisterVariable-Instanz</p> | |
| * @param int $ReportID <p>Der Datensatztyp als ReportID</p> | |
| * @param string $Text <p>Zu sendender Puffer</p> | |
| */ | |
| function RegVar_SendEvent(int $InstanceID, int $ReportID, string $Text) { | |
| } | |
| /** | |
| * sendet ein Datenpaket an die angegebene IP-Adresse | |
| * | |
| * <p>Sendet ein Datenpaket <b>Text</b> über die Instanz mit der ID <b>InstanzID</b>. Zusätzlich werden noch die IP-Adresse <b>ClientIP</b> und der Port <b>ClientPort</b> angegeben.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/registervariable/regvar-sendpacket/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der RegisterVariable-Instanz</p> | |
| * @param string $Text <p>Zu sendender Puffer</p> | |
| * @param string $ClientIP <p>IP-Adresse an die gesendet werden soll</p> | |
| * @param int $ClientPort <p>Port an den gesendet werden soll</p> | |
| */ | |
| function RegVar_SendPacket(int $InstanceID, string $Text, string $ClientIP, int $ClientPort) { | |
| } | |
| /** | |
| * sendet Daten an die übergeordnete Instanz | |
| * | |
| * <p>Sendet einen String <b>Text</b> über die Instanz mit der ID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/registervariable/regvar-sendtext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Text <p>Zu sendender Puffer</p> | |
| */ | |
| function RegVar_SendText(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * setzt den internen Puffer | |
| * | |
| * <p>Setzt den internen Puffer der Instanz mit ID <b>InstanzID</b> auf Wert <b>Puffer</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/registervariable/regvar-setbuffer/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Text <p>Daten, die in den Puffer geschrieben werden sollen</p> | |
| */ | |
| function RegVar_SetBuffer(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * führe die Aktion einer IP-Symcon Variable aus | |
| * | |
| * <p>Die Funktion führt die Aktion der Variable mit der ID <b>VariablenID</b> mit dem Wert <b>Wert</b> aus. Hierbei wird die gleiche Schaltaktion wie im WebFront und anderen Visualisierungen verwendet. Ist für die Variable ein eigenes Aktionsskript definiert, so wird dies Skript ausgeführt. Ansonsten wird, falls vorhanden, die Standardaktion einer Instanzvariable ausgeführt. Existiert weder eine eigene noch eine Standardaktion, so führt die Funtkion RequestAction zu einem Fehler. Üblicherweise schalten Variablenaktionen die dazugehörige Eigenschaft eines Gerätes entsprechend des neuen Wertes und setzen abschließend den Wert der Variablen entsprechend. Kommt es beim Schalten zu einem Fehler, wird dieser ausgegeben. Es ist darauf zu achten, dass der Typ des Wertes zum Typ der Variablen passt. Ist die Zielvariable vom Typ String, so sollte auch Wert vom Typ String sein. Des Weiteren steht im Skript die Systemvariable mit $_IPS["SENDER"] = Action zur Verfügung. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/requestaction/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| * @param mixed $Value <p>Wert für die Aktion</p> | |
| */ | |
| function RequestAction(int $VariableID, mixed $Value) { | |
| } | |
| /** | |
| * führe die Aktion einer IP-Symcon Variable mit individuellen Sender aus | |
| * | |
| * <p>Die Funktion führt die Aktion der Variable mit der ID <b>VariablenID</b> mit dem Wert <b>Wert</b> und dem Sender <b>Sender</b> aus. Hierbei wird die gleiche Schaltaktion wie im WebFront und anderen Visualisierungen verwendet. Ist für die Variable ein eigenes Aktionsskript definiert, so wird dies Skript ausgeführt. Ansonsten wird, falls vorhanden, die Standardaktion einer Instanzvariable ausgeführt. Existiert weder eine eigene noch eine Standardaktion, so führt die Funtkion RequestAction zu einem Fehler. Üblicherweise schalten Variablenaktionen die dazugehörige Eigenschaft eines Gerätes entsprechend des neuen Wertes und setzen abschließend den Wert der Variablen entsprechend. Kommt es beim Schalten zu einem Fehler, wird dieser ausgegeben. Es ist darauf zu achten, dass der Typ des Wertes zum Typ der Variablen passt. Ist die Zielvariable vom Typ String, so sollte auch Wert vom Typ String sein. Des Weiteren steht im Skript die Systemvariable mit $_IPS["SENDER"] = Action zur Verfügung. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/requestactionex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| * @param mixed $Value <p>Wert für die Aktion</p> | |
| * @param string $Sender <p>Name des Sender</p> | |
| */ | |
| function RequestActionEx(int $VariableID, mixed $Value, string $Sender) { | |
| } | |
| /** | |
| * führt einen Lesevorgang auf einem Gerät aus | |
| * | |
| * <p>Führt einen erneuten Lesevorgang für das Gerät mit der ID <b>InstanzID</b> aus.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sps-siemens-vipa-logo/s7-requestread/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function S7_RequestRead(int $InstanceID) { | |
| } | |
| /** | |
| * schreibt einen Wert in die konfigurierte Adresse | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse der Instanz mit der ID <b>InstanzID</b>, ohne den genauen Datentyp zu wissen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sps-siemens-vipa-logo/s7-write/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Value <p>32Bit Gleitkommawert nach IEEE754 oder Ganzzahlig</p> | |
| */ | |
| function S7_Write(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf An/Aus | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sps-siemens-vipa-logo/s7-writebit/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param bool $Value <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function S7_WriteBit(int $InstanceID, bool $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Bytewert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sps-siemens-vipa-logo/s7-writebyte/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>0-255</p> | |
| */ | |
| function S7_WriteByte(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Char | |
| * | |
| * <p>Die Funktion hieß bis einschließlich Version 4.3 __S7_WriteShortInt__</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sps-siemens-vipa-logo/s7-writechar/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>-128 bis 127</p> | |
| */ | |
| function S7_WriteChar(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten unsigned Integerwert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sps-siemens-vipa-logo/s7-writedword/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>0-4294967295</p> | |
| */ | |
| function S7_WriteDWord(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Integerwert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sps-siemens-vipa-logo/s7-writeinteger/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>-2147483648 bis 2147483647</p> | |
| */ | |
| function S7_WriteInteger(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Floatwert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sps-siemens-vipa-logo/s7-writereal/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param float $Value <p>64Bit Gleitkommawert nach IEEE754</p> | |
| */ | |
| function S7_WriteReal(int $InstanceID, float $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten Shortwert | |
| * | |
| * <p>Die Funktion hieß bis einschließlich Version 4.3 __S7_WriteSmallInt__</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sps-siemens-vipa-logo/s7-writeshort/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>-32768 bis 32767</p> | |
| */ | |
| function S7_WriteShort(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * S7_WriteString | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Value | |
| */ | |
| function S7_WriteString(int $InstanceID, string $Value) { | |
| } | |
| /** | |
| * setzt eine Adresse auf einen bestimmten unsigned Smallintegerwert | |
| * | |
| * <p>Schreibt den Wert <b>Wert</b> in die konfigurierte Adresse der Instanz mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sps-siemens-vipa-logo/s7-writeword/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Value <p>0-65535</p> | |
| */ | |
| function S7_WriteWord(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * SC_CreateSkin | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $SkinURL | |
| */ | |
| function SC_CreateSkin(int $InstanceID, string $SkinURL) { | |
| } | |
| /** | |
| * SC_DeleteModule | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $BundleID | |
| */ | |
| function SC_DeleteModule(int $InstanceID, string $BundleID) { | |
| } | |
| /** | |
| * SC_DeleteSkin | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| */ | |
| function SC_DeleteSkin(int $InstanceID, string $Skin) { | |
| } | |
| /** | |
| * SC_GetLastConfirmedStoreConditions | |
| * | |
| * @returns int | |
| * @param int $InstanceID | |
| */ | |
| function SC_GetLastConfirmedStoreConditions(int $InstanceID) { | |
| } | |
| /** | |
| * SC_GetModuleInfoList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function SC_GetModuleInfoList(int $InstanceID) { | |
| } | |
| /** | |
| * SC_GetSkin | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| */ | |
| function SC_GetSkin(int $InstanceID, string $Skin) { | |
| } | |
| /** | |
| * SC_GetSkinIconContent | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| * @param string $Icon | |
| */ | |
| function SC_GetSkinIconContent(int $InstanceID, string $Skin, string $Icon) { | |
| } | |
| /** | |
| * SC_GetSkinList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function SC_GetSkinList(int $InstanceID) { | |
| } | |
| /** | |
| * SC_GetSkinRepositoryInfo | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| */ | |
| function SC_GetSkinRepositoryInfo(int $InstanceID, string $Skin) { | |
| } | |
| /** | |
| * SC_GetSkinRepositoryLocalBranchList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| */ | |
| function SC_GetSkinRepositoryLocalBranchList(int $InstanceID, string $Skin) { | |
| } | |
| /** | |
| * SC_GetSkinRepositoryRemoteBranchList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| */ | |
| function SC_GetSkinRepositoryRemoteBranchList(int $InstanceID, string $Skin) { | |
| } | |
| /** | |
| * SC_InstallModule | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $BundleID | |
| * @param int $Channel | |
| * enum[0=scStable, 1=scBeta, 2=scTesting] | |
| * @param int $ReleaseID | |
| */ | |
| function SC_InstallModule(int $InstanceID, string $BundleID, int $Channel, int $ReleaseID) { | |
| } | |
| /** | |
| * SC_IsSkinClean | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| */ | |
| function SC_IsSkinClean(int $InstanceID, string $Skin) { | |
| } | |
| /** | |
| * SC_IsSkinUpdateAvailable | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| */ | |
| function SC_IsSkinUpdateAvailable(int $InstanceID, string $Skin) { | |
| } | |
| /** | |
| * SC_IsSkinValid | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| */ | |
| function SC_IsSkinValid(int $InstanceID, string $Skin) { | |
| } | |
| /** | |
| * SC_MakeRequest | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param string $Endpoint | |
| * @param string $Method | |
| * @param string $Body | |
| */ | |
| function SC_MakeRequest(int $InstanceID, string $Endpoint, string $Method, string $Body) { | |
| } | |
| /** | |
| * bewegt den Rolladen an eine bestimmte Position | |
| * | |
| * <p>Bewegt den Rolladen für das Gerät mit der ID <b>InstanzID</b> auf die <b>Position</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/shutter-control-legacy/sc-move/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Shutter Control Instanz</p> | |
| * @param int $Position <p>0%-100%, 99% = Auf Spalt fahren</p> | |
| */ | |
| function SC_Move(int $InstanceID, int $Position) { | |
| } | |
| /** | |
| * bewegt den Rolladen bis zu Endposition runter | |
| * | |
| * <p>Bewegt den Rolladen für das Gerät mit der ID <b>InstanzID</b> für <b>Dauer</b> Millisekunden nach unten.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/shutter-control-legacy/sc-movedown/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Shutter Control Instanz</p> | |
| * @param int $Duration <p>0 = Endlagenschalter, >1 = Dauer in ms</p> | |
| */ | |
| function SC_MoveDown(int $InstanceID, int $Duration) { | |
| } | |
| /** | |
| * bewegt den Rolladen bis zu Endposition hoch | |
| * | |
| * <p>Bewegt den Rolladen für das Gerät mit der ID <b>InstanzID</b> für <b>Dauer</b> Millisekunden nach oben.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/shutter-control-legacy/sc-moveup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Shutter Control Instanz</p> | |
| * @param int $Duration <p>0 = Endlagenschalter, >1 = Dauer in ms</p> | |
| */ | |
| function SC_MoveUp(int $InstanceID, int $Duration) { | |
| } | |
| /** | |
| * SC_RevertSkin | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| */ | |
| function SC_RevertSkin(int $InstanceID, string $Skin) { | |
| } | |
| /** | |
| * SC_SetLastConfirmedStoreConditions | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $LastConfirmedStoreConditions | |
| */ | |
| function SC_SetLastConfirmedStoreConditions(int $InstanceID, int $LastConfirmedStoreConditions) { | |
| } | |
| /** | |
| * stoppt einen Bewegungsvorgang | |
| * | |
| * <p>Stoppt einen Bewegungsvorgang für das Gerät mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/shutter-control-legacy/sc-stop/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der Shutter Control Instanz</p> | |
| */ | |
| function SC_Stop(int $InstanceID) { | |
| } | |
| /** | |
| * SC_UpdateSkin | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| */ | |
| function SC_UpdateSkin(int $InstanceID, string $Skin) { | |
| } | |
| /** | |
| * SC_UpdateSkinRepositoryBranch | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Skin | |
| * @param string $Branch | |
| */ | |
| function SC_UpdateSkinRepositoryBranch(int $InstanceID, string $Skin, string $Branch) { | |
| } | |
| /** | |
| * SIT_SetIcon | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param string $Icon | |
| */ | |
| function SIT_SetIcon(int $InstanceID, string $Icon) { | |
| } | |
| /** | |
| * SMS_RequestBalance | |
| * | |
| * @returns float | |
| * @param int $InstanceID | |
| */ | |
| function SMS_RequestBalance(int $InstanceID) { | |
| } | |
| /** | |
| * SMS_RequestStatus | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param string $MsgID | |
| */ | |
| function SMS_RequestStatus(int $InstanceID, string $MsgID) { | |
| } | |
| /** | |
| * versendet eine E-Mail an die Standardadresse | |
| * | |
| * <p>Sendet über die Instanz mit der ID <b>InstanzID</b> eine SMS mit dem Text an Nummer.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/sms/sms-send/ | |
| * @returns string <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Number <p>Mobilfunknummer des Empfängers</p> | |
| * @param string $Text <p>Text der SMS (max. 160 Zeichen)</p> | |
| */ | |
| function SMS_Send(int $InstanceID, string $Number, string $Text) { | |
| } | |
| /** | |
| * versendet eine E-Mail an die Standardadresse | |
| * | |
| * <p>Sendet über die Instanz mit der ID <b>InstanzID</b> eine E-Mail mit dem Betreff und Text.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/smtp/smtp-sendmail/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der SMTP Instanz</p> | |
| * @param string $Subject <p>Betreff der E-Mail</p> | |
| * @param string $Textg <p>Text der E-Mail</p> | |
| */ | |
| function SMTP_SendMail(int $InstanceID, string $Subject, string $Textg) { | |
| } | |
| /** | |
| * versendet eine E-Mail mit Anhang an die Standardadresse | |
| * | |
| * <p>Sendet über die Instanz mit der ID <b>InstanzID</b> eine E-Mail mit dem Betreff, Anhang und Text.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/smtp/smtp-sendmailattachment/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der SMTP Instanz</p> | |
| * @param string $Subject <p>Betreff der E-Mail</p> | |
| * @param string $Text <p>Text der E-Mail</p> | |
| * @param string $Filename <p>Pfad zur Datei</p> | |
| */ | |
| function SMTP_SendMailAttachment(int $InstanceID, string $Subject, string $Text, string $Filename) { | |
| } | |
| /** | |
| * versendet eine E-Mail mit Anhang an eine beliebige Adresse | |
| * | |
| * <p>Sendet über die Instanz mit der ID <b>InstanzID</b> eine E-Mail mit dem Betreff, Anhang und Text an Empfänger. Im Gegensatz zur SMTP_SendMail Funktion kann hier der Empfänger explizit im Funktionsaufruf angegeben werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/smtp/smtp-sendmailattachmentex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der SMTP Instanz</p> | |
| * @param string $Address <p>E-Mail Adresse des Empfängers</p> | |
| * @param string $Subject <p>Betreff der E-Mail</p> | |
| * @param string $Text <p>Text der E-Mail</p> | |
| * @param string $Filename <p>Pfad zur Datei</p> | |
| */ | |
| function SMTP_SendMailAttachmentEx(int $InstanceID, string $Address, string $Subject, string $Text, string $Filename) { | |
| } | |
| /** | |
| * versendet eine E-Mail an eine beliebige Adresse | |
| * | |
| * <p>Sendet über die Instanz mit der ID <b>InstanzID</b> eine E-Mail mit dem Betreff und Text an Empfänger. Im Gegensatz zur SMTP_SendMail Funktion kann hier der Empfänger explizit im Funktionsaufruf angegeben werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/smtp/smtp-sendmailex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der SMTP Instanz</p> | |
| * @param string $Address <p>E-Mail Adresse des Empfängers</p> | |
| * @param string $Subject <p>Betreff der E-Mail</p> | |
| * @param string $Text <p>Text der E-Mail</p> | |
| */ | |
| function SMTP_SendMailEx(int $InstanceID, string $Address, string $Subject, string $Text) { | |
| } | |
| /** | |
| * versendet eine E-Mail mit Anhang eines Medienobjekts vom Typ "Bild/Ton" an die Standardadresse | |
| * | |
| * <p>Sendet über die Instanz mit der ID <b>InstanzID</b> eine E-Mail mit dem Betreff, Medienobjekt und Text.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/smtp/smtp-sendmailmedia/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der SMTP Instanz</p> | |
| * @param string $Subject <p>Betreff der E-Mail</p> | |
| * @param string $Text <p>Text der E-Mail</p> | |
| * @param int $MediaID <p>ID des Medienobjekts (nur Bild/Ton und Dokument)</p> | |
| */ | |
| function SMTP_SendMailMedia(int $InstanceID, string $Subject, string $Text, int $MediaID) { | |
| } | |
| /** | |
| * versendet eine E-Mail mit Anhang eines Medienobjekts vom Typ "Bild/Ton" an eine beliebige Adresse | |
| * | |
| * <p>Sendet über die Instanz mit der ID <b>InstanzID</b> eine E-Mail mit dem Betreff, Medienobjekt und Text an Empfänger. Im Gegensatz zur SMTP_SendMailMedia Funktion kann hier der Empfänger explizit im Funktionsaufruf angegeben werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/smtp/smtp-sendmailmediaex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der SMTP Instanz</p> | |
| * @param string $Address <p>E-Mail Adresse des Empfängers</p> | |
| * @param string $Subject <p>Betreff der E-Mail</p> | |
| * @param string $Text <p>Text der E-Mail</p> | |
| * @param int $MediaID <p>ID des Medienobjekts (nur Bild/Ton und Dokument)</p> | |
| */ | |
| function SMTP_SendMailMediaEx(int $InstanceID, string $Address, string $Subject, string $Text, int $MediaID) { | |
| } | |
| /** | |
| * SMTP_UpdateFormUseSSL | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $UseSSL | |
| */ | |
| function SMTP_UpdateFormUseSSL(int $InstanceID, bool $UseSSL) { | |
| } | |
| /** | |
| * SM_HelloWorld | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function SM_HelloWorld(int $InstanceID) { | |
| } | |
| /** | |
| * sendet einen String auf den I/O | |
| * | |
| * <p>Sendet den String <b>Text</b> auf dem Serial Port mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/serialport/sprt-sendtext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden Serial Ports</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| */ | |
| function SPRT_SendText(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * schaltet den Break einer Serial Port Instanz | |
| * | |
| * <p>Schaltet den Break auf <b>AnAus</b> (True = An; False = Aus) auf dem Serial Port mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/serialport/sprt-setbreak/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden Serial Ports</p> | |
| * @param bool $OnOff <p>schaltet den Break An <b>True</b> oder Aus <b>False</b></p> | |
| */ | |
| function SPRT_SetBreak(int $InstanceID, bool $OnOff) { | |
| } | |
| /** | |
| * schaltet den DTR einer Serial Port Instanz | |
| * | |
| * <p>Schaltet den DTR auf <b>AnAus</b> (True = An; False = Aus) auf dem Serial Port mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/serialport/sprt-setdtr/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden Serial Ports</p> | |
| * @param bool $OnOff <p>schaltet den DTR An <b>True</b> oder Aus <b>False</b></p> | |
| */ | |
| function SPRT_SetDTR(int $InstanceID, bool $OnOff) { | |
| } | |
| /** | |
| * schaltet den RTS einer Serial Port Instanz | |
| * | |
| * <p>Schaltet den RTS auf <b>AnAus</b> (True = An; False = Aus) auf dem Serial Port mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/serialport/sprt-setrts/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden Serial Ports</p> | |
| * @param bool $OnOff <p>schaltet den RTS An <b>True</b> oder Aus <b>False</b></p> | |
| */ | |
| function SPRT_SetRTS(int $InstanceID, bool $OnOff) { | |
| } | |
| /** | |
| * sendet einen String auf den I/O | |
| * | |
| * <p>Sendet den String <b>Text</b> auf dem Server Socket mit der ID <b>InstanzID</b>. Als Empfängeradressierung wird die IP <b>ClientIP</b> und Port <b>ClientPort</b> genutzt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/serversocket/ssck-sendpacket/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden Server Sockets</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| * @param string $ClientIP <p>IP des Empfängers</p> | |
| * @param int $ClientPort <p>Port des Empfängers</p> | |
| */ | |
| function SSCK_SendPacket(int $InstanceID, string $Text, string $ClientIP, int $ClientPort) { | |
| } | |
| /** | |
| * sendet einen String auf den I/O | |
| * | |
| * <p>Sendet den String <b>Text</b> auf dem Server Socket mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/serversocket/ssck-sendtext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden Server Sockets</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| */ | |
| function SSCK_SendText(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * setzt den Wert einer IP-Symcon Variable unabhängig des Typs | |
| * | |
| * <p>Die Funktion schreibt den neuen Wert <b>Wert</b> in die IP-Symcon Variable mit der ID <b>VariablenID</b>. Es ist darauf zu achten, dass der Typ des Wertes zum Typ der Variablen passt. Ist die Zielvariable vom Typ String, so sollte auch Wert vom Typ String sein.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/setvalue/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| * @param mixed $Value <p>Neuer Wert der Variable</p> | |
| */ | |
| function SetValue(int $VariableID, mixed $Value) { | |
| } | |
| /** | |
| * setzt den Wert einer IP-Symcon Variable vom Typ Boolean | |
| * | |
| * <p>Die Funktion setzt den Inhalt der IP-Symcon Variablen mit der ID <b>VariablenID</b>. Die gewählte Variable muss vom Typ Boolean sein. Wenn nicht, bricht die Funktion mit einem Fehler ab. Eine Konvertierung wird nicht vorgenommen. Für ein typunsicheres Setzten der Variable kann die Funktion SetValue genutzt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/setvalueboolean/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| * @param bool $Value <p>TRUE/FALSE</p> | |
| */ | |
| function SetValueBoolean(int $VariableID, bool $Value) { | |
| } | |
| /** | |
| * setzt den Wert einer IP-Symcon Variable vom Typ Float | |
| * | |
| * <p>Die Funktion setzt den Inhalt der IP-Symcon Variablen mit der ID <b>VariablenID</b>. Die gewählte Variable muss vom Typ Float sein. Wenn nicht, bricht die Funktion mit einem Fehler ab. Eine Konvertierung von Integer/Boolean (0/1) wird vorgenommen. Für ein typunsicheres Setzten der Variable kann die Funktion SetValue genutzt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/setvaluefloat/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| * @param float $Value <p>64Bit Gleitkommazahl</p> | |
| */ | |
| function SetValueFloat(int $VariableID, float $Value) { | |
| } | |
| /** | |
| * setzt den Wert einer IP-Symcon Variable vom Typ Integer | |
| * | |
| * <p>Die Funktion setzt den Inhalt der IP-Symcon Variablen mit der ID <b>VariablenID</b>. Die gewählte Variable muss vom Typ Integer sein. Wenn nicht, bricht die Funktion mit einem Fehler ab. Eine Konvertierung von Float (Trunc)/Boolean (0/1) wird vorgenommen. Für ein typunsicheres Setzten der Variable können Sie die SetValue Funktion nutzen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/setvalueinteger/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| * @param int $Value <p>-2,147,483,648 .. 2,147,483,647</p> | |
| */ | |
| function SetValueInteger(int $VariableID, int $Value) { | |
| } | |
| /** | |
| * setzt den Wert einer IP-Symcon Variable vom Typ String | |
| * | |
| * <p>Die Funktion setzt den Inhalt der IP-Symcon Variablen mit der ID <b>VariablenID</b>. Die gewählte Variable muss vom Typ String sein. Wenn nicht, bricht die Funktion mit einem Fehler ab. Eine Konvertierung von Float/Integer/Boolean (False/True) wird vorgenommen. Für ein typunsicheres Setzten der Variable kann die Funktion SetValue genutzt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/befehlsreferenz/variablenzugriff/setvaluestring/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $VariableID <p>ID der Variable</p> | |
| * @param string $Value <p>Text</p> | |
| */ | |
| function SetValueString(int $VariableID, string $Value) { | |
| } | |
| /** | |
| * zeigt Informationen zur Batterie an | |
| * | |
| * <p>Gibt Informationen über das Vorhandensein einer Batterie, ob sie in Gebrauch ist und wieviel Prozent der Batterie noch vorhanden sind. Die Angaben der Restlaufzeit und maximalen Batterielaufzeit werden in Sekunden angegeben.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/system-informationen/sys-getbattery/ | |
| * @returns array <p>Array mit Informationen zur Batterie</p> | |
| */ | |
| function Sys_GetBattery() { | |
| } | |
| /** | |
| * zeigt die CPU Auslastung an | |
| * | |
| * <p><b>Ab Version 4.0</b><br>Liefert für jede CPU die aktuelle Last (CPU_*) und die momentane Durchschnittlast für alle CPU Kerne (CPU_AVG).</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/system-informationen/sys-getcpuinfo/ | |
| * @returns array <p>Array mit Informationen zur CPU-Auslastung</p> | |
| */ | |
| function Sys_GetCPUInfo() { | |
| } | |
| /** | |
| * zeigt den Festplattenspeicherplatz/-verbrauch an | |
| * | |
| * <p>Liefert Informationen zu den vorhandenen Festplatten im System inklusive der Größe und dem bereits verbrauchten Speicher.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/system-informationen/sys-getharddiskinfo/ | |
| * @returns array <p>Array mit Informationen zu allen Festplatten</p> | |
| */ | |
| function Sys_GetHardDiskInfo() { | |
| } | |
| /** | |
| * zeigt den Speicherverbrauch an | |
| * | |
| * <p>Gibt Informationen zum Speicherverbrauch des Betriebssystems.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/system-informationen/sys-getmemoryinfo/ | |
| * @returns array <p>Array mit Informationen zum Gesamtspeicherverbrauch und virtuellen Speicherverbrauch</p> | |
| */ | |
| function Sys_GetMemoryInfo() { | |
| } | |
| /** | |
| * zeigt Informationen zu den Netzwerkadaptern | |
| * | |
| * <p>Liefert Informationen über alle Netzwerkadapter</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/system-informationen/sys-getnetworkinfo/ | |
| * @returns array <p>Array mit Informationen zu allen Netzwerkadaptern</p> | |
| */ | |
| function Sys_GetNetworkInfo() { | |
| } | |
| /** | |
| * listet alle Prozesse auf | |
| * | |
| * <p>Gibt Informationen zum Prozess von IP-Symcon.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/system-informationen/sys-getprocessinfo/ | |
| * @returns array <p>Array mit Informationen, wie z.B. Speicherverbrauch und Anzahl der Threads</p> | |
| */ | |
| function Sys_GetProcessInfo() { | |
| } | |
| /** | |
| * zeigt Informationen zu den Druckerwarteschlangen an | |
| * | |
| * <p>Gibt Informationen über alle Druckerwarteschlangen aus</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/system-informationen/sys-getspooler/ | |
| * @returns array <p>Array mit Informationen zu allen Druckerwarteschlagen und den im Druck befindlichen Dokumenten</p> | |
| */ | |
| function Sys_GetSpooler() { | |
| } | |
| /** | |
| * liest den Inhalt einer URL als String aus | |
| * | |
| * <p>Liest den Inhalt der <b>URL</b> aus und gibt ihn als Rückgabewert zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/system-informationen/sys-geturlcontent/ | |
| * @returns string <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis den Inhalt der Webseite (auch Binärcode), andernfalls <b>FALSE</b>.</p> | |
| * @param string $URL <p>Vollständige URL</p> | |
| */ | |
| function Sys_GetURLContent(string $URL) { | |
| } | |
| /** | |
| * liest den Inhalt einer URL als String aus und bietet die Möglichkeit einen Proxy zu spezifizieren | |
| * | |
| * <p>Liest den Inhalt der <b>URL</b> aus und gibt ihn als Rückgabewert zurück. Dabei können einige <b>Parameter</b> für Timeouts, Authentifizierung und Proxy vorgenommen werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/system-informationen/sys-geturlcontentex/ | |
| * @returns string <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis den Inhalt der Webseite (auch Binärcode), andernfalls <b>FALSE</b>.</p> | |
| * @param string $URL <p>Vollständige URL</p> | |
| * @param array $Options <p>Array mit Index => Value Paaren</p><li>TimeoutInteger<b>Default = 10000</b>. Timeout in Millisekunden</li><li>AuthUserString<b>Default = ""</b>. Benutzername für Basis-Authentifizierung</li><li>AuthPassString<b>Default = ""</b>. Passwort für Basis-Authentifizierung</li><li>VerifyPeerBoolean<b>Default = true</b>. Verifiziere, dass das SSL Zertifikat des Hosts korrekt ist (nur sichtbar falls Benutze SSL aktiv ist)</li><li>VerifyHostBoolean<b>Default = true</b>. Verifiziere, dass die Host URL aus dem SSL Zertifikat mit dem Host aus der Eigenschaft übereinstimmt (nur sichtbar falls Benutze SSL aktiv ist)</li> | |
| */ | |
| function Sys_GetURLContentEx(string $URL, array $Options) { | |
| } | |
| /** | |
| * sendet einen Ping an ein Netzwerkgerät | |
| * | |
| * <p>Sendet einen Ping an <b>Host</b> und wartet <b>Timeout</b> Millisekunden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/system-informationen/sys-ping/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param string $Host <p>Rechnername oder IP-Adresse</p> | |
| * @param int $Timeout <p>Zeit in Millisekunden</p> | |
| */ | |
| function Sys_Ping(string $Host, int $Timeout) { | |
| } | |
| /** | |
| * TC_AddLanguage | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Language | |
| */ | |
| function TC_AddLanguage(int $InstanceID, string $Language) { | |
| } | |
| /** | |
| * TC_AddTranslation | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Language | |
| * @param string $SourceText | |
| * @param string $TranslatedText | |
| */ | |
| function TC_AddTranslation(int $InstanceID, string $Language, string $SourceText, string $TranslatedText) { | |
| } | |
| /** | |
| * TC_GetLanguages | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function TC_GetLanguages(int $InstanceID) { | |
| } | |
| /** | |
| * TC_RemoveLanguage | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Language | |
| */ | |
| function TC_RemoveLanguage(int $InstanceID, string $Language) { | |
| } | |
| /** | |
| * TC_RemoveTranslation | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Language | |
| * @param string $SourceText | |
| */ | |
| function TC_RemoveTranslation(int $InstanceID, string $Language, string $SourceText) { | |
| } | |
| /** | |
| * TC_UpdateTranslation | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Language | |
| * @param string $SourceText | |
| * @param string $TranslatedText | |
| */ | |
| function TC_UpdateTranslation(int $InstanceID, string $Language, string $SourceText, string $TranslatedText) { | |
| } | |
| /** | |
| * generiert eine WAV Datei mit dem gewünschten Text | |
| * | |
| * <p>Generiert über das Text-To-Speech Modul mit der ID <b>InstanzID</b> eine Sounddatei im Wav-Format in die Datei <b>Dateiname</b>. Der Format Parameter bestimmt die Qualität der Wav Datei.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/text-to-speech/tts-generatefile/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Text-To-Speech Moduls</p> | |
| * @param string $Text <p>Zu sagender Text</p> | |
| * @param string $Filename <p>Dateiname/-pfad im System</p> | |
| * @param int $Format <li>Default0</li><li>8kHz, 8Bit, Mono4</li><li>8kHz, 8Bit, Stereo5</li><li>8kHz, 16Bit, Mono6</li><li>8kHz, 16Bit, Stereo7</li><li>11kHz, 8Bit, Mono8</li><li>11kHz, 8Bit, Stereo9</li><li>11kHz, 16Bit, Mono10</li><li>11kHz, 16Bit, Stereo11</li><li>12kHz, 8Bit, Mono12</li><li>12kHz, 8Bit, Stereo13</li><li>12kHz, 16Bit, Mono14</li><li>12kHz, 16Bit, Stereo15</li><li>16kHz, 8Bit, Mono16</li><li>16kHz, 8Bit, Stereo17</li><li>16kHz, 16Bit, Mono18</li><li>16kHz, 16Bit, Stereo19</li><li>22kHz, 8Bit, Mono20</li><li>22kHz, 8Bit, Stereo21</li><li>22kHz, 16Bit, Mono22</li><li>22kHz, 16Bit, Stereo23</li><li>24kHz, 8Bit, Mono24</li><li>24kHz, 8Bit, Stereo25</li><li>24kHz, 16Bit, Mono26</li><li>24kHz, 16Bit, Stereo27</li><li>32kHz, 8Bit, Mono28</li><li>32kHz, 8Bit, Stereo29</li><li>32kHz, 8Bit, Stereo30</li><li>32kHz, 16Bit, Stereo31</li><li>44kHz, 8Bit, Mono32</li><li>44kHz, 8Bit, Stereo33</li><li>44kHz, 16Bit, Mono34</li><li>44kHz, 16Bit, Stereo35</li><li>48kHz, 8Bit, Mono36</li><li>48kHz, 8Bit, Stereo37</li><li>48kHz, 16Bit, Mono38</li><li>48kHz, 16Bit, Stereo39</li> | |
| */ | |
| function TTS_GenerateFile(int $InstanceID, string $Text, string $Filename, int $Format) { | |
| } | |
| /** | |
| * spricht einen beliebigen Text auf der gewählten Soundkarte | |
| * | |
| * <p>Spricht über das Text-To-Speech Modul mit der ID <b>InstanzID</b> den in <b>Text</b> angegeben Text. Der <b>Warten</b> Parameter gibt an, ob gewartet werden soll, bis die Sprachausgabe beendet wurde.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/text-to-speech/tts-speak/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Text-To-Speech Moduls</p> | |
| * @param string $Text <p>Zu sagender Text</p> | |
| * @param bool $Wait <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function TTS_Speak(int $InstanceID, string $Text, bool $Wait) { | |
| } | |
| /** | |
| * UC_DeleteObjects | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param array $IDs | |
| */ | |
| function UC_DeleteObjects(int $InstanceID, array $IDs) { | |
| } | |
| /** | |
| * UC_DuplicateObject | |
| * | |
| * @returns int | |
| * @param int $InstanceID | |
| * @param int $ID | |
| * @param int $ParentID | |
| * @param bool $Recursive | |
| */ | |
| function UC_DuplicateObject(int $InstanceID, int $ID, int $ParentID, bool $Recursive) { | |
| } | |
| /** | |
| * UC_FindInFiles | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param array $Files | |
| * @param string $SearchStr | |
| */ | |
| function UC_FindInFiles(int $InstanceID, array $Files, string $SearchStr) { | |
| } | |
| /** | |
| * UC_FindInvalidStrings | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function UC_FindInvalidStrings(int $InstanceID) { | |
| } | |
| /** | |
| * UC_FindReferences | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $ID | |
| */ | |
| function UC_FindReferences(int $InstanceID, int $ID) { | |
| } | |
| /** | |
| * UC_FindShortTags | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function UC_FindShortTags(int $InstanceID) { | |
| } | |
| /** | |
| * UC_FixInvalidStrings | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param array $References | |
| */ | |
| function UC_FixInvalidStrings(int $InstanceID, array $References) { | |
| } | |
| /** | |
| * UC_FixShortTags | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param array $References | |
| */ | |
| function UC_FixShortTags(int $InstanceID, array $References) { | |
| } | |
| /** | |
| * UC_GetEventStatistics | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function UC_GetEventStatistics(int $InstanceID) { | |
| } | |
| /** | |
| * UC_GetIconContent | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param string $Icon | |
| */ | |
| function UC_GetIconContent(int $InstanceID, string $Icon) { | |
| } | |
| /** | |
| * UC_GetIconList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function UC_GetIconList(int $InstanceID) { | |
| } | |
| /** | |
| * UC_GetKernelStatistics | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function UC_GetKernelStatistics(int $InstanceID) { | |
| } | |
| /** | |
| * UC_GetLastLogMessages | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $Type | |
| * enum[0=lmtDefault, 1=lmtSuccess, 2=lmtNotify, 3=lmtWarning, 4=lmtError, 5=lmtDebug, 6=lmtCustom] | |
| */ | |
| function UC_GetLastLogMessages(int $InstanceID, int $Type) { | |
| } | |
| /** | |
| * UC_GetLogMessageStatistics | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function UC_GetLogMessageStatistics(int $InstanceID) { | |
| } | |
| /** | |
| * UC_GetMessageSenderIDList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function UC_GetMessageSenderIDList(int $InstanceID) { | |
| } | |
| /** | |
| * UC_GetMessageSenderIDSizeList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function UC_GetMessageSenderIDSizeList(int $InstanceID) { | |
| } | |
| /** | |
| * UC_GetMessageTypeList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function UC_GetMessageTypeList(int $InstanceID) { | |
| } | |
| /** | |
| * UC_GetScriptSenderList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function UC_GetScriptSenderList(int $InstanceID) { | |
| } | |
| /** | |
| * UC_RenameScript | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $ScriptID | |
| * @param string $Filename | |
| */ | |
| function UC_RenameScript(int $InstanceID, int $ScriptID, string $Filename) { | |
| } | |
| /** | |
| * UC_ReplaceInFiles | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param array $Files | |
| * @param string $SearchStr | |
| * @param string $ReplaceStr | |
| */ | |
| function UC_ReplaceInFiles(int $InstanceID, array $Files, string $SearchStr, string $ReplaceStr) { | |
| } | |
| /** | |
| * UC_ResetLastLogMessages | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function UC_ResetLastLogMessages(int $InstanceID) { | |
| } | |
| /** | |
| * UC_ResetLogMessageStatistics | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function UC_ResetLogMessageStatistics(int $InstanceID) { | |
| } | |
| /** | |
| * UC_SendUsageData | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function UC_SendUsageData(int $InstanceID) { | |
| } | |
| /** | |
| * sendet einen String auf den I/O | |
| * | |
| * <p>Sendet den String <b>Text</b> auf dem UDP Socket mit der ID <b>InstanzID</b>. Als Empfängeradressierung wird die IP <b>ClientIP</b> und Port <b>ClientPort</b> genutzt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/udpsocket/usck-sendpacket/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden UDP Sockets</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| * @param string $ClientIP <p>IP des Empfängers</p> | |
| * @param int $ClientPort <p>Port des Empfängers</p> | |
| */ | |
| function USCK_SendPacket(int $InstanceID, string $Text, string $ClientIP, int $ClientPort) { | |
| } | |
| /** | |
| * sendet einen String auf den I/O | |
| * | |
| * <p>Sendet den String <b>Text</b> auf dem UDP Socket mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/udpsocket/usck-sendtext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden UDP Sockets</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| */ | |
| function USCK_SendText(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * UVR_UpdateValues | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function UVR_UpdateValues(int $InstanceID) { | |
| } | |
| /** | |
| * VAN_PrintValue | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| */ | |
| function VAN_PrintValue(int $InstanceID) { | |
| } | |
| /** | |
| * VELLEUSB_ReadAnalogChannel | |
| * | |
| * @returns int | |
| * @param int $InstanceID | |
| * @param int $Channel | |
| */ | |
| function VELLEUSB_ReadAnalogChannel(int $InstanceID, int $Channel) { | |
| } | |
| /** | |
| * VELLEUSB_ReadCounter | |
| * | |
| * @returns int | |
| * @param int $InstanceID | |
| * @param int $Counter | |
| */ | |
| function VELLEUSB_ReadCounter(int $InstanceID, int $Counter) { | |
| } | |
| /** | |
| * VELLEUSB_ReadDigital | |
| * | |
| * @returns int | |
| * @param int $InstanceID | |
| */ | |
| function VELLEUSB_ReadDigital(int $InstanceID) { | |
| } | |
| /** | |
| * VELLEUSB_ReadDigitalChannel | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Channel | |
| */ | |
| function VELLEUSB_ReadDigitalChannel(int $InstanceID, int $Channel) { | |
| } | |
| /** | |
| * VELLEUSB_ResetCounter | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Counter | |
| */ | |
| function VELLEUSB_ResetCounter(int $InstanceID, int $Counter) { | |
| } | |
| /** | |
| * VELLEUSB_SetCounterDebounceTime | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Counter | |
| * @param int $Time | |
| */ | |
| function VELLEUSB_SetCounterDebounceTime(int $InstanceID, int $Counter, int $Time) { | |
| } | |
| /** | |
| * VELLEUSB_WriteAnalogChannel | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Channel | |
| * @param int $Value | |
| */ | |
| function VELLEUSB_WriteAnalogChannel(int $InstanceID, int $Channel, int $Value) { | |
| } | |
| /** | |
| * VELLEUSB_WriteDigital | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function VELLEUSB_WriteDigital(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * VELLEUSB_WriteDigitalChannel | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Channel | |
| * @param bool $Value | |
| */ | |
| function VELLEUSB_WriteDigitalChannel(int $InstanceID, int $Channel, bool $Value) { | |
| } | |
| /** | |
| * sendet ein Connect Datenpaket | |
| * | |
| * <p>Sendet an alle mit der Virtual I/O mit der ID <b>InstanzID</b> verbunden Instanzen ein Datenpaket vom Typ Erweitert (Socket). Dieses beinhaltet: Type = 1 (Connect), Buffer = "" (Buffer leer), ClientIP = <b>ClientIP</b> und ClientPort = <b>ClientPort</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/virtualio/vio-connect/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu aktualisierenden Virtual I/O</p> | |
| * @param string $ClientIP <p>die zu verbindene ClientIP</p> | |
| * @param int $ClientPort <p>der zu verbindene Port</p> | |
| */ | |
| function VIO_Connect(int $InstanceID, string $ClientIP, int $ClientPort) { | |
| } | |
| /** | |
| * sendet ein Disconnect Datenpaket | |
| * | |
| * <p>Sendet an alle mit der Virtual I/O mit der ID <b>InstanzID</b> verbunden Instanzen ein Datenpaket vom Typ Erweitert (Socket). Dieses beinhaltet: Type = 2 (Disconnect), Buffer = "" (Buffer leer), ClientIP = <b>ClientIP</b> und ClientPort = <b>ClientPort</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/virtualio/vio-disconnect/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu aktualisierenden Virtual I/O</p> | |
| * @param string $ClientIP <p>die zu verbindene ClientIP</p> | |
| * @param int $ClientPort <p>der zu verbindene Port</p> | |
| */ | |
| function VIO_Disconnect(int $InstanceID, string $ClientIP, int $ClientPort) { | |
| } | |
| /** | |
| * liefert ein Array von erweiterten Datenpaketen | |
| * | |
| * <p>Liefert ein Array aller empfangen Datenpakete der Virtual I/O Instanz mit der ID <b>InstanzID</b> vom Typ Erweitert (Socket).</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/virtualio/vio-getpacketlist/ | |
| * @returns array <p>liefert ein Array von erweiterten Datenpaketen</p> | |
| * @param int $InstanceID <p>ID der zu aktualisierenden Virtual I/O</p> | |
| */ | |
| function VIO_GetPacketList(int $InstanceID) { | |
| } | |
| /** | |
| * liefert ein Array von simplen Datenpaketen | |
| * | |
| * <p>Liefert ein Array aller empfangen Datenpakete der Virtual I/O Instanz mit der ID <b>InstanzID</b> vom Typ Simpel.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/virtualio/vio-gettextlist/ | |
| * @returns array <p>liefert ein Array von simplen Datenpaketen</p> | |
| * @param int $InstanceID <p>ID der zu aktualisierenden Virtual I/O</p> | |
| */ | |
| function VIO_GetTextList(int $InstanceID) { | |
| } | |
| /** | |
| * VIO_HTTPResponse | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Route | |
| * @param string $Method | |
| * @param string $Data | |
| */ | |
| function VIO_HTTPResponse(int $InstanceID, string $Route, string $Method, string $Data) { | |
| } | |
| /** | |
| * VIO_PushData | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Event | |
| * @param string $Data | |
| * @param string $Retry | |
| * @param string $ID | |
| */ | |
| function VIO_PushData(int $InstanceID, string $Event, string $Data, string $Retry, string $ID) { | |
| } | |
| /** | |
| * sendet ein erweitertes Datenpaket | |
| * | |
| * <p>Sendet an alle mit der Virtual I/O mit der ID <b>InstanzID</b> verbunden Instanzen ein Datenpaket vom Typ Erweitert (Socket). Dieses beinhaltet: Type = 0 (Data), Buffer = <b>Text</b>, ClientIP = <b>ClientIP</b> und ClientPort = <b>ClientPort</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/virtualio/vio-pushpacket/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu aktualisierenden Virtual I/O</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| * @param string $ClientIP <p>auf die zusendende ClientIP</p> | |
| * @param int $ClientPort <p>auf den zusendenden Port</p> | |
| */ | |
| function VIO_PushPacket(int $InstanceID, string $Text, string $ClientIP, int $ClientPort) { | |
| } | |
| /** | |
| * sendet ein erweitertes Datenpaket | |
| * | |
| * <p>Sendet an alle mit der Virtual I/O mit der ID <b>InstanzID</b> verbunden Instanzen ein Datenpaket vom Typ Erweitert (Socket). Dieses beinhaltet: Type = 0 (Data), Buffer = <b>Text</b>, ClientIP = <b>ClientIP</b> und ClientPort = <b>ClientPort</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/virtualio/vio-pushpackethex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu aktualisierenden Virtual I/O</p> | |
| * @param string $Text <p>der zusendene String in HEX</p> | |
| * @param string $ClientIP <p>auf die zusendende ClientIP</p> | |
| * @param int $ClientPort <p>auf den zusendenden Port</p> | |
| */ | |
| function VIO_PushPacketHEX(int $InstanceID, string $Text, string $ClientIP, int $ClientPort) { | |
| } | |
| /** | |
| * sendet ein simples Datenpaket | |
| * | |
| * <p>Sendet an alle mit der Virtual I/O mit der ID <b>InstanzID</b> verbunden Instanzen ein Datenpaket vom Typ Simpel. Dieses beinhaltet: Buffer = <b>Text</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/virtualio/vio-pushtext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu aktualisierenden Virtual I/O</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| */ | |
| function VIO_PushText(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * sendet ein simples Datenpaket | |
| * | |
| * <p>Sendet an alle mit der Virtual I/O mit der ID <b>InstanzID</b> verbunden Instanzen ein Datenpaket vom Typ Simpel. Dieses beinhaltet: Buffer = <b>Text</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/virtualio/vio-pushtexthex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu aktualisierenden Virtual I/O</p> | |
| * @param string $Text <p>der zusendene String in HEX</p> | |
| */ | |
| function VIO_PushTextHEX(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * sendet ein erweitertes Datenpaket an sich selbst | |
| * | |
| * <p>Sendet an die Virtual I/O mit der ID <b>InstanzID</b> selbst ein Datenpaket vom Typ Erweitert (Socket). Dieses beinhaltet: Type = 0 (Data), Buffer = <b>Text</b>, ClientIP = <b>ClientIP</b> und ClientPort = <b>ClientPort</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/virtualio/vio-sendpacket/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu aktualisierenden Virtual I/O</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| * @param string $ClientIP <p>auf die zusendende ClientIP</p> | |
| * @param int $ClientPort <p>auf den zusendenden Port</p> | |
| */ | |
| function VIO_SendPacket(int $InstanceID, string $Text, string $ClientIP, int $ClientPort) { | |
| } | |
| /** | |
| * sendet ein simples Datenpaket an sich selbst | |
| * | |
| * <p>Sendet an die Virtual I/O mit der ID <b>InstanzID</b> selbst ein Datenpaket vom Typ Simpel. Dieses beinhaltet: Buffer = <b>Text</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/virtualio/vio-sendtext/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der zu aktualisierenden Virtual I/O</p> | |
| * @param string $Text <p>der zusendene String</p> | |
| */ | |
| function VIO_SendText(int $InstanceID, string $Text) { | |
| } | |
| /** | |
| * VS_UpdateSource | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $ContentSource | |
| */ | |
| function VS_UpdateSource(int $InstanceID, string $ContentSource) { | |
| } | |
| /** | |
| * VT_UpdateParameter | |
| * | |
| * @returns mixed | |
| * @param int $InstanceID | |
| * @param mixed $name | |
| * @param mixed $parameter | |
| * @param mixed $value | |
| */ | |
| function VT_UpdateParameter(int $InstanceID, mixed $name, mixed $parameter, mixed $value) { | |
| } | |
| /** | |
| * akzeptiert eine Verbindung | |
| * | |
| * <p>Akzeptiert bei der VoIP-Instanz mit der ID <b>InstanzID</b> die Verbindung mit der ID <b>VerbindungsID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/voip/voip-acceptcall/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $ConnectionID <p>ID der zu schaltenden Verbindung</p> | |
| */ | |
| function VoIP_AcceptCall(int $InstanceID, int $ConnectionID) { | |
| } | |
| /** | |
| * baut eine Verbindung auf | |
| * | |
| * <p>Baut bei der VoIP-Instanz mit der ID <b>InstanzID</b> eine Verbindung mit der Nummer <b>Nummer</b> auf.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/voip/voip-connect/ | |
| * @returns int <p>Gibt die ID der Verbindung zurück</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Number <p>Telefonnummer mit der eine Verbindung aufgebaut werden soll</p> | |
| */ | |
| function VoIP_Connect(int $InstanceID, string $Number) { | |
| } | |
| /** | |
| * beendet eine Verbindung | |
| * | |
| * <p>Trennt bei der VoIP-Instanz mit der ID <b>InstanzID</b> die Verbindung mit der ID <b>VerbindungsID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/voip/voip-disconnect/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $ConnectionID <p>ID der zu schaltenden Verbindung</p> | |
| */ | |
| function VoIP_Disconnect(int $InstanceID, int $ConnectionID) { | |
| } | |
| /** | |
| * gibt Informationen zu einer Verbindung wieder | |
| * | |
| * <p>Gibt die Informationen der Verbindung mit der ID <b>VerbindungsID</b> der VoIP-Instanz mit der ID <b>InstanzID</b> zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/voip/voip-getconnection/ | |
| * @returns array <p>Array mit folgenden Informationen</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $ConnectionID <p>ID der zu schaltenden Verbindung</p> | |
| */ | |
| function VoIP_GetConnection(int $InstanceID, int $ConnectionID) { | |
| } | |
| /** | |
| * gibt Daten einer Verbindung zurück | |
| * | |
| * <p>Gibt den Inhalt der Daten der Verbindung mit der ID <b>VerbindungsID</b> der VoIP-Instanz mit der ID <b>InstanzID</b> zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/voip/voip-getdata/ | |
| * @returns string <p>Inhalt der Daten der Verbindung als String</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $ConnectionID <p>ID der zu schaltenden Verbindung</p> | |
| */ | |
| function VoIP_GetData(int $InstanceID, int $ConnectionID) { | |
| } | |
| /** | |
| * spielt eine Wavedatei ab | |
| * | |
| * <p>Spielt auf der VoIP-Instanz mit der ID <b>InstanzID</b> die Sounddatei <b>Dateiname</b> auf der Verbindung mit der ID <b>VerbindungsID</b> ab. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/voip/voip-playwave/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $ConnectionID <p>ID der zu schaltenden Verbindung</p> | |
| * @param string $Filename <p>Pfad und Name der Datei, welche abgespielt werden soll</p> | |
| */ | |
| function VoIP_PlayWave(int $InstanceID, int $ConnectionID, string $Filename) { | |
| } | |
| /** | |
| * lehnt eine Verbindung ab | |
| * | |
| * <p>Lehnt bei der VoIP-Instanz mit der ID <b>InstanzID</b> die Verbindung mit der ID <b>VerbindungsID</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/voip/voip-rejectcall/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $ConnectionID <p>ID der zu schaltenden Verbindung</p> | |
| */ | |
| function VoIP_RejectCall(int $InstanceID, int $ConnectionID) { | |
| } | |
| /** | |
| * sendet eine Abfolge von Zeichen als DTMF | |
| * | |
| * <p>Sendet auf der VoIP-Instanz mit der ID <b>InstanzID</b> die Zeichen <b>DTMF</b> auf der Verbindung mit der ID <b>VerbindungsID</b>. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/voip/voip-senddtmf/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $ConnectionID <p>ID der zu schaltenden Verbindung</p> | |
| * @param string $Digit <p>Zeichen, welche als DTMF gesendet werden sollen</p> | |
| */ | |
| function VoIP_SendDTMF(int $InstanceID, int $ConnectionID, string $Digit) { | |
| } | |
| /** | |
| * setzt die Daten einer Verbindung | |
| * | |
| * <p>Setzt auf der VoIP-Instanz mit der ID <b>InstanzID</b> die Daten <b>Daten</b> der Verbindung mit der ID <b>VerbindungsID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/voip/voip-setdata/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $ConnectionID <p>ID der zu schaltenden Verbindung</p> | |
| * @param string $Data <p>Daten, für die Verbindung gesetzt werden soll</p> | |
| */ | |
| function VoIP_SetData(int $InstanceID, int $ConnectionID, string $Data) { | |
| } | |
| /** | |
| * fügt Musikdatei zur Playlist hinzu | |
| * | |
| * <p>Fügt eine Datei der internen Playlist vom Media Player mit der ID <b>InstanzID</b> zu.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-addfile/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| * @param string $Filename <p>Pfad zur abzuspielenden Datei</p> | |
| */ | |
| function WAC_AddFile(int $InstanceID, string $Filename) { | |
| } | |
| /** | |
| * löscht die Playlist | |
| * | |
| * <p>Löscht die interne Playlist vom Media Player mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-clearplaylist/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| */ | |
| function WAC_ClearPlaylist(int $InstanceID) { | |
| } | |
| /** | |
| * WAC_GetPlaylistFile | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param int $Position | |
| */ | |
| function WAC_GetPlaylistFile(int $InstanceID, int $Position) { | |
| } | |
| /** | |
| * löscht die Playlist | |
| * | |
| * <p>Gibt die Länge der internen Playlist vom Media Player mit der ID <b>InstanzID</b> zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-getplaylistlength/ | |
| * @returns int <p>Anzahl der Tracks, die in der Playlist eingetragen sind.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| */ | |
| function WAC_GetPlaylistLength(int $InstanceID) { | |
| } | |
| /** | |
| * löscht die Playlist | |
| * | |
| * <p>Gibt die aktuelle Position der internen Playlist vom Media Player mit der ID <b>InstanzID</b> zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-getplaylistposition/ | |
| * @returns int <p>Wert zwischen 1 und WAC_GetPlayListLength; Falls die Playlist leer sein sollte, wird -1 zurückgegeben.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function WAC_GetPlaylistPosition(int $InstanceID) { | |
| } | |
| /** | |
| * WAC_GetPlaylistTitle | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param int $Position | |
| */ | |
| function WAC_GetPlaylistTitle(int $InstanceID, int $Position) { | |
| } | |
| /** | |
| * spielt den nächsten Titel der Playlist ab | |
| * | |
| * <p>Geht in der internen Playlist vom Media Player mit der ID <b>InstanzID</b> einen Titel vorwärts oder wählt zufällig einen Titel aus, wenn Shuffle aktiviert ist. Sollte die Wiedergabe gestartet sein, wird nach dem Zurückgehen der dann neue, aktuelle Titel von Anfang an abgespielt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-next/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| */ | |
| function WAC_Next(int $InstanceID) { | |
| } | |
| /** | |
| * pausiert die Wiedergabe | |
| * | |
| * <p>Pausiert die Wiedergabe der internen Playlist vom Media Player mit der ID <b>InstanzID</b>. Durch ein erneutes aufrufen von WAC_Pause oder einem Aufruf von WAC_Play kann die Wiedergabe fortgesetzt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-pause/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>. Es wird auch <b>TRUE</b> zurückgegeben, falls keine aktive Wiedergabe vorhanden ist.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| */ | |
| function WAC_Pause(int $InstanceID) { | |
| } | |
| /** | |
| * spielt die Playlist ab | |
| * | |
| * <p>Startet die Wiedergabe der internen Playlist vom Media Player mit der ID <b>InstanzID</b>. Falls Sie noch keine Dateien hinzugefügt haben, können Sie dies über WAC_AddFile tun. Eine direkte Funktion zum Abspielen einer einzelnen Datei ist WAC_PlayFile. Bitte beachten Sie auch die unterstützten Dateiformate, die sich auf WAC_PlayFile finden können.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-play/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| */ | |
| function WAC_Play(int $InstanceID) { | |
| } | |
| /** | |
| * spielt eine Musikdatei direkt ab | |
| * | |
| * <p>Spielt eine Datei mit Dateiname direkt über den Media Player mit der ID <b>InstanzID</b> ab. Der Befehl ist nur zur Vereinfachung vorhanden. Sie können ihn auch durch eine Abfolge von WAC_ClearPlaylist, WAC_AddFile, WAC_Play ersetzen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-playfile/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| * @param string $Filename <p>Pfad zur abzuspielenden Datei</p> | |
| */ | |
| function WAC_PlayFile(int $InstanceID, string $Filename) { | |
| } | |
| /** | |
| * spielt den vorherigen Titel der Playlist ab | |
| * | |
| * <p>Geht in der internen Playlist vom Media Player mit der ID <b>InstanzID</b> einen Titel zurück. Sollte die Wiedergabe gestartet sein, wird nach dem Zurückgehen der dann neue aktuelle Titel von Anfang an abgespielt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-prev/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| */ | |
| function WAC_Prev(int $InstanceID) { | |
| } | |
| /** | |
| * löscht die Playlist | |
| * | |
| * <p>Setzt die aktuelle Position der internen Playlist vom Media Player mit der ID <b>InstanzID</b> auf die neue <b>Position</b>. Nach dem Ausführen muss WAC_Play ausgeführt werden, wenn die Wiedergabe an der neuen Position starten soll. Andernfalls wird der nächste Titel, nach dem Ende des aktuellen Titels abgespielt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-setplaylistposition/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Position | |
| */ | |
| function WAC_SetPlaylistPosition(int $InstanceID, int $Position) { | |
| } | |
| /** | |
| * setzt den Positionsmarker auf eine bestimmte Sekunde | |
| * | |
| * <p>Setzt den Positionsmarker vom Media Player mit der ID <b>InstanzID</b> auf die angegeben <b>Sekunden</b>. Der Titel muss zum Ausführungszeitpunkt bereits abgespielt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-setposition/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| * @param int $Seconds <p>Sprungmarke in Sekunden</p> | |
| */ | |
| function WAC_SetPosition(int $InstanceID, int $Seconds) { | |
| } | |
| /** | |
| * schaltet die Wiederholung der Playlist ein/aus | |
| * | |
| * <p>Aktiviert/ deaktiviert die Wiederholung der Playlist vom Media Player mit der ID InstanzID.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-setrepeat/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| * @param bool $DoRepeat <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function WAC_SetRepeat(int $InstanceID, bool $DoRepeat) { | |
| } | |
| /** | |
| * schaltet die Zufallswiedergabe ein/aus | |
| * | |
| * <p>Aktiviert/ deaktiviert die Zufallswiedergabe vom Media Player mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-setshuffle/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| * @param bool $DoShuffle <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function WAC_SetShuffle(int $InstanceID, bool $DoShuffle) { | |
| } | |
| /** | |
| * setzt die Lautstärke | |
| * | |
| * <p>Fadet die Lautstärke vom Media Player mit der ID <b>InstanzID</b> innerhalb von 500ms auf die gewünschte Lautstärke.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-setvolume/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| * @param int $Volume <p>0-100 (%)</p> | |
| */ | |
| function WAC_SetVolume(int $InstanceID, int $Volume) { | |
| } | |
| /** | |
| * stoppt die Wiedergabe | |
| * | |
| * <p>Stoppt die Wiedergabe der internen Playlist vom Media Player mit der ID InstanzID.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/mediaplayer/wac-stop/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>. Es wird auch <b>TRUE</b> zurückgegeben, falls keine aktive Wiedergabe vorhanden ist.</p> | |
| * @param int $InstanceID <p>ID des zu steuernden Media Players</p> | |
| */ | |
| function WAC_Stop(int $InstanceID) { | |
| } | |
| /** | |
| * sendet eine WebSocket-Nachricht an alle verbundenen Clients | |
| * | |
| * <p>Sendet die Nachricht <b>Nachricht</b> an alle verbundene Clients auf den Hook <b>Hookpfad</b> des WebHook Controls mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/webhook-control/wc-pushmessage/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des WebHook Control</p> | |
| * @param string $Hook <p>Pfad des Hooks</p> | |
| * @param string $Data <p>Zu sendene Nachricht</p> | |
| */ | |
| function WC_PushMessage(int $InstanceID, string $Hook, string $Data) { | |
| } | |
| /** | |
| * sendet eine WebSocket-Nachricht an einen bestimmten Client | |
| * | |
| * <p>Sendet die Nachricht <b>Nachricht</b> an einen bestimmten Client auf den Hook <b>Hookpfad</b> des WebHook Controls mit der ID <b>InstanzID</b>. Der Client kann über die Paramter der IP-Adresse <b>Zieladresse</b> und des Zielports <b>Port</b> bestimmt werden.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/webhook-control/wc-pushmessageex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des WebHook Control</p> | |
| * @param string $Hook <p>Pfad des Hooks</p> | |
| * @param string $Data <p>Zu sendene Nachricht</p> | |
| * @param string $RemoteIP <p>Adresse an die gesendet werden soll</p> | |
| * @param int $RemotePort <p>Port auf den gesendet werden soll</p> | |
| */ | |
| function WC_PushMessageEx(int $InstanceID, string $Hook, string $Data, string $RemoteIP, int $RemotePort) { | |
| } | |
| /** | |
| * WEB_UpdateFormEnableSSL | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $EnableSSL | |
| */ | |
| function WEB_UpdateFormEnableSSL(int $InstanceID, bool $EnableSSL) { | |
| } | |
| /** | |
| * WFC_AddItem | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $ID | |
| * @param string $ClassName | |
| * @param string $Configuration | |
| * @param string $ParentID | |
| */ | |
| function WFC_AddItem(int $InstanceID, string $ID, string $ClassName, string $Configuration, string $ParentID) { | |
| } | |
| /** | |
| * sendet eine Audio-Meldung auf das WebFront | |
| * | |
| * <p>Sendet eine Audio-Nachricht mit <b>Titel</b> an das WebFront, das dem Konfigurator mit der ID <b>InstanzID</b> zugeordnet ist. Die Audio-Nachricht erscheint als kleiner Kasten in der oberen rechten Ecke des WebFronts und wird für die Abspieldauer angezeigt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/webfront-visualisierung/wfc-audionotification/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der WebFront Visualisierung</p> | |
| * @param string $Title <p>Titel der Audio-Meldung</p> | |
| * @param int $MediaID <p>ID des Media-Objekts, welches vom Typ "Ton" ist</p> | |
| */ | |
| function WFC_AudioNotification(int $InstanceID, string $Title, int $MediaID) { | |
| } | |
| /** | |
| * WFC_ChangeVisibleGreetingFields | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Value | |
| */ | |
| function WFC_ChangeVisibleGreetingFields(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * WFC_DeleteItem | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $ID | |
| */ | |
| function WFC_DeleteItem(int $InstanceID, string $ID) { | |
| } | |
| /** | |
| * WFC_Execute | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param int $ActionID | |
| * @param int $TargetID | |
| * @param mixed $Value | |
| */ | |
| function WFC_Execute(int $InstanceID, int $ActionID, int $TargetID, mixed $Value) { | |
| } | |
| /** | |
| * WFC_FetchChartData | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $ObjectID | |
| * @param int $StartTime | |
| * @param int $TimeSpan | |
| * enum[0=tsHour, 1=tsDay, 2=tsWeek, 3=tsMonth, 4=tsYear, 5=tsDecade] | |
| * @param int $Density | |
| * enum[0=gdNormal, 1=gdHD, 2=gdRaw] | |
| */ | |
| function WFC_FetchChartData(int $InstanceID, int $ObjectID, int $StartTime, int $TimeSpan, int $Density) { | |
| } | |
| /** | |
| * WFC_FetchChartDataEx | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $ObjectID | |
| * @param int $StartTime | |
| * @param int $TimeSpan | |
| * enum[0=tsHour, 1=tsDay, 2=tsWeek, 3=tsMonth, 4=tsYear, 5=tsDecade] | |
| * @param int $Density | |
| * enum[0=gdNormal, 1=gdHD, 2=gdRaw] | |
| * @param array $Visibility | |
| */ | |
| function WFC_FetchChartDataEx(int $InstanceID, int $ObjectID, int $StartTime, int $TimeSpan, int $Density, array $Visibility) { | |
| } | |
| /** | |
| * WFC_GetAggregatedValues | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $VariableID | |
| * @param int $AggregationSpan | |
| * enum[0=agHour, 1=agDay, 2=agWeek, 3=agMonth, 4=agYear, 5=ag5Minutes, 6=ag1Minute, 7=agChanges] | |
| * @param int $StartTime | |
| * @param int $EndTime | |
| * @param int $Limit | |
| */ | |
| function WFC_GetAggregatedValues(int $InstanceID, int $VariableID, int $AggregationSpan, int $StartTime, int $EndTime, int $Limit) { | |
| } | |
| /** | |
| * WFC_GetItems | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function WFC_GetItems(int $InstanceID) { | |
| } | |
| /** | |
| * WFC_GetLoggedValues | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $VariableID | |
| * @param int $StartTime | |
| * @param int $EndTime | |
| * @param int $Limit | |
| */ | |
| function WFC_GetLoggedValues(int $InstanceID, int $VariableID, int $StartTime, int $EndTime, int $Limit) { | |
| } | |
| /** | |
| * WFC_GetSnapshot | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function WFC_GetSnapshot(int $InstanceID) { | |
| } | |
| /** | |
| * WFC_GetSnapshotChanges | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $LastTimeStamp | |
| */ | |
| function WFC_GetSnapshotChanges(int $InstanceID, int $LastTimeStamp) { | |
| } | |
| /** | |
| * WFC_GetSnapshotChangesEx | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $CategoryID | |
| * @param int $LastTimeStamp | |
| */ | |
| function WFC_GetSnapshotChangesEx(int $InstanceID, int $CategoryID, int $LastTimeStamp) { | |
| } | |
| /** | |
| * WFC_GetSnapshotEx | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $CategoryID | |
| */ | |
| function WFC_GetSnapshotEx(int $InstanceID, int $CategoryID) { | |
| } | |
| /** | |
| * Öffnet im WebFront eine Kategorie als Popup | |
| * | |
| * <p>Öffnet die Kategorie mit der ID <b>KategorieID</b> als Popup. Dabei werden alle Unterobjekte der Kategorie in dem Popup angezeigt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/webfront-visualisierung/wfc-opencategory/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der WebFront Visualisierung</p> | |
| * @param int $CategoryID <p>ID der Kategorie</p> | |
| */ | |
| function WFC_OpenCategory(int $InstanceID, int $CategoryID) { | |
| } | |
| /** | |
| * sendet eine Push-Nachricht an die mobilen Apps | |
| * | |
| * <p>Sendet eine Push-Nachricht mit <b>Titel</b>, <b>Text</b> an alle mobilen Geräte, die dem Konfigurator mit der ID <b>InstanzID</b> zugeordnet sind. Alternativ kann auch einer der folgenden Sounds abgespielt werden:</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/webfront-visualisierung/wfc-pushnotification/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der WebFront Visualisierung</p> | |
| * @param string $Title <p>Titel der Meldung (maximal 32 Zeichen). Kann auch leer sein.</p> | |
| * @param string $Text <p>Text der Meldung (maximal 256 Zeichen).</p> | |
| * @param string $Sound <p>Wird in den Apps ab Version 3.0.6 ausgewertet</p> | |
| * @param int $TargetID <p>Es kann beim Öffnen der Push Nachricht direkt zu einem Objekt gesprungen werden. (ab Version 5.0)</p> | |
| */ | |
| function WFC_PushNotification(int $InstanceID, string $Title, string $Text, string $Sound, int $TargetID) { | |
| } | |
| /** | |
| * WFC_RegisterPNS | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param string $Token | |
| * @param string $Provider | |
| * @param string $DeviceID | |
| * @param string $DeviceName | |
| */ | |
| function WFC_RegisterPNS(int $InstanceID, string $Token, string $Provider, string $DeviceID, string $DeviceName) { | |
| } | |
| /** | |
| * lädt das WebFront auf dem Client-Rechner neu | |
| * | |
| * <p>Lädt das WebFront, das der Visualisierung mit der ID <b>InstanzID</b> zugeordnet ist neu.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/webfront-visualisierung/wfc-reload/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der WebFront Visualisierung</p> | |
| */ | |
| function WFC_Reload(int $InstanceID) { | |
| } | |
| /** | |
| * WFC_RenderChart | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param int $ObjectID | |
| * @param int $StartTime | |
| * @param int $TimeSpan | |
| * enum[0=tsHour, 1=tsDay, 2=tsWeek, 3=tsMonth, 4=tsYear, 5=tsDecade] | |
| * @param int $Density | |
| * enum[0=gdNormal, 1=gdHD, 2=gdRaw] | |
| * @param bool $IsExtrema | |
| * @param bool $IsDyn | |
| * @param int $Width | |
| * @param int $Height | |
| */ | |
| function WFC_RenderChart(int $InstanceID, int $ObjectID, int $StartTime, int $TimeSpan, int $Density, bool $IsExtrema, bool $IsDyn, int $Width, int $Height) { | |
| } | |
| /** | |
| * WFC_RenderChartEx | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| * @param int $ObjectID | |
| * @param int $StartTime | |
| * @param int $TimeSpan | |
| * enum[0=tsHour, 1=tsDay, 2=tsWeek, 3=tsMonth, 4=tsYear, 5=tsDecade] | |
| * @param int $Density | |
| * enum[0=gdNormal, 1=gdHD, 2=gdRaw] | |
| * @param bool $IsExtrema | |
| * @param bool $IsDyn | |
| * @param int $Width | |
| * @param int $Height | |
| * @param array $Visibility | |
| */ | |
| function WFC_RenderChartEx(int $InstanceID, int $ObjectID, int $StartTime, int $TimeSpan, int $Density, bool $IsExtrema, bool $IsDyn, int $Width, int $Height, array $Visibility) { | |
| } | |
| /** | |
| * WFC_SaveGridConfiguration | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Configuration | |
| */ | |
| function WFC_SaveGridConfiguration(int $InstanceID, string $Configuration) { | |
| } | |
| /** | |
| * sendet eine kleine Meldung auf das WebFront | |
| * | |
| * <p>Sendet eine kleine Nachricht mit <b>Titel</b>, <b>Text</b> und <b>Icon</b> an das WebFront, das der Visualisierung mit der ID <b>InstanzID</b> zugeordnet ist. Die Nachricht erscheint als kleiner Kasten in der oberen rechten Ecke des WebFronts und wird für <b>Timeout</b> Sekunden angezeigt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/webfront-visualisierung/wfc-sendnotification/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der WebFront Visualisierung</p> | |
| * @param string $Title <p>Titel der Meldung</p> | |
| * @param string $Text <p>Text der Meldung. Kann auch leer sein.</p> | |
| * @param string $Icon <p>Wenn nicht leer, dann wird das Icon angezeigt. Siehe Icons</p> | |
| * @param int $Timeout <p>Anzuzeigende Zeit in Sekunden. 0 = Nur ausblenden, wenn der Nutzer auf die Meldung klickt.</p> | |
| */ | |
| function WFC_SendNotification(int $InstanceID, string $Title, string $Text, string $Icon, int $Timeout) { | |
| } | |
| /** | |
| * sendet eine große Meldung an das WebFront | |
| * | |
| * <p>Sendet eine große Meldung an das WebFront, das der Visualisierung mit der ID <b>InstanzID</b> zugeordnet ist. Es werden der Inhalt <b>Text</b> und der <b>Titel</b> angezeigt.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/webfront-visualisierung/wfc-sendpopup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der WebFront Visualisierung</p> | |
| * @param string $Title <p>Angezeigter Titel</p> | |
| * @param string $Text <p>Angezeigter Text (HTML wird gefiltert!)</p> | |
| */ | |
| function WFC_SendPopup(int $InstanceID, string $Title, string $Text) { | |
| } | |
| /** | |
| * WFC_SetItems | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $Items | |
| */ | |
| function WFC_SetItems(int $InstanceID, string $Items) { | |
| } | |
| /** | |
| * wechselt den Reiter im WebFront | |
| * | |
| * <p>Wechselt im WebFront, das der Visualisierung mit der ID <b>InstanzID</b> zugeordnet ist, auf den Reiter mit der ID <b>PageName</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/webfront-visualisierung/wfc-switchpage/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID der WebFront Visualisierung</p> | |
| * @param string $PageName <p>Name des Reiters (z.B. item1234)</p> | |
| */ | |
| function WFC_SwitchPage(int $InstanceID, string $PageName) { | |
| } | |
| /** | |
| * WFC_UpdateConfiguration | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $ID | |
| * @param string $Configuration | |
| */ | |
| function WFC_UpdateConfiguration(int $InstanceID, string $ID, string $Configuration) { | |
| } | |
| /** | |
| * WFC_UpdateFormGraphDefaults | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $GraphRawDensity | |
| */ | |
| function WFC_UpdateFormGraphDefaults(int $InstanceID, bool $GraphRawDensity) { | |
| } | |
| /** | |
| * WFC_UpdateFormNotificationValues | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function WFC_UpdateFormNotificationValues(int $InstanceID) { | |
| } | |
| /** | |
| * WFC_UpdateFormSecurityWarning | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $AllowPasswordlessOnWAN | |
| */ | |
| function WFC_UpdateFormSecurityWarning(int $InstanceID, bool $AllowPasswordlessOnWAN) { | |
| } | |
| /** | |
| * WFC_UpdateParentID | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $ID | |
| * @param string $ParentID | |
| */ | |
| function WFC_UpdateParentID(int $InstanceID, string $ID, string $ParentID) { | |
| } | |
| /** | |
| * WFC_UpdatePosition | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $ID | |
| * @param int $Position | |
| */ | |
| function WFC_UpdatePosition(int $InstanceID, string $ID, int $Position) { | |
| } | |
| /** | |
| * WFC_UpdateVisibility | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param string $ID | |
| * @param bool $Visible | |
| */ | |
| function WFC_UpdateVisibility(int $InstanceID, string $ID, bool $Visible) { | |
| } | |
| /** | |
| * sendet eine Nachricht über den WebSocket | |
| * | |
| * <p>Sendet an den WebSocket Client mit der ID <b>InstanzID</b> die Nachricht <b>Nachricht</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/websocketclient/wsc-sendmessage/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden WebSocket Clients</p> | |
| * @param string $Message <p>der zu sendene String</p> | |
| */ | |
| function WSC_SendMessage(int $InstanceID, string $Message) { | |
| } | |
| /** | |
| * lässt die konfigurierte URL abfragen | |
| * | |
| * <p>Lässt die URL des HTTP Clients mit der ID <b>InstanzID</b> abfragen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/io/httpclient/www-updatepage/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu aktualisierenden HTTP Clients</p> | |
| */ | |
| function WWW_UpdatePage(int $InstanceID) { | |
| } | |
| /** | |
| * sendet einmalig einen Fernbedienungsbefehl | |
| * | |
| * <p>Sendet einen Fernbedienungsbefehl über die Instanz mit der ID <b>InstanzID</b> ab. Die Werte Fernbedienung und Knopf geben an, welcher Befehl gesendet werden soll. Diese müssen in der Client Software (WinLIRC/IRTrans Tray) entsprechend eingerichtet worden sein.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/winlirc/winlirc-sendonce/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param string $Remote <p>Name der Fernbedienung, der in der Fernbedienungsdatenbank eingetragen ist/wurde.</p> | |
| * @param string $Button <p>Name der Fernbedienungsfunktion, die in der Fernbedienungsdatenbank eingetragen ist/wurde.</p> | |
| */ | |
| function WinLIRC_SendOnce(int $InstanceID, string $Remote, string $Button) { | |
| } | |
| /** | |
| * WuT_SwitchMode | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $DeviceOn | |
| */ | |
| function WuT_SwitchMode(int $InstanceID, bool $DeviceOn) { | |
| } | |
| /** | |
| * WuT_UpdateValue | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function WuT_UpdateValue(int $InstanceID) { | |
| } | |
| /** | |
| * WuT_UpdateValues | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function WuT_UpdateValues(int $InstanceID) { | |
| } | |
| /** | |
| * sendet einen Datenstring an ein bestimmtes Gerät | |
| * | |
| * <p>Sendet den DatenString <b>Buffer</b> an das Zielgerät <b>ZielGerät</b> und das XBee-Gateway mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xbee/xbee-sendbuffer/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des abzufragenden Geräts</p> | |
| * @param int $DestinationDevice <p>ID des ZielGeräts</p> | |
| * @param string $Buffer <p>Datenbuffer der versendet werden soll</p> | |
| */ | |
| function XBee_SendBuffer(int $InstanceID, int $DestinationDevice, string $Buffer) { | |
| } | |
| /** | |
| * sendet einen Befehl an einen bestimmten XBee-Splitter | |
| * | |
| * <p>Sendet den Befehl <b>Befehl</b> an den XBee-Splitter mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/xbee/xbee-sendcommand/ | |
| * @returns string <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu verändernden Geräts</p> | |
| * @param string $Command <p>Befehl der gesendet werden soll</p> | |
| */ | |
| function XBee_SendCommand(int $InstanceID, string $Command) { | |
| } | |
| /** | |
| * schickt eine Anfrage ins lokale Netzwerk | |
| * | |
| * <p>Schickt eine Anfrage über das SSDP Control mit der ID <b>InstanzID</b> und dem passenden Suchziel <b>SuchZiel</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/ssdp-control/yc-searchdevices/ | |
| * @returns array <p>Gibt alle Informationen zu gefundenen Geräten als Array zurück.</p> | |
| * @param int $InstanceID <p>ID des anzufragenden SSDP Control</p> | |
| * @param string $SearchTarget <p>.</p> | |
| */ | |
| function YC_SearchDevices(int $InstanceID, string $SearchTarget) { | |
| } | |
| /** | |
| * fragt Informationen eines einzelnen Services ab | |
| * | |
| * <p>Fragt den Service des DNS-SD Controls mit der ID <b>InstanzID</b> und dem passenden Namen <b>Name</b>, RegType <b>RegType</b> und der Domain <b>Domain</b> ab.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dnssd-control/zc_queryservice/ | |
| * @returns array <p>Gibt alle Informationen zum gefundenen Service als Array zurück.</p> | |
| * @param int $InstanceID <p>ID des anzufragenden DNS-SD Control</p> | |
| * @param string $Name <p>Name des Services</p> | |
| * @param string $Type <p>Der RegType des Services</p> | |
| * @param string $Domain <p>Domain des Services</p> | |
| */ | |
| function ZC_QueryService(int $InstanceID, string $Name, string $Type, string $Domain) { | |
| } | |
| /** | |
| * ZC_QueryServiceEx | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Name | |
| * @param string $Type | |
| * @param string $Domain | |
| * @param int $Timeout | |
| */ | |
| function ZC_QueryServiceEx(int $InstanceID, string $Name, string $Type, string $Domain, int $Timeout) { | |
| } | |
| /** | |
| * fragt Informationen von Services eines bestimmten Types ab | |
| * | |
| * <p>Fragt die Services des DNS-SD Controls mit der ID <b>InstanzID</b> und dem passenden RegType <b>RegType</b> und der Domain <b>Domain</b> ab. </p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dnssd-control/zc_queryservicetype/ | |
| * @returns array <p>Gibt alle gefundenen Services als Array zurück.</p> | |
| * @param int $InstanceID <p>ID des anzufragenden DNS-SD Control</p> | |
| * @param string $Type <p>Der RegType des Services</p> | |
| * @param string $Domain <p>Domain des Services</p> | |
| */ | |
| function ZC_QueryServiceType(int $InstanceID, string $Type, string $Domain) { | |
| } | |
| /** | |
| * ZC_QueryServiceTypeEx | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param string $Type | |
| * @param string $Domain | |
| * @param int $Timeout | |
| */ | |
| function ZC_QueryServiceTypeEx(int $InstanceID, string $Type, string $Domain, int $Timeout) { | |
| } | |
| /** | |
| * Fragt alle eingerichteten Services ab | |
| * | |
| * <p>Fragt die Services des DNS-SD Controls mit der ID <b>InstanzID</b> ab und gibt diese als Array zurück.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/dnssd-control/zc_queryservicetypes/ | |
| * @returns array <p>Gibt alle Services und Informationen als Array zurück.</p> | |
| * @param int $InstanceID <p>ID des anzufragenden DNS-SD Control</p> | |
| */ | |
| function ZC_QueryServiceTypes(int $InstanceID) { | |
| } | |
| /** | |
| * ZC_QueryServiceTypesEx | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param int $Timeout | |
| */ | |
| function ZC_QueryServiceTypesEx(int $InstanceID, int $Timeout) { | |
| } | |
| /** | |
| * ZW_AssociationAddToGroup | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Group | |
| * @param int $Node | |
| */ | |
| function ZW_AssociationAddToGroup(int $InstanceID, int $Group, int $Node) { | |
| } | |
| /** | |
| * ZW_AssociationAddToGroupEx | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Group | |
| * @param int $Node | |
| * @param int $Channel | |
| */ | |
| function ZW_AssociationAddToGroupEx(int $InstanceID, int $Group, int $Node, int $Channel) { | |
| } | |
| /** | |
| * ZW_AssociationRemoveFromGroup | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Group | |
| * @param int $Node | |
| */ | |
| function ZW_AssociationRemoveFromGroup(int $InstanceID, int $Group, int $Node) { | |
| } | |
| /** | |
| * ZW_AssociationRemoveFromGroupEx | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Group | |
| * @param int $Node | |
| * @param int $Channel | |
| */ | |
| function ZW_AssociationRemoveFromGroupEx(int $InstanceID, int $Group, int $Node, int $Channel) { | |
| } | |
| /** | |
| * bient ein Gerät über die Basisfunktion | |
| * | |
| * <p>Schaltet die Basisfunktion vom angegeben Gerät mit der InstanzID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-basic/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param int $Value <p>0..255</p> | |
| */ | |
| function ZW_Basic(int $InstanceID, int $Value) { | |
| } | |
| /** | |
| * ZW_ClearWakeUpQueue | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_ClearWakeUpQueue(int $InstanceID) { | |
| } | |
| /** | |
| * setzt den KaltWeiß Kanal eines RGBWW Z-Wave Geräts | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> im KaltWeiß Kanal auf den Wert <b>KaltWeiß</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-colorcw/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param int $ColdWhite <p>KaltWeiß Intensität von 0..255</p> | |
| */ | |
| function ZW_ColorCW(int $InstanceID, int $ColdWhite) { | |
| } | |
| /** | |
| * setzt die Farbe eines Z-Wave Geräts | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf die Farbwertkombination <b>RGB</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-colorrgb/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param int $Red <p>Rot Intensität von 0..255</p> | |
| * @param int $Green <p>Grün Intensität von 0..255</p> | |
| * @param int $Blue <p>Blau Intensität von 0..255</p> | |
| */ | |
| function ZW_ColorRGB(int $InstanceID, int $Red, int $Green, int $Blue) { | |
| } | |
| /** | |
| * setzt die Farben und Intensität eines RGBWW Z-Wave Geräts | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf die Farbwertkombination <b>RGBWW</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-colorrgbww/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param int $Red <p>Rot Intensität von 0..255</p> | |
| * @param int $Green <p>Grün Intensität von 0..255</p> | |
| * @param int $Blue <p>Blau Intensität von 0..255</p> | |
| * @param int $WarmWhite <p>WarmWeiß Intensität von 0..255</p> | |
| * @param int $ColdWhite <p>KaltWeiß Intensität von 0..255</p> | |
| */ | |
| function ZW_ColorRGBWW(int $InstanceID, int $Red, int $Green, int $Blue, int $WarmWhite, int $ColdWhite) { | |
| } | |
| /** | |
| * setzt den WarmWeiß Kanal eines Z-Wave Geräts | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> im WarmWeiß Kanal auf den Wert <b>WarmWeiß</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-colorww/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param int $WarmWhite <p>WarmWeiß Intensität von 0..255</p> | |
| */ | |
| function ZW_ColorWW(int $InstanceID, int $WarmWhite) { | |
| } | |
| /** | |
| * ZW_ConfigurationAddCustom | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Parameter | |
| * @param string $Description | |
| */ | |
| function ZW_ConfigurationAddCustom(int $InstanceID, int $Parameter, string $Description) { | |
| } | |
| /** | |
| * ZW_ConfigurationGetValue | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Parameter | |
| */ | |
| function ZW_ConfigurationGetValue(int $InstanceID, int $Parameter) { | |
| } | |
| /** | |
| * ZW_ConfigurationRemoveCustom | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Parameter | |
| */ | |
| function ZW_ConfigurationRemoveCustom(int $InstanceID, int $Parameter) { | |
| } | |
| /** | |
| * ZW_ConfigurationResetValue | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Parameter | |
| */ | |
| function ZW_ConfigurationResetValue(int $InstanceID, int $Parameter) { | |
| } | |
| /** | |
| * ZW_ConfigurationSetValue | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Parameter | |
| * @param int $Value | |
| */ | |
| function ZW_ConfigurationSetValue(int $InstanceID, int $Parameter, int $Value) { | |
| } | |
| /** | |
| * ZW_DeleteFailedDevice | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $NodeID | |
| */ | |
| function ZW_DeleteFailedDevice(int $InstanceID, int $NodeID) { | |
| } | |
| /** | |
| * beginnt ein Runterdimmen | |
| * | |
| * <p>Beginnt das Runterdimmen des Geräts mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-dimdown/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function ZW_DimDown(int $InstanceID) { | |
| } | |
| /** | |
| * beginnt mit einer Laufzeit Runterzudimmen | |
| * | |
| * <p>Beginnt das Runterdimmen des Geräts mit der ID <b>InstanzID</b> in der Laufzeit <b>Duration</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-dimdownex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Duration <p>Laufzeit bis komplett heruntergedimmt wird (0..255) (Siehe Tabelle)</p> | |
| */ | |
| function ZW_DimDownEx(int $InstanceID, int $Duration) { | |
| } | |
| /** | |
| * dimmt ein Z-Wave Gerät auf eine bestimmte Stufe | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Intensität</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-dimset/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Intensity <p>Wert von 0-100 (in %)</p> | |
| */ | |
| function ZW_DimSet(int $InstanceID, int $Intensity) { | |
| } | |
| /** | |
| * dimmt ein Z-Wave Gerät in einer Laufzeit auf eine bestimmte Stufe | |
| * | |
| * <p>Dimmt das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Intensität</b> in der Laufzeit <b>Duration</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-dimsetex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Intensity <p>Wert von 0-100 (in %)</p> | |
| * @param int $Duration <p>Laufzeit bis die Intensität erreicht wird (0..255) (Siehe Tabelle)</p> | |
| */ | |
| function ZW_DimSetEx(int $InstanceID, int $Intensity, int $Duration) { | |
| } | |
| /** | |
| * stoppt die Dimmung eines Z-Wave Geräts | |
| * | |
| * <p>Unterbricht das Dimmen des Geräts mit der ID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-dimstop/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| */ | |
| function ZW_DimStop(int $InstanceID) { | |
| } | |
| /** | |
| * beginnt ein Hochdimmen | |
| * | |
| * <p>Beginnt das Hochdimmen des Geräts mit der ID <b>InstanzID</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-dimup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function ZW_DimUp(int $InstanceID) { | |
| } | |
| /** | |
| * beginnt mit einer Laufzeit Hochzudimmen | |
| * | |
| * <p>Beginnt das Hochdimmen des Geräts mit der ID <b>InstanzID</b> in der Laufzeit <b>Duration</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-dimupex/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Duration <p>Laufzeit bis komplett hochgedimmt wird (0..255) (Siehe Tabelle)</p> | |
| */ | |
| function ZW_DimUpEx(int $InstanceID, int $Duration) { | |
| } | |
| /** | |
| * Setzt den Door Lock Operation Modus eines Z-Wave Geräts | |
| * | |
| * <p>Setzt den Door Lock Operation Mode des Geräts mit der ID <b>InstanzID</b> auf den Modus <b>Modus</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-doorlockoperation/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Mode <p>Modus auf den das Z-Wave Gerät eingestellt werden soll</p> | |
| */ | |
| function ZW_DoorLockOperation(int $InstanceID, int $Mode) { | |
| } | |
| /** | |
| * ZW_GetInformation | |
| * | |
| * @returns string | |
| * @param int $InstanceID | |
| */ | |
| function ZW_GetInformation(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_GetKnownDevices | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function ZW_GetKnownDevices(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_GetSupportedVersions | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function ZW_GetSupportedVersions(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_GetWakeUpQueue | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function ZW_GetWakeUpQueue(int $InstanceID) { | |
| } | |
| /** | |
| * setzt den LockMode | |
| * | |
| * <p>Setzt den LockMode bei dem Gerät mit der InstanzID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-lockmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param bool $Locked <p>0..255</p> | |
| */ | |
| function ZW_LockMode(int $InstanceID, bool $Locked) { | |
| } | |
| /** | |
| * resetet das Meter | |
| * | |
| * <p>Setzt das Meter vom Gerät mit der InstanzID <b>InstanzID</b> zurück</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-meterreset/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| */ | |
| function ZW_MeterReset(int $InstanceID) { | |
| } | |
| /** | |
| * Startet den Optimierugnsprozess des Funknetzwerks für ein Z-Wave Gerät | |
| * | |
| * <p>Startet den Optimierungsprozess der Funkverbindung für das Gerät mit der InstanzID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-optimize/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| */ | |
| function ZW_Optimize(int $InstanceID) { | |
| } | |
| /** | |
| * setzt die Protection und dessen Mode | |
| * | |
| * <p>Setzt die Protection und dessen Mode <b>Mode</b> vom angegeben Gerät mit der InstanzID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-protectionset/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param int $Mode <p>0..255</p> | |
| * enum[0=pUnprotected, 1=pProtectedBySequence, 2=pNoOperationPossible] | |
| */ | |
| function ZW_ProtectionSet(int $InstanceID, int $Mode) { | |
| } | |
| /** | |
| * ZW_ProtectionSetEx | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Mode | |
| * enum[0=pUnprotected, 1=pProtectedBySequence, 2=pNoOperationPossible] | |
| * @param int $ModeRF | |
| * enum[0=prfUnprotected, 1=prfNoRFControl, 2=prfNoRFResponse] | |
| */ | |
| function ZW_ProtectionSetEx(int $InstanceID, int $Mode, int $ModeRF) { | |
| } | |
| /** | |
| * ZW_ReactivateFailedNode | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_ReactivateFailedNode(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_RequestInfo | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_RequestInfo(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_RequestPriorityRoute | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function ZW_RequestPriorityRoute(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_RequestRoutingList | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| * @param bool $RemoveBad | |
| * @param bool $RemoveNonRepeaters | |
| */ | |
| function ZW_RequestRoutingList(int $InstanceID, bool $RemoveBad, bool $RemoveNonRepeaters) { | |
| } | |
| /** | |
| * sende eine Statusmeldungsanfrage an ein Gerät | |
| * | |
| * <p>Fragt den Status für das Gerät mit der ID <b>InstanzID</b> ab. Nur netzbetriebene Geräte können per Befehl direkt abgefragt werden, da batteriebetriebene Geräte nicht dauerhaft dem Abfragen lauschen.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-requeststatus/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| */ | |
| function ZW_RequestStatus(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_ResetStatistics | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_ResetStatistics(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_ResetToDefault | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_ResetToDefault(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_SearchMainDevice | |
| * | |
| * @returns int | |
| * @param int $InstanceID | |
| */ | |
| function ZW_SearchMainDevice(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_SearchSubDevices | |
| * | |
| * @returns array | |
| * @param int $InstanceID | |
| */ | |
| function ZW_SearchSubDevices(int $InstanceID) { | |
| } | |
| /** | |
| * bewegt den Rolladen nach unten bis zur Endposition/Stop | |
| * | |
| * <p>Bewegt den Rolladen mit der ID <b>InstanzID</b> nach unten, bis ZW_ShutterStop ausgeführt oder die Endposition erreicht wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-shuttermovedown/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function ZW_ShutterMoveDown(int $InstanceID) { | |
| } | |
| /** | |
| * bewegt den Rolladen nach oben bis zur Endposition/Stop | |
| * | |
| * <p>Bewegt den Rolladen mit der ID <b>InstanzID</b> nach oben, bis ZW_ShutterStop ausgeführt oder die Endposition erreicht wird.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-shuttermoveup/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function ZW_ShutterMoveUp(int $InstanceID) { | |
| } | |
| /** | |
| * stoppt einen Bewegungsvorgang | |
| * | |
| * <p>Stoppt eine aktuelle Bewegung des Rolladens.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-shutterstop/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| */ | |
| function ZW_ShutterStop(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_StartAddDevice | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_StartAddDevice(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_StartAddNewPrimaryController | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_StartAddNewPrimaryController(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_StartRemoveDevice | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_StartRemoveDevice(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_StopAddDevice | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_StopAddDevice(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_StopAddNewPrimaryController | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_StopAddNewPrimaryController(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_StopRemoveDevice | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_StopRemoveDevice(int $InstanceID) { | |
| } | |
| /** | |
| * Setzt den Switch All Modus eines Z-Wave Geräts | |
| * | |
| * <p>Setzt die Instanz mit der ID <b>InstanzID</b> auf den Modus <b>Modus</b>.</p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-switchallmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des zu schaltenden Geräts</p> | |
| * @param int $Mode <p>Modus auf den das Z-Wave Gerät eingestellt werden soll</p> | |
| */ | |
| function ZW_SwitchAllMode(int $InstanceID, int $Mode) { | |
| } | |
| /** | |
| * schaltet ein Z-Wave Gerät an/aus | |
| * | |
| * <p>Schaltet das Gerät mit der ID <b>InstanzID</b> auf Wert <b>Status</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-switchmode/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param bool $DeviceOn <p><b>TRUE</b> für An, <b>FALSE</b> für Aus</p> | |
| */ | |
| function ZW_SwitchMode(int $InstanceID, bool $DeviceOn) { | |
| } | |
| /** | |
| * ZW_SwitchModeEx | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $DeviceOn | |
| * @param int $Duration | |
| */ | |
| function ZW_SwitchModeEx(int $InstanceID, bool $DeviceOn, int $Duration) { | |
| } | |
| /** | |
| * Testet ob eine Verbindung zu einem Z-Wave Gerät funktioniert | |
| * | |
| * <p>Testet die Verbindung zu dem Gerät mit der InstanzID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-test/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| */ | |
| function ZW_Test(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_TestDevice | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $NodeID | |
| */ | |
| function ZW_TestDevice(int $InstanceID, int $NodeID) { | |
| } | |
| /** | |
| * Setzt den FanMode für Thermostat | |
| * | |
| * <p>Setzt den FanMode <b>FanMode</b> vom angegeben Gerät mit der InstanzID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-thermostatfanmodeset/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param int $FanMode <p>0..255</p> | |
| * enum[0=tfmAutoLow, 1=tfmOnLow, 2=tfmAutoHigh, 3=tfmOnHigh] | |
| */ | |
| function ZW_ThermostatFanModeSet(int $InstanceID, int $FanMode) { | |
| } | |
| /** | |
| * Setzt den Thermostat Mode | |
| * | |
| * <p>Setzt den Mode <b>Mode</b> vom angegeben Gerät mit der InstanzID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-thermostatmodeset/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param int $Mode <p>0..255</p> | |
| * enum[0=tmOff, 1=tmHeat, 2=tmCool, 3=tmAuto, 4=tmAuxiliary, 5=tmResume, 6=tmFanOnly, 7=tmFurnace, 8=tmDryAir, 9=tmMoistAir, 10=tmAutoChangeover] | |
| */ | |
| function ZW_ThermostatModeSet(int $InstanceID, int $Mode) { | |
| } | |
| /** | |
| * Setzt den PointSet Value | |
| * | |
| * <p>Setzt den PointSet <b>PointSet</b> vom angegeben Gerät mit der InstanzID <b>InstanzID</b></p> | |
| * | |
| * @link https://www.symcon.de/de/service/dokumentation/modulreferenz/z-wave/zw-thermostatsetpointset/ | |
| * @returns bool <p>Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis <b>TRUE</b>, andernfalls <b>FALSE</b>.</p> | |
| * @param int $InstanceID <p>ID des Geräts</p> | |
| * @param int $SetPoint <p>0..255</p> | |
| * enum[0=tspInvalid, 1=tspHeating, 2=tspCooling, 3=tspFurnace, 4=tspDryAir, 5=tspMoistAir, 6=tspAutoChangeover, 7=tspEnergySaveHeating, 8=tspEnergySaveCooling, 9=tspAwayHeating, 10=tspAwayCooling, 11=tspFullPower] | |
| * @param float $Value <p>0..255</p> | |
| */ | |
| function ZW_ThermostatSetPointSet(int $InstanceID, int $SetPoint, float $Value) { | |
| } | |
| /** | |
| * ZW_UIAddAssociation | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $GroupID | |
| */ | |
| function ZW_UIAddAssociation(int $InstanceID, int $GroupID) { | |
| } | |
| /** | |
| * ZW_UIAddParameter | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_UIAddParameter(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_UICancelUserCode | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_UICancelUserCode(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_UICloseAddAssociationDialog | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_UICloseAddAssociationDialog(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_UIIsParameterQueued | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $ID | |
| */ | |
| function ZW_UIIsParameterQueued(int $InstanceID, int $ID) { | |
| } | |
| /** | |
| * ZW_UIOpenEditParameterDialog | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $ID | |
| * @param string $Name | |
| * @param string $Enum | |
| */ | |
| function ZW_UIOpenEditParameterDialog(int $InstanceID, int $ID, string $Name, string $Enum) { | |
| } | |
| /** | |
| * ZW_UIReadCustomValues | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_UIReadCustomValues(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_UIReadValues | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_UIReadValues(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_UISendCurrentConfigurationParameters | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_UISendCurrentConfigurationParameters(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_UISetRoutingOptions | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $ShowRepeating | |
| * @param bool $ShowResponding | |
| */ | |
| function ZW_UISetRoutingOptions(int $InstanceID, bool $ShowRepeating, bool $ShowResponding) { | |
| } | |
| /** | |
| * ZW_UIUpdateAssociations | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_UIUpdateAssociations(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_UIUpdateConfigurationParameters | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_UIUpdateConfigurationParameters(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_UIUpdateParameterSelection | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $ParameterValue | |
| */ | |
| function ZW_UIUpdateParameterSelection(int $InstanceID, int $ParameterValue) { | |
| } | |
| /** | |
| * ZW_UIUpdateUserCodeList | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| */ | |
| function ZW_UIUpdateUserCodeList(int $InstanceID) { | |
| } | |
| /** | |
| * ZW_UpdatePriorityReturnRoute | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $DestinationID | |
| * @param array $Route | |
| * @param int $Speed | |
| */ | |
| function ZW_UpdatePriorityReturnRoute(int $InstanceID, int $DestinationID, array $Route, int $Speed) { | |
| } | |
| /** | |
| * ZW_UpdatePriorityRoute | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param array $Route | |
| * @param int $Speed | |
| */ | |
| function ZW_UpdatePriorityRoute(int $InstanceID, array $Route, int $Speed) { | |
| } | |
| /** | |
| * ZW_UserCodeLearn | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param bool $Enabled | |
| */ | |
| function ZW_UserCodeLearn(int $InstanceID, bool $Enabled) { | |
| } | |
| /** | |
| * ZW_UserCodeRemove | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Identifier | |
| */ | |
| function ZW_UserCodeRemove(int $InstanceID, int $Identifier) { | |
| } | |
| /** | |
| * ZW_WakeUpSetInterval | |
| * | |
| * @returns bool | |
| * @param int $InstanceID | |
| * @param int $Seconds | |
| */ | |
| function ZW_WakeUpSetInterval(int $InstanceID, int $Seconds) { | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment