Projet RGB Aktor Sonnenaufgang

Guten Morgen!

Gibt es eigentlich schon eine Sonnenauf bzw. Untergangs Simulation für den RGB Aktor?

Viele Grüße
Marcus

Hi Marcus!

Meinst du sowas hier? >> LED Aquariumbeleuchtung IPS-RGBW-868 RGB oder Homematic - Seite 2

Wenn nicht, dann wären ein wenig mehr Infos zu deiner verwendeten Hardware und wie du was verbaut hast, sehr praktisch :slight_smile:

Grüße,
Chris

Hm, ich denke mal ich meine etwas anderes… :slight_smile:

Das Projet Gateway und RGB Aktor sind in IP-Symcon eingebunden und lassen sich auch ansteuern

Ich möchte den Projet RGB Aktor mit IP Symcon wie folgt ansteuern:

Ich möchte zu einer bestimmten, einstellbaren Startzeit einen Sonnenaufgang in meinem Schlafzimmer simulieren. D.h. über einen Zeitraum von ca. 30 Minuten sollte ein weicher Farbverlauf von „dunkel“ über blau, violett bis Gelbrot entstehen…

Es müssten also ca alle 1 Minute die Sollwerte der RGB Einstellungen automatisch verändert werden um die gewünschten Farben zu erhalten.

Das hört sich interessant an.

Könnte es mir so vorstellen.
Ein Array in dem 30 Zeilen (pro Minute einen) mit den jeweiligen RGB und Helligkeitswerten gespeichert sind.

Eine Variable Zähler.

Ein Script das jede Minute gestartet wird.

Dann der Ablauf folgendermaßen

Array ( 1. 0,255,0,2
2. 10,255,0,5)… Usw.

Read Zähler
$r = (Array [zähler])
$g = (Array [zähler])
$b = (Array [zähler])
$helligkeit = (Array [zähler])

Set RGB ($r, $g, $b, $helligkeit)
Set variable Zähler = Zähler +1

If Zähler =30 scripttimer Off

Das kann man wirklich ziemlich einfach umsetzen. Eine fertige Lösung ist mir nicht bekannt.

Theoretisch braucht man nur diesen Befehl „PJ_DimRGBW (12345,$rot,0,$gruen,0,$blau,0,weiss$,0)“ und ein wenig drum herum… Man kann sich sogar einfach die Farben im WebFront auswählen lassen, welche „durchlaufen“ werden sollen.

Oooooder man passt sich dieses Skript ein wenig an und lässt, statt random-Werten, eigene Farben/Werte „ablaufen“.
>> Simples Random-Farb-Script für den RGBW-868 Stripe

Oooooder wenn du es doch selbst programmieren willst, dann hätte ich hier 2 praktische Funktionen für dich. Damit hatte ich das Dimmen meiner RGBW-Streifen im Wohnzimmer umgesetzt :slight_smile:

function colorLuminance($hex, $lum = 0)
{
	$hex = preg_replace('/[^0-9a-f]/', '', $hex);
	if (strlen($hex) == 3) {
		$hex = $hex[0] . $hex[0] . $hex[1] . $hex[1] . $hex[2] . $hex[2];
	}
	$rgb = "#";
	for ($i = 0; $i < 3; $i++) {
		$c = hexdec(substr($hex, $i * 2, 2));
		$c = dechex(min(255, max(0, round($c + $c * $lum, 0))));
		$rgb .= substr("00" . $c, -2, 2);
	}
	return $rgb;
}


function hex2rgb($hex) {
   $hex = str_replace("#", "", $hex);

   if(strlen($hex) == 3) {
      $r = hexdec(substr($hex,0,1).substr($hex,0,1));
      $g = hexdec(substr($hex,1,1).substr($hex,1,1));
      $b = hexdec(substr($hex,2,1).substr($hex,2,1));
   } else {
      $r = hexdec(substr($hex,0,2));
      $g = hexdec(substr($hex,2,2));
      $b = hexdec(substr($hex,4,2));
   }
   $rgb = array($r, $g, $b);
   //return implode(",", $rgb); // Komma separiert
   return $rgb; // Array
}

Grüße,
Chris

Vielen Dank für die Tipp’s.
Ich werde mich dann mal ran setzen und versuchen eure Vorschläge um zu setzen.

Viele Grüße
Marcus

Wenn du eine Lösung hast, dann bitte hier posten :slight_smile:

Grüße,
Chris

Gibt’s schon Neuigkeiten?
Denke das größte Problem wird sein in welcher Richtung man die Farbverläufe machen will.

Blau zu lila dann zu rot zu Orange dann gelb?

Ich hab mich heut mal ein Script geschrieben, das den Sonnenaufgang simuliert.

<?
$IDIPSLightRGB    = 30201 /*[Program\IPSLibrary\data\modules\IPSLight\Switches\RGB Test 1#Color]*/;
$IDZahler         = 38216 /*[ZZ_Sonstiges\RGB Sonnenaufgang\aktueller Stand]*/;



// ######################################################################################################
// Hier nichts mehr ändern

IPSUtils_Include ('IPSLight.inc.php', 'IPSLibrary::app::modules::IPSLight');
$lightManager = new IPSLight_Manager();

	$Schrittweite     = 16;
	$ZahlerErzeugt 	= 0;
	$R = 0;
	$G = 0;
	$B = 0;


$ZahlerAktuell  	= getvalue ($IDZahler);

// Phase läuft 4 mal durch
// 1. Phase = Rot 0                   Grün 0                          Blau steigt an
// 2. Phase = Rot steigt an   	     Grün 0                          Blau 255
// 3. Phase = Rot 255            	  Grün 0                          Blau sinkt ab
// 4. Phase = Rot 255                 Grün steigt an    		          Blau 0

for ($Phase = 1; $Phase  <= 4; $Phase++) {

switch ($Phase) {
    case 1:
            // Dimmt Blau langsam hoch
            while($B <= 200)
                        {
                        $R = 0;
                        $G = 0;
                        $B = $B + $Schrittweite;

								$array[] = array(	'Zahl' 	=> $ZahlerErzeugt,
								                  'R'   	=> $R,
								                  'G' 		=> $G,
								                  'B'      => $B);
								$ZahlerErzeugt  = $ZahlerErzeugt  + 1;
								}
                        break;

    case 2:
            // Dimmt Rot langsam hoch
            while($R <= 200)
                        {
                        $R = $R + $Schrittweite;
                        $G = 0;
                        $B = 255;

								$array[] = array(	'Zahl' 	=> $ZahlerErzeugt,
								                  'R'   	=> $R,
								                  'G' 		=> $G,
								                  'B'      => $B);
                        $ZahlerErzeugt  = $ZahlerErzeugt  + 1;
                        }
        break;

    case 3:
            // Dimmt Blau langsam runter
            while($B > $Schrittweite)
                        {
                        $R = 255;
                        $G = 0;
                        $B = $B - $Schrittweite;

								$array[] = array(	'Zahl' 	=> $ZahlerErzeugt,
								                  'R'   	=> $R,
								                  'G' 		=> $G,
								                  'B'      => $B);
                        $ZahlerErzeugt  = $ZahlerErzeugt  + 1;
                        }
        break;

    case 4:
            // Dimmt Grün langsam hoch
            while($G <= 100)
                        {
                        $R = 255;
                        $G = $G + $Schrittweite;
                        $B = 0;

								$array[] = array(	'Zahl' 	=> $ZahlerErzeugt,
								                  'R'   	=> $R,
								                  'G' 		=> $G,
								                  'B'      => $B);
                        $ZahlerErzeugt  = $ZahlerErzeugt  + 1;
                        }
        break;

}
}



if ($ZahlerAktuell  >= count($array)){
	// Ende erreicht
	$ZahlerAktuell = 0;

	}else{

	// Weiter machen
	$FarbeRot    = $array[$ZahlerAktuell]['R'];
	$FarbeGruen  = $array[$ZahlerAktuell]['G'];
	$FarbeBlau   = $array[$ZahlerAktuell]['B'];
	// Umrechnen von Hex auf Dezimal
	$FarbeRDez   = $FarbeRot * 256 * 256;
	$FarbeGDez   = $FarbeGruen *  256;
	$FarbeBDez   = $FarbeBlau ;
	
	$FarbeDezimal = $FarbeRDez + $FarbeGDez + $FarbeBDez;

	$lightManager->SetRGB($IDIPSLightRGB, $FarbeDezimal);

	
	$ZahlerAktuell  = $ZahlerAktuell  + 1;
	}

// Erhöht den Zahler um 1 und schreibt ihn in die Variable
setvalue ($IDZahler, $ZahlerAktuell);
?>

Man muss nur eine Integer Variable anlegen, dort wird der aktuelle Stand gespeichert.
Allerdings funktioinert das mit Mi Light nicht wirklich. Wahrschienlch weil es nicht so schnell umschalen kann.
Mit den RGB 868 funktioniert es bestens.

Der Ablauf ist von Blau - Lila - Rot - Orange

Bei jedem Ausführen des Skripts geht es einen Schritt weiter.
Im Finale soll es dann automatisch per Timer laufen.