Somit war der Grundstein für die Logik gelegt, die möglichst flexibel, für unterschiedliche Anwendungen, konfigurierbar sein soll.

Funktion:

Gesteuert wird die Logik über ein control-item, welches zugleich in der Logik Konfiguration als watch-item dient. Wir das control-item auf True gesetzt, so läuft die Logik. False stoppt die Blinkroutine.

blink_cycles setzt Initial den Countdown, der mit jedem Aufruf um 1 nach unten zählt. Bei 0 stoppt die Logik und setzt zudem das control-item auf False. 

blink_interval bestimmt die Blinkabstand in Sekunden. 

Mit items_cyclic und items_anticyclic werden die Items übergeben, die blinken sollen. Antizyklische Items werden immer dann aus/an wenn die zyklischen Items an/aus sind. 

Bevor die items zum blinken gebracht werden, sichert die Logik die ursprünglichen Werte, die auch am Ende wieder hergestellt werden.

Um die Routine ohne aktives schalten der Items testen zu können, wurde noch dry_run aufgenommen.

Zusammengefasst ergibt sich folgende Beispiel-Konfiguration für ../etc/logic.yaml:

visual_alarm:
    filename: blinker.py
    watch_item: HOME.alarm.action.blinkinglight
    set_items_cyclic:
        - AUSSEN.south.light.outer
        - AUSSEN.west.light.outer
    set_items_anticyclic:
        - AUSSEN.south.light.inner
        - AUSSEN.east.light.door
        - AUSSEN.west.light.nested
    set_blink_cycles: 4 # -1 for endless loop 
    set_blink_interval: 4
    dry_run: 1

Alle items müssen vom Typ boolean sein, da nur einfache Schaltoperationen durchgeführt werden.

Die Logik lässt sich relativ einfach nutzen, indem das im watch_item verbundene Item, also im Beispiel HOME.alarm.action.blinkinglight, auf True gesetzt wird. Die Logik ruft sich selbst solange auf, bis set_blink_cycles erreicht ist oder vorher das watch_item auf False gesetzt wurde. Am Ende wird das watch_item auf von der Logik auf False gesetzt.

Die Logik selbst ist in ../logics/blinker.py:

#!/usr/bin/env python3
# vim: tabstop=2 softtabstop=2 shiftwidth=2 expandtab

# Logic blinker.py

# LOGIC config
# -------------------------------------------------------
# visual_alarm:
#   filename: blinker.py
#   watch_item: HOME.alarm.action.blinkinglight
#   set_items_cyclic:
#     - AUSSEN.south.light.outer
#     - AUSSEN.west.light.outer
#   set_items_anticyclic: 
#     - AUSSEN.south.light.inner
#     - AUSSEN.east.light.door 
#     - AUSSEN.west.light.nested
#   set_blink_cycles: -1 " -1: endless 
#   set_blink_interval: 2
#   dry_run: 0 

control_item_name = trigger['source'] 
control_item = sh.return_item(control_item_name)
triggered_by = trigger['by'] 


if control_item is not None:
  logger.info("LOGIC blinker.py: {0} triggered from source {1} by {2}".format(logic.name, control_item_name, triggered_by))

  # control_item_active = trigger['value']
  control_item_active = control_item()

  # set parameters from logic config
  if hasattr(logic, 'set_items_cyclic'):
    blink_items_cyclic = logic.set_items_cyclic

  if hasattr(logic, 'set_items_anticyclic'):
    blink_items_anticyclic = logic.set_items_anticyclic

  if hasattr(logic, 'set_blink_cycles'):
    blink_cycles = int(logic.set_blink_cycles)
  else:
    blink_cycles = 2
    logger.info("LOGIC blinker.py: no blink cycles set, setting to default: {2}".format(blink_cycles))

  if hasattr(logic, 'set_blink_interval'):
    blink_interval = int(logic.set_blink_interval)
  else:
    blink_interval = 2
    logger.info("LOGIC blinker.py: no blink interval set, setting to default: {2}".format(blink_interval))

  if hasattr(logic, 'dry_run'):
    dry_run = (int(logic.dry_run) > 0)
  else:
    dry_run = False

  if control_item_active == True:

    # first call?
    if not hasattr(logic, 'blink_init'):
      logger.info("LOGIC blinker.py: initiating {0} blinks for {1} cyclic and {2} anti-cyclic items".format(blink_cycles, len(blink_items_cyclic), len(blink_items_anticyclic)))
      logic.blink_init = True

      blink_items = blink_items_cyclic + blink_items_anticyclic
      if len(blink_items) > 0:
        # SAVE item states
        logic.saved_items = {}
        for item_name in blink_items:
          item = sh.return_item(item_name)
          logic.saved_items[item_name] = item()
          logger.info("LOGIC blinker.py: save {0} = {1}".format(item_name, item()))

      if dry_run == True:
        logger.warn("LOGIC blinker.py: test mode, dry run active")

      else:
        logger.warn("LOGIC blinker.py: no blink items set")
 

    # prepare blink
    if hasattr(logic, 'blink_value'):
      logic.blink_value = not logic.blink_value
    else:
      logic.blink_value = True

    if hasattr(logic, 'blink_countdown'):
      logic.blink_countdown -= 1
    else:
      logic.blink_countdown = blink_cycles
     
    # any blinks left?
    if logic.blink_countdown > 0 or blink_cycles == -1:
      if blink_cycles == -1:
        logger.info("LOGIC blinker.py BLINK (endless)")
      else:
        logger.info("LOGIC blinker.py BLINK ({0} cycles remaining)".format(logic.blink_countdown))

      # set all cyclic items
      for item_name in blink_items_cyclic:
        item = sh.return_item(item_name)
        logger.info("LOGIC blinker.py SET {item} to {value})".format(item=item_name, value=logic.blink_value))
        if dry_run == False:
          item(logic.blink_value)

      # set all anti-cyclic items
      for item_name in blink_items_anticyclic:
        item = sh.return_item(item_name)
        logger.info("LOGIC blinker.py SET {item} to {value})".format(item=item_name, value=(not logic.blink_value)))
        if dry_run == False:
          item(not logic.blink_value)

      sh.trigger("logics.{0}".format(logic.name), by=trigger['by'], source=trigger['source'], value=trigger['value'], dt=sh.now() + datetime.timedelta(seconds=blink_interval))

    else:
      logger.info("LOGIC blinker.py countdown finished, set control item to False")
      control_item(False) # this triggers logic again!

  else:
    logger.info("LOGIC blinker.py control item set to false: stop blink logic, restore saved item values")

    # RESTORE item states
    if hasattr(logic, 'saved_items'):
      for item_name in logic.saved_items:
        item = sh.return_item(item_name)
        value = logic.saved_items[item_name]
        logger.info("LOGIC blinker.py: restore {0} = {1}".format(item_name, item()))
        if dry_run == False:
          item(value)
      
    # reset persistent values
    if hasattr(logic, 'saved_items'):
      delattr(logic, 'saved_items')  
    if hasattr(logic, 'blink_countdown'):
      delattr(logic, 'blink_countdown')  
    if hasattr(logic, 'blink_value'):
      delattr(logic, 'blink_value')  
    if hasattr(logic, 'blink_init'):
      delattr(logic, 'blink_init')  
    
else:
  logger.info("LOGIC blinker.py triggered without source... ignoring...")

Überarbeitung im Januar 2021:

Diese Logik wurde aufgrund weitere Anforderungen im Januar 2021 ergänzt. (siehe Thread im Forum) Die folgende Version vom 18. Januar 2021 blinkt mit einem oder zwei Items:

#!/usr/bin/env python3
# vim: tabstop=4 softtabstop=4 shiftwidth=4 expandtab

# Logic blinker2.py

# LOGIC config
# -------------------------------------------------------
# visual_alarm:
#     filename: blinker2.py
#     watch_item: HOME.alarm.action.blinkinglight
#     set_items_cyclic:
#         - AUSSEN.south.light.outer
#         - AUSSEN.west.light.outer
#     set_items_anticyclic:
#         - AUSSEN.south.light.inner
#         - AUSSEN.east.light.door
#         - AUSSEN.west.light.nested
#     set_blink_cycles: -1 ' -1: endless
#     set_blink_interval: 2
#     dry_run: 0

control_item_name = trigger['source']
control_item = sh.return_item(control_item_name)
triggered_by = trigger['by']

if control_item is not None:
    logger.info(f'LOGIC blinker.py: {logic.name} triggered from source {control_item_name} by {triggered_by}')

    # control_item_active = trigger['value']
    control_item_active = control_item()

    # set parameters from logic config
    blink_items_cyclic = []
    if hasattr(logic, 'set_items_cyclic'):
        blink_items_cyclic = logic.set_items_cyclic
    if blink_items_cyclic == 'None':
        blink_items_cyclic = []
    if isinstance(blink_items_cyclic, str):
        blink_items_cyclic = [blink_items_cyclic, ]

    # do we have blink items?
    if not isinstance(blink_items_cyclic, list) or len(blink_items_cyclic) == 0:
        logger.info('LOGIC blinker.py: error, no cyclic blink items set. Aborting')
    else:

        blink_items_anticyclic = []
        if hasattr(logic, 'set_items_anticyclic'):
            blink_items_anticyclic = logic.set_items_anticyclic
        if blink_items_anticyclic == 'None':
            blink_items_anticyclic = []
        elif isinstance(blink_items_anticyclic, str):
            blink_items_anticyclic = [blink_items_anticyclic, ]

        # did we get strange data?
        if not isinstance(blink_items_anticyclic, list):
            blink_items_anticyclic = []

        if hasattr(logic, 'set_blink_cycles'):
            blink_cycles = int(logic.set_blink_cycles)
        else:
            blink_cycles = 2
            logger.info(f'LOGIC blinker.py: no blink cycles set, setting to default: {blink_cycles}')

        if hasattr(logic, 'set_blink_interval'):
            blink_interval = int(logic.set_blink_interval)
        else:
            blink_interval = 2
            logger.info(f'LOGIC blinker.py: no blink interval set, setting to default: {blink_interval}')

        if hasattr(logic, 'dry_run'):
            dry_run = (int(logic.dry_run) > 0)
        else:
            dry_run = False

        if control_item_active:

            # first call?
            if not hasattr(logic, 'blink_init'):
                logger.info(f'LOGIC blinker.py: initiating {blink_cycles} blinks for {len(blink_items_cyclic)} cyclic and {len(blink_items_anticyclic)} anti-cyclic items')
                logic.blink_init = True

                blink_items = blink_items_cyclic + blink_items_anticyclic
                if len(blink_items) > 0:
                    # SAVE item states
                    logic.saved_items = {}
                    for item_name in blink_items:
                        item = sh.return_item(item_name)
                        if item:
                            logic.saved_items[item_name] = item()
                            logger.info(f'LOGIC blinker.py: save {item_name} = {item()}')

                    if dry_run:
                        logger.warn('LOGIC blinker.py: test mode, dry run active')

                else:
                    logger.warn('LOGIC blinker.py: no blink items set')

            # prepare blink
            if hasattr(logic, 'blink_value'):
                logic.blink_value = not logic.blink_value
            else:
                logic.blink_value = True

            if hasattr(logic, 'blink_countdown'):
                logic.blink_countdown -= 1
            else:
                logic.blink_countdown = blink_cycles

            # any blinks left?
            if logic.blink_countdown > 0 or blink_cycles == -1:
                if blink_cycles == -1:
                    logger.info('LOGIC blinker.py BLINK (endless)')
                else:
                    logger.info(f'LOGIC blinker.py BLINK ({logic.blink_countdown} cycles remaining)')

                # set all cyclic items
                for item_name in blink_items_cyclic:
                    item = sh.return_item(item_name)
                    logger.info(f'LOGIC blinker.py SET {item_name} to {logic.blink_value}')
                    if not dry_run:
                        item(logic.blink_value)
                        print(f'    - {item.id()}:{item()}')

                # set all anti-cyclic items
                for item_name in blink_items_anticyclic:
                    item = sh.return_item(item_name)
                    logger.info(f'LOGIC blinker.py SET {item_name} to {not logic.blink_value}')
                    if not dry_run:
                        item(not logic.blink_value)
                        print(f'    - {item.id()}:{item()}')

                sh.trigger(f'logics.{logic.name}', by=trigger['by'], source=trigger['source'], value=trigger['value'], dt=sh.now() + datetime.timedelta(seconds=blink_interval))

            else:
                logger.info('LOGIC blinker.py countdown finished, set control item to False')
                control_item(False)  # this triggers logic again!

        else:
            logger.info('LOGIC blinker.py control item set to false: stop blink logic, restore saved item values')

            # RESTORE item states
            if hasattr(logic, 'saved_items'):
                for item_name in logic.saved_items:
                    item = sh.return_item(item_name)
                    value = logic.saved_items[item_name]
                    logger.info(f'LOGIC blinker.py: restore {item_name} = {item()}')
                    if not dry_run:
                        item(value)

            # reset persistent values
            if hasattr(logic, 'saved_items'):
                delattr(logic, 'saved_items')
            if hasattr(logic, 'blink_countdown'):
                delattr(logic, 'blink_countdown')
            if hasattr(logic, 'blink_value'):
                delattr(logic, 'blink_value')
            if hasattr(logic, 'blink_init'):
                delattr(logic, 'blink_init')

else:
    logger.info('LOGIC blinker.py triggered without source... ignoring...')

Die Items

date:

    month:
        since:
            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.month.since.year
                    eval: str(sh.date.month.since.year()) + 'm'

        until:
            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.month.until.year
                    eval: str(sh.date.month.until.year()) + 'm'

    week:
        since:
            month:
                type: num
                cache: 'yes'
            year:
                type: num
                cache: 'yes'
        until:
            month:
                type: num
                cache: 'yes'
            year:
                type: num
                cache: 'yes'

    day:
        since:
            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.since.week
                    eval: str(sh.date.day.since.week()) + 'd'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.since.month
                    eval: str(sh.date.day.since.month()) + 'd'
            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.since.year
                    eval: str(sh.date.day.since.year()) + 'd'

        until:
            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.since.week
                    eval: str(sh.date.day.since.week()) + 'd'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.until.month
                    eval: str(sh.date.day.until.month()) + 'd'

            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.until.year
                    eval: str(sh.date.day.until.year()) + 'd'

    hour:
        since:
            midnight:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.since.midnight
                    eval: str(sh.date.hour.since.midnight()) + 'h'

            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.since.week
                    eval: str(sh.date.hour.since.week()) + 'h'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.since.month
                    eval: str(sh.date.hour.since.month()) + 'h'

            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.since.year
                    eval: str(sh.date.hour.since.year()) + 'h'

        until:
            midnight:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.until.midnight
                    eval: str(sh.date.hour.until.midnight()) + 'h'

            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.until.week
                    eval: str(sh.date.hour.until.week()) + 'h'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.until.month
                    eval: str(sh.date.hour.until.month()) + 'h'

            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.until.year
                    eval: str(sh.date.hour.until.year()) + 'h'

    minute:
        since:
            hour:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.since.hour
                    eval: str(sh.date.minute.since.hour()) + 'i'

            midnight:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.since.midnight
                    eval: str(sh.date.minute.since.midnight()) + 'i'

            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.since.week
                    eval: str(sh.date.minute.since.week()) + 'i'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.since.month
                    eval: str(sh.date.minute.since.month()) + 'i'

            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.since.year
                    eval: str(sh.date.minute.since.year()) + 'i'

        until:
            hour:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.until.hour
                    eval: str(sh.date.minute.until.hour()) + 'i'

            midnight:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.until.midnight
                    eval: str(sh.date.minute.until.midnight()) + 'i'

            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.until.week
                    eval: str(sh.date.minute.until.week()) + 'i'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.until.month
                    eval: str(sh.date.minute.until.month()) + 'i'

            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.until.year
                    eval: str(sh.date.minute.until.year()) + 'i'

    second:
        since:
            minute:
                type: num

            hour:
                type: num

            midnight:
                type: num

            week:
                type: num

            month:
                type: num

            year:
                type: num

        until:

            minute:
                type: num

            hour:
                type: num

            midnight:
                type: num

            week:
                type: num

            month:
                type: num

            year:
                type: num

Die Logik

Als Logik wird unter logics/zeit.py die nachfolgende Datei angelegt.

# /logics/zeit.py
# !/usr/bin/env python3


from lib.shtime import Shtime

sh_now = Shtime.get_instance().now()

# Funktionen

def days_of_month(month, year):
    if month in [1, 3, 5, 7, 8, 10, 12]:
        days = 31
    elif month in [4, 6, 9, 11]:
        days = 30
    elif (year % 400 == 0) or ((year % 4 == 0) and not (year % 100 == 0)):  # Schaltjahr
        days = 29
    else:
        days = 28
    return days

def days_of_year(year):
    period_end = datetime.datetime(year, 12, 31)
    days_of_year = (period_end - datetime.datetime(period_end.year, 1, 1)).days + 1
    return (days_of_year)

def day_of_year(year, month, day):
    period_end = datetime.datetime(year, month, day)
    day_of_year = (period_end - datetime.datetime(period_end.year, 1, 1)).days + 1
    return (day_of_year)

# Sekunde/Minute
sh.date.second.since.minute(sh_now.second)
sh.date.second.until.minute(60 - sh_now.second - 1)

# Minute/Stunde
sh.date.minute.since.hour(sh_now.minute)
sh.date.minute.until.hour(60 - sh_now.minute - 1)

# Stunde/Tag
sh.date.hour.since.midnight(sh_now.hour)
sh.date.hour.until.midnight(24 - sh_now.hour - 1)

# Tag/Woche
sh.date.day.since.week(sh_now.isoweekday())
sh.date.day.until.week(7 - sh_now.isoweekday())

# Stunde/Woche
sh.date.hour.since.week(sh.date.hour.since.midnight() + (24 * (sh.date.day.since.week() - 1)))
sh.date.hour.until.week(sh.date.hour.until.midnight() + (24 * sh.date.day.until.week()))

# Kalenderwoche/Jahr
sh.date.week.since.year(sh_now.isocalendar()[1])
sh.date.week.until.year(52-sh_now.isocalendar()[1])

# Monat/Jahr
sh.date.month.since.year(sh_now.month)
sh.date.month.until.year(12 - sh_now.month)

# Sekunde/Stunde
sh.date.second.since.hour(sh.date.second.since.minute() + (60 * sh.date.minute.since.hour()))
sh.date.second.until.hour(sh.date.second.until.minute() + (60 * sh.date.minute.until.hour()))

# Sekunde/Tag
sh.date.second.since.midnight(sh.date.second.since.minute() + (3600 * sh.date.hour.since.midnight()))
sh.date.second.until.midnight(sh.date.second.until.minute() + (3600 * sh.date.hour.until.midnight()))

# Minute/Tag
sh.date.minute.since.midnight(sh.date.minute.since.hour() + (60 * sh.date.hour.since.midnight()))
sh.date.minute.until.midnight(sh.date.minute.until.hour() + (60 * sh.date.hour.until.midnight()))

# Minute/Woche
sh.date.minute.since.week(sh.date.minute.since.hour() + (60 * sh.date.hour.since.week()))
sh.date.minute.until.week(sh.date.minute.until.hour() + (60 * sh.date.hour.until.week()))

# Sekunde/Woche
sh.date.second.since.week(sh.date.second.since.minute() + (60 * sh.date.minute.since.week()))
sh.date.second.until.week(sh.date.second.until.minute() + (60 * sh.date.minute.until.week()))

# Tage/Monat
sh.date.day.since.month(sh_now.day)
sh.date.day.until.month(days_of_month(sh_now.month, sh_now.year) - sh.date.day.since.month() - 1)

# Wochen/Monat
sh.date.week.since.month((sh.date.day.since.month()-1)//7+1)
sh.date.week.until.month((sh.date.day.until.month())//7)

# Tage/Jahr
sh.date.day.since.year(day_of_year(sh_now.year, sh_now.month, sh_now.day) - 1)
sh.date.day.until.year(days_of_year(sh_now.year) - sh.date.day.since.year() - 1)

# Stunde/Monat
sh.date.hour.since.month((24 * sh.date.day.since.month()) + sh.date.hour.since.midnight())
sh.date.hour.until.month((24 * days_of_month(sh_now.month, sh_now.year)) - sh.date.hour.since.month() - 1)

# Stunde/Jahr
sh.date.hour.since.year((24 * sh.date.day.since.year()) + sh.date.hour.since.midnight())
sh.date.hour.until.year((24 * days_of_year(sh_now.year)) - sh.date.hour.since.year() - 1)

# Minute/Monat
sh.date.minute.since.month((60 * sh.date.hour.since.month()) + sh.date.minute.since.hour())
sh.date.minute.until.month(sh.date.minute.since.month() - (60 * sh.date.hour.until.month()) - 1)

# Minute/Jahr
sh.date.minute.since.year((60 * sh.date.hour.since.year()) + sh.date.minute.since.hour())
sh.date.minute.until.year((60 * sh.date.hour.until.year()) + sh.date.minute.until.hour())

# Sekunde/Monat
sh.date.second.since.month((60 * sh.date.minute.since.month()) + sh.date.second.since.minute())
sh.date.second.until.month((60 * sh.date.minute.until.month()) + sh.date.second.until.minute())

# Sekunde/Jahr
sh.date.second.since.year((60 * sh.date.minute.since.year()) + sh.date.second.since.minute())
sh.date.second.until.year((60 * sh.date.minute.until.year()) + sh.date.second.until.minute())

In der etc/logic.yaml wird sie wie folgt eingebunden:

zeitberechnung:
    filename: zeit.py
    crontab:
        -   init
        -   '* * * *'

Anwendungsbeispiel: Database Plugin

Neben der Anzeige der Daten, macht es vor allem Sinn, die Werte im Zusammenspiel mit (historischen) Datenbank-Daten zu verwenden. Ein Beispiel wäre wie folgt:

consumption_since_midnight:
	type: num
	eval: sh.knx.cellar.utility_room.water_meter.db('count>0', sh.date.minute.since.midnight.dbstr(), 'now')
	eval_trigger: knx.cellar.utility_room.water_meter
	database@mysqldb: init

Im Eval-Ausdruck wird die Anzahl der Werte > 0 ermittelt, die zwischen Mitternacht und dem IST-Zeitpunkt erfasst wurden. Da für 1 Liter jedes Mal ein Impuls mit einer „1“ erfasst wird, erhält man so minutengenau die Anzahl der Liter seit Mitternacht. Die Methode dbstr() in sh.date.minute.since.midnight.dbstr() liefert direkt den Wert, den das Database-Plugin benötigt. Präziser gesagt, hängt sie dem numerischen Wert noch ein „i“ an, so dass die Angabe auf Ebene des Plugins korrekt interpretiert wird.
Über die Methode .db auf dem Item, wird die Datenbankabfrage gestartet. Das Item muss dazu mit dem Database-Plugin verknüpft sein database@mysqldb: init und bereits Daten im abgefragten Zeitraum erfasst haben.

(Das Titelbild ist unter der Creative Commons Zero (CC0) Lizenz veröffentlicht und wurde von www.pexels.com bezogen.)

Anzahl und Position der eingeschalteten Lampen ermitteln und visualisieren.

Logik

Es werden alle Lichter gesucht, die nicht auf Taster oder Level enden und die nicht in Zentral definiert sind. Die eingeschalteten Lichter werden als Link zum Ausschalten gespeichert, so dass sie bequem später ausgeschaltet werden können.

/usr/local/smarthome/logics/light.py

#!/usr/bin/env python

counter = []

# finde alle Lichter, die eingeschaltet sind (und nicht auf taster oder level enden)
for item in sh.match_items('*.licht.*'):
	if item() and not item.id().endswith('taster') and not item.id().endswith('level') and not item.id().startswith('zentral') and not item.id().endswith('aussen'):
		counter.append(item)

# ermittle licht bool wert
if len(counter) > 0:
	sh.zentral.zaehler.licht(1)
else:
	sh.zentral.zaehler.licht(0)

# setze licht anzahl wert
sh.zentral.zaehler.licht.anzahl(len(counter))
	
# ermittle Namen der Lichter, die eingeschaltet sind
namen = "<ul class='logik_licht'>"
for item in counter:
	parent_item = item.return_parent()
	namen += "<li><a href=\"#\" class=\"ui-link\" onclick=\"io.write(\'"+item.id()+"\',0);\">{0} {1}</a></li>".format(str(parent_item), str(item))
	
namen += "</ul>"
	
# setze Namen der eingeschalteten Lichter
sh.zentral.zaehler.licht.namen(namen.strip())
		
# Logging
logger.info("Es sind {0} Lichter an. ( {1})".format(str(sh.zentral.zaehler.licht.anzahl()), sh.zentral.zaehler.licht.namen()))

Die Logik aktiviert man unter etc/logic.conf mit dem Eintrag von:

/usr/local/smarthome/etc/logic.yaml

In der Zentral.conf habe ich Elemente definiert, die die ermittelten Werte aufnehmen.

lichter:
    filename: light.py
    watch_item: *.licht.*

/usr/local/smarthome/items/Zentral.yaml

# /usr/local/smarthome/items/Zentral.conf
zentral:
    name: Zentral

    zaehler:
        name: Zähler
        sv_page: room

        licht:
            name: Licht an
            type: bool
            visu: yes

            anzahl:
                name: Anzahl eingeschalteter Lichter
                type: num
                visu: yes

            namen:
                name: Eingeschaltete Lichter
                type: str
                visu: yes

Items

Folgende Items werden benötigt.

/usr/local/smarthome/items/EG.yaml

eg:
    name: Erdgeschoß

    flur:
        name: Flur
        sv_page: room
        sv_img: scene_hall.png

        licht:
            name: Flur

            decke:
                name: Dimmer
                type: bool
                visu: yes
                visu_acl: rw
                sv_img: light_ceiling_light.png

                level:
                    type: num
                    visu: yes
                    visu_acl: rw

HTML-Seite

Die ermittelten Werte können nun in einer HTML-Seite wie folgt angezeigt werden:

Es sind <strong>{{ basic.value('zentral.zaehler.licht.anzahl.1', 'zentral.zaehler.licht.anzahl', '', '') }}</strong> Lichter an
<br/>
( {{ basic.value('zentral.zaehler.licht.namen.1', 'zentral.zaehler.licht.namen', '', '') }} )

15.02.2014: Original Wiki Beitrag von ReneHezser
19.05.2015: Überarbeitung durch cstrassburg 

Es gibt jeweils einen eigenen Namensraum für Scheduler, die durch

• Items
• Logiken
• Scheduler

erzeugt wurden. Die Scheduler sind im Backend auf unterschiedlichen Reitern auf der Seite Scheduler zu sehen. Auf einem vierten Reiter sind die Scheduler zu sehen, die nicht in diese drei Namensräume fallen.

Das erweiterte API um diese Scheduler sauber anzusprechen ist noch auf der To Do Liste.

Zur Zeit können diese Scheduler über die bisherigen Scheduler Methoden angesprochen werden. Den Namen muss dabei jeweils ein Präfix vorangestellt werden.

Für:

• items   ->   items.<scheduler name>
• Logiken   ->   logics.<scheduler name>
• Plugins   ->   plugins.<scheduler name>

Ziel

Mit einem Schaltbefehl ein anderes Objekt mit Ein- oder Aussschalten. Der jeweilig andere Schaltzustand wird ignoriert. Anstonsten hätte ich ja ein Gruppenobjekt mehrfach zuordnen können.

Ich nutze die beiden Logiken z.B. im Badezimmer um die Rollladen herunterzufahren wenn der Bewegungsmelder das Licht einschaltet. Wenn ich dann manuell noch Zusatzlicht Einschalte, wird dieses automatisch vom Bewegungsmelder wieder mit dem Hauptlicht ausgeschaltet. Die Logik sendet jeweils ein 0 oder 1 an das mittels switchon oder switchon referenzierte Item. Somit können Lampen aus und Rollladen heruntergefahren werden.

Logik

Zuerst die beiden Logiken, die im logics Verzeichnis gespeichert werden.

switchoff.py

#!/usr/bin/env python

# get triggering item
trigger_source = trigger['source']
logger.debug('SwitchOff triggered by '+trigger_source)
trigger_item = sh.return_item(trigger_source)

if not trigger_item():
    # switch off associated item
    item_to_switchoff = sh.return_item(trigger_item.conf['switchoff'])
    logger.info('Switching off '+str(item_to_switchoff))
    item_to_switchoff(0)
else:
    logger.debug('SwitchOff trigger item is switched on. Nothing to do.')

switchon.py

#!/usr/bin/env python

# get triggering item
trigger_source = trigger['source']
logger.debug('SwitchOn triggered by '+trigger_source)
trigger_item = sh.return_item(trigger_source)

if trigger_item():
    # switch on associated item
    item_to_switchon = sh.return_item(trigger_item.conf['switchon'])
    logger.info('Switching on '+str(item_to_switchon))
    item_to_switchon(1)
else:
    logger.debug('SwitchOn trigger item is switched off. Nothing to do.')

In der Zentral.config habe ich Elemente definiert, die die ermittelten Werte aufnehmen.

logic.yaml

Registriert werden die beiden Logiken in der logic.yaml im ../etc Ordner von SmartHomeNG. Die Logiken werden auf alle Items registriert, die die Eigenschaften switchon/switchoff definiert haben.

SwitchOff:
    filename: switchoff.py
    watch_item: '*:switchoff'

SwitchOn:
    filename: switchon.py
    watch_item: '*:switchon'

Items

Die Zuordnung der Logiken zu Items geschieht in yaml-Dateien im items Ordner.

og:
    badezimmer:
        name: Badezimmer
        sv_page: room
        sv_img: scene_bathroom.svg
        
        licht:
            name: Badezimmer
            
            spiegel:
                name: Licht Spiegel
                ...
            
            decke:
                name: Licht
                type: bool
                ...
                switchon: og.badezimmer.rollo.fenster.lang
                switchoff: og.badezimmer.licht.spiegel

Das Auslösende Element wird ermittelt und über ein zusätzliches Attribut das zugeordnete Objekt gefunden und geschaltet.