switched from qsettings to json added editng of actors

src/actor.cpp

@@ -1,41 +0,0 @@
-#include "actor.h"
-
-Actor::Actor(QObject *parent): QObject(parent)
-{
-
-}
-
-Actor::~Actor()
-{
-
-}
-
-void Actor::performAction()
-{
-    trigger();
-    if(action_ == ACTION_OFF) off();
-    else if(action_ == ACTION_ON) on();
-    else if(action_ != ACTION_TRIGGER_ONLY) toggle();
-}
-
-void Actor::setActive(int state)
-{
-    state ? makeActive() : makeInactive();
-}
-
-bool Actor::isActive()
-{
-    return active;
-}
-
-void Actor::setAction(uint8_t action)
-{
-    action_ = action;
-}
-
-
-void Actor::onStateChanged(bool state)
-{
-
-}
-

src/actor.cpp.autosave

@@ -0,0 +1,100 @@
+#include "actor.h"
+#include<QDebug>
+
+Actor::Actor(QObject *parent): QObject(parent)
+{
+    buildName();
+}
+
+Actor::~Actor()
+{
+
+}
+
+void Actor::performAction()
+{
+    if(active)
+    {
+        trigger();
+        if(action_ == ACTION_OFF) off();
+        else if(action_ == ACTION_ON) on();
+        else if(action_ != ACTION_TOGGLE) toggle();
+        else if(action_ != ACTION_VALUE) sigValue(value_);
+    }
+}
+
+void Actor::makeActive()
+{
+    active = true;
+}
+
+
+void Actor::makeInactive()
+{
+    active = false;
+}
+
+void Actor::buildName()
+{
+    name = "Actor";
+    appendActionToName();
+}
+
+void Actor::appendActionToName()
+{
+    if(action_ == ACTION_OFF || action_ == ACTION_DEFAULT ) name.append("off");
+    else if(action_ == ACTION_ON ) name.append("on");
+    else if(action_ == ACTION_TOGGLE ) name.append("toggle");
+    else if(action_ == ACTION_VALUE ) name.append("value to " + QString::number(value_));
+}
+
+void Actor::setActive(int state)
+{
+    state ? makeActive() : makeInactive();
+    buildName();
+}
+
+bool Actor::isActive()
+{
+    return active;
+}
+
+bool Actor::isExausted()
+{
+    return exausted;
+}
+
+void Actor::saveSettings(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Active", active);
+    settings->setValue(subsecton + "Exausted", exausted);
+    settings->setValue(subsecton + "Name", name);
+    settings->setValue(subsecton + "Action", action_);
+}
+
+void Actor::loadSettings(QString subsecton, QSettings* settings)
+{
+    active   = settings->value(subsecton + "Active").toBool();
+    exausted = settings->value(subsecton + "Exausted").toBool();
+    name     = settings->value(subsecton + "Name").toString();
+    action_  = settings->value(subsecton + "Action").toUInt();
+}
+
+void Actor::setAction(uint8_t action)
+{
+    action_ = action;
+    qDebug()<<"setting action to "<<action;
+    buildName();
+}
+
+void Actor::setValue(uint8_t value)
+{
+    value_=value;
+    buildName();
+}
+
+void Actor::onStateChanged(bool state)
+{
+
+}
+

src/actor.h

@@ -1,45 +0,0 @@
-#ifndef ACTOR_H
-#define ACTOR_H
-
-#include <QObject>
-#include <QString>
-
-class Actor : public QObject
-{
-    Q_OBJECT
-public:
-    static const uint8_t ACTION_DEFAULT = 0;
-    static const uint8_t ACTION_TOGGLE = 1;
-    static const uint8_t ACTION_ON = 2;
-    static const uint8_t ACTION_OFF = 3;
-    static const uint8_t ACTION_TRIGGER_ONLY = 4;
-
-    QString name;
-
-protected:
-    uint8_t action_ = 0;
-    bool active = false;
-
-    void performAction();
-
-signals:
-    void on();
-    void off();
-    void trigger();
-    void toggle();
-
-public slots:
-    virtual void makeActive() = 0;
-    virtual void makeInactive() = 0;
-    virtual void setActive(int state);
-    virtual void onStateChanged(bool state);
-
-public:
-    Actor(QObject* parent = nullptr);
-    virtual ~Actor();
-
-    bool isActive();
-    void setAction(uint8_t action);
-};
-
-#endif // ACTOR_H

src/actors/actor.cpp

@@ -0,0 +1,140 @@
+#include "actor.h"
+#include<QDebug>
+
+#include "alarmtime.h"
+#include "sensoractor.h"
+#include "timeractor.h"
+#include "regulator.h"
+
+Actor::Actor(QObject *parent): QObject(parent)
+{
+}
+
+Actor::~Actor()
+{
+
+}
+
+void Actor::performAction()
+{
+    if(active)
+    {
+        trigger();
+        sigValue(triggerValue);
+    }
+}
+
+void Actor::makeActive()
+{
+    active = true;
+}
+
+
+void Actor::makeInactive()
+{
+    active = false;
+}
+
+QString Actor::actionName()
+{
+    QString string;
+    if(triggerValue == 0 ) string = "off";
+    else if(triggerValue == 1 )  string = "on";
+    else string = "value to " + QString::number(triggerValue);
+    return  string;
+}
+
+void Actor::setActive(uint8_t state)
+{
+    state ? makeActive() : makeInactive();
+}
+
+bool Actor::isActive()
+{
+    return active;
+}
+
+bool Actor::isExausted()
+{
+    return exausted;
+}
+
+void Actor::store(QJsonObject& json)
+{
+    json["Active"] =  active;
+    json["Exausted"] = exausted;
+    if(!name.isEmpty()) json["Name"] = name;
+    json["TriggerValue"] = triggerValue;
+}
+
+void Actor::load(const QJsonObject& json)
+{
+    active = json["Active"].toBool();
+    exausted = json["Exausted"].toBool();
+    name = json["Name"].toString("");
+    triggerValue = json["TriggerValue"].toInt();
+}
+
+void Actor::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Active", active);
+    settings->setValue(subsecton + "Exausted", exausted);
+    if(!name.isEmpty())settings->setValue(subsecton + "Name", name);
+    settings->setValue(subsecton + "TriggerValue", triggerValue);
+}
+
+void Actor::load(QString subsecton, QSettings* settings)
+{
+    active   = settings->value(subsecton + "Active").toBool();
+    exausted = settings->value(subsecton + "Exausted").toBool();
+    if(settings->contains(subsecton + "Name"))name     = settings->value(subsecton + "Name").toString();
+    triggerValue  = settings->value(subsecton + "TriggerValue").toUInt();
+}
+
+void Actor::setTriggerValue(uint8_t value)
+{
+    triggerValue=value;
+}
+
+uint8_t Actor::getTriggerValue()
+{
+    return  triggerValue;
+}
+
+QString Actor::getName()
+{
+    if(name.size() > 0) return  name;
+    else return "Actor";
+}
+
+void Actor::onValueChanged(uint8_t value)
+{
+
+}
+
+Actor* Actor::createActor(const QString& type)
+{
+    Actor* actor = nullptr;
+    if(type == "Alarm") actor = new AlarmTime();
+    else if(type == "Sensor") actor = new SensorActor();
+    else if(type == "Timer") actor = new TimerActor();
+    else if(type == "Regulator") actor = new Regulator();
+    else if(type == "Actor") actor = new Actor();
+    return actor;
+}
+
+Actor* Actor::loadActor(const QJsonObject &json)
+{
+    QString type = json["Type"].toString("Actor");
+    Actor* actor = createActor(type);
+    if(actor) actor->load(json);
+    return actor;
+}
+
+Actor* Actor::loadActor(QString subsecton, QSettings* settings)
+{
+    QString type = settings->value(subsecton + "Type").toString();
+    Actor* actor = createActor(type);
+    if(actor) actor->load(subsecton, settings);
+    return actor;
+}

src/actors/actor.h

@@ -0,0 +1,61 @@
+#ifndef ACTOR_H
+#define ACTOR_H
+
+#include <QObject>
+#include <QString>
+#include <QSettings>
+#include <QJsonObject>
+
+class Actor : public QObject
+{
+    Q_OBJECT
+public:
+
+    uint8_t triggerValue = 0;
+
+protected:
+    bool active = true;
+    bool exausted = false;
+
+    void performAction();
+
+    QString name;
+
+signals:
+
+    void sigValue(uint8_t value);
+    void trigger();
+
+public slots:
+    virtual void makeActive();
+    virtual void makeInactive();
+    virtual void setActive(uint8_t state);
+    virtual void onValueChanged(uint8_t state);
+
+
+public:
+    Actor(QObject* parent = nullptr);
+    virtual ~Actor();
+    bool isExausted();
+
+    virtual QString actionName();
+
+    virtual QString getName();
+
+    bool isActive();
+    void setTriggerValue(uint8_t value);
+
+    uint8_t getTriggerValue();
+
+    static Actor* createActor(const QString& type);
+
+    virtual void store(QJsonObject& json);
+    virtual void load(const QJsonObject& json);
+    static Actor* loadActor(const QJsonObject& json);
+
+    virtual void store(QString subsecton, QSettings* settings);
+    virtual void load(QString subsecton, QSettings* settings);
+    static Actor* loadActor(QString subsecton, QSettings* settings);
+};
+
+#endif // ACTOR_H

src/actors/alarmtime.cpp

@@ -0,0 +1,145 @@
+#include "alarmtime.h"
+
+AlarmTime::AlarmTime(const QDateTime time, QObject *parent) : Actor(parent), time_(time)
+{
+    connect(&timer, SIGNAL(timeout()), this, SLOT(doTick()));
+    timer.setInterval(1000);
+}
+
+AlarmTime::~AlarmTime()
+{
+    makeInactive();
+}
+
+void AlarmTime::run()
+{
+    makeInactive();
+
+    active = true;
+    timer.start();
+
+    qDebug()<<"Start Alarm Time Manager\n";
+}
+
+void AlarmTime::makeActive()
+{
+    run();
+}
+
+QString AlarmTime::getName()
+{
+    if(name.size() > 0)return  name;
+    else
+    {
+        QString string;
+        string = "Alarm: ";
+        if(repeat_ == REPEAT_DAILY)
+        {
+            string.append("daily ");
+            string.append(time_.toString("HH:mm"));
+        }
+        else if(repeat_ == REPEAT_WEEKLY)
+        {
+            string.append("weekly ");
+            string.append(time_.toString("ddd HH:mm"));
+
+        }
+        else if(repeat_ == REPEAT_MONTHLY)
+        {
+             string.append("monthly ");
+             string.append(time_.toString("dd HH:mm"));
+        }
+        else if(repeat_ == REPEAT_YEARLY)
+        {
+            string.append("yearly ");
+             string.append(time_.toString("dd.mm HH:mm"));
+
+        }
+        else string.append(time_.toString("dd.mm.yyyy HH:mm"));
+        return string;
+    }
+}
+
+void AlarmTime::setRepeat(const uint8_t repeat)
+{
+    repeat_=repeat;
+}
+
+uint8_t AlarmTime::getRepeat()
+{
+    return repeat_;
+}
+
+QDateTime AlarmTime::getDateTime()
+{
+    return time_;
+}
+
+void AlarmTime::makeInactive()
+{
+    timer.stop();
+    active = false;
+}
+
+void AlarmTime::doTick()
+{
+    if(
+            (
+                (triggerd_ == false)                                                                                           &&
+                (time_.date().year()  == QDate::currentDate().year()  || repeat_ != REPEAT_NEVER)                              &&
+                (time_.date().month() == QDate::currentDate().month() || repeat_ == REPEAT_MONTHLY || repeat_ == REPEAT_DAILY) &&
+                (time_.date().day()   == QDate::currentDate().day()   || repeat_ == REPEAT_DAILY)
+            )
+            ||
+            (
+                (repeat_ == REPEAT_WEEKLY) &&
+                (time_.date().dayOfWeek() == QDate::currentDate().dayOfWeek())
+            )
+      )
+    {
+       if(time_.time().hour() == QTime::currentTime().hour() && time_.time().minute() == QTime::currentTime().minute())
+       {
+           qDebug()<<"Trigger\n";
+           triggerd_=true;
+           performAction();
+           if(repeat_ == REPEAT_NEVER) exausted = true;
+       }
+    }
+    else if( repeat_ != REPEAT_NEVER && time_.time().hour() != QTime::currentTime().hour() ) triggerd_=false;
+}
+
+void AlarmTime::changeTime(const QDateTime& time)
+{
+    time_=time;
+}
+
+
+void AlarmTime::store(QJsonObject& json)
+{
+    json["Type"] = "Alarm";
+    Actor::store(json);
+    json["Time"] = time_.toString();
+    json["Repeat"] = repeat_;
+}
+
+void AlarmTime::load(const QJsonObject& json)
+{
+    Actor::load(json);
+    time_ = QDateTime::fromString(json["Time"].toString(""));
+    repeat_ = json["Repeat"].toInt(REPEAT_NEVER);
+}
+
+void AlarmTime::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Type", "Alarm");
+    Actor::store(subsecton, settings);
+    settings->setValue(subsecton + "Time", time_);
+    settings->setValue(subsecton + "Repeat", repeat_);
+}
+
+void AlarmTime::load(QString subsecton, QSettings* settings)
+{
+    Actor::load(subsecton, settings);
+    time_ = settings->value(subsecton + "Time").toDateTime();
+    repeat_ = settings->value(subsecton + "Repeat").toUInt();
+}

src/actors/alarmtime.h

@@ -1,6 +1,6 @@
 #ifndef ALARMTIME_H
 #define ALARMTIME_H
-#include <QTime>
+#include <QDateTime>
 #include <QObject>
 #include <QRunnable>
 #include <QScopedPointer>
@@ -25,21 +25,33 @@ public:
 private:
 
     bool triggerd_ = false;
-    QTime time_;
+    QDateTime time_;
     QTimer timer;
     uint8_t repeat_ = REPEAT_NEVER;
 
 public:
-    explicit AlarmTime(const QTime time = QTime::currentTime(), QObject *parent = nullptr);
+    explicit AlarmTime(const QDateTime time = QDateTime::currentDateTime(), QObject *parent = nullptr);
     ~AlarmTime();
 
+    QDateTime getDateTime();
+
+    virtual void store(QJsonObject& json);
+    virtual void load(const QJsonObject& json);
+
+    virtual void store(QString subsecton, QSettings* settings);
+    virtual void load(QString subsecton, QSettings* settings);
+
+    uint8_t getRepeat();
+
 public slots:
+
     void run();
     virtual void makeActive();
     virtual void makeInactive();
+    virtual QString getName();
     void doTick();
-    void changeTime(QTime time);
-    void setRepeat(uint8_t repeat);
+    void changeTime(const QDateTime& time);
+    void setRepeat(const uint8_t repeat);
 };
 
 #endif // ALARMTIME_H

src/actors/regulator.cpp

@@ -0,0 +1,111 @@
+#include "regulator.h"
+
+#include <QDebug>
+
+Regulator::Regulator(const Sensor sensor, QObject* parent): Actor(parent), sensor_(sensor)
+{
+
+}
+
+Regulator::Regulator(QObject* parent): Actor(parent)
+{
+
+}
+
+void Regulator::setSensor(const Sensor sensor)
+{
+    sensor_ = sensor;
+}
+
+void Regulator::sensorEvent(Sensor sensor)
+{
+    if(active && sensor == sensor_)
+    {
+        qDebug()<<"got sensor: "<<sensor.type<<" "<<sensor.id<<" want: "<<sensor_.type<<" "<<sensor_.id;
+        if( sensor.field < setPoint_-band_ && (sensor.field < sensor_.field || sensor_.field > setPoint_-band_) )
+        {
+           trigger();
+           sigValue(triggerValue);
+        }
+        else if( sensor.field > setPoint_+band_ && (sensor.field > sensor_.field || sensor_.field < setPoint_+band_) )
+        {
+            trigger();
+            sigValue(!triggerValue);
+        }
+        sensor_ = sensor;
+    }
+}
+
+void Regulator::setPoint(float setPoint)
+{
+    setPoint_ = setPoint;
+}
+
+void Regulator::setBand ( float band )
+{
+    band_ = band;
+}
+
+void Regulator::setInvert( bool invert )
+{
+    invert_ = invert;
+}
+
+void Regulator::store(QJsonObject& json)
+{
+    json["Type"] = "Regulator";
+    Actor::store(json);
+    json["Band"] = band_;
+    json["SetPoint"] = setPoint_;
+    json["SensorType"] = static_cast<int>(sensor_.type);
+    json["SensorId"] = static_cast<int>(sensor_.id);
+    json["SensorField"] = sensor_.field;
+    json["SensorName"] = sensor_.name;
+}
+
+void Regulator::load(const QJsonObject& json)
+{
+    Actor::load(json);
+    band_ = json["Band"].toInt(1);
+    setPoint_ = json["SetPoint"].toInt(22);
+    sensor_.type = json["SensorType"].toInt(0);
+    sensor_.id = json["SensorId"].toInt(0);
+    sensor_.field = json["SensorField"].toInt(0);
+    sensor_.name = json["SensorName"].toString("Sensor");
+}
+
+void Regulator::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Type", "Regulator");
+    Actor::store(subsecton, settings);
+    settings->setValue(subsecton + "Band", band_);
+    settings->setValue(subsecton + "SetPoint", setPoint_);
+    settings->setValue(subsecton + "SensorType", static_cast<int>(sensor_.type));
+    settings->setValue(subsecton + "SensorId", static_cast<int>(sensor_.id));
+    settings->setValue(subsecton + "SensorField", sensor_.field);
+    settings->setValue(subsecton + "SensorName", sensor_.name);
+}
+
+void Regulator::load(QString subsecton, QSettings* settings)
+{
+   Actor::load(subsecton, settings);
+
+   setPoint_   = settings->value(subsecton + "SetPoint").toUInt();
+   band_ = settings->value(subsecton + "Band").toFloat();
+   sensor_.type = settings->value(subsecton + "SensorType").toUInt();
+   sensor_.id = settings->value(subsecton + "SensorId").toUInt();
+   sensor_.field = settings->value(subsecton + "SensorField").toFloat();
+   sensor_.name = settings->value(subsecton + "SensorName").toString();
+}
+
+QString Regulator::getName()
+{
+    if(name.size() > 0) return name;
+    else
+    {
+        QString string;
+        string = "Regulate \"" + sensor_.name + "\" to ";
+        string.append(QString::number(setPoint_) + " ");
+        return string;
+    }
+}

src/actors/regulator.h

@@ -0,0 +1,39 @@
+#pragma once
+#include "actor.h"
+#include "../sensors/sensor.h"
+
+class Regulator : public Actor
+{
+    Q_OBJECT
+
+private:
+    Sensor sensor_;
+    float setPoint_ = 0;
+    float band_ = 1;
+    bool invert_ = false;
+
+public slots:
+
+    void sensorEvent(Sensor sensor);
+
+    void setSensor(const Sensor sensor);
+    void setPoint( float setPoint );
+    void setBand ( float band );
+    void setInvert( bool invert );
+
+public:
+
+    float getBand() {return  band_;}
+    float getSetPoint() {return  setPoint_;}
+    Regulator(const Sensor sensor, QObject* parent = nullptr);
+    Regulator(QObject* parent = nullptr);
+    Sensor getSensor(){return sensor_;}
+    virtual QString getName();
+    virtual ~Regulator(){}    
+    
+    virtual void store(QJsonObject& json);
+    virtual void load(const QJsonObject& json);
+    
+    virtual void store(QString subsecton, QSettings* settings);
+    virtual void load(QString subsecton, QSettings* settings);
+};

src/actors/sensoractor.cpp

@@ -0,0 +1,112 @@
+#include "sensoractor.h"
+
+#include <QDebug>
+
+SensorActor::SensorActor(const Sensor sensor, QObject* parent): Actor(parent), sensor_(sensor)
+{
+
+}
+
+SensorActor::SensorActor(QObject* parent): Actor(parent)
+{
+
+}
+
+void SensorActor::setSensor(const Sensor sensor)
+{
+    sensor_ = sensor;
+}
+
+void SensorActor::sensorEvent(Sensor sensor)
+{
+    if(sensor == sensor_)
+    {
+        qDebug()<<"got sensor: "<<sensor.type<<" "<<sensor.id<<" want: "<<sensor_.type<<" "<<sensor_.id;
+        if((sloap_ == SLOPE_UP || sloap_ == SLOPE_BOTH) && sensor_.field < threshold_ && sensor.field >= threshold_ )  performAction();
+        else if((sloap_ == SLOPE_DOWN || sloap_ == SLOPE_BOTH) && sensor_.field > threshold_ && sensor.field <= threshold_)  performAction();
+        sensor_ = sensor;
+    }
+}
+
+void SensorActor::setSloap(uint8_t sloap)
+{
+    sloap_=sloap;
+}
+
+void SensorActor::setThreshold(float threshold)
+{
+    threshold_ = threshold;
+}
+
+float SensorActor::getThreshold()
+{
+    return threshold_;
+}
+uint8_t SensorActor::getSloap()
+{
+    return sloap_;
+}
+
+void SensorActor::store(QJsonObject& json)
+{
+    json["Type"] = "Sensor";
+    Actor::store(json);
+    json["Sloap"] = sloap_;
+    json["Threshold"] = threshold_;
+    json["SensorType"] = static_cast<int>(sensor_.type);
+    json["SensorId"] = static_cast<int>(sensor_.id);
+    json["SensorField"] = sensor_.field;
+    json["SensorName"] = sensor_.name;
+}
+
+void SensorActor::load(const QJsonObject& json)
+{
+    Actor::load(json);
+    sloap_ = json["Sloap"].toInt(0);
+    threshold_ = json["Threshold"].toDouble(0);
+    sensor_.type = json["SensorType"].toInt(0);
+    sensor_.id = json["SensorId"].toInt(0);
+    sensor_.field = json["SensorField"].toInt(0);
+    sensor_.name = json["SensorName"].toString("Sensor");
+}
+
+void SensorActor::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Type", "Sensor");
+    Actor::store(subsecton, settings);
+    settings->setValue(subsecton + "Sloap", sloap_);
+    settings->setValue(subsecton + "Threshold", threshold_);
+    settings->setValue(subsecton + "SensorType", static_cast<int>(sensor_.type));
+    settings->setValue(subsecton + "SensorId", static_cast<int>(sensor_.id));
+    settings->setValue(subsecton + "SensorField", sensor_.field);
+    settings->setValue(subsecton + "SensorName", sensor_.name);
+}
+
+void SensorActor::load(QString subsecton, QSettings* settings)
+{
+   Actor::load(subsecton, settings);
+
+   sloap_   = settings->value(subsecton + "Sloap").toUInt();
+   threshold_ = settings->value(subsecton + "Threshold").toFloat();
+   sensor_.type = settings->value(subsecton + "SensorType").toUInt();
+   sensor_.id = settings->value(subsecton + "SensorId").toUInt();
+   sensor_.field = settings->value(subsecton + "SensorField").toFloat();
+   sensor_.name = settings->value(subsecton + "SensorName").toString();
+}
+
+QString SensorActor::getName()
+{
+    if(name.size() > 0) return name;
+    else
+    {
+        QString string;
+        string = "Sensor \"" + sensor_.name + "\"";
+
+        if(sloap_ == SLOPE_UP) string.append(" rises to ");
+        else if (sloap_ == SLOPE_DOWN) string.append(" drops to ");
+        else if (sloap_ == SLOPE_BOTH) string.append(" passes ");
+
+        string.append(QString::number(threshold_) + " ");
+        return string;
+    }
+}

src/actors/sensoractor.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "actor.h"
+#include "../sensors/sensor.h"
+
+class SensorActor : public Actor
+{
+    Q_OBJECT
+public:
+
+    static constexpr uint8_t SLOPE_UP   = 0;
+    static constexpr uint8_t SLOPE_DOWN = 1;
+    static constexpr uint8_t SLOPE_BOTH = 2;
+
+private:
+    Sensor sensor_;
+    uint8_t sloap_ = SLOPE_UP;
+    float threshold_ = 0;
+
+public slots:
+    
+    void sensorEvent(Sensor sensor);
+
+    void setSloap(uint8_t sloap);
+    void setSensor(const Sensor sensor);
+    void setThreshold( float threshold );
+
+public:
+
+    SensorActor(const Sensor sensor, QObject* parent = nullptr);
+    SensorActor(QObject* parent = nullptr);
+    Sensor getSensor(){return sensor_;}
+    virtual QString getName();
+    virtual ~SensorActor(){}
+
+    float getThreshold();
+    uint8_t getSloap();
+    
+    virtual void store(QJsonObject& json);
+    virtual void load(const QJsonObject& json);
+    
+    virtual void store(QString subsecton, QSettings* settings);
+    virtual void load(QString subsecton, QSettings* settings);
+};
+
+

src/actors/timeractor.cpp

@@ -0,0 +1,69 @@
+#include "timeractor.h"
+#include <QDebug>
+
+TimerActor::TimerActor(const int timeoutSec, QObject *parent): Actor(parent), timeoutMsec_(timeoutSec*1000)
+{
+    connect(&timer, &QTimer::timeout, this, &TimerActor::timeout);
+    timer.setSingleShot(true);
+}
+
+void TimerActor::onValueChanged(uint8_t state)
+{
+    if((state && !triggerValue) || (!state && triggerValue))
+    {
+        if(timer.isActive()) timer.stop();
+        timer.setInterval(timeoutMsec_);
+        timer.start();
+    }
+}
+
+void TimerActor::store(QJsonObject& json)
+{
+    json["Type"] = "Timer";
+    Actor::store(json);
+    json["Timeout"] = timeoutMsec_;
+}
+
+void TimerActor::load(const QJsonObject& json)
+{
+    Actor::load(json);
+    timeoutMsec_ = json["Timeout"].toInt(10000);
+}
+
+void TimerActor::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Type", "Timer");
+    Actor::store(subsecton, settings);
+    settings->setValue(subsecton + "Timeout", timeoutMsec_);
+}
+void TimerActor::load(QString subsecton, QSettings* settings)
+{
+    Actor::load(subsecton, settings);
+    timeoutMsec_ = settings->value(subsecton + "Timeout").toInt();
+}
+
+void TimerActor::setTimeout(const int timeoutSec)
+{
+    timeoutMsec_ = timeoutSec*1000;
+}
+
+int TimerActor::getTimeout()
+{
+    return timeoutMsec_*1000;
+}
+
+void TimerActor::timeout()
+{
+    performAction();
+}
+
+QString TimerActor::getName()
+{
+    if(name.size() > 0) return name;
+    else
+    {
+        QString string;
+        string = "Timeout after " + QString::number(timeoutMsec_/1000) + " seconds. ";
+        return string;
+    }
+}

src/actors/timeractor.h

@@ -0,0 +1,33 @@
+#pragma once
+#include <QTimer>
+#include "actor.h"
+
+class TimerActor: public Actor
+{
+    Q_OBJECT
+private:
+    int timeoutMsec_;
+
+    QTimer timer;
+
+private slots:
+
+    void timeout();
+
+public slots:
+
+    virtual void onValueChanged(uint8_t state);
+    void setTimeout(const int timeoutSec);
+
+public:
+    explicit TimerActor(const int timeoutSec = 60, QObject *parent = nullptr);
+    virtual QString getName();
+
+    int getTimeout();
+
+    virtual void store(QJsonObject& json);
+    virtual void load(const QJsonObject& json);
+
+    virtual void store(QString subsecton, QSettings* settings);
+    virtual void load(QString subsecton, QSettings* settings);
+};

src/alarmactions.cpp

@@ -1,33 +1,14 @@
 #include "alarmactions.h"
 #include <QProcess>
-#include <QSound>
-#include <QProcess>
-#include <QTime>
-#include <QApplication>
 
-AlarmActions::AlarmActions(QSettings *settings, Microcontroller* micro, QObject *parent) : QObject(parent), _micro(micro), _settings(settings)
+AlarmActions::AlarmActions(QApplication* a, Microcontroller* micro, QObject *parent) : QObject(parent), _micro(micro), a_(a)
 {
 
 }
 
 void AlarmActions::syncoff()
 {
-    _settings->sync();
-    for(unsigned int i = 0; i < _micro->getLastState().size(); i++) _micro->relayOff(i);
+    qDebug()<<"syncoff";
     QProcess::execute ( "syncoff" );
-}
-
-void AlarmActions::Alarm()
-{
-
-    if(_settings->value("Alarms/alarmSoundFile").toString().size() != 0)_micro->startSunrise();
-    if(_settings->value("Alarms/alarmSoundFile").toString().size() != 0)
-    {
-        _micro->relayOn(0);
-
-        QTime dieTime= QTime::currentTime().addSecs(10);
-        while (QTime::currentTime() < dieTime) QApplication::processEvents(QEventLoop::AllEvents, 100);
-
-        QSound::play(_settings->value("Alarms/alarmSoundFile").toString());
-    }
+    a_->exit(0);
 }

src/alarmactions.h

@@ -1,8 +1,7 @@
 #ifndef POWER_H
 #define POWER_H
 
-#include <QObject>
-#include <QSettings>
+#include <QApplication>
 #include "microcontroller.h"
 
 class AlarmActions : public QObject
@@ -10,10 +9,10 @@ class AlarmActions : public QObject
 private:
     Q_OBJECT
     Microcontroller* _micro;
-    QSettings* _settings;
+    QApplication* a_;
 
 public:
-    explicit AlarmActions(QSettings* settings, Microcontroller* micro, QObject *parent = nullptr);
+    explicit AlarmActions(QApplication* a, Microcontroller* micro, QObject *parent = nullptr);
 
 signals:
 
@@ -21,8 +20,6 @@ public slots:
 
     void syncoff();
 
-    void Alarm();
-
 };
 
 #endif // POWER_H

src/alarmtime.cpp

@@ -1,51 +0,0 @@
-#include "alarmtime.h"
-
-AlarmTime::AlarmTime(const QTime time, QObject *parent) : Actor(parent), time_(time)
-{
-    connect(&timer, SIGNAL(timeout()), this, SLOT(doTick()));
-    timer.setInterval(1000);
-}
-
-AlarmTime::~AlarmTime()
-{
-    makeInactive();
-}
-
-void AlarmTime::run()
-{
-    makeInactive();
-
-    active = true;
-    timer.start();
-
-    qDebug()<<"Start Alarm Time Manager\n";
-}
-
-void AlarmTime::makeActive()
-{
-    run();
-}
-
-
-void AlarmTime::makeInactive()
-{
-    timer.stop();
-    active = false;
-}
-
-void AlarmTime::doTick()
-{
-    if(time_.hour() == QTime::currentTime().hour() && time_.minute() == QTime::currentTime().minute() && triggerd_==false )
-    {
-       qDebug()<<"Trigger\n";
-       triggerd_=true;
-       performAction();
-    }
-    else if( time_.hour() != QTime::currentTime().hour() ) triggerd_=false;
-}
-
-void AlarmTime::changeTime(QTime time)
-{
-    time_=time;
-     qDebug()<<"Time Changed\n";
-}

src/broadcast.cpp

@@ -0,0 +1,83 @@
+#include "broadcast.h"
+#include <QJsonDocument>
+#include <QDebug>
+
+BroadCast::BroadCast(QIODevice* const iodevice): iodevice_(iodevice)
+{
+    if(iodevice_ != nullptr) connect(iodevice_, &QIODevice::readyRead, this, &BroadCast::readyRead);
+}
+
+void BroadCast::write(const char * const buffer, const size_t length)
+{
+    QByteArray mBuffer("BCST: ");
+    for (size_t i = 0; i < length; ++i)
+    {
+        if(buffer[i] != '\n' && buffer[i] != '\0') mBuffer.push_back(buffer[i]);
+        else
+        {
+            mBuffer.push_back('\\');
+            if(buffer[i] == '\n')mBuffer.push_back('n');
+            else mBuffer.push_back('0');
+        }
+    }
+    if(iodevice_)iodevice_->write(mBuffer);
+}
+
+void BroadCast::write(const QByteArray& buffer)
+{
+    write(buffer.data(), buffer.size());
+}
+
+void BroadCast::sendJson(const QJsonObject& json)
+{
+    QJsonDocument jsonDocument(json);
+    write("JSON: ");
+    write(jsonDocument.toJson());
+}
+
+void BroadCast::decode()
+{
+    if(buffer_.size() >= 6 && buffer_[0] == 'J' && buffer_[1] == 'S' && buffer_[2] == 'O' && buffer_[3] == 'N' && buffer_[4] == ':')
+    {
+        buffer_.remove(0,6);
+        for(int i = 0; i < buffer_.size()-1; ++i)
+        {
+            if( buffer_[i] == '\\' && buffer_[i+1] == 'n' )
+            {
+                buffer_[i] = '\n';
+                buffer_.remove(i+1,1);
+            }
+            else if( buffer_[i] == '\\' && buffer_[i+1] == '0' )
+            {
+                buffer_[i] = '\0';
+                buffer_.remove(i+1,1);
+            }
+        }
+        QJsonDocument document;
+        QJsonParseError error;
+        document.fromJson(buffer_, &error);
+        if(error.error == QJsonParseError::NoError) gotJson(document.object());
+        else
+        {
+            qDebug()<<error.errorString();
+        }
+    }
+}
+
+void BroadCast::readyRead()
+{
+    buffer_.append(iodevice_->readAll());
+    if(buffer_.size() >= 6)
+    {
+        if(buffer_[0] == 'B' && buffer_[1] == 'C' && buffer_[2] == 'S' && buffer_[3] == 'T' && buffer_[4] == ':')
+        {
+            if(buffer_.contains('\n'))
+            {
+                buffer_.remove(0,6);
+                decode();
+                buffer_.clear();
+            }
+        }
+        else buffer_.clear();
+    }
+}

src/broadcast.h

@@ -0,0 +1,42 @@
+#ifndef BROADCAST_H
+#define BROADCAST_H
+#include <QIODevice>
+#include <QObject>
+#include <QString>
+#include <QJsonObject>
+
+class BroadCast: public QObject
+{
+    Q_OBJECT
+
+private:
+
+    static constexpr uint8_t MODE_PREPACKET = 0;
+    static constexpr uint8_t MODE_PACKET = 1;
+
+    QByteArray buffer_;
+
+    QIODevice* const iodevice_;
+
+    void write(const char * const buffer, const size_t length);
+    void write(const QByteArray& buffer);
+
+    void decode();
+
+private slots:
+
+    void readyRead();
+
+signals:
+
+    void gotJson(QJsonObject json);
+
+public:
+
+    BroadCast(QIODevice* const iodevice = nullptr);
+    void sendJson(const QJsonObject& json);
+
+};
+
+#endif // BROADCAST_H
+

src/items/auxitem.cpp

@@ -0,0 +1,24 @@
+#include "auxitem.h"
+
+AuxItem::AuxItem(SensorStore* sensors, Microcontroller* micro, uint32_t itemIdIn, QString name,  uint8_t value, QObject* parent): Item(sensors, itemIdIn, name, value, parent), micro_(micro)
+{
+
+}
+
+void AuxItem::setValue(uint8_t value)
+{
+    Item::setValue(value);
+    micro_->setAuxPwm(value);
+}
+
+void AuxItem::store(QJsonObject &json)
+{
+    json["Type"] = "Aux";
+    Item::store(json);
+}
+
+void AuxItem::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Type", "Aux");
+    Item::store(subsecton, settings);
+}

src/items/auxitem.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "item.h"
+#include "../microcontroller.h"
+
+class AuxItem: public Item
+{
+    Q_OBJECT
+private:
+    Microcontroller* micro_;
+
+public slots:
+
+    virtual void setValue(uint8_t value);
+
+public:
+    AuxItem(SensorStore* sensors, Microcontroller* micro, uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "",  uint8_t value = 0, QObject* parent = nullptr);
+
+    virtual void store(QJsonObject& json);
+    virtual void store(QString subsecton, QSettings* settings);
+};

src/items/item.cpp

@@ -0,0 +1,173 @@
+#include "item.h"
+
+#include "relay.h"
+#include "../microcontroller.h"
+#include "../actors/sensoractor.h"
+#include "../actors/regulator.h"
+
+#include <QJsonArray>
+
+ItemData::ItemData(uint32_t itemIdIn, QString name, uint8_t value): name_(name), value_(value), itemId_(itemIdIn)
+{
+
+}
+
+QString ItemData::getName() const
+{
+    return name_;
+}
+
+void ItemData::setName(QString name)
+{
+    name_ = name;
+}
+
+uint8_t ItemData::getValue() const
+{
+    return value_;
+}
+
+uint32_t ItemData::id() const
+{
+    return  itemId_;
+}
+
+
+//item
+
+bool Item::secondaryFlag = false;
+
+Item::Item(SensorStore* sensors, uint32_t itemIdIn, QString name, uint8_t value,  QObject *parent): QObject(parent), ItemData (itemIdIn, name, value), sensors_(sensors)
+{
+
+}
+
+Item::Item(SensorStore* sensors, const ItemData& itemData,  QObject *parent): QObject(parent), ItemData(itemData), sensors_(sensors)
+{
+
+}
+
+bool Item::actorsActive() const
+{
+    return actorsActive_;
+}
+
+void Item::store(QJsonObject &json)
+{
+    json["Name"] = name_;
+    json["ItemId"] = static_cast<double>(itemId_);
+    json["ActorsActive"] = actorsActive_;
+    QJsonArray actorsArray;
+    for(size_t i = 0; i < actors_.size(); ++i)
+    {
+        QJsonObject actorObject;
+        actors_[i]->store(actorObject);
+        actorsArray.append(actorObject);
+    }
+    json["Actors"] = actorsArray;
+}
+
+void Item::load(const QJsonObject &json, const bool preserve)
+{
+    if(!preserve)
+    {
+        name_ = json["Name"].toString(name_);
+        itemId_ = static_cast<uint32_t>(json["ItemId"].toDouble(0));
+    }
+    actorsActive_ = json["ActorsActive"].toBool(true);
+    const QJsonArray actorsArray(json["Actors"].toArray(QJsonArray()));
+    for(int i = 0; i < actorsArray.size(); ++i)
+    {
+        if(actorsArray[i].isObject())
+        {
+            Actor* actor = Actor::loadActor(actorsArray[i].toObject());
+            if(actor != nullptr) addActor(actor);
+        }
+    }
+}
+
+void Item::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Name", name_);
+    settings->setValue(subsecton + "ItemId", static_cast<unsigned>(itemId_));
+    settings->setValue(subsecton + "ActorsActive", actorsActive_);
+    settings->setValue(subsecton + "Actors", static_cast<unsigned>(actors_.size()));
+    for(size_t i = 0; i < actors_.size(); ++i)
+    {
+        actors_[i]->store(subsecton + "/Actor" + QString::number(i), settings);
+    }
+}
+
+void Item::load(QString subsecton, QSettings* settings, bool preserve)
+{
+    if(!preserve)
+    {
+        name_ = settings->value(subsecton + "Name").toString();
+        itemId_ = settings->value(subsecton + "ItemId").toUInt();
+    }
+    actorsActive_ = settings->value(subsecton + "ActorsActive").toBool();
+    unsigned actorsLen = settings->value(subsecton + "Actors").toUInt();
+    for(unsigned i = 0; i < actorsLen; ++i)
+    {
+        Actor* actor = Actor::loadActor(subsecton + "/Actor" + QString::number(i), settings);
+        if(actor != nullptr) addActor(actor);
+    }
+}
+
+void Item::setValue(uint8_t value)
+{
+    value_ = value;
+    valueChanged(value_);
+}
+
+void Item::informValue(uint8_t value)
+{
+    Item::setValue(value);
+}
+
+void Item::addActor(Actor* actor)
+{
+    actor->setParent(this);
+    actors_.push_back(actor);
+    if(!secondaryFlag)connect(actor, &Actor::sigValue, this, &Item::setValue);
+    connect(this, &Item::valueChanged, actor, &Actor::onValueChanged);
+
+    SensorActor* sensorActor = dynamic_cast<SensorActor*>(actor);
+    if(sensorActor != nullptr && sensors_ != nullptr)connect(sensors_, &SensorStore::sensorChangedState, sensorActor, &SensorActor::sensorEvent);
+
+    Regulator* regulator = dynamic_cast<Regulator*>(actor);
+    if(regulator != nullptr && sensors_ != nullptr)connect(sensors_, &SensorStore::sensorChangedState, regulator, &Regulator::sensorEvent);
+
+    if(actorsActive_) actor->makeActive();
+    else actor->makeInactive();
+}
+
+bool Item::removeActor(Actor* actor)
+{
+    for(unsigned int i = 0; i < actors_.size(); i++)
+    {
+        if(actors_[i] == actor)
+        {
+            delete actor;
+            actors_.erase(actors_.begin()+i);
+            return true;
+        }
+    }
+    return false;
+}
+
+std::vector< Actor* >& Item::getActors()
+{
+    return actors_;
+}
+
+bool Item::hasActors()
+{
+    return actors_.size() > 0;
+}
+
+void Item::setActorsActive(bool in)
+{
+    actorsActive_ = in;
+    for(unsigned i = 0; i < actors_.size(); i++) in ? actors_[i]->makeActive() : actors_[i]->makeInactive();
+}

src/items/item.h

@@ -0,0 +1,75 @@
+#pragma once
+#include <QObject>
+#include <vector>
+#include <QRandomGenerator>
+#include <QSettings>
+#include <QJsonObject>
+
+#include "../actors/actor.h"
+#include "../sensors/sensor.h"
+
+class ItemData
+{
+protected:
+    QString name_;
+    uint8_t value_;
+    uint32_t itemId_;
+
+public:
+
+    ItemData(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0);
+
+    inline bool operator==(const ItemData& in) const{ return itemId_==in.itemId_; }
+    inline bool operator!=(const ItemData& in) const{ return itemId_!=in.itemId_; }
+
+    uint32_t id() const;
+
+    QString getName() const;
+    void setName(QString name);
+    uint8_t getValue() const;
+};
+
+
+class Item: public QObject, public ItemData
+{
+    Q_OBJECT
+private:
+    std::vector< Actor* > actors_;
+    bool actorsActive_ = true;
+
+public:
+
+    static bool secondaryFlag;
+    SensorStore* sensors_;
+
+signals:
+
+    void valueChanged(uint8_t value);
+
+public slots:
+
+    virtual void setValue(uint8_t value);
+
+public:
+
+    Item(SensorStore* sensors = nullptr, uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0,  QObject *parent = nullptr);
+    Item(SensorStore* sensors, const ItemData& itemData,  QObject *parent = nullptr);
+
+    std::vector< Actor* >& getActors();
+    bool hasActors();
+    void addActor(Actor* actor);
+    bool removeActor(Actor* actor);
+    bool actorsActive() const;
+    void setActorsActive(bool in);
+    void informValue(uint8_t value);
+    void setSensorStore(SensorStore* sensors){sensors_ = sensors;}
+    SensorStore* getSensorStore(){return sensors_;}
+
+    virtual void store(QJsonObject& json);
+    virtual void load(const QJsonObject& json, const bool preserve = false);
+
+    virtual void store(QString subsecton, QSettings* settings);
+    virtual void load(QString subsecton, QSettings* settings, bool preserve = false);
+
+};
+

src/items/itemstore.cpp

@@ -0,0 +1,132 @@
+#include "itemstore.h"
+#include "relay.h"
+#include <QJsonArray>
+
+ItemStore::ItemStore(SensorStore* sensors, QObject *parent): QObject(parent), sensors_(sensors)
+{
+}
+
+void ItemStore::addItem(std::shared_ptr<Item> item)
+{
+    bool mached = false;
+    for(unsigned i = 0; i < items_.size(); i++ ) if(*items_[i] == *item) mached = true;
+    if(!mached)
+    {
+        items_.push_back(std::shared_ptr<Item>(item));
+        items_.back()->setSensorStore(sensors_);
+        itemAdded(std::weak_ptr<Item>(items_.back()));
+        qDebug()<<"item added";
+    }
+}
+
+void ItemStore::addItems(const std::vector<std::shared_ptr<Item>>& itemIn)
+{
+    for(unsigned i = 0; i < items_.size(); i++ )
+    {
+        if(Relay* relay = dynamic_cast<Relay*>(items_[i].get()))
+        {
+            bool mached = false;
+            for(unsigned j = 0; j < itemIn.size(); j++) if(*(items_[i]) == *(itemIn[j]))
+            {
+                mached = true;
+                if(itemIn[j]->getValue() != items_[i]->getValue()) items_[i]->informValue(itemIn[j]->getValue());
+                Relay* relayIn = dynamic_cast<Relay*>(itemIn[j].get());
+                if(relayIn)
+                {
+                    if(relay->getId() != relayIn->getId()) relay->setId(relayIn->getId());
+                }
+
+            }
+            if(!mached)
+            {
+                itemDeleted(*items_[i].get());
+                items_.erase(items_.begin()+i);
+            }
+        }
+    }
+
+    for(unsigned j = 0; j < itemIn.size(); j++)addItem(itemIn[j]);
+
+}
+
+void ItemStore::itemStateChanged(const ItemData& item)
+{
+     for(unsigned i = 0; i < items_.size(); i++ )
+     {
+         if(items_[i]->operator==(item))
+         {
+            qDebug()<<"is item "<<i<<" with ids: "<<item.id()<<"  "<<items_[i]->id()<<"\nHas state: "<<items_[i]->getValue()<<" wants state: "<<item.getValue();
+            if(items_[i]->getValue() != item.getValue())items_[i]->informValue(item.getValue());
+         }
+
+     }
+
+}
+
+void ItemStore::store(QJsonObject& json)
+{
+    QJsonArray itemsArray;
+    for(size_t i = 0; i < items_.size(); ++i)
+    {
+        QJsonObject itemObject;
+        items_[i]->store(itemObject);
+        itemsArray.append(itemObject);
+    }
+    json["Items"] = itemsArray;
+}
+
+void ItemStore::load(const QJsonObject& json, Microcontroller * const micro)
+{
+    const QJsonArray itemsArray(json["Items"].toArray(QJsonArray()));
+    for(int i = 0; i < itemsArray.size(); ++i)
+    {
+        if(itemsArray[i].isObject())
+        {
+            const QJsonObject itemObject = itemsArray[i].toObject();
+            if(!itemObject["Name"].isObject()) qDebug()<<"no name";
+            std::shared_ptr<Relay> newItem;
+            if(itemObject["Type"].toString("") == "Relay")
+            {
+                newItem = std::shared_ptr<Relay>(new Relay(sensors_, micro));
+            }
+            else if(itemObject["Type"].toString("") == "Aux")
+            {
+            }
+            if(newItem)
+            {
+                newItem->load(itemObject);
+                addItem(newItem);
+            }
+        }
+    }
+}
+
+void ItemStore::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "/NumberOfItems", static_cast<unsigned>(items_.size()));
+    for(size_t i = 0; i < items_.size(); ++i)
+    {
+        items_[i]->store(subsecton + "/Item" + QString::number(i), settings);
+    }
+}
+
+void ItemStore::load(QString subsecton, QSettings* settings, Microcontroller* micro)
+{
+    unsigned itemLen = settings->value(subsecton + "/NumberOfItems").toUInt();
+    for(size_t i = 0; i < itemLen; ++i)
+    {
+        std::shared_ptr<Relay> newItem;
+        if(settings->value(subsecton + "/Item" + QString::number(i)+ "Type").toString() == "Relay")
+        {
+            newItem = std::shared_ptr<Relay>(new Relay(sensors_, micro));
+        }
+        else if(settings->value(subsecton + "/Item" + QString::number(i)+ "Type").toString() == "Aux")
+        {
+        }
+        if(newItem)
+        {
+            newItem->load(subsecton + "/Item" + QString::number(i), settings);
+            addItem(newItem);
+        }
+    }
+}

src/items/itemstore.h

@@ -0,0 +1,41 @@
+#pragma once
+#include <vector>
+#include <memory>
+#include "item.h"
+#include "../sensors/sensor.h"
+#include "../microcontroller.h"
+
+#include <QJsonObject>
+
+class ItemStore: public QObject
+{
+    Q_OBJECT
+private:
+    std::vector< std::shared_ptr<Item> > items_;
+
+    SensorStore* sensors_;
+
+public:
+
+    ItemStore(SensorStore* sensors_ = nullptr, QObject *parent = nullptr);
+    virtual ~ItemStore(){}
+
+    inline std::vector< std::shared_ptr<Item> >* getItems(){ return &items_; }
+
+    void store(QJsonObject &json);
+    void load(const QJsonObject &json, Microcontroller * const micro);
+
+    void store(QString subsecton, QSettings* settings);
+    void load(QString subsecton, QSettings* settings, Microcontroller* micro);
+
+signals:
+
+    void itemDeleted(ItemData item);
+    void itemAdded(std::weak_ptr<Item> Item);
+
+public slots:
+
+    void addItem(std::shared_ptr<Item> item);
+    void addItems(const std::vector<std::shared_ptr<Item>>& itemsIn);
+    void itemStateChanged(const ItemData& item);
+};

src/items/poweritem.cpp

@@ -0,0 +1,37 @@
+#include "poweritem.h"
+#include <QProcess>
+#include <QApplication>
+
+PowerItem::PowerItem(SensorStore* sensors, QApplication* a, uint32_t itemIdIn, QString name,  uint8_t value, QObject* parent): Item(sensors, itemIdIn, name, value, parent), a_(a)
+{
+    stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 0));
+    setValue(true);
+}
+
+void PowerItem::setValue(uint8_t value)
+{
+    Item::setValue(value);
+    if(!value)
+    {
+       QTimer::singleShot(5000, this, &PowerItem::timeout);
+       stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 1));
+    }
+}
+
+void PowerItem::timeout()
+{
+    QProcess::startDetached("syncoff");
+    a_->exit(0);
+}
+
+void PowerItem::store(QJsonObject& json)
+{
+    json["Type"] = "Power";
+    Item::store(json);
+}
+
+void PowerItem::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Type", "Power");
+    Item::store(subsecton, settings);
+}

src/items/poweritem.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "item.h"
+#include "../sensors/sensors.h"
+#include "../microcontroller.h"
+
+#include <QTimer>
+
+class PowerItem: public Item
+{
+    Q_OBJECT
+private:
+    QApplication* a_;
+
+signals:
+
+    void stateChanged(Sensor sensor);
+
+private slots:
+
+    void timeout();
+
+public slots:
+
+    virtual void setValue(uint8_t value);
+
+public:
+    PowerItem(SensorStore* sensors, QApplication* a, uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "",  uint8_t value = 0, QObject* parent = nullptr);
+    void emmitSensor(){stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 0));}
+    virtual void store(QJsonObject& json);
+    virtual void store(QString subsecton, QSettings* settings);
+};

src/items/relay.cpp

@@ -0,0 +1,80 @@
+#include "relay.h"
+#include "../microcontroller.h"
+
+//Relay
+
+Relay::Relay(SensorStore* sensors, Microcontroller* micro, uint8_t id, QString name, uint16_t address, bool state, QObject* parent): Item(sensors, 0, name, state, parent), micro_(micro), id_(id), address_(address)
+{
+    itemId_ = address | ((uint32_t)id << 16);
+}
+
+void Relay::setValue(uint8_t value)
+{
+   Item::setValue(value);
+   if(value)micro_->relayOn(id_);
+   else micro_->relayOff(id_);
+}
+
+void Relay::on()
+{
+    setValue(true);
+}
+
+void Relay::off()
+{
+   setValue(false);
+}
+
+void Relay::toggle()
+{
+    value_ ? off() : on();
+}
+
+void Relay::store(QJsonObject& json)
+{
+    json["Type"] = "Relay";
+    Item::store(json);
+    json["Id"] = static_cast<double>(id_);
+    json["Address"] = address_;
+}
+
+void Relay::load(const QJsonObject& json)
+{
+    Item::load(json);
+    id_ = static_cast<uint8_t>(json["Id"].toInt(0));
+    address_ = static_cast<uint16_t>(json["Address"].toInt(0));
+    itemId_ = address_ | (static_cast<uint32_t>(id_) << 16);
+}
+
+void Relay::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Type", "Relay");
+    Item::store(subsecton, settings);
+    settings->setValue(subsecton + "Id", static_cast<unsigned>(id_));
+    settings->setValue(subsecton + "Address", address_);
+}
+
+void Relay::load(QString subsecton, QSettings* settings)
+{
+    Item::load(subsecton, settings);
+    id_ = settings->value(subsecton + "Id").toUInt();
+    address_ = settings->value(subsecton + "Address").toUInt();
+    itemId_ = address_ | ((uint32_t)id_ << 16);
+}
+
+uint16_t Relay::getAddress() const
+{
+    return address_;
+}
+
+uint8_t Relay::getId() const
+{
+    return id_;
+}
+
+void Relay::setId(uint8_t id)
+{
+    id_=id;
+    itemId_ = address_ | ((uint32_t)id << 16);
+}
+

src/items/relay.h

@@ -0,0 +1,41 @@
+#ifndef RELAY_H
+#define RELAY_H
+
+#include<stdint.h>
+#include<QObject>
+
+#include "../sensors/sensor.h"
+#include "item.h"
+
+class Microcontroller;
+
+class Relay : public Item
+{
+    Q_OBJECT
+private:
+    Microcontroller* micro_;
+
+    uint8_t id_;
+    uint16_t address_;
+
+public slots:
+
+    virtual void setValue(uint8_t value);
+    void on();
+    void off();
+    void toggle();
+
+public:
+    Relay(SensorStore* sensors, Microcontroller* micro, uint8_t id = 0, QString name = "", uint16_t address = 0, bool state = false, QObject* parent = nullptr);
+
+    uint16_t getAddress() const;
+    uint8_t getId() const;
+    void setId(uint8_t id);
+
+    virtual void store(QJsonObject& json);
+    virtual void load(const QJsonObject& json);
+
+    virtual void store(QString subsecton, QSettings* settings);
+    virtual void load(QString subsecton, QSettings* settings);
+};
+#endif // RELAY_H

src/items/rgbitem.cpp

@@ -0,0 +1,24 @@
+#include "rgbitem.h"
+
+RgbItem::RgbItem(SensorStore* sensors, Microcontroller* micro, uint32_t itemIdIn, QString name,  uint8_t value, QObject* parent): Item(sensors, itemIdIn, name, value, parent), micro_(micro)
+{
+
+}
+
+void RgbItem::setValue(uint8_t value)
+{
+    Item::setValue(value);
+    value ? micro_->rgbOn() : micro_->rgbOff();
+}
+
+void RgbItem::store(QJsonObject &json)
+{
+    json["Type"] = "Rgb";
+    Item::store(json);
+}
+
+void RgbItem::store(QString subsecton, QSettings* settings)
+{
+    settings->setValue(subsecton + "Type", "Rgb");
+    Item::store(subsecton, settings);
+}

src/items/rgbitem.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../microcontroller.h"
+#include "item.h"
+
+class RgbItem: public Item
+{
+    Q_OBJECT
+private:
+    Microcontroller* micro_;
+
+public slots:
+
+    virtual void setValue(uint8_t value);
+
+public:
+    RgbItem(SensorStore* sensors, Microcontroller* micro, uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "",  uint8_t value = 0, QObject* parent = nullptr);
+
+    virtual void store(QJsonObject& json);
+    virtual void store(QString subsecton, QSettings* settings);
+};

src/main.cpp

@@ -6,21 +6,118 @@
 #include <QSettings>
 #include <QSignalMapper>
 #include <QTcpSocket>
+#include <QFileInfo>
+#include <QJsonDocument>
+#include <QStandardPaths>
+
+#ifndef Q_OS_ANDROID
 #include <QtSerialPort/QtSerialPort>
 #include <QtSerialPort/QSerialPortInfo>
 #include <QCommandLineParser>
+#endif
 
-
-
-#include "alarmtime.h"
+#include "actors/alarmtime.h"
 #include "microcontroller.h"
-#include "mainwindow.h"
-#include "ampmanager.h"
+#include "ui/mainwindow.h"
+#include "sensors/speakersensor.h"
+#include "sensors/sunsensor.h"
+#include "sensors/ocupancysensor.h"
 #include "alarmactions.h"
-#include "alarmsettingsdialog.h"
+#include "sensors/sensor.h"
+#include "items/itemstore.h"
+#include "items/auxitem.h"
+#include "items/rgbitem.h"
+#include "items/poweritem.h"
+
 
 #define BAUD  QSerialPort::Baud38400
 
+QJsonDocument* createJsonDocument(const bool pathOption, const QString& filePath)
+{
+    QFile file;
+
+    #ifndef Q_OS_ANDROID
+    if(pathOption && filePath.size() > 0) file.setFileName(filePath);
+    else
+    #endif
+    {
+       file.setFileName(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json");
+    }
+
+    file.open(QIODevice::ReadOnly);
+    if(!file.isOpen()) std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
+    else
+    {
+        QJsonDocument* document = new QJsonDocument(QJsonDocument::fromJson(file.readAll()));
+        file.close();
+        return  document;
+    }
+    return new QJsonDocument;
+}
+
+void saveJsonDocument(const QJsonDocument * const document, const bool pathOption, const QString& filePath)
+{
+    QFile file;
+
+    #ifndef Q_OS_ANDROID
+    if(pathOption && filePath.size() > 0) file.setFileName(filePath);
+    else
+    #endif
+    {
+       file.setFileName(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json");
+    }
+    std::cout<<"config file: "<<file.fileName().toLatin1().data()<<std::endl;
+    file.open(QIODevice::WriteOnly);
+    if(!file.isOpen()) std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
+    else
+    {
+        file.write(document->toJson());
+        file.close();
+    }
+}
+
+QSettings* createQSettings(const bool pathOption, const QString& filePath )
+{
+    QSettings* settings;
+    #ifndef Q_OS_ANDROID
+    if(pathOption && filePath.size() > 0)
+    {
+        settings = new QSettings(filePath, QSettings::IniFormat);
+        std::cout<<"Config file: "<<settings->fileName().toLatin1().data()<<std::endl;
+    }
+    else if(pathOption)
+    {
+        std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
+        settings = new QSettings;
+    }
+    else
+    #endif
+    {
+        settings = new QSettings;
+    }
+    return  settings;
+}
+
+void loadItemState(const QJsonDocument * const jsonDocument, QSettings * const settings, Microcontroller* micro, ItemStore* items, PowerItem* power, RgbItem* rgb, AuxItem* aux )
+{
+    if(jsonDocument)
+    {
+        const QJsonObject jsonObject = jsonDocument->object();
+        items->load(jsonObject, micro);
+        power->load(jsonObject["Power"].toObject());
+        if(jsonObject["Items"].toArray().size() >= 2)
+        {
+            rgb->load(jsonObject["Items"].toArray()[0].toObject());
+            aux->load(jsonObject["Items"].toArray()[1].toObject());
+        }
+    }
+    else
+    {
+        items->load("Items", settings, micro);
+        power->load("Power", settings);
+    }
+}
+
 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv);
@@ -29,11 +126,12 @@ int main(int argc, char *argv[])
     QCoreApplication::setOrganizationName("UVOS");
     QCoreApplication::setOrganizationDomain("uvos.xyz");
     QCoreApplication::setApplicationName("SHinterface");
-    QCoreApplication::setApplicationVersion("0.5");
+    QCoreApplication::setApplicationVersion("0.6");
 
     QDir::setCurrent(a.applicationDirPath());
 
     //parse comand line
+    #ifndef Q_OS_ANDROID
     QCommandLineParser parser;
     parser.setApplicationDescription("Smart Home Interface");
     parser.addHelpOption();
@@ -48,14 +146,25 @@ int main(int argc, char *argv[])
     parser.addOption(serialOption);
     QCommandLineOption baudOption(QStringList() << "b" << "baud", QCoreApplication::translate("main", "Set Baud Rate"));
     parser.addOption(baudOption);
+    QCommandLineOption settingsPathOption(QStringList() << "c" << "config", QCoreApplication::translate("main", "Set config file"), "configFilePath");
+    parser.addOption(settingsPathOption);
     QCommandLineOption secondaryOption(QStringList() << "e" << "secondary", QCoreApplication::translate("main", "Set if instance is not main instance"));
     parser.addOption(secondaryOption);
+    QCommandLineOption qsettingsOption(QStringList() << "q" << "qsettigns", QCoreApplication::translate("main", "Set if jsettings file format should be used."));
+    parser.addOption(secondaryOption);
     parser.process(a);
+    #endif
+
+    QSettings* settings = nullptr;
+    QJsonDocument* jsonDocument = nullptr;
+    if(parser.isSet(qsettingsOption)) settings = createQSettings(parser.isSet(settingsPathOption), parser.value(settingsPathOption));
+    else jsonDocument = createJsonDocument(parser.isSet(settingsPathOption), parser.value(settingsPathOption));
 
-    QSettings settings;
 
     //connect to microcontoler
     Microcontroller micro;
+
+    #ifndef Q_OS_ANDROID
     if(parser.isSet(tcpOption))
     {
         QTcpSocket* microSocket = new QTcpSocket;
@@ -86,55 +195,95 @@ int main(int argc, char *argv[])
         if(!microPort->open(QIODevice::ReadWrite)) std::cout<<"Can not open serial port "<<microPort->portName().toStdString()<<". Continueing in demo mode"<<'\n';
         else micro.setIODevice(microPort);
     }
+    #else
+        QTcpSocket* microSocket = new QTcpSocket;
+        microSocket->connectToHost("10.0.0.1", 6856, QIODevice::ReadWrite);
+        if(!microSocket->waitForConnected(1000))
+        {
+            std::cout<<"Can not connect to to Server.\n";
+            return 1;
+        }
+        micro.setIODevice(microSocket);
+    #endif
 
-    AlarmActions alarmActions(&settings, &micro);
 
-    AmpManager amp(&micro, 0);
+    AlarmActions alarmActions(&a, &micro);
 
-    //Alarms
-    AlarmTime almNight(settings.value("nightTime").toTime());
-    AlarmTime almAlarm(settings.value("alarmTime").toTime());
+    //sensors
+    SpeakerSensorSource livingroomSpeakerSensorSource("Livingroom Speakers");
+    SunSensorSource     sunSensorSource(49.884450, 8.650536);
+    OcupancySensorSource ocupancySensor;
+
+    SensorStore sensors;
+    QObject::connect(&micro, &Microcontroller::gotSensorState, &sensors, &SensorStore::sensorGotState);
+    QObject::connect(&livingroomSpeakerSensorSource, &SpeakerSensorSource::stateChanged, &sensors, &SensorStore::sensorGotState);
+    QObject::connect(&sunSensorSource, &SunSensorSource::stateChanged, &sensors, &SensorStore::sensorGotState);
+    QObject::connect(&sensors, &SensorStore::sensorChangedState, &ocupancySensor, &OcupancySensorSource::sensorEvent);
+    QObject::connect(&ocupancySensor, &OcupancySensorSource::stateChanged, &sensors, &SensorStore::sensorGotState);
+
+    QMetaObject::invokeMethod(&livingroomSpeakerSensorSource, "run", Qt::QueuedConnection);
+    sunSensorSource.run();
+
+    //item store
+    ItemStore items(&sensors);
+    QObject::connect(&micro, &Microcontroller::gotRelayList, &items, &ItemStore::addItems);
+    QObject::connect(&micro, &Microcontroller::itemChanged, &items, &ItemStore::itemStateChanged);
+
+    //Power Item
+    PowerItem powerItem(&sensors, &a, 5487423, "Power");
+    QObject::connect(&powerItem, &PowerItem::stateChanged, &sensors, &SensorStore::sensorGotState);
+    powerItem.emmitSensor();
 
     //mainwindow
-    MainWindow w(&micro, parser.isSet(secondaryOption));
+    MainWindow w(&micro, &powerItem, &items, &sensors);
     QObject::connect(&micro, SIGNAL(textRecived(QString)), &w, SLOT(changeHeaderLableText(QString)));
-    QObject::connect(&micro, SIGNAL(relayStateChanged(std::vector<bool>)), &w, SLOT(relayStateChanged(std::vector<bool>)));
-    QObject::connect(&micro, SIGNAL(auxStateChanged(int)), &w, SLOT(auxStateChanged(int)));
+    if(!micro.connected()) w.changeHeaderLableText("No io debug only!");
 
-    //dialogs
-    AlarmSettingsDialog alarmDialog(&almNight, &almAlarm, &settings, &w);
+    //special items
+    std::shared_ptr<RgbItem> rgbItem(new RgbItem(&sensors, &micro, 5487422, "Rgb Lights"));
+    items.addItem(rgbItem);
 
-    if(!parser.isSet(secondaryOption))
-    {
-
-        QObject::connect(&almNight, SIGNAL(trigger()), &alarmActions, SLOT(syncoff()));
-        QObject::connect(&w, SIGNAL(signalAlmNightChanged(QTime)), &almNight, SLOT(changeTime(QTime)));
-        QObject::connect(&w, SIGNAL(signalAlmNightStateChanged(int)), &almNight, SLOT(runOrAbort(int)));
-        almNight.run();
-
-        QObject::connect(&almAlarm, &AlarmTime::trigger, &micro, &Microcontroller::startSunrise);
-        QObject::connect(&w, SIGNAL(signalAlmAlarmChanged(QTime)), &almAlarm, SLOT(changeTime(QTime)));
-        QObject::connect(&w, SIGNAL(signalAlmAlarmStateChanged(int)), &almAlarm, SLOT(runOrAbort(int)));
-        almAlarm.run();
-
-        //Amplifyer
-        QObject::connect(&w, SIGNAL(signalAmpOn()), &amp, SLOT(run()));
-        QObject::connect(&w, SIGNAL(signalAmpOff()), &amp, SLOT(abort()));
-        QMetaObject::invokeMethod(&amp, "run", Qt::QueuedConnection  );
-    }
-
-    //show dialogs
-    QObject::connect(&w, &MainWindow::showAlmSettingsDialog, &alarmDialog, &AlarmSettingsDialog::show);
+    std::shared_ptr<AuxItem> auxItem(new AuxItem(&sensors, &micro, 5487421, "Desk Light"));
+    items.addItem(auxItem);
 
     QMetaObject::invokeMethod(&micro, "run", Qt::QueuedConnection  );
 
+    loadItemState(jsonDocument, settings, &micro, &items, &powerItem, rgbItem.get(), auxItem.get());
+
+    #ifndef Q_OS_ANDROID
+    if(!parser.isSet(secondaryOption))
+    {
+        Item::secondaryFlag = false;
+    }
+    else
+    {
+        Item::secondaryFlag = true;
+    }
+    #endif
+
     w.show();
 
-    micro.requestRelayList();
-    micro.requestState();
+    //micro.requestState();
+    int retVal = a.exec();
 
-    micro.requestRelayList();
-    micro.requestState();
-
-    return a.exec();
+    if(settings)
+    {
+        items.store("Items", settings);
+        powerItem.store("Power/", settings);
+        settings->sync();
+    }
+    else
+    {
+        QJsonObject itemsJsonObject;
+        items.store(itemsJsonObject);
+        QJsonObject powerObject;
+        powerItem.store(powerObject);
+        itemsJsonObject.insert("Power", powerObject);
+        jsonDocument->setObject(itemsJsonObject);
+        saveJsonDocument(jsonDocument, parser.isSet(settingsPathOption), parser.value(settingsPathOption));
+    }
+    if(settings) delete settings;
+    else delete jsonDocument;
+    return retVal;
 }
+

src/microcontroller.cpp

@@ -1,15 +1,16 @@
 #include "microcontroller.h"
 
-//relays
+#include <chrono>
+#include <thread>
+
+static constexpr bool debug = true;
 
 void Microcontroller::relayToggle(int state, int relay)
 {
     char buffer[8];
     int length = sprintf(buffer, "%d \n", relay);
-    if(_port != nullptr) state ? _port->write("relay on ", sizeof("relay on ")-1) : _port->write("relay off ", sizeof("relay off ")-1);
-    state ? std::cout<<"relay on " : std::cout<<"relay off ";
-    std::cout<<buffer;
-    if(_port != nullptr) _port->write(buffer, length);
+    state ? write("relay on ") : write("relay off ");
+    write(buffer, length);
 }
 
 void Microcontroller::relayOn(int relay)
@@ -26,48 +27,61 @@ void Microcontroller::relayOff(int relay)
 
 void Microcontroller::rgbOn()
 {
-    if(_port != nullptr) _port->write("rgb on\n", sizeof("rgb on\n")-1);
+    write("rgb on\n");
 }
 
 void Microcontroller::rgbOff()
 {
-    if(_port != nullptr) _port->write( "rgb off\n", sizeof("rgb off\n")-1);
+    write( "rgb off\n");
 }
 
 void Microcontroller::changeRgbColor(const QColor color)
 {
     char buffer[64];
-    int length = sprintf(buffer, "rgb set %03d %03d %03d \n", color.red(), color.green(), color.blue() );
-    if(_port != nullptr) _port->write(buffer, length);
-    std::cout<<buffer;
+    int length = sprintf(buffer, "rgb set %03d %03d %03d\n", color.red(), color.green(), color.blue());
+        write(buffer, length);
+        std::cout<<buffer;
+    }
+
+    void Microcontroller::setAuxPwm(int duty)
+    {
+    char buffer[64];
+    int length = sprintf(buffer, "aux set %03d\n", duty );
+    write(buffer, length);
 }
 
-void Microcontroller::setAuxPwm(int duty)
+void Microcontroller::write(const QByteArray& buffer)
 {
-    if(duty != _auxState)
+    #ifndef Q_OS_ANDROID
+    if constexpr(debug) std::cerr<<buffer.data();
+    #endif
+    if(_port != nullptr)
     {
-        if(duty > 1)
-        {
-            if(_auxState <= 1 && _port != nullptr) _port->write("aux on\n");
-            char buffer[64];
-            int length = sprintf(buffer, "aux set %03d \n", duty );
-            if(_port != nullptr) _port->write(buffer, length);
-        }
-        else if(_port != nullptr)_port->write("aux off\n");
+        _port->write(buffer);
+        _port->waitForBytesWritten(1000);
     }
-    _auxState = duty;
+    std::this_thread::sleep_for(std::chrono::milliseconds(40));
+}
+
+void Microcontroller::write(char* buffer, const size_t length)
+{
+    #ifndef Q_OS_ANDROID
+    if constexpr(debug) std::cerr<<buffer;
+    #endif
+    if(_port != nullptr)
+    {
+        _port->write(buffer, length);
+        _port->waitForBytesWritten(1000);
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(40));
 }
 
 void Microcontroller::setPattern(int pattern)
 {
-    if(_port != nullptr)
-    {
         char buffer[4];
-        std::cout<<"pattern apply\n";
-        _port->write("rgb pattern ", sizeof("rgb pattern ")-1);
-        int length = sprintf(buffer, "%d \n", pattern);
-        _port->write(buffer, length);
-    }
+        write("rgb pattern ");
+        int length = sprintf(buffer, "%d\n", pattern);
+        write(buffer, length);
 }
 
 void Microcontroller::startSunrise()
@@ -96,12 +110,7 @@ void Microcontroller::run()
 
 void Microcontroller::requestState()
 {
-   if(_port != nullptr) _port->write("state\n", sizeof("state\n"));
-}
-
-void Microcontroller::requestRelayList()
-{
-    if(_port != nullptr) _port->write("relay list\n", sizeof("relay list\n"));
+   write("state\n");
 }
 
 void Microcontroller::abort()
@@ -112,16 +121,12 @@ void Microcontroller::abort()
     }
 }
 
-std::vector<bool> Microcontroller::getLastState()
-{
-    return _relayStates;
-}
-
 //housekeeping
 
 Microcontroller::Microcontroller(QIODevice* port): _port(port)
 {
-
+    _port->readAll();
+    _port->write("\n");
 }
 
 Microcontroller::Microcontroller()
@@ -136,31 +141,60 @@ Microcontroller::~Microcontroller()
 void Microcontroller::setIODevice(QIODevice *port)
 {
     _port = port;
+    _port->readAll();
+    _port->write("\n");
+}
+
+std::shared_ptr<Relay> Microcontroller::processRelayLine(const QString& buffer)
+{
+    QStringList bufferList = buffer.split(' ');
+    if(bufferList.size() >= 8 && buffer.startsWith("RELAY NUMBER:"))
+    {
+        QString name;
+        for(int i = 8; i < bufferList.size(); i++) name.append(bufferList[i] + ' ');
+        if(name.size() > 1)name.remove(name.size()-1, 1);
+        else name = "Relay " + QString::number(bufferList[1].toInt(nullptr, 2));
+        qDebug()<<"Relay "<<bufferList[2].toInt()<<"Name "<<name<<" id "<<bufferList[4].toInt(nullptr, 2)<<" state "<<bufferList[6].toInt();
+        return std::shared_ptr<Relay>( new Relay(nullptr, this, bufferList[2].toInt(), name, bufferList[4].toInt(nullptr, 2), bufferList[6].toInt()));
+    }
+    return  nullptr;
+}
+
+void Microcontroller::processList(const QString& buffer)
+{
+    QStringList bufferList = buffer.split(' ');
+    if(bufferList.size() >= 8 && buffer.startsWith("RELAY NUMBER:"))
+    {
+        relayList.push_back(processRelayLine(buffer));
+    }
+    else if(buffer.contains("EOL"))
+    {
+        listMode = false;
+        qDebug()<<"got relay list " << relayList.size();
+        gotRelayList(relayList);
+        relayList.clear();
+    }
+    else listMode = false;
+}
+
+void Microcontroller::processRelayState(const QString& buffer)
+{
+    itemChanged(static_cast<ItemData>(*processRelayLine(buffer)));
+}
+
+void Microcontroller::processSensorState(const QString& buffer)
+{
+    QStringList bufferList = buffer.split(' ');
+    Sensor sensor(bufferList[2].toUInt(), bufferList[4].toUInt(), bufferList[6].toUInt());
+    if(sensor.type == Sensor::TYPE_HUMIDITY ||  sensor.type == Sensor::TYPE_TEMPERATURE) sensor.field = sensor.field/10;
+    if(bufferList.size() >= 7)gotSensorState(sensor);
 }
 
 
 void Microcontroller::processMicroReturn()
 {
-    QString workbuff = _buffer;
-
-    if(listMode)
-    {
-        QStringList workbufList = workbuff.split(' ');
-        if(workbufList.size() >= 5 && workbufList[0] == "NUMBER:")
-        {
-            QString name;
-            for(int i = 5; i < workbufList.size(); i++) name.append(workbufList[i] + ' ');
-            name.remove(name.size()-1, 1);
-            relayList.push_back(RelayStore(workbufList[1].toInt(), name, workbufList[3].toInt()));
-        }
-        else if(_buffer.startsWith("EOL"))
-        {
-            listMode = false;
-            gotRelayList(relayList);
-            relayList.clear();
-        }
-        else listMode = false;
-    }
+    qDebug()<<_buffer;
+    if(listMode) processList(_buffer);
     else
     {
         if(_buffer.startsWith("Relays:"))
@@ -168,43 +202,8 @@ void Microcontroller::processMicroReturn()
             listMode = true;
             relayList.clear();
         }
-        else if(_buffer.startsWith("ST"))
-        {
-
-            workbuff.remove(0, 2);
-            QStringList workbufList = workbuff.split(',');
-
-            //aux state
-            if(workbufList[0].toInt() != _auxState)
-            {
-                _auxState = workbufList[0].toInt();
-                auxStateChanged(_auxState);
-            }
-
-            //relay state
-            uint_fast8_t numberOfRelays = workbufList[1].toInt();
-            if(workbufList.size() >= numberOfRelays+2)
-            {
-                _relayStates.resize(numberOfRelays, false);
-                for(uint_fast8_t i = 0; i < numberOfRelays; i++)
-                {
-                    if(_relayStates[i] != static_cast<bool>(workbufList[i+2].toInt()))
-                    {
-                        _relayStates[i] = static_cast<bool>(workbufList[i+2].toInt());
-                       relayStateChanged(RelayStore(i, "", 0, _relayStates[i]));
-                    }
-                }
-            }
-        }
-        else if(workbuff.contains("Door Open Warning"))
-        {
-            doorOpenTimeout();
-        }
-        else if(workbuff.size() > 2 && workbuff[0]=='D' && workbuff[1]=='2')
-        {
-            if(workbuff[3] == 'O') doorOpened(1);
-            else if(workbuff[3] == 'C') doorClosed(1);
-        }
+        else if(_buffer.startsWith("RELAY NUMBER:"))processRelayState(_buffer);
+        else if(_buffer.startsWith("SENSOR")) processSensorState(_buffer);
     }
 
 }

src/microcontroller.h

@@ -8,12 +8,15 @@
 #include <QIODevice>
 #include <QString>
 #include <QRunnable>
-#include <QScopedPointer>
+#include <QDebug>
 #include <QEventLoop>
 #include <QTimer>
 #include <QAbstractButton>
 #include <vector>
-#include "relay.h"
+#include <memory>
+#include "items/item.h"
+#include "items/relay.h"
+#include "sensors/sensor.h"
 
 class Microcontroller : public QObject
 {
@@ -23,20 +26,31 @@ class Microcontroller : public QObject
 public:
 
     static constexpr char AMP_RELAY = 0;
+    static constexpr char SENSOR_TEMPERATURE = 1;
+    static constexpr char SENSOR_DOOR = 0 ;
 
 private:
 
     bool listMode = false;
-    std::vector<RelayStore> relayList;
 
-    std::vector<bool> _relayStates; //ugh vector of bools
-    int _auxState = 0;
+    //uint8_t _auxState = 0;
+
     QIODevice* _port = nullptr;
 
+    std::vector< std::shared_ptr<Item> > relayList;
+
     QScopedPointer<QEventLoop> loop;
     QString _buffer;
 
     void processMicroReturn();
+    void processList(const QString& buffer);
+    void processRelayState(const QString& buffer);
+    void processSensorState(const QString& buffer);
+    std::shared_ptr<Relay> processRelayLine(const QString& buffer);
+
+    void write(char *buffer, const size_t length);
+    void write(const QByteArray& buffer);
+
 
 public:
     Microcontroller(QIODevice* port);
@@ -44,7 +58,6 @@ public:
     ~Microcontroller();
     bool connected();
     void setIODevice(QIODevice* port);
-    std::vector<bool> getLastState();
 
 public slots:
     void rgbOn();
@@ -53,8 +66,7 @@ public slots:
     void setPattern(int pattern);
     void startSunrise();
 
-    void requestRelayList();
-     void requestState();
+    void requestState();
 
     void setAuxPwm(int duty);
 
@@ -68,12 +80,11 @@ public slots:
 
 signals:
     void textRecived(const QString string);
-    void relayStateChanged(RelayStore relay);
+    void itemChanged(ItemData relay);
     void auxStateChanged(int value);
-    void gotRelayList(std::vector<RelayStore>& relays);
-    void doorOpenTimeout();
-    void doorOpened(int id);
-    void doorClosed(int id);
+    void gotRelayList(std::vector< std::shared_ptr<Item> >&);
+
+    void gotSensorState(Sensor sensor);
 };
 
 #endif // MICROCONTROLLER_H

src/relay.cpp

@@ -1,116 +0,0 @@
-#include "relay.h"
-#include "microcontroller.h"
-
-RelayStore::RelayStore(uint8_t id, QString name, uint16_t address, bool state): name_(name),  state_(state), id_(id), address_(address)
-{
-
-}
-
-QString RelayStore::getName() const
-{
-    return name_;
-}
-
-void RelayStore::setName(QString name)
-{
-    name_ = name;
-}
-
-bool RelayStore::getState() const
-{
-    return state_;
-}
-
-bool RelayStore::actorsActive() const
-{
-    return actorsActive_;
-}
-
-uint16_t RelayStore::getAddress() const
-{
-    return address_;
-}
-
-uint8_t RelayStore::getId() const
-{
-    return id_;
-}
-
-void RelayStore::setId(uint8_t id)
-{
-    id_=id;
-}
-
-//Relay
-
-Relay::Relay(Microcontroller* micro, uint8_t id, QString name, uint16_t address, bool state, QObject* parent): QObject(parent), RelayStore(id, name, address, state), micro_(micro)
-{
-
-}
-
-Relay::Relay(Microcontroller* micro, const RelayStore& relayStore, QObject *parent): QObject(parent), RelayStore(relayStore), micro_(micro)
-{
-
-}
-
-void Relay::setState(bool state)
-{
-    state_ = state;
-}
-
-void Relay::addActor(Actor* actor)
-{
-    actor->setParent(this);
-    actors_.push_back(actor);
-    connect(actor, &Actor::on, this, &Relay::on);
-    connect(actor, &Actor::off, this, &Relay::off);
-    connect(actor, &Actor::toggle, this, &Relay::toggle);
-    if(actorsActive_) actor->makeActive();
-}
-
-std::vector< Actor* > Relay::getActors()
-{
-    return actors_;
-}
-
-bool Relay::hasActors()
-{
-    return actors_.size() > 0;
-}
-
-Relay* Relay::copy() const
-{
-    Relay* copy = new Relay(micro_, id_, name_, address_, parent());
-    copy->actors_ = actors_;
-    return copy;
-}
-
-void Relay::on()
-{
-    micro_->relayOn(id_);
-    state_ = true;
-    for(unsigned i = 0; i < actors_.size(); i++) actors_[i]->onStateChanged(state_);
-}
-
-void Relay::off()
-{
-    micro_->relayOff(id_);
-    state_ = false;
-    for(unsigned i = 0; i < actors_.size(); i++) actors_[i]->onStateChanged(state_);
-}
-
-void Relay::toggle()
-{
-    state_ ? off() : on();
-}
-
-void Relay::moveToState(bool state)
-{
-    state ? on() : off();
-}
-
-void Relay::setActorsActive(bool in)
-{
-    actorsActive_ = true;
-    for(unsigned i = 0; i < actors_.size(); i++) in ? actors_[i]->makeActive() : actors_[i]->makeInactive();
-}

src/relay.h

@@ -1,57 +0,0 @@
-#ifndef RELAY_H
-#define RELAY_H
-
-#include<stdint.h>
-#include<QObject>
-#include<QString>
-#include<vector>
-#include<memory>
-
-#include"actor.h"
-
-class Microcontroller;
-
-class RelayStore
-{
-    protected:
-        QString name_;
-        bool state_ = false;
-        uint8_t id_;
-        uint16_t address_;
-        bool actorsActive_ = true;
-
-    public:
-        RelayStore(uint8_t id, QString name = "", uint16_t address = 0, bool state = false);
-        bool actorsActive() const;
-        QString getName() const;
-        void setName(QString name);
-        uint16_t getAddress() const;
-        uint8_t getId() const;
-        void setId(uint8_t id);
-        bool getState() const;
-};
-
-class Relay : public QObject, public RelayStore
-{
-    Q_OBJECT
-private:
-    Microcontroller* micro_;
-    std::vector< Actor* > actors_;
-
-public slots:
-    void on();
-    void off();
-    void toggle();
-    void moveToState(bool state);
-    void setActorsActive(bool in);
-
-public:
-    Relay(Microcontroller* micro, uint8_t id, QString name = "", uint16_t address = 0, bool state = false, QObject *parent = nullptr);
-    Relay(Microcontroller* micro, const RelayStore& relayStore, QObject *parent = nullptr);
-    void addActor(Actor* actor);
-    bool hasActors();
-    Relay* copy() const;
-    void setState(bool state);
-    std::vector< Actor* > getActors();
-};
-#endif // RELAY_H

src/relayscrollbox.cpp

@@ -1,66 +0,0 @@
-#include "relayscrollbox.h"
-#include "ui_relayscrollbox.h"
-
-RelayScrollBox::RelayScrollBox(QWidget *parent) :
-    QWidget(parent),
-    ui(new Ui::RelayScrollBox)
-{
-    ui->setupUi(this);
-}
-
-RelayScrollBox::~RelayScrollBox()
-{
-    delete ui;
-}
-
-void RelayScrollBox::addRelay(const Relay& relay)
-{
-    widgets_.push_back(new RelayWidget(relay.copy(), this));
-    ui->relayWidgetVbox->addWidget(widgets_.back());
-}
-
-void RelayScrollBox::addRelay(const RelayStore& relay)
-{
-    RelayWidget* newWidget = new RelayWidget(new Relay(micro_, relay), this);
-    widgets_.push_back(newWidget);
-    ui->relayWidgetVbox->addWidget(widgets_.back());
-}
-
-void RelayScrollBox::setMicrocontoller(Microcontroller* micro)
-{
-    micro_ = micro;
-}
-
-void RelayScrollBox::gotRelays(const std::vector<RelayStore>& relays)
-{
-    for(unsigned i = 0; i < widgets_.size(); i++ )
-    {
-        bool mached = false;
-        for(unsigned j = 0; j < relays.size(); j++) if(widgets_[i]->getRelay()->getAddress() == relays[j].getAddress())
-        {
-            mached = true;
-            if(widgets_[i]->getRelay()->getId() != relays[j].getId()) widgets_[i]->getRelay()->setId(relays[j].getId());
-        }
-        if(!mached)
-        {
-            delete widgets_[i];
-            widgets_.erase(widgets_.begin()+i);
-        }
-    }
-
-    for(unsigned j = 0; j < relays.size(); j++)
-    {
-        bool mached = false;
-        for(unsigned i = 0; i < widgets_.size(); i++ ) if(widgets_[i]->getRelay()->getAddress() == relays[j].getAddress()) mached = true;
-        if(!mached)
-        {
-           addRelay(relays[j]);
-        }
-    }
-
-}
-
-void RelayScrollBox::relaySateChanged(const RelayStore& Realy)
-{
-
-}

src/relayscrollbox.h

@@ -1,40 +0,0 @@
-#ifndef RELAYSCROLLBOX_H
-#define RELAYSCROLLBOX_H
-
-#include <QWidget>
-#include <vector>
-#include <memory>
-#include "relaywidget.h"
-#include "relay.h"
-#include "microcontroller.h"
-
-
-namespace Ui {
-class RelayScrollBox;
-}
-
-class RelayScrollBox : public QWidget
-{
-    Q_OBJECT
-private:
-    Microcontroller* micro_ = nullptr;
-    std::vector< RelayWidget* > widgets_;
-
-public:
-    explicit RelayScrollBox(QWidget *parent = nullptr);
-    ~RelayScrollBox();
-
-public slots:
-    void addRelay(const Relay& relay);
-    void addRelay(const RelayStore& relay);
-    void setMicrocontoller(Microcontroller* micro);
-    void gotRelays(const std::vector<RelayStore>& relays);
-    void relaySateChanged(const RelayStore& Realy);
-
-private:
-    Ui::RelayScrollBox *ui;
-};
-
-#endif // RELAYSCROLLBOX_H
-
-

src/sensors/ocupancysensor.cpp

@@ -0,0 +1,42 @@
+#include "ocupancysensor.h"
+#include <QTimer>
+#include <QDebug>
+
+
+OcupancySensorSource::OcupancySensorSource(QObject *parent): QObject (parent)
+{
+    connect(&ping, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(pingExit(int, QProcess::ExitStatus)));
+    Timeout();
+}
+
+void OcupancySensorSource::sensorEvent(Sensor sensor)
+{
+    if(sensor.type == Sensor::TYPE_DOOR && sensor.id == 1 && sensor.field != 0.0f)
+    {
+        QTimer::singleShot(240000, this, &OcupancySensorSource::Timeout);
+         qDebug()<<"starting timer";
+    }
+}
+
+void OcupancySensorSource::Timeout()
+{
+    qDebug()<<"starting ping";
+    ping.start("ping 192.168.0.104 -c 1 -W 1");
+}
+
+void OcupancySensorSource::pingExit(int exitCode, QProcess::ExitStatus exitStatus)
+{
+    qDebug()<<"ping finished";
+    if(exitStatus == QProcess::ExitStatus::NormalExit)
+    {
+        qDebug()<<"Exit Code "<<exitCode;
+        if(exitCode == 0)
+        {
+            stateChanged(Sensor(Sensor::TYPE_OCUPANCY, 0, 1, "Occupancy"));
+        }
+        else
+        {
+            stateChanged(Sensor(Sensor::TYPE_OCUPANCY, 0, 0, "Occupancy"));
+        }
+    }
+}

src/sensors/ocupancysensor.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <QObject>
+#include <QProcess>
+#include "sensor.h"
+
+class OcupancySensorSource : public QObject
+{
+    Q_OBJECT
+private:
+
+    QProcess ping;
+
+public:
+    explicit OcupancySensorSource(QObject *parent = nullptr);
+
+public slots:
+    void sensorEvent(Sensor sensor);
+
+private slots:
+
+    void Timeout();
+    void pingExit(int exitCode, QProcess::ExitStatus exitStatus);
+
+signals:
+    void stateChanged(Sensor sensor);
+};

src/sensors/sensor.cpp

@@ -0,0 +1,45 @@
+#include "sensor.h"
+
+#include <QDebug>
+
+SensorStore::SensorStore(QObject *parent): QObject(parent)
+{
+    sensors_.push_back(Sensor(0,1,0,"Front door"));
+    sensors_.push_back(Sensor(0,0,0,"Bedroom door"));
+}
+
+void SensorStore::sensorGotState(const Sensor& sensor)
+{
+    bool exsisting = false;
+    for(unsigned i = 0; i < sensors_.size(); ++i)
+    {
+        if(sensor.type == sensors_[i].type && sensor.id == sensors_[i].id)
+        {
+            sensors_[i].updateSeen();
+            if(sensors_[i].field != sensor.field)
+            {
+                sensors_[i].field = sensor.field;
+                sensorChangedState(sensor);
+                stateChenged(sensors_);
+            }
+            exsisting = true;
+            break;
+        }
+    }
+    if(!exsisting)
+    {
+        sensors_.push_back(sensor);
+        sensorChangedState(sensor);
+        stateChenged(sensors_);
+    }
+
+    for(unsigned i = 0; i < sensors_.size(); ++i)
+    {
+        if(sensors_[i].type > 0 && sensors_[i].type < 128 && QDateTime::currentDateTime() > sensors_[i].lastSeen.addSecs(1800))
+        {
+            sensorDeleted(sensors_[i]);
+            stateChenged(sensors_);
+            sensors_.erase(sensors_.begin()+i);
+        }
+    }
+}

src/sensors/sensor.h

@@ -0,0 +1,77 @@
+#pragma once
+#include <stdint.h>
+#include<QString>
+#include<QDateTime>
+#include<QObject>
+#include<vector>
+
+class Sensor
+{
+public:
+
+    static constexpr uint8_t TYPE_DOOR = 0;
+    static constexpr uint8_t TYPE_TEMPERATURE = 1;
+    static constexpr uint8_t TYPE_HUMIDITY = 2;
+    static constexpr uint8_t TYPE_PRESSURE = 3;
+    static constexpr uint8_t TYPE_BRIGHTNESS = 4;
+    static constexpr uint8_t TYPE_LOWBATTERY = 128;
+    static constexpr uint8_t TYPE_SHUTDOWN_IMMINENT = 251;
+    static constexpr uint8_t TYPE_OCUPANCY = 252;
+    static constexpr uint8_t TYPE_SUN_ALTITUDE = 253;
+    static constexpr uint8_t TYPE_AUDIO_OUTPUT = 254;
+    static constexpr uint8_t TYPE_DUMMY = 255;
+
+    uint8_t type;
+    uint8_t id;
+    float field;
+    QString name;
+    QDateTime lastSeen;
+
+    Sensor(uint8_t typeIn, uint8_t idIn, float fieldIn = 0, QString nameIn = ""): type(typeIn), id(idIn), field(fieldIn), name(nameIn)
+    {
+        lastSeen = QDateTime::currentDateTime();
+        if(nameIn == "") generateName();
+    }
+    Sensor(QString nameIn = "dummy"): type(TYPE_DUMMY), id(0), field(0), name(nameIn)
+    {
+        lastSeen = QDateTime::currentDateTime();
+    }
+    inline bool operator==(const Sensor& in){ return type==in.type && id == in.id; }
+    inline bool operator!=(const Sensor& in){ return !(*this==in); }
+    inline void updateSeen(){lastSeen = QDateTime::currentDateTime();}
+    inline void generateName()
+    {
+        if(type == TYPE_TEMPERATURE) name = "Temperature " + QString::number(id);
+        else if(type == TYPE_DOOR)  name = "Door " + QString::number(id);
+        else if(type == TYPE_AUDIO_OUTPUT)  name = "Speakers " + QString::number(id);
+        else if(type == TYPE_HUMIDITY)  name = "Humidity " + QString::number(id);
+        else if(type == TYPE_SUN_ALTITUDE)  name = "Solar Altitude";
+        else if(type == TYPE_SHUTDOWN_IMMINENT)  name = "Shutdown Imminent";
+        else name = "Sensor Type " + QString::number(type) + " Id " + QString::number(id);
+    }
+};
+
+class SensorStore: public QObject
+{
+    Q_OBJECT
+private:
+    std::vector<Sensor> sensors_;
+
+public:
+
+    SensorStore(QObject *parent = nullptr);
+    virtual ~SensorStore(){}
+
+    inline std::vector<Sensor>* getSensors(){ return &sensors_; }
+
+public slots:
+
+    void sensorGotState(const Sensor& sensor);
+
+signals:
+
+    void stateChenged(std::vector<Sensor> sensors);
+    void sensorChangedState(Sensor sensor);
+    void sensorDeleted(Sensor sensor);
+
+};

src/sensors/speakersensor.cpp

@@ -0,0 +1,59 @@
+#include "speakersensor.h"
+
+#include <QDebug>
+
+SpeakerSensorSource::SpeakerSensorSource(QString name, QObject *parent) : QObject(parent), name_(name)
+{
+  silenceCount = 0;
+}
+
+SpeakerSensorSource::~SpeakerSensorSource()
+{
+    abort();
+}
+
+void SpeakerSensorSource::run()
+{
+    abort();
+    arecord.start( "arecord --disable-softvol -r 8000 -D front -" );
+
+    connect(&timer, SIGNAL(timeout()), this, SLOT(doTick()));
+    timer.setInterval(500);
+    timer.start();
+
+    stateChanged(Sensor(Sensor::TYPE_AUDIO_OUTPUT, 0, 1, name_));
+}
+
+
+void SpeakerSensorSource::abort()
+{
+    if(arecord.state() == QProcess::Running)arecord.close();
+    if(timer.isActive())timer.stop();
+}
+
+void SpeakerSensorSource::doTick()
+{
+    if(arecord.state() == QProcess::Running)
+    {
+       QByteArray buffer = arecord.readAllStandardOutput();
+       //qDebug()<<(int16_t)buffer[0];
+       for(long i = 0; i < buffer.size(); i++)
+       {
+           if((int16_t)buffer.at(i) != -128)
+           {
+              silenceCount = 0;
+           }
+       }
+       if(silenceCount > 40 && state)
+       {
+            stateChanged(Sensor(Sensor::TYPE_AUDIO_OUTPUT, 0, 0, name_));
+            state = false;
+       }
+       else if(silenceCount == 0 && !state)
+       {
+           stateChanged(Sensor(Sensor::TYPE_AUDIO_OUTPUT, 0, 1, name_));
+           state = true;
+       }
+       silenceCount++;
+    }
+}

src/sensors/speakersensor.h

@@ -10,39 +10,36 @@
 #include <QTimer>
 #include <QProcess>
 #include <QByteArray>
-#include <QtDebug>
 
-#include "microcontroller.h"
+#include "sensor.h"
 
 
-class AmpManager : public QObject
+class SpeakerSensorSource : public QObject
 {
     Q_OBJECT
+private:
+    QString name_;
+    bool state = true;
+    QTimer timer;
+
 public:
-    explicit AmpManager(Microcontroller *micro, int relayNumber, QObject *parent = nullptr);
-    ~AmpManager();
-
-
+    explicit SpeakerSensorSource(QString name = "", QObject *parent = nullptr);
+    ~SpeakerSensorSource();
 
 public slots:
     void run();
     void abort();
 
+signals:
+    void stateChanged(Sensor sensor);
+
 private slots:
     void doTick();
 
 private:
-    QScopedPointer<QEventLoop> loop;
-
     long silenceCount = 0;
-    Microcontroller *_micro;
-    int _relayNumber;
-
 
     QProcess arecord;
-
-    bool relayState = false;
-
 };
 
 #endif // AMPMANAGER_H

src/sensors/sunsensor.cpp

@@ -0,0 +1,25 @@
+#include "sunsensor.h"
+
+SunSensorSource::SunSensorSource(double lat, double lon, QObject *parent): QObject(parent), sun_(lat, lon)
+{
+    connect(&timer, SIGNAL(timeout()), this, SLOT(doTick()));
+}
+
+void SunSensorSource::run()
+{
+    connect(&timer, SIGNAL(timeout()), this, SLOT(doTick()));
+    timer.setInterval(10000); //10s
+    timer.start();
+    doTick();
+}
+
+
+void SunSensorSource::abort()
+{
+    if(timer.isActive())timer.stop();
+}
+
+void SunSensorSource::doTick()
+{
+    stateChanged(Sensor(Sensor::TYPE_SUN_ALTITUDE, 0, static_cast<float>(sun_.altitude())));
+}

src/sensors/sunsensor.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <QTimer>
+
+#include "../sun.h"
+#include "sensor.h"
+
+
+class SunSensorSource : public QObject
+{
+    Q_OBJECT
+private:
+
+    Sun sun_;
+    QTimer timer;
+
+public:
+    explicit SunSensorSource(double lat, double lon, QObject *parent = nullptr);
+
+public slots:
+    void run();
+    void abort();
+
+signals:
+    void stateChanged(Sensor sensor);
+
+private slots:
+    void doTick();
+};

src/serial_io.cpp

@@ -1,67 +0,0 @@
-#include "serial_io.h"
-
-struct termios toptions;;
-
-void sWrite(int port, char string[], size_t length)
-{
-    if(port != -1) write(port, string, length);
-    else std::cout<<string;
-}
-
-void sWrite(int port, const char string[], size_t length)
-{
-    if(port != -1) write(port, string, length);
-    else std::cout<<string;
-}
-
-ssize_t sRead(int port, void *buf, size_t count)
-{
-    return (port != -1) ? read(port, buf, count) : 0;
-}
-
-int serialport_init()
-{
-int fd;
-    system("stty -F /dev/ttyUSB0 38400 sane -echo");
-    fd = open(DEVICE, O_RDWR | O_NOCTTY | O_NDELAY);
-    if (fd == -1)
-        {
-        perror("init_serialport: Unable to open port ");
-        return -1;
-        }
-
-    if (tcgetattr(fd, &toptions) < 0)
-        {
-        perror("init_serialport: Couldn't get term attributes");
-        return -1;
-        }
-    speed_t brate = BAUDRATE;
-    cfsetispeed(&toptions, brate);
-    cfsetospeed(&toptions, brate);
-    // 8N1
-    toptions.c_cflag &= ~PARENB;
-    toptions.c_cflag &= ~CSTOPB;
-    toptions.c_cflag &= ~CSIZE;
-    toptions.c_cflag |= CS8;
-    // no flow control
-    toptions.c_cflag &= ~CRTSCTS;
-
-    toptions.c_cflag |= CREAD | CLOCAL | IGNPAR;  // turn on READ & ignore ctrl lines
-    toptions.c_iflag &= ~(IXON | IXOFF | IXANY); // turn off s/w flow ctrl
-
-    toptions.c_lflag &= ~(ICANON | ISIG | ECHO | ECHOE); // make raw
-    toptions.c_oflag &= ~OPOST; // make raw
-
-    // see: http://unixwiz.net/techtips/termios-vmin-vtime.html
-    toptions.c_cc[VMIN]  = 0;
-    toptions.c_cc[VTIME] = 20;
-    fcntl(fd, F_SETFL, FNDELAY);
-
-    if( tcsetattr(fd, TCSANOW, &toptions) < 0)
-        {
-        perror("init_serialport: Couldn't set term attributes");
-        return -1;
-        }
-    return fd;
-}
-

src/serial_io.h

@@ -1,21 +0,0 @@
-#ifndef SERIAL_H
-#define SERIAL_H
-#include <termios.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <iostream>
-
-#define BAUDRATE B38400
-#define DEVICE "/dev/ttyUSB0"
-
-void sWrite(int port, char string[], size_t length);
-
-void sWrite(int port, const char string[], size_t length);
-
-ssize_t sRead(int port, void *buf, size_t count);
-
-
-int serialport_init();
-
-
-#endif // SERIAL_H

src/serialwatcher.cpp

@@ -1,36 +0,0 @@
-#include "serialwatcher.h"
-
-void SerialWatcher::run()
-{
-    abort();
-
-    loop.reset(new QEventLoop);
-    QTimer timer;
-    connect(&timer, SIGNAL(timeout()), this, SLOT(doTick()));
-    timer.setInterval(500);
-    timer.start();
-
-    loop->exec();
-}
-
-
-void SerialWatcher::abort()
-{
-    if (!loop.isNull()){
-        loop->quit();
-    }
-}
-
-void SerialWatcher::doTick()
-{
-    char charBuf;
-    while(sRead(_serial, &charBuf, 1) == 1)
-    {
-        _buffer.push_back(charBuf);
-        if( _buffer.endsWith('\n') )
-        {
-            textRecived(_buffer);
-            _buffer.clear();
-        }
-    }
-}

src/serialwatcher.h

@@ -1,39 +0,0 @@
-#ifndef SERIALWATCHER_H
-#define SERIALWATCHER_H
-#include "serial_io.h"
-
-#define BUFFER_SIZE 128
-
-#include<QString>
-#include<QObject>
-#include<QRunnable>
-#include<QScopedPointer>
-#include<QEventLoop>
-#include<QTimer>
-
-class SerialWatcher: public QObject, public QRunnable
-{
-    Q_OBJECT
-private:
-
-    QScopedPointer<QEventLoop> loop;
-    int _serial;
-    
-    QString _buffer;
-
-public:
-    explicit SerialWatcher(int serial, QObject *parent = 0);
-    ~SerialWatcher();
-
-signals:
-    void textRecived(const QString string);
-
-public slots:
-    void run();
-    void abort();
-
-    void doTick();
-};
-
-
-#endif // SERIALWATCHER_H

src/speakersensor.cpp

@@ -1,65 +0,0 @@
-#include "ampmanager.h"
-
-AmpManager::AmpManager(Microcontroller *micro, int relayNumber, QObject *parent) : QObject(parent), _micro(micro), _relayNumber(relayNumber)
-{
-  silenceCount = 0;
-}
-
-AmpManager::~AmpManager()
-{
-    abort();
-}
-
-void AmpManager::run()
-{
-    abort();
-    arecord.start( "arecord -D front  -" );
-    loop.reset(new QEventLoop);
-    QTimer timer;
-    connect(&timer, SIGNAL(timeout()), this, SLOT(doTick()));
-    timer.setInterval(500);
-    timer.start();
-
-    qDebug()<<"Start Auto Amp Manager\n";
-    _micro->relayOn(_relayNumber);
-    relayState = true;
-    loop->exec();
-}
-
-
-void AmpManager::abort()
-{
-    if (!loop.isNull()){
-        loop->quit();
-    }
-    if(arecord.state() == QProcess::Running)arecord.close();
-    qDebug()<<"Stop Auto Amp Manager\n";
-}
-
-void AmpManager::doTick()
-{
-    if(arecord.state() == QProcess::Running)
-    {
-       QByteArray buffer = arecord.readAllStandardOutput();
-       for(long i = 0; i < buffer.size(); i++)
-       {
-           if((uint8_t) buffer.at(i) != 128)
-           {
-               silenceCount = 0;
-           }
-       }
-       if(silenceCount > 40 && relayState)
-       {
-            std::cout<<"Auto off Amp\n";
-            _micro->relayOff(_relayNumber);
-            relayState = false;
-       }
-       else if(silenceCount == 0 && !relayState)
-       {
-           std::cout<<"Auto on Amp\n";
-           _micro->relayOn(_relayNumber);
-           relayState = true;
-       }
-       silenceCount ++;
-    }
-}

src/sun.cpp

@@ -0,0 +1,187 @@
+#include "sun.h"
+
+class Sun::JdTime
+{
+public:
+	static constexpr double JULIAN_OFFSET = 68.184 / 86400.0;
+	static constexpr double JULIAN_DATEATY2K = 2451544.500000;
+
+	double julianDate;
+	double daysSinceY2K;
+	double siderialUtcTime;
+	double localHour;
+	double utcHour;
+	int    day;
+	int    year;
+	
+	JdTime();
+	void update();
+	std::time_t toStdTime();
+	void fromStdTime(std::time_t time);
+};
+
+Sun::JdTime::JdTime()
+{
+	update();
+}
+
+void Sun::JdTime::update()
+{
+	std::time_t time = std::time(nullptr);
+	fromStdTime(time);
+}
+
+
+void Sun::JdTime::fromStdTime(std::time_t time)
+{
+    std::tm     ltime = *std::localtime( &time ); 
+	
+	localHour = ltime.tm_hour + ltime.tm_min/60.0 + ltime.tm_sec/3600.0;
+	utcHour = localHour - ltime.tm_gmtoff/3600.0;
+	day = ltime.tm_yday;
+	year = ltime.tm_year + 1900;
+	
+	std::tm millennium = {0,0,0,1,0,100};
+	std::time_t millenniumTime = std::mktime(&millennium) - timezone;
+	
+	daysSinceY2K = (time - millenniumTime)/(60*60*24.0);
+	//std::cout<<"days since y2k: "<<daysSinceY2K<<std::endl;
+	julianDate = daysSinceY2K + JULIAN_DATEATY2K - JULIAN_OFFSET;
+	//std::cout<<"julianDate: "<<julianDate<<std::endl;
+	
+	siderialUtcTime = 6.697374558 + 0.06570982441908 * (long)daysSinceY2K + 1.00273790935*utcHour;
+	while(siderialUtcTime < 0)  siderialUtcTime+=24;
+	siderialUtcTime = fmod(siderialUtcTime, 24);
+}
+
+std::time_t Sun::JdTime::toStdTime()
+{
+	std::tm millennium = {0,0,0,0,0,100};
+	std::time_t millenniumTime = std::mktime(&millennium)- timezone;
+	
+	millenniumTime = millenniumTime + (julianDate-JULIAN_DATEATY2K+JULIAN_OFFSET)*(24*60*60);
+	return millenniumTime;
+}
+
+Sun::Sun(double latitude, double longitude, double altitude): latitude_(latitude), longetude_(longitude), altitude_(altitude)
+{}
+
+double Sun::nextMeanSolarNoonJD(const JdTime& time)
+{
+	return (long)time.daysSinceY2K + 2451545.0 + 0.0009 - (longetude_ / 360);
+}
+
+double Sun::meanSolarAnomaly(double meanSolarNoon)
+{
+	return fmod(357.5291 + 0.98560028 *  (meanSolarNoon-2451545), 360);
+}
+
+double Sun::eqOfCenter(double meanSolarAnomaly)
+{
+	return 1.9148*sin(meanSolarAnomaly*TO_RADS) + 0.0200*sin(2*meanSolarAnomaly*TO_RADS) + 0.0003*sin(3*meanSolarAnomaly*TO_RADS);
+}
+
+double Sun::eclipticLongitude(double eqOfCenter, double meanSolarAnomaly)
+{
+	return fmod(meanSolarAnomaly + eqOfCenter + ARGUMENT_OF_PERIHELION + 180, 360); //hmmm
+}
+
+double Sun::equationOfTime(double meanSolarAnomaly, double eclipticLongitude) //wrong
+{
+	return (-7.659*sin(meanSolarAnomaly*TO_RADS)+9.863*sin(2*(meanSolarAnomaly+eclipticLongitude)*TO_RADS))/60;
+}
+
+double Sun::localSolarTime(const JdTime& time, double equationOfTime)
+{
+	return time.utcHour + equationOfTime + (4/60.0)*longetude_;
+}
+
+double Sun::solarDeclination(double eclipticLongitude)
+{
+	return TO_DEGS*asin(sin(eclipticLongitude*TO_RADS)*sin(PLANETARY_AXIAL_TILT*TO_RADS));
+}
+
+double Sun::hourAngle(double localSolarTime)
+{	
+	return 360/24 * (localSolarTime - 12);
+}
+
+double Sun::hourAngleAtSunset(double solarDeclination)
+{	
+	return TO_DEGS*acos((sin((-0.83-(2.076*sqrt(altitude_)/60.0))*TO_RADS) - sin(solarDeclination*TO_RADS)*sin(latitude_*TO_RADS))/(cos(latitude_*TO_RADS)*cos(solarDeclination*TO_RADS)));
+}
+
+double Sun::altitude()
+{
+	JdTime time;
+	double meanSolarNoonValue     = nextMeanSolarNoonJD(time);
+	double meanSolarAnomalyValue  = meanSolarAnomaly(meanSolarNoonValue);
+	double eclipticLongitudeValue = eclipticLongitude(eqOfCenter(meanSolarAnomalyValue), meanSolarAnomalyValue);
+	double localSolarTimeValue    = localSolarTime(time, equationOfTime(meanSolarAnomalyValue, eclipticLongitudeValue));
+	double declinationValue       = solarDeclination(eclipticLongitudeValue);
+	
+	double cosZenithAngle = sin(latitude_*TO_RADS)*sin(declinationValue*TO_RADS)+cos(latitude_*TO_RADS)*cos(declinationValue*TO_RADS)*cos(hourAngle(localSolarTimeValue)*TO_RADS);
+	
+	return TO_DEGS*asin(cosZenithAngle);
+}
+
+double Sun::maximumAltitude()
+{
+	JdTime time;
+	double meanSolarNoonValue     = nextMeanSolarNoonJD(time);
+	double meanSolarAnomalyValue  = meanSolarAnomaly(meanSolarNoonValue);
+	double eclipticLongitudeValue = eclipticLongitude(eqOfCenter(meanSolarAnomalyValue), meanSolarAnomalyValue);
+	double declinationValue       = solarDeclination(eclipticLongitudeValue);
+	
+	double cosZenithAngle = sin(latitude_*TO_RADS)*sin(declinationValue*TO_RADS)+cos(latitude_*TO_RADS)*cos(declinationValue*TO_RADS);
+	
+	return TO_DEGS*asin(cosZenithAngle);
+}
+
+double Sun::azimuth()
+{
+	return 0;
+}
+
+
+std::time_t Sun::riseTime()
+{
+	JdTime time;
+	double meanSolarNoonValue     = nextMeanSolarNoonJD(time);
+	double meanSolarAnomalyValue  = meanSolarAnomaly(meanSolarNoonValue);
+	double eclipticLongitudeValue = eclipticLongitude(eqOfCenter(meanSolarAnomalyValue), meanSolarAnomalyValue);
+	double declinationValue       = solarDeclination(eclipticLongitudeValue);
+	double hourAngleValue         = hourAngleAtSunset(declinationValue);
+	
+	time.julianDate = meanSolarNoonValue + equationOfTime(meanSolarAnomalyValue, eclipticLongitudeValue) - hourAngleValue/360.0;
+	
+	return time.toStdTime();
+}
+std::time_t Sun::setTime()
+{
+	JdTime time;
+	double meanSolarNoonValue     = nextMeanSolarNoonJD(time);
+	double meanSolarAnomalyValue  = meanSolarAnomaly(meanSolarNoonValue);
+	double eclipticLongitudeValue = eclipticLongitude(eqOfCenter(meanSolarAnomalyValue), meanSolarAnomalyValue);
+	double declinationValue       = solarDeclination(eclipticLongitudeValue);
+	double hourAngleValue         = hourAngleAtSunset(declinationValue);
+	
+	time.julianDate = meanSolarNoonValue + equationOfTime(meanSolarAnomalyValue, eclipticLongitudeValue) + hourAngleValue/360.0;
+	
+	return time.toStdTime();
+}
+
+
+double Sun::declination()
+{
+	JdTime time;
+	double meanSolarNoonValue     = nextMeanSolarNoonJD(time);
+	double meanSolarAnomalyValue  = meanSolarAnomaly(meanSolarNoonValue);
+	return solarDeclination(eclipticLongitude(eqOfCenter(meanSolarAnomalyValue), meanSolarAnomalyValue));
+}
+
+
+double maximumAltitude()
+{
+	return 0;
+}

src/sun.h

@@ -0,0 +1,56 @@
+// C++ program calculating the solar position for
+// the current date and a set location (latitude, longitude)
+// Jarmo Lammi 1999
+//
+// Code refreshed to work in the newer versions of C++
+// ComM_PIled and tested with
+// Apple LLVM version 6.0 (clang-600.0.56) (based on LLVM 3.5svn)
+// Target: x86_64-apple-darwin14.0.0
+// Jarmo Lammi 4-Jan-2015
+
+#include <iostream>
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include <ctime>
+
+class Sun
+{
+private:
+	
+    static constexpr double TO_DEGS = 180.0/M_PI;
+    static constexpr double TO_RADS = M_PI/180.0;
+    static constexpr double SUN_DIA = 0.53; //degrees
+    static constexpr double AIR_REFRACTION  = 34.0/60.0;
+	
+	static constexpr double ARGUMENT_OF_PERIHELION  = 102.9372;
+	static constexpr double PLANETARY_AXIAL_TILT  = 23.44;
+    
+    class JdTime;
+    
+    double latitude_;
+    double longetude_;
+	double altitude_;
+    
+private:
+	
+    double nextMeanSolarNoonJD(const JdTime& time);
+	double meanSolarAnomaly(double meanSolarNoon);
+	double eqOfCenter(double meanSolarAnomaly);
+	double eclipticLongitude(double eqOfCenter, double meanSolarAnomaly);
+	double solarTransit(double meanSolarNoon, double meanSolarAnomaly, double eclipticLongitude);
+	double solarDeclination(double eclipticLongitude);
+	double hourAngleAtSunset(double solarDeclination);
+	double hourAngle(double localSolarTime);
+	double equationOfTime(double meanSolarAnomaly, double eclipticLongitude);
+	double localSolarTime(const JdTime& time, double equationOfTime);
+	
+public:
+	
+    Sun(double latitude, double longitude, double altitude = 0);
+    double altitude();
+	double maximumAltitude();
+    double azimuth();
+	double declination();
+    std::time_t riseTime();
+    std::time_t setTime();
+};

src/suntest.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+#include "sun.h"
+
+#include <iomanip>
+
+int main()
+{
+	std::cout<<std::setprecision(15);
+    Sun sun(49.884450, 8.650536);
+	std::time_t time = sun.setTime();
+	tm setTime = *localtime(&time);
+	time = sun.riseTime();
+	tm riseTime = *localtime(&time);
+	std::cout<<"sunset: "<<setTime.tm_hour<<':'<<setTime.tm_min<<std::endl;
+	std::cout<<"riseTime: "<<riseTime.tm_hour<<':'<<riseTime.tm_min<<std::endl;
+	std::cout<<"current Alt: "<<sun.altitude()<<std::endl;
+	std::cout<<"maximum Alt: "<<sun.maximumAltitude()<<std::endl;
+	std::cout<<"declination: "<<sun.declination()<<std::endl;
+    return 0;
+}

src/ui/actorsettingsdialog.cpp

@@ -1,14 +1,98 @@
 #include "actorsettingsdialog.h"
 #include "ui_actorsettingsdialog.h"
+#include <QDebug>
+#include <QSpinBox>
 
-ActorSettingsDialog::ActorSettingsDialog(QWidget *parent) :
+ActorSettingsDialog::ActorSettingsDialog(AlarmTime* alarm, QWidget *parent):
     QDialog(parent),
+    actor_(alarm),
     ui(new Ui::ActorSettingsDialog)
+{
+    init();
+
+    widget = new AlarmWidget(alarm, this);
+    ui->vertlayout->addWidget(widget);
+}
+
+ActorSettingsDialog::ActorSettingsDialog(SensorActor* actor, SensorStore* sensors, QWidget *parent) :
+QDialog(parent),
+actor_(actor),
+ui(new Ui::ActorSettingsDialog)
+{
+    init();
+
+    widget = new SensorActorWidget(actor, sensors, this);
+    ui->vertlayout->addWidget(widget);
+}
+
+ActorSettingsDialog::ActorSettingsDialog(Regulator* actor, SensorStore* sensors, QWidget *parent) :
+    QDialog(parent),
+    actor_(actor),
+    ui(new Ui::ActorSettingsDialog)
+{
+    init();
+
+    widget = new RegulatorWdiget(actor, sensors, this);
+    ui->vertlayout->addWidget(widget);
+}
+
+ActorSettingsDialog::ActorSettingsDialog(TimerActor* actor, QWidget *parent) :
+QDialog(parent),
+actor_(actor),
+ui(new Ui::ActorSettingsDialog)
+{
+    init();
+
+    widget = new TimerActorWidget(actor, this);
+    ui->vertlayout->addWidget(widget);
+}
+
+
+ActorSettingsDialog::ActorSettingsDialog(Actor* actor, QWidget *parent) :
+QDialog(parent),
+actor_(actor),
+ui(new Ui::ActorSettingsDialog)
+{
+    init();
+}
+
+void ActorSettingsDialog::init()
 {
     ui->setupUi(this);
+    connect(ui->comboBox_action, SIGNAL(currentIndexChanged(int)), this, SLOT(changeAction(int)));
+    connect(ui->spinBox,  SIGNAL(valueChanged(int)), this, SLOT(valueChanged(int)));
+    ui->spinBox->hide();
+
+    ui->spinBox->setValue(actor_->getTriggerValue());
+    if(actor_->getTriggerValue() == 0) ui->comboBox_action->setCurrentIndex(0);
+    else if(actor_->getTriggerValue() == 1) ui->comboBox_action->setCurrentIndex(1);
+    else ui->comboBox_action->setCurrentIndex(2);
 }
 
 ActorSettingsDialog::~ActorSettingsDialog()
 {
     delete ui;
 }
+
+void ActorSettingsDialog::valueChanged(int value)
+{
+    actor_->setTriggerValue(value);
+}
+
+void ActorSettingsDialog::hideCancle(const bool hide)
+{
+
+}
+
+void ActorSettingsDialog::changeAction(int index)
+{
+         if(index == 0) actor_->setTriggerValue(0);
+    else if(index == 1) actor_->setTriggerValue(1);
+    else if(index == 2)
+    {
+             ui->spinBox->show();
+             actor_->setTriggerValue(ui->spinBox->value());
+    }
+    if(index != 2)ui->spinBox->hide();
+}
+

src/ui/actorsettingsdialog.h

@@ -2,6 +2,11 @@
 #define ACTORSETTINGSDIALOG_H
 
 #include <QDialog>
+#include <QWidget>
+#include "actorwidgets/alarmwidget.h"
+#include "actorwidgets/sensoractorwidget.h"
+#include "actorwidgets/timeractorwidget.h"
+#include "actorwidgets/regulatorwdiget.h"
 
 namespace Ui {
 class ActorSettingsDialog;
@@ -11,10 +16,27 @@ class ActorSettingsDialog : public QDialog
 {
     Q_OBJECT
 
+private:
+    Actor* actor_;
+    QWidget* widget;
+
+    void init();
+
 public:
-    explicit ActorSettingsDialog(QWidget *parent = nullptr);
+    ActorSettingsDialog(AlarmTime* actor, QWidget *parent = nullptr);
+    ActorSettingsDialog(SensorActor* actor, SensorStore* sensors = nullptr, QWidget *parent = nullptr);
+    ActorSettingsDialog(Regulator* actor, SensorStore* sensors = nullptr, QWidget *parent = nullptr);
+    ActorSettingsDialog(TimerActor* actor, QWidget *parent);
+    ActorSettingsDialog(Actor* actor, QWidget *parent);
     ~ActorSettingsDialog();
 
+    void hideCancle(const bool hide);
+
+private slots:
+    void changeAction(int index);
+    void valueChanged(int value);
+
+
 private:
     Ui::ActorSettingsDialog *ui;
 };

src/ui/actorsettingsdialog.ui

@@ -11,7 +11,11 @@
    </rect>
   </property>
   <property name="windowTitle">
-   <string>Dialog</string>
+   <string>Actor Settings</string>
+  </property>
+  <property name="windowIcon">
+   <iconset resource="../../resources.qrc">
+    <normaloff>:/images/UVOSicon.bmp</normaloff>:/images/UVOSicon.bmp</iconset>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
@@ -33,11 +37,6 @@
        </item>
        <item>
         <widget class="QComboBox" name="comboBox_action">
-         <item>
-          <property name="text">
-           <string>On</string>
-          </property>
-         </item>
          <item>
           <property name="text">
            <string>Off</string>
@@ -45,9 +44,21 @@
          </item>
          <item>
           <property name="text">
-           <string>Toggle</string>
+           <string>On</string>
           </property>
          </item>
+         <item>
+          <property name="text">
+           <string>Value</string>
+          </property>
+         </item>
+        </widget>
+       </item>
+       <item>
+        <widget class="QSpinBox" name="spinBox">
+         <property name="maximum">
+          <number>255</number>
+         </property>
         </widget>
        </item>
       </layout>
@@ -66,7 +77,9 @@
    </item>
   </layout>
  </widget>
- <resources/>
+ <resources>
+  <include location="../../resources.qrc"/>
+ </resources>
  <connections>
   <connection>
    <sender>buttonBox</sender>

src/ui/actorwidgets/alarmwidget.cpp

@@ -0,0 +1,73 @@
+#include "alarmwidget.h"
+#include "ui_alarmwidget.h"
+
+AlarmWidget::AlarmWidget(AlarmTime* alarm, QWidget *parent) :
+    QWidget(parent),
+    alarm_(alarm),
+    ui(new Ui::AlarmWidget)
+{
+    ui->setupUi(this);
+    connect(ui->checkBox, &QCheckBox::stateChanged, this, &AlarmWidget::toggleRepeating);
+    connect(ui->radioButton, &QRadioButton::clicked, this, &AlarmWidget::setRepeatingType);
+    connect(ui->radioButton_2, &QRadioButton::clicked, this, &AlarmWidget::setRepeatingType);
+    connect(ui->radioButton_3, &QRadioButton::clicked, this, &AlarmWidget::setRepeatingType);
+    connect(ui->radioButton_4, &QRadioButton::clicked, this, &AlarmWidget::setRepeatingType);
+
+    ui->dateTimeEdit->setDateTime(alarm->getDateTime());
+
+    if(alarm_->getRepeat() == AlarmTime::REPEAT_NEVER)
+    {
+        ui->radioButton->setEnabled(false);
+        ui->radioButton_2->setEnabled(false);
+        ui->radioButton_3->setEnabled(false);
+        ui->radioButton_4->setEnabled(false);
+    }
+    else
+    {
+        ui->radioButton->setEnabled(true);
+        ui->radioButton_2->setEnabled(true);
+        ui->radioButton_3->setEnabled(true);
+        ui->radioButton_4->setEnabled(true);
+    }
+
+    if(alarm_->getRepeat() == AlarmTime::REPEAT_DAILY) ui->radioButton->setChecked(true);
+    else if(alarm_->getRepeat() == AlarmTime::REPEAT_WEEKLY) ui->radioButton_2->setChecked(true);
+    else if(alarm_->getRepeat() == AlarmTime::REPEAT_MONTHLY)ui->radioButton_3->setChecked(true);
+    else if(alarm_->getRepeat() == AlarmTime::REPEAT_YEARLY) ui->radioButton_4->setChecked(true);
+
+    connect(ui->dateTimeEdit, &QDateTimeEdit::dateTimeChanged, alarm, &AlarmTime::changeTime);
+}
+
+AlarmWidget::~AlarmWidget()
+{
+    delete ui;
+}
+
+void AlarmWidget::setRepeatingType()
+{
+    if(ui->radioButton->isChecked())alarm_->setRepeat(AlarmTime::REPEAT_DAILY);
+    if(ui->radioButton_2->isChecked())alarm_->setRepeat(AlarmTime::REPEAT_WEEKLY);
+    if(ui->radioButton_3->isChecked())alarm_->setRepeat(AlarmTime::REPEAT_MONTHLY);
+    if(ui->radioButton_4->isChecked())alarm_->setRepeat(AlarmTime::REPEAT_YEARLY);
+}
+
+void AlarmWidget::toggleRepeating(int state)
+{
+    if(state)
+    {
+        ui->radioButton->setEnabled(true);
+        ui->radioButton_2->setEnabled(true);
+        ui->radioButton_3->setEnabled(true);
+        ui->radioButton_4->setEnabled(true);
+        setRepeatingType();
+    }
+    else
+    {
+        alarm_->setRepeat(AlarmTime::REPEAT_NEVER);
+        ui->radioButton->setEnabled(false);
+        ui->radioButton_2->setEnabled(false);
+        ui->radioButton_3->setEnabled(false);
+        ui->radioButton_4->setEnabled(false);
+    }
+}
+

src/ui/actorwidgets/alarmwidget.h

@@ -2,6 +2,7 @@
 #define ALARMWIDGET_H
 
 #include <QWidget>
+#include "../../actors/alarmtime.h"
 
 namespace Ui {
 class AlarmWidget;
@@ -11,10 +12,16 @@ class AlarmWidget : public QWidget
 {
     Q_OBJECT
 
+    AlarmTime* alarm_;
+
 public:
-    explicit AlarmWidget(QWidget *parent = nullptr);
+    explicit AlarmWidget(AlarmTime* alarm, QWidget *parent = nullptr);
     ~AlarmWidget();
 
+private slots:
+    void toggleRepeating(int state);
+        void setRepeatingType();
+
 private:
     Ui::AlarmWidget *ui;
 };

src/ui/actorwidgets/alarmwidget.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>357</width>
-    <height>166</height>
+    <height>208</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -60,7 +60,7 @@
       <enum>QDateTimeEdit::DaySection</enum>
      </property>
      <property name="displayFormat">
-      <string>dd.mM.yyyy hh:mm</string>
+      <string>dd.MM.yyyy hh:mm</string>
      </property>
      <property name="calendarPopup">
       <bool>true</bool>
@@ -90,7 +90,7 @@
       <bool>false</bool>
      </property>
      <property name="text">
-      <string>Monthly</string>
+      <string>&amp;Monthly</string>
      </property>
     </widget>
    </item>

src/ui/actorwidgets/regulatorwdiget.cpp

@@ -0,0 +1,48 @@
+#include "regulatorwdiget.h"
+#include "ui_regulatorwdiget.h"
+#include <QDebug>
+
+RegulatorWdiget::~RegulatorWdiget()
+{
+    delete ui;
+}
+
+
+
+RegulatorWdiget::RegulatorWdiget(Regulator* regulator, SensorStore* sensors, QWidget *parent) :
+    QWidget(parent),
+    regulator_(regulator),
+    sensors_(sensors),
+    ui(new Ui::RegulatorWdiget)
+{
+    ui->setupUi(this);
+    if(sensors)ui->listView->sensorsChanged(*(sensors->getSensors()));
+    else
+    {
+        ui->listView->hide();
+        ui->label->hide();
+    }
+    ui->doubleSpinBox_setPoint->setValue(regulator->getSetPoint());
+    ui->doubleSpinBox_band->setValue(regulator->getBand());
+
+    connect(ui->listView, &SensorListWidget::clicked, this, &RegulatorWdiget::setSensor);
+    connect(ui->doubleSpinBox_setPoint, SIGNAL(valueChanged(double)),  this, SLOT(setPoint(double)));
+    connect(ui->doubleSpinBox_band, SIGNAL(valueChanged(double)), this, SLOT(setBand(double)));
+}
+
+void RegulatorWdiget::setPoint(double in)
+{
+    regulator_->setPoint(in);
+}
+
+void RegulatorWdiget::setBand(double band)
+{
+    regulator_->setBand(band);
+}
+
+void RegulatorWdiget::setSensor(const QModelIndex &index)
+{
+    regulator_->setSensor(sensors_->getSensors()->at(index.row()));
+    setPoint(sensors_->getSensors()->at(index.row()).field);
+    ui->doubleSpinBox_setPoint->setValue(sensors_->getSensors()->at(index.row()).field);
+}

src/ui/actorwidgets/regulatorwdiget.h

@@ -0,0 +1,32 @@
+#ifndef REGULATORWDIGET_H
+#define REGULATORWDIGET_H
+
+#include <QWidget>
+#include "../../actors/regulator.h"
+
+namespace Ui {
+class RegulatorWdiget;
+}
+
+class RegulatorWdiget : public QWidget
+{
+    Q_OBJECT
+
+    Regulator* regulator_;
+    SensorStore* sensors_;
+
+public:
+    explicit RegulatorWdiget(Regulator* regulator, SensorStore* sensors = nullptr, QWidget *parent = nullptr);
+    ~RegulatorWdiget();
+
+private slots:
+
+    void setPoint(double in);
+    void setBand(double band);
+    void setSensor(const QModelIndex &index);
+
+private:
+    Ui::RegulatorWdiget *ui;
+};
+
+#endif // REGULATORWDIGET_H

src/ui/actorwidgets/regulatorwdiget.ui

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RegulatorWdiget</class>
+ <widget class="QWidget" name="RegulatorWdiget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>500</width>
+    <height>326</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QLabel" name="label">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text">
+      <string>Select Sensor</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="SensorListWidget" name="listView">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QLabel" name="label_3">
+       <property name="text">
+        <string>Set Point</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QDoubleSpinBox" name="doubleSpinBox_setPoint">
+       <property name="minimum">
+        <double>-9999.989999999999782</double>
+       </property>
+       <property name="maximum">
+        <double>9999.989999999999782</double>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="label_2">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>Band</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QDoubleSpinBox" name="doubleSpinBox_band"/>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>SensorListWidget</class>
+   <extends>QListView</extends>
+   <header location="global">../src/ui/sensorlistwidget.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

src/ui/actorwidgets/sensoractorwidget.cpp

@@ -0,0 +1,52 @@
+#include "sensoractorwidget.h"
+#include "ui_sensoractorwidget.h"
+
+#include <QDebug>
+
+SensorActorWidget::SensorActorWidget(SensorActor* sensorActor, SensorStore* sensors, QWidget *parent) :
+    QWidget(parent),
+    sensorActor_(sensorActor),
+    sensors_(sensors),
+    ui(new Ui::SensorActorWidget)
+{
+    ui->setupUi(this);
+    if(sensors)ui->listView->sensorsChanged(*(sensors->getSensors()));
+    else
+    {
+        ui->listView->hide();
+        ui->label->hide();
+    }
+
+    if(sensorActor_->getSloap() == SensorActor::SLOPE_UP) ui->comboBox_slope->setCurrentIndex(0);
+    else if(sensorActor_->getSloap() == SensorActor::SLOPE_DOWN) ui->comboBox_slope->setCurrentIndex(1);
+    else if(sensorActor_->getSloap() == SensorActor::SLOPE_BOTH) ui->comboBox_slope->setCurrentIndex(2);
+
+    ui->doubleSpinBox_threshold->setValue(sensorActor_->getThreshold());
+
+    connect(ui->listView, &SensorListWidget::clicked, this, &SensorActorWidget::setSensor);
+    connect(ui->doubleSpinBox_threshold, SIGNAL(valueChanged(double)),  this, SLOT(setThreshold(double)));
+    connect(ui->comboBox_slope, SIGNAL(currentIndexChanged(int)), this, SLOT(setSlope(int)));
+}
+
+SensorActorWidget::~SensorActorWidget()
+{
+    delete ui;
+}
+
+void SensorActorWidget::setThreshold(double in)
+{
+    sensorActor_->setThreshold(in);
+}
+
+void SensorActorWidget::setSlope(int index)
+{
+    if(index == 0) sensorActor_->setSloap(SensorActor::SLOPE_UP);
+    else if(index == 1) sensorActor_->setSloap(SensorActor::SLOPE_DOWN);
+    else if(index == 2) sensorActor_->setSloap(SensorActor::SLOPE_BOTH);
+}
+
+void SensorActorWidget::setSensor(const QModelIndex &index)
+{
+    sensorActor_->setSensor(sensors_->getSensors()->at(index.row()));
+    qDebug()<<"Selected "<<sensors_->getSensors()->at(index.row()).name;
+}

src/ui/actorwidgets/sensoractorwidget.h

@@ -0,0 +1,33 @@
+#ifndef SENSORACTORWIDGET_H
+#define SENSORACTORWIDGET_H
+
+#include <QWidget>
+#include <QItemSelection>
+#include "../../actors/sensoractor.h"
+
+namespace Ui {
+class SensorActorWidget;
+}
+
+class SensorActorWidget : public QWidget
+{
+    Q_OBJECT
+
+    SensorActor* sensorActor_;
+    SensorStore* sensors_;
+
+public:
+    explicit SensorActorWidget(SensorActor* sensorActor, SensorStore* sensors = nullptr, QWidget *parent = nullptr);
+    ~SensorActorWidget();
+
+private slots:
+
+    void setThreshold(double in);
+    void setSlope(int index);
+    void setSensor(const QModelIndex &index);
+
+private:
+    Ui::SensorActorWidget *ui;
+};
+
+#endif // SENSORACTORWIDGET_H

src/ui/actorwidgets/sensoractorwidget.ui

@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>SensorActorWidget</class>
+ <widget class="QWidget" name="SensorActorWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>500</width>
+    <height>326</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QLabel" name="label">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text">
+      <string>Select Sensor</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="SensorListWidget" name="listView">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QLabel" name="label_3">
+       <property name="text">
+        <string>Threshold</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QComboBox" name="comboBox_slope">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <item>
+        <property name="text">
+         <string>&gt; =</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>&lt; =</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Passes</string>
+        </property>
+       </item>
+      </widget>
+     </item>
+     <item>
+      <widget class="QDoubleSpinBox" name="doubleSpinBox_threshold">
+       <property name="minimum">
+        <double>-9999.989999999999782</double>
+       </property>
+       <property name="maximum">
+        <double>9999.989999999999782</double>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>SensorListWidget</class>
+   <extends>QListView</extends>
+   <header location="global">../src/ui/sensorlistwidget.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

src/ui/actorwidgets/timeractorwidget.cpp

@@ -0,0 +1,20 @@
+#include "timeractorwidget.h"
+#include "ui_timeractorwidget.h"
+
+#include <QSpinBox>
+
+TimerActorWidget::TimerActorWidget(TimerActor* actor, QWidget *parent) :
+    QWidget(parent),
+    ui(new Ui::TimerActorWidget)
+{
+    ui->setupUi(this);
+
+    ui->spinBox->setValue(actor->getTimeout());
+
+    connect(ui->spinBox, SIGNAL(valueChanged(int)), actor, SLOT(setTimeout(int)));
+}
+
+TimerActorWidget::~TimerActorWidget()
+{
+    delete ui;
+}

src/ui/actorwidgets/timeractorwidget.h

@@ -0,0 +1,23 @@
+#ifndef TIMERACTORWIDGET_H
+#define TIMERACTORWIDGET_H
+
+#include <QWidget>
+#include "../../actors/timeractor.h"
+
+namespace Ui {
+class TimerActorWidget;
+}
+
+class TimerActorWidget : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit TimerActorWidget(TimerActor* actor, QWidget *parent = nullptr);
+    ~TimerActorWidget();
+
+private:
+    Ui::TimerActorWidget *ui;
+};
+
+#endif // TIMERACTORWIDGET_H

src/ui/actorwidgets/timeractorwidget.ui

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>TimerActorWidget</class>
+ <widget class="QWidget" name="TimerActorWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>50</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QHBoxLayout" name="horizontalLayout">
+   <item>
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>Timeout</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QSpinBox" name="spinBox">
+     <property name="maximum">
+      <number>999999</number>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QLabel" name="label_2">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text">
+      <string>Seconds</string>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

src/ui/alarmsettingsdialog.cpp

@@ -1,50 +0,0 @@
-#include "alarmsettingsdialog.h"
-#include "ui_alarmsettingsdialog.h"
-
-#include <QFileDialog>
-
-AlarmSettingsDialog::AlarmSettingsDialog(AlarmTime* almNight, AlarmTime* almAlarm, QSettings* settings, QWidget *parent): QDialog(parent), ui(new Ui::AlarmSettingsDialog), almNight_(almNight), almAlarm_(almAlarm), settings_(settings)
-{
-    ui->setupUi(this);
-
-    //restore settings
-    ui->checkBox_Alarm->setChecked(settings_->value("Alarms/alarmOn").toBool());
-    ui->checkBox_Sunrise->setChecked(settings_->value("Alarms/sunrise").toBool());
-    ui->timeEdit_Shutdown->setTime(settings_->value("Alarms/shutdownTime").toTime());
-    ui->timeEdit_Alarm->setTime(settings_->value("Alarms/alarmTime").toTime());
-    ui->lineEdit->setText(settings_->value("Alarms/alarmSoundFile").toString());
-
-    connect(ui->pushButton_changeFile, SIGNAL(clicked()), this, SLOT(showFileChooser()));
-}
-
-AlarmSettingsDialog::~AlarmSettingsDialog()
-{
-    delete ui;
-}
-
-void AlarmSettingsDialog::accept()
-{
-    //store settings
-    settings_->setValue("Alarms/alarmOn", ui->checkBox_Alarm->checkState());
-    settings_->setValue("Alarms/sunrise", ui->checkBox_Sunrise->checkState());
-    settings_->setValue("Alarms/shutdownTime", ui->timeEdit_Shutdown->time());
-    settings_->setValue("Alarms/alarmTime", ui->timeEdit_Alarm->time());
-    settings_->setValue("Alarms/alarmSoundFile", ui->lineEdit->text());
-
-    //send signals
-    signalAlarmSoundFile(ui->lineEdit->text());
-    signalSunrise(ui->checkBox_Sunrise->checkState());
-
-    //modify alarm objects
-    almAlarm_->changeTime(ui->timeEdit_Alarm->time());
-    almNight_->changeTime(ui->timeEdit_Shutdown->time());
-
-    QDialog::accept();
-}
-
-void AlarmSettingsDialog::showFileChooser()
-{
-    ui->lineEdit->setText(QFileDialog::getOpenFileName(this));
-}
-
-

src/ui/alarmsettingsdialog.h

@@ -1,43 +0,0 @@
-#ifndef ALARMSETTINGSDIALOG_H
-#define ALARMSETTINGSDIALOG_H
-
-#include <QDialog>
-#include <QTime>
-#include <QString>
-#include <QSettings>
-
-#include "alarmtime.h"
-
-namespace Ui {
-class AlarmSettingsDialog;
-}
-
-class AlarmSettingsDialog : public QDialog
-{
-    Q_OBJECT
-
-    AlarmTime* almNight_;
-    AlarmTime* almAlarm_;
-    QSettings* settings_;
-
-
-public:
-    explicit AlarmSettingsDialog(AlarmTime* almNight, AlarmTime* almAlarm, QSettings* settings, QWidget* parent = nullptr);
-    ~AlarmSettingsDialog();
-
-signals:
-    void signalAlarmSoundFile(QString fileName);
-    void signalSunrise(bool enabled);
-
-public slots:
-    void accept();
-
-private slots:
-    void showFileChooser();
-
-
-private:
-    Ui::AlarmSettingsDialog *ui;
-};
-
-#endif // ALARMSETTINGSDIALOG_H

src/ui/alarmsettingsdialog.ui

@@ -1,241 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>AlarmSettingsDialog</class>
- <widget class="QDialog" name="AlarmSettingsDialog">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>462</width>
-    <height>406</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Dialog</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <widget class="QGroupBox" name="groupBox">
-     <property name="title">
-      <string>Alarm</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_2">
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_alm">
-        <item>
-         <widget class="QLabel" name="label_3">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="text">
-           <string>Time</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QTimeEdit" name="timeEdit_Alarm">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="checkBox_Alarm">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="text">
-           <string>Enable</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_snd">
-        <property name="leftMargin">
-         <number>0</number>
-        </property>
-        <property name="topMargin">
-         <number>0</number>
-        </property>
-        <item>
-         <widget class="QLabel" name="label">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="text">
-           <string>Sound File</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QLineEdit" name="lineEdit">
-          <property name="enabled">
-           <bool>true</bool>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QPushButton" name="pushButton_changeFile">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="text">
-           <string>Change</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_2">
-        <property name="topMargin">
-         <number>0</number>
-        </property>
-        <item>
-         <widget class="QLabel" name="label_2">
-          <property name="text">
-           <string>Sunrise</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <spacer name="horizontalSpacer">
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>40</width>
-            <height>20</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="checkBox_Sunrise">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="text">
-           <string>Enable</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <widget class="QGroupBox" name="groupBox_2">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="title">
-      <string>Auto Power off</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_3">
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_4">
-        <item>
-         <widget class="QLabel" name="label_4">
-          <property name="text">
-           <string>Time</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QTimeEdit" name="timeEdit_Shutdown"/>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="checkBox_Shutdown">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="text">
-           <string>Enable</string>
-          </property>
-          <property name="checked">
-           <bool>true</bool>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <widget class="QDialogButtonBox" name="buttonBox">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="standardButtons">
-      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
-     </property>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>accepted()</signal>
-   <receiver>AlarmSettingsDialog</receiver>
-   <slot>accept()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>248</x>
-     <y>254</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>157</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>rejected()</signal>
-   <receiver>AlarmSettingsDialog</receiver>
-   <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>316</x>
-     <y>260</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>286</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
-</ui>

src/ui/alarmsettingsdialog_LOCAL_22257.ui

@@ -1,142 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>AlarmSettingsDialog</class>
- <widget class="QDialog" name="AlarmSettingsDialog">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>423</width>
-    <height>281</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Dialog</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <widget class="QLabel" name="label">
-     <property name="text">
-      <string>Sound File:</string>
-     </property>
-    </widget>
-   </item>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout">
-     <property name="leftMargin">
-      <number>0</number>
-     </property>
-     <property name="topMargin">
-      <number>0</number>
-     </property>
-     <item>
-      <widget class="QLineEdit" name="lineEdit">
-       <property name="enabled">
-        <bool>false</bool>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QPushButton" name="pushButton">
-       <property name="text">
-        <string>Change</string>
-       </property>
-      </widget>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout_2">
-     <property name="topMargin">
-      <number>0</number>
-     </property>
-     <item>
-      <widget class="QLabel" name="label_2">
-       <property name="text">
-        <string>Sunrise</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <spacer name="horizontalSpacer">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item>
-      <widget class="QCheckBox" name="checkBox">
-       <property name="text">
-        <string>Enable</string>
-       </property>
-      </widget>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <spacer name="verticalSpacer">
-     <property name="orientation">
-      <enum>Qt::Vertical</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>20</width>
-       <height>40</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-   <item>
-    <widget class="QDialogButtonBox" name="buttonBox">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="standardButtons">
-      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
-     </property>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>accepted()</signal>
-   <receiver>AlarmSettingsDialog</receiver>
-   <slot>accept()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>248</x>
-     <y>254</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>157</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>rejected()</signal>
-   <receiver>AlarmSettingsDialog</receiver>
-   <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>316</x>
-     <y>260</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>286</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
-</ui>

src/ui/alarmsettingsdialog_REMOTE_22257.ui

@@ -1,71 +0,0 @@
-<ui version="4.0">
- <author/>
- <comment/>
- <exportmacro/>
- <class>AlarmSettingsDialog</class>
- <widget name="AlarmSettingsDialog" class="QDialog">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>400</width>
-    <height>300</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Dialog</string>
-  </property>
-  <widget name="buttonBox" class="QDialogButtonBox">
-   <property name="geometry">
-    <rect>
-     <x>30</x>
-     <y>240</y>
-     <width>341</width>
-     <height>32</height>
-    </rect>
-   </property>
-   <property name="orientation">
-    <enum>Qt::Horizontal</enum>
-   </property>
-   <property name="standardButtons">
-    <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
-   </property>
-  </widget>
- </widget>
- <pixmapfunction/>
- <resources/>
- <connections>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>accepted()</signal>
-   <receiver>AlarmSettingsDialog</receiver>
-   <slot>accept()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>248</x>
-     <y>254</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>157</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>rejected()</signal>
-   <receiver>AlarmSettingsDialog</receiver>
-   <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>316</x>
-     <y>260</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>286</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
-</ui>

src/ui/alarmwidget.cpp

@@ -1,14 +0,0 @@
-#include "alarmwidget.h"
-#include "ui_alarmwidget.h"
-
-AlarmWidget::AlarmWidget(QWidget *parent) :
-    QWidget(parent),
-    ui(new Ui::AlarmWidget)
-{
-    ui->setupUi(this);
-}
-
-AlarmWidget::~AlarmWidget()
-{
-    delete ui;
-}

src/ui/itemscrollbox.cpp

@@ -0,0 +1,48 @@
+#include "itemscrollbox.h"
+#include "ui_relayscrollbox.h"
+#include "../items/auxitem.h"
+
+ItemScrollBox::ItemScrollBox(QWidget *parent) :
+    QWidget(parent),
+    ui(new Ui::RelayScrollBox)
+{
+    ui->setupUi(this);
+    QScroller::grabGesture(ui->scrollArea, QScroller::TouchGesture);
+    QScroller::grabGesture(ui->scrollArea, QScroller::LeftMouseButtonGesture);
+}
+
+ItemScrollBox::~ItemScrollBox()
+{
+    delete ui;
+}
+
+void ItemScrollBox::addItem(std::weak_ptr<Item> item)
+{
+    if(auto workItem  = item.lock())
+    {
+        if(dynamic_cast<AuxItem*>(workItem.get()))
+        {
+            widgets_.push_back(new ItemWidget(item, true));
+        }
+        else
+        {
+            widgets_.push_back(new ItemWidget(item));
+        }
+        ui->relayWidgetVbox->addWidget(widgets_.back());
+    }
+}
+
+void ItemScrollBox::removeItem(const ItemData& item)
+{
+    for(unsigned i = 0; i < widgets_.size(); i++)
+    {
+        if(widgets_[i]->controles(item))
+        {
+            ui->relayWidgetVbox->removeWidget(widgets_[i]);
+            delete widgets_[i];
+            widgets_.erase(widgets_.begin()+i);
+        }
+    }
+}
+
+

src/ui/itemscrollbox.h

@@ -0,0 +1,41 @@
+#ifndef RELAYSCROLLBOX_H
+#define RELAYSCROLLBOX_H
+
+#include <QWidget>
+#include <vector>
+#include <memory>
+#include <QScroller>
+#include "itemwidget.h"
+#include "../items/relay.h"
+#include "../items/item.h"
+#include "../items/itemstore.h"
+
+
+namespace Ui {
+class RelayScrollBox;
+}
+
+class ItemScrollBox : public QWidget
+{
+    Q_OBJECT
+private:
+    std::vector< ItemWidget* > widgets_;
+
+public:
+    explicit ItemScrollBox(QWidget *parent = nullptr);
+    ~ItemScrollBox();
+
+    void setItemStore(ItemStore* itemStore);
+
+public slots:
+
+    void addItem(std::weak_ptr<Item> item);
+    void removeItem(const ItemData& item);
+
+private:
+    Ui::RelayScrollBox *ui;
+};
+
+#endif // RELAYSCROLLBOX_H
+
+

src/ui/itemsettingsdialog.cpp

@@ -0,0 +1,148 @@
+ #include "itemsettingsdialog.h"
+#include "ui_itemsettingsdialog.h"
+#include "actorsettingsdialog.h"
+#include "../actors/alarmtime.h"
+#include "../actors/sensoractor.h"
+#include "../actors/timeractor.h"
+#include "../actors/regulator.h"
+
+#include<memory>
+
+ItemSettingsDialog::ItemSettingsDialog(Item* item, QWidget *parent) :
+    QDialog(parent),
+    item_(item),
+    ui(new Ui::ItemSettingsDialog)
+{
+    ui->setupUi(this);
+
+    setModal(false);
+
+    ui->label_name->setText(item_->getName());
+
+    if(Relay* relay = dynamic_cast<Relay*>(item_))
+    {
+        ui->label_address->setText(QString::number(relay->getAddress(), 2));
+        ui->label_id->setText(QString::number(relay->getId(), 10));
+    }
+    else
+    {
+        ui->label_address->hide();
+        ui->label_id->hide();
+        ui->label_address_lable->hide();
+        ui->label_id_lable->hide();
+    }
+    ui->checkBox_auto->setChecked(item_->actorsActive());
+
+    connect(ui->checkBox_auto, &QCheckBox::toggled, item_, &Relay::setActorsActive);
+    connect(ui->pushButton_add, &QPushButton::clicked, this, &ItemSettingsDialog::addActor);
+    connect(ui->pushButton_remove, &QPushButton::clicked, this, &ItemSettingsDialog::removeActor);
+    connect(ui->pushButton_edit, &QPushButton::clicked, this, &ItemSettingsDialog::editActor);
+
+     ui->tableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem("Actor"));
+     ui->tableWidget->setHorizontalHeaderItem(1, new QTableWidgetItem("Action"));
+     ui->tableWidget->setHorizontalHeaderItem(2, new QTableWidgetItem("Acts on"));
+     ui->tableWidget->setHorizontalHeaderItem(3, new QTableWidgetItem("Enabled"));
+     ui->tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
+     ui->tableWidget->horizontalHeader()->resizeSection(1, 60);
+     ui->tableWidget->horizontalHeader()->resizeSection(2, 60);
+     ui->tableWidget->horizontalHeader()->resizeSection(3, 75);
+    loadActorList();
+}
+
+ItemSettingsDialog::~ItemSettingsDialog()
+{
+    delete ui;
+}
+
+void ItemSettingsDialog::loadActorList()
+{
+    //ui->listWidget->clear();
+    ui->tableWidget->setRowCount(item_->getActors().size());
+
+    for(unsigned i = 0; i < item_->getActors().size(); i++)
+    {
+        ui->tableWidget->setItem(i, 0, new QTableWidgetItem(item_->getActors()[i]->getName()));
+        ui->tableWidget->setItem(i, 1, new QTableWidgetItem(item_->getActors()[i]->actionName()));
+        ui->tableWidget->setItem(i, 2, new QTableWidgetItem("Item"));
+        ui->tableWidget->setItem(i, 3, new QTableWidgetItem(item_->getActors()[i]->isActive() ? "Y" : "N"));
+    }
+}
+
+void ItemSettingsDialog::addActor()
+{
+    ActorSettingsDialog* dialog = nullptr;
+    Actor* actor = nullptr;
+
+    if(ui->comboBox->currentText() == "Alarm")
+    {
+        AlarmTime* alarm = new AlarmTime;
+        actor = alarm;
+        dialog = new ActorSettingsDialog(alarm, this);
+    }
+    else if(ui->comboBox->currentText() == "Sensor" &&  item_->getSensorStore() != nullptr)
+    {
+        SensorActor* sensorActor = new SensorActor();
+        actor = sensorActor;
+        dialog = new ActorSettingsDialog(sensorActor, item_->getSensorStore(), this);
+    }
+    else if(ui->comboBox->currentText() == "Timer" )
+    {
+        TimerActor* timerActor = new TimerActor();
+        actor = timerActor;
+        dialog = new ActorSettingsDialog(timerActor, this);
+    }
+    else if(ui->comboBox->currentText() == "Regulator" &&  item_->getSensorStore() != nullptr)
+    {
+        Regulator* regulator = new Regulator();
+        actor = regulator;
+        dialog = new ActorSettingsDialog(regulator, item_->getSensorStore(), this);
+    }
+
+
+    if(dialog != nullptr)
+    {
+        dialog->setParent(this);
+        dialog->show();
+        if(dialog->exec() == QDialog::Accepted)
+        {
+            item_->addActor(actor);
+            loadActorList();
+        }
+        else delete actor;
+        delete dialog;
+    }
+
+}
+
+void ItemSettingsDialog::removeActor()
+{
+    if(item_->getActors().size() > ui->tableWidget->currentRow())
+    {
+       item_->removeActor(item_->getActors().at(ui->tableWidget->currentRow()));
+       loadActorList();
+    }
+}
+
+void ItemSettingsDialog::editActor()
+{
+    if(item_->getActors().size() > ui->tableWidget->currentRow())
+    {
+        Actor* actor = item_->getActors()[ui->tableWidget->currentRow()];
+
+        AlarmTime* alarmTime = dynamic_cast<AlarmTime*>(actor);
+        Regulator* regulator = dynamic_cast<Regulator*>(actor);
+        SensorActor* sensorActor = dynamic_cast<SensorActor*>(actor);
+        TimerActor* timerActor = dynamic_cast<TimerActor*>(actor);
+
+        ActorSettingsDialog* dialog;
+
+        if(alarmTime) dialog = new ActorSettingsDialog(alarmTime, this);
+        else if(regulator)  dialog = new ActorSettingsDialog(regulator, nullptr, this);
+        else if(sensorActor) dialog = new ActorSettingsDialog(sensorActor, nullptr, this);
+        else if(timerActor) dialog = new ActorSettingsDialog(timerActor, this);
+        else dialog = new ActorSettingsDialog(actor, this);
+        dialog->setParent(this);
+        dialog->show();
+        dialog->exec();
+    }
+}

src/ui/itemsettingsdialog.h

@@ -0,0 +1,34 @@
+#ifndef RELAYSETTINGSDIALOG_H
+#define RELAYSETTINGSDIALOG_H
+
+#include <QDialog>
+#include <QSettings>
+#include "../items/relay.h"
+
+namespace Ui {
+class ItemSettingsDialog;
+}
+
+class ItemSettingsDialog : public QDialog
+{
+    Q_OBJECT
+    Item* item_;
+
+private:
+    void loadActorList();
+
+public:
+    explicit ItemSettingsDialog(Item* item, QWidget *parent = nullptr);
+    ~ItemSettingsDialog();
+
+private slots:
+
+    void removeActor();
+    void addActor();
+    void editActor();
+
+private:
+    Ui::ItemSettingsDialog *ui;
+};
+
+#endif // RELAYSETTINGSDIALOG_H

src/ui/itemsettingsdialog.ui

@@ -1,20 +1,20 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>RelaySettingsDialog</class>
- <widget class="QDialog" name="RelaySettingsDialog">
+ <class>ItemSettingsDialog</class>
+ <widget class="QDialog" name="ItemSettingsDialog">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>400</width>
-    <height>319</height>
+    <width>577</width>
+    <height>390</height>
    </rect>
   </property>
   <property name="windowTitle">
-   <string>Relay Settings</string>
+   <string>Item Settings</string>
   </property>
   <property name="windowIcon">
-   <iconset resource="resources.qrc">
+   <iconset resource="../../resources.qrc">
     <normaloff>:/images/UVOSicon.bmp</normaloff>:/images/UVOSicon.bmp</iconset>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
@@ -29,15 +29,15 @@
      <property name="bottomMargin">
       <number>10</number>
      </property>
-     <item row="3" column="0">
-      <widget class="QLabel" name="label_5">
+     <item row="1" column="0">
+      <widget class="QLabel" name="label_id_lable">
        <property name="text">
-        <string>Address</string>
+        <string>ID:</string>
        </property>
       </widget>
      </item>
-     <item row="3" column="1">
-      <widget class="QLabel" name="label_address">
+     <item row="1" column="1">
+      <widget class="QLabel" name="label_id">
        <property name="text">
         <string>TextLabel</string>
        </property>
@@ -65,6 +65,23 @@
        </property>
       </widget>
      </item>
+     <item row="3" column="0">
+      <widget class="QLabel" name="label_address_lable">
+       <property name="text">
+        <string>Address</string>
+       </property>
+      </widget>
+     </item>
+     <item row="3" column="1">
+      <widget class="QLabel" name="label_address">
+       <property name="text">
+        <string>TextLabel</string>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+       </property>
+      </widget>
+     </item>
      <item row="2" column="0">
       <widget class="QLabel" name="label">
        <property name="text">
@@ -75,39 +92,136 @@
        </property>
       </widget>
      </item>
-     <item row="1" column="1">
-      <widget class="QLabel" name="label_id">
+    </layout>
+   </item>
+   <item>
+    <widget class="QCheckBox" name="checkBox_auto">
+     <property name="text">
+      <string>Actors enabled</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QTableWidget" name="tableWidget">
+     <property name="frameShape">
+      <enum>QFrame::StyledPanel</enum>
+     </property>
+     <property name="verticalScrollBarPolicy">
+      <enum>Qt::ScrollBarAsNeeded</enum>
+     </property>
+     <property name="horizontalScrollBarPolicy">
+      <enum>Qt::ScrollBarAlwaysOff</enum>
+     </property>
+     <property name="autoScroll">
+      <bool>false</bool>
+     </property>
+     <property name="editTriggers">
+      <set>QAbstractItemView::NoEditTriggers</set>
+     </property>
+     <property name="tabKeyNavigation">
+      <bool>false</bool>
+     </property>
+     <property name="showDropIndicator" stdset="0">
+      <bool>false</bool>
+     </property>
+     <property name="dragDropOverwriteMode">
+      <bool>false</bool>
+     </property>
+     <property name="selectionBehavior">
+      <enum>QAbstractItemView::SelectRows</enum>
+     </property>
+     <property name="showGrid">
+      <bool>false</bool>
+     </property>
+     <property name="gridStyle">
+      <enum>Qt::SolidLine</enum>
+     </property>
+     <property name="cornerButtonEnabled">
+      <bool>false</bool>
+     </property>
+     <property name="rowCount">
+      <number>0</number>
+     </property>
+     <property name="columnCount">
+      <number>4</number>
+     </property>
+     <attribute name="horizontalHeaderVisible">
+      <bool>false</bool>
+     </attribute>
+     <attribute name="horizontalHeaderMinimumSectionSize">
+      <number>32</number>
+     </attribute>
+     <attribute name="horizontalHeaderHighlightSections">
+      <bool>true</bool>
+     </attribute>
+     <attribute name="verticalHeaderVisible">
+      <bool>false</bool>
+     </attribute>
+     <attribute name="verticalHeaderDefaultSectionSize">
+      <number>32</number>
+     </attribute>
+     <column/>
+     <column/>
+     <column/>
+     <column/>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_2">
+     <property name="leftMargin">
+      <number>0</number>
+     </property>
+     <property name="topMargin">
+      <number>0</number>
+     </property>
+     <item>
+      <widget class="QPushButton" name="pushButton_remove">
        <property name="text">
-        <string>TextLabel</string>
-       </property>
-       <property name="alignment">
-        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+        <string>Remove</string>
        </property>
       </widget>
      </item>
-     <item row="1" column="0">
-      <widget class="QLabel" name="label_2">
+     <item>
+      <widget class="QPushButton" name="pushButton_edit">
        <property name="text">
-        <string>ID:</string>
+        <string>Edit</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
-   <item>
-    <widget class="QListWidget" name="listWidget"/>
-   </item>
-   <item>
-    <widget class="QPushButton" name="pushButton">
-     <property name="text">
-      <string>Remove</string>
-     </property>
-    </widget>
-   </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QLabel" name="label_3">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>Act on</string>
+       </property>
+      </widget>
+     </item>
      <item>
       <widget class="QComboBox" name="comboBox">
+       <item>
+        <property name="text">
+         <string>Sensor</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Linear</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Regulator</string>
+        </property>
+       </item>
        <item>
         <property name="text">
          <string>Alarm</string>
@@ -118,26 +232,6 @@
          <string>Timer</string>
         </property>
        </item>
-       <item>
-        <property name="text">
-         <string>Speaker</string>
-        </property>
-       </item>
-       <item>
-        <property name="text">
-         <string>RGB Value</string>
-        </property>
-       </item>
-       <item>
-        <property name="text">
-         <string>Temperature</string>
-        </property>
-       </item>
-       <item>
-        <property name="text">
-         <string/>
-        </property>
-       </item>
       </widget>
      </item>
      <item>
@@ -168,13 +262,13 @@
   </layout>
  </widget>
  <resources>
-  <include location="resources.qrc"/>
+  <include location="../../resources.qrc"/>
  </resources>
  <connections>
   <connection>
    <sender>buttonBox</sender>
    <signal>accepted()</signal>
-   <receiver>RelaySettingsDialog</receiver>
+   <receiver>ItemSettingsDialog</receiver>
    <slot>accept()</slot>
    <hints>
     <hint type="sourcelabel">
@@ -190,7 +284,7 @@
   <connection>
    <sender>buttonBox</sender>
    <signal>rejected()</signal>
-   <receiver>RelaySettingsDialog</receiver>
+   <receiver>ItemSettingsDialog</receiver>
    <slot>reject()</slot>
    <hints>
     <hint type="sourcelabel">

src/ui/itemwidget.cpp

@@ -0,0 +1,98 @@
+#include "itemwidget.h"
+#include "ui_itemwidget.h"
+
+#include <QCheckBox>
+#include <QDebug>
+#include <QSlider>
+
+ItemWidget::ItemWidget(std::weak_ptr<Item> item, bool analog, QWidget *parent) :
+    QWidget(parent),
+    item_(item),
+    ui(new Ui::ItemWidget)
+{
+    ui->setupUi(this);
+
+    if(analog)
+    {
+        ui->horizontalSpacer->changeSize(0,0);
+        ui->checkBox->hide();
+        //ui->label->hide();
+    }
+    else
+    {
+        ui->slider->hide();
+    }
+
+    if(auto workingRelay = item_.lock())
+    {
+        ui->checkBox->setChecked(workingRelay->getValue());
+
+        ui->label->setText(workingRelay->getName());
+
+        if(analog)connect(ui->slider, &QSlider::valueChanged, this, &ItemWidget::moveToValue);
+        else connect(ui->checkBox, &QCheckBox::toggled, this, &ItemWidget::moveToState);
+        connect(ui->pushButton, &QPushButton::clicked, this, &ItemWidget::showSettingsDialog);
+        connect(workingRelay.get(), &Relay::valueChanged, this, &ItemWidget::stateChanged);
+
+    }
+    else disable();
+}
+
+void ItemWidget::moveToValue(int value)
+{
+    if(auto workingItem = item_.lock()) workingItem->setValue(value);
+    else disable();
+}
+
+void ItemWidget::moveToState(bool state)
+{
+    if(auto workingItem = item_.lock()) workingItem->setValue(state);
+    else disable();
+}
+
+void ItemWidget::disable()
+{
+    ui->checkBox->setEnabled(false);
+    ui->label->setEnabled(false);
+}
+
+bool ItemWidget::controles(const ItemData& relay)
+{
+    if(auto workingRelay = item_.lock())
+    {
+        if(relay == *workingRelay) return  true;
+        else return false;
+    }
+    return true;
+}
+
+void ItemWidget::showSettingsDialog()
+{
+    if(auto workingRelay = item_.lock())
+    {
+        ItemSettingsDialog dialog(workingRelay.get(), this);
+        dialog.exec();
+    }
+    else disable();
+}
+
+std::weak_ptr<Item> ItemWidget::getItem()
+{
+    return item_;
+}
+
+void ItemWidget::stateChanged(int state)
+{
+    qDebug()<<"widget got state "<<state;
+    ui->slider->blockSignals(true);
+    ui->slider->setValue(state);
+    ui->slider->blockSignals(false);
+    ui->checkBox->blockSignals(true);
+    ui->checkBox->setChecked(state);
+    ui->checkBox->blockSignals(false);
+}
+
+ItemWidget::~ItemWidget()
+{
+    delete ui;
+}

src/ui/itemwidget.h

@@ -0,0 +1,40 @@
+#ifndef RELAYWIDGET_H
+#define RELAYWIDGET_H
+
+#include <QWidget>
+#include <memory>
+#include "itemsettingsdialog.h"
+#include "../items/item.h"
+
+namespace Ui {
+class ItemWidget;
+}
+
+class ItemWidget : public QWidget
+{
+    Q_OBJECT
+private:
+    std::weak_ptr<Item> item_;
+
+    void disable();
+
+private slots:
+    void showSettingsDialog();
+    void moveToState(bool state);
+    void moveToValue(int value);
+
+public:
+    explicit ItemWidget(std::weak_ptr<Item> item, bool analog = false, QWidget *parent = nullptr);
+    std::weak_ptr<Item> getItem();
+    bool controles(const ItemData& relay);
+    ~ItemWidget();
+
+public slots:
+
+    void stateChanged(int state);
+
+private:
+    Ui::ItemWidget *ui;
+};
+
+#endif // RELAYWIDGET_H

src/ui/itemwidget.ui

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>RelayWidget</class>
- <widget class="QWidget" name="RelayWidget">
+ <class>ItemWidget</class>
+ <widget class="QWidget" name="ItemWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
@@ -10,6 +10,12 @@
     <height>48</height>
    </rect>
   </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
@@ -35,19 +41,22 @@
     </spacer>
    </item>
    <item>
-    <widget class="QCheckBox" name="checkBox">
-     <property name="text">
-      <string>On</string>
+    <widget class="QSlider" name="slider">
+     <property name="maximum">
+      <number>255</number>
+     </property>
+     <property name="tracking">
+      <bool>true</bool>
+     </property>
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item>
-    <widget class="QCheckBox" name="checkBox_auto">
-     <property name="enabled">
-      <bool>true</bool>
-     </property>
+    <widget class="QCheckBox" name="checkBox">
      <property name="text">
-      <string>Auto</string>
+      <string>On</string>
      </property>
     </widget>
    </item>

src/ui/mainwindow-android.ui

@@ -0,0 +1,261 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>650</width>
+    <height>513</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>50</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>650</width>
+    <height>300</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Smart Home Interface</string>
+  </property>
+  <property name="windowIcon">
+   <iconset resource="../../resources.qrc">
+    <normaloff>:/images/UVOSicon.bmp</normaloff>:/images/UVOSicon.bmp</iconset>
+  </property>
+  <widget class="QWidget" name="centralWidget">
+   <property name="sizePolicy">
+    <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
+     <horstretch>0</horstretch>
+     <verstretch>0</verstretch>
+    </sizepolicy>
+   </property>
+   <property name="layoutDirection">
+    <enum>Qt::LeftToRight</enum>
+   </property>
+   <property name="autoFillBackground">
+    <bool>false</bool>
+   </property>
+   <layout class="QHBoxLayout" name="horizontalLayout_10" stretch="0,1">
+    <item>
+     <layout class="QVBoxLayout" name="verticalLayout" stretch="0,1,0,0,0">
+      <item>
+       <widget class="QLabel" name="label_serialRecive">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="frameShape">
+         <enum>QFrame::Box</enum>
+        </property>
+        <property name="text">
+         <string>SHinterface</string>
+        </property>
+        <property name="textFormat">
+         <enum>Qt::AutoText</enum>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QGroupBox" name="groupBox_2">
+        <property name="title">
+         <string>Sensors</string>
+        </property>
+        <layout class="QVBoxLayout" name="verticalLayout_3">
+         <property name="leftMargin">
+          <number>2</number>
+         </property>
+         <property name="rightMargin">
+          <number>2</number>
+         </property>
+         <item>
+          <widget class="SensorListWidget" name="sensorListView">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+           <property name="minimumSize">
+            <size>
+             <width>0</width>
+             <height>25</height>
+            </size>
+           </property>
+           <property name="maximumSize">
+            <size>
+             <width>16777215</width>
+             <height>16777215</height>
+            </size>
+           </property>
+           <property name="editTriggers">
+            <set>QAbstractItemView::NoEditTriggers</set>
+           </property>
+           <property name="showDropIndicator" stdset="0">
+            <bool>false</bool>
+           </property>
+           <property name="defaultDropAction">
+            <enum>Qt::TargetMoveAction</enum>
+           </property>
+           <property name="selectionMode">
+            <enum>QAbstractItemView::NoSelection</enum>
+           </property>
+           <property name="selectionRectVisible">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
+      <item>
+       <widget class="QPushButton" name="button_color">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>50</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>0</width>
+          <height>0</height>
+         </size>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>16777215</width>
+          <height>48</height>
+         </size>
+        </property>
+        <property name="baseSize">
+         <size>
+          <width>0</width>
+          <height>128</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>Color</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <spacer name="verticalSpacer_2">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::Preferred</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item>
+       <widget class="QPushButton" name="pushButton_alarms">
+        <property name="text">
+         <string>Alarms</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </item>
+    <item>
+     <layout class="QVBoxLayout" name="verticalLayout_2" stretch="1,0">
+      <item>
+       <widget class="QGroupBox" name="groupBox">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="title">
+         <string>Relays</string>
+        </property>
+        <layout class="QVBoxLayout" name="verticalLayout_4">
+         <property name="leftMargin">
+          <number>2</number>
+         </property>
+         <property name="rightMargin">
+          <number>2</number>
+         </property>
+         <item>
+          <widget class="ItemScrollBox" name="relayList" native="true">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <property name="topMargin">
+         <number>0</number>
+        </property>
+        <item>
+         <widget class="QPushButton" name="pushButton_refesh">
+          <property name="text">
+           <string>Refesh</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="button_quit">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="layoutDirection">
+           <enum>Qt::RightToLeft</enum>
+          </property>
+          <property name="text">
+           <string>Quit</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </item>
+   </layout>
+  </widget>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <customwidgets>
+  <customwidget>
+   <class>ItemScrollBox</class>
+   <extends>QWidget</extends>
+   <header location="global">../src/ui/itemscrollbox.h</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>SensorListWidget</class>
+   <extends>QListView</extends>
+   <header location="global">../src/ui/sensorlistwidget.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources>
+  <include location="../../resources.qrc"/>
+ </resources>
+ <connections/>
+</ui>

src/ui/mainwindow.cpp

@@ -1,47 +1,34 @@
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
-#include "relayscrollbox.h"
+#include "itemscrollbox.h"
 
-MainWindow::MainWindow(Microcontroller *micro , bool isRemoteMode , QWidget *parent) :
+#include "itemsettingsdialog.h"
+
+MainWindow::MainWindow(Microcontroller *micro, PowerItem* powerItem, ItemStore* itemStore, SensorStore *sensorStore, QWidget *parent) :
     QMainWindow(parent),
     ui(new Ui::MainWindow),
     colorChooser(this),
-    _micro(micro)
+    _micro(micro),
+    _powerItem(powerItem)
 {
     ui->setupUi(this);
 
-    if(!_micro->connected()) ui->label_serialRecive->setText("No IO Port! Debug only.");
+    connect(ui->pushButton_power, SIGNAL(clicked()), this, SLOT(showPowerItemDialog()));
 
     //Relays
-    connect(ui->pushButton_refesh, SIGNAL(clicked()), _micro, SLOT(requestRelayList()));
-    ui->relayList->setMicrocontoller(_micro);
-    connect(_micro, &Microcontroller::gotRelayList, ui->relayList, &RelayScrollBox::gotRelays);
-    connect(_micro, &Microcontroller::relayStateChanged, ui->relayList, &RelayScrollBox::relaySateChanged);
+    connect(ui->pushButton_refesh, SIGNAL(clicked()), _micro, SLOT(requestState()));
+    connect(itemStore, &ItemStore::itemAdded, ui->relayList, &ItemScrollBox::addItem);
+    connect(itemStore, &ItemStore::itemDeleted, ui->relayList, &ItemScrollBox::removeItem);
+
+    //Sensors
+
+    ui->sensorListView->sensorsChanged(*(sensorStore->getSensors()));
+    connect(sensorStore, &SensorStore::stateChenged, ui->sensorListView, &SensorListWidget::sensorsChanged);
 
     //RGB Leds
-    connect(ui->presettApply, SIGNAL(clicked()), this, SLOT(slotApplyPreset()));
     connect(&colorChooser, SIGNAL(colorSelected(const QColor)), this, SLOT(slotChangedRgb(const QColor)));
-    connect(ui->button_lightsOn, SIGNAL(clicked()), _micro, SLOT(rgbOn()));
-    connect(ui->button_lightsOff, SIGNAL(clicked()), _micro, SLOT(rgbOff()));
     connect(ui->button_quit, SIGNAL(clicked()), this, SLOT(close()));
     connect(ui->button_color, SIGNAL(clicked()), &colorChooser, SLOT(show()));
-
-    new QListWidgetItem(tr("Pattern 0 Solid"), ui->listWidget_patern);
-    new QListWidgetItem(tr("Pattern 1"), ui->listWidget_patern);
-    new QListWidgetItem(tr("Pattern 2 Alarm"), ui->listWidget_patern);
-    new QListWidgetItem(tr("Pattern 3"), ui->listWidget_patern);
-    new QListWidgetItem(tr("Pattern 4 Sunrise"), ui->listWidget_patern);
-
-    //Desk light
-
-    connect(ui->horizontalSlider_deskLight, &QAbstractSlider::valueChanged, _micro, [this](int value){ _micro->setAuxPwm(value); });
-
-    connect(ui->pushButton_alarms, SIGNAL(clicked()), this, SIGNAL(showAlmSettingsDialog()));
-}
-
-void MainWindow::remoteMode()
-{
-
 }
 
 MainWindow::~MainWindow()
@@ -49,30 +36,24 @@ MainWindow::~MainWindow()
     delete ui;
 }
 
+void MainWindow::showPowerItemDialog()
+{
+    ItemSettingsDialog diag(_powerItem, this);
+    diag.show();
+    diag.exec();
+}
+
 void MainWindow::slotChangedRgb(const QColor color)
 {
     _micro->changeRgbColor(color);
 }
 
-
-void MainWindow::slotApplyPreset()
-{
-    if(ui->listWidget_patern->selectedItems().count() == 1) _micro->setPattern(ui->listWidget_patern->currentRow());
-}
-
-void MainWindow::slotDoorOpenTimeout()
-{
-    //ui->checkBox_doorOpen->setChecked(true);
-}
-
-void MainWindow::auxStateChanged(int value)
-{
-    ui->horizontalSlider_deskLight->blockSignals(true);
-    ui->horizontalSlider_deskLight->setValue(value);
-    ui->horizontalSlider_deskLight->blockSignals(false);
-}
-
-void MainWindow::changeHeaderLableText(const QString string)
+void MainWindow::changeHeaderLableText(QString string)
 {
+    if(string.size() > 28)
+    {
+        string.remove(28, string.size()-(28));
+        string.append("...");
+    }
     ui->label_serialRecive->setText(string);
 }

src/ui/mainwindow.h

@@ -6,8 +6,11 @@
 #include <QListWidgetItem>
 #include <QTime>
 #include <vector>
-#include "alarmtime.h"
-#include "microcontroller.h"
+#include "../actors/alarmtime.h"
+#include "../microcontroller.h"
+#include "../sensors/sensor.h"
+#include "../items/itemstore.h"
+#include "../items/poweritem.h"
 
 
 namespace Ui
@@ -20,7 +23,7 @@ class MainWindow : public QMainWindow
     Q_OBJECT
 
 public:
-    explicit MainWindow(Microcontroller *micro, bool isRemoteMode = false, QWidget *parent = nullptr);
+    explicit MainWindow(Microcontroller *micro, PowerItem* powerItem, ItemStore* itemStore, SensorStore *sensorStore, QWidget *parent = nullptr);
     ~MainWindow();
 
 private:
@@ -30,30 +33,17 @@ private:
 
     Microcontroller *_micro;
 
-    void remoteMode();
-
-signals:
-
-    void signalAmpOn();
-    void signalAmpOff();
-
-    void showAlmSettingsDialog();
+    PowerItem *_powerItem;
 
 private slots:
 
     //RGB
     void slotChangedRgb(const QColor color);
-    void slotApplyPreset();
-
-    void changeHeaderLableText(const QString string);
-
-    //door
-    void slotDoorOpenTimeout();
+    void showPowerItemDialog();
 
 public slots:
 
-    void auxStateChanged(int value);
-
+    void changeHeaderLableText(QString string);
 };
 
 #endif // MAINWINDOW_H

src/ui/mainwindow.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>862</width>
-    <height>570</height>
+    <width>887</width>
+    <height>530</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -18,15 +18,15 @@
   </property>
   <property name="minimumSize">
    <size>
-    <width>600</width>
-    <height>197</height>
+    <width>650</width>
+    <height>300</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>Smart Home Interface</string>
   </property>
   <property name="windowIcon">
-   <iconset resource="resources.qrc">
+   <iconset resource="../../resources.qrc">
     <normaloff>:/images/UVOSicon.bmp</normaloff>:/images/UVOSicon.bmp</iconset>
   </property>
   <widget class="QWidget" name="centralWidget">
@@ -42,79 +42,63 @@
    <property name="autoFillBackground">
     <bool>false</bool>
    </property>
-   <layout class="QHBoxLayout" name="horizontalLayout_10">
+   <layout class="QHBoxLayout" name="horizontalLayout_10" stretch="0,1">
     <item>
-     <layout class="QHBoxLayout" name="horizontalLayout">
+     <layout class="QVBoxLayout" name="verticalLayout" stretch="0,1,0">
       <item>
-       <layout class="QVBoxLayout" name="verticalLayout_2">
-        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_9">
-          <property name="topMargin">
-           <number>0</number>
-          </property>
-          <property name="bottomMargin">
-           <number>10</number>
-          </property>
-          <item>
-           <widget class="QLabel" name="label_serialRecive">
-            <property name="sizePolicy">
-             <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-              <horstretch>0</horstretch>
-              <verstretch>0</verstretch>
-             </sizepolicy>
-            </property>
-            <property name="frameShape">
-             <enum>QFrame::Box</enum>
-            </property>
-            <property name="text">
-             <string>SHinterface</string>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
-        <item>
-         <widget class="QGroupBox" name="groupBox">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="title">
-           <string>Relays</string>
-          </property>
-          <layout class="QVBoxLayout" name="verticalLayout_4">
-           <item>
-            <widget class="RelayScrollBox" name="relayList" native="true">
-             <property name="sizePolicy">
-              <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
-               <horstretch>0</horstretch>
-               <verstretch>0</verstretch>
-              </sizepolicy>
-             </property>
-            </widget>
-           </item>
-           <item>
-            <widget class="QPushButton" name="pushButton_refesh">
-             <property name="text">
-              <string>Refesh</string>
-             </property>
-            </widget>
-           </item>
-          </layout>
-         </widget>
-        </item>
-       </layout>
-      </item>
-     </layout>
-    </item>
-    <item>
-     <layout class="QVBoxLayout" name="verticalLayout">
-      <item>
-       <widget class="QListWidget" name="listWidget_patern">
+       <widget class="QLabel" name="label_serialRecive">
         <property name="sizePolicy">
-         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="frameShape">
+         <enum>QFrame::Box</enum>
+        </property>
+        <property name="text">
+         <string>SHinterface</string>
+        </property>
+        <property name="textFormat">
+         <enum>Qt::AutoText</enum>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QGroupBox" name="groupBox_2">
+        <property name="title">
+         <string>Sensors</string>
+        </property>
+        <layout class="QVBoxLayout" name="verticalLayout_3">
+         <property name="leftMargin">
+          <number>2</number>
+         </property>
+         <property name="rightMargin">
+          <number>2</number>
+         </property>
+         <item>
+          <widget class="SensorListWidget" name="sensorListView">
+           <property name="selectionMode">
+            <enum>QAbstractItemView::NoSelection</enum>
+           </property>
+           <property name="showGrid">
+            <bool>false</bool>
+           </property>
+           <property name="gridStyle">
+            <enum>Qt::NoPen</enum>
+           </property>
+           <attribute name="verticalHeaderVisible">
+            <bool>false</bool>
+           </attribute>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
+      <item>
+       <widget class="QPushButton" name="button_color">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
@@ -128,65 +112,7 @@
         <property name="maximumSize">
          <size>
           <width>16777215</width>
-          <height>120</height>
-         </size>
-        </property>
-        <property name="baseSize">
-         <size>
-          <width>0</width>
-          <height>50</height>
-         </size>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_2">
-        <item>
-         <spacer name="horizontalSpacer_3">
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>40</width>
-            <height>20</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
-        <item>
-         <widget class="QPushButton" name="presettApply">
-          <property name="minimumSize">
-           <size>
-            <width>128</width>
-            <height>32</height>
-           </size>
-          </property>
-          <property name="text">
-           <string>Apply</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-      <item>
-       <widget class="QPushButton" name="button_color">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
-          <horstretch>0</horstretch>
-          <verstretch>50</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="minimumSize">
-         <size>
-          <width>0</width>
-          <height>0</height>
-         </size>
-        </property>
-        <property name="maximumSize">
-         <size>
-          <width>16777215</width>
-          <height>80</height>
+          <height>48</height>
          </size>
         </property>
         <property name="baseSize">
@@ -196,121 +122,82 @@
          </size>
         </property>
         <property name="text">
-         <string>Choose Color</string>
+         <string>Color</string>
         </property>
        </widget>
       </item>
+     </layout>
+    </item>
+    <item>
+     <layout class="QVBoxLayout" name="verticalLayout_2" stretch="1,0">
       <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_11">
-        <property name="topMargin">
-         <number>10</number>
-        </property>
-        <property name="bottomMargin">
-         <number>10</number>
-        </property>
-        <item>
-         <widget class="QPushButton" name="button_lightsOn">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-            <horstretch>0</horstretch>
-            <verstretch>50</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="minimumSize">
-           <size>
-            <width>0</width>
-            <height>48</height>
-           </size>
-          </property>
-          <property name="text">
-           <string>ON</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QPushButton" name="button_lightsOff">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
-            <horstretch>0</horstretch>
-            <verstretch>50</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="minimumSize">
-           <size>
-            <width>0</width>
-            <height>48</height>
-           </size>
-          </property>
-          <property name="text">
-           <string>OFF</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_8">
-        <item>
-         <widget class="QLabel" name="label_3">
-          <property name="text">
-           <string>Desk Light</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QSlider" name="horizontalSlider_deskLight">
-          <property name="maximum">
-           <number>254</number>
-          </property>
-          <property name="tracking">
-           <bool>false</bool>
-          </property>
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-      <item>
-       <spacer name="verticalSpacer_2">
-        <property name="orientation">
-         <enum>Qt::Vertical</enum>
-        </property>
-        <property name="sizeType">
-         <enum>QSizePolicy::Preferred</enum>
-        </property>
-        <property name="sizeHint" stdset="0">
-         <size>
-          <width>20</width>
-          <height>20</height>
-         </size>
-        </property>
-       </spacer>
-      </item>
-      <item>
-       <widget class="QPushButton" name="pushButton_alarms">
-        <property name="text">
-         <string>Alarms</string>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QPushButton" name="button_quit">
+       <widget class="QGroupBox" name="groupBox">
         <property name="sizePolicy">
-         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+         <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
-        <property name="layoutDirection">
-         <enum>Qt::RightToLeft</enum>
-        </property>
-        <property name="text">
-         <string>Quit</string>
+        <property name="title">
+         <string>Items</string>
         </property>
+        <layout class="QVBoxLayout" name="verticalLayout_4">
+         <property name="leftMargin">
+          <number>2</number>
+         </property>
+         <property name="rightMargin">
+          <number>2</number>
+         </property>
+         <item>
+          <widget class="ItemScrollBox" name="relayList" native="true">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+          </widget>
+         </item>
+        </layout>
        </widget>
       </item>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <property name="topMargin">
+         <number>0</number>
+        </property>
+        <item>
+         <widget class="QPushButton" name="pushButton_power">
+          <property name="text">
+           <string>Config Shutdown</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="pushButton_refesh">
+          <property name="text">
+           <string>Refesh</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="button_quit">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="layoutDirection">
+           <enum>Qt::RightToLeft</enum>
+          </property>
+          <property name="text">
+           <string>Quit</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
      </layout>
     </item>
    </layout>
@@ -319,14 +206,19 @@
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
-   <class>RelayScrollBox</class>
+   <class>ItemScrollBox</class>
    <extends>QWidget</extends>
-   <header>relayscrollbox.h</header>
+   <header location="global">../src/ui/itemscrollbox.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>SensorListWidget</class>
+   <extends>QTableWidget</extends>
+   <header location="global">../src/ui/sensorlistwidget.h</header>
+  </customwidget>
  </customwidgets>
  <resources>
-  <include location="resources.qrc"/>
+  <include location="../../resources.qrc"/>
  </resources>
  <connections/>
 </ui>

src/ui/relaydialog.ui

@@ -1,230 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>RelayDialog</class>
- <widget class="QDialog" name="RelayDialog">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>358</width>
-    <height>320</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Advanced Relays</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <widget class="QGroupBox" name="groupBox">
-     <property name="title">
-      <string>Advanced</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_2">
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_3">
-        <item>
-         <widget class="QLabel" name="label_3">
-          <property name="text">
-           <string>3Dator</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <spacer name="horizontalSpacer_3">
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>40</width>
-            <height>20</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="checkBox_R0">
-          <property name="text">
-           <string>On</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-      <item>
-       <widget class="Line" name="line_4">
-        <property name="orientation">
-         <enum>Qt::Horizontal</enum>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_4">
-        <item>
-         <widget class="QLabel" name="label_4">
-          <property name="text">
-           <string>3040</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <spacer name="horizontalSpacer_4">
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>40</width>
-            <height>20</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="checkBox_R1">
-          <property name="text">
-           <string>On</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-      <item>
-       <widget class="Line" name="line_5">
-        <property name="orientation">
-         <enum>Qt::Horizontal</enum>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_2">
-        <item>
-         <widget class="QLabel" name="label_6">
-          <property name="text">
-           <string>Aux</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <spacer name="horizontalSpacer_6">
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>40</width>
-            <height>20</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="checkBox_R2">
-          <property name="text">
-           <string>On</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout_5">
-     <property name="leftMargin">
-      <number>0</number>
-     </property>
-     <property name="topMargin">
-      <number>0</number>
-     </property>
-     <item>
-      <widget class="QLabel" name="label_5">
-       <property name="text">
-        <string>Enterance Watch</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <spacer name="horizontalSpacer_5">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item>
-      <widget class="QCheckBox" name="checkBox">
-       <property name="text">
-        <string>Inside</string>
-       </property>
-       <property name="checked">
-        <bool>true</bool>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QCheckBox" name="checkBox_2">
-       <property name="text">
-        <string>Watch</string>
-       </property>
-       <property name="checked">
-        <bool>true</bool>
-       </property>
-      </widget>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <widget class="QDialogButtonBox" name="buttonBox">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="standardButtons">
-      <set>QDialogButtonBox::Ok</set>
-     </property>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>accepted()</signal>
-   <receiver>RelayDialog</receiver>
-   <slot>accept()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>248</x>
-     <y>254</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>157</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>rejected()</signal>
-   <receiver>RelayDialog</receiver>
-   <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>316</x>
-     <y>260</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>286</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
-</ui>

src/ui/relayscrollbox.cpp

@@ -1,32 +0,0 @@
-#include "relayscrollbox.h"
-#include "ui_relayscrollbox.h"
-
-RelayScrollBox::RelayScrollBox(QWidget *parent) :
-    QWidget(parent),
-    ui(new Ui::RelayScrollBox)
-{
-    ui->setupUi(this);
-    QScroller::grabGesture(ui->scrollArea, QScroller::TouchGesture);
-    QScroller::grabGesture(ui->scrollArea, QScroller::LeftMouseButtonGesture);
-}
-
-RelayScrollBox::~RelayScrollBox()
-{
-    delete ui;
-}
-
-void RelayScrollBox::addRelay(std::weak_ptr<Relay> relay)
-{
-    widgets_.push_back(new RelayWidget(relay));
-    ui->relayWidgetVbox->addWidget(widgets_.back());
-}
-
-void RelayScrollBox::removeRelay(const RelayStore& realy)
-{
-    for(unsigned i = 0; i < widgets_.size(); i++)
-    {
-        if(widgets_[i]->controles(realy)) widgets_.erase(widgets_.begin()+i);
-    }
-}
-
-

src/ui/relayscrollbox.h

@@ -1,40 +0,0 @@
-#ifndef RELAYSCROLLBOX_H
-#define RELAYSCROLLBOX_H
-
-#include <QWidget>
-#include <vector>
-#include <memory>
-#include <QScroller>
-#include "relaywidget.h"
-#include "../relay.h"
-#include "../item.h"
-
-
-namespace Ui {
-class RelayScrollBox;
-}
-
-class RelayScrollBox : public QWidget
-{
-    Q_OBJECT
-private:
-    std::vector< RelayWidget* > widgets_;
-
-public:
-    explicit RelayScrollBox(QWidget *parent = nullptr);
-    ~RelayScrollBox();
-
-    void setItemStore(ItemStore* itemStore);
-
-public slots:
-
-    void addRelay(std::weak_ptr<Relay> relay);
-    void removeRelay(const RelayStore& Realy);
-
-private:
-    Ui::RelayScrollBox *ui;
-};
-
-#endif // RELAYSCROLLBOX_H
-
-

src/ui/relayscrollbox.ui

@@ -16,6 +16,18 @@
   <layout class="QHBoxLayout" name="horizontalLayout">
    <item>
     <widget class="QScrollArea" name="scrollArea">
+     <property name="frameShape">
+      <enum>QFrame::NoFrame</enum>
+     </property>
+     <property name="lineWidth">
+      <number>0</number>
+     </property>
+     <property name="verticalScrollBarPolicy">
+      <enum>Qt::ScrollBarAlwaysOff</enum>
+     </property>
+     <property name="horizontalScrollBarPolicy">
+      <enum>Qt::ScrollBarAlwaysOff</enum>
+     </property>
      <property name="widgetResizable">
       <bool>true</bool>
      </property>
@@ -24,8 +36,8 @@
        <rect>
         <x>0</x>
         <y>0</y>
-        <width>384</width>
-        <height>284</height>
+        <width>388</width>
+        <height>288</height>
        </rect>
       </property>
       <layout class="QVBoxLayout" name="verticalLayout">

src/ui/relaysettingsdialog.cpp

@@ -1,18 +0,0 @@
-#include "relaysettingsdialog.h"
-#include "ui_relaysettingsdialog.h"
-
-RelaySettingsDialog::RelaySettingsDialog(RelayStore* relay, QWidget *parent) :
-    QDialog(parent),
-    relay_(relay),
-    ui(new Ui::RelaySettingsDialog)
-{
-    ui->setupUi(this);
-    ui->label_address->setText(QString::number(relay_->getAddress(), 2));
-    ui->label_name->setText(relay_->getName());
-    ui->label_id->setText(QString::number(relay_->getId(), 10));
-}
-
-RelaySettingsDialog::~RelaySettingsDialog()
-{
-    delete ui;
-}

src/ui/relaysettingsdialog.h

@@ -1,24 +0,0 @@
-#ifndef RELAYSETTINGSDIALOG_H
-#define RELAYSETTINGSDIALOG_H
-
-#include <QDialog>
-#include "relay.h"
-
-namespace Ui {
-class RelaySettingsDialog;
-}
-
-class RelaySettingsDialog : public QDialog
-{
-    Q_OBJECT
-    RelayStore* relay_;
-
-public:
-    explicit RelaySettingsDialog(RelayStore* relay, QWidget *parent = nullptr);
-    ~RelaySettingsDialog();
-
-private:
-    Ui::RelaySettingsDialog *ui;
-};
-
-#endif // RELAYSETTINGSDIALOG_H

src/ui/relaywidget.cpp

@@ -1,50 +0,0 @@
-#include "relaywidget.h"
-#include "ui_relaywidget.h"
-
-#include <QCheckBox>
-
-RelayWidget::RelayWidget(Relay* relay, QWidget *parent) :
-    QWidget(parent),
-    relay_(relay),
-    ui(new Ui::RelayWidget)
-{
-    ui->setupUi(this);
-
-    relay_->setParent(this);
-
-    if(!relay->hasActors())
-    {
-        ui->checkBox_auto->hide();
-
-    }
-    ui->checkBox_auto->setChecked(relay->actorsActive());
-    ui->checkBox->setChecked(relay->getState());
-
-    ui->label->setText(relay_->getName());
-
-    connect(ui->checkBox, &QCheckBox::toggled, relay_, &Relay::moveToState);
-    connect(ui->checkBox_auto, &QCheckBox::toggled, relay_, &Relay::setActorsActive);
-    connect(ui->pushButton, &QPushButton::clicked, this, &RelayWidget::showSettingsDialog);
-}
-
-void RelayWidget::showSettingsDialog()
-{
-    RelaySettingsDialog dialog(relay_, this);
-    dialog.exec();
-}
-
-Relay* RelayWidget::getRelay()
-{
-    return relay_;
-}
-
-void RelayWidget::stateChanged(bool state)
-{
-    ui->checkBox->setChecked(state);
-    relay_->setState(state);
-}
-
-RelayWidget::~RelayWidget()
-{
-    delete ui;
-}

src/ui/relaywidget.h

@@ -1,33 +0,0 @@
-#ifndef RELAYWIDGET_H
-#define RELAYWIDGET_H
-
-#include <QWidget>
-#include "relaysettingsdialog.h"
-#include "relay.h"
-
-namespace Ui {
-class RelayWidget;
-}
-
-class RelayWidget : public QWidget
-{
-    Q_OBJECT
-private:
-    Relay* relay_;
-
-private slots:
-    void showSettingsDialog();
-
-public:
-    explicit RelayWidget(Relay* relay_, QWidget *parent = nullptr);
-    Relay* getRelay();
-    ~RelayWidget();
-
-public slots:
-    void stateChanged(bool state);
-
-private:
-    Ui::RelayWidget *ui;
-};
-
-#endif // RELAYWIDGET_H

src/ui/sensoractorwidget.cpp

@@ -1,14 +0,0 @@
-#include "sensoractorwidget.h"
-#include "ui_sensoractorwidget.h"
-
-SensorActorWidget::SensorActorWidget(QWidget *parent) :
-    QWidget(parent),
-    ui(new Ui::SensorActorWidget)
-{
-    ui->setupUi(this);
-}
-
-SensorActorWidget::~SensorActorWidget()
-{
-    delete ui;
-}

src/ui/sensoractorwidget.h

@@ -1,22 +0,0 @@
-#ifndef SENSORACTORWIDGET_H
-#define SENSORACTORWIDGET_H
-
-#include <QWidget>
-
-namespace Ui {
-class SensorActorWidget;
-}
-
-class SensorActorWidget : public QWidget
-{
-    Q_OBJECT
-
-public:
-    explicit SensorActorWidget(QWidget *parent = nullptr);
-    ~SensorActorWidget();
-
-private:
-    Ui::SensorActorWidget *ui;
-};
-
-#endif // SENSORACTORWIDGET_H

src/ui/sensoractorwidget.ui

@@ -1,21 +0,0 @@
-<ui version="4.0">
- <author/>
- <comment/>
- <exportmacro/>
- <class>SensorActorWidget</class>
- <widget name="SensorActorWidget" class="QWidget">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>400</width>
-    <height>300</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
- </widget>
- <pixmapfunction/>
- <connections/>
-</ui>

src/ui/sensorlistwidget.cpp

@@ -1,33 +1,47 @@
 #include "sensorlistwidget.h"
 
-SensorListWidget::SensorListWidget(QWidget *parent): QListWidget (parent)
-{}
+#include <QDebug>
+#include <QHeaderView>
 
-SensorListWidget::SensorListWidget(SensorStore& sensorStore, QWidget* parent): QListWidget (parent)
+SensorListWidget::SensorListWidget(QWidget *parent): QTableWidget(parent)
+{
+    setColumnCount(2);
+    setSelectionBehavior(QAbstractItemView::SelectRows);
+    horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
+
+    setHorizontalHeaderItem(0, new QTableWidgetItem("Sensor"));
+    setHorizontalHeaderItem(1, new QTableWidgetItem("Value"));
+}
+
+SensorListWidget::SensorListWidget(SensorStore& sensorStore, QWidget* parent): QTableWidget (parent)
 {
       sensorsChanged(*(sensorStore.getSensors()));
 }
 
-
 void SensorListWidget::sensorsChanged(std::vector<Sensor> sensors)
 {
     clear();
+    setHorizontalHeaderItem(0, new QTableWidgetItem("Sensor"));
+    setHorizontalHeaderItem(1, new QTableWidgetItem("Value"));
+    setRowCount(sensors.size());
     for(size_t i = 0; i < sensors.size(); ++i)
     {
-        QString itemString = sensors[i].name + ": ";
+        QString itemString;
+        itemString.append(QString::number(sensors[i].field));
+        itemString.append(' ');
 
         if(sensors[i].type == Sensor::TYPE_DOOR)
         {
-            if(sensors[i].field) itemString.append("Open");
-            else itemString.append("Closed");
+            if(sensors[i].field) itemString.append("\"Open\"");
+            else itemString.append("\"Closed\"");
         }
         else if(sensors[i].type == Sensor::TYPE_AUDIO_OUTPUT)
         {
-            if(sensors[i].field) itemString.append("Playing");
-            else itemString.append("Silent");
+            if(sensors[i].field) itemString.append("\"Playing\"");
+            else itemString.append("\"Silent\"");
         }
-        else itemString.append(QString::number(sensors[i].field));
-        addItem(itemString);
+        setItem(i, 0, new QTableWidgetItem(sensors[i].name));
+        setItem(i, 1, new QTableWidgetItem(itemString));
     }
 }