[WireGate-Plugin] Neues Plugin: Universeller Szenencontroller

[Fry]

Hallo zusammen,
gerade habe ich einen neuen, universellen Szenencontroller ins Wiregate-Plugin-SVN eingecheckt.

Das neue Plugin legt die Szenendaten wahlweise im plugin_info oder in seinem eigenen Konfigurationsfile ab (wird einfach angehängt) und funktioniert nach folgendem einfachen Schema: Für jeden Szenentyp (Raum, Taster, etc., z.B. "Wohnzimmer") wird spezifiziert, welche GA die Szene speichert und welche sie aufruft - das darf beim ETS-Typ "Szene" auch die gleiche GA sein. Dann wird noch aufgezählt, welche GAs beim Speichern der Szene ausgelesen werden sollen und welche beim Aufrufen mit den gespeicherten Werten beschrieben - fertig.

Der ab sofort im SVN verfügbare Szenencontroller ist im Detail am besten durch seine Konfigurationsdatei vorgestellt:

Das folgende Beispiel konfiguriert Szenen fuer ein Zimmer (Schlafzimmer).

%scene=( 
Schlafzimmer => {store=>'0/1/2', recall=>'0/1/3', gas=>{'1/2/3'=>'1/2/3', '1/2/4'=>'1/2/5'}},
);

Die GA zum Aufrufen "Recall" einer Szene (zB kurzer Tastendruck am Taster) ist 0/1/3, die GA zum Speichern "Store" einer Szene (langer Druck) ist 0/1/2. Beim Speichern werden die Werte aus 1/2/3 und 1/2/4 ausgelesen und in die entsprechende Szenennummer abgelegt, beim Abrufen dieser Szenennummer werden genau diese Werte wieder in 1/2/3 und 1/2/5 zurueckgeschrieben.

(Die Zuordnungen unter gas enthalten immer ein Paar: die erste GA wird beim Speichern (Store) der Szene ausgelesen und ihr Wert gespeichert, die zweite GA wird beim Aufrufen (Recall) mit dem gespeicherten Wert beschrieben.)

So weit, so einfach.

Noch einige Details, die vor allem aus der Komplexität der ETS mit seinen vielen Datentypen und der "strengen Typisierung" resultieren:

1. Szenennummer bei "Wert uebermitteln"-Taster (DPTSubId 5.010, in ETS als "Wert" konfiguriert):
Sowohl bei Store als auch bei Recall wird der Inhalt des Bustelegramms als Index der Szene verwendet.
Geschickterweise konfiguriert man das so, dass jeder Taster einen eindeutigen, festen Wert uebermittelt.
So kann jede Taste im Raum jeweils eine Szene speichern und wieder aufrufen, sie muss dafuer einfach eine
Zahl (sinnvollerweise einen 8bit-Wert, DPTSubId 5.010), uebermitteln.

2. Szene abrufen/speichern bei "Szenen"-Tastern (in ETS als "Szene" konfiguriert):
Hier wird die Szenennummer wie oben im Taster konfiguriert, dieselbe (!) GA fuer store und recall
gesetzt und wieder die DPTSubId 5.010 in /etc/wiregate/eibga.conf konfiguriert.
In diesem Fall wird die Unterscheidung zwischen Store und Recall durch das 7. Bit des Wertes getroffen,
was kompatibel mit "Szenen"-Tastern ist (zumindest klappt es mit meinen MDTs).

3. Szenennummer bei "Schalten"-Taster (DPTSubId 1.017, in ETS als einfaches "Schalten" ohne Wert konfiguriert):
Falls die DPTSubId 1.017 ist (Trigger) - typisch fuer "Schalten"-Taster, kann der Inhalt des Telegramms
keine Szenennummer uebermitteln. Dann wird als Szenennummer einfach die physikalische Adresse des Tasters
genommen. So koennen auch Taster, die ueber eine lang-kurz-Schaltung verfuegen aber keine Werte senden,
jeweils eine eigene Szene ablegen.

Have fun, Fry

Hier die komplette Konfigurationsdatei als Beispiel:

#!/usr/bin/perl
#
# Konfiguration Szenencontroller ######################################
#

%scene=(

    # Storage auf 'configfile' setzen, wenn die Szenen hier im Konfigfile gespeichert werden sollen. 
    # Sie ueberleben in diesem Fall sogar das Loeschen des plugin_info und gelten somit als "fest verdrahtet".
    # Ansonsten 'plugin_info' setzen, dann werden die Szenen im %plugin_info gespeichert.
    # 'configfile' hat allerdings noch die Vorteile, dass die Werte hier editierbar werden und dass plugin_info
    # nicht so "zugemuellt" wird.
    storage=>'configfile', # 'plugin_info' oder 'configfile'

    # Das folgende Beispiel konfiguriert Szenen fuer ein Zimmer (Schlafzimmer). 
    #
    Schlafzimmer => {store=>'0/1/2', recall=>'0/1/3', gas=>{'1/2/3'=>'1/2/3', '1/2/4'=>'1/2/5'}},
    #
    # Die GA zum Aufrufen "Recall" einer Szene (zB kurzer Tastendruck am Taster) ist 0/1/3, 
    # die GA zum Speichern "Store" einer Szene (langer Druck) ist 0/1/2.
    # Beim Speichern werden die Werte aus 1/2/3 und 1/2/4 ausgelesen und in die entsprechende Szenennummer 
    # abgelegt, beim Abrufen dieser Szenennummer werden genau diese Werte wieder in 1/2/3 und 1/2/5 zurueck-
    # geschrieben.
    #
    # (Die Zuordnungen unter gas enthalten immer ein Paar: die erste GA wird beim Speichern (Store) der Szene 
    # ausgelesen und ihr Wert gespeichert, die zweite GA wird beim Aufrufen (Recall) mit dem gespeicherten Wert
    # beschrieben.)
    # 
    # Noch einige Details:
    #
    # 1. Szenennummer bei "Wert uebermitteln"-Taster (DPTSubId 5.010, in ETS als "Wert" konfiguriert):
    # Sowohl bei Store als auch bei Recall wird der Inhalt des Bustelegramms als Index der Szene verwendet. 
    # Geschickterweise konfiguriert man das so, dass jeder Taster einen eindeutigen, festen Wert uebermittelt.
    # So kann jede Taste im Raum jeweils eine Szene speichern und wieder aufrufen, sie muss dafuer einfach eine
    # Zahl (sinnvollerweise einen 8bit-Wert, DPTSubId 5.010), uebermitteln.
    #
    # 2. Szene abrufen/speichern bei "Szenen"-Tastern (in ETS als "Szene" konfiguriert):
    # Hier wird die Szenennummer wie oben im Taster konfiguriert, dieselbe (!) GA fuer store und recall 
    # gesetzt und wieder die DPTSubId 5.010 in /etc/wiregate/eibga.conf konfiguriert. 
    # In diesem Fall wird die Unterscheidung zwischen Store und Recall durch das 7. Bit des Wertes getroffen,
    # was kompatibel mit "Szenen"-Tastern ist (zumindest klappt es mit meinen MDTs).
    #
    # 3. Szenennummer bei "Schalten"-Taster (DPTSubId 1.017, in ETS als einfaches "Schalten" ohne Wert konfiguriert):
    # Falls die DPTSubId 1.017 ist (Trigger) - typisch fuer "Schalten"-Taster, kann der Inhalt des Telegramms 
    # keine Szenennummer uebermitteln. Dann wird als Szenennummer einfach die physikalische Adresse des Tasters
    # genommen. So koennen auch Taster, die ueber eine lang-kurz-Schaltung verfuegen aber keine Werte senden,
    # jeweils eine eigene Szene ablegen.
    #
    # 4. Schlussendlich wieder mal Werbung fuer die GA-Kurznamen. Setzt man im Skript Translator.pl $use_short_names=1
    # und verwendet GA-Namen mit eindeutigem Kuerzel (=erstes Wort des Namens), so funktioniert auch das folgende:
    Schlafzimmer2 => {store=>'ZS_SZ', recall=>'ZA_SZ', gas=>{'LI_SZ'=>'LI_SZ', 'JX_SZ'=>'JW_SZ', 'JQ_SZ'=>'JP_SZ'}},
    # ist doch leserlicher, oder? SZ=Schlafzimmer, ZA=Szene abrufen, ZS=Szene speichern, LI=Licht, 
    # JX=Jalousiewinkel abfragen, JW=Jalousiewinkel einstellen, JQ=Jalousieposition abfragen, JP=Jalousie positionieren

    );

[Fry]

Hier der komplette Code des Plugins. Der Code ist rudimentär getestet, gerne höre ich von euch, ob er auch für euch funktioniert...

VG, Fry

####################
# Szenencontroller #
####################
# Wiregate-Plugin
# (c) 2012 Fry under the GNU Public License

# $plugin_info{$plugname.'_cycle'}=0; return "deaktiviert";

my $use_short_names=0; # 1 fuer GA-Kuerzel (erstes Wort des GA-Namens), 0 fuer die "nackte" Gruppenadresse

# eibgaconf fixen falls nicht komplett indiziert
if($use_short_names && !exists $eibgaconf{ZV_Uhrzeit})
{
    for my $ga (grep /^[0-9\/]+$/, keys %eibgaconf)
    {
        $eibgaconf{$ga}{ga}=$ga;
        my $name=$eibgaconf{$ga}{name};
        next unless defined $name;
        $eibgaconf{$name}=$eibgaconf{$ga};

        next unless $name=~/^\s*(\S+)/;
        my $short=$1;
        $short='ZV_'.$1 if $eibgaconf{$ga}{name}=~/^Zeitversand.*(Uhrzeit|Datum)/;

        $eibgaconf{$ga}{short}=$short;
        $eibgaconf{$short}=$eibgaconf{$ga};
    }
}

# Aufrufgrund ermitteln
my $event=undef;
if (!$plugin_initflag) 
{ $event='restart'; } # Restart des daemons / Reboot
#elsif ((stat('/etc/wiregate/plugin/generic/' . $plugname))[9] > time()-2) 
# ab PL30:
elsif ($plugin_info{$plugname.'_lastsaved'} > $plugin_info{$plugname.'_last'})
{ $event='modified'; } # Plugin modifiziert
elsif (%msg) { $event='bus'; } # Bustraffic
#elsif ($fh) { $event='socket'; } # Netzwerktraffic
else { $event='cycle'; } # Zyklus

# Konfigurationsfile einlesen
my $conf=$plugname; $conf=~s/\.pl$/.conf/;
$conf="/etc/wiregate/plugin/generic/conf.d/$conf";
my %scene=();
my $err=read_from_config();
return "config err" if $err;

# Dynamisch definierte Szenen aus plugin_info einlesen
recall_from_plugin_info();

if($event=~/restart|modified/)
{
    # Cleanup aller Szenenvariablen in %plugin_info 
    for my $k (grep /^$plugname\_/, keys %plugin_info)
    {
        delete $plugin_info{$k};
    }

    # Alle Szenen-GAs abonnieren
    my $count=0;
    my $scene_lookup='';

    for my $room (keys %scene)
    {
        next if $room eq 'storage';

        my $store=$scene{$room}{store};
        my $recall=$scene{$room}{recall};

        $store=$scene{$room}{store}=$eibgaconf{$store}{ga} if $store!~/^[0-9\/]+$/ && defined $eibgaconf{$store};
        $recall=$scene{$room}{recall}=$eibgaconf{$recall}{ga} if $recall!~/^[0-9\/]+$/ && defined $eibgaconf{$recall};
        
        next unless defined $store && defined $recall;

        $scene_lookup.="St($store)=>'$room', Rc($recall)=>'$room', ";
        
        $plugin_subscribe{$store}{$plugname}=1;
        $plugin_subscribe{$recall}{$plugname}=1;

        $count++;
    }

    $plugin_info{$plugname.'__SceneLookup'}=$scene_lookup;
    $plugin_info{$plugname.'_cycle'}=0; 
   
    return $count." initialisiert";
}

if($event=~/bus/)
{
    # nur auf Write-Telegramme reagieren
    return if $msg{apci} ne 'A_GroupValue_Write'; 

    # Aufruf durch GA
    my $ga=$msg{dst};
    my $n=int($msg{value}); # die Szenennummer 

    # die betreffende Szene finden
    unless($plugin_info{$plugname.'__SceneLookup'}=~/(St|Rc)\($ga\)=>\'(.+?)\',/)
    {
        delete $plugin_subscribe{$ga}{$plugname}; # unbekannte GA
        return;
    }

    my $cmd=$1; chop $cmd;
    my $room=$2;

    if($eibgaconf{$ga}{DPTSubId} eq '1.017')
    {
        # Szenennummer aus physikalischer Adresse ableiten falls DPTSubId==1.017
        return unless $msg{src}=~/[0-9]+\.[0-9]+\.([0-9]+)/;
        $n=$1;
    }
    elsif($scene{$room}{store} eq $scene{$room}{recall})
    {
        # Speichern oder Abrufen? Falls beides die gleiche GA, aus 7. Bit der Szenennummer ableiten
        $cmd = ($n & 0x80)?'S':'R';
        $n = ($n & 0x7f)+1; 
    }
    else # Aufruf mit Wert = Szenennummer
    {
        $n = 128 if $n>128; # begrenzen auf max. 128
    }

    # Szenencode
    my $z="$room\__$n";

    # Debugging
#    plugin_log($plugname, "Szene $z ".($cmd eq 'S'?'speichern':'abrufen'));

    if($cmd eq 'S') # Szene speichern
    {
        delete $scene{$z};

        for my $ga (keys %{$scene{$room}{gas}})
        {
            my $wga=$scene{$room}{gas}{$ga}; # auf diese GA muss spaeter geschrieben werden
            $wga=$eibgaconf{$wga}{short} if $wga=~/^[0-9\/]+$/ && $use_short_names && defined $eibgaconf{$wga}{short};    
            $ga=$eibgaconf{$ga}{ga} if $ga!~/^[0-9\/]+$/ && defined $eibgaconf{$ga};    
            $scene{$z}{$wga}=knx_read($ga,300);
            delete $scene{$z}{$wga} unless defined $scene{$z}{$wga};
        }

        if($scene{storage} eq 'configfile')
        {
            store_to_config($z);
        }
        else
        {
            store_to_plugin_info($z);
        }
    }
    else # Szene abrufen
    {
        for my $v (keys %{$scene{$z}})
        {
            my $ga=$v;
            $ga=$eibgaconf{$ga}{ga} if $ga!~/^[0-9\/]+$/ && defined $eibgaconf{$ga};
            knx_write($ga,$scene{$z}{$v});
        }
    }    
}

return;

########## Datenpersistenz - Speichern und Einlesen ###############

sub read_from_config
{
    open CONFIG, "<$conf" || return "no config found";
    my @lines = <CONFIG>;
    close CONFIG;
    eval("@lines");
    return "config error" if $@;
}

sub store_to_config
{
    my $z=shift; # die Szenenbezeichnung 

    open CONFIG, ">>$conf";
    print CONFIG "\$scene{$z}={";
    for my $v (sort keys %{$scene{$z}})
    {
        print CONFIG sprintf "'$v'=>%.2f, ", $scene{$z}{$v};
    }
    print CONFIG "};\n";
    close CONFIG;
}

# alternativ: speichern ins globale Hash plugin_info

sub store_to_plugin_info
{
    my $z=shift; # die Szenenbezeichnung   

    # Alle Laufzeitvariablen im Hash %{$dyn} 
    # in das (flache) Hash plugin_info schreiben
    for my $k (grep /^$plugname\__$z/, keys %plugin_info)
    {
        delete $plugin_info{$k};
    }
    
    for my $v (keys %{$scene{$z}})
    {
        $plugin_info{$plugname.'__'.$z.'__'.$v}=$scene{$z}{$v};
    }
}

sub recall_from_plugin_info
{
    for my $k (grep /^$plugname\__/, keys %plugin_info)
    {
        next unless($k=~/^$plugname\__([A-Z0-9 ]+__[0-9]+)__(.*)$/i);
        my ($z,$v)=($1,$2); 
        $scene{$z}{$v}=$plugin_info{$k};
    }
}

[DasVantom]

Hallo zusammen, Hi Fry.

Da ich eleganter weise überlesen habe, dass das DALI-Gateway nur 16 Szene kann, würde ich gerne dieses Plugin verwenden.

Leider bin ich für die Konfiguration zu beschränkt und würde Hilfe benötigen.

Ich würde gerne mit Szenen arbeiten (wie Du 8-Bit).
Als Beispiel:

Szene1: 1
Szene2: 12
Szene3: 55

GA_Szenen: 8/2/16

In deiner Erklärung steht, Store und Recall die selbe GA. DPT in die eibga.conf eintragen. Verstehe ich sogar noch.

Aber was muss ich jetzt in die Konfigurationsdatei schreiben um die Szenen (8-Bit Werte) auf der GA_Szenen unterscheiden zu können. Wie wertet man Szene1:1, Szene2:12, Stene3:55 aus.

Ohne jetzt zu denken oder Ahnung zu haben, müsste doch irgendwie sowas sein.

Code:
%scene=(
Szene1 => {scene => '1', store=>'8/2/16', recall=>'8/2/16', gas=>{'1/2/3'=>'1/3/3', '1/2/4'=>'1/3/4'}},

Szene2 => {scene => '12', store=>'8/2/16', recall=>'8/2/16', gas=>{'1/2/5'=>'1/3/5', '1/2/6'=>'1/3/6'}},

Szene3 => {scene => '55', store=>'8/2/16', recall=>'8/2/16', gas=>{'1/2/7'=>'1/3/7', '1/2/8'=>'1/3/8'}},
);


Evt. funktioniert es auch komplett anders aber das ist mir leider nicht ersichtlich.

Danke für die Hilfe, falls man versteht was ich meine.


Gruß
Flo

[henfri]

Nicht schlecht!
Ich habe zwar (noch?) keine Verwendung, aber ein DANKE für deinen Einsatz möchte ich trotzdem los werden!

Gruß,
Hendrik

[Fry]

Hi Flo,
bitte lies dir nochmal durch, was ich oben geschrieben habe. Hier noch ein paar Hinweise zum Verständnis:

1. Szenen sind Einstellungen, die man speichern und wieder aufrufen kann, so wie man im Radio Sender speichert. Bspw. bietet sich an: langer Tastendruck fürs Speichern, kurzer fürs Abrufen. Die GAs, mit denen das Speichern/Aufrufen ausgelöst werden soll, sind in der Konfi unter store und recall angegeben.

2. Je nachdem, welche Art Taster oder anderes Gerät du dafür verwendest, ist die Konfi anzupassen, siehe meine Erläuterungen oben. Die SzenenNUMMER (entspricht dem "Speicherplatz" einer Szene) wird dabei vom Gerät geliefert. Nimmst du bspw. einen Taster mit Szenenfunktion, so trägst du die Szenennummer in der ETS-Konfiguration des Tasters ein.

3. Zu einer Szene gehört eine Liste von GAs (zB Dimmwerte, Jalousienpositionen), deren Werte beim Speichern (Store) ausgelesen werden und beim Aufrufen (Recall) wieder geschrieben werden. Ohne diese funktioniert gar nichts.

Viel Erfolg!
Fry

[Fry]

Zitat von henfri Nicht schlecht! Ich habe zwar (noch?) keine Verwendung, aber ein DANKE für deinen Einsatz möchte ich trotzdem los werden! Gruß, Hendrik

Gerne Hendrik!

leider steht mein WG jetzt auf der Baustelle, damit fehlt mir die Testplattform, und außerdem habe ich Ärger mit der hiesigen Dachmafia...

mit anderen Worten, erwartet in nächster Zeit erstmal wenig von mir...

Fry

[DasVantom]

Hallo,

so, jetzt habe auch ich es. Mir war das "so weit" bekannt, was ich jedoch jetzt erst bemerkt habe, das nach dem speichern einer Szene, eine weitere Zeile in der Config-Datei erscheint.

z.B.
$scene{'Kueche_Herd#5'}={'2/3/10'=>100.00, '2/3/8'=>100.00, };

Somit hier die Szene gespeichert wird (Wert hinter der #). Mir war nicht klar, woher er die Zuordnung der entsprechenden Szene und deren Werte weiß. Mit der oben genanten Zeile ist mir jetzt aber alles klar.

Freue mich jetzt auf die Verwendung.

Danke für die Mühen und Erstellung des Plugins.

Gruß
Flo

[Fry]

Gerne!
Fry

[nEiMi]

Heute wollte ich in die Cometvisu meine erste Szene integrieren und dazu den Szenencontroller hier nutzen um alle Szenen zentral in einer Datei verwalten zu können... aber irgendwie bring ich das mal wieder nicht auf die Reihe...

Hier meine Szenencontroller.conf

%scene=(
    debug=>1,
    Wohnen => {store=>'9/6/61', recall=>'9/5/61', gas=>{'1/3/64'=>'1/3/64'}},
    );

in der CometVisu rufe ich dann die entsprechenden GA´s so auf:

<trigger value="1" styling="GreyGreen">
   <layout colspan="3" />
   <label><icon name="it_fernsehen" />Szene speichern</label>
   <address transform="DPT:1.017" variant="">9/6/61</address>
</trigger>
<trigger value="1">
  <label>Szene abrufen</label>
  <address transform="DPT:1.017" variant="">9/5/61</address>
</trigger>

nach dem betägtigen des Buttons Szene speichern ist dann folgender Eintrag in der Szenencontroller.conf:

$scene{'Wohnen#0'}={};

Leider stehen aber keine Werte drin...

Hab diesen Eintrag dann auch nach dem Beispiel von DasVantom mal mit folgenden Werten gefüllt:

$scene{'Wohnen#0'}={'1/3/64'=>30.00};

Beim Versuch das dann über den CV-Button Szene abrufen passierte aber wieder nichts...

Auch eine Änderung auf

$scene{'Wohnen#´5'}={'1/3/64'=>30.00};

und den Abruf per

<trigger value="5">
  <label>Szene abrufen</label>
  <address transform="DPT:5.010" variant="">9/5/61</address>
</trigger>

bringt mir keinen Erfolg...

bin nun mit meinem Latein am Ende und ersuche daher Hilfe von euch...

Danke schonmal

[Fry]

Erstens: Sind die verwendeten GAs bei dir korrekt mit DPTId und DPTSubId in der /etc/wiregate/eibga.conf eingepflegt? Falls nein, KANN es nicht funktionieren.

Zweitens: was steht in der var/log/eib.log? Interessant wäre es zu wissen, ob überhaupt wire/read-requests abgesetzt und ggf. beantwortet werden.

Drittens lies bitte den Vorspann der Konfigurationsdatei zu DPTIds durch. Die Hinweise dort solltest du auch beachten.

VG, Fry