Items von Smarthome nach Homeasssistant exportieren

[henfri]

Hallo,

ich probiere gerade HomeAssistant aus.
Da ich faul bin und bei Monkey-Work meine Aufmerksamkeit katastrophal ist, so dass ich dann Fehler mache, habe ich mir eine Export-Logik gebaut.

#!/usr/bin/env python3
# logic_sh2ha.py

from ruamel.yaml import YAML
from ruamel.yaml.comments import CommentedMap as OrderedDict
import traceback

yaml=YAML()

from lib.item import Items
items = Items.get_instance()

def create_cover(item):
  from ruamel.yaml.comments import CommentedMap as OrderedDict
  from lib.item import Items
  #item=Items.return_item(item)
  #logger.error("Item {} DW {}".format(item.property.name, dw))
  if True:
      logger.error("in create_cover {}".format(item))
      cover = OrderedDict([('name', str(item)),  
           ('move_long_address',        uf.sh2ha.get_outgoing_gas(item.auf_ab)),
           #('move_short_address',       uf.sh2ha.get_outgoing_gas(item.auf_ab)),
           ('stop_address',             uf.sh2ha.get_outgoing_gas(item.stop)),
           ('position_address',         uf.sh2ha.get_outgoing_gas(item.position)),
           ('position_state_address',   uf.sh2ha.get_incoming_gas(item.position)),
           ('travelling_time_down',     30),
           ('travelling_time_up',       35)
                          ])
      try:
        cover['angle_address']= uf.sh2ha.get_outgoing_gas(item.lamelle)
        cover['angle_state_address']= uf.sh2ha.get_incoming_gas(item.lamelle)
      except:
        logger.warning("Keine Lamelle {}".format(item.property.name))
  #except:
  #    cover = OrderedDict()
  return cover
logic.create_cover=create_cover


def create_ow_expose_temp(item):
  from ruamel.yaml.comments import CommentedMap as OrderedDict
  #from lib.item import Items
  #dw=items.find_children(item,'Dimmwert')
  #logger.error("Item {} DW {}".format(item.property.name, dw))
  if len(uf.sh2ha.get_outgoing_gas(item))>0:
    try:
      ow_expose = OrderedDict([  
           ('type',                     'temperature'),
           ('address',                  uf.sh2ha.get_outgoing_gas(item)),  
           ('cooldown',                 '300'        ),
           ('entity_id',                'sensor.'+item.property.ow_addr.replace('.','_')+'_temperature' )
      ])
      ow_expose.yaml_add_eol_comment(item.property.name,key='address')
    except:
      ow_expose = []
  else:
    ow_expose = []
  return ow_expose
logic.create_ow_expose_temp=create_ow_expose_temp


def create_heating(item):
      from ruamel.yaml.comments import CommentedMap as OrderedDict
      if True:
          tmp=uf.sh2ha.get_outgoing_gas(item.modus).split("/")
          mode=tmp[0]+"/"+tmp[1]+"/"+str(int(tmp[2])+1)
          logger.error(mode)
          climate = OrderedDict(
      [
      ('name', item.property.name),
      ('temperature_address',              uf.sh2ha.get_incoming_gas(item.ist) ),
      ('setpoint_shift_address',           uf.sh2ha.get_outgoing_gas(item.sollwertverschiebung) ),
      ('setpoint_shift_state_address',     uf.sh2ha.get_incoming_gas(item.sollwertverschiebung) ),
      ('target_temperature_state_address', uf.sh2ha.get_incoming_gas(item.soll)            ),
      ('operation_mode_address',           mode              ),
      ('controller_status_state_address',  uf.sh2ha.get_incoming_gas(item.modus) ),
      ('command_value_state_address',     uf.sh2ha.get_incoming_gas(item.stellwert) )
          
      ])
      #except:
      #      logger.error("Fehler")
      #      climate=[]
      logger.error(climate)
      return climate

logic.create_heating=create_heating

Das sind die Funktionen, die ein Smarthome-NG Item als Input nehmen, und daraus eine HA Entity/Geräte erzeugen.
Dabei ist zu beachten, dass die HA Entitäten/Geräte "größer" sind, als bei Smarthome.
Z.B. gibt es ein Heizungs-Element, welches dann GAs für Ist, Soll, Sollwertverschiebung, ... hat. Bei Smarthome wären das ja mehrere Items.

Die Funktionen oben, setzen eine bestimmte Struktur voraus.... Ich denke aber, die wird bei den Meisten ähnlich sein, so dass der Code oben eigentlich allgemein sein sollte.

Jetzt müsst ihr "nur noch" für jeden Typ (Heizung, Steckdose, ...) eine Liste erstellen, und die jeweilige Funktion aufrufen.

rollo_items=items.match_items('*auf_ab*')
heating_items=items.match_items('*eizung')
ow_items=items.match_items('*:ow_addr')

Und dann:

heating= []
# Erstelle eine Liste von OrderedDict-Objekten
for item in heating_items:
    try:
        logger.info("Item {}".format(item.property.name))
        a=item.ist()
        l=logic.create_heating(item)
        heating.append(l)
    except:
        logger.info("kein Heizungsitem {}. error {}".format(item.property.name, traceback.format_exc()))


cover= []
# Erstelle eine Liste von OrderedDict-Objekten
for item in rollo_items:
    logger.error(item)
    l=logic.create_cover(item.return_parent())#search was for auf_ab
    if l !=  []:
      cover.append(l)

ow_exposes= []
# Erstelle eine Liste von OrderedDict-Objekten
for item in ow_items:
  if item.property.ow_sensor.startswith('T'):
    l=logic.create_ow_expose_temp(item)
    if l !=  []:
      ow_exposes.append(l)

So, das waren jetzt drei Beispiele. Es gibt natürlich noch mehr Geräte-Typen.
Anbei die ganze Logik.

Zusätzlich benötigen wir noch userfunctions, diese hängen auch an und müssen eingebunden werden.

Feedback gerne, aber ich werde daraus nur lernen, aber nix mehr ändern. Wenn ihr den Code verbessert, gerne posten!

Gruß,
Hendrik