daemon.c

//***************************************************************************
// Home Automation Control
// File daemon.c
// This code is distributed under the terms and conditions of the
// GNU GENERAL PUBLIC LICENSE. See the file LICENSE for details.
// Date 2010 - 2024  Jörg Wendel
//***************************************************************************

#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <dirent.h>
#include <algorithm>
#include <cmath>
#include <libgen.h>

#include "lib/curl.h"
#include "lib/json.h"

#include "daemon.h"
#include "growatt.h"

bool HomeCtl::shutdown {false};

//***************************************************************************
// Widgets
//***************************************************************************

const char* HomeCtl::widgetTypes[] =
{
   "Symbol",
   "Chart",
   "Text",
   "Value",
   "Gauge",
   "Meter",
   "MeterLevel",
   "PlainText",
   "Choice",
   "SymbolValue",
   "Spacer",
   "Time",
   "SymbolText",
   "BarChart",
   "SpecialSymbol",
   "Level",
   "Balance",
   "Timer",
   0
};

const char* HomeCtl::toName(WidgetType type)
{
   if (type > wtUnknown && type < wtCount)
      return widgetTypes[type];

   return widgetTypes[wtText];
}

HomeCtl::WidgetType HomeCtl::toType(const char* name)
{
   if (!name)
      return wtUnknown;

   for (int t = wtUnknown+1; t < wtCount; t++)
      if (strcasecmp(name, widgetTypes[t]) == 0)
         return (WidgetType)t;

   return wtText;
}

//***************************************************************************
// Default Value Types
//***************************************************************************

HomeCtl::ValueTypes HomeCtl::defaultValueTypes[] =
{
   // expression, title

   { "^VA$",      "Messwerte" },
   { "^SD",       "Status Laufzeiten" },
   { "^DO",       "Digitale Ausgänge" },
   { "^MCPO",     "Digitale Ausgänge" },
   { "^DI",       "Digitale Eingänge" },
   { "^MCPI",     "Digitale Eingänge" },
   { "^GPIO",     "GPIO" },
   { "^W1",       "One Wire Sensoren" },
   { "^SC",       "Skripte" },
   { "^AO",       "Analog Ausgänge" },
   { "^AI",       "Analog Eingänge" },
   { "^ADS",      "Analog Eingänge" },
   { "^Sp",       "Weitere Sensoren" },
   { "^DZL",      "DECONZ Lampen" },
   { "^DZLG",     "DECONZ Lampen Gruppe" },
   { "^DZS",      "DECONZ Sensoren" },
   { "^HM.*",     "Home Matic" },
   { "^P4.*",     "P4 Daemon" },
   { "^WEA",      "Wetter" },
   { "^SUN",      "Sonne" },
   { "^DHT",      "Wetter" },
   { "^CV",       "Calculated Values" },
   { "^PA",       "Parameter" },
   { "^UD",       "User Defined" },
   { "^VIC",      "Victron" },
   { "^VOTRO",    "Votronic" },
   { "^MOPEKA.*", "Mopeka" },

   { "",          "" }
};

const char* HomeCtl::getTitleOfType(const char* type)
{
   for (int i = 0; defaultValueTypes[i].typeExpression != ""; i++)
   {
      // tell(eloAlways, "check type '%s' against '%s'", type, defaultValueTypes[i].typeExpression.c_str());
      if (rep(type, defaultValueTypes[i].typeExpression.c_str()) == success)
         return defaultValueTypes[i].title.c_str();
   }

   return type;
}

//***************************************************************************
// Widgets - Default Properties
//***************************************************************************

HomeCtl::DefaultWidgetProperty HomeCtl::defaultWidgetProperties[] =
{
   // #TODO - auf einen JSON string umstellen

   // type, address,  unit,  widgetType, minScale, maxScale scaleStep, showPeak

   { "-",        na,   "*",      wtMeter,        0,        45,      10, false },
   { "SPACER",   na,   "*",      wtSpace,        0,         0,       0, false },
   { "TIME",     na, "txt",  wtPlainText,        0,         0,       0, true },
   { "DO",       na,   "*",     wtSymbol,        0,         0,       0, false },
   { "DI",       na,   "*",     wtSymbol,        0,         0,       0, false },
   { "GPIO",     na,   "*",     wtSymbol,        0,         0,       0, false },
   { "AO",       na,   "*",      wtMeter,        0,        45,      10, false },
   { "AI",       na,   "*",      wtMeter,        0,        45,      10, false },
   { "SD",       na,   "*",      wtChart,        0,      2000,       0, true },
   { "SC",       na,    "",       wtText,        0,         0,       0, false },
   { "SC",       na, "txt",       wtText,        0,         0,       0, false },
   { "SC",       na, "stxt",wtSymbolText,        0,         0,       0, false },
   { "SC",       na, "zst",     wtSymbol,        0,         0,       0, false },
   { "SC",       na,   "*",      wtMeter,        0,        40,      10, true },
   { "UD",       na, "txt",       wtText,        0,         0,       0, false },
   { "UD",       na, "zst", wtSymbolText,        0,         0,       0, false },
   { "UD",       na,   "*",       wtText,        0,         0,       0, false },
   { "W1",       na,   "*", wtMeterLevel,        0,        40,      10, true },
   { "VA",       na,   "%", wtMeterLevel,        0,       100,      20, true },
   { "VA",       na,   "*",      wtMeter,        0,        45,      10, true },
   { "HMB",      na,   "*",wtSymbolValue,        0,         0,       0, true },
   { "DZL",      na,   "*",     wtSymbol,        0,         0,       0, true },
   { "DZLG",     na,   "*",     wtSymbol,        0,         0,       0, true },
   { "DZS",      na, "zst",     wtSymbol,        0,         0,       0, true },
   { "DZS",      na,  "°C", wtMeterLevel,        0,        45,      10, true },
   { "DZS",      na,   "%",      wtChart,        0,         0,       0, true },
   { "DZS",      na, "hPa",      wtChart,        0,         0,       0, true },
   { "DZS",      na, "mov",     wtSymbol,        0,         0,       0, true },
   { "DZS",      na,  "lx",      wtChart,        0,         0,       0, true },
   { "DZS",      na,   "*",      wtMeter,        0,        45,      12, true },
   { "WEA",      na,   "*",  wtPlainText,        0,         0,       0, true },
   { "SUN",      na,   "*",  wtPlainText,        0,         0,       0, false },
   { "N4000",    na,   "*",      wtValue,        0,         0,       0, false },
   { "T2090",    na,   "*",      wtValue,        0,         0,       0, true },
   { "CV",       na, "txt",       wtText,        0,         0,       0, true },
   { "CV",       na,  "°C",  wtMeterLevel,       0,         0,       0, true },
   { "CV",       na,   "*",      wtSymbol,       0,         0,       0, true },
   { "" }
};

HomeCtl::DefaultWidgetProperty* HomeCtl::getDefalutProperty(const char* type, const char* unit, int address)
{
   for (int i = 0; defaultWidgetProperties[i].type != ""; i++)
   {
      if (defaultWidgetProperties[i].type == type)
      {
         bool addressMatch = defaultWidgetProperties[i].address == na || defaultWidgetProperties[i].address == address;
         bool unitMatch = defaultWidgetProperties[i].unit == "*" || defaultWidgetProperties[i].unit == unit;

         if (unitMatch && addressMatch)
            return &defaultWidgetProperties[i];
      }
   }

   return &defaultWidgetProperties[0]; // the default of the defaluts
}

//***************************************************************************
// Widget Defaults 2 Json
//***************************************************************************

int HomeCtl::widgetDefaults2Json(json_t* jDefaults, std::string type, std::string unit, const char* usrTitle, int address)
{
   DefaultWidgetProperty* defProperty {getDefalutProperty(type.c_str(), unit.c_str(), address)};

   // #TODO move to a json config
   //                     like /etc/homectld/widget-defaults.json
   //   and a user config like /etc/homectld/widget-defaults-usr.json

   const char* color {type != "HMB" ? "rgb(255, 255, 255)" : "rgb(0, 99, 162)"};
   const char* colorOn {type != "HMB" ? "rgb(235, 197, 5)" : "rgb(255, 255, 255)"};

   WidgetType widgetType {defProperty->widgetType};

   if (defProperty->widgetType == wtUnknown)
   {
      if (unit == "°C")
         widgetType = wtMeterLevel;
      else if (unit == "V" || unit == "A")
         widgetType = wtMeter;
      else if (unit == "txt" || unit == "")
         widgetType = wtText;
      else if (unit == "stxt")
         widgetType = wtSymbolText;
      else if (unit == "sym")
         widgetType = wtSymbol;
   }

   json_object_set_new(jDefaults, "widgettype", json_integer(widgetType));
   json_object_set_new(jDefaults, "unit", json_string(unit.c_str()));
   json_object_set_new(jDefaults, "scalemax", json_integer(defProperty->maxScale));
   json_object_set_new(jDefaults, "scalemin", json_integer(defProperty->minScale));
   json_object_set_new(jDefaults, "scalestep", json_integer(defProperty->scaleStep));
   json_object_set_new(jDefaults, "showpeak", json_boolean(defProperty->showPeak));
   json_object_set_new(jDefaults, "color", json_string(color));
   json_object_set_new(jDefaults, "colorOn", json_string(colorOn));

   const char* on {getImageFor(type, usrTitle, unit, true)};
   const char* off {getImageFor(type, usrTitle, unit, false)};

   if (strstr(off, "mdi:") == off)
      json_object_set_new(jDefaults, "symbol", json_string(off));
   else
      json_object_set_new(jDefaults, "imgoff", json_string(off));

   if (strstr(on, "mdi:") == on)
         json_object_set_new(jDefaults, "symbolOn", json_string(on));
   else
      json_object_set_new(jDefaults, "imgon", json_string(on));

   return done;
}

//***************************************************************************
// Get Image For
//***************************************************************************

const char* HomeCtl::getImageFor(std::string type, const char* usrTitle, std::string unit, int value)
{
   // #TODO move symbol/image to getDefalutProperty() ?!!

   const char* imagePath {};

   if (strcasestr(usrTitle, "Pump"))
      imagePath = value ? "img/icon/pump-on.gif" : "img/icon/pump-off.png";
   else if (strcasestr(usrTitle, "Steckdose") || strcasestr(usrTitle, "Plug") )
      imagePath = value ? "img/icon/plug-on.png" : "img/icon/plug-off.png";
   else if (strcasestr(usrTitle, "UV-C") || strcasestr(usrTitle, "UVC"))
      imagePath = value ? "img/icon/uvc-on.png" : "img/icon/uvc-off.png";
   else if (strcasestr(usrTitle, "Shower") || strcasestr(usrTitle, "Dusche"))
      imagePath = value ? "img/icon/shower-on.png" : "img/icon/shower-off.png";
   else if (strcasestr(usrTitle, "VDR"))
      imagePath = value ? "img/icon/vdr-on.png" : "img/icon/vdr-off.png";
   else if (strcasestr(usrTitle, "VPN"))
      imagePath = value ? "img/icon/vpn-on.png" : "img/icon/vpn-off.png";
   else if (strcasestr(usrTitle, "SATIP"))
      imagePath = value ? "img/icon/satip-on.png" : "img/icon/satip-off.png";
   else if (strcasestr(usrTitle, "Music") || strcasestr(usrTitle, "Musik"))
      imagePath = value ? "img/icon/note-on.png" : "img/icon/note-off.png";
   else if (strcasestr(usrTitle, "Fan") || strcasestr(usrTitle, "Lüfter"))
      imagePath = value ? "img/icon/fan-on.png" : "img/icon/fan-off.png";
   else if (strcasestr(usrTitle, "Desktop"))
      imagePath = value ? "img/icon/desktop-on.png" : "img/icon/desktop-off.png";
   else if (type == "DZL" || strcasestr(usrTitle, "Licht") || strcasestr(usrTitle, "Bulb") || strcasestr(usrTitle, "Light"))
      imagePath = value ? "mdi:mdi-lightbulb" : "mdi:mdi-lightbulb";
   else if (type == "DI" || type == "DO" || type == "GPIO")
      imagePath = value ? "mdi:mdi-toggle-switch-outline" : "mdi:mdi-toggle-switch-off-outline";
   else if (unit == "mov")
      imagePath = "mdi:mdi-walk";
   else if (type == "HMB")
      imagePath = value ? "mdi:mdi-blinds-open" : "mdi:mdi-blinds";
   else if (type == "DZL")
      imagePath = value ? "mdi:mdi-lightbulb-variant" : "mdi:mdi-lightbulb-variant-outline";
   else if (type == "DZLG")
      imagePath = value ? "mdi:mdi-lightbulb-group" : "mdi:mdi-lightbulb-group-outline";

   else
      imagePath = value ? "mdi:mdi-toggle-switch-outline" : "mdi:mdi-toggle-switch-off-outline";

   tell(eloDebug, "Debug: Found special image for '%s/%s/%s/%d' [%s]", type.c_str(), usrTitle, unit.c_str(), value, imagePath);

   return imagePath;
}

//***************************************************************************
// Object
//***************************************************************************

HomeCtl::HomeCtl()
{
   nextRefreshAt = time(0) + 5;
   startedAt = time(0);

   cDbConnection::init();
   cDbConnection::setEncoding("utf8");
   cDbConnection::setHost(dbHost);
   cDbConnection::setPort(dbPort);
   cDbConnection::setName(dbName);
   cDbConnection::setUser(dbUser);
   cDbConnection::setPass(dbPass);

   cCurl::create();      // create global cCurl instance
   webSock = new cWebSock(this, httpPath);
}

HomeCtl::~HomeCtl()
{
   exit();
   delete webSock;
   cCurl::destroy();
   cDbConnection::exit();
   free(mqttUrlPlain);
}

//***************************************************************************
// Push In Message (from WS to daemon)
//***************************************************************************

int HomeCtl::pushInMessage(const char* data)
{
   cMyMutexLock lock(&messagesInMutex);

   messagesIn.push(data);

   return success;
}

//***************************************************************************
// Push Out Message (from daemon to WS)
//***************************************************************************

// realPrecision: significant digits of the reals; 4 fits the (float) sensor values,
//  coordinates need more (4 digits round 51.0579 to 51.06 - a grid of about 1 km)

int HomeCtl::pushOutMessage(json_t* oContents, const char* event, long client, bool keepJson, int realPrecision)
{
   json_t* obj {json_object()};

   addToJson(obj, "event", event);
   json_object_set_new(obj, "object", oContents);

   char* p {json_dumps(obj, JSON_REAL_PRECISION(realPrecision))};

   if (!keepJson)
      json_decref(obj);

   if (!p)
   {
      tell(eloAlways, "Error: Dumping json message for event '%s' failed", event);
      return fail;
   }

   webSock->pushOutMessage(p, (lws*)client);
   free(p);
   webSock->performData(cWebSock::mtData);

   return done;
}

int HomeCtl::pushDataUpdate(const char* event, long client)
{
   // push all in the jsonSensorList to the 'interested' clients

   if (client)
   {
      auto cl {wsClients[(void*)client]};
         json_t* oJson {json_object()};

      for (auto& sj : jsonSensorList)
         json_object_set(oJson, sj.first.c_str(), sj.second);

      pushOutMessage(oJson, event, client);
   }
   else
   {
      for (const auto& cl : wsClients)
      {
         json_t* oJson {json_object()};

         for (auto& sj : jsonSensorList)
            json_object_set(oJson, sj.first.c_str(), sj.second);

         pushOutMessage(oJson, event, (long)cl.first);
      }
   }

   // cleanup

   // since we use the references more than once we have to do it
   //  by calling json_object_set instead of json_object_set_new
   //  therefore we have to free it by json_decref()

   for (auto sj : jsonSensorList)
      json_decref(sj.second);

   jsonSensorList.clear();

   return success;
}

//***************************************************************************
// Init / Exit
//***************************************************************************

int HomeCtl::init()
{
   int status {success};

   initLocale();

   // initialize the dictionary

   char* dictPath {};
   asprintf(&dictPath, "%s/database.dat", confDir);

   if (dbDict.in(dictPath) != success)
   {
      tell(eloAlways, "Fatal: Dictionary not loaded, aborting!");
      return 1;
   }

   tell(eloAlways, "Dictionary '%s' loaded", dictPath);
   free(dictPath);

   while ((status = initDb()) != success && !doShutDown())
   {
      exitDb();
      tell(eloAlways, "Retrying in %d seconds", 10);
      doSleep(10);
   }

   deconz.init(this, connection);

   // ---------------------------------
   // check users - add default user if empty

   int userCount {0};
   tableUsers->countWhere("", userCount);

   if (userCount <= 0)
   {
      tell(eloAlways, "Initially adding default user (" NAME "/" NAME ")");

      md5Buf defaultPwd;
      createMd5(NAME, defaultPwd);
      tableUsers->clear();
      tableUsers->setValue("USER", NAME);
      tableUsers->setValue("PASSWD", defaultPwd);
      tableUsers->setValue("TOKEN", "dein&&secret12login34token");
      tableUsers->setValue("RIGHTS", 0xff);  // all rights
      tableUsers->store();
   }

   // ---------------------------------
   // update the config table by the configuration definition

   initConfigTable();
   readConfiguration(true);
   mqttCheckConnection();
   gpsReceiverPublishConfig();   // the GPS script may run already

   // ---------------------------------
   // setup GPIO

   gpio = new Gpio(myName(), confDir);
   gpio->init();

   // -------------------
   // init values

   tableValueFacts->clear();

   for (bool f = selectActiveValueFacts->find(); f; f = selectActiveValueFacts->fetch())
      initSensorByFact(tableValueFacts->getStrValue("TYPE"), tableValueFacts->getIntValue("ADDRESS"));

   selectActiveValueFacts->freeResult();

   // ---------------------------------
   // apply configuration specials

   applyConfigurationSpecials();

   // resume a GPS tour which was active at the last shutdown

   gpsTourInit();

   // homeMaticInterface

   if (homeMaticInterface && !homeMaticViaService())      // the service hmmqtt publishes its devices retained
   {
      if (mqttCheckConnection() == success && !mqttUrl.empty())
      {
         const char* request {"{ \"method\" : \"listDevices\" }"};
         mqttWriter->write(INSTANCE "2mqtt/homematic/rpccall", request);
         tell(eloHomeMatic, "-> (home-matic) '%s' to '%s'", INSTANCE "2mqtt/homematic/rpccall", request);
      }
      else
      {
         tell(eloAlways, "Error: Can't request home-matic data, MQTT connection failed");
      }
   }

   publishVictronInit("VIC");
   requestSensorInit("ALPICOOL");
   requestSensorInit("KENWOOD");

   // init web socket ...

   while (webSock->init(webPort, webSocketPingTime, confDir, webSsl) != success)
   {
      tell(eloAlways, "Retrying in 2 seconds");
      sleep(2);
   }

   initArduino();
   performMqttRequests();
   initScripts();
   loadIoStates();           // load states of outputs on last exit
   lmcInit(true);

   if (!isEmpty(deconz.getHttpUrl()) && !isEmpty(deconz.getApiKey()))
      deconz.initWsClient();
   // deconz.initDevices();

   if (!isEmpty(deconz.getHttpUrl()) && isEmpty(deconz.getApiKey()))
   {
      tell(eloAlways, "DECONZ: No API key for '%s' jet, try to query", deconz.getHttpUrl());
      std::string result;
      int status {deconz.queryApiKey(result)};

      if (status != success)
      {
         tell(eloAlways, "DECONZ: Key result was '%s' (%d)", result.c_str(), status);
         tell(eloAlways, "ACHTUNG: Initiale Registrierung bei deconz '%s' fehlgeschlagen! "   \
              "Unlock the deCONZ gateway and restart homectrld within the 60 seconds", deconz.getHttpUrl());
      }
      else
      {
         setConfigItem("deconzApiKey", result.c_str());
         deconz.setApiKey(result.c_str());
         deconz.initDevices();
      }
   }

   addValueFact(1, "CV", 1, "Calc Sensor 1", "", "");
   addValueFact(2, "WEA", 1, "Windy App by Spot ID", "", "");
   addValueFact(3, "WEA", 1, "Windy App Map", "", "");
   addValueFact(4, "WEA", 1, "Windy App by GPS", "", "");

   lua.configure([this](sol::state& s) {
      s.new_usertype<SensorData>("SensorData",
         "value",     sol::readonly(&SensorData::value),
         "state",     sol::readonly(&SensorData::state),
         "text",      sol::readonly(&SensorData::text),
         "last",      sol::property(&SensorData::last),         // getters -> read-only properties
         "changedAt", sol::property(&SensorData::changedAt),
         "kind",      sol::readonly(&SensorData::kind),
         "name",      sol::readonly(&SensorData::name),
         "title",     sol::readonly(&SensorData::title),
         "unit",      sol::readonly(&SensorData::unit),
         "valid",     sol::property(&SensorData::valid));

      s.set_function("watch", [this](const std::string& wType, int wAddr) {
         luaDeps[luaCurrentKey].insert({wType, wAddr});
      });

      s.set_function("every", [this](int seconds) {          // periodic run in the own interval of the script
         luaEvery[luaCurrentKey] = std::max(seconds, 1);
      });

      s.set_function("tell", [](int level, const std::string& msg) {
         tell(static_cast<Eloquence>(level), "%s", msg.c_str());
      });

      s["eloAlways"] = (int)eloAlways;
      s["eloInfo"]   = (int)eloInfo;
      s["eloDebug"]  = (int)eloDebug;
      s["eloLua"]    = (int)eloLua;

      // share config options

      sol::table configTable {s.create_table()};
      sol::table configMetatable {s.create_table()};

      // Hook für den Zugriff: config["optionFooBar"]

      configMetatable[sol::meta_function::index] = [this](sol::table t, const std::string& key) -> sol::object {
         sol::state_view luaState = t.lua_state();

         // Suche das Config-Item in der config Tabelle

         ConfigItemType type {ctString};

         // key existiert nicht in der Konfiguration

         if (!this->configItemExists(key.c_str(), &type))
            return sol::nil;

         // Type abhängiges Auslesen über die exakte Überladung

         switch (type)
         {
            case ConfigItemType::ctInteger:
            {
               int intVal {0};
               this->getConfigItem(key.c_str(), intVal);
               return sol::make_object(luaState, intVal);
            }
            case ConfigItemType::ctBitSelect:
            {
               long longVal {0};
               this->getConfigItem(key.c_str(), longVal);
               return sol::make_object(luaState, longVal);
            }
            case ConfigItemType::ctNum:
            {
               double doubleVal {0.0};
               this->getConfigItem(key.c_str(), doubleVal);
               return sol::make_object(luaState, doubleVal);
            }
            case ConfigItemType::ctBool:
            {
               bool boolVal {false};
               this->getConfigItem(key.c_str(), boolVal);
               return sol::make_object(luaState, boolVal);
            }

            // Alle textbasierten und restlichen Auswahllisten nutzen std::string

            case ConfigItemType::ctString:
            case ConfigItemType::ctText:
            case ConfigItemType::ctChoice:
            case ConfigItemType::ctComboChoice:

            case ConfigItemType::ctMultiSelect:
            case ConfigItemType::ctRange:
            default:
            {
               std::string strVal;
               this->getConfigItem(key.c_str(), strVal);
               return sol::make_object(luaState, strVal);
            }
         }
      };

      configTable[sol::metatable_key] = configMetatable;
      s["config"] = configTable;
   });

   lua.push([&](sol::state& s) {
      s["sensors"] = &sensors;
   });

   initialized = true;
   triggerProcess = true;    // first evaluation of the LUA scripts (collects their watch() / every())

   return success;
}

int HomeCtl::initLocale()
{
   // setenv("TZ", "CET", 1);

   // Locale initialisieren (Liest die Umgebungsvariablen des Systems wie LANG oder LC_ALL)

   const char* locale {setlocale(LC_ALL, "")};

   if (!locale)
   {
      tell(eloDebug, "Debug: Detecting locale setting for LC_ALL failed");
      return fail;
   }

   tell(eloInfo, "Current locale is %s", locale);

   // Zeitzone des Systems einlesen - tzset() nach setlocale

   tzset();

   if ((strcasestr(locale, "UTF-8") != 0) || (strcasestr(locale, "UTF8") != 0))
      tell(eloInfo, "Detected UTF-8");

   time_t nun {time(nullptr)};
   struct tm* tmTime {localtime(&nun)};
   char strTime[64] {};
   strftime(strTime, sizeof(strTime), "%c", tmTime);

   tell(eloAlways, "Daylight (glob: %d, akt: %d); Timezone offset is (%ld) now it's %ld [%s]",
        daylight, tmTime->tm_isdst, timezone, nun, strTime);

   return done;
}

int HomeCtl::exit()
{
   for (auto it = sensors["DO"].begin(); it != sensors["DO"].end(); ++it)
   {
      if (!sensors["DO"][it->first].impulse)
         gpioWrite(it->first, false, false);
   }

   for (auto& sensor : sensors["GPIO"])
   {
      if (sensor.second.fct == "out" && !sensor.second.impulse)
         gpioWrite(sensor.first, false, false);
   }

   lmcExit();
   deconz.exit();
   mqttDisconnect();
   exitDb();

   return success;
}

//***************************************************************************
// Init Sensor
//***************************************************************************

int HomeCtl::applyConfigurationSpecials()
{
   std::map<int,PinInfo> pinList;
   gpio->getPinList(pinList);

   for (const auto& [phys, pinInfo] : pinList)
   {
      if (!pinInfo.usable)  // is GPIO pin and not blocked by other process
         continue;

      initGpioLine(phys, pinInfo);
   }

   return done;
}

//***************************************************************************
// Init Sensor
//***************************************************************************

int HomeCtl::initSensorByFact(myString type, uint address)
{
   cDbRow* fact {valueFactRowOf(type.c_str(), address)};

   if (!fact)
   {
      tell(eloAlways, "Warning: valuefact for %s:0x%02x not found!", type.c_str(), address);
      return fail;
   }

   sensors[type][address].type = type;
   sensors[type][address].address = address;
   sensors[type][address].record = fact->hasValue("RECORD", "A");
   sensors[type][address].name = fact->getStrValue("NAME");
   sensors[type][address].unit = fact->getStrValue("UNIT");
   sensors[type][address].factor = fact->getIntValue("FACTOR");
   sensors[type][address].group = fact->getIntValue("GROUPID");
   sensors[type][address].active = fact->hasValue("STATE", "A");
   sensors[type][address].choices = fact->getStrValue("CHOICES");

   if (!fact->getValue("PARAMETER")->isEmpty())
      sensors[type][address].parameter = fact->getStrValue("PARAMETER");

   if (type == "GPIO" || type == "DO" || type == "DI" || type == "DZL" || type == "DZLG")
      sensors[type][address].kind = "status";

   if (sensors[type][address].unit == "txt")
      sensors[type][address].kind = "text";

   if (!fact->getValue("USRTITLE")->isEmpty())
      sensors[type][address].title = fact->getStrValue("USRTITLE");
   else if (!fact->getValue("TITLE")->isEmpty())
      sensors[type][address].title = fact->getStrValue("TITLE");
   else
      sensors[type][address].title = fact->getStrValue("NAME");

   if (type != "CV" && !fact->getValue("SETTINGS")->isEmpty())
   {
      json_t* jCal {jsonLoad(fact->getStrValue("SETTINGS"), 0, true)};

      if (!jCal)
         tell(eloAlways, "Ignoring invalid JSON in settings config of '%s:0x%x'", type.c_str(), address);

      if (jCal)
      {
         if (type == "GPIO")
            sensors[type][address].fct = getStringFromJson(jCal, "fct", "off");

         if (type == "AI" || type.starts_with("ADS"))
         {
            aiSensorConfig[type][address].calPointA = getDoubleFromJson(jCal, "pointA");
            aiSensorConfig[type][address].calPointB = getDoubleFromJson(jCal, "pointB");
            aiSensorConfig[type][address].calPointValueA = getDoubleFromJson(jCal, "valueA");
            aiSensorConfig[type][address].calPointValueB = getDoubleFromJson(jCal, "valueB");
            aiSensorConfig[type][address].round = getDoubleFromJson(jCal, "round");
            aiSensorConfig[type][address].cutBelow = getDoubleFromJson(jCal, "cutBelow", -10000.0);
         }
         else if (type == "DO" || type.starts_with("MCPO") || (type == "GPIO" && sensors[type][address].fct == "out"))
         {
            sensors[type][address].outputModes = getIntFromJson(jCal, "outputModes", 1);
            sensors[type][address].invert = getBoolFromJson(jCal, "invert", true);
            sensors[type][address].impulse = getBoolFromJson(jCal, "impulse");
            sensors[type][address].feedbackInType = getStringFromJson(jCal, "feedbackInType", "");
            sensors[type][address].feedbackInAddress = getIntFromJson(jCal, "feedbackInAddress");
            sensors[type][address].script = getStringFromJson(jCal, "script", "");

            cfgOutput(type, address, jCal);
         }
         else if (type == "DI" || type.starts_with("MCPI") || (type == "GPIO" && sensors[type][address].fct == "in"))
         {
            sensors[type][address].invert = getBoolFromJson(jCal, "invert", true);
            sensors[type][address].pull = (Gpio::PullUpDown)getIntFromJson(jCal, "pull", 0);

            cfgInput(type, address, jCal);
         }
         else if (type == "SC")
         {
            sensors[type][address].script = fact->getStrValue("SETTINGS");
         }

         json_decref(jCal);
      }
   }

   tell(eloDebug, "Debug: Init sensor %s/0x%02x - '%s' %s", type.c_str(), address,
        sensors[type][address].title.c_str(), sensors[type][address].active ? "active" : "not active");

   return success;
}

//***************************************************************************
// Init GPIO Line
//***************************************************************************

int HomeCtl::initGpioLine(uint physPin, const PinInfo& pinInfo)
{
   std::string name {std::to_string(physPin) + " - " + pinInfo.name + "\n" + pinInfo.description};
   addValueFact(physPin, "GPIO", 1, name.c_str(), "", "", urControl);

   if (sensors["GPIO"][physPin].active)
   {
      if (sensors["GPIO"][physPin].fct == "out")
      {
         gpio->pinMode(physPin, Gpio::dirOut);
         cfgOutput("GPIO", physPin);

         if (!sensors["GPIO"][physPin].impulse)
            gpioWrite(physPin, false, false);
      }
      else if (sensors["GPIO"][physPin].fct == "in")
      {
         gpio->pinMode(physPin, Gpio::dirIn);
         cfgInput("GPIO", physPin);
         gpioRead(physPin);
      }
   }

   return done;
}

//***************************************************************************
// Init digital Output
//***************************************************************************

int HomeCtl::initOutput(uint pin, int outputModes, OutputMode mode, const char* name, uint rights)
{
   std::string n {std::string(name) + " " + std::to_string(pin) + "\n" + gpio->pinToName(pin)};
   addValueFact(pin, "DO", 1, n.c_str(), "", "", rights);

   // tell(eloDetail, "Info: initOutput 'DO:0x%x' to mode (%d)", pin, mode);

   sensors["DO"][pin].outputModes = outputModes;
   sensors["DO"][pin].mode = mode;

   gpio->pinMode(pin, Gpio::dirOut);
   cfgOutput("DO", pin);

   if (!sensors["DO"][pin].impulse)
      gpioWrite(pin, false, false);

   return done;
}

int HomeCtl::cfgOutput(myString type, uint pin, json_t* jCal)
{
   if (type.starts_with("MCPO"))
   {
      publishI2CSensorConfig(type.c_str(), pin, jCal);
   }

   else if (type == "DO" || type == "GPIO")
   {
      if (sensors[type][pin].impulse)
      {
         sensors[type][pin].markValid();
         sensors[type][pin].state = sensors[type][pin].invert ? true : false;
      }
   }

   return done;
}

//***************************************************************************
// Init digital Input
//***************************************************************************

int HomeCtl::initInput(uint pin, const char* name)
{
   std::string n = std::string(name) + " " + std::to_string(pin) + "\n" + gpio->pinToName(pin);
   addValueFact(pin, "DI", 1, n.c_str());

   gpio->pinMode(pin, Gpio::dirIn);
   cfgInput("DI", pin);
   gpioRead(pin);

   return done;
}

int HomeCtl::cfgInput(myString type, uint pin, json_t* jCal)
{
   if (type.starts_with("MCPI"))
      publishI2CSensorConfig(type.c_str(), pin, jCal);

   else if (type == "DI" || (type == "GPIO" && sensors[type][pin].fct == "in"))
   {
      if (sensors[type][pin].pull != Gpio::pudOff)
         gpio->pullUpDnControl(pin, sensors[type][pin].pull);

      if (sensors[type][pin].active) //
      {
         tell(eloDebugGpio, "Debug: GPIO: ISR(%d) (%s)", pin, gpio->pinToName(pin).c_str());

         if (!sensors[type][pin].interruptSet)
         {
            if (gpio->setIsr(pin, Gpio::edgeBoth, std::bind(&HomeCtl::onGpioChange, this, std::placeholders::_1, std::placeholders::_2)) != success)
               tell(eloAlways, "Error: Unable to setup ISR to pin %d (%s)", pin, gpio->pinToName(pin).c_str());
            else
               sensors[type][pin].interruptSet = true;
         }
      }
   }

   return done;
}

//***************************************************************************
// Init Scripts
//***************************************************************************

int HomeCtl::initScripts()
{
   // LogDuration ld("initScripts");
   int count {0};

   tableValueFacts->clear();
   tableValueFacts->setValue("TYPE", "SC");

   // cleanup valuefacts (delete all 'SC' sensors which not exist)

   for (bool f = selectValueFactsByType->find(); f; f = selectValueFactsByType->fetch())
   {
      char* path {};
      asprintf(&path, "%s/scripts.d/%s", confDir, tableValueFacts->getStrValue("NAME"));

      if (!fileExists(path))
      {
         char* stmt {};
         asprintf(&stmt, "%s = %ld and %s = 'SC'",
                  tableValueFacts->getField("ADDRESS")->getDbName(), tableValueFacts->getIntValue("ADDRESS"),
                  tableValueFacts->getField("TYPE")->getDbName());
         tell(eloScript, "Script: Removing value fact for script '%s'", path);
         tableValueFacts->deleteWhere("%s", stmt);
         free(stmt);
      }

      free(path);
   }

   tableValueFacts->reset();

   // check for new scripts

   FileList scripts;
   char* path {};
   asprintf(&path, "%s/scripts.d", confDir);
   int status = getFileList(path, DT_REG, "sh", false, &scripts, count);

   if (status != success)
   {
      free(path);
      return status;
   }

   for (const auto& script : scripts)
   {
      long addr {0};

      tableValueFacts->clear();
      tableValueFacts->setValue("TYPE", "SC");
      tableValueFacts->setValue("NAME", script.name.c_str());

      if (selectValueFactsByTypeAndName->find())
         continue;

      if (selectMaxValueFactsByType->find() && !tableValueFacts->getValue("ADDRESS")->isNull())
         addr = tableValueFacts->getIntValue("ADDRESS") + 1;

      tableValueFacts->clear();
      tableValueFacts->setValue("TYPE", "SC");
      tableValueFacts->setValue("ADDRESS", addr);
      tableValueFacts->setValue("NAME", script.name.c_str());
      tell(eloScript, "Script: Added new script sensor '%s' with address %ld", script.name.c_str(), addr);
      tableValueFacts->store();
   }

   tableValueFacts->clear();
   tableValueFacts->setValue("TYPE", "SC");

   for (bool f = selectValueFactsByType->find(); f; f = selectValueFactsByType->fetch())
   {
      char* scriptPath {};
      asprintf(&scriptPath, "%s/%s", path, tableValueFacts->getStrValue("NAME"));
      long addr {tableValueFacts->getIntValue("ADDRESS")};
      std::string name {tableValueFacts->getStrValue("NAME")};

      // execute script

      sensors["SC"][addr].script = tableValueFacts->getStrValue("SETTINGS");

      const char* arguments {sensors["SC"][addr].script.c_str()};

      tell(eloScript, "Script: Calling %s %s %ld 'mqtt://%s/%s' '%s'", scriptPath, "init", addr, mqttUrlPlain, INSTANCE "2mqtt/scripts", arguments);
      std::string result {executeCommand(2 /*seconds timeout*/, "%s %s %ld 'mqtt://%s/%s' '%s'", scriptPath, "init", addr, mqttUrlPlain, INSTANCE "2mqtt/scripts", arguments)};

      json_t* oData {jsonLoad(result.c_str(), 0, true)};

      // #TODO add a duration check and warn if > 500ms !!
      // char* tmp {};
      // asprintf(&tmp,"Debug: init of script %s:0x%lx", name.c_str(), addr);
      // ld.show(tmp);
      // free(tmp);

      if (!oData)
      {
         if (result.starts_with("Error:"))
            tell(eloAlways, "Script: '%s' failed with [%s]", scriptPath, result.c_str());
         else
            tell(eloAlways, "Script: Error, got invalid JSON from script '%s' [%s]", scriptPath, result.c_str());

         free(scriptPath);
         continue;
      }

      // parsing result to initialize script sensor

      std::string kind = getStringFromJson(oData, "kind", "status");
      const char* title = getStringFromJson(oData, "title");
      const char* unit = getStringFromJson(oData, "unit");
      const char* choices = getStringFromJson(oData, "choices");
      double value = getDoubleFromJson(oData, "value");
      const char* text = getStringFromJson(oData, "text");
      bool valid = getBoolFromJson(oData, "valid", true);
      json_t* jParameter = getObjectFromJson(oData, "parameter");

      if (isEmpty(unit))
      {
         if (kind == "text")
            unit = "";
         else if (kind == "status")
            unit = "zst";
      }

      sensors["SC"][addr].kind = kind;

      if (jParameter)
      {
         char* p = json_dumps(jParameter, 0);
         // don't free it's only a reference onto oData! // json_decref(jParameter);
         tell(eloScript, "Script: parameter: '%s'", p);
         sensors["SC"][addr].parameter = p;
         free(p);
      }

      if (kind == "status" || kind == "trigger")
         sensors["SC"][addr].setState((bool)value);
      else if (kind == "text")
         sensors["SC"][addr].setText(text);
      else
         sensors["SC"][addr].setValue(value);

      if (!valid)
         sensors["SC"][addr].invalidate();    // the script may report invalid data

      sensors["SC"][addr].markStored();       // the init result is only provisional (some scripts report 0 at init),
                                              //  stored is the first 'status' result (updateScriptSensors)

      // NAME is the script file (callScript() runs the script by it), TITLE the title reported
      // by the script or the file name without extension

      auto tuple {split(name, '.')};
      addValueFact(addr, "SC", 1, name.c_str(), unit, !isEmpty(title) ? title : tuple[0].c_str(), urControl, choices, soNone, sensors["SC"][addr].parameter.c_str());

      tell(eloScript, "Script: Found script '%s' addr (%ld), unit '%s'; title '%s', name '%s' result was [%s]", scriptPath, addr, unit, title, name.c_str(), result.c_str());
      free(scriptPath);
      json_decref(oData);
   }

   free(path);

   return success;
}

//***************************************************************************
// Call Script
//***************************************************************************

int HomeCtl::callScript(int addr, const char* command)
{
   if (commandThreads.find(addr) != commandThreads.end())
   {
      if (commandThreads[addr].active)
      {
         tell(eloAlways, "Info: Skipping call of script 'SC:0x%02x', already running, timing out in %ld seconds",
              addr, commandThreads[addr].timeoutAt - time(0));
         return done;
      }
   }

   tableValueFacts->clear();
   tableValueFacts->setValue("TYPE", "SC");
   tableValueFacts->setValue("ADDRESS", addr);

   if (!tableValueFacts->find())
   {
      tell(eloAlways, "Fatal: Script for 'SC:0x%02x' not found", addr);
      return fail;
   }

   char* cmd {};
   const char* arguments {sensors["SC"][addr].script.c_str()};

   asprintf(&cmd, "%s/scripts.d/%s %s %d 'mqtt://%s/%s' '%s'", confDir, tableValueFacts->getStrValue("NAME"),
            command, addr, mqttUrlPlain, INSTANCE "2mqtt/scripts", arguments);

   tell(eloScript, "Script: Calling '%s' ..", cmd);
   int result {executeCommandAsync(addr, cmd)};
   free(cmd);
   tell(eloScript, ".. done");

   tableValueFacts->reset();

   if (result == success && strstr("start|stop|toggle", command))
   {
      sensors["SC"][addr].working = true;

      json_t* ojData {json_object()};
      sensor2Json(ojData, "SC", addr);

      char* tuple {};
      asprintf(&tuple, "%s:0x%02x", "SC", addr);
      jsonSensorList[tuple] = ojData;
      free(tuple);

      pushDataUpdate("update", 0L);
   }

   return result;
}

//***************************************************************************
// Send Command via MQTT
//***************************************************************************

int HomeCtl::switchCommand(std::string type, int addr, std::string action, const char* topic, const char* value)
{
   // prepare command

   json_t* obj {json_object()};
   json_object_set_new(obj, "type", json_string(type.c_str()));
   json_object_set_new(obj, "address", json_integer(addr));

   const char* payload {};

   // TASMOTA devices expect the plain payload ON/OFF/TOGGLE on their command topic
   // (cmnd/<device>/POWERn), the type is chosen by the converter script (e.g. 'BBQ')

   bool tasmota {type == "TASMOTA" || strncmp(topic, "cmnd/", 5) == 0 || strstr(topic, "/cmnd/")};

   if (action == "switch")    // for 'choice' select (actually used at least for VICTRON)
      json_object_set_new(obj, "value", json_string(value ? value : ""));
   else if (tasmota)
      payload = !value ? "TOGGLE" : (atoi(value) ? "ON" : "OFF");
   else
      json_object_set_new(obj, "value", json_integer(value ? atoi(value) : 0));

   // send to command topic

   if (!payload)
   {
      char* message {json_dumps(obj, JSON_REAL_PRECISION(8))};

      tell(eloDebug, "Debug: Send '%s' for '%s:0x%x' to '%s' [%s]", action.c_str(), type.c_str(), addr, topic, message);
      mqttWriter->write(topic, message);
      free(message);
   }

   else
   {
      tell(eloDebug, "Debug: Send '%s' for '%s:0x%x' to '%s' [%s]", action.c_str(), type.c_str(), addr, topic, payload);
      mqttWriter->write(topic, payload);
   }

   json_decref(obj);

   return done;
}

//***************************************************************************
// Value Fact Of
//***************************************************************************

cDbRow* HomeCtl::valueFactRowOf(std::string type, uint addr)
{
   tableValueFacts->clear();
   tableValueFacts->setValue("ADDRESS", (long)addr);
   tableValueFacts->setValue("TYPE", type.c_str());

   if (!tableValueFacts->find())
      return nullptr;

   return tableValueFacts->getRow();
}

//***************************************************************************
// Get Sensor
//***************************************************************************

HomeCtl::SensorData* HomeCtl::getSensor(const char* type, int addr)
{
   if (isEmpty(type))
      return nullptr;

   auto itType = sensors.find(type);

   if (itType == sensors.end())
      return nullptr;

   auto itSensor = itType->second.find(addr);

   if (itSensor == itType->second.end())
      return nullptr;

   return &itSensor->second;
}

//***************************************************************************
// Init/Exit Database
//***************************************************************************

cDbFieldDef xmlTimeDef("XML_TIME", "xmltime", cDBS::ffAscii, 20, cDBS::ftData);
cDbFieldDef rangeFromDef("RANGE_FROM", "rfrom", cDBS::ffDateTime, 0, cDBS::ftData);
cDbFieldDef rangeToDef("RANGE_TO", "rto", cDBS::ffDateTime, 0, cDBS::ftData);
cDbFieldDef avgValueDef("AVG_VALUE", "avalue", cDBS::ffFloat, 122, cDBS::ftData);
cDbFieldDef maxValueDef("MAX_VALUE", "mvalue", cDBS::ffFloat, 122, cDBS::ftData);
cDbFieldDef rangeEndDef("time", "time", cDBS::ffDateTime, 0, cDBS::ftData);

int HomeCtl::initDb()
{
   static bool initial {true};
   int status {success};

   if (connection)
      exitDb();

   tell(eloAlways, "Try conneting to database");

   connection = new cDbConnection();

   if (initial)
   {
      // ------------------------------------------
      // initially create/alter tables and indices
      // ------------------------------------------

      initial = false;
      tell(eloDb, "Checking database connection ...");

      if (connection->attachConnection() != success)
      {
         tell(eloAlways, "Error: Initial database connect failed");
         return fail;
      }

      tell(eloDb, "Checking table structure and indices ...");

      for (auto t = dbDict.getFirstTableIterator(); t != dbDict.getTableEndIterator(); t++)
      {
         cDbTable* table = new cDbTable(connection, t->first.c_str());

         if (strstr(table->TableName(), "information_schema"))
         {
            tell(eloAlways, "Skipping check of table '%s'", t->first.c_str());
            delete table;
            continue;
         }

         tell(eloDb, "Checking table '%s'", t->first.c_str());

         if (!table->exist())
         {
            if ((status += table->createTable()) != success)
            {
               continue;
               delete table;
            }
         }
         else
         {
            status += table->validateStructure();
         }

         status += table->createIndices();

         delete table;
      }

      connection->detachConnection();

      if (status != success)
         return abrt;

      tell(eloDb, "Checking table structure and indices succeeded");
   }

   // ------------------------
   // create/open tables
   // ------------------------

   tableTableStatistics = new cDbTable(connection, "information_schema.TABLES", true /*read-only*/);
   if (tableTableStatistics->open() != success) return fail;

   tableValueFacts = new cDbTable(connection, "valuefacts");
   if (tableValueFacts->open() != success) return fail;

   tableValueTypes = new cDbTable(connection, "valuetypes");
   if (tableValueTypes->open() != success) return fail;

   tableSamples = new cDbTable(connection, "samples");
   if (tableSamples->open() != success) return fail;

   tablePeaks = new cDbTable(connection, "peaks");
   if (tablePeaks->open() != success) return fail;

   tableConfig = new cDbTable(connection, "config");
   if (tableConfig->open() != success) return fail;

   tableSensorAlert = new cDbTable(connection, "sensoralert");
   if (tableSensorAlert->open() != success) return fail;

   tableUsers = new cDbTable(connection, "users");
   if (tableUsers->open() != success) return fail;

   tableGroups = new cDbTable(connection, "groups");
   if (tableGroups->open() != success) return fail;

   tableDashboards = new cDbTable(connection, "dashboards");
   if (tableDashboards->open() != success) return fail;

   tableDashboardWidgets = new cDbTable(connection, "dashboardwidgets");
   if (tableDashboardWidgets->open() != success) return fail;

   tableHaspPages = new cDbTable(connection, "hasppages");
   if (tableHaspPages->open() != success) return fail;

   tableHaspPageWidgets = new cDbTable(connection, "hasppagewidgets");
   if (tableHaspPageWidgets->open() != success) return fail;

   tableGpsTours = new cDbTable(connection, "gpstours");
   if (tableGpsTours->open() != success) return fail;

   tableGpsTourEvents = new cDbTable(connection, "gpstourevents");
   if (tableGpsTourEvents->open() != success) return fail;

   tableActivities = new cDbTable(connection, "activities");
   if (tableActivities->open(1 /*allow alter*/) != success) return fail;

   tableActivityTracks = new cDbTable(connection, "activitytracks");
   if (tableActivityTracks->open() != success) return fail;

   tableSchemaConf = new cDbTable(connection, "schemaconf");
   if (tableSchemaConf->open() != success) return fail;

   tableHomeMatic = new cDbTable(connection, "homematic");
   if (tableHomeMatic->open() != success) return fail;

   tableIoStates = new cDbTable(connection, "iostates");
   if (tableIoStates->open() != success) return fail;

   // prepare statements

   selectTableStatistic = new cDbStatement(tableTableStatistics);

   selectTableStatistic->build("select ");
   selectTableStatistic->bindAllOut();
   selectTableStatistic->build(" from %s where ", tableTableStatistics->TableName());
   selectTableStatistic->bind("SCHEMA", cDBS::bndIn | cDBS::bndSet);
   selectTableStatistic->build(" order by (data_length + index_length) desc");

   status += selectTableStatistic->prepare();

   // ------------------

   selectActiveValueFacts = new cDbStatement(tableValueFacts);

   selectActiveValueFacts->build("select ");
   selectActiveValueFacts->bindAllOut();
   selectActiveValueFacts->build(" from %s where", tableValueFacts->TableName());
   selectActiveValueFacts->build(" state = 'A' or record = 'A'");
   selectActiveValueFacts->build(" order by type, address");

   status += selectActiveValueFacts->prepare();

   // ------------------

   selectValueFactsByType = new cDbStatement(tableValueFacts);

   selectValueFactsByType->build("select ");
   selectValueFactsByType->bindAllOut();
   selectValueFactsByType->build(" from %s where ", tableValueFacts->TableName());
   selectValueFactsByType->bind("TYPE", cDBS::bndIn | cDBS::bndSet);

   status += selectValueFactsByType->prepare();

   // ------------------

   selectValueFactsByTypeAndName = new cDbStatement(tableValueFacts);

   selectValueFactsByTypeAndName->build("select ");
   selectValueFactsByTypeAndName->bindAllOut();
   selectValueFactsByTypeAndName->build(" from %s where ", tableValueFacts->TableName());
   selectValueFactsByTypeAndName->bind("TYPE", cDBS::bndIn | cDBS::bndSet);
   selectValueFactsByTypeAndName->bind("NAME", cDBS::bndIn | cDBS::bndSet, " and ");

   status += selectValueFactsByTypeAndName->prepare();

   // ------------------

   selectMaxValueFactsByType = new cDbStatement(tableValueFacts);

   selectMaxValueFactsByType->build("select ");
   selectMaxValueFactsByType->bind("ADDRESS", cDBS::bndOut, "max(");
   selectMaxValueFactsByType->build(") from %s where ", tableValueFacts->TableName());
   selectMaxValueFactsByType->bind("TYPE", cDBS::bndIn | cDBS::bndSet);

   status += selectMaxValueFactsByType->prepare();

   // ------------------

   selectAllValueTypes = new cDbStatement(tableValueTypes);

   selectAllValueTypes->build("select ");
   selectAllValueTypes->bindAllOut();
   selectAllValueTypes->build(" from %s", tableValueTypes->TableName());

   status += selectAllValueTypes->prepare();

   // ------------------

   selectAllValueFacts = new cDbStatement(tableValueFacts);

   selectAllValueFacts->build("select ");
   selectAllValueFacts->bindAllOut();
   selectAllValueFacts->build(" from %s", tableValueFacts->TableName());

   status += selectAllValueFacts->prepare();

   // ------------------
   // select all config items of this instance (in display order)

   selectAllConfig = new cDbStatement(tableConfig);

   selectAllConfig->build("select ");
   selectAllConfig->bindAllOut();
   selectAllConfig->build(" from %s where ", tableConfig->TableName());
   selectAllConfig->bind("OWNER", cDBS::bndIn | cDBS::bndSet);
   selectAllConfig->build(" order by ord, category, name");

   status += selectAllConfig->prepare();

   // ------------------
   // select all users

   selectAllUser = new cDbStatement(tableUsers);

   selectAllUser->build("select ");
   selectAllUser->bindAllOut();
   selectAllUser->build(" from %s", tableUsers->TableName());

   status += selectAllUser->prepare();

   // ------------------
   // Groups

   selectAllGroups = new cDbStatement(tableGroups);

   selectAllGroups->build("select ");
   selectAllGroups->bindAllOut();
   selectAllGroups->build(" from %s", tableGroups->TableName());

   status += selectAllGroups->prepare();

   // ------------------
   // select max(time) from samples

   selectMaxTime = new cDbStatement(tableSamples);

   selectMaxTime->build("select ");
   selectMaxTime->bind("TIME", cDBS::bndOut, "max(");
   selectMaxTime->build(") from %s", tableSamples->TableName());

   status += selectMaxTime->prepare();

   // ------------------
   // select max(time) of specific sensor from samples

   selectSensorMaxTime = new cDbStatement(tableSamples);

   selectSensorMaxTime->build("select ");
   selectSensorMaxTime->bind("TIME", cDBS::bndOut, "max(");
   selectSensorMaxTime->build(") from %s where ", tableSamples->TableName());
   selectSensorMaxTime->bind("TYPE", cDBS::bndIn | cDBS::bndSet);
   selectSensorMaxTime->bind("ADDRESS", cDBS::bndIn | cDBS::bndSet, " and ");
   selectSensorMaxTime->build(" having max(time) is not null");  // verhindert Rückgabe von NULL statt keiner row

   status += selectSensorMaxTime->prepare();

   // ------------------
   // select samples for chart data
   // ein sample avg / 5 Minuten

   rangeFrom.setField(&rangeFromDef);
   rangeTo.setField(&rangeToDef);
   xmlTime.setField(&xmlTimeDef);
   avgValue.setField(&avgValueDef);
   maxValue.setField(&maxValueDef);
   selectSamplesRange = new cDbStatement(tableSamples);

   selectSamplesRange->build("select ");
   selectSamplesRange->bind("ADDRESS", cDBS::bndOut);
   selectSamplesRange->bind("TYPE", cDBS::bndOut, ", ");
   selectSamplesRange->bindTextFree("date_format(time, '%Y-%m-%dT%H:%i')", &xmlTime, ", ", cDBS::bndOut);
   selectSamplesRange->bindTextFree("avg(value)", &avgValue, ", ", cDBS::bndOut);
   selectSamplesRange->bindTextFree("max(value)", &maxValue, ", ", cDBS::bndOut);
   selectSamplesRange->build(" from %s where ", tableSamples->TableName());
   selectSamplesRange->bind("ADDRESS", cDBS::bndIn | cDBS::bndSet);
   selectSamplesRange->bind("TYPE", cDBS::bndIn | cDBS::bndSet, " and ");
   selectSamplesRange->bindCmp(0, "TIME", &rangeFrom, ">=", " and ");
   selectSamplesRange->bindCmp(0, "TIME", &rangeTo, "<=", " and ");
   selectSamplesRange->build(" group by date(time), ((60/5) * hour(time) + floor(minute(time)/5))");
   selectSamplesRange->build(" order by time");

   status += selectSamplesRange->prepare();

   // ------------------
   // select samples for chart data (for dashboard widget and rage > 15)
   // ein sample avg / Stunde

   selectSamplesRange60 = new cDbStatement(tableSamples);

   selectSamplesRange60->build("select ");
   selectSamplesRange60->bind("ADDRESS", cDBS::bndOut);
   selectSamplesRange60->bind("TYPE", cDBS::bndOut, ", ");
   selectSamplesRange60->bindTextFree("date_format(time, '%Y-%m-%dT%H:%i')", &xmlTime, ", ", cDBS::bndOut);
   selectSamplesRange60->bindTextFree("avg(value)", &avgValue, ", ", cDBS::bndOut);
   selectSamplesRange60->bindTextFree("max(value)", &maxValue, ", ", cDBS::bndOut);
   selectSamplesRange60->build(" from %s where ", tableSamples->TableName());
   selectSamplesRange60->bind("ADDRESS", cDBS::bndIn | cDBS::bndSet);
   selectSamplesRange60->bind("TYPE", cDBS::bndIn | cDBS::bndSet, " and ");
   selectSamplesRange60->bindCmp(0, "TIME", &rangeFrom, ">=", " and ");
   selectSamplesRange60->bindCmp(0, "TIME", &rangeTo, "<=", " and ");
   selectSamplesRange60->build(" group by date(time), ((60/60) * hour(time) + floor(minute(time)/60))");
   selectSamplesRange60->build(" order by time");

   status += selectSamplesRange60->prepare();

   // ------------------
   // select samples for chart data
   // ein sample avg / 360 Minuten (6 Stunden)

   selectSamplesRange360 = new cDbStatement(tableSamples);

   selectSamplesRange360->build("select ");
   selectSamplesRange360->bind("ADDRESS", cDBS::bndOut);
   selectSamplesRange360->bind("TYPE", cDBS::bndOut, ", ");
   selectSamplesRange360->bindTextFree("date_format(time, '%Y-%m-%dT%H:%i')", &xmlTime, ", ", cDBS::bndOut);
   selectSamplesRange360->bindTextFree("avg(value)", &avgValue, ", ", cDBS::bndOut);
   selectSamplesRange360->bindTextFree("max(value)", &maxValue, ", ", cDBS::bndOut);
   selectSamplesRange360->build(" from %s where ", tableSamples->TableName());
   selectSamplesRange360->bind("ADDRESS", cDBS::bndIn | cDBS::bndSet);
   selectSamplesRange360->bind("TYPE", cDBS::bndIn | cDBS::bndSet, " and ");
   selectSamplesRange360->bindCmp(0, "TIME", &rangeFrom, ">=", " and ");
   selectSamplesRange360->bindCmp(0, "TIME", &rangeTo, "<=", " and ");
   selectSamplesRange360->build(" group by date(time), floor(hour(time)/6)");
   selectSamplesRange360->build(" order by time");

   status += selectSamplesRange360->prepare();

   // ------------------
   // select samples for chart data
   // ein sample avg / month

   selectSamplesRangeMonth = new cDbStatement(tableSamples);

   selectSamplesRangeMonth->build("select ");
   selectSamplesRangeMonth->bind("ADDRESS", cDBS::bndOut);
   selectSamplesRangeMonth->bind("TYPE", cDBS::bndOut, ", ");
   selectSamplesRangeMonth->bindTextFree("date_format(time, '%Y-%m')", &xmlTime, ", ", cDBS::bndOut);
   selectSamplesRangeMonth->bindTextFree("avg(value)", &avgValue, ", ", cDBS::bndOut);
   selectSamplesRangeMonth->bindTextFree("max(value)", &maxValue, ", ", cDBS::bndOut);
   selectSamplesRangeMonth->build(" from %s where ", tableSamples->TableName());
   selectSamplesRangeMonth->bind("ADDRESS", cDBS::bndIn | cDBS::bndSet);
   selectSamplesRangeMonth->bind("TYPE", cDBS::bndIn | cDBS::bndSet, " and ");
   selectSamplesRangeMonth->bindCmp(0, "TIME", &rangeFrom, ">=", " and ");
   selectSamplesRangeMonth->bindCmp(0, "TIME", &rangeTo, "<=", " and ");
   selectSamplesRangeMonth->build(" group by year(time), month(time)");
   selectSamplesRangeMonth->build(" order by time");

   status += selectSamplesRangeMonth->prepare();

   // ------------------
   // ein sample (Summe) pro Monat für den Tages 'max Wert'

   // select date_format(time, '%Y-%m'), sum(value) from samples
   //  where type = '?' and address = ?
   //   and time in (select max(time) from samples where
   //     type = 'GROWATT' and address = 53
   //    group by year(time), month(time), day(time)) group by year(time), month(time);

   selectSamplesRangeMonthOfDayMax = new cDbStatement(tableSamples);

   selectSamplesRangeMonthOfDayMax->build("select ");
   selectSamplesRangeMonthOfDayMax->bind("ADDRESS", cDBS::bndOut);
   selectSamplesRangeMonthOfDayMax->bind("TYPE", cDBS::bndOut, ", ");
   selectSamplesRangeMonthOfDayMax->bindTextFree("date_format(time, '%Y-%m')", &xmlTime, ", ", cDBS::bndOut);
   selectSamplesRangeMonthOfDayMax->bindTextFree("sum(value)", &maxValue, ", ", cDBS::bndOut);
   selectSamplesRangeMonthOfDayMax->build(" from %s where ", tableSamples->TableName());
   selectSamplesRangeMonthOfDayMax->bind("ADDRESS", cDBS::bndIn | cDBS::bndSet);
   selectSamplesRangeMonthOfDayMax->bind("TYPE", cDBS::bndIn | cDBS::bndSet, " and ");
   selectSamplesRangeMonthOfDayMax->bindCmp(0, "TIME", &rangeFrom, ">=", " and ");
   selectSamplesRangeMonthOfDayMax->bindCmp(0, "TIME", &rangeTo, "<=", " and ");
   selectSamplesRangeMonthOfDayMax->build(" and time in (select max(time) from %s where ", tableSamples->TableName());
   selectSamplesRangeMonthOfDayMax->bind("ADDRESS", cDBS::bndIn | cDBS::bndSet);
   selectSamplesRangeMonthOfDayMax->bind("TYPE", cDBS::bndIn | cDBS::bndSet, " and ");
   selectSamplesRangeMonthOfDayMax->build(" group by year(time), month(time), day(time))");
   selectSamplesRangeMonthOfDayMax->build(" group by year(time), month(time)");
   selectSamplesRangeMonthOfDayMax->build(" order by time");

   status += selectSamplesRangeMonthOfDayMax->prepare();

   // ------------------

   selectAllIoStates = new cDbStatement(tableIoStates);

   selectAllIoStates->build("select ");
   selectAllIoStates->bindAllOut();
   selectAllIoStates->build(" from %s", tableIoStates->TableName());

   status += selectAllIoStates->prepare();

   // ------------------

   // ------------------

   selectSensorAlerts = new cDbStatement(tableSensorAlert);

   selectSensorAlerts->build("select ");
   selectSensorAlerts->bindAllOut();
   selectSensorAlerts->build(" from %s where state = 'A'", tableSensorAlert->TableName());
   selectSensorAlerts->bind("KIND", cDBS::bndIn | cDBS::bndSet, " and ");

   status += selectSensorAlerts->prepare();

   // ------------------

   selectAllSensorAlerts = new cDbStatement(tableSensorAlert);

   selectAllSensorAlerts->build("select ");
   selectAllSensorAlerts->bindAllOut();
   selectAllSensorAlerts->build(" from %s", tableSensorAlert->TableName());

   status += selectAllSensorAlerts->prepare();

   // ------------------
   // select * from samples      (for alertCheck)
   //    where type = ? and address = ?
   //     and time <= ?
   //     and time > ?

   rangeEnd.setField(&rangeEndDef);

   selectSampleInRange = new cDbStatement(tableSamples);

   selectSampleInRange->build("select ");
   selectSampleInRange->bind("ADDRESS", cDBS::bndOut);
   selectSampleInRange->bind("TYPE", cDBS::bndOut, ", ");
   selectSampleInRange->bind("TIME", cDBS::bndOut, ", ");
   selectSampleInRange->bind("VALUE", cDBS::bndOut, ", ");
   selectSampleInRange->build(" from %s where ", tableSamples->TableName());
   selectSampleInRange->bind("ADDRESS", cDBS::bndIn | cDBS::bndSet);
   selectSampleInRange->bind("TYPE", cDBS::bndIn | cDBS::bndSet, " and ");
   selectSampleInRange->bindCmp(0, &rangeEnd, "<=", " and ");
   selectSampleInRange->bindCmp(0, "TIME", 0, ">", " and ");
   selectSampleInRange->build(" order by time");

   status += selectSampleInRange->prepare();

   // ------------------

   selectDashboards = new cDbStatement(tableDashboards);

   selectDashboards->build("select ");
   selectDashboards->bindAllOut();
   selectDashboards->build(" from %s order by ord", tableDashboards->TableName());

   status += selectDashboards->prepare();

   // ------------------

   selectDashboardById = new cDbStatement(tableDashboards);

   selectDashboardById->build("select ");
   selectDashboardById->bind("ID", cDBS::bndOut);
   selectDashboardById->build(" from %s where ", tableDashboards->TableName());
   selectDashboardById->bind("TITLE", cDBS::bndIn | cDBS::bndSet);

   status += selectDashboardById->prepare();

   // ------------------

   selectDashboardWidgetsFor = new cDbStatement(tableDashboardWidgets);

   selectDashboardWidgetsFor->build("select ");
   selectDashboardWidgetsFor->bindAllOut();
   selectDashboardWidgetsFor->build(" from %s where ", tableDashboardWidgets->TableName());
   selectDashboardWidgetsFor->bind("DASHBOARDID", cDBS::bndIn | cDBS::bndSet);
   selectDashboardWidgetsFor->build(" order by ord");

   status += selectDashboardWidgetsFor->prepare();

   // ------------------

   selectHaspPages = new cDbStatement(tableHaspPages);

   selectHaspPages->build("select ");
   selectHaspPages->bindAllOut();
   selectHaspPages->build(" from %s order by ord", tableHaspPages->TableName());

   status += selectHaspPages->prepare();

   // ------------------
   // all GPS tours, newest first

   selectGpsTours = new cDbStatement(tableGpsTours);

   selectGpsTours->build("select ");
   selectGpsTours->bindAllOut();
   selectGpsTours->build(" from %s order by starttime desc", tableGpsTours->TableName());

   status += selectGpsTours->prepare();

   // the events (fuel, toll, ...) of one tour

   selectGpsTourEvents = new cDbStatement(tableGpsTourEvents);

   selectGpsTourEvents->build("select ");
   selectGpsTourEvents->bindAllOut();
   selectGpsTourEvents->build(" from %s where ", tableGpsTourEvents->TableName());
   selectGpsTourEvents->bind("TOURID", cDBS::bndIn | cDBS::bndSet);
   selectGpsTourEvents->build(" order by time");

   status += selectGpsTourEvents->prepare();

   // all fuel stops (of all tours and the standalone ones) in time order

   selectGpsFuelEvents = new cDbStatement(tableGpsTourEvents);

   selectGpsFuelEvents->build("select ");
   selectGpsFuelEvents->bindAllOut();
   selectGpsFuelEvents->build(" from %s where type = 'fuel' order by time", tableGpsTourEvents->TableName());

   status += selectGpsFuelEvents->prepare();

   // ------------------
   // Garmin activities, newest first

   selectActivities = new cDbStatement(tableActivities);

   selectActivities->build("select ");
   selectActivities->bindAllOut();
   selectActivities->build(" from %s order by starttime desc", tableActivities->TableName());

   status += selectActivities->prepare();

   // the activities with a stored track (cache flag in the list)

   selectActivityTrackIds = new cDbStatement(tableActivityTracks);

   selectActivityTrackIds->build("select ");
   selectActivityTrackIds->bind("GARMINID", cDBS::bndOut);
   selectActivityTrackIds->build(" from %s where track is not null and track <> ''", tableActivityTracks->TableName());

   status += selectActivityTrackIds->prepare();

   // ------------------
   // recorded GPS points (tour samples GPS:0x0a, aggregate 'T') of a time range

   gpsTourFrom.setField(tableSamples->getField("TIME"));
   gpsTourTo.setField(tableSamples->getField("TIME"));

   selectGpsTourSamples = new cDbStatement(tableSamples);

   selectGpsTourSamples->build("select ");
   selectGpsTourSamples->bind("TIME", cDBS::bndOut);
   selectGpsTourSamples->bind("TEXT", cDBS::bndOut, ", ");
   selectGpsTourSamples->build(" from %s where ", tableSamples->TableName());
   selectGpsTourSamples->bind("ADDRESS", cDBS::bndIn | cDBS::bndSet);
   selectGpsTourSamples->bind("TYPE", cDBS::bndIn | cDBS::bndSet, " and ");
   selectGpsTourSamples->bind("AGGREGATE", cDBS::bndIn | cDBS::bndSet, " and ");
   selectGpsTourSamples->bindCmp(0, "TIME", &gpsTourFrom, ">=", " and ");
   selectGpsTourSamples->bindCmp(0, "TIME", &gpsTourTo, "<=", " and ");
   selectGpsTourSamples->build(" order by time");

   status += selectGpsTourSamples->prepare();

   // ------------------

   selectHaspPageWidgetsFor = new cDbStatement(tableHaspPageWidgets);

   selectHaspPageWidgetsFor->build("select ");
   selectHaspPageWidgetsFor->bindAllOut();
   selectHaspPageWidgetsFor->build(" from %s where ", tableHaspPageWidgets->TableName());
   selectHaspPageWidgetsFor->bind("PAGEID", cDBS::bndIn | cDBS::bndSet);
   selectHaspPageWidgetsFor->build(" order by pos");

   status += selectHaspPageWidgetsFor->prepare();

   // ------------------

   selectSchemaConfByState = new cDbStatement(tableSchemaConf);

   selectSchemaConfByState->build("select ");
   selectSchemaConfByState->bindAllOut();
   selectSchemaConfByState->build(" from %s where ", tableSchemaConf->TableName());
   selectSchemaConfByState->bind("STATE", cDBS::bndIn | cDBS::bndSet);

   status += selectSchemaConfByState->prepare();

   // ------------------

   selectAllSchemaConf = new cDbStatement(tableSchemaConf);

   selectAllSchemaConf->build("select ");
   selectAllSchemaConf->bindAllOut();
   selectAllSchemaConf->build(" from %s", tableSchemaConf->TableName());

   status += selectAllSchemaConf->prepare();

   // ------------------

   if (status == success)
      tell(eloDb, "Connection to database established");

   int gCount {0};

   if (connection->query(gCount, "select * from groups") == success)
   {
      if (!gCount)
      {
         connection->query("insert into groups set name='Heizung'");
         connection->query("update valuefacts set groupid = 1 where groupid is null or groupid = 0");
      }
   }

   // ------------------

   selectHomeMaticByUuid = new cDbStatement(tableHomeMatic);

   selectHomeMaticByUuid->build("select ");
   selectHomeMaticByUuid->bindAllOut();
   selectHomeMaticByUuid->build(" from %s where ", tableHomeMatic->TableName());
   selectHomeMaticByUuid->bind("UUID", cDBS::bndIn | cDBS::bndSet);

   status += selectHomeMaticByUuid->prepare();

   /*
   // patch dashboars widget options to default (once)
   tableDashboardWidgets->clear();
   tableDashboardWidgets->setValue("DASHBOARDID", 5);
   for (bool f = selectDashboardWidgetsFor->find(); f; f = selectDashboardWidgetsFor->fetch())
   {
      if (tableDashboardWidgets->hasValue("TYPE", "DZL"))
      {
         tableValueFacts->clear();
         tableValueFacts->setValue("TYPE", tableDashboardWidgets->getStrValue("TYPE"));
         tableValueFacts->setValue("ADDRESS", tableDashboardWidgets->getIntValue("ADDRESS"));

         if (tableValueFacts->find())
         {
            json_t* jDefaults {json_object()};
            widgetDefaults2Json(jDefaults, tableValueFacts->getStrValue("TYPE"),
                                tableValueFacts->getStrValue("UNIT"), "",
                                tableValueFacts->getIntValue("ADDRESS"));
            char* opts = json_dumps(jDefaults, JSON_REAL_PRECISION(4));
            tell(eloAlways, "PATCH: %s/%ld to '%s'", tableValueFacts->getStrValue("TYPE"), tableValueFacts->getIntValue("ADDRESS"), opts);
            tableDashboardWidgets->setValue("WIDGETOPTS", opts);
            tableDashboardWidgets->store();
            free(opts);
            json_decref(jDefaults);
         }
         tableValueFacts->reset();
      }
   }
   selectDashboardWidgetsFor->freeResult();
   */

   int count {0};

   // -------------------
   // init table valuetypes - if emty

   count = 0;
   tableValueTypes->countWhere("1=1", count);

   if (!count)
   {
      tableValueFacts->clear();

      for (bool f = selectAllValueFacts->find(); f; f = selectAllValueFacts->fetch())
      {
         tableValueTypes->clear();
         tableValueTypes->setValue("TYPE", tableValueFacts->getStrValue("TYPE"));

         if (!tableValueTypes->find())
         {
            tableValueTypes->setValue("TITLE", getTitleOfType(tableValueFacts->getStrValue("TYPE")));
            tableValueTypes->store();
         }
      }

      selectAllValueFacts->freeResult();
   }

   // -------------------
   // create at least one dashboard

   count = 0;
   tableDashboards->countWhere("1=1", count);

   if (!count)
   {
      tell(eloInfo, "Starting with empty dashboard");
      tableDashboards->setValue("TITLE", "");
      tableDashboards->setValue("SYMBOL", "mdi:mdi-home");
      tableDashboards->store();
   }

   return status;
}

int HomeCtl::exitDb()
{
   delete tableTableStatistics;    tableTableStatistics = nullptr;
   delete tableSamples;            tableSamples = nullptr;
   delete tablePeaks;              tablePeaks = nullptr;
   delete tableValueFacts;         tableValueFacts = nullptr;
   delete tableValueTypes;         tableValueTypes = nullptr;
   delete tableConfig;             tableConfig = nullptr;
   delete tableUsers;              tableUsers = nullptr;
   delete tableGroups;             tableGroups = nullptr;
   delete tableSensorAlert;        tableSensorAlert = nullptr;
   delete tableDashboards;         tableDashboards = nullptr;
   delete tableDashboardWidgets;   tableDashboardWidgets = nullptr;
   delete tableSchemaConf;         tableSchemaConf = nullptr;
   delete tableHomeMatic;          tableHomeMatic = nullptr;
   delete tableIoStates;           tableIoStates = nullptr;

   delete selectTableStatistic;    selectTableStatistic = nullptr;
   delete selectAllGroups;         selectAllGroups = nullptr;
   delete selectActiveValueFacts;  selectActiveValueFacts = nullptr;
   delete selectValueFactsByType;  selectValueFactsByType = nullptr;
   delete selectMaxValueFactsByType;     selectMaxValueFactsByType = nullptr;
   delete selectValueFactsByTypeAndName; selectValueFactsByTypeAndName = nullptr;
   delete selectAllValueFacts;     selectAllValueFacts = nullptr;
   delete selectAllValueTypes;     selectAllValueTypes = nullptr;
   delete selectAllConfig;         selectAllConfig = nullptr;
   delete selectAllUser;           selectAllUser = nullptr;
   delete selectMaxTime;           selectMaxTime = nullptr;
   delete selectSensorMaxTime;     selectSensorMaxTime = nullptr;
   delete selectSamplesRange;      selectSamplesRange = nullptr;
   delete selectSamplesRange60;    selectSamplesRange60 = nullptr;
   delete selectSamplesRange360;   selectSamplesRange360 = nullptr;
   delete selectSamplesRangeMonth; selectSamplesRangeMonth = nullptr;
   delete selectSamplesRangeMonthOfDayMax; selectSamplesRangeMonthOfDayMax = nullptr;
   delete selectSampleInRange;     selectSampleInRange = nullptr;
   delete selectSensorAlerts;      selectSensorAlerts = nullptr;
   delete selectAllIoStates;       selectAllIoStates = nullptr;
   delete selectAllSensorAlerts;   selectAllSensorAlerts = nullptr;
   delete selectDashboards;        selectDashboards = nullptr;
   delete selectDashboardById;     selectDashboardById = nullptr;
   delete selectSchemaConfByState; selectSchemaConfByState = nullptr;
   delete selectAllSchemaConf;     selectAllSchemaConf = nullptr;
   delete selectHomeMaticByUuid;   selectHomeMaticByUuid = nullptr;
   delete selectDashboardWidgetsFor; selectDashboardWidgetsFor = nullptr;
   delete selectHaspPages;         selectHaspPages = nullptr;
   delete selectHaspPageWidgetsFor; selectHaspPageWidgetsFor = nullptr;
   delete selectGpsTours;          selectGpsTours = nullptr;
   delete selectGpsTourEvents;     selectGpsTourEvents = nullptr;
   delete selectGpsFuelEvents;     selectGpsFuelEvents = nullptr;
   delete tableGpsTourEvents;      tableGpsTourEvents = nullptr;
   delete selectGpsTourSamples;    selectGpsTourSamples = nullptr;
   delete tableGpsTours;           tableGpsTours = nullptr;
   delete selectActivities;        selectActivities = nullptr;
   delete selectActivityTrackIds;  selectActivityTrackIds = nullptr;
   delete tableActivities;         tableActivities = nullptr;
   delete tableActivityTracks;     tableActivityTracks = nullptr;

   delete connection;              connection = nullptr;

   return done;
}

//***************************************************************************
// Read Configuration
//***************************************************************************

int HomeCtl::readConfiguration(bool initial)
{
   // init configuration

   if (argEloquence != eloAlways)
   {
      eloquence = argEloquence;
      argEloquence = eloAlways;
   }
   else
   {
      std::string elo;
      getConfigItem("eloquence", elo, "");
      eloquence = Elo::stringToEloquence(elo.c_str());
      tell(eloDetail, "Info: Eloquence configured to '%s' => 0x%04x", elo.c_str(), eloquence);
   }

   tell(eloAlways, "Info: Eloquence set to 0x%04x (%d)", eloquence, eloquence);

   getConfigItem("interval", interval, interval);
   getConfigItem("arduinoInterval", arduinoInterval, arduinoInterval);
   getConfigItem("webPort", webPort, webPort);
   getConfigItem("webUrl", webUrl);
   getConfigItem("webSsl", webSsl);
   getConfigItem("iconSet", iconSet, "light");
   getConfigItem("windyAppSpotID", windyAppSpotID, "5247411");
   getConfigItem("windyAppID", windyAppID, "");
   comboHistoryAdd("windyAppSpotID", windyAppSpotID.c_str());     // the current spot is a suggestion from the start

   std::string tmp;
   getConfigItem("schema", tmp);

   char* port {};
   asprintf(&port, "%d", webPort);

   if (webUrl.empty() || !strstr(webUrl.c_str(), port))
   {
      char* tmp {};
      asprintf(&tmp, "http%s://%s:%d", webSsl ? "s" : "", getFirstIp(), webPort);
      webUrl = tmp;
      free(tmp);
      setConfigItem("webUrl", webUrl.c_str());
   }
   free(port);

   std::string addrs;
   getConfigItem("addrsDashboard", addrs, "");
   addrsDashboard = split(addrs.c_str(), ',');

   getConfigItem("mail", sendMails, no);
   getConfigItem("mailScript", mailScript);
   getConfigItem("stateMailTo", stateMailTo);
   getConfigItem("errorMailTo", errorMailTo);

   getConfigItem("aggregateInterval", aggregateInterval);
   getConfigItem("aggregateHistory", aggregateHistory);

   getConfigItem("gpsTourMinDistance", gpsTourMinDistance, 25);
   getConfigItem("gpsTourPauseAfter", gpsTourPauseAfter, 5);
   getConfigItem("gpsTourPauseRadius", gpsTourPauseRadius, 200);
   getConfigItem("gpsTourEndTolerance", gpsTourEndTolerance, 200);
   getConfigItem("garminTrackDeviation", garminTrackDeviation, 50);

   {
      int staticHold {gpsUbloxStaticHold};
      bool automotive {gpsUbloxAutomotive};
      bool galileo {gpsUbloxGalileo};

      getConfigItem("gpsUbloxStaticHold", gpsUbloxStaticHold, 0);
      getConfigItem("gpsUbloxAutomotive", gpsUbloxAutomotive, false);
      getConfigItem("gpsUbloxGalileo", gpsUbloxGalileo, false);

      if (!initial && (staticHold != gpsUbloxStaticHold || automotive != gpsUbloxAutomotive || galileo != gpsUbloxGalileo))
         gpsReceiverPublishConfig();
   }

   // DECONZ

   std::string deconzUrl;
   getConfigItem("deconzHttpUrl", deconzUrl, "");

   if (!deconzUrl.empty())
   {
      deconz.setHttpUrl(deconzUrl.c_str());
      std::string deconzKey;
      getConfigItem("deconzApiKey", deconzKey, "");

      if (!deconzKey.empty())
         deconz.setApiKey(deconzKey.c_str());
   }

   getConfigItem("instanceName", instanceName);

   // location

   getConfigItem("latitude", latitude);
   getConfigItem("longitude", longitude);
   getConfigItem("gpsLocation", gpsLocation, false);

   if (!initial)
      sunUpdate(true);

   // OpenWeatherMap

   getConfigItem("weatherInterval", weatherInterval, weatherInterval);

   std::string apiKey {!openWeatherApiKey.empty() ? openWeatherApiKey : ""};
   getConfigItem("openWeatherApiKey", openWeatherApiKey);

   if (!openWeatherApiKey.empty() && openWeatherApiKey != apiKey)
      updateWeather();

   bool hmInterface {homeMaticInterface};
   std::string hmBridge {homeMaticBridge}, hmTopic {homeMaticTopic};
   getConfigItem("homeMaticInterface", homeMaticInterface, false);
   getConfigItem("homeMaticBridge", homeMaticBridge, "Node-RED");
   getConfigItem("homeMaticTopic", homeMaticTopic, "homematic");

   // MQTT

   getConfigItem("mqttUser", mqttUser, mqttUser.c_str());
   getConfigItem("mqttPassword", mqttPassword, mqttPassword.c_str());

   std::string url {mqttUrl};
   getConfigItem("mqttUrl", mqttUrl);
   free(mqttUrlPlain);
   mqttUrlPlain = strdup(strrchr(mqttUrl.c_str(), '/') ? strrchr(mqttUrl.c_str(), '/')+1 : mqttUrl.c_str());

   std::string sTopics {sensorTopics};
   std::string hTopic {haspMqttTopic};
   getConfigItem("mqttSensorTopics", sensorTopics, "+/w1/#");
   mqttSensorTopics = split(sensorTopics, ',');
   mqttSensorTopics.push_back(INSTANCE "2mqtt/ping/#");
   mqttSensorTopics.push_back(INSTANCE "2mqtt/light/+/set/#");
   mqttSensorTopics.push_back(INSTANCE "2mqtt/command/#");
   mqttSensorTopics.push_back(INSTANCE "2mqtt/nodered/#");
   mqttSensorTopics.push_back(INSTANCE "2mqtt/scripts/#");

   getConfigItem("haspMqttTopic", haspMqttTopic, "hasp/plates");

   if (!haspMqttTopic.empty())
   {
      mqttSensorTopics.push_back("hasp/+/LWT");       // openHASP panel online/offline -> resend pages
      mqttSensorTopics.push_back("hasp/+/state/+");   // touch events of the panel objects
   }

   if (homeMaticViaService())
   {
      tell(eloAlways, "Adding homematic topics of the service hmmqtt ('%s')", homeMaticTopic.c_str());

      for (const char* sub : { "/status", "/devices", "/state/#", "/pairing", "/event/#" })
         mqttSensorTopics.push_back(homeMaticTopic + sub);
   }
   else if (homeMaticInterface)
   {
      tell(eloAlways, "Adding homematic topics");
      mqttSensorTopics.push_back(INSTANCE "2mqtt/homematic/rpcresult");
      mqttSensorTopics.push_back(INSTANCE "2mqtt/homematic/events");
   }

   if (url != mqttUrl || sTopics != sensorTopics || hTopic != haspMqttTopic ||
       hmInterface != homeMaticInterface || hmBridge != homeMaticBridge || hmTopic != homeMaticTopic)
   {
      tell(eloAlways, "Config of MQTT url or subscribtions changed, reconnect");
      mqttDisconnect();
   }

   getConfigItem("arduinoTopic", arduinoTopic, "");

   if (!arduinoTopic.empty())
      mqttSensorTopics.push_back(std::string(arduinoTopic) + "/out");

   getConfigItem("lmcHost", lmcHost, "");
   getConfigItem("lmcPort", lmcPort, 9090);
   getConfigItem("lmcPlayerMac", lmcPlayerMac, "");

   // Home Automation MQTT

   getConfigItem("mqttHaDataTopic", mqttHaDataTopic, INSTANCE "2mqtt/<TYPE>/<NAME>/state");
   getConfigItem("mqttHaSendWithKeyPrefix", mqttHaSendWithKeyPrefix, "");
   getConfigItem("mqttHaHaveConfigTopic", mqttHaHaveConfigTopic, false);

   mqttHaInterfaceStyle = misNone;

   if (!mqttHaDataTopic.empty() && !mqttUrl.empty())
   {
      if (mqttHaDataTopic[mqttHaDataTopic.length()-1] == '/')
         mqttHaDataTopic[mqttHaDataTopic.length()-1] = '\0';

      if (strstr(mqttHaDataTopic.c_str(), "<NAME>"))
         mqttHaInterfaceStyle = misMultiTopic;
      else if (strstr(mqttHaDataTopic.c_str(), "<GROUP>"))
         mqttHaInterfaceStyle = misGroupedTopic;
      else
         mqttHaInterfaceStyle = misSingleTopic;

      std::string styleName = "None";

      if (mqttHaInterfaceStyle == misMultiTopic)
         styleName = "MultiTopic";
      else if (mqttHaInterfaceStyle == misGroupedTopic)
         styleName = "GroupedTopic";
      else if (mqttHaInterfaceStyle == misSingleTopic)
         styleName = "SingleTopic";

      tell(eloAlways, "MQTT interface style set to '%s' for [%s]", styleName.c_str(), mqttHaDataTopic.c_str());
   }

   for (bool f = selectAllGroups->find(); f; f = selectAllGroups->fetch())
      groups[tableGroups->getIntValue("ID")].name = tableGroups->getStrValue("NAME");

   selectAllGroups->freeResult();

   return done;
}

//***************************************************************************
// Do Sleep
//***************************************************************************

void HomeCtl::doSleep(int t)
{
   time_t end = time(0) + t;

   while (time(0) < end && !doShutDown())
      usleep(5000);
}

//***************************************************************************
// standby
//***************************************************************************

int HomeCtl::standby(int t)
{
   time_t end = time(0) + t;

   while (time(0) < end && !doShutDown())
   {
      meanwhile();
      usleep(5000);
   }

   return done;
}

int HomeCtl::standbyUntil()
{
   while (time(0) < nextRefreshAt && !doShutDown())
   {
      meanwhile();
      usleep(5000);
   }

   return done;
}

//***************************************************************************
// Meanwhile
//***************************************************************************

int HomeCtl::meanwhile()
{
   static time_t lastPingAt {0};
   static uint64_t nextProcessMs {0};

   if (!initialized)
      return done;

   if (!connection || !connection->isConnected())
      return fail;

   if (lastPingAt+2 <= time(0))
   {
      lastPingAt = time(0);
      json_t* oJson {json_object()};
      pushOutMessage(oJson, "ping", 0);
   }

   tell(eloDebug2, "loop ...");

   atMeanwhile();

   while (!triggerGpioPins.empty())
   {
      gpioRead(triggerGpioPins.front());
      triggerGpioPins.pop();
   }

   dispatchClientRequest();
   dispatchDeconz();
   performLightRules();
   homeMaticCheckRequests();
   performMqttRequests();
   performJobs();
   performLmcUpdates();
   // updateInputs();

   if (valueFactsChanged)
   {
      valueFactsChanged = false;
      json_t* oJson {json_object()};
      valueFacts2Json(oJson, false);
      pushOutMessage(oJson, "valuefacts");
   }

   if ((triggerProcess || luaEveryDue()) && nextProcessMs <= cTimeMs::Now())
   {
      process();
      nextProcessMs = cTimeMs::Now() + 500;
   }

   return done;
}

//***************************************************************************
// Loop
//***************************************************************************

int HomeCtl::loop()
{
   tell(eloAlways, "%s started", TARGET);

   scheduleAggregate();

   while (!doShutDown())
   {
      // check db connection

      while (!doShutDown() && (!connection || !connection->isConnected()))
      {
         if (initDb() == success)
            break;

         exitDb();
         tell(eloAlways, "Retrying in 10 seconds");
         standby(10);
      }

      if (doShutDown())
         break;

      standbyUntil();

      if (doLoop() != success)
         continue;

      // refresh expected?

      if (time(0) < nextRefreshAt)
         continue;

      nextRefreshAt = time(0) + interval;
      uint64_t loopDuration {0};

      {
         LogDuration ld("loop total", eloLoopTimings);

         // aggregate

         if (aggregateHistory && nextAggregateAt <= time(0))
         {
            LogDuration ld("aggregate", eloLoopTimings);
            aggregate();
         }

         {
            LogDuration ld("updateWeather", eloLoopTimings);
            updateWeather();
         }

         sunUpdate();

         {
            LogDuration ld("updateSensors", eloLoopTimings);
            updateSensors();  // update some sensors for wich we get no trigger
         }

         performData(0L);
         haspPublishAllValues();   // openHASP panel: publish changed values (no-op without configured pages)
         gpsTourCheckPause(time(0));

         {
            LogDuration ld("updateScriptSensors", eloLoopTimings);
            updateScriptSensors();
         }

         {
            LogDuration ld("process", eloLoopTimings);
            process();     // time ranges of the DO sensors; the LUA scripts run by their watch() / every()
         }

         shadeUpdate();    // shading of the blinds

         {
            LogDuration ld("storeSamples", eloLoopTimings);
            storeSamples();
         }

         {
            LogDuration ld("updateInputs", eloLoopTimings);
            updateInputs();
         }

         {
            LogDuration ld("afterUpdate", eloLoopTimings);
            afterUpdate();
         }

         loopDuration = ld.getDuration();
      }

      if (loopDuration > (uint)(interval*1000))
         tell(eloAlways, "Warning: The duration of the main loop takes %jxms longer than the configured "
              "interval of %d seconds, as a result, the web interface responds slowly or not at all.",
              loopDuration, interval);

      initialRun = false;
   }

   return success;
}

//***************************************************************************
// Update Inputs
//***************************************************************************

int HomeCtl::updateInputs(bool check)
{
   static time_t nextInputCheckAt {0};

   if (time(0) < nextInputCheckAt)
      return done;

   nextInputCheckAt = time(0) + 5;

   for (const auto& s : sensors["DI"])
   {
      if (s.second.active)
      {
         bool state {gpioRead(s.first, check)};
         tell(eloDebugGpio, "Debug: GPIO: updateInputs(%d) DI 0x%x (%d)", check, s.first, state);
      }
   }

   for (const auto& s : sensors["GPIO"])
   {
      if (s.second.fct == "in" && s.second.active)
      {
         bool state {gpioRead(s.first, check)};
         tell(eloDebugGpio, "Debug: GPIO: updateInputs(%d) GPIO 0x%x (%d)", check, s.first, state);
      }
   }

   return done;
}

//***************************************************************************
// Store Samples
//***************************************************************************

int HomeCtl::storeSamples()
{
   int count {0};
   int skipped {0};

   lastSampleTime = time(0);
   tell(eloDebug, "Debug: Store samples ..");
   connection->startTransaction();

   if (mqttHaInterfaceStyle == misSingleTopic)
       oHaJson = json_object();

   for (auto& typeSensorsIt : sensors)
   {
      for (auto& sensorIt : typeSensorsIt.second)
      {
         SensorData* sensor = &sensorIt.second;

         if (sensor->type == "WEA")
            continue;

         // the coordinates of an active GPS tour are stored by gpsTourUpdate() on movement

         if (gpsTour.id && sensor->type == "GPS" && sensor->address == gpsCoordinateAddress)
            continue;

         if (storable(sensor) != success)
         {
            if (sensor->record)
               skipped++;

            continue;
         }

         // the IO state (restore of the last data at start) and the peaks are maintained
         // for all sensors, the sample only with recording

         storeIoState(sensor->type.c_str(), sensor->address);
         storePeaks(lastSampleTime, sensor);

         if (sensor->record)
         {
            store(lastSampleTime, sensor);
            count++;
         }

         sensor->markStored();
      }
   }

   connection->commit();
   tell(eloInfo, "Stored %d samples, skipped %d", count, skipped);

   return success;
}

//***************************************************************************
// Storable - has the sensor new, valid data to be stored?
//***************************************************************************

int HomeCtl::storable(const SensorData* sensor)
{
   if (!sensor->type.length())
   {
      tell(eloDebug, "Debug: Missing type of '%s:0x%02x' (%s)",
           sensor->type.c_str(), sensor->address, sensor->name.c_str());
      return ignore;
   }

   if (sensor->disabled)
   {
      tell(eloDebug, "Debug: Sensor of '%s:0x%02x' (%s) disabled",
           sensor->type.c_str(), sensor->address, sensor->name.c_str());
      return ignore;
   }

   if (isNan(sensor->value))
   {
      tell(eloAlways, "Warning: Data of '%s:0x%02x' (%s) is NaN, skipping store",
           sensor->type.c_str(), sensor->address, sensor->name.c_str());
      return ignore;
   }

   if (!sensor->last())
   {
      tell(eloDebug, "Debug: Missing data stamp of '%s:0x%02x' (%s), skipping store",
           sensor->type.c_str(), sensor->address, sensor->name.c_str());
      return ignore;
   }

   if (!sensor->unstored())
   {
      tell(eloDebug, "Debug: No new data for '%s:0x%02x' (%s) since the last store, skipping store (%s)",
           sensor->type.c_str(), sensor->address, sensor->name.c_str(), l2pTime(sensor->last()).c_str());
      return ignore;
   }

   if (!sensor->valid())
   {
      tell(eloDebug, "Debug: Data of '%s:0x%02x' (%s) is invalid, skipping store",
           sensor->type.c_str(), sensor->address, sensor->name.c_str());
      return ignore;
   }

   return success;
}

//***************************************************************************
// Store - the sample (check storable() before, IO state and peaks are stored by the caller)
//***************************************************************************

int HomeCtl::store(time_t now, const SensorData* sensor)
{
   tableSamples->clear();

   tableSamples->setValue("TIME", now);
   tableSamples->setValue("ADDRESS", (long)sensor->address);
   tableSamples->setValue("TYPE", sensor->type.c_str());
   tableSamples->setValue("AGGREGATE", "S");
   tableSamples->setValue("SAMPLES", 1);

   if (sensor->kind == "status")
      tableSamples->setValue("VALUE", (double)sensor->state);
   else if (sensor->kind == "value")
      tableSamples->setValue("VALUE", sensor->value);

   // send text if set, independent of 'kind'

   if (sensor->text != "")
      tableSamples->setValue("TEXT", sensor->text.c_str());

   tableSamples->store();

   return success;
}

//***************************************************************************
// Store Peaks
//***************************************************************************

int HomeCtl::storePeaks(time_t now, const SensorData* sensor)
{
   tablePeaks->clear();

   tablePeaks->setValue("ADDRESS", (long)sensor->address);
   tablePeaks->setValue("TYPE", sensor->type.c_str());

   if (!tablePeaks->find())
   {
      tablePeaks->setValue("MIN", sensor->value);
      tablePeaks->setValue("MAX", sensor->value);
      tablePeaks->setValue("TIMEMIN", now);
      tablePeaks->setValue("TIMEMAX", now);
      tablePeaks->store();
   }
   else
   {
      tablePeaks->clearChanged();

      if (sensor->value > tablePeaks->getFloatValue("MAX"))
      {
         tablePeaks->setValue("MAX", sensor->value);
         tablePeaks->setValue("TIMEMAX", now);
      }

      if (sensor->value < tablePeaks->getFloatValue("MIN"))
      {
         tablePeaks->setValue("MIN", sensor->value);
         tablePeaks->setValue("TIMEMIN", now);
      }

      if (tablePeaks->getChanges())
         tablePeaks->store();
   }

   return success;
}

//***************************************************************************
// Process
//***************************************************************************

int HomeCtl::process(bool force, bool signal)
{
   // Zeitschaltuhr

   // actors (deCONZ lights, HomeMatic blinds) switch only at the limits of their time ranges,
   //  the actions are collected and done after the loop (toggleIo() uses tableValueFacts)

   time_t now {time(0)};
   time_t checkedAt {actorTimesCheckedAt};
   std::vector<ActorTimeAction> actorActions;

   actorTimesCheckedAt = now;

   if (now - checkedAt > 15 * tmeSecondsPerMinute)
      checkedAt = now;           // start or stalled for a long time - limits in the past are not caught up

   for (bool f = selectActiveValueFacts->find(); f; f = selectActiveValueFacts->fetch())
   {
      std::string type {tableValueFacts->getStrValue("TYPE")};
      ulong address {(ulong)tableValueFacts->getIntValue("ADDRESS")};
      bool gpioOut {type == "GPIO" && sensors[type][address].fct == "out"};

      if (type == "DZL" || type == "DZLG" || type == "HMB")
      {
         if (sensors[type][address].active && checkedAt < now && !tableValueFacts->getValue("SETTINGS")->isEmpty())
         {
            json_t* o {jsonLoad(tableValueFacts->getStrValue("SETTINGS"), 0, true)};

            if (o)
            {
               actorTimesDue(type.c_str(), address, o, checkedAt, now, actorActions);
               json_decref(o);
            }
         }

         continue;
      }

      if (!sensors[type][address].active || sensors[type][address].mode != omAuto)
         continue;

      if (type != "DO" && !gpioOut)
         continue;

      // output is 'pseudo validated' (stored every cycle)

      sensors[type][address].touch();

      bool activate {false};
      bool hasRanges {false}; // 1. Flag hinzufügen, um zu tracken ob wir schalten dürfen

      if (!tableValueFacts->getValue("SETTINGS")->isEmpty())
      {
         json_t* o {jsonLoad(tableValueFacts->getStrValue("SETTINGS"), 0, true)};

         if (!o)
            continue;

         json_t* jTimes {getObjectFromJson(o, "times")};

         if (jTimes && json_is_array(jTimes))
         {
            std::vector<Range> currentRanges;
            size_t index {0};
            json_t* value {};

            json_array_foreach(jTimes, index, value)
            {
               // start / end: "HH:MM" or dawn|sunrise|sunset|dusk, each with an optional offset [minutes]

               Range r;

               if (sunResolve(getStringFromJson(value, "start"), getIntFromJson(value, "startOffset", 0), r.from) == success &&
                   sunResolve(getStringFromJson(value, "end"), getIntFromJson(value, "endOffset", 0), r.to) == success)
               {
                  // optional valid on some days only, the morning part of a range over midnight belongs to the day before

                  bool morningPart {r.from > r.to && (uint)l2hhmm(now) < r.to};

                  if (rangeDateValid(value, morningPart ? midnightOf(now) - 1 : now))
                     currentRanges.push_back(r);
               }
            }

            if (!currentRanges.empty())
            {
               activate = isInTimeRange(&currentRanges, time(0));
               hasRanges = true;
            }
         }

         json_decref(o);
      }

      // no times configured?

      if (!hasRanges)
         continue;

      // changed?

      if (sensors[type][address].state != activate)
         gpioWrite(address, activate);
   }

   for (const auto& action : actorActions)
      actorTimeAction(action);

   return processLua(force, signal);
}

//***************************************************************************
// Process LUA
//***************************************************************************

// is a periodic run requested by every() of a script due? (the main loop calls process() then)

bool HomeCtl::luaEveryDue()
{
   for (const auto& [key, seconds] : luaEvery)
      if (time(0) - luaLastRun[key] >= seconds)
         return true;

   return false;
}

int HomeCtl::processLua(bool force, bool signal)
{
   // calculate CV and DO/GPIO(out) sensors by LUA

   if (!initialized)         // the GPIO setup triggers process() before the LUA bindings (watch, every, sensors) exist
      return done;

   for (bool f = selectActiveValueFacts->find(); f; f = selectActiveValueFacts->fetch())
   {
      std::string type {tableValueFacts->getStrValue("TYPE")};
      ulong address {(ulong)tableValueFacts->getIntValue("ADDRESS")};
      bool gpioOut {type == "GPIO" && sensors[type][address].fct == "out"};

      if (!sensors[type][address].active)
         continue;

      if (type != "CV" && type != "DO" && !gpioOut)
         continue;

      if ((gpioOut || type == "DO") && sensors[type][address].mode != omAuto)
         continue;

      std::string expression;

      if (type == "CV")
      {
         if (!tableValueFacts->getValue("SETTINGS")->isEmpty())
         {
            json_t* o {jsonLoad(tableValueFacts->getStrValue("SETTINGS"), 0, true)};

            if (!o)
               continue;

            expression = getStringFromJson(o, "lua", "");
            json_decref(o);
         }
      }
      else
         expression = sensors[type][address].script;

      if (expression.empty())
         continue;

      char* key {};
      asprintf(&key, "%s:0x%02lx", type.c_str(), address);

      tell(eloLua, "LUA: Processing '%s'", key);

      if (!sensors[type][address].last())
         getConfigItem(key, sensors[type][address].value, 0);

      luaCurrentKey = key;

      bool update {false};

      // the first run collects the watch() / every() declarations

      if (!luaLastRun.count(key))
      {
         tell(eloLua, "LUA: '%s' first run, collecting watch() / every()", key);
         update = true;
      }

      // if deps is set check it

      if (!update && !luaDeps[luaCurrentKey].empty())
      {
         for (const auto& [wType, wAddr] : luaDeps[luaCurrentKey])
         {
            if (!sensors.count(wType) || !sensors.at(wType).count(wAddr))
               continue;

            // compare with the last run of the script, not with the last change of the result: a result
            // that does not change (e.g. a runtime counter in whole minutes) kept the script running on
            // every process() call (each MQTT value), which starved scripts accumulating time between calls

            if (sensors.at(wType).at(wAddr).changedAt() >= luaLastRun[luaCurrentKey])
            {
               tell(eloLua, "LUA: '%s:0x%02x' (%s) changed since the last run of '%s:0x%02lx' (%s)",
                    wType.c_str(), wAddr, l2pTime(sensors.at(wType).at(wAddr).changedAt()).c_str(),
                    type.c_str(), address, l2pTime(luaLastRun[luaCurrentKey]).c_str());

               update = true;
               break;
            }
         }
      }

      // every(seconds) of the script due?

      if (!update && luaEvery.count(key) && time(0) - luaLastRun[key] >= luaEvery[key])
      {
         tell(eloLua, "LUA: '%s' every(%d) is due", key, luaEvery[key]);
         update = true;
      }

      if (!update && !force)
      {
         tell(eloLua, "LUA: '%s' skipping call, no change of input parameters", key);
         free(key);
         continue;
      }

      // call LUA script

      std::vector<std::string> arguments;
      char luaRef[64];
      snprintf(luaRef, sizeof(luaRef), "%s:0x%02lx", type.c_str(), address);
      Lua::Result res;

      lua.push([&](sol::state& s) { s["signal"] = signal; });

      if (lua.executeExpression(expression.c_str(), arguments, res, luaRef) != success)
      {
         free(key);
         continue;                   // not counted as a run, the next call tries again (first run collects the declarations)
      }

      luaLastRun[key] = time(0);

      if (luaDeps[key].empty() && !luaEvery.count(key))        // nothing declared -> once a minute
      {
         tell(eloLua, "LUA: '%s' declares neither watch() nor every(), running it every 60 seconds", key);
         luaEvery[key] = 60;
      }

      if (res.type == Lua::tDouble)
      {
         tell(eloLua, "LUA '%s' result was double (%f)", key, res.dValue);
         sensors[type][address].setValue(res.dValue);
      }
      else if (res.type == Lua::tInteger)
      {
         tell(eloLua, "LUA '%s' result was integer (%d)", key, res.iValue);
         sensors[type][address].setValue(res.iValue);
      }
      else if (res.type == Lua::tBoolean)
      {
         tell(eloLua, "LUA '%s' result was bool (%s)", key, res.bValue ? "true" : "false");
         sensors[type][address].setState(res.bValue);
      }
      else if (res.type == Lua::tString)
      {
         tell(eloLua, "LUA '%s' result was text '%s'", key, res.sValue.c_str());
         sensors[type][address].setText(res.sValue);
      }
      else if (res.type == Lua::tNil)
      {
         tell(eloLua, "LUA: '%s' returned NIL", key);
         continue;
      }
      else
      {
         tell(eloAlways, "LUA: '%s' got unexpected type (%d)", key, res.type);
         sensors[type][address].touch();
      }

      setConfigItem(key, sensors[type][address].value, "I");
      // tell(eloAlways, "Set value of %s:0x%lx to %f; last is %ld", type.c_str(), address, sensors[type][address].value, sensors[type][address].last());

      // tell(eloLua, "LUA '%s' changed from %f to %f", key, oldValue, sensors[type][address].value);

      if (tableValueFacts->hasValue("TYPE", "DO") || gpioOut)
      {
         tell(eloDebug, "Debug: Calling toggleio() to %d for '%s:0x%02lx'", sensors[type][address].state, type.c_str(), address);
         toggleIo(address, type.c_str(), sensors[type][address].state);
      }
      else // if (sensors[type][address].value != oldValue)
      {
         {
            // tell(eloLua, "LUA '%s' update WS to %f", key, sensors[type][address].value);

            json_t* ojData {json_object()};
            sensor2Json(ojData, type.c_str(), address);

            if (sensors[type][address].kind == "status")
               json_object_set_new(ojData, "value", json_integer(sensors[type][address].state));
            else
               json_object_set_new(ojData, "value", json_real(sensors[type][address].value));

            json_object_set_new(ojData, "text", json_string(sensors[type][address].text.c_str()));

            // if (sensors[type][address].image.length())
            //    json_object_set_new(ojData, "image", json_string(sensors[type][address].image.c_str()));

            jsonSensorList[key] = ojData;
            pushDataUpdate("update", 0L);
         }

         mqttHaPublish(sensors[type][address]);
         mqttNodeRedPublishSensor(sensors[type][address]);
      }

      free(key);
   }

   selectActiveValueFacts->freeResult();
   triggerProcess = false;

   return done;
}

//***************************************************************************
// Update Script Sensors
//***************************************************************************

void HomeCtl::updateScriptSensors()
{
   tableValueFacts->clear();

   tell(eloInfo, "Update script sensors");

   // for (const auto& cmdThreadCtl : commandThreads)
   // {
   //    if (!cmdThreadCtl.second.active)
   //       pthread_join(cmdThreadCtl.second.pThread, 0);
   // }

   for (auto it = commandThreads.begin(), itNext = it; it != commandThreads.end(); it = itNext)
   {
      ++itNext;

      if (!it->second.active)
      {
         tell(eloDebug, "Debug: Cleanup thread for '%s'", it->second.command.c_str());
         commandThreads.erase(it);
      }
   }

   for (bool f = selectActiveValueFacts->find(); f; f = selectActiveValueFacts->fetch())
   {
      if (!tableValueFacts->hasValue("TYPE", "SC"))
         continue;

      uint addr = tableValueFacts->getIntValue("ADDRESS");
      callScript(addr, "status");
   }

   selectActiveValueFacts->freeResult();
}

//***************************************************************************
// After Update
//***************************************************************************

void HomeCtl::afterUpdate()
{
   sensorAlertCheck(lastSampleTime);

   char* path {};
   asprintf(&path, "%s/after-update.sh", confDir);

   if (fileExists(path))
   {
      tell(eloDetail, "Detail: Calling '%s'", path);
      system(path);
   }

   free(path);
}

//***************************************************************************
// Sensor Alert Check
//***************************************************************************

void HomeCtl::sensorAlertCheck(time_t now)
{
   tableSensorAlert->clear();
   tableSensorAlert->setValue("KIND", "M");

   // iterate over all alert roules ..

   for (bool f = selectSensorAlerts->find(); f; f = selectSensorAlerts->fetch())
   {
      alertMailBody = "";
      alertMailSubject = "";
      performAlertCheck(tableSensorAlert->getRow(), now, 0);
   }

   selectSensorAlerts->freeResult();
}

//***************************************************************************
// Perform Alert Check
//***************************************************************************

int HomeCtl::performAlertCheck(cDbRow* alertRow, time_t now, int recurse, int force)
{
   int alert = 0;

   // data from alert row

   int addr = alertRow->getIntValue("ADDRESS");
   const char* type = alertRow->getStrValue("TYPE");

   int id = alertRow->getIntValue("ID");
   int lgop = alertRow->getIntValue("LGOP");
   time_t lastAlert = alertRow->getIntValue("LASTALERT");
   int maxRepeat = alertRow->getIntValue("MAXREPEAT");

   int minIsNull = alertRow->getValue("MIN")->isNull();
   int maxIsNull = alertRow->getValue("MAX")->isNull();
   int min = alertRow->getIntValue("MIN");
   int max = alertRow->getIntValue("MAX");

   int range = alertRow->getIntValue("RANGEM");
   int delta = alertRow->getIntValue("DELTA");

   // lookup value facts

   tableValueFacts->clear();
   tableValueFacts->setValue("ADDRESS", addr);
   tableValueFacts->setValue("TYPE", type);

   // lookup samples

   tableSamples->clear();
   tableSamples->setValue("ADDRESS", addr);
   tableSamples->setValue("TYPE", type);
   tableSamples->setValue("AGGREGATE", "S");
   tableSamples->setValue("TIME", now);

   if (!tableSamples->find() || !tableValueFacts->find())
   {
      tell(eloAlways, "Info: Can't perform sensor check for %s/%d '%s'", type, addr, l2pTime(now).c_str());
      return 0;
   }

   // data from samples and value facts

   double value = tableSamples->getFloatValue("VALUE");

   const char* title = tableValueFacts->getStrValue("TITLE");
   const char* unit = tableValueFacts->getStrValue("UNIT");

   // -------------------------------
   // check min / max threshold

   if (!minIsNull || !maxIsNull)
   {
      if (force || (!minIsNull && value < min) || (!maxIsNull && value > max))
      {
         tell(eloAlways, "%d) Alert for sensor %s/0x%x, value %.2f not in range (%d - %d)",
              id, type, addr, value, min, max);

         // max one alert mail per maxRepeat [minutes]

         if (force || !lastAlert || lastAlert < time(0)- maxRepeat * tmeSecondsPerMinute)
         {
            alert = 1;
            add2AlertMail(alertRow, title, value, unit);
         }
      }
   }

   // -------------------------------
   // check range delta

   if (range && delta)
   {
      // select value of this sensor around 'time = (now - range)'

      time_t rangeStartAt = time(0) - range*tmeSecondsPerMinute;
      time_t rangeEndAt = rangeStartAt + interval;

      tableSamples->clear();
      tableSamples->setValue("ADDRESS", addr);
      tableSamples->setValue("TYPE", type);
      tableSamples->setValue("AGGREGATE", "S");
      tableSamples->setValue("TIME", rangeStartAt);
      rangeEnd.setValue(rangeEndAt);

      if (selectSampleInRange->find())
      {
         double oldValue = tableSamples->getFloatValue("VALUE");

         if (force || labs(value - oldValue) > delta)
         {
            tell(eloAlways, "%d) Alert for sensor %s/0x%x , value %.2f changed more than %d in %d minutes",
                 id, type, addr, value, delta, range);

            // max one alert mail per maxRepeat [minutes]

            if (force || !lastAlert || lastAlert < time(0)- maxRepeat * tmeSecondsPerMinute)
            {
               alert = 1;
               add2AlertMail(alertRow, title, value, unit);
            }
         }
      }

      selectSampleInRange->freeResult();
      tableSamples->reset();
   }

   // ---------------------------
   // Check sub rules recursive

   if (alertRow->getIntValue("SUBID") > 0)
   {
      if (recurse > 50)
      {
         tell(eloAlways, "Info: Aborting recursion after 50 steps, seems to be a config error!");
      }
      else
      {
         tableSensorAlert->clear();
         tableSensorAlert->setValue("ID", alertRow->getIntValue("SUBID"));

         if (tableSensorAlert->find())
         {
            int sAlert = performAlertCheck(tableSensorAlert->getRow(), now, recurse+1);

            switch (lgop)
            {
               case loAnd:    alert = alert &&  sAlert; break;
               case loOr:     alert = alert ||  sAlert; break;
               case loAndNot: alert = alert && !sAlert; break;
               case loOrNot:  alert = alert || !sAlert; break;
            }
         }
      }
   }

   // ---------------------------------
   // update master row and send mail

   if (alert && !recurse)
   {
      tableSensorAlert->clear();
      tableSensorAlert->setValue("ID", id);

      if (tableSensorAlert->find())
      {
         if (!force)
         {
            tableSensorAlert->setValue("LASTALERT", time(0));
            tableSensorAlert->update();
         }

         sendAlertMail(tableSensorAlert->getStrValue("MADDRESS"));
      }
   }

   return alert;
}

//***************************************************************************
// Add To Alert Mail
//***************************************************************************

int HomeCtl::add2AlertMail(cDbRow* alertRow, const char* title, double value, const char* unit)
{
   char* sensor {};

   std::string subject = alertRow->getStrValue("MSUBJECT");
   std::string body = alertRow->getStrValue("MBODY");
   int addr = alertRow->getIntValue("ADDRESS");
   const char* type = alertRow->getStrValue("TYPE");

   int min = alertRow->getIntValue("MIN");
   int max = alertRow->getIntValue("MAX");
   int range = alertRow->getIntValue("RANGEM");
   int delta = alertRow->getIntValue("DELTA");
   int maxRepeat = alertRow->getIntValue("MAXREPEAT");
   double minv {0};
   double maxv {0};

   tablePeaks->clear();
   tablePeaks->setValue("ADDRESS", alertRow->getIntValue("ADDRESS"));
   tablePeaks->setValue("TYPE", alertRow->getStrValue("TYPE"));

   if (tablePeaks->find())
   {
      minv = tablePeaks->getFloatValue("MIN");
      maxv = tablePeaks->getFloatValue("MAX");
   }

   tablePeaks->reset();

   if (!body.length())
      body = "- undefined -";

   // prepare

   asprintf(&sensor, "%s/0x%x", type, addr);

   // templating

   subject = strReplace("%sensorid%", sensor, subject);
   subject = strReplace("%value%", value, subject);
   subject = strReplace("%unit%", unit, subject);
   subject = strReplace("%title%", title, subject);
   subject = strReplace("%min%", (long)min, subject);
   subject = strReplace("%max%", (long)max, subject);
   subject = strReplace("%range%", (long)range, subject);
   subject = strReplace("%delta%", (long)delta, subject);
   subject = strReplace("%time%", l2pTime(time(0)).c_str(), subject);
   subject = strReplace("%repeat%", (long)maxRepeat, subject);
   subject = strReplace("%weburl%", webUrl, subject);
   subject = strReplace("%minv%", minv, subject);
   subject = strReplace("%maxv%", maxv, subject);

   body = strReplace("%sensorid%", sensor, body);
   body = strReplace("%value%", value, body);
   body = strReplace("%unit%", unit, body);
   body = strReplace("%title%", title, body);
   body = strReplace("%min%", (long)min, body);
   body = strReplace("%max%", (long)max, body);
   body = strReplace("%range%", (long)range, body);
   body = strReplace("%delta%", (long)delta, body);
   body = strReplace("%time%", l2pTime(time(0)).c_str(), body);
   body = strReplace("%repeat%", (long)maxRepeat, body);
   body = strReplace("%weburl%", webUrl, body);
   body = strReplace("%minv%", minv, body);
   body = strReplace("%maxv%", maxv, body);

   alertMailSubject += std::string(" ") + subject;
   alertMailBody += std::string("\n") + body;

   free(sensor);

   return success;
}

//***************************************************************************
// Send Mail
//***************************************************************************

int HomeCtl::sendAlertMail(const char* to)
{
   // check

   if (isEmpty(to) || mailScript.empty())
      return done;

   if (alertMailBody.empty())
      alertMailBody = "- undefined -";

   char* html = 0;

   alertMailBody = strReplace("\n", "<br/>\n", alertMailBody);

   const char* htmlHead =
      "<head>\n"
      "  <style type=\"text/css\">\n"
      "    caption { background: #095BA6; font-family: Arial Narrow; color: #fff; font-size: 18px; }\n"
      "  </style>\n"
      "</head>\n";

   asprintf(&html,
            "<html>\n"
            " %s"
            " <body>\n"
            "  %s\n"
            " </body>\n"
            "</html>\n",
            htmlHead, alertMailBody.c_str());

   alertMailBody = html;
   free(html);

   // send mail

   return sendMail(to, alertMailSubject.c_str(), alertMailBody.c_str(), "text/html");
}

//***************************************************************************
// Update Conf Tables
//***************************************************************************

int HomeCtl::updateSchemaConfTable()
{
   const int step = 20;
   int y = 50;
   int added = 0;

   tableValueFacts->clear();

   for (bool f = selectActiveValueFacts->find(); f; f = selectActiveValueFacts->fetch())
   {
      int addr = tableValueFacts->getIntValue("ADDRESS");
      const char* type = tableValueFacts->getStrValue("TYPE");
      y += step;

      tableSchemaConf->clear();
      tableSchemaConf->setValue("ADDRESS", addr);
      tableSchemaConf->setValue("TYPE", type);

      if (!tableSchemaConf->find())
      {
         tableSchemaConf->setValue("KIND", "value");
         tableSchemaConf->setValue("STATE", "A");

         tableSchemaConf->store();
         added++;
      }
   }

   selectActiveValueFacts->freeResult();
   tell(eloInfo, "Added %d html schema configurations", added);

   return success;
}

//***************************************************************************
// Is In Time Range
//***************************************************************************

bool HomeCtl::isInTimeRange(const std::vector<Range>* ranges, time_t t)
{
   for (auto it = ranges->begin(); it != ranges->end(); ++it)
   {
      if (it->inRange(l2hhmm(t)))
      {
         tell(eloDebug2, "Debug2: %d in time range '%d-%d'", l2hhmm(t), it->from, it->to);
         return true;
      }
   }

   return false;
}

//***************************************************************************
// Schedule Aggregate
//***************************************************************************

int HomeCtl::scheduleAggregate()
{
   struct tm tm = {0};
   time_t now {0};

   if (!aggregateHistory)
   {
      tell(eloInfo, "NO aggregateHistory configured!");
      return done;
   }

   // calc today at 01:00:00

   now = time(0);
   localtime_r(&now, &tm);

   tm.tm_sec = 0;
   tm.tm_min = 0;
   tm.tm_hour = 1;
   tm.tm_isdst = -1;               // force DST auto detect

   nextAggregateAt = mktime(&tm);

   // if in the past ... skip to next day ...

   if (nextAggregateAt <= time(0))
      nextAggregateAt += tmeSecondsPerDay;

   tell(eloAlways, "Scheduled aggregation for '%s' with interval of %d minutes",
        l2pTime(nextAggregateAt).c_str(), aggregateInterval);

   return success;
}

//***************************************************************************
// Aggregate
//***************************************************************************

int HomeCtl::aggregate()
{
   char* stmt {};
   time_t history {time(0) - (aggregateHistory * tmeSecondsPerDay)};
   int aggCount {0};
   int status {fail};

   tell(eloAlways, "Starting aggregation ..");
   asprintf(&stmt,
            "replace into samples "
            "  select address, type, 'A' as aggregate, "
            "    CONCAT(DATE(time), ' ', SEC_TO_TIME((TIME_TO_SEC(time) DIV %d) * %d)) + INTERVAL %d MINUTE time, "
            "    unix_timestamp(sysdate()) as inssp, unix_timestamp(sysdate()) as updsp, "
            "    round(sum(value)/count(*), 2) as value, text, count(*) samples "
            "  from "
            "    samples "
            "  where "
            "    aggregate = 'S' and "
            "    time <= from_unixtime(%ld) "
            "  group by "
            "    CONCAT(DATE(time), ' ', SEC_TO_TIME((TIME_TO_SEC(time) DIV %d) * %d)) + INTERVAL %d MINUTE, address, type;",
            aggregateInterval * tmeSecondsPerMinute, aggregateInterval * tmeSecondsPerMinute, aggregateInterval,
            history,
            aggregateInterval * tmeSecondsPerMinute, aggregateInterval * tmeSecondsPerMinute, aggregateInterval);

   tell(eloAlways, "Starting aggregation ...");

   if (connection->query(aggCount, "%s", stmt) == success)
   {
      tell(eloDebug, "Aggregation: [%s]", stmt);
      free(stmt);

      // Einzelmesspunkte löschen ... (die Samples der GPS Touren (aggregate 'T') bleiben erhalten)

      asprintf(&stmt, "aggregate = 'S' and time <= from_unixtime(%ld)", history);

      if ((status = tableSamples->deleteWhere("%s", stmt)) == success)
         tell(eloAlways, "Aggregation with interval of %d minutes done; Created %d aggregation rows", aggregateInterval, aggCount);
   }

   free(stmt);
   tell(eloAlways, ".. aggregation %s", status == success ? "done" : "failed");
   scheduleAggregate();      // schedule next aggregation even in case of error!

   return success;
}

int HomeCtl::sendMail(const char* receiver, const char* subject, const char* body, const char* mimeType)
{
   char* command {};
   int result {0};

   asprintf(&command, "%s '%s' '%s' '%s' '%s'", mailScript.c_str(), subject, body, mimeType, receiver);
   result = system(command);
   free(command);

   if (eloquence & eloDebug)
      tell(eloInfo, "Send mail '%s' with [%s] to '%s'", subject, body, receiver);
   else
      tell(eloInfo, "Send mail '%s' to '%s'", subject, receiver);

   return result;
}

//***************************************************************************
// Load HTML Mail Header
//***************************************************************************

int HomeCtl::loadHtmlHeader()
{
   char* file {};

   // load only once at first call

   if (htmlHeader.length())
      return done;

   asprintf(&file, "%s/mail-head.html", confDir);

   if (fileExists(file))
   {
      MemoryStruct data;

      if (loadFromFile(file, &data) == success)
      {
         data.append("\0");
         htmlHeader = data.memory;
      }
   }

   free(file);

   if (htmlHeader.length())
      return success;

   htmlHeader =
      "  <head>\n"
      "    <style type=\"text/css\">\n"
      "      table {"
      "        border: 1px solid #d2d2d2;\n"
      "        border-collapse: collapse;\n"
      "      }\n"
      "      table tr.head {\n"
      "        background-color: #004d8f;\n"
      "        color: #fff;\n"
      "        font-weight: bold;\n"
      "        font-family: Helvetica, Arial, sans-serif;\n"
      "        font-size: 12px;\n"
      "      }\n"
      "      table tr th,\n"
      "      table tr td {\n"
      "        padding: 4px;\n"
      "        text-align: left;\n"
      "      }\n"
      "      table tr:nth-child(1n) td {\n"
      "        background-color: #fff;\n"
      "      }\n"
      "      table tr:nth-child(2n+2) td {\n"
      "        background-color: #eee;\n"
      "      }\n"
      "      td {\n"
      "        color: #333;\n"
      "        font-family: Helvetica, Arial, sans-serif;\n"
      "        font-size: 12px;\n"
      "        border: 1px solid #D2D2D2;\n"
      "      }\n"
      "      </style>\n"
      "  </head>\n";

   return success;
}

//***************************************************************************
// Add Value Fact
//***************************************************************************

int HomeCtl::addValueFact(int addr, const char* type, int factor, const char* name, const char* unit,
                         const char* aTitle, int rights, const char* choices, SensorOptions options, const char* parameter)

{
   const char* title {!isEmpty(aTitle) ? aTitle : name};

   // check / add to valueTypes

   tableValueTypes->clear();
   tableValueTypes->setValue("TYPE", type);

   if (!tableValueTypes->find())
   {
      tableValueTypes->setValue("TITLE", getTitleOfType(type));
      tableValueTypes->store();
   }

   // check / add to valueFacts

   tableValueFacts->clear();
   tableValueFacts->setValue("TYPE", type);
   tableValueFacts->setValue("ADDRESS", addr);

   bool exist {tableValueFacts->find()};
   // tell(eloAlways, "addValueFact(%d, %s, %d, %s, %s, %s, ...) [%s/%d]", addr, type, factor, name, unit, title, aTitle, exist);

   if (!exist)
   {
      tell(eloAlways, "Add ValueFact '%u' '%s'", addr, type);

      tableValueFacts->setValue("NAME", name);
      tableValueFacts->setValue("TITLE", title);
      tableValueFacts->setValue("FACTOR", factor);
      tableValueFacts->setValue("RIGHTS", rights);
      tableValueFacts->setValue("STATE", "D");
      tableValueFacts->setValue("OPTIONS", options);

      if (!isEmpty(unit))
         tableValueFacts->setValue("UNIT", unit);

      if (!isEmpty(parameter))
         tableValueFacts->setValue("PARAMETER", parameter);

      if (!isEmpty(choices))
         tableValueFacts->setValue("CHOICES", choices);

      tableValueFacts->store();
      initSensorByFact(type, addr);

      if (initialized)
         valueFactsChanged = true;            // update web clients (done collected in meanwhile())

      return 1;                               // 1 for 'added'
   }

   tableValueFacts->clearChanged();

   // choices can change dynamic (by script response)

   if (!isEmpty(choices))
      tableValueFacts->setValue("CHOICES", choices);

   // the capabilities of the deCONZ lights (switch / dim / color) are taken from deCONZ on every start

   if (strcmp(type, "DZL") == 0)
      tableValueFacts->setValue("OPTIONS", options);

   if (strcmp(type, "SC") != 0)
   {
      if (tableValueFacts->getChanges())
      {
         tableValueFacts->store();
         return 2;                               // 2 for 'modified'
      }

      return done;
   }

   // für SC Sensoren wird der valuefact in initScripts erst 'roh' angelegt
   // um dann in der daruf folgenden Schleife aktualisiert zu werden, daher ist hier
   // ein update nötig!

   // already exist, update ...

   tableValueFacts->clearChanged();

   tableValueFacts->setValue("NAME", name);
   tableValueFacts->setValue("TITLE", title);
   tableValueFacts->setValue("FACTOR", factor);
   // tell(eloAlways, "Update right of '%s0x%x' to (%d)", type, addr, rights);

   tableValueFacts->setValue("RIGHTS", rights);
   tableValueFacts->setValue("OPTIONS", options);

   if (!tableValueFacts->hasValue("UNIT", unit))
      tableValueFacts->setValue("UNIT", unit);

   if (!isEmpty(parameter))
      tableValueFacts->setValue("PARAMETER", parameter);

   if (tableValueFacts->getChanges())
   {
      tableValueFacts->store();
      return 2;                                // 2 for 'modified'
   }

   return done;
}

//***************************************************************************
// Dispatch Mqtt Command Request
//   Format: {"state": "OFF", "brightness": 255}
//***************************************************************************

int HomeCtl::dispatchMqttHaCommandRequest(json_t* jData, const char* topic)
{
   auto it = hassCmdTopicMap.find(topic);

   if (it != hassCmdTopicMap.end())
   {
      const char* state = getStringFromJson(jData, "state", "");

      if (isEmpty(state))
         return fail;

      // #TODO GPIO?
      for (auto itOutput = sensors["DO"].begin(); itOutput != sensors["DO"].end(); ++itOutput)
      {
         bool bState = strcmp(state, "ON") == 0;

         if (it->second == itOutput->second.name)
         {
            gpioWrite(itOutput->first, bState);
            break;
         }
      }
   }

   return success;
}

//***************************************************************************
// Dispatch Node-Red Command's Request
//   Format:  '[{ "command" : "set", "id" : 'SC:0x9', "value" : "on|off" }, ...]'
//***************************************************************************

int HomeCtl::dispatchNodeRedCommands(const char* topic, json_t* jObject)
{
   if (json_is_array(jObject))
   {
      size_t index {0};
      json_t* jCommand {};

      json_array_foreach(jObject, index, jCommand)
         dispatchNodeRedCommand(jCommand);
   }
   else
   {
      dispatchNodeRedCommand(jObject);
   }

   return success;
}

//***************************************************************************
// Dispatch Node-Red Command Request
//   Format:  '{ "command" : "set", "id" : 'SC:0x9', "value" : "on|off", "bri" : 100 }'
//***************************************************************************

int HomeCtl::dispatchNodeRedCommand(json_t* jObject)
{
   const char* command = getStringFromJson(jObject, "command", "set");
   const char* key = getStringFromJson(jObject, "id");

   if (!key)
   {
      tell(eloAlways, "Error: Node-Red: Got unexpected id '%s' from node-red, commad was '%s'", key, command);
      return fail;
   }

   int bri = getIntFromJson(jObject, "bri", na);
   int transitiontime = getIntFromJson(jObject, "transitiontime", na);
   const char* sState = getStringFromJson(jObject, "state", "off");
   if (!sState) sState = "off";
   bool state = strcasecmp(sState, "on") == 0;

   auto tuple = split(key, ':');
   uint address = strtol(tuple[1].c_str(), nullptr, 0);
   tell(eloNodeRed, "Node-Red: switch %s to %d (%d/%d)", key, state, bri, transitiontime);
   toggleIo(address, tuple[0].c_str(), state, bri, transitiontime);

   return success;
}

//***************************************************************************
// Update Weather
//
// Format:
//   { "weather":[{"id":804,"main":"Clouds","description":"Bedeckt","icon":"04d"}],
//     "main":{"temp":8.49,"feels_like":8.49,"temp_min":7.1,"temp_max":9.55,"pressure":1008,"humidity":89},
//     "visibility":10000,
//     "wind":{"speed":0.89,"deg":238,"gust":3.58},
//     "clouds":{"all":100},
//     "dt":1640765212,
//     "sys":{"type":2,"id":2012565,"country":"DE","sunrise":1640762680,"sunset":1640791732},
//     "timezone":3600, "id":2955014, "name":"Assenheim", "cod":200}
//
//  https://openweathermap.org/current#min
//  https://openweathermap.org/forecast5
//  Get the free API Key here: https://openweathermap.org/price
//***************************************************************************

int HomeCtl::updateWeather()
{
   static time_t nextWeatherAt {0};

   if (openWeatherApiKey.empty())
      return done;

   if (time(0) < nextWeatherAt)
      return done;

   nextWeatherAt = time(0) + weatherInterval*tmeSecondsPerMinute;
   sensors["WEA"][1].invalidate();

   cCurl curl;
   curl.init();

   MemoryStruct data;
   int size {0};
   char* url {};

   GpsCoordinate pos {location()};

   asprintf(&url, "http://api.openweathermap.org/data/2.5/forecast?appid=%s&units=metric&lang=de&lat=%f&lon=%f",
            openWeatherApiKey.c_str(), pos.latitude, pos.longitude);

   tell(eloWeather, "-> (openweathermap) [%s]", url);
   int status {curl.downloadFile(url, size, &data, 2)};

   if (status != success)
   {
      tell(eloAlways, "Error: Requesting weather at '%s' failed", url);
      free(url);
      return fail;
   }

   free(url);
   tell(eloWeather, "<- (openweathermap) [%s]", data.memory);

   json_t* jData {jsonLoad(data.memory)};

   if (!jData)
      return fail;

   const char* city {getStringByPath(jData, "city/name")};
   json_t* jArray {getObjectFromJson(jData, "list")};

   if (!jArray)
   {
      json_decref(jData);
      return fail;
   }

   json_t* jWeather {json_object()};
   json_t* jForecasts {json_array()};

   json_object_set_new(jWeather, "forecasts", jForecasts);
   json_object_set_new(jWeather, "city", json_string(city));

   size_t index {0};
   json_t* jObj {};

   json_array_foreach(jArray, index, jObj)
   {
      if (index == 0)
         weather2json(jWeather, jObj);

      json_t* jFcItem {json_object()};
      json_array_append_new(jForecasts, jFcItem);
      weather2json(jFcItem, jObj);
   }

   addValueFact(1, "WEA", 1, "weather", "txt", "Wetter");
   sensors["WEA"][1].kind = "text";

   char* p {json_dumps(jWeather, JSON_REAL_PRECISION(4))};
   json_decref(jWeather);
   sensors["WEA"][1].setText(p);
   free(p);

   {
      json_t* ojData {json_object()};
      sensor2Json(ojData, "WEA", 1);
      json_object_set_new(ojData, "text", json_string(sensors["WEA"][1].text.c_str()));

      char* tuple {};
      asprintf(&tuple, "%s:0x%02x", "WEA", 1);
      jsonSensorList[tuple] = ojData;
      free(tuple);

      pushDataUpdate("update", 0L);
   }

   json_decref(jData);
   curl.exit();

   return done;
}

//***************************************************************************
// Weather 2 Json
//***************************************************************************

int HomeCtl::weather2json(json_t* jWeather, json_t* owmWeather)
{
   json_object_set_new(jWeather, "stime", json_string(l2pTime(getIntFromJson(owmWeather, "dt")).c_str()));
   json_object_set_new(jWeather, "time", json_integer(getIntFromJson(owmWeather, "dt")));
   json_object_set_new(jWeather, "detail", json_string(getStringByPath(owmWeather, "weather[0]/description")));
   json_object_set_new(jWeather, "icon", json_string(getStringByPath(owmWeather, "weather[0]/icon")));
   json_object_set_new(jWeather, "temp", json_real(getDoubleByPath(owmWeather, "main/temp")));
   json_object_set_new(jWeather, "tempfeels", json_real(getDoubleByPath(owmWeather, "main/feels_like")));
   json_object_set_new(jWeather, "tempmax", json_real(getDoubleByPath(owmWeather, "main/temp_max")));
   json_object_set_new(jWeather, "tempmin", json_real(getDoubleByPath(owmWeather, "main/temp_min")));
   json_object_set_new(jWeather, "humidity", json_real(getIntByPath(owmWeather, "main/humidity")));
   json_object_set_new(jWeather, "pressure", json_real(getIntByPath(owmWeather, "main/pressure")));
   json_object_set_new(jWeather, "windspeed", json_real(getDoubleByPath(owmWeather, "wind/speed")));
   json_object_set_new(jWeather, "windgust", json_real(getDoubleByPath(owmWeather, "wind/gust")));
   json_object_set_new(jWeather, "winddir", json_real(getIntByPath(owmWeather, "wind/deg")));

   return done;
}

//***************************************************************************
// Dispatch Deconz
//   Format: {"type": "DZL", "address": 29, "state": false, "bri": 80}
//           {"type": "DZS", "address": 25, "btnevent": 1002}
//           {"type": "DZS", "address": 33, "presence": true}
//***************************************************************************

int HomeCtl::dispatchDeconz()
{
   cMyMutexLock lock(&Deconz::messagesInMutex);

   while (!Deconz::messagesIn.empty())
   {
      tell(eloDeconz, "<- (DECONZ) '%s'", Deconz::messagesIn.front().c_str());

      const char* msg{Deconz::messagesIn.front().c_str()};

      if (strcmp(msg, "WS CONNECTED") == 0)
      {
         Deconz::messagesIn.pop();
         tell(eloAlways, "DECONZ: Init devices on WS connected");
         return deconz.initDevices();
      }

      json_t* oData {jsonLoad(msg)};
      const char* type {getStringFromJson(oData, "type")};
      int address {getIntFromJson(oData, "address")};
      SensorData* sensor {getSensor(type, address)};

      if (!sensor)
      {
         json_decref(oData);      // free the json object
         Deconz::messagesIn.pop();
         return done;
      }

      bool state {getBoolFromJson(oData, "state")};
      double value {getDoubleFromJson(oData, "value")};
      int bri {getIntFromJson(oData, "bri", na)};
      int hue {getIntFromJson(oData, "hue", 0)};
      int sat {getIntFromJson(oData, "sat", 0)};

      if (getObjectFromJson(oData, "state"))
         sensor->setState(state);
      else if (getObjectFromJson(oData, "value"))
         sensor->setValue(value);
      else if (getObjectFromJson(oData, "btnevent"))
         sensor->setValue(getIntFromJson(oData, "btnevent"));
      else if (getObjectFromJson(oData, "presence"))
         sensor->setState(getBoolFromJson(oData, "presence"));

      // switches and motion sensors are events for the light rules - also the same value again
      //  (processed by performLightRules() outside of the lock)

      if (getObjectFromJson(oData, "btnevent"))
         lightRuleEvents.push_back({ type, (uint)address, getIntFromJson(oData, "btnevent"), na });
      else if (getObjectFromJson(oData, "presence"))
         lightRuleEvents.push_back({ type, (uint)address, na, getBoolFromJson(oData, "presence") });

      if (getObjectFromJson(oData, "bri"))
         sensor->setValue(bri);

      if (getObjectFromJson(oData, "hue") && sensor->hue != hue)
      {
         sensor->hue = hue;
         sensor->markChanged();
      }

      if (getObjectFromJson(oData, "sat") && sensor->sat != sat)
      {
         sensor->sat = sat;
         sensor->markChanged();
      }

      sensor->touch();                       // also for messages without one of the above
      sensor->setLastJson("deconz", msg);
      sensor->battery = getIntFromJson(oData, "battery", na);

      // send update to WS
      {
         json_t* ojData {json_object()};
         sensor2Json(ojData, type, address);

         if (getObjectFromJson(oData, "state"))
         {
            json_object_set_new(ojData, "value", json_integer(sensor->state));
            if (getObjectFromJson(oData, "bri"))
               json_object_set_new(ojData, "score", json_integer(bri));
            if (getObjectFromJson(oData, "hue"))
               json_object_set_new(ojData, "hue", json_integer(hue));
            if (getObjectFromJson(oData, "sat"))
               json_object_set_new(ojData, "sat", json_integer(sat));
         }
         else if (getObjectFromJson(oData, "value"))
            json_object_set_new(ojData, "value", json_real(sensor->value));

         if (sensor->battery != na)
            json_object_set_new(ojData, "battery", json_integer(sensor->battery));

         char* tuple {};
         asprintf(&tuple, "%s:0x%02x", type, address);
         jsonSensorList[tuple] = ojData;
         free(tuple);

         pushDataUpdate("update", 0L);
      }

      mqttHaPublish(sensors[type][address]);
      mqttNodeRedPublishSensor(sensors[type][address]);

      json_decref(oData);      // free the json object
      Deconz::messagesIn.pop();
   }

   return success;
}

//***************************************************************************
// Homematic Interface (via node-red)
//***************************************************************************

int HomeCtl::dispatchHomematicRpcResult(const char* message)
{
   json_t* jData {jsonLoad(message)};

   if (!jData)
   {
      tell(eloAlways, "Error: (home-matic) Can't parse json in '%s'", message);
      return fail;
   }

   if (!json_is_array(jData))
      tell(eloHomeMatic, "<- (home-matic) '%s'", message);

   // the answer of getParamset(uuid, "VALUES") - without the uuid, the requests are sent one by one

   if (json_is_object(jData))
   {
      if (!homeMaticValueRequests.empty())
      {
         homeMaticParamset(homeMaticValueRequests.front().c_str(), jData);
         homeMaticValueRequests.pop_front();
         homeMaticRequestNext();
      }

      json_decref(jData);
      return done;
   }

   size_t index {0};
   json_t* jItem {};
   bool blinds {false};

   json_array_foreach(jData, index, jItem)
   {
      std::string hmType = getStringFromJson(jItem, "TYPE", "");
      const char* uuid = getStringFromJson(jItem, "ADDRESS");

      if (!uuid || hmType != "BLIND")
         continue;

      if (eloquence & eloHomeMatic)
      {
         char* p = json_dumps(jItem, JSON_REAL_PRECISION(4));
         tell(eloHomeMatic, "<- (home-matic) '%s'", p);
         free(p);
      }

      tell(eloHomeMatic, "%zu) '%s', type '%s', direction %d", index, uuid, hmType.c_str(),
           getIntFromJson(jItem, "DIRECTION", na));

      // value fact HMB for the blind (table 'homematic': uuid -> address)

      homeMaticAddBlind(uuid, getIntFromJson(jItem, "DIRECTION", 0) == 2 ? 2 : 1);

      homeMaticValueRequests.push_back(uuid);
      blinds = true;
   }

   json_decref(jData);

   if (blinds)
      homeMaticRequestNext();

   return done;
}

//***************************************************************************
// HomeMatic - actual values of the blinds
//   getParamset(uuid, "VALUES") via the NR bridge (rpccall -> rpcresult), the answer carries
//   no uuid - therefore one request after the other, an unanswered one is dropped after 10 s
//***************************************************************************

int HomeCtl::homeMaticRequestNext()
{
   homeMaticRequestAt = 0;

   if (homeMaticValueRequests.empty() || mqttCheckConnection() != success)
      return done;

   char* request {};
   asprintf(&request, "{ \"method\" : \"getParamset\", \"parameters\" : [\"%s\", \"VALUES\"] }",
            homeMaticValueRequests.front().c_str());
   mqttWriter->write(INSTANCE "2mqtt/homematic/rpccall", request);
   tell(eloHomeMatic, "-> (home-matic) '%s' to '%s'", INSTANCE "2mqtt/homematic/rpccall", request);
   free(request);

   homeMaticRequestAt = time(0);

   return done;
}

int HomeCtl::homeMaticCheckRequests()
{
   if (homeMaticRequestAt && homeMaticRequestAt + 10 < time(0))
   {
      tell(eloAlways, "Warning: (home-matic) No answer for the values of '%s', skipping",
           homeMaticValueRequests.front().c_str());

      homeMaticValueRequests.pop_front();
      homeMaticRequestNext();
   }

   return done;
}

int HomeCtl::homeMaticParamset(const char* uuid, json_t* jValues)
{
   long address {na};

   for (const auto& [addr, u] : homeMaticUuids)
      if (u == uuid)
         address = addr;

   if (address == na || !getObjectFromJson(jValues, "LEVEL"))
      return fail;

   SensorData& sensor {sensors["HMB"][address]};
   double value {getDoubleFromJson(jValues, "LEVEL") * 100};    // to [%]

   tell(eloHomeMatic, "<- (home-matic) '%s' level %.0f%%", uuid, value);

   sensor.setState(value == 100);                               // on if completely open
   sensor.setValue(value);
   sensor.working = getBoolFromJson(jValues, "WORKING", false);

   if (getIntFromJson(jValues, "DIRECTION", 0) != 0)
      sensor.lastDir = getIntFromJson(jValues, "DIRECTION") == 2 ? dirClose : dirOpen;

   {
      json_t* ojData {json_object()};
      sensor2Json(ojData, "HMB", address);
      json_object_set_new(ojData, "value", json_real(value));

      char* tuple {};
      asprintf(&tuple, "%s:0x%02lx", "HMB", address);
      jsonSensorList[tuple] = ojData;
      free(tuple);

      pushDataUpdate("update", 0L);
   }

   mqttHaPublish(sensor);

   return done;
}

int HomeCtl::dispatchHomematicEvents(const char* message)
{
   // { "val" : 0.25,
   //   "hm" : { "device"      : "OEQ1853240",
   //            "channel"     : "OEQ1853240:1",
   //            "channelType" : "BLIND",
   //            "datapoint"   : "LEVEL",
   //            "valueStable" : 0.25 }

   tell(eloHomeMatic, "<- (home-matic) '%s'", message);

   json_t* jData = jsonLoad(message);

   if (!jData)
   {
      tell(eloAlways, "Error: (home-matic) Can't parse json in '%s'", message);
      return fail;
   }

   const char* uuid = getStringByPath(jData, "/hm/channel");
   std::string channelType = getStringByPath(jData, "/hm/channelType");
   std::string datapoint = getStringByPath(jData, "/hm/datapoint");

   if (!uuid || channelType != "BLIND")
      return done;

   tableHomeMatic->clear();
   tableHomeMatic->setValue("UUID", uuid);

   if (!selectHomeMaticByUuid->find())
   {
      json_decref(jData);
      return done;
   }

   const char* type {tableHomeMatic->getStrValue("TYPE")};
   long address {tableHomeMatic->getIntValue("ADDRESS")};
   double value {sensors[type][address].value};

   tell(eloDebug, "Debug: Got (home-matic) '%s' last value is %d", datapoint.c_str(), (int)sensors[type][address].value);
   selectHomeMaticByUuid->freeResult();

   sensors[type][address].touch();
   sensors[type][address].setLastJson("homematic/events", message);

   // for blinds:
   //  offen -> state true (on)
   //           100% (value 100)

   if (datapoint == "LEVEL")
   {
      value = getDoubleFromJson(jData, "val") * 100;     // to [%]
      sensors[type][address].setState(value == 100);     // on wenn ganz offen (offen entspricht=> 100%)
      sensors[type][address].setValue(value);
   }
   else if (datapoint == "WORKING")
      sensors[type][address].working = getBoolFromJson(jData, "val");
   else if (datapoint == "DIRECTION")
   {
      if (getIntFromJson(jData, "val") != 0)
         sensors[type][address].lastDir = getIntFromJson(jData, "val") == 2 ? dirClose : dirOpen;
   }
   else if (datapoint == "LEVEL_NOTWORKING")
   {
      value = getDoubleFromJson(jData, "val") * 100;    // to [%]
      sensors[type][address].working = false;
   }

   {
      json_t* ojData {json_object()};
      sensor2Json(ojData, type, address);
      json_object_set_new(ojData, "value", json_real(value));

      char* tuple {};
      asprintf(&tuple, "%s:0x%02lx", type, address);
      jsonSensorList[tuple] = ojData;
      free(tuple);

      pushDataUpdate("update", 0L);
   }

   mqttHaPublish(sensors[type][address]);
   mqttNodeRedPublishSensor(sensors[type][address]);
   json_decref(jData);

   return done;
}

std::string buildStringFromCamelCase(std::string camelCaseStr)
{
   size_t n {0};

   while (n+1 < camelCaseStr.length())
   {
      if ((islower(camelCaseStr[n]) || isdigit(camelCaseStr[n])) && isupper(camelCaseStr[n+1]))
      {
         camelCaseStr = camelCaseStr.substr(0,n+1) + " " + camelCaseStr.substr(n+1);
         n++;
      }

      n++;
   }

   return camelCaseStr;
}

//***************************************************************************
// GroWatt Interface
//
// Input:
// {
//   "meta": {
//     "mac": "C8:C9:A3:8B:0F:0C"
//   },
//   "data": {
//     "0": {
//       "name": "InverterStatus",
//       "unit": "",
//       "val": 1,
//       "text": "Normal Operation"
//     },
//     "1": {
//       "name": "InputPower",
//       "unit": "W",
//       "val": 684.6
//     },
//     "3": {
//       "name": "PV1Voltage",
//       "unit": "V",
//       "val": 97
//     },
//     "4": {
//       "name": "PV1InputCurrent",
//       "unit": "A",
//       "val": 7.6
//     },
//     ...
//***************************************************************************

int HomeCtl::dispatchGrowattEvents(const char* message)
{
   json_t* jData = jsonLoad(message);

   if (!jData)
   {
      tell(eloAlways, "Error: (GroWatt) Can't parse json in '%s'", message);
      return fail;
   }

   tell(eloGroWatt, "<- (GroWatt) '%s'", message);
   // json_t* jHoldingRegisters = getObjectFromJson(jData, "param");  // not used yet
   json_t* jInputRegisters = getObjectFromJson(jData, "data");

   if (jInputRegisters)
   {
      const char* key {};
      json_t* jObj {};

      json_object_foreach(jInputRegisters, key, jObj)
      {
         const char* type {"GROWATT"};
         std::string title = getStringFromJson(jObj, "name");
         const char* unit = getStringFromJson(jObj, "unit");
         int address = GroWatt::getAddressOf(title.c_str());  // get old address
         // int address = atoi(key);                          // the new address

         if (address < 0)
         {
            tell(eloAlways, "Warning: Failed to lookup address of Growatt sensor '%s'", key);
            continue;
         }

         std::string text = getStringFromJson(jObj, "text", "");
         json_t* jValue  = getObjectFromJson(jObj, "val");
         double value = json_is_integer(jValue) ? json_integer_value(jValue) : json_real_value(jValue);

         sensors[type][address].kind = "value";
         sensors[type][address].setValue(value);
         sensors[type][address].setLastJson("growatt/solar", message);

         if (address == 51)                     // Laufzeit in Sekunden
         {
            char duration[100] {};
            toElapsed(value, duration);
            text = duration;
         }

         if (!text.empty())
         {
            sensors[type][address].kind = "text";
            sensors[type][address].setText(text);
         }

         // tell(eloAlways, "update samples set address = %s where address = %d and type = 'GROWATT'", key, address);
         // tell(eloAlways, "update valuefacts set address = %s where address = %d and type = 'GROWATT'", key, address);

         addValueFact(address, type, 1, title.c_str(), unit, title.c_str());

         // send update to WS
         {
            json_t* ojData {json_object()};
            sensor2Json(ojData, type, address);

            if (sensors[type][address].kind == "status")
               json_object_set_new(ojData, "value", json_integer(sensors[type][address].state));
            else
               json_object_set_new(ojData, "value", json_real(sensors[type][address].value));

            json_object_set_new(ojData, "text", json_string(sensors[type][address].text.c_str()));

            if (sensors[type][address].image.length())
               json_object_set_new(ojData, "image", json_string(sensors[type][address].image.c_str()));

            char* tuple {};
            asprintf(&tuple, "%s:0x%02x", type, address);
            jsonSensorList[tuple] = ojData;
            free(tuple);

            pushDataUpdate("update", 0L);
         }

         mqttHaPublish(sensors[type][address]);
         mqttNodeRedPublishSensor(sensors[type][address]);
      }
   }

   json_decref(jData);
   triggerProcess = true;  // growatt

   return done;
}

//***************************************************************************
// Dispatch RTL 433 MHz
//  (rtl_433)
//     { "time":"2023-07-14 20:45:32", "model":"Nexus-T", "id":60, "channel":1, "temperature_C":14.8}
//***************************************************************************

int HomeCtl::dispatchRtl433(const char* message)
{
   tell(eloMqtt, "(RTL433) <-'%s'", message);

   json_t* jData = jsonLoad(message);

   if (!jData)
   {
      tell(eloAlways, "Error: (RTL433) Can't parse json in '%s'", message);
      return fail;
   }

   std::string  kind = "value";
   const char* type = "RTL433";
   int address = getIntFromJson(jData, "id");
   const char* unit = "°C";
   // const char* timeStr = getStringFromJson(jData, "time");
   const char* title = getStringFromJson(jData, "model");
   double value = getDoubleFromJson(jData, "temperature_C");

   addValueFact(address, type, 1, title, unit, title);

   sensors[type][address].kind = kind;
   sensors[type][address].setValue(value);
   sensors[type][address].setLastJson("rtl_433", message);

   // send update to WS
   {
      json_t* ojData {json_object()};
      sensor2Json(ojData, type, address);

      if (kind == "status")
         json_object_set_new(ojData, "value", json_integer(sensors[type][address].state));
      else
         json_object_set_new(ojData, "value", json_real(sensors[type][address].value));

      json_object_set_new(ojData, "text", json_string(sensors[type][address].text.c_str()));

      if (sensors[type][address].image.length())
         json_object_set_new(ojData, "image", json_string(sensors[type][address].image.c_str()));

      char* tuple {};
      asprintf(&tuple, "%s:0x%02x", type, address);
      jsonSensorList[tuple] = ojData;
      free(tuple);

      pushDataUpdate("update", 0L);
   }

   mqttHaPublish(sensors[type][address]);
   mqttNodeRedPublishSensor(sensors[type][address]);
   json_decref(jData);

   return done;
}

//***************************************************************************
// Lookup Command Topic
//***************************************************************************

const char* HomeCtl::lookupCommandTopic(const char* type, int address)
{
   std::string cmdTopicKey {type};

   if (address != na)
      cmdTopicKey = std::string(type) + ":" + std::to_string(address);

   if (commandTopicsMap.find(cmdTopicKey) == commandTopicsMap.end())
   {
      std::string topic {};
      getConfigItem(("mqttCmdTopic" + cmdTopicKey).c_str(), topic);

      if (topic.empty())
      {
         if (address == na)
            return nullptr;

         // try lookup by key like 'VIC' (without address)
         //  until some types (devices) use one topic for all addresses

         return lookupCommandTopic(type, na);
      }

      commandTopicsMap[cmdTopicKey] = topic;
   }

   if (commandTopicsMap.find(cmdTopicKey) != commandTopicsMap.end() && !commandTopicsMap[cmdTopicKey].empty())
      return commandTopicsMap[cmdTopicKey].c_str();

   return nullptr;
}

//***************************************************************************
// Dispatch Other
//
// Data/State:
//   { "value": 77.0, "type": "P4VA", "address": 1, "unit": "°C", "title": "Abgas" }
//   { "state": 1, "address": 5, "type": "SMI260", "kind": "status", "title": "I Power On", "unit": "" }
//
// Script Trigger:
//   { "action": "trigger", "script": "lte.sh" }
//
// Registration of a topic to send "commands to the sensor:
//   { "action": "init", "type": "ALPICOOL", "topic": "homectld2mqtt/alpicool/in", "config" : true}
//***************************************************************************

int HomeCtl::dispatchOther(const char* topic, const char* message)
{
   // tell(eloAlways, "Debug: Dispatch '%s'", message);

   // check if we have a converter script - before parsing, the payload of foreign
   // devices (e.g. TASMOTA 'OFF') is usually no JSON, the script converts it

   char* converter {};
   asprintf(&converter, "%s/mqtt.d/%s.sh", confDir, strReplace("/", "_", topic).c_str());

   tell(eloDebug2, "Debug2: Checking for converter script for '%s [%s]", topic, converter);

   if (fileExists(converter))
   {
      FileStat fStat;
      fileStat(converter, fStat);

      // an empty converter script means skipping the message.

      if (!fStat.size)
      {
         free(converter);
         return done;
      }

      executeCommand("%s 'mqtt://%s/%s' '%s' '%s' %d", converter, mqttUrlPlain, INSTANCE "2mqtt/scripts", topic, message, ++mqttConverters[converter]);
      if (mqttConverters[converter] == 1)
         executeCommand("%s 'mqtt://%s/%s' '%s' '%s' %d", converter, mqttUrlPlain, INSTANCE "2mqtt/scripts", topic, message, ++mqttConverters[converter]);
      tell(eloScript, ".. '%s' done", converter);
      free(converter);
      return done;
   }

   free(converter);

   json_t* jData {jsonLoad(message)};

   if (!jData)
   {
      tell(eloAlways, "Error: (%s) Can't parse json in '%s'", topic, message);
      return fail;
   }

   std::string action {getStringFromJson(jData, "action", "update")};

   if (action == "trigger")
   {
      std::string script {getStringFromJson(jData, "script", "")};

      if (script.empty())
         return ignore;

      tell(eloScript, "Scripts: Got trigger for script '%s'", script.c_str());

      for (const auto& [address, sensor] : sensors["SC"])
      {
         if (sensor.name == script)
         {
            tell(eloAlways, "Script '%s' (%d) was triggered by MQTT", sensor.name.c_str(), address);
            callScript(address, "status");

            return done;
         }
      }

      return ignore;
   }

   // tell(eloAlways, "dispatch (%s) '%s'", topic, message);

   time_t newTime {time(0)};
   myString type = getStringFromJson(jData, "type", "");
   int address = getIntFromJson(jData, "address", na);

   bool valid {getBoolFromJson(jData, "valid", true)};
   const char* unit = getStringFromJson(jData, "unit");
   const char* title = getStringFromJson(jData, "title");
   const char* color = getStringFromJson(jData, "color", "");
   std::string kind = getStringFromJson(jData, "kind", "");
   uint rights = getIntFromJson(jData, "rights", 0);
   const char* image = getStringFromJson(jData, "image", "");
   const char* choices = getStringFromJson(jData, "choices", nullptr);
   json_t* jParameter = getObjectFromJson(jData, "parameter");
   const char* cmdTopic = getStringFromJson(jData, "topic");
   std::string deviceId = getStringFromJson(jData, "deviceid", "");

   if (type.empty())
   {
      tell(eloAlways, "Error: Missing 'type' in '%s' (dispatchOther) [%s]", topic, message);
      json_decref(jData);
      return fail;
   }

   if (action == "init")
   {
      if (!isEmpty(cmdTopic))
      {
         std::string cmdTopicKey {type};

         if (address != na)
            cmdTopicKey = type + ":" + std::to_string(address);

         commandTopicsMap[cmdTopicKey] = cmdTopic;
         setConfigItem(("mqttCmdTopic" + cmdTopicKey).c_str(), commandTopicsMap[cmdTopicKey].c_str());
      }

      tableValueFacts->clear();

      // publish IO config of MCP sensors to i2c process via mqtt

      for (bool f = selectActiveValueFacts->find(); f; f = selectActiveValueFacts->fetch())
      {
         if (!myString(tableValueFacts->getStrValue("TYPE")).starts_with("MCP"))
            continue;

         if (!tableValueFacts->getValue("SETTINGS")->isEmpty())
         {
            json_t* jCal {jsonLoad(tableValueFacts->getStrValue("SETTINGS"), 0, true)};

            if (jCal)
            {
               publishI2CSensorConfig(tableValueFacts->getStrValue("TYPE"), tableValueFacts->getIntValue("ADDRESS"), jCal);
               json_decref(jCal);
            }
            else
            {
               tell(eloAlways, "Ignoring invalid JSON in settings config of '%s:0x%lx'",
                    tableValueFacts->getStrValue("TYPE"), tableValueFacts->getIntValue("ADDRESS"));
            }
         }
      }

      selectActiveValueFacts->freeResult();

      // restore last state

      if (sensors[type][address].kind == "status" && sensors[type][address].outputModes & ooUser)
      {
         bool state {false};
         OutputMode mode {omManual};

         if (loadIoState(type.c_str(), address, state, mode) == success)
         {
            if (sensors[type][address].outputModes & ooAuto)
               sensors[type][address].mode = mode;

            // set (restore) the stored state

            const char* topic {lookupCommandTopic(type.c_str(), address)};

            if (!isEmpty(topic))
               switchCommand(type, address, "toggle", topic, state ? "1" : "0");
         }
      }

      // sensor expect config?

      bool config {getBoolFromJson(jData, "config")};

      tell(eloAlways, "Info: Sensor '%s' %sexpect config, sensor topic is '%s'",
           type.c_str(), config ? "" : "don't ", cmdTopic);

      if (type == "GPS")
         gpsReceiverPublishConfig();   // the receiver settings to gpsmqtt.py

      if (config)
      {
         // store 'parameters' (with deviceId' as key) send from the device
         // and make them avalible in the configuration

         json_t* jParameters {getObjectFromJson(jData, "parameters")};
         const char* deviceid {getStringFromJson(jData, "deviceid")};

         if (!isEmpty(deviceid))
         {
            std::string name {type + ':' + deviceid};

            if (jParameters)
            {
               char* tmp {json_dumps(jParameters, JSON_REAL_PRECISION(4))};
               std::string parameters {tmp};
               free(tmp);

               // read to avoid override

               std::string p;
               getConfigItem(name.c_str(), p);

               if (!p.empty())
                  parameters = p;

               // check if the config item is already known

               bool exist {configItemExists(name.c_str())};

               // store/refresh the definition of the sensors config item

               addConfigItem(name.c_str(),
                             ctText,               // type
                             parameters.c_str(),   // value
                             "S",                  // kind
                             false,                // internal
                             "Sensors",            // category
                             name.c_str(),         // title
                             "after changing this setting restart homectld");  // description

               if (!exist)
               {
                  readConfiguration(false);

                  json_t* oJson {json_object()};
                  config2Json(oJson);
                  pushOutMessage(oJson, "config");

                  oJson = json_array();
                  configDetails2Json(oJson);
                  pushOutMessage(oJson, "configdetails");
               }

               setConfigItem(name.c_str(), parameters.c_str(), "S");   // store

            }

            publishSensorInit(type.c_str(), name.c_str());
         }
      }

      json_decref(jData);
      return done;
   } // if (action == "init")

   if (type != "SC")
   {
      if (!title)
      {
         tell(eloAlways, "Error: Missing 'title' in '%s' (dispatchOther) [%s]", topic, message);
         json_decref(jData);
         return fail;
      }

      if (jParameter)
      {
         char* p {json_dumps(jParameter, 0)};  // don't free jParameter - only a reference to oData!

         tell(eloDebug, "Sensor parameter: '%s'", p);
         sensors[type][address].parameter = p;
         free(p);
      }

      if (type.starts_with("MCPO"))   // #TODO i2cmqtt sollte rights mit liefern!
         rights = urControl;

      if (!isEmpty(choices))          // #TODO alle mit steuerbaren choices (THEATFORD, VICTRON) sollten rights mit liefern!
         rights = urControl;

      addValueFact(address, type.c_str(), 1, title, unit, title, rights, choices, soNone, sensors[type][address].parameter.c_str());
   }

   if (type == "SC")    // SC - script sensor (send result async via MQTT)
   {
      newTime += 2;         // workaround due to async result of SC (if last is identical it's never stored)
      sensors[type][address].working = false;  // reset 'working' state (needed for SC sensors)
   }

   // ignore data for not active sensors

   if (!sensors[type][address].active)
   {
      json_decref(jData);
      return done;
   }

   sensors[type][address].setLastJson(topic, message, newTime);

   // ignore invalid data - don't publish and don't store

   if (!valid)
   {
      sensors[type][address].invalidate(newTime);
      json_decref(jData);
      return done;
   }

   sensors[type][address].battery = getIntFromJson(jData, "battery", na);
   sensors[type][address].kind = getStringFromJson(jData, "kind", "value");

   // ignore data for impulse (outputs)

   if (sensors[type][address].impulse)
   {
      json_decref(jData);
      return done;
   }

   if (type.starts_with("ADS"))
   {
      bool changed {updateAnalogInput(address, type.c_str(), getDoubleFromJson(jData, "value"), newTime, unit)};
      json_decref(jData);

      if (changed)
         triggerProcess = true;  // ADS Sensor (an unchanged value must not clear a trigger of another sensor)

      return success;
   }

   sensors[type][address].image = image;
   sensors[type][address].color = color;

   bool changed {false};

   if (sensors[type][address].kind == "value")
   {
      changed = sensors[type][address].setValue(getDoubleFromJson(jData, "value"), newTime);
   }
   else if (sensors[type][address].kind == "status")
   {
      bool state {getBoolFromJson(jData, "state")};

      changed = sensors[type][address].setState(sensors[type][address].invert ? !state : state, newTime);
      sensors[type][address].setText(getStringFromJson(jData, "text", ""), newTime);

      if (changed && sensors[type][address].outputModes & ooUser)
         storeIoState(type.c_str(), address);
   }
   else if (sensors[type][address].kind == "text")
   {
      changed = sensors[type][address].setText(getStringFromJson(jData, "text", ""), newTime);
   }
   else // ??
   {
      sensors[type][address].markChanged(newTime);
      changed = true;
   }

   sensors[type][address].value = getDoubleFromJson(jData, "value"); // needed rere, retundant??

   // handle feedback inputs
   //   -> setup output state if we got a feedback input

   // #TODO for GPIO ...

   if (type.starts_with("MCPI"))
   {
      for (const auto& itType : sensors)
      {
         myString _type {itType.first};

         if (!_type.starts_with("MCPO") && _type != "DO")
            continue;

         for (const auto& s : sensors[_type])
         {
            myString feedbackInType = s.second.feedbackInType;

            if (feedbackInType.starts_with("MCPI") && s.second.feedbackInAddress == (uint)address)
            {
               sensors[_type][s.first].setState(sensors[type][address].state);
               publishPin(_type.c_str(), s.first);
            }
         }
      }
   }

   if (changed)
   {
      // tell(eloAlways, "triggerProcess on '%s:0x%x' change to '%f' [%s]",
      //      type.c_str(), address, sensors[type][address].value, sensors[type][address].kind.c_str());

      triggerProcess = true; // dispatchOther
   }

   // the live position: also an unchanged one is taken over (after a restart the receiver may stand
   //  still for hours with 'static hold', the WEBIF asks for the position when the map page is opened);
   //  0/0 comes from a receiver without fix (e.g. right after the start of gpsmqtt.py), no position

   if (type == "GPS" && address == gpsCoordinateAddress)
   {
      GpsCoordinate c;

      if (parseGpsText(sensors[type][address].text.c_str(), c) && (c.latitude != 0.0 || c.longitude != 0.0))
      {
         bool first {!gpsCoordinate.latitude && !gpsCoordinate.longitude};

         gpsCoordinate = c;

         if (changed || first)
         {
            gpsLive(nullptr, 0);
            gpsTourUpdate(time(0));
         }
      }
   }

   // send update to WS
   {
      json_t* ojData {json_object()};
      sensor2Json(ojData, type.c_str(), address);

      if (kind == "status")
         json_object_set_new(ojData, "value", json_integer(sensors[type][address].state));
      else
         json_object_set_new(ojData, "value", json_real(sensors[type][address].value));

      json_object_set_new(ojData, "text", json_string(sensors[type][address].text.c_str()));

      if (sensors[type][address].battery != na)
         json_object_set_new(ojData, "battery", json_integer(sensors[type][address].battery));

      if (sensors[type][address].image.length())
         json_object_set_new(ojData, "image", json_string(sensors[type][address].image.c_str()));

      char* tuple {};
      asprintf(&tuple, "%s:0x%02x", type.c_str(), address);
      jsonSensorList[tuple] = ojData;
      free(tuple);

      pushDataUpdate("update", 0L);
   }

   mqttHaPublish(sensors[type][address]);
   mqttNodeRedPublishSensor(sensors[type][address]);
   json_decref(jData);

   return done;
}

//***************************************************************************
// Init Config Table
//   the configuration definition (config.c) is the source of the 'N' items,
//   they are written to the config table here. Beside this all further access
//   to the configuration is done via the config table!
//***************************************************************************

int HomeCtl::initConfigTable()
{
   std::set<std::string> known;
   int ord {0};

   for (const auto& it : configuration)
   {
      known.insert(it.name);

      tableConfig->clear();
      tableConfig->setValue("OWNER", myName());
      tableConfig->setValue("NAME", it.name.c_str());

      bool insert {!tableConfig->find()};

      tableConfig->setValue("TYPE", it.type);
      tableConfig->setValue("TITLE", it.title.c_str());
      tableConfig->setValue("CATEGORY", it.category.c_str());
      tableConfig->setValue("DESCRIPTION", it.description.c_str());
      tableConfig->setValue("INTERNAL", it.internal ? "Y" : "N");
      tableConfig->setValue("KIND", it.kind.c_str());
      tableConfig->setValue("ORD", ord++);

      if (insert)
         tableConfig->setValue("VALUE", it.def.c_str());

      tableConfig->store();
      tableConfig->reset();
   }

   // check the table for items no longer part of the configuration definition
   //   and for items implicitly created by setConfigItem() (they don't have a category)

   std::vector<std::string> obsolete;
   std::vector<std::string> internal;

   tableConfig->clear();
   tableConfig->setValue("OWNER", myName());

   for (bool f = selectAllConfig->find(); f; f = selectAllConfig->fetch())
   {
      const char* name {tableConfig->getStrValue("NAME")};

      if (tableConfig->hasValue("KIND", "N"))
      {
         if (!known.count(name))
            obsolete.push_back(name);
      }
      else if (isEmpty(tableConfig->getStrValue("CATEGORY")) && !tableConfig->hasValue("INTERNAL", "Y"))
      {
         internal.push_back(name);
      }
   }

   selectAllConfig->freeResult();

   for (const auto& name : obsolete)
   {
      tell(eloAlways, "Info: Removing obsolete config item '%s'", name.c_str());
      tableConfig->deleteWhere("owner = '%s' and name = '%s'", myName(), name.c_str());
   }

   for (const auto& name : internal)
   {
      tell(eloAlways, "Info: Marking config item '%s' as internal", name.c_str());

      tableConfig->clear();
      tableConfig->setValue("OWNER", myName());
      tableConfig->setValue("NAME", name.c_str());

      if (tableConfig->find())
      {
         tableConfig->setValue("KIND", "I");
         tableConfig->setValue("INTERNAL", "Y");
         tableConfig->setValue("ORD", (long)coDynamic);
         tableConfig->store();
      }

      tableConfig->reset();
   }

   return success;
}

//***************************************************************************
// Config Item Exists
//***************************************************************************

bool HomeCtl::configItemExists(const char* name, ConfigItemType* type)
{
   tableConfig->clear();
   tableConfig->setValue("OWNER", myName());
   tableConfig->setValue("NAME", name);

   bool exist {(bool)tableConfig->find()};

   if (exist && type)
      *type = (ConfigItemType)tableConfig->getIntValue("TYPE");

   tableConfig->reset();

   return exist;
}

//***************************************************************************
// Add Config Item
//   create/edit a config item at runtime (sensor or user defined options)
//***************************************************************************

int HomeCtl::addConfigItem(const char* name, ConfigItemType type, const char* value, const char* kind,
                          bool internal, const char* category, const char* title, const char* description,
                          int ord)
{
   tableConfig->clear();
   tableConfig->setValue("OWNER", myName());
   tableConfig->setValue("NAME", name);

   bool insert {!tableConfig->find()};

   tableConfig->setValue("TYPE", type);
   tableConfig->setValue("TITLE", title);
   tableConfig->setValue("CATEGORY", category);
   tableConfig->setValue("DESCRIPTION", description);
   tableConfig->setValue("INTERNAL", internal ? "Y" : "N");
   tableConfig->setValue("KIND", kind);
   tableConfig->setValue("ORD", (long)ord);

   if (insert)
      tableConfig->setValue("VALUE", value);

   int status {tableConfig->store()};
   tableConfig->reset();

   return status;
}

//***************************************************************************
// Config Data
//***************************************************************************

int HomeCtl::getConfigItem(const char* name, std::string& value, const char* def)
{
   value.clear();

   tableConfig->clear();
   tableConfig->setValue("OWNER", myName());
   tableConfig->setValue("NAME", name);

   if (tableConfig->find())
   {
      value = tableConfig->getStrValue("VALUE");
   }
   else if (!isEmpty(def))
   {
      value = def;
      setConfigItem(name, value.c_str());  // store the default
   }

   tableConfig->reset();

   return success;
}

int HomeCtl::setConfigItem(const char* name, const char* value, const char* kind)
{
   tell(eloDebug2, "Debug2: Storing config '%s' with value '%s'", name, value);
   tableConfig->clear();
   tableConfig->setValue("OWNER", myName());
   tableConfig->setValue("NAME", name);

   // load the already stored row (if any), otherwise the update would
   //   clear all fields we don't set here (TYPE, TITLE, CATEGORY, ...)

   bool exist {(bool)tableConfig->find()};

   tableConfig->setValue("VALUE", value);

   // config option 'kind'

   // N - Normal                 - Page as described in config structure
   // U - User defined           - Page 'User Options'
   // I - Ingternal              - Page not shown
   // S - Special Sensor options - Page 'Sensors' (we get it direct from the Sensor by MQTT)
   //
   // if kind is set to the default 'N' check if we have to patch it
   // if kind is empty it's only a update of a already stores option - leave it

   if (*kind == 'N')
   {
      // the option is known if it's already stored in the config table,
      //   in this case leave its kind untouched. Otherwise it's a option
      //   created on the fly (a default of getConfigItem) -> internal

      if (exist)
      {
         kind = "";
      }
      else
      {
         kind = "I";
         tableConfig->setValue("INTERNAL", "Y");
         tableConfig->setValue("ORD", (long)coDynamic);
      }
   }

   if (!isEmpty(kind))
      tableConfig->setValue("KIND", kind);

   int status {tableConfig->store()};
   tableConfig->reset();

   return status;
}

int HomeCtl::getConfigItem(const char* name, int& value, int def)
{
   std::string txt;

   getConfigItem(name, txt);

   if (!txt.empty())
      value = atoi(txt.c_str());
   else if (txt.empty() && def != na)
   {
      value = def;
      setConfigItem(name, (long)value);
   }
   else
      value = 0;

   return success;
}

int HomeCtl::getConfigItem(const char* name, long& value, long def)
{
   std::string txt;

   getConfigItem(name, txt);

   if (!txt.empty())
      value = atol(txt.c_str());
   else if (txt.empty() && def != na)
   {
      value = def;
      setConfigItem(name, value);
   }
   else
      value = 0;

   return success;
}

int HomeCtl::setConfigItem(const char* name, long value, const char* kind)
{
   char txt[16] {};

   snprintf(txt, sizeof(txt), "%ld", value);

   return setConfigItem(name, txt, kind);
}

int HomeCtl::getConfigItem(const char* name, double& value, double def)
{
   std::string txt;

   getConfigItem(name, txt);

   if (!txt.empty())
      value = strtod(txt.c_str(), nullptr);
   else if (txt.empty() && def != naf)
   {
      value = def;
      setConfigItem(name, value);
   }
   else
      value = 0.0;

   tell(eloDebug, "Debug: getConfigItem '%s' now %.2f [%s]", name, value, txt.c_str());

   return success;
}

int HomeCtl::setConfigItem(const char* name, double value, const char* kind)
{
   char txt[16+TB] {};
   snprintf(txt, sizeof(txt), "%.2f", value);
   return setConfigItem(name, txt, kind);
}

int HomeCtl::getConfigItem(const char* name, bool& value, bool def)
{
   std::string txt;

   getConfigItem(name, txt);

   if (!txt.empty())
      value = atoi(txt.c_str());
   else if (txt.empty())
   {
      value = def;
      setConfigItem(name, value);
   }

   return success;
}

int HomeCtl::setConfigItem(const char* name, bool value, const char* kind)
{
   char txt[16] {};

   snprintf(txt, sizeof(txt), "%d", value ? 1 : 0);

   return setConfigItem(name, txt, kind);
}

//***************************************************************************
// Get Config Time Range Item
//***************************************************************************

int HomeCtl::getConfigTimeRangeItem(const char* name, std::vector<Range>& ranges)
{
   std::string tmp;
   getConfigItem(name, tmp, "");
   ranges.clear();

   char* buf {};
   asprintf(&buf, "%s", tmp.c_str());

   for (const char* r = strtok(buf, ","); r; r = strtok(0, ","))
   {
      uint fromHH {0}, fromMM {0}, toHH {0}, toMM {0};

      if (sscanf(r, "%u:%u-%u:%u", &fromHH, &fromMM, &toHH, &toMM) == 4)
      {
         uint from = fromHH*100 + fromMM;
         uint to = toHH*100 + toMM;

         ranges.push_back({from, to});
         tell(eloDebug2, "Schedule range %d - %d for '%s'", from, to, name);
      }
      else
      {
         tell(eloAlways, "Error: Unexpected range '%s' for '%s'", r, name);
      }
   }

   free(buf);

   return success;
}

//***************************************************************************
// Toggle Color
//***************************************************************************

int HomeCtl::toggleColor(uint addr, const char* type, int hue, int sat, int bri)
{
   cDbRow* fact {valueFactRowOf(type, addr)};

   if (!fact)
      return fail;

   if (strcmp(type, "DZL") == 0)
      deconz.color(type, addr, hue, sat, bri);

   return success;
}

//***************************************************************************
// Digital IO Stuff
//***************************************************************************

int HomeCtl::toggleIo(uint addr, const char* type, int state, int bri, int transitiontime)
{
   cDbRow* fact {valueFactRowOf(type, addr)};

   if (!fact)
   {
      tell(eloAlways, "Warning: toggleio() fact for %s:0x%02x not found", type, addr);
      return fail;
   }

   int newState {state == na ? !sensors[type][addr].state : state};
   tell(eloDebugGpio, "Debug: GPIO: toggleio() '%s:0x%02x' to '%s'", type, addr, newState ? "true" : "false");

   if (strcmp(type, "DO") == 0 || strcmp(type, "GPIO") == 0)
      gpioWrite(addr, newState);
   else if (strcmp(type, "SC") == 0)
      callScript(addr, "toggle");
   else if (strcmp(type, "DZL") == 0 || strcmp(type, "DZLG") == 0)
   {
      lightCommands.erase(lightKey(type, addr));   // by hand, no check
      deconz.toggle(type, addr, newState, bri, transitiontime);
   }
   else if (strcmp(type, "HMB") == 0)
   {
      double value = sensors[type][addr].value;
      tell(eloDebug, "Debug: toggleIo - last direction = '%s', level was %d",
           sensors[type][addr].lastDir == dirOpen ? "open" : "close", (int)sensors[type][addr].value);

      if (bri == na && (sensors[type][addr].lastDir == dirOpen || sensors[type][addr].value == 100))
         value = 0;
      else if (bri == na && (sensors[type][addr].lastDir == dirClose || sensors[type][addr].value == 0))
         value = 100;
      else
         value = bri;

      tell(eloDebug, "Debug: toggleIo - sending level %d", (int)sensors[type][addr].value);

      sensors[type][addr].state = newState;
      mqttNodeRedPublishAction(sensors[type][addr], value);

      /* char* request {};
      asprintf(&request, "{ \"method\" : \"getDeviceDescription\", \"parameters\" : [\"%s\"] }", uuid);
      mqttWriter->write(INSTANCE "2mqtt/homematic/rpccall", request);
      tell(eloHomeMatic, "-> (home-matic) '%s' to '%s'", INSTANCE "2mqtt/homematic/rpccall", request);
      free(request);*/
   }
   else if (!commandTopicsMap[type].empty())  //  if (myString(type).starts_with("MCPO"))
   {
      // {"type": "MCPO27", "address": 0, "state": false}'

      if (sensors[type][addr].active)
      {
         // if (commandTopicsMap[type].empty())
         // {
         //    tell(eloAlways, "Error: Can't toggle %s:0x%02d, missing i2c topic", type, addr);
         //    return done;
         // }

         tell(eloAlways, "Toggle %s:0x%02d to %d", type, addr, state);

         bool state {!sensors[type][addr].state};
         json_t* obj {json_object()};

         json_object_set_new(obj, "type", json_string(type));
         json_object_set_new(obj, "address", json_integer(addr));

         if (!sensors[type][addr].impulse)
         {
            state = sensors["type"][addr].invert ? !state : state;
            json_object_set_new(obj, "value", json_integer(sensors["type"][addr].invert ? !state : state));

            json_object_set_new(obj, "action", json_string(state ? "set" : "clear"));  // MCP special
         }
         else
            json_object_set_new(obj, "action", json_string("impulse"));

         char* message {json_dumps(obj, JSON_REAL_PRECISION(8))};
         json_decref(obj);
         mqttWriter->write(commandTopicsMap[type].c_str(), message);
         free(message);
      }
   }

   return success;
}

int HomeCtl::toggleIoNext(uint pin)
{
   if (sensors["DO"][pin].state)
   {
      toggleIo(pin, "DO");
      usleep(300000);
      toggleIo(pin, "DO");
      return success;
   }

   gpioWrite(pin, true);

   return success;
}

void HomeCtl::pin2Json(json_t* ojData, const char* type, uint pin)
{
   json_object_set_new(ojData, "address", json_integer(pin));
   json_object_set_new(ojData, "type", json_string(type));
   json_object_set_new(ojData, "valid", json_boolean(sensors[type][pin].valid()));
   json_object_set_new(ojData, "mode", json_string(sensors[type][pin].mode == omManual ? "manual" : "auto"));

   // pin state -> value

   if (sensors[type][pin].feedbackInType.empty())
   {
      json_object_set_new(ojData, "value", json_integer(sensors[type][pin].state));
   }
   else
   {
      const char* fbType = sensors[type][pin].feedbackInType.c_str();
      uint fbAddr = sensors[type][pin].feedbackInAddress;
      json_object_set_new(ojData, "value", json_integer(sensors[fbType][fbAddr].state));
   }
}

int HomeCtl::toggleOutputMode(json_t* oObject, long client)
{
   int addr {getIntFromJson(oObject, "address")};
   const char* type {getStringFromJson(oObject, "type")};

   // allow mode toggle only if more than one option is given

   if (sensors[type][addr].outputModes & ooAuto && sensors[type][addr].outputModes & ooUser)
   {
      OutputMode mode = sensors[type][addr].mode == omAuto ? omManual : omAuto;
      // tell(eloDetail, "Info: Toggle output mode of 'DO:0x%x' to (%d)", addr, mode);
      sensors[type][addr].mode = mode;
      storeIoState(type, addr);
      publishPin(type, addr);
   }

   return success;
}

//***************************************************************************
// On GPIO Change
//  !Attention!
//    calles in thred dont use database access functions like gpioWrite(), ...
//***************************************************************************

void HomeCtl::onGpioChange(int physPin, bool value)
{
   tell(eloDebugGpio, "Debug: GPIO: Interrupt trigger for pin %d (%s)", physPin, value ? "ON" : "OFF");
   triggerGpioPins.push(physPin);
}

void HomeCtl::gpioWrite(uint pin, bool state, bool saveIoState)
{
   // #TODO for GPIO
   // workaround! -->

   std::string type {"DO"};

   if (auto it = sensors.find("GPIO"); it != sensors.end())
   {
      auto itSensors = it->second.find(pin);

      if (itSensors != it->second.end() && itSensors->second.active && itSensors->second.fct == "out")
         type = "GPIO";
   }

   // <--

   if (sensors[type][pin].impulse)
   {
      tell(eloDebug, "Debug: Trigger impulse for %s:0x%02x", type.c_str(), pin);
      gpio->digitalWrite(pin, false);
      usleep(50000); // 50 ms
      gpio->digitalWrite(pin, true);

      sensors[type][pin].setState(true);
   }
   else
   {
      // invert the state on 'invert' - most relay board are active at 'false'

      sensors[type][pin].setState(state);
      bool invState {sensors[type][pin].invert ? !state : state};

      tell(eloDebugGpio, "Debug: GPIO: calling digitalWrite(%s:0x%x, %d), invert was %s",
           type.c_str(), pin, invState, sensors[type][pin].invert ? "true" : "false");

      gpio->digitalWrite(pin, invState);
   }

   if (saveIoState)
      storeIoState(type.c_str(), pin);

   performJobs();

   publishPin(type.c_str(), pin); // send update to WS
   mqttHaPublish(sensors[type][pin]);
   mqttNodeRedPublishSensor(sensors[type][pin]);
}

//***************************************************************************
// GPIO Read
//***************************************************************************

bool HomeCtl::gpioRead(uint pin, bool check)
{
   int state {gpio->digitalRead(pin)};
   bool changed {false};

   // #TODO for GPIO
   // workaround!
   // -->
   std::string type {"DI"};

   if (auto it = sensors.find("GPIO"); it != sensors.end())
   {
      auto itSensors = it->second.find(pin);

      if (itSensors != it->second.end() && itSensors->second.active && itSensors->second.fct == "in")
         type = "GPIO";
   }

   // <--


   tell(eloDebugGpio, "Debug: GPIO: gpioRead(%s:0x%x) got '%s' (%sinverted)",
        type.c_str(), pin, state ? "true" : "false", sensors[type][pin].invert ? "" : "not ");

   if (sensors[type][pin].invert)
      state = !state;

   // tell(eloAlways, "Pin %d %d / %d", pin, sensors[type][pin].state, state);

   sensors[type][pin].touch();

   if (check && sensors[type][pin].state == state)
      return state;

   changed = sensors[type][pin].setState(state);

   // check 'linked' output(s)

   for (const auto& itType : sensors)
   {
      myString _type {itType.first};

      // #TODO for GPIO

      if (!_type.starts_with("MCPO") && _type != "DO")
          continue;

      for (const auto& s : sensors[_type])
      {
         if (s.second.feedbackInType == type && s.second.feedbackInAddress == pin)
         {
            sensors[_type][s.first].setState(state);
            publishPin(_type.c_str(), s.first);
         }
      }
   }

   publishPin(type.c_str(), pin);
   mqttHaPublish(sensors[type][pin]);
   mqttNodeRedPublishSensor(sensors[type][pin]);

   if (changed)
      process(false, true);

   return sensors[type][pin].state;
}

//***************************************************************************
// Publish Victron Init
//***************************************************************************

void HomeCtl::publishVictronInit(const char* type)
{
   if (commandTopicsMap.find(type) == commandTopicsMap.end())
   {
      std::string topic;
      getConfigItem((std::string("mqttCmdTopic") + type).c_str(), topic);

      if (!topic.empty())
         commandTopicsMap[type] = topic;
   }

   if (commandTopicsMap.find(type) == commandTopicsMap.end() || commandTopicsMap[type].empty())
   {
      tell(eloAlways, "Info: Skip init victron '%s', missing topic", type);
      return;
   }

   mqttCheckConnection();

   if (!mqttWriter)
   {
      tell(eloAlways, "Error: Can't init victron for '%s', missing broker at '%s'", type, mqttUrl.c_str());
      return;
   }

   json_t* jConfig {json_object()};

   json_object_set_new(jConfig, "action", json_string("init"));
   json_object_set_new(jConfig, "type", json_string(type));

   char* message {json_dumps(jConfig, JSON_REAL_PRECISION(8))};
   json_decref(jConfig);
   mqttWriter->write(commandTopicsMap[type].c_str(), message);
   free(message);
}

//***************************************************************************
// Publish/Request Sensor Init
//   for MQTT sensors (ESP32 sketches like alpicool, kenwood) which accept a
//   config packet: request their init message / send them their config
//
//    #TODO
//     - collect publish????Init methods
//***************************************************************************

void HomeCtl::requestSensorInit(const char* type)
{
   if (!lookupCommandTopic(type, na))
   {
      tell(eloAlways, "Info: Skip request-init from '%s', missing topic", type);
      return;
   }

   json_t* jInit {json_object()};
   json_object_set_new(jInit, "type", json_string(type));
   json_object_set_new(jInit, "action", json_string("requestinit"));

   char* message {json_dumps(jInit, JSON_REAL_PRECISION(8))};
   json_decref(jInit);
   mqttWriter->write(commandTopicsMap[type].c_str(), message);
   free(message);
}

void HomeCtl::publishSensorInit(const char* type, const char* name)
{
   if (!lookupCommandTopic(type, na))
   {
      tell(eloAlways, "Info: Skip init '%s', missing topic", type);
      return;
   }

   mqttCheckConnection();

   if (!mqttWriter)
   {
      tell(eloAlways, "Error: Can't init for '%s', missing broker at '%s'", type, mqttUrl.c_str());
      return;
   }

   // {"type": "ALPICOOL", "action": "init", "config": {"eloquence": 3, "interval": 20} }

   std::string message;
   getConfigItem(name, message);

   if (!message.empty())
   {
      json_t* jSetup {json_object()};
      json_object_set_new(jSetup, "type", json_string(type));
      json_object_set_new(jSetup, "action", json_string("init"));

      json_t* jConfig {jsonLoad(message.c_str())};
      json_object_set_new(jSetup, "config", jConfig);

      char* tmp = json_dumps(jSetup, JSON_REAL_PRECISION(8));
      json_decref(jSetup);
      // tell(eloAlways, "DEBUG: SEND '%s'", tmp);
      mqttWriter->write(commandTopicsMap[type].c_str(), tmp);
      free(tmp);
   }
}

//***************************************************************************
// Publish I2C Sensor Config
//***************************************************************************

void HomeCtl::publishI2CSensorConfig(const char* type, uint pin, json_t* jParameters)
{
   if (commandTopicsMap.find(type) == commandTopicsMap.end())
   {
      std::string topic;
      getConfigItem((std::string("mqttCmdTopic") + type).c_str(), topic);

      if (!topic.empty())
         commandTopicsMap[type] = topic;
   }

   if (commandTopicsMap.find(type) == commandTopicsMap.end() || commandTopicsMap[type].empty())
   {
      tell(eloAlways, "Error: Can't init victron for '%s', missing topic", type);
      return;
   }

   json_t* jConfig {json_object()};

   json_object_set_new(jConfig, "action", json_string("init"));
   json_object_set_new(jConfig, "type", json_string(type));
   json_object_set_new(jConfig, "address", json_integer(pin));
   json_object_set(jConfig, "config", jParameters);  // not json_object_set_new until calller free jCal!

   char* message = json_dumps(jConfig, JSON_REAL_PRECISION(8));
   mqttWriter->write(commandTopicsMap[type].c_str(), message);
   free(message);
   json_decref(jConfig);
}

//***************************************************************************
// Publish Pin State
//***************************************************************************

void HomeCtl::publishPin(const char* type, uint pin)
{
   json_t* ojData {json_object()};
   pin2Json(ojData, type, pin);

   char* key {};
   asprintf(&key, "%s:0x%02x", type, pin);
   jsonSensorList[key] = ojData;
   free(key);

   pushDataUpdate("update", 0L);
}

//***************************************************************************
// Publish Special Value
//***************************************************************************

// void HomeCtl::publishSpecialValue(int addr)
// {
//    cDbRow* fact = valueFactRowOf("SP", addr);

//    if (!fact)
//       return ;

//    json_t* ojData {json_object()};

//    sensor2Json(ojData, "SP", addr);

//    if (sensors["SP"][addr].kind == "text")
//       json_object_set_new(ojData, "text", json_string(sensors["SP"][addr].text.c_str()));
//    else if (sensors["SP"][addr].kind == "value")
//       json_object_set_new(ojData, "value", json_real(sensors["SP"][addr].value));

//    if (sensors["SP"][addr].disabled)
//       json_object_set_new(ojData, "disabled", json_boolean(true));

//    char* tuple {};
//    asprintf(&tuple, "SP:0x%02x", addr);
//    jsonSensorList[tuple] = ojData;
//    free(tuple);

//    pushDataUpdate("update", 0L);
// }

//***************************************************************************
// Store/Load Output State
//***************************************************************************

int HomeCtl::storeIoState(const char* type, uint address)
{
   tell(eloDebug, "Debug: Store IO state of '%s:0x%x' [%d]", type, address, sensors[type][address].state);

   tableIoStates->clear();
   tableIoStates->setValue("TYPE", type);
   tableIoStates->setValue("ADDRESS", (int)address);

   tableIoStates->setValue("TIME", sensors[type][address].changedAt());
   tableIoStates->setValue("LAST", sensors[type][address].last());
   tableIoStates->setValue("KIND", sensors[type][address].kind.c_str());
   tableIoStates->setValue("STATE", sensors[type][address].state);
   tableIoStates->setValue("VALUE", sensors[type][address].value);
   tableIoStates->setValue("TEXT", sensors[type][address].text.c_str());
   tableIoStates->setValue("MODE", sensors[type][address].mode);
   tableIoStates->store();

   return done;
}

int HomeCtl::loadIoState(const char* type, uint address, bool& state, OutputMode& mode)
{
   tableIoStates->clear();
   tableIoStates->setValue("TYPE", type);
   tableIoStates->setValue("ADDRESS", (int)address);

   if (!tableIoStates->find())
      return fail;

   // changedAt = tableIoStates->getTimeValue("TIME");
   // value = tableIoStates->getIntValue("VALUE");
   state = tableIoStates->getIntValue("STATE") == 1;
   mode = (OutputMode)tableIoStates->getIntValue("MODE");

   return success;
}

int HomeCtl::loadIoStates()
{
   tableIoStates->clear();

   for (bool f = selectAllIoStates->find(); f; f = selectAllIoStates->fetch())
   {
      std::string type {tableIoStates->getStrValue("TYPE")};
      uint address {(uint)tableIoStates->getIntValue("ADDRESS")};
      bool state {(bool)tableIoStates->getIntValue("STATE")};

      if (!sensors[type][address].active)
         continue;

      if (sensors[type][address].impulse || !(sensors[type][address].outputModes & ooUser))
         continue;

      tell(eloDebug2, "Debug2: Recover IO state of '%s:0x%x' to '%s', mode to (%ld)",
           type.c_str(), address, state ? "true" : "false", tableIoStates->getIntValue("MODE"));

      sensors[type][address].restoreChangedAt(tableIoStates->getTimeValue("TIME"));

      // the row exists for every stored sensor (store() -> storeIoState()) - restore the last
      // stored value only for sensors without current data, data received during the init
      // (MQTT, script init, ..) must not be overwritten (it counts as unstored and would be stored as 0)

      if (!sensors[type][address].valid())
      {
         sensors[type][address].value = tableIoStates->getFloatValue("VALUE");   // VALUE is a float column, getIntValue() returned 0
         sensors[type][address].text = tableIoStates->getStrValue("TEXT");
         sensors[type][address].state = state;

         // the restored data is valid (the WEBIF shows invalid sensors dimmed until new data
         // arrives) but not unstored, store() won't write it as a new sample

         if (time_t last {tableIoStates->getTimeValue("LAST")}; last)
            sensors[type][address].restoreLast(last);

         // the kind (status / value / text) is only known from the sensor's data, without it a
         // restored status sensor is published as 'value' (e.g. -1 -> shown as 'on' by the WEBIF)

         if (!isEmpty(tableIoStates->getStrValue("KIND")))
            sensors[type][address].kind = tableIoStates->getStrValue("KIND");

         sensors[type][address].markValid();
      }

      if (sensors[type][address].outputModes & ooAuto)
         sensors[type][address].mode = (OutputMode)tableIoStates->getIntValue("MODE");

      if (type == "DO" || (type == "GPIO" && sensors[type][address].fct == "out"))
      {
         gpioWrite(address, state, false);
         tell(eloDetail, "Info: IO state of '%s:0x%02x' recovered to '%s'", type.c_str(), address, state ? "true" : "false");
      }
      else
      {
         // MCPO and other IOs connected via MQTT are restored
         // as part of the MQTT/INIT message.
      }
   }

   selectAllIoStates->freeResult();
   ioStatesLoaded = true;

   // init sensors last info

   tableValueFacts->clear();

   for (bool f = selectAllValueFacts->find(); f; f = selectAllValueFacts->fetch())
   {
      const char* type {tableValueFacts->getStrValue("TYPE")};
      long address {tableValueFacts->getIntValue("ADDRESS")};

      if (!sensors[type][address].active)
         continue;

      tableSamples->clear();
      tableSamples->setValue("TYPE", type);
      tableSamples->setValue("ADDRESS", address);

      if (!selectSensorMaxTime->find())
         continue;

      if (tableSamples->getTimeValue("TIME") > sensors[type][address].last())   // iostates LAST may be newer
         sensors[type][address].restoreLast(tableSamples->getTimeValue("TIME"));

      tell(eloDebug, "Debug: Init 'last' of '%s:0x%02lx' to '%s'", type, address, l2pTime(sensors[type][address].last()).c_str());
   }

   selectAllValueFacts->freeResult();

   // nothing is unstored at start - store() writes a sensor only after it got
   // new data (before: the first store wrote 0 for all sensors not reported yet)

   return done;
}

//***************************************************************************
// Arduino Stuff ...
//***************************************************************************

int HomeCtl::dispatchArduinoMsg(const char* message)
{
   json_t* jObject {jsonLoad(message)};

   if (!jObject)
   {
      tell(eloAlways, "Error: Can't parse json in '%s'", message);
      return fail;
   }

   const char* event = getStringFromJson(jObject, "event", "<null>");

   if (strcmp(event, "update") == 0)
   {
      bool changed {false};
      json_t* jArray = getObjectFromJson(jObject, "analog");
      size_t index {0};
      json_t* jValue {};

      json_array_foreach(jArray, index, jValue)
      {
         const char* name = getStringFromJson(jValue, "name");
         std::string unit = getStringFromJson(jValue, "unit", "");
         double value = getDoubleFromJson(jValue, "value");
         time_t stamp = getIntFromJson(jValue, "time", 0);
         const char* type = "AI";
         uint addr = atoi(name+1);

         if (!stamp)
            stamp = time(0);

         if (stamp < time(0)-300)
         {
            tell(eloInfo, "Skipping old (%ld seconds) arduino value", time(0)-stamp);
            continue;
         }

         if (unit == "dig")
            unit = "%";

         if (unit == "")
            unit = addr <= 7 ? "%" : "mV";

         std::string title {"Analog Input (Arduino) " + std::to_string(addr)};

         if (sensors[type][addr].active) // don't override unit if sensor already exist
            unit.clear();

         addValueFact(addr, type, 1, title.c_str(), unit.c_str());
         changed |= updateAnalogInput(addr, type, value, stamp, unit.c_str());

         char* raw {json_dumps(jValue, JSON_COMPACT)};
         sensors[type][addr].setLastJson("arduino/out", raw, stamp);
         free(raw);
      }

      if (changed)
      {
         // tell(eloAlways, "triggerProcess on AI change");
         triggerProcess = true;  // arduino message
      }
   }
   else if (strcmp(event, "init") == 0)
      initArduino();
   else
      tell(eloAlways, "Got unexpected event '%s' from arduino", event);

   json_decref(jObject);

   return success;
}

//***************************************************************************
// Init Arduino
//***************************************************************************

int HomeCtl::initArduino()
{
   tell(eloAlways, "initArduino(%s); connected %d", mqttUrl.c_str(), mqttReader->isConnected());

   mqttCheckConnection();

   if (mqttUrl.empty() || !mqttReader->isConnected())
      return fail;

   json_t* oJson {json_object()};

   json_object_set_new(oJson, "event", json_string("setUpdateInterval"));
   json_object_set_new(oJson, "parameter", json_integer(arduinoInterval));

   char* p = json_dumps(oJson, JSON_REAL_PRECISION(4));
   json_decref(oJson);

   if (!p)
   {
      tell(eloAlways, "Error: Dumping json message failed");
      return fail;
   }

   if (mqttReader->isConnected())
   {
      std::string topic = std::string(arduinoTopic) + "/in";
      mqttReader->write(topic.c_str(), p);
      tell(eloAlways, "Debug: [ARDUINO] PushMessage to arduino topic '%s' [%s]", topic.c_str(), p);
   }

   free(p);

   return success;
}

//***************************************************************************
// Update Analog Input
//***************************************************************************

bool HomeCtl::updateAnalogInput(uint addr, const char* type, double value, time_t stamp, const char* unit)
{
   // the Ardoino read the analog inputs with a resolution of 12 bits (3.3V => 4095)
   // the MCP read the analog inputs with a resolution of ... bits ...

   if (!sensors[type][addr].active)
      return false;

   double dValue {value};

   if (aiSensorConfig[type][addr].calPointValueA || aiSensorConfig[type][addr].calPointValueB)
   {
      double m = (aiSensorConfig[type][addr].calPointB - aiSensorConfig[type][addr].calPointA) / (aiSensorConfig[type][addr].calPointValueB - aiSensorConfig[type][addr].calPointValueA);
      double b = aiSensorConfig[type][addr].calPointB - m * aiSensorConfig[type][addr].calPointValueB;
      dValue = m * value + b;
   }

   if (aiSensorConfig[type][addr].round)
   {
      double oValue {dValue};
      dValue = std::llround(dValue*aiSensorConfig[type][addr].round) / aiSensorConfig[type][addr].round;
      tell(eloDebug, "Debug: Rounded %.2f to %.2f", oValue, dValue);
   }

   if (dValue < aiSensorConfig[type][addr].cutBelow)
      dValue = 0.0;

   bool changed {sensors[type][addr].setValue(dValue, stamp)};

   if (changed)
      tell(eloDebug, "Debug: %s:0x%02x changed to %f", type, addr, dValue);

   tell(eloDebug, "Debug: Input A%d (%s:0x%02x): %.3f%s [%.2f] from '%s'", addr,
        sensors[type][addr].type.c_str(), sensors[type][addr].address,
        sensors[type][addr].value, sensors[type][addr].unit.c_str(),
        value, l2pTime(sensors[type][addr].last()).c_str());

   // ----------------------------------

   json_t* ojData {json_object()};

   sensor2Json(ojData, type, addr);

   json_object_set_new(ojData, "value", json_real(sensors[type][addr].value));
   json_object_set_new(ojData, "plain", json_real(value)); // plain sensor value (without user settings)

   char* tuple {};
   asprintf(&tuple, "%s:0x%02x", type, addr);
   jsonSensorList[tuple] = ojData;
   free(tuple);

   pushDataUpdate("update", 0L);

   return changed;
}

//***************************************************************************
// W1 Stuff ...
//***************************************************************************

int HomeCtl::dispatchW1Msg(const char* message)
{
   json_t* jArray = jsonLoad(message);

   if (!jArray)
   {
      tell(eloAlways, "Error: Can't parse json in '%s'", message);
      return fail;
   }

   bool changed {false};
   size_t index {0};
   json_t* jValue {};

   json_array_foreach(jArray, index, jValue)
   {
      const char* name {getStringFromJson(jValue, "name")};
      double value {getDoubleFromJson(jValue, "value")};
      time_t stamp {getIntFromJson(jValue, "time")};

      changed |= updateW1(name, value, stamp);

      char* raw {json_dumps(jValue, JSON_COMPACT)};
      sensors["W1"][toW1Id(name)].setLastJson("w1", raw, stamp ? stamp : time(0));
      free(raw);
   }

   json_decref(jArray);
   cleanupW1();

   if (changed)
   {
      // tell(eloAlways, "triggerProcess on W1 changed");
      triggerProcess = true;   // w1
   }

   return success;
}

bool HomeCtl::updateW1(const char* id, double value, time_t stamp)
{
   uint address = toW1Id(id);

   tableValueFacts->clear();
   tableValueFacts->setValue("ADDRESS", (int)address);
   tableValueFacts->setValue("TYPE", "W1");

   if (!tableValueFacts->find())
      addValueFact(address, "W1", 1, id, "°C");

   tableValueFacts->clear();
   tableValueFacts->setValue("ADDRESS", (int)address);
   tableValueFacts->setValue("TYPE", "W1");

   if (!tableValueFacts->find() || !tableValueFacts->hasValue("STATE", "A"))
      return false;

   if (stamp < time(0)-300)
   {
      tell(eloInfo, "Skipping old (%ld seconds) value of 'W1:%d'", time(0)-stamp, address);
      return false;
   }

   bool changed {sensors["W1"][address].setValue(value, stamp)};

   json_t* ojData {json_object()};

   sensor2Json(ojData, "W1", address);
   json_object_set_new(ojData, "value", json_real(value));

   char* tuple {};
   asprintf(&tuple, "W1:0x%02x", address);
   jsonSensorList[tuple] = ojData;
   free(tuple);

   pushDataUpdate("update", 0L);

   if (changed)
   {
      mqttHaPublish(sensors["W1"][address]);
      mqttNodeRedPublishSensor(sensors["W1"][address]);
   }

   tableValueFacts->reset();

   return changed;
}

void HomeCtl::cleanupW1()
{
   uint detached {0};

   for (auto& it : sensors["W1"])
   {
      if (it.second.valid() && it.second.last() < time(0) - 5*tmeSecondsPerMinute)
      {
         tell(eloAlways, "Info: Missing w1 sensor '%x', removing it from list", it.first);
         it.second.invalidate();
         detached++;
      }
   }
}

bool HomeCtl::existW1(uint address)
{
   auto it = sensors["W1"].find(address);
   return it != sensors["W1"].end();
}

double HomeCtl::valueOfW1(uint address, time_t& last)
{
   last = 0;

   auto it = sensors["W1"].find(address);

   if (it == sensors["W1"].end())
      return 0;

   last = sensors["W1"][address].last();

   return sensors["W1"][address].value;
}

uint HomeCtl::toW1Id(const char* name)
{
   const char* p;
   int len = strlen(name);

   // use 4 minor bytes as id

   if (len <= 2)
      return na;

   if (len <= 8)
      p = name;
   else
      p = name + (len - 8);

   return strtoull(p, 0, 16);
}

//***************************************************************************
// Execute Command Async
//  mit 15 Sekunden Timeout
//***************************************************************************

#include <poll.h>
#include <unistd.h>

void HomeCtl::cmdThread(ThreadControl* threadCtl)
{
   if (!threadCtl)
      return;

   threadCtl->timeoutAt = time(nullptr) + 15;
   threadCtl->active = true;
   threadCtl->result.clear();

   FILE* pipe {popen(threadCtl->command.c_str(), "r")};

   if (!pipe)
   {
      threadCtl->active = false;
      return;
   }

   // Holen des zugrundeliegenden Datei-Deskriptors für poll()

   int fd {fileno(pipe)};
   char buffer[128] {};

   while (time(nullptr) < threadCtl->timeoutAt && !threadCtl->cancel)
   {
      struct pollfd pfd;
      pfd.fd = fd;
      pfd.events = POLLIN; // Wir wollen wissen, ob Daten zum Lesen da sind

      // Wartet maximal 1000 Millisekunden (1 Sekunde) auf Daten

      int ret {poll(&pfd, 1, 1000)};

      if (ret > 0)
      {
         // Daten sind da oder die Pipe wurde geschlossen

         if (pfd.revents & POLLIN)
         {
            if (fgets(buffer, sizeof(buffer), pipe))
               threadCtl->result += buffer;
            else
               break; // EOF (Skript ist fertig)
         }

         if (pfd.revents & (POLLERR | POLLHUP | POLLNVAL))
            break; // Fehler oder Pipe geschlossen
      }
      else if (ret == 0)
      {
         // Timeout von poll() erreicht (1 Sekunde vorbei, keine Daten).
         // Die Schleife läuft weiter und prüft oben das Gesamt-Timeout!

         continue;
      }
      else
      {
         // poll() Fehler (z.B. durch Signal unterbrochen)

         if (errno == EINTR)
            continue;
         break;
      }
   }

   // Wenn abgebrochen/Timeout: Sicherstellen, dass der Prozess wirklich stirbt
   // Prüfen, ob wir wegen eines Timeouts oder Cancels abgebrochen haben

   if (time(nullptr) >= threadCtl->timeoutAt || threadCtl->cancel)
   {
      // Das Skript läuft noch! Wir müssen es hart beenden.
      // pkill -P tötet alle Kindprozesse, die von dieser Pipe geöffnet wurden

      std::string killCmd = "pkill -9 -P " + std::to_string(getpid()) + " -f \"" + threadCtl->command + "\"";
      system(killCmd.c_str());
   }

   // Jetzt blockiert pclose nicht mehr, da der Prozess tot ist

   pclose(pipe);
   threadCtl->active = false;
}

int HomeCtl::executeCommandAsync(uint address, const char* cmd)
{
   auto& tControl {commandThreads[address]};
   tControl.command = cmd;
   tControl.cancel = false;

   try
   {
      // Erstellt einen std::thread und lagert ihn sofort aus (detach)
      // Dadurch entfällt das manuelle pthread_join

      std::thread(&HomeCtl::cmdThread, &tControl).detach();
   }
   catch (const std::system_error& e)
   {
      tell(eloAlways, "Error: Failed to start command thread");
      return fail;
   }

   return success;
}

//***************************************************************************
// Wifi Commands
//***************************************************************************

bool HomeCtl::wifiDeviceExists(const char* iface)
{
   if (isEmpty(iface))
      return true;                       // profile not bound to an interface

   std::string out {executeCommand("nmcli.asjson.sh wifi-dev")};
   json_t* jDevs {jsonLoad(out.c_str())};
   bool exists {false};
   size_t i {0};
   json_t* jDev {};

   json_array_foreach(jDevs, i, jDev)
   {
      if (strcmp(getStringFromJson(jDev, "device", ""), iface) == 0)
         exists = true;
   }

   json_decref(jDevs);

   return exists;
}

int HomeCtl::connectWifi(const char* ssid, std::string& result, const char* pwd)
{
   // prefer a stored profile of this SSID. A profile is bound to the interface it was
   // created on (USB sticks got names like wlx74da38732900), after a change of the stick
   // it can't be activated any more -> unbind it first, then it works on any wifi device

   std::string out {executeCommand("nmcli.asjson.sh wifi-con")};
   json_t* jCons {jsonLoad(out.c_str())};
   std::string uuid;
   std::string iface;
   bool usable {false};
   size_t i {0};
   json_t* jCon {};

   json_array_foreach(jCons, i, jCon)
   {
      if (strcmp(getStringFromJson(jCon, "ssid", ""), ssid) != 0)
         continue;

      const char* boundTo {getStringFromJson(jCon, "iface", "")};
      bool exists {wifiDeviceExists(boundTo)};

      if (uuid.empty() || exists)
      {
         uuid = getStringFromJson(jCon, "uuid", "");
         iface = boundTo;
         usable = exists;
      }

      if (usable)
         break;
   }

   json_decref(jCons);

   if (uuid.empty())
   {
      // no profile yet - let nmcli create one

      std::vector<std::string> args {"nmcli", "device", "wifi", "connect", ssid};

      if (!isEmpty(pwd))
      {
         args.push_back("password");
         args.push_back(pwd);
      }

      return executeNmcli(args, result);
   }

   if (!usable)
   {
      tell(eloAlways, "Info: Wifi profile of '%s' is bound to the missing interface '%s', unbinding it", ssid, iface.c_str());
      executeNmcli({"nmcli", "connection", "modify", "uuid", uuid, "connection.interface-name", ""}, result);
   }

   if (!isEmpty(pwd))
      executeNmcli({"nmcli", "connection", "modify", "uuid", uuid, "802-11-wireless-security.psk", pwd}, result);

   return executeNmcli({"nmcli", "connection", "up", "uuid", uuid}, result);
}

int HomeCtl::disconnectWifi(const char* ssid, std::string& result)
{
   std::vector<std::string> args = {"nmcli", "connection", "down", ssid};

   // or dsconnect total without aut reconnect:
   // std::vector<std::string> args = {"nmcli", "device", "disconnect", "<wlan0>"};

   return executeNmcli(args, result);
}

int HomeCtl::forgetWifi(const char* uuid, const char* ssid, std::string& result)
{
   // delete the stored connection profile(s), the network needs a new setup (password) afterwards
   //  - by uuid: exactly this profile
   //  - by ssid: all profiles of the network

   if (!isEmpty(uuid))
   {
      int status {executeNmcli({"nmcli", "connection", "delete", "uuid", uuid}, result)};

      if (status == success && !isEmpty(ssid))
         tidyWifiProfileName(ssid);

      return status;
   }

   if (isEmpty(ssid))
      return fail;

   std::string out {executeCommand("nmcli.asjson.sh wifi-con")};
   json_t* jCons {jsonLoad(out.c_str())};
   int status {success};
   size_t i {0};
   json_t* jCon {};

   json_array_foreach(jCons, i, jCon)
   {
      if (strcmp(getStringFromJson(jCon, "ssid", ""), ssid) != 0)
         continue;

      std::string res;

      if (executeNmcli({"nmcli", "connection", "delete", "uuid", getStringFromJson(jCon, "uuid", "")}, res) != success)
         status = fail;

      result += res;
   }

   json_decref(jCons);

   return status;
}

void HomeCtl::tidyWifiProfileName(const char* ssid)
{
   // nmcli names duplicates 'SSID 1', 'SSID 2', ... - if only one profile of the SSID
   // is left, name it like the SSID again

   std::string out {executeCommand("nmcli.asjson.sh wifi-con")};
   json_t* jCons {jsonLoad(out.c_str())};
   std::string uuid;
   std::string name;
   int count {0};
   size_t i {0};
   json_t* jCon {};

   json_array_foreach(jCons, i, jCon)
   {
      if (strcmp(getStringFromJson(jCon, "ssid", ""), ssid) != 0)
         continue;

      count++;
      uuid = getStringFromJson(jCon, "uuid", "");
      name = getStringFromJson(jCon, "network", "");
   }

   json_decref(jCons);

   if (count == 1 && name != ssid)
   {
      std::string result;
      tell(eloAlways, "Info: Renaming wifi profile '%s' to '%s'", name.c_str(), ssid);
      executeNmcli({"nmcli", "connection", "modify", "uuid", uuid, "connection.id", ssid}, result);
   }
}

int HomeCtl::executeNmcli(const std::vector<std::string>& cmdArgs, std::string& result)
{
   result.clear();
   int pipeFd[2] {};

   if (pipe(pipeFd) == -1)
   {
      tell(eloAlways, "Error: Creating pipe failed");
      return fail;
   }

   pid_t pid {fork()};

   if (pid < 0)
   {
      close(pipeFd[0]);
      close(pipeFd[1]);
      tell(eloAlways, "Error: fork(I) failed");
      return fail;
   }

   if (pid == 0)
   {
      // Child

      close(pipeFd[0]);
      dup2(pipeFd[1], STDOUT_FILENO);
      dup2(pipeFd[1], STDERR_FILENO);
      close(pipeFd[1]);

      // Vektor von std::string in das von execvp erwartete char* Array konvertieren

      std::vector<char*> cArgs;
      cArgs.reserve(cmdArgs.size() + 1);

      for (const auto& arg : cmdArgs)
         cArgs.push_back(const_cast<char*>(arg.c_str()));

      cArgs.push_back(nullptr);

      execvp("nmcli", cArgs.data());

      tell(eloAlways, "Error: Calling nmcli failed");
      _exit(127);     // Exit-Code for 'command not found'
   }
   else
   {
      close(pipeFd[1]);

      // read error text from pipe (is any)

      ssize_t bytesRead {0};
      char buffer[256];

      while ((bytesRead = read(pipeFd[0], buffer, sizeof(buffer))) > 0)
         result.append(buffer, bytesRead);

      close(pipeFd[0]);

      int status {0};

      if (waitpid(pid, &status, 0) == -1)
      {
         tell(eloAlways, "Error: Failed waiting for child");
         return fail;
      }

      // remove linfeed and trailing whitspaces

      while (!result.empty() && (result.back() == '\n' || result.back() == '\r' || result.back() == ' '))
         result.pop_back();

      if (WIFEXITED(status))
         return WEXITSTATUS(status);     // 0 on success

      return fail;
   }

   return success;
}