IPSShadowing - eine Beschattungssteuerung

10 Zeiten: 5 (100,90,75,50,25%) für Runterfahren und 5 für das Hochfahren.

Der Umfang war auch mein erster Gedanke (ist es auch noch immer). So wie Andreas mit der Stärke der Rolladenlamellen auch beschrieben hat.
Wegen der Gewichte:
Während beim Messen der Zeiten hatte ich den Fall (bei mehreren Rolladen) das die Zeiten immer kürzer wurden.
(Runter, Rauf, Runter, Rauf, etc…)
Daher meine Vermutung:
Das Gewicht beeinflusst vielleicht den Motor und die Schmiermittel. Der Motor wird zu heiß.

Fazit: Es wird wohl eine Verbindung aus beiden Ursachen haben.
Und die Zeiten sind abhängig von der Stärke der Lamellen (= Umfang) und der Höhe, Breite der Fensterfläche (=Gewicht).

Gruß
Günter

Hallo Andreas

Ich benutze dein Modul ja schon länger. Es macht immer wieder Spaß.
Ich bin jetzt gerade dabei meine Visu mit Mediola aufzubauen.
Jetzt wollte ich fragen ob man die Variablen unter der Katergorie Device 1 …8 umbennen kann.
Das Problem ist folgendes. Mediola erkennt nur Variablen unterhalb einer Instanz oder im Root Verzeichnis.
Leider sehe ich nur die Namen der Variablen also 8 mal Position da ich 8 Rollos habe.
Eine andrere möglichkeit wäre noch anstatt der Katergorie Device 1 eine Dummy Instanz anlegen.
Ich weiß nur Leider nicht wie das Modul Arbeitet mit den Namen oder mit den IDs.
Vieleicht könntest Du mir was dazu sagen.

Mfg Stefan

Ja, habe bei den Devices durchgängig den Ident verwendet, es sollte also kein Problem sein, die Variablen umzubenennen

Hallo Andreas,
analog des Example (Ansteuerung deiner Markissen über den IPSMessageHandler) versuche ich meine Rolladen zu steuern.
Ich vermute mal das über ExecuteButton aus IPSModuleSensor_IPSShadowing.class.php geschaltet wird.

Ausgangssituation: Schaltwippe
Unterschied zw. Lange und kurze Bedienung (-> 2 Instanzen)

__
Edit: Hab eine Lösung gefunden! -> Ich hab dir eine PN geschickt!
(Ist eine grundlegende Änderung: muss noch geklärt werden was die Änderung sonst noch beeinflusst.)

Gruß
Günter

Hallo zusammen,

ich habe das Skript installiert und versuche nun irgendwie einen Raffstore zufriedenstellend zu konfigurieren - leider klappt das nicht so wie ich mir das wünsche. Konkret habe ich drei Probleme: Lamellenwendung bei Raffstores, Ausrichtung von Räumen um Raffstores über den Sonnenstand zu führen und die Raumkonfiguration generell für die Visualisierung…

Das Wiki ist an dieser Stelle (zumindest für mich) keine Hilfe. Vielleicht suche ich aber auch nicht nach den richtigen Stichworten.

Nun aber zu meinen Fragen:

Lamellenwendung:

Die Angabe der Zeit in den Parametern „c_Property_TimeDimoutUp“ bzw. „c_Property_TimeDimoutDown“ ist mit der Angabe von glatten Sekunden zu unpräzise…

Meine Raffstores wenden in etwas weniger als 2 Sekunden (1.8 Sekunden um genau zu sein) komplett. Und ich möchte im Beschattungsmodus eine Wendung von ca. 40 Grad (0.7 / 1.8 Sekunden) und nicht ca. 56 Grad (1.0 /1,8 Sekunden) erreichen. Gibt es da eine andere Möglichkeit?

Ausrichtung eines Raumes:

Mir ist auch nicht ganz klar, wie das Programm rausbekommt, in welche Himmelsrichtung eine Fenster ausgerichtet ist. Pro Raum kann ich es nicht konfigurieren. Es gibt teilweise Räume mit Ausrichtung in zwei bis drei Himmelsrichtungen…

Raumkonfiguration im allgemeinen für die Visualisierung:

Darüber hinaus frage ich mich, wie ich mit einem vertretbaren Aufwand die Räume konfiguriere, damit diese in der Web-Oberfläche korrekt angezeigt werden (und nicht Zimmer 1, 2 und Markise). Manuelle Anpassung des WebFronts ist ja ein ziemlicher Krampf was die Geschwindigkeit anbelangt - oder muss man da einfach einmal durch?

Freue mich über jede Hilfe. Besten Dank!

VG, Christian

Hi Christian,

bez. Lamellenwendung weiss ich jetzt adhoc auch keine Abhilfe.
Das ganze ist aber von deiner Ansteuerung abhängig…wenn du das ganze z.b. über KNX Aktoren machst, denen du den Beschattungsstatus explizit mitteilen kannst, könnte man ev. eine eigene property class machen.

Die Raumausrichtung ist eigentlich einfach zu lösen.
Du mußt jeden einzelnen Rolladen einrichten, den kannst du dann auch entsprechend ausrichten, da er eindeutig ist.

Die Raumkonfiguration wird im Config File gemacht, dort kannst du einfach die Raumnamen eintragen.
Für deinen Fall müsstest du dann quasi für jeden Rolladen einen Raum machen (wegen der Ausrichtung).

Du kannst aber einzelne Räumen mittels Szenarien ansteuern (1 Szene sind dann z.b. die 3 Rolladen in einem bestimmten Raum).
Das ganze geht sehr bequem direkt im Webfront.
Bei mir sieht das so aus:

Ich möchte das Thema mit der Lamellenwendung noch einmal aufgreifen…

Ich habe mich jetzt mit den Scripten auseinander gesetzt und verstehe noch nicht so ganz warum es nicht möglich sein sollte nicht ganzzahlige Positionen anzufahren. Mir meiner bisherigen, selbst definierten Steuerung in HomeMatic-Skripten gibt es.

Ich habe das Behang und Wendung als Parameter übergeben und daraus die Fahrtenfolge abgeleitet. Zum Beispiel bedeutet 10W40 in meiner alten Logik:
1.) Behang auf 10% fahren
2.) Pause einlegen und Zielwert für 40% Lamellenwendung berechnen (hier: 1,8 Sekunden Komplettwendung * 0,4 = 0,72 Sekunden Wendezeit)
3.) Wendezeit in Delta zur aktuellen Behanghöhe umrechnen (hier: 10% + 0,72 Sekunden Wendezeit / 55 Sekunden Gesamtfahrzeit * 100 = 11,31 %)
4.) Behang auf 11,31% fahren

Damit bekam ich in der Vergangenheit jede beliebige Wendung hin. Wenn müsste ich wohl ein Script verändern, um Float-Werte an den Aktor übergeben zu können?

VG, Christian

Hallo Christian!
hier ein Beispielauszug aus meiner Config (habe aber nur Rolläden)

c_Property_TimeOpening		=> 24,
c_Property_TimeClosing		=> 21.5,

Versuch einfach FLOAT Werte einzugeben.
In der Übersicht kannst du sehen, dass die Prozentangaben als Dezimalbruchzahlen verarbeitet werden.

ABER: Die aktuellen Position wird aus der Variablen ‚Position‘ entnommen. --> Die ist eine Integervariable.

Bei Rolläden macht das nicht so viel aus. Mit der Dezimalzahl wird es nur ein bisschen genauer.
Ich vermute aber dass bei der Lamellenverstellung ein Problem aufkommt.
Hier könntest du probieren ein neues Variablenprofil mit FLOAT auf den Positionsvariablen zu hinterlegen.
Wenn ich den Code richtig gelesen habe, verarbeitet Brownson nur Varianttypes. Das heisst es wird keine Umwandlung des Variablentyps in den Scripts durchgeführt.

Damit verlierst du aber die Updatekompatibilität.

Gruß
Günter

Ich habe mal testweise verglichen, ob es einen Unterschied macht ob ich von IPS oder Homematic aus die Lamellen fahre - ganz unabhängig bon IPSShadowing. Sollte ja funktionieren. Dummerweise tut es genau das nicht!

Folgendes Skript fährt einfach einen Aktor in die gewünschte Position:


$id_aktor = 19917;  //ID es Aktors
$v_level = 0.01; // entspricht 1%
HM_WriteValueFloat($id_aktor, "LEVEL" , $v_level);

Glatte Prozentwerte sollten generell nie ein Problem sein - meine ich… Aber die Lamellenwendung in IPS ist trotzdem völlig willkürlich.
Mal fährt der Aktor zu weit und mal fährt er zu weniger oder gar nicht. Letzteres passierte mir in meiner eigenen Anwendung immer dann, wenn das Delta zwischen Ist- und Soll-Stellung des Aktors kleiner als 0,5% war. Homematic rundet intern auf halbe Prozente.
Homematic direkt ausgeführt fährt sauber alles an.

Irgendwie sehr unbefriedigend.

An den Laufzeiten der Raffstores kann es nicht liegen. Die habe ich selbstverständlich pro Aktor gemessen.

Mir scheint auch die Reihenfolge der Fahrten für Raffstores etwas merkwürdig. Warum werden die Positionen alle so umständlich angefahren. Im Prinzip reichen für ein sauberes anfahren der Behanghöhe und Lamellenwendung in jeder gewünschten Höhe drei Zwischenstufen. Das ganze „rauf- und runtergefahre“ vom Skript macht mich irgendwie wahnsinnig.

Damit musst du leben! Der Grund ist im Rohrmotor/Jalousiemotor zu suchen. Das sind im allgemeinen Getriebemotoren. Mit Schrittmotoren könntest du millimetergenau fahren. Die Ansteuerung dafür ist aber nicht mehr wirtschaftlich und wie es mit dem Gewicht vom Behang und dem Drehmoment aussieht, da kann ich auch nur raten. Und fertige Lösungen mit Schrittmotoren gibt es meines Wissens nicht.

Siehe oben, geht eben nicht millimetergenau.

Die Messungen sind eben auch nur relativ. Je genauer die Messung von Endlage zu Endlage desto besser. Ein Fahren von einer Zwischenposition aus, ist trotzdem nicht mehr genau.

Normalerweise müsstest du sogar folgendes machen:
Wenn du aus einer Zwischenpostion aus eine Lamellenverstellung durchführen willst, müsstest du zurück zu einer Endlage fahren und erst dann zur gewünschten Position.
Bsp: 50% -> 0% -> 75%

Fazit: Es wird hier keiner eine für dich maßgeschneiderte Lösung anbieten können.

Das hingegen denke ich nicht - bezogen auf die Motoren. Es ging ja bislang auch.
Irgendeine Lösung muss es geben, denn leben kann ich mit der aktuellen Lösung nicht… :wink:

Korrekt, wobei ich man davon ausgehen sollte das einige Zwischenschritte hinreichend genau angefahren werden. Wenn man sich permanent zwischen den Endlagen bewegt, wird es natürlich irgendwann ungenau. In der Regel werden die Endlagen oben/unten aber zweimal am Tag (Dämmerung morgens/abends) angefahren. Das reicht in der Praxis aus.

Beziehst Du Dich bei den Prozentwerten auf die Lamellenwendung? Dann ist das in meinen Augen dann nicht ganz richtig.

Die Wendung der Lamellen hat mit der Höhe des Behangs ja erst einmal gar nichts zu tun. Ich muss nur wissen wann die Lamellen in einer definierten Position sind - und das ist bei allen Raffstores der Fall, wenn diese ein wenig länger nach oben oder unten gefahren werden als eine komplette Wendung dauert. In der Regel werden das wenige Prozent oder Sekunden sein. Bei einer Wendedauer von 2 Sekunden z. B. reichen 3 Sekunden völlig und die Lamellen stehen entweder auf 0% (geschlossen) oder 100% (geschlossen-invers). Danach kann ich wieder sauber die gewünschte Lamellenwendung anfahren.

IPSShadowing macht ja im Grunde nichts anderes. Hier wird immer der Behang auf 100% (unten) gefahren, und dann geht es an die Verstellung der Lamellen. Bei einer Behanghöhe von 100% (unten) sind die Lamellen immer auf 0% Wendungen (geschlossen) gestellt. Das geht bei Raffstores technisch gar nicht anders. Daher sind weitere Kalibirierungen aus der Endlage heraus überflüssig bzw. machen sie die Sache nicht besser sondern definitiv schlechter/ungenauer.

Die entsprechenden Schritt habe ich im Script schon rausgenommen. Damit funktioniert das Abdunkeln wunderbar. Aber das ist ja auch keine Kunst in die Endlage zu fahren…

Das muss auch gar nicht sein. Ich bin leider kein PHP- oder IPS-Experte - daher hoffe ich, dass ich aber noch Tipp(s) oder Unterstützung bekomme, wie im Modul die Problematik der ganzzahligen Positionen/Sekunden gelöst werden kann. Ich selbst habe es nicht hinbekommen als ich gestern noch das Objektmodell und die Scripte um Float-Variablen erweitert habe. Die existierenden Attribute in den Device-Objekten kann ich ja nicht anpassen…

Es kann doch nicht sein, dass bei der Verbreitung von IPS und dem IPSShadowing-Modul niemand sonst Probleme mit der Genauigkeit der Beschattung hat. :confused:

Hallo,

ich habe die beschattungssteuerung instaliert aber es functioniert noch nicht correct denke ich, ich denke das die werte fon azimut und elevation nicht werden ubernomen.

Mus ich hier nog ein einstellung anderen?

danke, Ron

Hallo , scheint ein AnzeigeBug zu sein.
Es werden die Daten fuer 16 Uhr angezeigt.
Fuege mal in der Datei IPSShadowing_Azimuth.inc.php in Zeile 180 ( vor // Print Building ) folgendes ein.

 		$data  = Get_AnzimuatAndElevation( time(), $longitude, $latitude);
    $azimuth   = round($data['Azimuth']);
    $elevation = round($data['Elevation']);
    
 		// Print Building
		// --------------------------------------------------------------------------------------------------------------------------

Sorry the change what you did write nothing change at mt visu.

The problem is also that the shadowing going down in the morning by „tagesbegin“ also when the sun is not strong!!

i think i do something wrong in my settings also but i don’t can find it.

I hope there is someone what can help me a littel.

Thanks, Ron

<?
	/*
	 * This file is part of the IPSLibrary.
	 *
	 * The IPSLibrary is free software: you can redistribute it and/or modify
	 * it under the terms of the GNU General Public License as published
	 * by the Free Software Foundation, either version 3 of the License, or
	 * (at your option) any later version.
	 *
	 * The IPSLibrary is distributed in the hope that it will be useful,
	 * but WITHOUT ANY WARRANTY; without even the implied warranty of
	 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	 * GNU General Public License for more details.
	 *
	 * You should have received a copy of the GNU General Public License
	 * along with the IPSLibrary. If not, see http://www.gnu.org/licenses/gpl.txt.
	 */    

	/**@addtogroup ipsshadowing
	 * @{
	 *
	 * @file          IPSShadowing_Azimuth.inc.php
	 * @author        Andreas Brauneis
	 * @version
	 * Version 2.50.1, 21.03.2012<br/>
	 *
	 * Berechnung/Grafik von Azimuth und Elevation 
	 *
	 */
	 
	IPSUtils_Include ("IPSLogger.inc.php",                      "IPSLibrary::app::core::IPSLogger");
	IPSUtils_Include ("IPSComponent.class.php",                 "IPSLibrary::app::core::IPSComponent");
	IPSUtils_Include ("IPSShadowing_Constants.inc.php",         "IPSLibrary::app::modules::IPSShadowing");
	IPSUtils_Include ("IPSShadowing_Configuration.inc.php",     "IPSLibrary::config::modules::IPSShadowing");
	IPSUtils_Include ("IPSShadowing_Custom.inc.php",            "IPSLibrary::config::modules::IPSShadowing");
	IPSUtils_Include ("IPSShadowing_Logging.inc.php",           "IPSLibrary::app::modules::IPSShadowing");
	IPSUtils_Include ("IPSShadowing_Device.class.php",          "IPSLibrary::app::modules::IPSShadowing");
	IPSUtils_Include ("IPSShadowing_ProfileTemp.class.php",     "IPSLibrary::app::modules::IPSShadowing");
	IPSUtils_Include ("IPSShadowing_ProfileTime.class.php",     "IPSLibrary::app::modules::IPSShadowing");
	IPSUtils_Include ("IPSShadowing_ProfileManager.class.php",  "IPSLibrary::app::modules::IPSShadowing");
	IPSUtils_Include ("IPSShadowing_Scenario.class.php",        "IPSLibrary::app::modules::IPSShadowing");
	IPSUtils_Include ("IPSShadowing_ScenarioManager.class.php", "IPSLibrary::app::modules::IPSShadowing");

	//IPSShadowing_GenerateSunGraphic(time(), 150, 190,30);

	function IPSShadowing_GenerateSunGraphic($graphDate, $azimuthBgn=110, $azimuthEnd=220, $elevationLvl=20, $orientationSouth=false) {
		$longitude      = IPSSHADOWING_LONGITUDE;
		$latitude       = IPSSHADOWING_LATITUDE;
		$orientationDeg = IPSSHADOWING_BUILDINGORIENTATION;
		$relationDeg    = IPSSHADOWING_BUILDINGRELATION;

		$imageWidth   = 400;
		$imageHeight  = 450;

		$image         = imagecreate($imageWidth,$imageHeight);
		$white         = imagecolorallocate($image,255,255,255);
		$textColor     = imagecolorallocate($image,250,250,250);
		$transparent   = imagecolortransparent($image,$white);

		$elevationVOffset   = 110;
		$elevationSunRadio  = 10;
		$elevationFactor    = 1.5;
		$elevationColorAct  = imagecolorallocate($image, 255, 255, 0); // Yellow
		$elevationColorNor  = imagecolorallocate($image,  55,  55, 0);
		$elevationColorLine = imagecolorallocate($image, 100, 100, 100);
		$elevationColorText = imagecolorallocate($image, 200, 200, 200);

		$sunDegree      = $orientationSouth ? 0 : $orientationDeg;
		$sunOffsetH     = $imageWidth/2;
		$sunOffsetV     = $imageHeight/2+100;
		$sunRadius1     = $imageWidth/2-70;
		$sunRadius2     = $imageWidth/5;
		$sunColorAct    = imagecolorallocate($image, 255, 255, 0); // Yellow
		$sunColorEle    = imagecolorallocate($image, 200, 200, 200);
		$sunColorNor    = imagecolorallocate($image,  55,  55, 0);

		$buildingDeg1   = $orientationSouth ? 45 - $orientationDeg  : 45;
		$buildingDeg2   = $relationDeg;
		$buildingVOffset= $sunOffsetV;
		$buildingHOffset= $imageWidth/2;
		$buildingRadius = $imageWidth/7;
		$buildingColor  = imagecolorallocate($image, 100, 100, 100); // Grey

		// Prepare Elevation Display
		for ($idx=0;$idx<=60;$idx=$idx+10) {
			imageline($image, 20, $elevationVOffset-$idx*$elevationFactor, $imageWidth-10, $elevationVOffset-$idx*$elevationFactor, $elevationColorLine);
			imagestring($image,2,0,$elevationVOffset-$idx*$elevationFactor-7,$idx."°",$elevationColorText);
		}
		for ($hour=2;$hour<=22;$hour=$hour+2) {
			imageline($image, $imageWidth/24*$hour, $elevationVOffset+5, $imageWidth/24*$hour, $elevationVOffset-60*$elevationFactor-7, $elevationColorLine);
			imagestring($image,2,$imageWidth/24*$hour-5,$elevationVOffset+10,str_pad($hour, 2, "0", STR_PAD_LEFT),$elevationColorText);
		}

		for ($hour=0; $hour<24; $hour++) {
			$data      = Get_AnzimuatAndElevation(mktime($hour, 0, 0, date('n',$graphDate), date('d', $graphDate), date("Y",$graphDate)), $longitude, $latitude);
			$azimuth   = round($data['Azimuth']);
			$elevation = round($data['Elevation']);

			// Elevation
			// --------------------------------------------------------------------------------------------------------------------------
			if ($elevation >= -5) {
				$elevationColor = $elevationColorNor;
				if ($elevation>=$elevationLvl) {$elevationColor = $elevationColorAct;}
				imagefilledarc($image, $imageWidth/24*$hour, $elevationVOffset-$elevation*$elevationFactor, $elevationSunRadio, $elevationSunRadio, 0, 360, $elevationColor, IMG_ARC_PIE);
			}

			// Print Sun
			$sunColor = $sunColorNor;
			if ($azimuth>=$azimuthBgn and $azimuth<=$azimuthEnd) {
			   $sunColor = $sunColorAct;
			   if ($elevation < $elevationLvl) $sunColor = $sunColorEle;
			}

			// Azimut
			// --------------------------------------------------------------------------------------------------------------------------
			if ($elevation >=0) {
				$deg = 270-$azimuth-$sunDegree;
				$x1 = round(cos(($deg) * M_PI / 180) * $sunRadius1)+$sunOffsetH;
    			$y1 = round(sin(($deg) * M_PI / 180) * $sunRadius1);
				$x2 = round(cos(($deg+1) * M_PI / 180) * $sunRadius1)+$sunOffsetH;
    			$y2 = round(sin(($deg+1) * M_PI / 180) * $sunRadius1);
				$x3 = round(cos(($deg+1) * M_PI / 180) * $sunRadius2)+$sunOffsetH;
    			$y3 = round(sin(($deg+1) * M_PI / 180) * $sunRadius2);
				$x4 = round(cos(($deg) * M_PI / 180) * $sunRadius2)+$sunOffsetH;
    			$y4 = round(sin(($deg) * M_PI / 180) * $sunRadius2);
				$x5 = round(cos(($deg-1.5) * M_PI / 180) * ($sunRadius2+10))+$sunOffsetH;
    			$y5 = round(sin(($deg-1.5) * M_PI / 180) * ($sunRadius2+10));
				$x6 = round(cos(($deg+2.5) * M_PI / 180) * ($sunRadius2+10))+$sunOffsetH;
    			$y6 = round(sin(($deg+2.5) * M_PI / 180) * ($sunRadius2+10));

				imagefilledpolygon ($image ,array($x1,$sunOffsetV-$y1,$x2,$sunOffsetV-$y2,$x3,$sunOffsetV-$y3,$x4,$sunOffsetV-$y4), 4, $sunColor);
				imagefilledpolygon ($image ,array($x3,$sunOffsetV-$y3,$x4,$sunOffsetV-$y4,$x5,$sunOffsetV-$y5,$x6,$sunOffsetV-$y6), 4, $sunColor);

				$x3 = round(cos($deg * M_PI / 180) * $sunRadius1+9)+$sunOffsetH;
				$y3 = round(sin($deg * M_PI / 180) * $sunRadius1+9);
				if ($x3<=$imageWidth/2) {$x3=$x3-25;}
				imagestring($image,2,$x3,$sunOffsetV-$y3,str_pad($hour, 2, "0", STR_PAD_LEFT),$elevationColorText);
			}
		}

		for ($hour=9; $hour<17; $hour++) {
			$data      = Get_AnzimuatAndElevation(mktime($hour, 30, 0, date('n',$graphDate), date('d', $graphDate), date("Y",$graphDate)), $longitude, $latitude);
			$azimuth   = round($data['Azimuth']);
			$elevation = round($data['Elevation']);

			$sunColor = $sunColorNor;
			if ($azimuth>=$azimuthBgn and $azimuth<=$azimuthEnd) {
			   $sunColor = $sunColorAct;
			   if ($elevation < $elevationLvl) $sunColor = $sunColorEle;
			}
			if ($elevation >=10) {
				$deg = 270-$azimuth-$sunDegree;
				$x1 = round(cos(($deg) * M_PI / 180) * ($sunRadius1-10))+$sunOffsetH;
    			$y1 = round(sin(($deg) * M_PI / 180) * ($sunRadius1-10));
				$x2 = round(cos(($deg) * M_PI / 180) * ($sunRadius1-10))+$sunOffsetH;
    			$y2 = round(sin(($deg) * M_PI / 180) * ($sunRadius1-10));
				$x3 = round(cos(($deg) * M_PI / 180) * ($sunRadius2+10))+$sunOffsetH;
    			$y3 = round(sin(($deg) * M_PI / 180) * ($sunRadius2+10));
				$x4 = round(cos(($deg) * M_PI / 180) * ($sunRadius2+10))+$sunOffsetH;
    			$y4 = round(sin(($deg) * M_PI / 180) * ($sunRadius2+10));

				imageline($image, $x1,$sunOffsetV-$y1, $x3,$sunOffsetV-$y3, $sunColor);
			}
		}

		$x3 = round(cos((270-90-$sunDegree) * M_PI / 180) * ($sunRadius1+50))+$sunOffsetH;
		$y3 = round(sin((270-90-$sunDegree) * M_PI / 180) * ($sunRadius1+50));
		imagestring($image,4,$x3,$sunOffsetV-$y3,'Ost',$elevationColorText);

		$x3 = round(cos((270-180-$sunDegree) * M_PI / 180) * ($sunRadius1+25))+$sunOffsetH-15;
		$y3 = round(sin((270-180-$sunDegree) * M_PI / 180) * ($sunRadius1+25));
		imagestring($image,4,$x3,$sunOffsetV-$y3,'Süd',$elevationColorText);

		$x3 = round(cos((270-270-$sunDegree) * M_PI / 180) * ($sunRadius1+25))+$sunOffsetH;
		$y3 = round(sin((270-270-$sunDegree) * M_PI / 180) * ($sunRadius1+25));
		imagestring($image,4,$x3,$sunOffsetV-$y3,'West',$elevationColorText);

     $data  = Get_AnzimuatAndElevation( time(), $longitude, $latitude);
     $azimuth   = round($data['Azimuth']);
     $elevation = round($data['Elevation']);

		// Print Building
		// --------------------------------------------------------------------------------------------------------------------------
		$points = array(
			round(cos(($buildingDeg1-$buildingDeg2) * M_PI / 180)                     * $buildingRadius)+$buildingHOffset,
			round(sin(($buildingDeg1-$buildingDeg2) * M_PI / 180)                     * $buildingRadius)+$buildingVOffset,
			round(cos(($buildingDeg1+90+$buildingDeg2) * M_PI / 180)  * $buildingRadius)+$buildingHOffset,
			round(sin(($buildingDeg1+90+$buildingDeg2) * M_PI / 180)  * $buildingRadius)+$buildingVOffset,
			round(cos(($buildingDeg1+180-$buildingDeg2) * M_PI / 180)               * $buildingRadius)+$buildingHOffset,
			round(sin(($buildingDeg1+180-$buildingDeg2) * M_PI / 180)               * $buildingRadius)+$buildingVOffset,
			round(cos(($buildingDeg1+270+$buildingDeg2) * M_PI / 180) * $buildingRadius)+$buildingHOffset,
			round(sin(($buildingDeg1+270+$buildingDeg2) * M_PI / 180) * $buildingRadius)+$buildingVOffset ,
			);
		imagefilledpolygon ($image ,$points, 4, $buildingColor);

		imagestring($image,4,5,$elevationVOffset+35, 'Datum: '.date('Y-m-d',$graphDate),$buildingColor);

		imagestring($image,2,5,$imageHeight-15, 'Latitude: '.round($latitude,2),$buildingColor);
		imagestring($image,2,5,$imageHeight-30, 'Longitude: '.round($longitude,2),$buildingColor);
		imagestring($image,2,$imageWidth/2+10,$imageHeight-15, 'Elevation aktuell: '.$elevation,$buildingColor);
		imagestring($image,2,$imageWidth/2+10,$imageHeight-30, 'Azimuth aktuell: '.$azimuth,$buildingColor);

		// Write File
		imagegif ($image, IPS_GetKernelDir().'media\\IPSShadowing_Azimuth.gif', 90);
		imagedestroy($image);
	}

	function IPSShadowing_GenerateSunGraphicOld($graphDate, $azimuthBgn=110, $azimuthEnd=220, $elevationLvl=20) {
		$longitude    = IPSSHADOWING_LONGITUDE;
		$latitude     = IPSSHADOWING_LATITUDE;

		$imageWidth   = 300;
		$imageHeight  = 400;
		
		$image         = imagecreate($imageWidth,$imageHeight);
		$white         = imagecolorallocate($image,255,255,255);
		$textColor     = imagecolorallocate($image,250,250,250);
		$transparent   = imagecolortransparent($image,$white);

		$elevationVOffset   = 110;
		$elevationSunRadio  = 10;
		$elevationFactor    = 1.5;
		$elevationColorAct  = imagecolorallocate($image, 255, 255, 0); // Yellow
		$elevationColorNor  = imagecolorallocate($image,  55,  55, 0); 
		$elevationColorLine = imagecolorallocate($image, 100, 100, 100);
		$elevationColorText = imagecolorallocate($image, 200, 200, 200);

		$sunOffsetH  = $imageWidth/2;
		$sunOffsetV  = $imageHeight/2+80;
		$sunRadius1 = $imageWidth/2-20;
		$sunRadius2 = $imageWidth/4;
		$sunColorAct = imagecolorallocate($image, 255, 255, 0); // Yellow
		$sunColorEle = imagecolorallocate($image, 200, 200, 200);
		$sunColorNor = imagecolorallocate($image,  55,  55, 0);

		$buildingDeg1=15;
		$buildingDeg2=20;
		$buildingVOffset=$sunOffsetV;
		$buildingHOffset=$imageWidth/2;
		$buildingRadius=$imageWidth/5;
		$buildingColor = imagecolorallocate($image, 100, 100, 100); // Grey

		// Prepare Elevation Display
		for ($idx=0;$idx<=60;$idx=$idx+10) {
			imageline($image, 20, $elevationVOffset-$idx*$elevationFactor, $imageWidth-10, $elevationVOffset-$idx*$elevationFactor, $elevationColorLine);
			imagestring($image,2,0,$elevationVOffset-$idx*$elevationFactor-7,$idx."°",$elevationColorText);
		}
		for ($hour=2;$hour<=22;$hour=$hour+2) {
			imageline($image, $imageWidth/24*$hour, $elevationVOffset+5, $imageWidth/24*$hour, $elevationVOffset-60*$elevationFactor-7, $elevationColorLine);
			imagestring($image,2,$imageWidth/24*$hour-5,$elevationVOffset+10,str_pad($hour, 2, "0", STR_PAD_LEFT),$elevationColorText);
		}

		for ($hour=0; $hour<24; $hour++) {
			$data      = Get_AnzimuatAndElevation(mktime($hour, 0, 0, date('n',$graphDate), date('d', $graphDate), date("Y",$graphDate)), $longitude, $latitude);
			$azimuth   = round($data['Azimuth']);
			$elevation = round($data['Elevation']);

			// Elevation
			// --------------------------------------------------------------------------------------------------------------------------
			if ($elevation >= -5) {
				$elevationColor = $elevationColorNor;
				if ($elevation>=$elevationLvl) {$elevationColor = $elevationColorAct;}
				imagefilledarc($image, $imageWidth/24*$hour, $elevationVOffset-$elevation*$elevationFactor, $elevationSunRadio, $elevationSunRadio, 0, 360, $elevationColor, IMG_ARC_PIE);
			}

			// Print Sun
			$sunColor = $sunColorNor;
			if ($azimuth>=$azimuthBgn and $azimuth<=$azimuthEnd) {
			   $sunColor = $sunColorAct;
			   if ($elevation < $elevationLvl) $sunColor = $sunColorEle;
			}

			// Azimut
			// --------------------------------------------------------------------------------------------------------------------------
			if ($elevation >=0) {
				$deg = 270-$azimuth;
				$x1 = round(cos(($deg) * M_PI / 180) * $sunRadius1)+$sunOffsetH;
    			$y1 = round(sin(($deg) * M_PI / 180) * $sunRadius1);
				$x2 = round(cos(($deg+1) * M_PI / 180) * $sunRadius1)+$sunOffsetH;
    			$y2 = round(sin(($deg+1) * M_PI / 180) * $sunRadius1);
				$x3 = round(cos(($deg+1) * M_PI / 180) * $sunRadius2)+$sunOffsetH;
    			$y3 = round(sin(($deg+1) * M_PI / 180) * $sunRadius2);
				$x4 = round(cos(($deg) * M_PI / 180) * $sunRadius2)+$sunOffsetH;
    			$y4 = round(sin(($deg) * M_PI / 180) * $sunRadius2);
				$x5 = round(cos(($deg-1.5) * M_PI / 180) * ($sunRadius2+10))+$sunOffsetH;
    			$y5 = round(sin(($deg-1.5) * M_PI / 180) * ($sunRadius2+10));
				$x6 = round(cos(($deg+2.5) * M_PI / 180) * ($sunRadius2+10))+$sunOffsetH;
    			$y6 = round(sin(($deg+2.5) * M_PI / 180) * ($sunRadius2+10));

				imagefilledpolygon ($image ,array($x1,$sunOffsetV-$y1,$x2,$sunOffsetV-$y2,$x3,$sunOffsetV-$y3,$x4,$sunOffsetV-$y4), 4, $sunColor);
				imagefilledpolygon ($image ,array($x3,$sunOffsetV-$y3,$x4,$sunOffsetV-$y4,$x5,$sunOffsetV-$y5,$x6,$sunOffsetV-$y6), 4, $sunColor);

				$x3 = round(cos($deg * M_PI / 180) * $sunRadius1+9)+$sunOffsetH;
				$y3 = round(sin($deg * M_PI / 180) * $sunRadius1+9);
				if ($x3<=$imageWidth/2) {$x3=$x3-25;}
				imagestring($image,2,$x3,$sunOffsetV-$y3,str_pad($hour, 2, "0", STR_PAD_LEFT),$elevationColorText);
			}
		}

		for ($hour=9; $hour<17; $hour++) {
			$data      = Get_AnzimuatAndElevation(mktime($hour, 30, 0, date('n',$graphDate), date('d', $graphDate), date("Y",$graphDate)), $longitude, $latitude);
			$azimuth   = round($data['Azimuth']);
			$elevation = round($data['Elevation']);

			$sunColor = $sunColorNor;
			if ($azimuth>=$azimuthBgn and $azimuth<=$azimuthEnd) {
			   $sunColor = $sunColorAct;
			   if ($elevation < $elevationLvl) $sunColor = $sunColorEle;
			}
			if ($elevation >=10) {
				$deg = 270-$azimuth;
				$x1 = round(cos(($deg) * M_PI / 180) * ($sunRadius1-10))+$sunOffsetH;
    			$y1 = round(sin(($deg) * M_PI / 180) * ($sunRadius1-10));
				$x2 = round(cos(($deg) * M_PI / 180) * ($sunRadius1-10))+$sunOffsetH;
    			$y2 = round(sin(($deg) * M_PI / 180) * ($sunRadius1-10));
				$x3 = round(cos(($deg) * M_PI / 180) * ($sunRadius2+10))+$sunOffsetH;
    			$y3 = round(sin(($deg) * M_PI / 180) * ($sunRadius2+10));
				$x4 = round(cos(($deg) * M_PI / 180) * ($sunRadius2+10))+$sunOffsetH;
    			$y4 = round(sin(($deg) * M_PI / 180) * ($sunRadius2+10));

				imageline($image, $x1,$sunOffsetV-$y1, $x3,$sunOffsetV-$y3, $sunColor);
			}
		}

			
		// Print Building
		// --------------------------------------------------------------------------------------------------------------------------
		$points = array(
			round(cos($buildingDeg1 * M_PI / 180)                     * $buildingRadius)+$buildingHOffset,
			round(sin($buildingDeg1 * M_PI / 180)                     * $buildingRadius)+$buildingVOffset,
			round(cos(($buildingDeg1+90+$buildingDeg2) * M_PI / 180)  * $buildingRadius)+$buildingHOffset,
			round(sin(($buildingDeg1+90+$buildingDeg2) * M_PI / 180)  * $buildingRadius)+$buildingVOffset,
			round(cos(($buildingDeg1+180) * M_PI / 180)               * $buildingRadius)+$buildingHOffset,
			round(sin(($buildingDeg1+180) * M_PI / 180)               * $buildingRadius)+$buildingVOffset,
			round(cos(($buildingDeg1+270+$buildingDeg2) * M_PI / 180) * $buildingRadius)+$buildingHOffset,
			round(sin(($buildingDeg1+270+$buildingDeg2) * M_PI / 180) * $buildingRadius)+$buildingVOffset ,
			);
		imagefilledpolygon ($image ,$points, 4, $buildingColor);

		imagestring($image,2,5,$imageHeight-15, 'Latitude: '.round($latitude,2),$buildingColor);
		imagestring($image,2,5,$imageHeight-30, 'Longitude: '.round($longitude,2),$buildingColor);
		imagestring($image,2,5,$elevationVOffset+20, 'Datum: '.date('Y-m-d',$graphDate),$buildingColor);

		imagestring($image,2,$imageWidth/2+10,$imageHeight-15, 'Elevation aktuell: '.$elevation,$buildingColor);
		imagestring($image,2,$imageWidth/2+10,$imageHeight-30, 'Azimuth aktuell: '.$azimuth,$buildingColor);

		// Write File
		imagegif ($image, IPS_GetKernelDir().'media\\IPSShadowing_Azimuth.gif', 90);
		imagedestroy($image);
	}

	function Get_AnzimuatAndElevation($time, $dLongitude, $dLatitude) {
		$dHours = gmdate('H', $time);
		$dMinutes = gmdate('i', $time);
		$dSeconds = gmdate('s', $time);
		$iYear = gmdate('Y', $time);
		$iMonth = gmdate('m', $time);
		$iDay = gmdate('d', $time);

		$pi = 3.14159265358979323846;
		$twopi = (2*$pi);
		$rad = ($pi/180);
		$dEarthMeanRadius = 6371.01;    // In km
		$dAstronomicalUnit = 149597890; // In km

		// Calculate difference in days between the current Julian Day
		// and JD 2451545.0, which is noon 1 January 2000 Universal Time
		// Calculate time of the day in UT decimal hours
		$dDecimalHours = floatval($dHours) + (floatval($dMinutes) + floatval($dSeconds) / 60.0 ) / 60.0;
		// Calculate current Julian Day
		$iYfrom2000 = $iYear;//expects now as YY ;
		$iA= (14 - ($iMonth)) / 12;
		$iM= ($iMonth) + 12 * $iA -3;
		$liAux3=(153 * $iM + 2)/5;
		$liAux4= 365 * ($iYfrom2000 - $iA);
		$liAux5= ( $iYfrom2000 - $iA)/4;
		$dElapsedJulianDays= floatval(($iDay + $liAux3 + $liAux4 + $liAux5 + 59)+ -0.5 + $dDecimalHours/24.0);

		// Calculate ecliptic coordinates (ecliptic longitude and obliquity of the
		// ecliptic in radians but without limiting the angle to be less than 2*Pi
		// (i.e., the result may be greater than 2*Pi)
		$dOmega= 2.1429 - 0.0010394594 * $dElapsedJulianDays;
		$dMeanLongitude = 4.8950630 + 0.017202791698 * $dElapsedJulianDays; // Radians
		$dMeanAnomaly = 6.2400600 + 0.0172019699 * $dElapsedJulianDays;
		$dEclipticLongitude = $dMeanLongitude + 0.03341607 * sin( $dMeanAnomaly ) + 0.00034894 * sin( 2 * $dMeanAnomaly ) -0.0001134 -0.0000203 * sin($dOmega);
		$dEclipticObliquity = 0.4090928 - 6.2140e-9 * $dElapsedJulianDays +0.0000396 * cos($dOmega);

		// Calculate celestial coordinates ( right ascension and declination ) in radians
		// but without limiting the angle to be less than 2*Pi (i.e., the result may be
		// greater than 2*Pi)
		$dSin_EclipticLongitude = sin( $dEclipticLongitude );
		$dY1 = cos( $dEclipticObliquity ) * $dSin_EclipticLongitude;
		$dX1 = cos( $dEclipticLongitude );
		$dRightAscension = atan2( $dY1,$dX1 );
		if( $dRightAscension < 0.0 ) $dRightAscension = $dRightAscension + $twopi;
		$dDeclination = asin( sin( $dEclipticObliquity )* $dSin_EclipticLongitude );

		// Calculate local coordinates ( azimuth and zenith angle ) in degrees
		$dGreenwichMeanSiderealTime = 6.6974243242 +    0.0657098283 * $dElapsedJulianDays + $dDecimalHours;
		$dLocalMeanSiderealTime = ($dGreenwichMeanSiderealTime*15 + $dLongitude)* $rad;
		$dHourAngle = $dLocalMeanSiderealTime - $dRightAscension;
		$dLatitudeInRadians = $dLatitude * $rad;
		$dCos_Latitude = cos( $dLatitudeInRadians );
		$dSin_Latitude = sin( $dLatitudeInRadians );
		$dCos_HourAngle= cos( $dHourAngle );
		$dZenithAngle = (acos( $dCos_Latitude * $dCos_HourAngle * cos($dDeclination) + sin( $dDeclination )* $dSin_Latitude));
		$dY = -sin( $dHourAngle );
		$dX = tan( $dDeclination )* $dCos_Latitude - $dSin_Latitude * $dCos_HourAngle;
		$dAzimuth = atan2( $dY, $dX );
		if ( $dAzimuth < 0.0 )
			$dAzimuth = $dAzimuth + $twopi;
		$dAzimuth = $dAzimuth / $rad;
		// Parallax Correction
		$dParallax = ($dEarthMeanRadius / $dAstronomicalUnit) * sin( $dZenithAngle);
		$dZenithAngle = ($dZenithAngle + $dParallax) / $rad;
		$dElevation = 90 - $dZenithAngle;
			
		$data=array();
		$data['Azimuth']   = $dAzimuth;
		$data['Elevation'] = $dElevation;
		return $data;
	}

	/** @}*/
?>

Sorry i see now the day is also not ok in the visu!!

What do i wrong?

Thanks, Ron

Hallo zusammen,

seit gestern fahren bei mir die Rollos weder abends herunter noch heute morgen rauf.
Ich habe auch den Fehler dafür gefunden, jedoch weiß ich nicht wie ich ihn beheben kann.

Was habe ich getan: da meine Rollos vollkommen wirr raus und runter sind, habe ich versucht durch einfügen eines neuen Profiles in „Profile“->„Sonnenstand“ Süden und Norden von einander zu trennen. Dem Profil „Süden“ hat sich also noch ein Profil „Norden“ hinzu gesellt. Das Profil Norden habe ich kurz danach wieder gelöscht.

Was ist der Fehler: der Fehler liegt im „IPSShadowing_ProgramTimer“. Er wirft einen Fehler.

Notice: Undefined offset: 56649 in C:\IP-Symcon\scripts\IPSLibrary\app\modules\IPSShadowing\IPSShadowing_ProfileManager.class.php on line 200

Fatal error: Call to a member function ActivationBySun() on a non-object in C:\IP-Symcon\scripts\IPSLibrary\app\modules\IPSShadowing\IPSShadowing_ProfileManager.class.php on line 201

198     public function CloseByTemp($profileIdSun, $profileIdTemp, $tempIndoorPath='') {
199                 $profileTemp = $this->profilesTemp[$profileIdTemp];
200                 $profileSun  = $this->profilesSun[$profileIdSun];
201                 return ($profileTemp->CloseByTemp($tempIndoorPath) and $profileSun->ActivationBySun());
202     }

Leider kann ich damit nicht viel anfangen. Ich finde den eigentlichen Fehler nicht und kann ihn nicht beheben.
Jemand eine Idee?

Ich habe keine Ahnung warum, aber es hat sich erledigt.
Ich habe nochmals ein Profil „Norden“ angelegt und es direkt wieder gelöscht. Timer nochmal von Hand ausgeführt und er ist ohne Fehler gestartet. Sehr komisch!!

Hi,

what is wrong? it was working and now it seems he don’t see the shutter component!

but the component is working.


Ron

Hi Ron,

i think, this is an configuration issue - please post your configuration

Hello i hope you mean this:

<?
	/*
	 * This file is part of the IPSLibrary.
	 *
	 * The IPSLibrary is free software: you can redistribute it and/or modify
	 * it under the terms of the GNU General Public License as published
	 * by the Free Software Foundation, either version 3 of the License, or
	 * (at your option) any later version.
	 *
	 * The IPSLibrary is distributed in the hope that it will be useful,
	 * but WITHOUT ANY WARRANTY; without even the implied warranty of
	 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	 * GNU General Public License for more details.
	 *
	 * You should have received a copy of the GNU General Public License
	 * along with the IPSLibrary. If not, see http://www.gnu.org/licenses/gpl.txt.
	 */    

	/**@defgroup ipsshadowing_configuration IPSShadowing Konfiguration
	 * @ingroup ipsshadowing
	 * @{
	 *
	 * @file          IPSShadowing_Configuration.inc.php
	 * @author        Andreas Brauneis
	 * @version
	 *  Version 2.50.1, 19.03.2012<br/>
	 *
	 * Konfigurations File für IPSShadowing
	 *
	 */

	IPSUtils_Include ("IPSShadowing_Constants.inc.php",      "IPSLibrary::app::modules::IPSShadowing");
	IPSUtils_Include ("IPSTwilight_Configuration.inc.php",   "IPSLibrary::config::modules::Weather::IPSTwilight");

	/** Temperatursensor Innen
	 *
	 * Definition des Innentemperatur Sensors, die Konstante muß auf eine Variable verweisen, die die aktuelle Innentemperatur
	 * als Float Value enthält.
	 * Die Verlinkung der Variable erfolgt entweder direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_TEMPSENSORINDOOR",		"12586");

	/** Temperatursensor Aussen
	 *
	 * Definition des Aussentemperatur Sensors, die Konstante muß auf eine Variable verweisen, die die aktuelle Aussentemperatur
	 * als Float Value enthält.
	 * Die Verlinkung der Variable erfolgt entweder direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_TEMPSENSOROUTDOOR",	"45151");

	/** Helligkeitssensor
	 *
	 * Definition des Helligkeits Sensors, die Konstante muß auf eine Variable verweisen, die die aktuelle Helligkeit
	 * als Integer oder Float Value enthält.
	 * Die Verlinkung der Variable erfolgt entweder direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_BRIGHTNESSSENSOR",	'52718');

	/** Regensensor
	 *
	 * Definition des Regen Sensors, die Konstante muß auf eine Variable verweisen, die den Wert des Sensors als 
	 * boolschen Wert enthält.
	 * Die Verlinkung der Variable erfolgt entweder direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_RAINSENSOR",		"45257");

	/** Windsensor
	 *
	 * Definition des Wind Sensors, die Konstante muß auf eine Variable verweisen, die den Wert des Sensors als 
	 * Float Wert mit Angabe in "kmh" enthält, 
	 * Die Verlinkung der Variable erfolgt entweder direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_WINDSENSOR",		"11210");

	/** Anwesenheits Flag
	 *
	 * Definition des Anwesenheits Flags, die Konstante muß auf eine Variable verweisen, die den aktuellen Anwesenheits Status als
	 * boolean Wert enthält (true bedeutet Anwesend).
	 * Die Verlinkung der Variable erfolgt entweder direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_PRESENT",			'');

	/** Abwesenheits Flag
	 *
	 * Definition des Abwesenheits Flags, die Konstante muß auf eine Variable verweisen, die den aktuellen Abwesenheits Status als
	 * boolean Wert enthält (true bedeutet Abwesend).
	 * Diese Variable kann alternativ zu dem Anwesenheits Flag gesetzt werden.
	 * Die Verlinkung der Variable erfolgt entweder direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_ABSENCE",			"");

	/** Zeitpunkt Sonnenaufgang
	 *
	 * Definition des Tagesbeginn Zeitpunktes, die Konstante muß auf eine Variable verweisen, die die Zeit in der Form
	 * hh:mm enthält.
	 * Verlinkung erfolgt direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_TWILIGHTSUNRISE",			"Program.IPSLibrary.data.modules.Weather.IPSTwilight.Values.SunriseBegin");

	/** Zeitpunkt Sonnenuntergang
	 *
	 * Definition des Tagesend Zeitpunktes, die Konstante muß auf eine Variable verweisen, die die Zeit in der Form
	 * hh:mm enthält.
	 * Verlinkung erfolgt direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_TWILIGHTSUNSET",			"Program.IPSLibrary.data.modules.Weather.IPSTwilight.Values.SunriseEnd");
	
	/** Zeitpunkt limited Sonnenaufgang
	 * 
	 * Definition des "limited" Tagesbeginn Zeitpunktes, die Konstante muß auf eine Variable verweisen, die die Zeit in der Form
	 * hh:mm enthält. Durch diese Variable ist es möglich, dass der Tagesbeginn in bestimmten Grenzen liegen muß.
	 * Verlinkung erfolgt direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_TWILIGHTSUNRISELIMITED",	"Program.IPSLibrary.data.modules.Weather.IPSTwilight.Values.SunriseBeginLimited");

	/** Zeitpunkt limited Sonnenuntergang
	 *
	 * Definition des "limited" Tagesend Zeitpunktes, die Konstante muß auf eine Variable verweisen, die die Zeit in der Form
	 * hh:mm enthält. Durch diese Variable ist es möglich, dass der Tagesbeginn in bestimmten Grenzen liegen muß.
	 * Verlinkung erfolgt direkt durch Angabe der ID oder durch Angabe des Pfades.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_TWILIGHTSUNSETLIMITED",	"Program.IPSLibrary.data.modules.Weather.IPSTwilight.Values.SunriseEndLimited");

	/**
	 * Angabe des Breitengrades zur Berechnung des Sonnenstandes
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ('IPSSHADOWING_LATITUDE', IPSTWILIGHT_LATITUDE);

	/**
	* Angabe des Längengrades zur Berechnung des Sonnenstandes
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	*/
	define ('IPSSHADOWING_LONGITUDE', IPSTWILIGHT_LONGITUDE);

	/**
	 * Ausrichtung des Gebäudes
	 * 
	 * Dieser Wert spezifiziert die Abweichung von der Ausrichtung des Gebäudes Richtung Süden in Grad.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ('IPSSHADOWING_BUILDINGORIENTATION',   0);
	
	/**
	 * Verhältnis der Gebäudewände
	 *
	 * Mit diesem Parameter kann das Verhältnis der Länge der Gebäudewände in der Grafik verändert werden. 
	 *
	 * 0 bedeutet dass alle Gebäudewände gleich lang sind, bei positiven Werten wird die südliche Seite des Gebäudes
	 * breiter und umgekehrt.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ('IPSSHADOWING_BUILDINGRELATION',      0);
	

	/**
	 * Definiert die Anzahl der Meldungen, die im Applikation Logging Window angezeigt werden.
	 *
	 * Dieser Parameter kann jederzeit geändert werden, keine Installation erforderlich.
	 */
	define ("IPSSHADOWING_LOGMESSAGECOUNT",				30);

	/**
	 *
	 * Definition der Beschattungs Elemente
	 * Die Konfiguration erfolgt in Form eines Arrays, für jedes Beschattungs Device wird ein Eintrag im Array erzeugt.
	 * 
	 * Die Eigenschaft c_Property_ShadowingType spezifiziert den Type der Beschattung, folgende Typen stehen zur Auswahl:
	 * - c_ShadowingType_Jalousie, Ansteuerung einer Jalousie, es werden noch zusätzliche Properties ausgewertet, um die Lamellen in eine bestimmte Position zu bringen
	 * - c_ShadowingType_Shutter, Ansteuerung eines normalen Rollos
	 * - c_ShadowingType_Marquees, Ansteuerung einer Markise
	 *
	 * Der Eintrag "c_Property_Name" spezifiziert den Namen des Beschattungs Elements, der im WebFront und in den Log's angezeigt
	 * wird.
	 *
	 * Der Eintrag "c_Property_Component" spezifiziert die Hardware, es kann jeder "Shutter" Component String Konstruktor
	 * angegeben werden. Detailiertere Informationen kann man auch im core Modul IPSComponent finden.
	 *
	 * Mit den Properties c_Property_TimeOpening,  c_Property_TimeClosing, c_Property_TimeDimoutUp, c_Property_TimeDimoutDown, c_Property_TimePause 
	 * werden die Fahrzeiten spezifiziert. c_Property_TimeDimoutUp und c_Property_TimeDimoutDown werden nur bei Jalousien ausgewertet, um die Lamellen 
	 * in die Verdunkelungs- bzw. Beschatttungsposition zu bringen.
	 *
	 * Mit c_Property_TempSensorIndoor ist die Einbindung eines Innentemperatursensors für das Beschattungselement möglich. Verlinkung erfolgt durch 
	 * Angabe des Pfades oder direkt durch die ID der Temperatur Variable.
	 *
	 * Beispiel:
	 * @code
        function get_ShadowingConfiguration() {
          return array(
            c_ShadowingDevice_1  =>  array(
               c_Property_ShadowingType     => c_ShadowingType_Jalousie,
               c_Property_Name              => 'Küche',
               c_Property_Component         => 'IPSComponentShutter_Dummy,12345',
               c_Property_TimeOpening       => 35,
               c_Property_TimeClosing       => 35,
               c_Property_TimeDimoutUp      => 2,
               c_Property_TimeDimoutDown    => 3,
               c_Property_TimePause         => 1,
               c_Property_TempSensorIndoor  => '',
             ));
        }
	 * @endcocde
	 *
	 * @return string Liefert Array mit Beschattungs Elementen
	 */
	function get_ShadowingConfiguration() {
		return array(
			c_ShadowingDevice_1 =>	array(
				c_Property_ShadowingType	=> c_ShadowingType_Marquees,
				c_Property_Name				=> 'Markies',
				c_Property_Component		   => '13166',
				c_Property_TimeOpening		=> 32,
				c_Property_TimeClosing		=> 32,
				c_Property_TimeDimoutUp		=> 2,
				c_Property_TimeDimoutDown	=> 3,
				c_Property_TimePause		=> 1,
				c_Property_TempSensorIndoor	=> '12586',
				),
	   );
	}
	/** @}*/
?>