Ankündigung

Einklappen
Keine Ankündigung bisher.

emx_cyclic: Plugin zum Durchschalten von Wertereihen, e.g. NACHT,STANDBY,KOMFORT, ... usw.

Einklappen
Dieses Thema ist geschlossen.
X
X
Einklappen
 
  • Seite von 1
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge
Vorherige template Weiter
    #1

    [wiregate] emx_cyclic: Plugin zum Durchschalten von Wertereihen, e.g. NACHT,STANDBY,KOMFORT, ... usw.

    UPDATE: Das Plugin hatte hier eine Weile Pause. Vor ein paar Tagen musste ich dann leider feststellen, dass es noch einige Macken gibt, so dass ich die Verwendung aktuell nicht empfehle.

    Hintergrund: Ursprünglich sollten auch alternierende Reihen damit verarbeitet werden können (z.B: KOMFORT, FROSTSCHUTZ, STANDBY, FROSTCHUTZ), über deren Sinn sich erstens streiten ließe, und die das Plugin aktuell zweitens in einen Deadlock schicken können. Das lässt sich beheben, aber zur Zeit habe ich andere Prioritäten.

    Aber sowie es positive Neuigkeiten gibt, gebe ich das bekannt.
    -----------------------------------------------------------------------------------------------------------



    Meine TS3-Plus brauchen für jede Heizbetriebsart eine eigene Taste: Nacht, Standby, Komfort usw.

    Das hat mir nicht gefallen. Also habe ich ein Plugin geschrieben, mit dem ich im TS3+ das RTR-Objekt "Betriebmodus" mit einer einzigen Taste nacheinander mit unterschiedlichen Betriebsmodi füttern kann.

    Hierzu genügt ein "EIN" Telegramm auf einer beliebigen GA. Jedes Mal, wenn von dieser GA ein solches Telegramm kommt, wird der nächste Betriebsmodus aus der Wertereihe gelesen, und an eine anzugebende GA im TS3+ gesendet (Betriebsmodus-GA).

    Das Ganze läuft im Kreis, fängt also wieder von vorne an, wenn die Wertereihe zu Ende ist.

    Fürs Verständnis empfiehlt es sich, erst mal die u.a. config-Datei anzusehen. Dort findet sich auch die Dokumentation für die Konfigurations-Einträge.

    Es handelt sich um die erste (i.e. Alpha-) Version. Sie funktioniert bei mir wie geplant.

    Weil das Ganze aber nicht so trivial ist, wie ich mir das vorgestellt hatte, sind Fehler also wahrscheinlich, ddenn ich habe nur meine Betriebsmodus-Geschichte damit getestet. Es müssten aber auch andersartige (numerische) Werte funktionieren, z.B. fürs Dimmen o.ä.

    Hier im Klartext (emx_cyclic.pl), darunter die conf-Datei, und dann komplett noch mal als zip-File (warum geht eigentlich kein *tgz ?) angehängt.

    Code:
    # Plugin zum schalten zyklischer Werte von Gruppenadressen
# License: GPL (v2)
# version von emax
#
# $Id: emx_cylic.pl 1183 2012-12-03 17:07:14Z makki1 $
#
# Copyright: Edgar (emax) Hermanns, forum at hermanns punkt net
#
#--------------------------------------------------------------------
#  CHANGE LOG:
#  ##  who  yyyymmdd   bug#  description
#  --  ---  --------  -----  ----------------------------------------
#   .  ...  ........  .....  vorlage
#   0  edh  20161006  -----  erste Version
#-----------------------------------------------------------------------------
# Das Plugin verarbeitet Telegramme von Gruppenadressen und
# sendet abhängig vom aktuellen Status Werte an andere
# Gruppenaderessen.
#
# Beispiel:
#  Adresse 1/2/3 sendet ein EIN Telegramm
#  Das Plugin sendet den KNX-Betriebszustand 'STANDBY' an
#      Adresse 1/2/10.
#
#  Adresse 1/2/3 sendet erneut ein EIN Telegramm
#  Das Plugin sendet den KNX-Betriebszustand 'COMFORT' an
#      Adresse 1/2/10
#
#  Bei weiteren EIN-Telegrammen von 1/2/3 sendet das Plugin
#  den jeweils nächsten Wert der Reihe an 1/2/10 und beginnt
#  dann von vorne:
#           ...,COMFORT,ECONOMY,STANDBY,COMFORT,ECONOMY,STANDBY ...
#
# Aktuell können nur numerische Werte verschickt werden, und zwar sowohl
# ansteigend, absteigend als auch alternierend.
#
# Beispiel 'Dimmen':
#  Sende 0%,50%,70%,100%,70%,%50
# sendet ansteigende Werte bis 100%, fällt wieder ab und begint
# dann von vorne: 0,50,70,100,70,50,0,50 ....
#
# Bei alternierenden Werten gibt es die Einschränkung, dass diese dann nicht
# immer durchlaufen werden, wenn andere Busteilnehmer diese in einer
# anderen Reihenfolge verändern als in dieser plugin.Konfiguration
# angegeben ist.
# Sofern die anderen Teilnehmer die gleichen Reihenwerte verwenden, sollte
# die Synchronisierung aber klappen.
#
# Weitere Dokumentation conf.d/emx_cyclic.conf.sample.
#

# ECONOMY    entspricht NIGHT
# PROTECTION entspricht FROST/HITZESCHUTZ
use constant { KNX_AUTO=>0, KNX_COMFORT=>1, KNX_STANDBY=>2, KNX_ECONOMY=>3, KNX_PROTECTION=>4 };

#-----------------------------------------------------------------------------
# konfigurierbare  Werte, siehe conf.d/emx_cyclic.conf.sample
#-----------------------------------------------------------------------------
my @Sequences  = ();
#-----------------------------------------------------------------------------
# ACHTUNG: Das sind default-Werte. Änderungen NICHT hier, sondern
#          IMMER in der .conf Datei vornehmen!
#
# Dokumentation siehe dort.
#-----------------------------------------------------------------------------
my $Version = 1;
my $WiregatePA = '1.3.250';

#-----------------------------------------------------------------------------
# ENDE Einstellungen
#-----------------------------------------------------------------------------

my $oneDay         = (24 * 3600);
my ($srcGA, $telegramGA, $srcPA, $srcVal);
my $piPrefix;

# dbg: Siehe Parameter 1 in allen 'debug' Aufrufen.
my $dbg = ':ALL:'; # :dJ:'; # ':ALL:init:'; # ALL:alles,

sub debug
{
    my ($tag, $text) = (@_);
    my $caller = (caller(1))[3];
#    ($dbg =~ /:ALL:|$tag/) and plugin_log($plugname, "DBG$tag$caller:"."$text");
    plugin_log($plugname, "DBG$tag$caller:"."$text");
    return 1;
} # debug()

sub readConf
{
    my $confFile = '/etc/wiregate/plugin/generic/conf.d/'.basename($plugname,'.pl').'.conf';
    #---# &debug(':conf:', "confFile[$confFile].");
    if (! -f $confFile) {
        plugin_log($plugname, " no conf file [$confFile] found.");
    } else {
        plugin_log($plugname, " reading conf file [$confFile].");
        open(CONF, $confFile);
        my @lines = <CONF>;
        close($confFile);
        my $result = eval("@lines");
        ($result) and plugin_log($plugname, "conf file [$confFile] returned result[$result]");
        if ($@) {
            plugin_log($plugname, "conf file [$confFile] returned:");
            my @parts = split(/\n/, $@);
            plugin_log($plugname, "--> $_") foreach (@parts);
        }
    }
} # readConf

sub checkSeq {
  # semantische Pruefung
  # OK:     return 1
  # Fehler: return 0

  my ($sequence, $sCount, $log, $logName) = @_;
  #---# &debug(':check:', "checking sequence [$sCount].");
  my $missing = ' ';

  # Grundlegenede Prüfungen
  (!defined $sequence->{ToGA}   || $sequence->{ToGA}     eq '') and $missing .= 'ToGA ';
  (!defined $sequence->{FromGA} || $sequence->{FromGA}   eq '') and $missing .= 'FromGA ';
  (!defined $sequence->{Values} || $sequence->{Values} == 0)    and $missing .= 'Values ';

  if (length $missing > 1) {
      # nicht verarbeitbar, Fehlermeldung und nächstes
      plugin_log($plugname, "ERROR: [$logName] missing[$missing]. Ignored.");
    return 0;
  }

  if ($sequence->{FromGA} eq $sequence->{ToGA}) {
      plugin_log($plugname, "ERROR: [$logName] FromGA[$sequence->{FromGA}] equals ToGA. Ignored.");
      return 0;
  }

  #---# &debug(':check:', "checking sequence [$sCount]: OK.");
  return 1;
} # checkSeq

sub doInit {
  #---# &debug(':init:', 'entering');

  # Kontrollierte Startkonditionen setzen
  # Die Funktion wird aufgerufen, wenn es der erste Lauf einer Plugin-Version
  # ist. Es werden alle Werte aus alten Versionen aus %plugin_info geloescht.
  # "$plugname.$Version.initialized" wird gesetzt, und auch alle anderen
  # kuenftig verwendeten plugin_info-Variablen angelegt.
  # Anmerkung: Die default-Werte und der letzte Bus-Wert werden erst bei Ausführung gelesen.
  #            Es kann sich ja in der Zwischenzeit auf dem Bus Einiges aendern.

  plugin_log($plugname, "Initializing plugin version $Version.");

  # obsolete Versionen von $plugin_info bereinigen
  foreach (keys %plugin_info) {
    if (/^$plugname\.\d+\./) {
      delete $plugin_info{$_};
      plugin_log($plugname, "deleted obsolete plugin_info[$_]");
    }
  }

  # remove all subscriptions
  foreach my $sequence (@Sequences) {
      foreach my $ga('FromGA', 'ToGA') {
          #---# &debug(':init:',  "checking[$ga]");
          if (exists $sequence->{$ga} && $sequence->{$ga} ne '') {
              my $subsGA = $sequence->{$ga};
              if (exists $plugin_subscribe{$subsGA}{$plugname}) {
                  #---# &debug(':init:',  "unsubscribing from [$subsGA]");
                  plugin_log($plugname, "unsubscribing from [{$subsGA}]");
                  delete $plugin_subscribe{$subsGA}{$plugname};
              } else {  # !exists subscribe
                  #---# &debug(':init:',  "no subscriptipon for [$subsGA]");
              }
          } else { # !exists ga
              #---# &debug(':init:',  "ga[$ga] not defined in sequence");
          }
      } # foreach ga
  } # foreach sequence

  # now, subscribe all valid and active ga
  my $sCount = -1;
  foreach my $sequence (@Sequences) {
      ++$sCount;
      my $logName = "Eintrag[$sCount],";
      defined $sequence->{Name} and $logName = "Name[$sequence->{Name}],";
      !&checkSeq($sequence, $sCount, 1, $logName) and next;

      #---# &debug(':main:', "sequence [$sCount] ok.");
      if (defined $sequence->{Active} && $sequence->{Active} == 1) {
          # Wenn aktiv, anmelden
          foreach my $ga ($sequence->{FromGA}, $sequence->{ToGA}) {
              plugin_log($plugname, "[$logName]: subscribing to [$ga]");
              $plugin_subscribe{$ga}{$plugname} = 1;
          } # foreach FromGA ToGA
      } # if active
  } # foreach $sequence

  $plugin_info{$plugname.'_cycle'} = $oneDay;
  $plugin_info{"$piPrefix.initialized"} = 1;
} # doInit

sub findNextValueIdx() {
  my ($sequence, $lastIdx, $curVal) = @_;
  my $values = $sequence->{Values};
  my $idx = $lastIdx;

  foreach (@$values) {
      #---# &debug(':findNext:', "value[$_]");
  }

  #---# &debug(':findNext:', "lastIdx[$lastIdx],curVal[$curVal].");
  $idx < 0 and $idx = 0; # safety first

  # walk through the array, starting with the last index that was in use, and
  # find the gap where previousvalue <= currentValue <= nextValue
  #                 OR previousvalue >= currentValue >= nextValue
  my $loops = @$values;
  while ($loops) {
    --$loops;
    ++$idx;
    #---# &debug(':findNext:', "  loops[$loops],idxl[$idx].");
    $idx == @$values and $idx = 0;
    my $v = $values->[$idx];
    #---# &debug(':findNext:',"  ARRAY idx[$idx], v[$v]");
    my $prevV = $values->[$idx-1];
    #---# &debug(':findNext:',"  prevV[$prevV], curVal[$curVal],v[$v]");
    if ( ($prevV <= $curVal && $curVal <= $v) ||
         ($prevV >= $curVal && $curVal >= $v) ) {
        #---# &debug(':findNext:',"    found idx[$idx]");
        # return only if not same value
        $curVal != $v && $idx != $lastIdx and return $idx;
    }
  } # for values ...

  # // not found
  #---# &debug(':findNext:', "not found, return 0");
  return 0;
} # findNextValueIdx()

#=============================================================================
# main()
#=============================================================================
&readConf;
plugin_log($plugname, "Starting plugin version $Version.");
$piPrefix = "$plugname.$Version";

# ggf. neue Version initialiseren
!defined $plugin_info{"$piPrefix.initialized"} and &doInit();

# Wenn keine GA geliefert wurde, geschah der Aufruf aufgrund eines _cycle Timeouts.
# Dann ist nichts weiter zu tun.
if (!defined $msg{'dst'}) {
    #---# &debug(':main:', "just a new cycle. Nothing to do.");
    # refresh _cycle
    $plugin_info{"$plugname".'_cycle'} = $oneDay;
    return;
}

# GA, PA und wert lesen und in $plugin_info protokollieren
#---# &debug(':msg:', "----------> msg[$_]=$msg{$_}") foreach (keys %msg);

$srcPA      = $plugin_info{"$piPrefix.PA"}   = $msg{'src'};
$telegramGA = $plugin_info{"$piPrefix.GA"}   = $msg{'dst'};
$srcVal     = $plugin_info{"$piPrefix.VAL"} = $msg{'data'};

($srcPA eq $WiregatePA) and return;

# Durch die Sequenzen gehen und schauen was ansteht.
my $sCount = -1;
foreach my $sequence (@Sequences) {
    ++$sCount;
    #---# &debug(':main:', "sequence [$sCount].");
    my $logName = "Eintrag[$sCount],";
    defined $sequence->{Name} and $logName = "Name[$sequence->{Name}],";

    my $rc = &checkSeq($sequence, $sCount, 0, $logName);
    !$rc and next;

    (defined $sequence->{Aktiv} && !$sequence->{Aktiv})            and next; # inaktiv, naechstes

    #---# &debug(':main:', "sequence [$sCount] is active. telegramGA[$telegramGA],fromGA[$sequence->{FromGA}],toGA[$sequence->{ToGA}]");

    # Wir haben hier zwei Fälle:
    # 1. Es wurde von einem anderen Teilnehmer ein Wert an die Ziel-GA (ToGA) gesendet.
    #    In diesem Fall schreiben wir lediglich den Wert zur späteren Synchronisation mit.
    # 2. Es wurde eine Anforderung auf der FromGA für dieses Plugin gesendet, einen neuen Wert
    #    aus der Sequenz an an die ToGA zu senden. In diesem Fall suchen wir den nächsten Wert
    #    und senden diesen.

    # Fall 1, anderer Teilnehmer hat uns dazwischen gepfuscht. Das merken wir uns!!
    if ($telegramGA eq $sequence->{ToGA}) {
        #---# &debug(':main:', "message for ToGA[$telegramGA], FromPA[$srcPA].");
        my $lastIdx = (exists $plugin_info{"$piPrefix.SEQ.$sCount.idx"}) ?
            $plugin_info{"$piPrefix.SEQ.$sCount.idx"} : 0;

        #---# &debug(':main:', "lastIdx[$lastIdx].");

        # was hier passiert:
        # wir suchen ab dem zuletzt benutzten index nach einem passenden slot und aktualisieren
        # diesen ggf. in plugin_info
        my $idx = &findNextValueIdx($sequence, $lastIdx, $srcVal);

        # Dieser Index WÄRE der nächste. Wir wollen aber den aktuellen, der liegt eins davor.
        $idx = ($idx > 0) ? $idx-1 : @{$sequence->{Values}} - 1;
        ($lastIdx != $idx) and $plugin_info{"$piPrefix.SEQ.$sCount.idx"} = $idx;

        #---# &debug(':main:', "setting $piPrefix.SEQ.$sCount.idx] = $idx.");
        next;       # das wars
    } # Fall 1, $telegramGA eq $sequence->{ToGA}

    # Fall 2, Anforderung für uns: neuen Wert schicken
    (defined $sequence->{FromPA} && $srcPA ne $sequence->{FromPA}) and next; # quellen-gerät falsch
    my $val = (defined $sequence->{Value}) ? $sequence->{Value} : 1;
    #---# &debug(':main:', "compare srcVal[$srcVal] eq val[$val] ?");
    ($srcVal ne $val)                                              and next; # falscher Wert

    if ($telegramGA ne $sequence->{FromGA}) {
        plugin_log($plugname, "ERROR: triggering GA[$telegramGA] is unexpectedly not eq FromGA[$sequence->{FromGA}]. ignored");
        next;
    }

    my $toGA = $sequence->{ToGA};
    # Letzten Wert vom Bus holen
    #my $lastValue = knx_read($toGA, 0, 5.001);  
    my $lastValue;

    (exists $plugin_info{"$piPrefix.SEQ.$sCount.value"}) and $lastValue = $plugin_info{"$piPrefix.SEQ.$sCount.value"};

    if (!defined $lastValue) {
        $lastValue = (exists $sequence->{Restart}) ? $sequence->{Restart} : $sequence->{Sequence}[0];
        #---# &debug(':main:', "no last value stored, assuming [$lastValue]");
    }

    my $lastIdx = (exists $plugin_info{"$piPrefix.SEQ.$sCount.idx"}) ? $plugin_info{"$piPrefix.SEQ.$sCount.idx"} : 0;
    my $idx = &findNextValueIdx($sequence, $lastIdx, $lastValue);
    $val = $sequence->{Values}[$idx];
    #---# &debug(':main:', "lastValue[$lastValue],lastIdx[$lastIdx],new val[$val]");

    # log wenn Log=1

    (defined $sequence->{Log} && $sequence->{Log} eq '1') and
        plugin_log($plugname, "[$logName]: Sending value[$val],ToGA[$toGA]");
    # Wert senden
    #---# &debug(':main:', "temporarily unsubscribing from [$toGA]");
    #---# &debug(':main:', "sending[$logName] value[$val],ToGA[$toGA]");
    $plugin_subscribe{$toGA}{$plugname} = 0;   # subscription temporär aussetzen
    knx_write($toGA, $val, $sequence->{ToDPT});

    # Werte sichern
    $srcVal = $plugin_info{"$piPrefix.SEQ.$sCount.idx"} = $idx;
    $srcVal = $plugin_info{"$piPrefix.SEQ.$sCount.value"} = $val;

    # reset cycle-time    
    $plugin_info{"$plugname".'_cycle'} = $oneDay;
    #---# &debug(':main:', "resubscribing to [$toGA]");
    $plugin_subscribe{$toGA}{$plugname} = 1;   # subscription reaktivieren
} # foreach (@Sequences)

#---# &debug(':main:', "done.");
    Hier die conf-Datei (emx_cyclic.conf_sample):

    Code:
    #
# $Id: emx_dcode.conf_sample 471 2011-10-23 13:30:28Z e.max $
#
#-----------------------------------------------------------------------------
# ACHTUNG: Variablen muessen und duerfen NUR im Plugin
#          mit 'my' definiert werden,
#          'my' hier nicht verwenden!
#-----------------------------------------------------------------------------

#------------------------
# Konfigurierbare Werte
#
# $Version
# §Sequenzen
# $WiregatePA
#------------------------

#-----------------------------------------------------------------------------
# - Es koennen beliebig viele Eintraege fuer sequentielle Wertereihen
#   gemacht werden. Sie werden alle verarbeitet.
# - Wird ein 'FromPA' Wert angegeben, wird der Code nur von dieser PA akzeptiert.
# - Der Code darf nur aus Ziffern bestehen, muss aber in Hochkommas angegeben
#   werden. So gehen auch fuehrende Nullen. Zehn Tastendruecke sind eine Null.
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Eintraege in der Sequenz-Tabelle:
#
# Active      0: wird ingoriert, 1: wird verarbeitet
#             optional, default=0,
# Log         0: kein log-Eintrag, 1: wird geloggt
#             optional, default=0,
# Name        Beliebiger Text, kommt ins Log wenn Log = '1'
#             optional, default=undef
# FromPA      Physische Adresse, Format 1.2.3,
#             Eintrag wird nur verarbeitet, wenn das Telegramm von dieser PA
#             stammt.
#             optional, default=undef
# FromGA      Gruppenadresse, auf der der Weiterschalungsbefehl gesendet wird.
#             zwingend, Fehlermeldung und Abbruch wenn nicht vorhanden
# DPT         An das Plugin gesendeter Datentyp
#             optional, default = '1'
# Value       Wert des Telegramms. Verarbeitung startet nur bei diesem Wert.
#             Anmerkung: Aus mir unbekannten Gründen bekam ich für ein            
#             DPT 1 - Telegramm 'EIN' nur den Wert '01' statt '1' geliefert,
#             Deshalb habe ich diesen auch hier eingetragen, und es
#             funktioniert.
#             optional, default = '1'
# ToGA        Gruppenadresse, an die der Sequenzwert gesendet wird.
#             zwingend, Fehlermeldung und Abbruch wenn nicht vorhanden
# ToDPT       Ziel-Datentyp der an ToGA gesendet wird.
#             Wenn Datentyp = '5.001' (Prozent), werden die Prozentwerte
#             angegeben (also z.B. 10, 25, 30 ...), die Umrechnung erfolgt
#             automatisch.
#             zwingend, Fehlermeldung und Abbruch wenn nicht vorhanden
# Values      ARRAY (Komma-separierte Liste in eckigen Klammern)
#             Datensequenz. Bei jedem neuen Telegramm wird der naechst
#             folgende wert gesandt. Am Ende der Sequenz beginnt diese
#             wieder von vorne.
#             zwingend, Fehlermeldung und Abbruch wenn nicht vorhanden
# Restart     Anfangswert, siehe ANMERKUNG.
#             optional, default = erster Sequenzwert
#
# ANMERKUNG: Bei Erstaufruf des Script oder bei einer geaenderten $Version
#            werden alle Sequenzen zurück gesetzt. Das Script versucht dann,
#            den aktuellen Wert vom Bus zu lesen und dann je nach Resultat
#            die Verarbeitung a) oder b) ausgefuehrt:#            .
#            a) Wird der Wert auf dem Bus gefunden wird dieser in der Sequenz
#               gesucht und dann der naechst folgende Wert gesendet.
#            b) Wird der Wert nicht auf dem Bus gefunden, oder existiert
#               der gefundene Wert nicht in der Sequenz, wird der 'Restart'
#            Wert (s.d.) gesendet.
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Die Versionsnummer IMMER veraendern, wenn die Werte oder das Script geaendert
#     wurden. Der Wert muss numerisch sein, egal ob hoeher oder niedriger als
#     die Vorversion. Es ist auch egal, ob die Version bereits verwendet wurde,
#     es kommt nur darauf an, das der Wert sich AENDERT.
#-----------------------------------------------------------------------------
$Version = 1;

#-----------------------------------------------------------------------------
# Die WirgatePA bitte setzen, damit selbst gesendete Telegramme nicht zum
#     Dauerfeuer führen.
#-----------------------------------------------------------------------------
$WiregatePA = '1.3.250';


# Zur Erinnerung: KNX_AUTO=>0, KNX_COMFORT=>1, KNX_STANDBY=>2, KNX_ECONOMY=>3, KNX_PROTECTION=>4
@Sequences =
    (
     # Die Datenwerte ECONOMY,STANDBY und COMFORT sind im Plugin vordefiniert.
     {
         # Diese Sequenz schaltet die Zustände ECONOMY,STANDBY und COMFORT auf der
         # Gruppenadresse 4/1/16 durch.
         # Hierzu muss jeweils ein "EIN" Telegramm auf der Adresse 4/1/17 gesendet werden.
         Active=>1, Log=>1, Name=>'Heizmodus ELW Schlafz', Restart=>KNX_STANDBY,
         FromPA=>undef, FromGA=>'4/1/17', DPT=>'1',  Value=>'01',
         ToGA=>'4/1/16', ToDPT=>'20.102', Values => [KNX_ECONOMY,KNX_STANDBY,KNX_COMFORT]
     },
     {  
         # Hiermit werden nacheinader die Dimmwerte 25,50,75 und 100 an die Adresse 1/3/15
         # gesand. Dazu müss jeweils ein 'EIN' Telegramm auf der Adresse 1/3/14 gesendet
         # werden.
         Active=>1, Log=>1, Name=>'Dimmen Esszimmer',
         FromPA=>undef, FromGA=>'1/3/14', DPT=>'1',  Value=>'01',
         ToGA=>'1/3/15', ToDPT=>'5.001',  Values => [25,50,75,100] },
    );

1;

# emacs setting
# ;;; Local Variables: ***
# ;;; mode:perl ***
# ;;; End: ***
    Angehängte Dateien
    Zuletzt geändert von emax; 30.12.2016, 14:28.
    Kein Support per PN: Fragen bzw. Fehlermeldungen bitte im Forum posten.
    Stichworte: cyclic, durchschalten, emx, plugin, wertereihen
    #2
    Das ist eine wunderbare Idee.

    Darf ich mir diese Idee auch für unsere Logik-Engine ausleihen? Also "getriggerte sequentieller Wertfortschaltung".

    lg

    Stefan

    Kommentar

      #3
      Aber sicher doch, Werner. Ich wäre mit meinem WG doch nicht da, wo ich jetzt bin, wenn Ihr nicht auch alles teilen würdet.

      Freut mich, wenn es Dir gefällt. :-)
      Kein Support per PN: Fragen bzw. Fehlermeldungen bitte im Forum posten.

      Kommentar

        #4
        > Aber sicher doch, Werner

        Der Name verleitet zu Verwechslungen: Stefan natürlich ...

        Kein Support per PN: Fragen bzw. Fehlermeldungen bitte im Forum posten.

        Kommentar

          #5
          Kein Problem, mit dem Namen ist man das gewohnt..

          lg

          Stefan

          Kommentar

            #6
            Ich habe im ersten Beitrag ein Update veröffentlicht.
            Kein Support per PN: Fragen bzw. Fehlermeldungen bitte im Forum posten.

            Kommentar

            Vorherige template Weiter
            Lädt...
            X

            Wir verarbeiten personenbezogene Daten über die Nutzer unserer Website mithilfe von Cookies und anderen Technologien, um unsere Dienste bereitzustellen. Weitere Informationen findest Du in unserer Datenschutzerklärung.

            Indem Du unten auf "ICH stimme zu" klickst, stimmst Du unserer Datenschutzerklärung und unseren persönlichen Datenverarbeitungs- und Cookie-Praktiken zu, wie darin beschrieben. Du erkennst außerdem an, dass dieses Forum möglicherweise außerhalb Deines Landes gehostet wird und bist damit einverstanden, dass Deine Daten in dem Land, in dem dieses Forum gehostet wird, gesammelt, gespeichert und verarbeitet werden.

            Ich stimme zu