Refactor tcpserver into multiple files

Allow running without gui
Remove serialPortMultiplexer broadcast use
Add TcpServer and TcpClient
Introduce the concept of an item source

CMakeLists.txt

@@ -0,0 +1,174 @@
+cmake_minimum_required(VERSION 4.0)
+
+project(SHinterface VERSION 1.0 LANGUAGES CXX)
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Enable all warnings
+add_compile_options(-Wall)
+
+# Find Qt packages
+find_package(Qt6 COMPONENTS Core Gui Widgets Network Multimedia SerialPort Mqtt REQUIRED)
+
+# Find dependencies using pkg-config
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(PIPEWIRE REQUIRED libpipewire-0.3)
+pkg_check_modules(LIBNL3 REQUIRED libnl-3.0 libnl-genl-3.0)
+
+# Enable automatic moc and uic processing
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
+
+# Add src to include path for relative includes
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src)
+
+# Create executable
+add_executable(SHinterface
+        src/sensors/mqttsensorsource.h src/sensors/mqttsensorsource.cpp)
+
+# Add sources to executable
+target_sources(SHinterface 
+    PRIVATE
+        src/main.cpp
+        src/mainobject.h
+        src/mainobject.cpp
+        src/apgetconnected.h
+        src/apgetconnected.cpp
+        src/microcontroller.h
+        src/microcontroller.cpp
+        src/sun.h
+        src/sun.cpp
+        src/programmode.h
+        src/programmode.cpp
+        src/pipewire.h
+        src/pipewire.cpp
+
+        src/service/service.h
+        src/service/service.cpp
+        src/service/tcpclient.h
+        src/service/tcpclient.cpp
+        src/service/tcpserver.h
+        src/service/tcpserver.cpp
+
+        src/actors/actor.h
+        src/actors/actor.cpp
+        src/actors/factoractor.h
+        src/actors/factoractor.cpp
+        src/actors/polynomalactor.h
+        src/actors/polynomalactor.cpp
+        src/actors/sensoractor.h
+        src/actors/sensoractor.cpp
+        src/actors/alarmtime.h
+        src/actors/alarmtime.cpp
+        src/actors/regulator.h
+        src/actors/regulator.cpp
+        src/actors/timeractor.h
+        src/actors/timeractor.cpp
+
+        src/sensors/sensor.h
+        src/sensors/sensor.cpp
+        src/sensors/sunsensor.h
+        src/sensors/sunsensor.cpp
+
+        src/items/item.h
+        src/items/item.cpp
+        src/items/relay.h
+        src/items/relay.cpp
+        src/items/poweritem.h
+        src/items/poweritem.cpp
+        src/items/messageitem.h
+        src/items/messageitem.cpp
+        src/items/systemitem.h
+        src/items/systemitem.cpp
+        src/items/auxitem.h
+        src/items/auxitem.cpp
+        src/items/rgbitem.h
+        src/items/rgbitem.cpp
+        src/items/itemsource.h
+        src/items/itemsource.cpp
+        src/items/itemloadersource.h
+        src/items/itemloadersource.cpp
+        src/items/fixeditemsource.h
+        src/items/fixeditemsource.cpp
+        src/items/itemstore.h
+        src/items/itemstore.cpp
+
+        src/ui/mainwindow.h
+        src/ui/mainwindow.cpp
+        src/ui/itemwidget.h
+        src/ui/itemwidget.cpp
+        src/ui/itemscrollbox.h
+        src/ui/itemscrollbox.cpp
+        src/ui/sensorlistwidget.h
+        src/ui/sensorlistwidget.cpp
+        src/ui/itemcreationdialog.h
+        src/ui/itemcreationdialog.cpp
+        src/ui/itemsettingsdialog.h
+        src/ui/itemsettingsdialog.cpp
+        src/ui/actorsettingsdialog.h
+        src/ui/actorsettingsdialog.cpp
+
+        src/ui/actorwidgets/factoractorwidget.h
+        src/ui/actorwidgets/factoractorwidget.cpp
+        src/ui/actorwidgets/polynomalactorwidget.h
+        src/ui/actorwidgets/polynomalactorwidget.cpp
+        src/ui/actorwidgets/sensoractorwidget.h
+        src/ui/actorwidgets/sensoractorwidget.cpp
+        src/ui/actorwidgets/timeractorwidget.h
+        src/ui/actorwidgets/timeractorwidget.cpp
+        src/ui/actorwidgets/alarmwidget.h
+        src/ui/actorwidgets/alarmwidget.cpp
+        src/ui/actorwidgets/regulatorwdiget.h
+        src/ui/actorwidgets/regulatorwdiget.cpp
+
+        src/ui/itemsettingswidgets/messageitemsettingswidget.h
+        src/ui/itemsettingswidgets/messageitemsettingswidget.cpp
+        src/ui/itemsettingswidgets/relayitemsettingswidget.h
+        src/ui/itemsettingswidgets/relayitemsettingswidget.cpp
+        src/ui/itemsettingswidgets/systemitemsettingswidget.h
+        src/ui/itemsettingswidgets/systemitemsettingswidget.cpp
+)
+
+# Add UI files
+target_sources(SHinterface 
+    PRIVATE
+        src/ui/mainwindow.ui
+        src/ui/itemwidget.ui
+        src/ui/relayscrollbox.ui
+        src/ui/itemcreationdialog.ui
+        src/ui/itemsettingsdialog.ui
+        src/ui/actorsettingsdialog.ui
+        src/ui/actorwidgets/factoractorwidget.ui
+        src/ui/actorwidgets/polynomalactorwidget.ui
+        src/ui/actorwidgets/sensoractorwidget.ui
+        src/ui/actorwidgets/timeractorwidget.ui
+        src/ui/actorwidgets/alarmwidget.ui
+        src/ui/actorwidgets/regulatorwdiget.ui
+        src/ui/itemsettingswidgets/messageitemsettingswidget.ui
+        src/ui/itemsettingswidgets/relayitemsettingswidget.ui
+        src/ui/itemsettingswidgets/systemitemsettingswidget.ui
+)
+
+# Add resource file
+target_sources(SHinterface 
+    PRIVATE
+        resources.qrc
+)
+
+# Link libraries
+target_link_libraries(SHinterface 
+    Qt6::Core
+    Qt6::Gui
+    Qt6::Widgets
+    Qt6::Network
+    Qt6::Multimedia
+    Qt6::SerialPort
+    Qt6::Mqtt
+    ${PIPEWIRE_LIBRARIES}
+    ${LIBNL3_LIBRARIES}
+)
+
+# Add include paths
+include_directories(${PIPEWIRE_INCLUDE_DIRS} ${LIBNL3_INCLUDE_DIRS})

SHinterface.pro

@@ -1,156 +0,0 @@
-#-------------------------------------------------
-#
-# Project created by QtCreator 2017-06-01T22:31:38
-#
-#-------------------------------------------------
-
-QT       += core gui widgets network multimedia
-
-QT += serialport
-
-TARGET = SHinterface
-TEMPLATE = app
-
-INCLUDEPATH += /usr/include/libnl3/
-
-LIBS += -lnl-3 -lnl-genl-3
-
-# The following define makes your compiler emit warnings if you use
-# any feature of Qt which as been marked as deprecated (the exact warnings
-# depend on your compiler). Please consult the documentation of the
-# deprecated API in order to know how to port your code away from it.
-DEFINES += QT_DEPRECATED_WARNINGS
-
-QMAKE_CXXFLAGS += -std=c++17 -O2
-
-SOURCES += \
-    src/actors/factoractor.cpp \
-    src/actors/polynomalactor.cpp \
-    src/broadcast.cpp \
-    src/iomuliplexer.cpp \
-    src/items/messageitem.cpp \
-    src/items/systemitem.cpp \
-    src/ui/actorwidgets/factoractorwidget.cpp \
-    src/ui/itemcreationdialog.cpp \
-    src/ui/itemsettingswidgets/messageitemsettingswidget.cpp \
-    src/mainobject.cpp \
-    src/apgetconnected.cpp \
-    src/ui/actorwidgets/polynomalactorwidget.cpp \
-    src/ui/actorwidgets/sensoractorwidget.cpp \
-    src/ui/actorwidgets/alarmwidget.cpp \
-    src/ui/actorwidgets/timeractorwidget.cpp \
-    src/ui/itemsettingswidgets/relayitemsettingswidget.cpp \
-    src/ui/itemsettingswidgets/systemitemsettingswidget.cpp \
-    src/ui/itemwidget.cpp \
-    src/ui/itemsettingsdialog.cpp \
-    src/ui/itemscrollbox.cpp \
-    src/items/poweritem.cpp \
-    src/ui/actorwidgets/regulatorwdiget.cpp
-
-SOURCES += \
-    src/ui/actorsettingsdialog.cpp \
-    src/ui/mainwindow.cpp \
-    src/ui/sensorlistwidget.cpp
-
-SOURCES += \
-    src/actors/actor.cpp \
-    src/actors/sensoractor.cpp \
-    src/actors/alarmtime.cpp \
-    src/actors/regulator.cpp \
-    src/actors/timeractor.cpp
-
-SOURCES += \
-    src/sensors/sensor.cpp \
-    src/sensors/speakersensor.cpp \
-    src/sensors/sunsensor.cpp \
-    src/sensors/ocupancysensor.cpp
-
-SOURCES += \
-    src/items/relay.cpp \
-    src/items/item.cpp \
-    src/items/itemstore.cpp \
-    src/items/auxitem.cpp \
-    src/items/rgbitem.cpp
-
-SOURCES += \
-    src/alarmactions.cpp \
-    src/main.cpp \
-    src/microcontroller.cpp \
-    src/sun.cpp
-
-
-HEADERS  += \
-    src/actors/factoractor.h \
-    src/actors/polynomalactor.h \
-    src/broadcast.h \
-    src/iomuliplexer.h \
-    src/items/messageitem.h \
-    src/items/systemitem.h \
-    src/ui/actorwidgets/factoractorwidget.h \
-    src/ui/itemcreationdialog.h \
-    src/ui/itemsettingswidgets/messageitemsettingswidget.h \
-    src/mainobject.h \
-    src/apgetconnected.h \
-    src/ui/actorwidgets/alarmwidget.h \
-    src/ui/actorwidgets/polynomalactorwidget.h \
-    src/ui/actorwidgets/sensoractorwidget.h \
-    src/ui/actorwidgets/timeractorwidget.h \
-    src/ui/itemsettingswidgets/relayitemsettingswidget.h \
-    src/ui/itemsettingswidgets/systemitemsettingswidget.h \
-    src/ui/itemwidget.h \
-    src/ui/itemsettingsdialog.h \
-    src/ui/itemscrollbox.h \
-    src/items/poweritem.h \
-    src/ui/actorwidgets/regulatorwdiget.h
-
-HEADERS  += \
-    src/ui/actorsettingsdialog.h \
-    src/ui/mainwindow.h \
-    src/ui/sensorlistwidget.h
-
-HEADERS  += \
-    src/actors/actor.h \
-    src/actors/alarmtime.h \
-    src/actors/sensoractor.h \
-    src/actors/regulator.h \
-    src/actors/timeractor.h
-
-HEADERS  += \
-    src/sensors/sensor.h \
-    src/sensors/speakersensor.h \
-    src/sensors/sunsensor.h \
-    src/sensors/ocupancysensor.h
-
-HEADERS += \
-    src/items/relay.h \
-    src/items/item.h \
-    src/items/itemstore.h \
-    src/items/auxitem.h \
-    src/items/rgbitem.h
-
-HEADERS += \
-    src/alarmactions.h \
-    src/microcontroller.h \
-    src/sun.h
-
-FORMS    += \
-    src/ui/actorwidgets/factoractorwidget.ui \
-    src/ui/itemcreationdialog.ui \
-    src/ui/itemsettingswidgets/messageitemsettingswidget.ui \
-    src/ui/actorsettingsdialog.ui \
-    src/ui/actorwidgets/polynomalactorwidget.ui \
-    src/ui/itemsettingswidgets/relayitemsettingswidget.ui \
-    src/ui/itemsettingswidgets/systemitemsettingswidget.ui \
-    src/ui/mainwindow.ui \
-    src/ui/relayscrollbox.ui \
-    src/ui/actorwidgets/sensoractorwidget.ui \
-    src/ui/actorwidgets/alarmwidget.ui \
-    src/ui/actorwidgets/timeractorwidget.ui \
-    src/ui/itemsettingsdialog.ui \
-    src/ui/itemwidget.ui \
-    src/ui/actorwidgets/regulatorwdiget.ui
-
-android:FORMS += src/ui/mainwindow-android.ui
-
-RESOURCES += \
-    resources.qrc

src/actor.cpp.autosave

@@ -1,100 +0,0 @@
-#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/actors/actor.cpp

@@ -88,7 +88,7 @@ uint8_t Actor::getTriggerValue()
 
 void Actor::onValueChanged(uint8_t value)
 {
-
+	(void)value;
 }
 
 std::shared_ptr<Actor> Actor::createActor(const QString& type)

src/actors/actor.h

@@ -5,7 +5,7 @@
 #include <QString>
 #include <QJsonObject>
 
-#include "../items/item.h"
+#include "items/item.h"
 
 class Actor : public Item
 {

src/actors/alarmtime.cpp

@@ -4,17 +4,17 @@ AlarmTime::AlarmTime(const QDateTime time, QObject *parent) : Actor(parent), tim
 {
 	connect(&timer, SIGNAL(timeout()), this, SLOT(doTick()));
 	timer.setInterval(1000);
-    run();
+	AlarmTime::run();
 }
 
 AlarmTime::~AlarmTime()
 {
-    makeInactive();
+	AlarmTime::makeInactive();
 }
 
 void AlarmTime::run()
 {
-    makeInactive();
+	AlarmTime::makeInactive();
 
 	active = true;
 	timer.start();
@@ -61,7 +61,7 @@ QString AlarmTime::getName() const
 
 void AlarmTime::setRepeat(const uint8_t repeat)
 {
-    repeat_=repeat;
+	repeat_ = repeat;
 	exausted = false;
 }
 

src/actors/factoractor.cpp

@@ -26,8 +26,9 @@ void MultiFactorActor::setValue(uint8_t value)
 		{
 			performAction();
 		}
-        bool exausted = true;
-        for(size_t i = 0; i < getActors().size(); ++i) if(!getActors()[i]->isExausted()) exausted = false;
+		exausted = true;
+		for(size_t i = 0; i < getActors().size(); ++i) if(!getActors()[i]->isExausted())
+			exausted = false;
 	}
 }
 

src/actors/factoractor.h

@@ -29,13 +29,28 @@ public:
 	virtual QString getName() const;
 
 	void setFactorActor(std::shared_ptr<Actor> factorActor);
-    std::shared_ptr<Actor> getFactorActor(){return factorActor_;}
-    void setFactorDirection(const bool direction){factorDirection = direction;}
-    bool getFactorDirection(){return factorDirection;}
-    uint getPreCancleTime(){return preCancleMin_;}
-    void setPreCancleTime(uint minutes){preCancleMin_ = minutes;}
+	std::shared_ptr<Actor> getFactorActor()
+	{
+		return factorActor_;
+	}
+	void setFactorDirection(const bool direction)
+	{
+		factorDirection = direction;
+	}
+	bool getFactorDirection()
+	{
+		return factorDirection;
+	}
+	uint getPreCancleTime()
+	{
+		return preCancleMin_;
+	}
+	void setPreCancleTime(uint minutes)
+	{
+		preCancleMin_ = minutes;
+	}
 
-    virtual ~MultiFactorActor(){}
+	virtual ~MultiFactorActor() {}
 
 	virtual void store(QJsonObject& json);
 	virtual void load(const QJsonObject& json, bool preserve);

src/actors/polynomalactor.cpp

@@ -35,7 +35,8 @@ void PolynomalActor::sensorEvent(Sensor sensor)
 {
 	if(active && sensor == sensor_)
 	{
-        double result = pow3_*(sensor.field*sensor.field*sensor.field)+pow2_*(sensor.field*sensor.field)+pow1_*sensor.field+pow0_;
+		double result = pow3_*(sensor.field*sensor.field*sensor.field)+pow2_*(sensor.field*sensor.field)+pow1_*sensor.field
+		                +pow0_;
 		if(result < 0) result = 0;
 		else if(result > 254) result = 255;
 		if(result != prevValue)sigValue(static_cast<uint8_t>(result));
@@ -76,7 +77,8 @@ QString PolynomalActor::getName() const
 	else
 	{
 		QString string;
-        string = QString::number(pow3_) + "x^3 + " + QString::number(pow2_) + "x^2 + " + QString::number(pow1_) + "x + " + QString::number(pow0_) + " (x: " + sensor_.name + ")";
+		string = QString::number(pow3_) + "x^3 + " + QString::number(pow2_) + "x^2 + " + QString::number(
+		             pow1_) + "x + " + QString::number(pow0_) + " (x: " + sensor_.name + ")";
 		return string;
 	}
 }

src/actors/polynomalactor.h

@@ -1,7 +1,7 @@
 #ifndef POLYNOMALACTOR_H
 #define POLYNOMALACTOR_H
 #include "actor.h"
-#include "../sensors/sensor.h"
+#include "sensors/sensor.h"
 
 class PolynomalActor: public Actor
 {
@@ -28,9 +28,12 @@ public:
 	PolynomalActor(const Sensor sensor, QObject* parent = nullptr);
 	PolynomalActor(QObject* parent = nullptr);
 	void setSensor(const Sensor sensor);
-    Sensor getSensor(){return sensor_;}
+	Sensor getSensor()
+	{
+		return sensor_;
+	}
 	virtual QString getName() const;
-    virtual ~PolynomalActor(){}
+	virtual ~PolynomalActor() {}
 
 	virtual void store(QJsonObject& json);
 	virtual void load(const QJsonObject& json, bool preserve);

src/actors/regulator.cpp

@@ -4,12 +4,16 @@
 
 Regulator::Regulator(const Sensor sensor, QObject* parent): Actor(parent), sensor_(sensor)
 {
-
+	timer.setSingleShot(true);
+	timer.start(timeout_*1000);
+	connect(&timer, &QTimer::timeout, this, &Regulator::timeout);
 }
 
 Regulator::Regulator(QObject* parent): Actor(parent)
 {
-
+	timer.setSingleShot(true);
+	timer.start(timeout_*1000);
+	connect(&timer, &QTimer::timeout, this, &Regulator::timeout);
 }
 
 void Regulator::setSensor(const Sensor sensor)
@@ -21,6 +25,7 @@ void Regulator::sensorEvent(Sensor sensor)
 {
 	if(active && sensor == sensor_)
 	{
+		timer.start(timeout_*1000);
 		if( sensor.field < setPoint_-band_ && (sensor.field < sensor_.field || sensor_.field > setPoint_-band_ || first) )
 		{
 			sigValue(triggerValue);
@@ -34,6 +39,20 @@ void Regulator::sensorEvent(Sensor sensor)
 	}
 }
 
+void Regulator::makeInactive()
+{
+	first = true;
+	if(active)
+		sigValue(!triggerValue);
+	timer.stop();
+	Actor::makeInactive();
+}
+
+void Regulator::timeout()
+{
+	sigValue(safeValue_);
+}
+
 void Regulator::setPoint(float setPoint)
 {
 	setPoint_ = setPoint;
@@ -49,12 +68,25 @@ void Regulator::setInvert( bool invert )
 	invert_ = invert;
 }
 
+void Regulator::setSafeValue(int value)
+{
+	safeValue_ = value;
+}
+
+void Regulator::setTimeout(int value)
+{
+	timeout_ = value;
+	timer.start(timeout_*1000);
+}
+
 void Regulator::store(QJsonObject& json)
 {
 	json["Type"] = "Regulator";
 	Actor::store(json);
 	json["Band"] = band_;
 	json["SetPoint"] = setPoint_;
+	json["SafeValue"] = safeValue_;
+	json["Timeout"] = timeout_;
 	json["SensorType"] = static_cast<int>(sensor_.type);
 	json["SensorId"] = static_cast<int>(sensor_.id);
 	json["SensorField"] = sensor_.field;
@@ -66,15 +98,21 @@ void Regulator::load(const QJsonObject& json, bool preserve)
 	Actor::load(json, preserve);
 	band_ = json["Band"].toDouble(1);
 	setPoint_ = json["SetPoint"].toDouble(22);
+	safeValue_ = json["SafeValue"].toDouble(0);
+	timeout_ = json["Timeout"].toDouble(1800);
 	sensor_.type = json["SensorType"].toInt(0);
 	sensor_.id = json["SensorId"].toInt(0);
 	sensor_.field = json["SensorField"].toInt(0);
 	sensor_.name = json["SensorName"].toString("Sensor");
+	timer.start(timeout_*1000);
 }
 
 QString Regulator::getName() const
 {
-    if(name_.size() > 0) return name_;
+	if(name_.size() > 0)
+	{
+		return name_;
+	}
 	else
 	{
 		QString string;

src/actors/regulator.h

@@ -1,6 +1,9 @@
 #pragma once
+
+#include <QTimer>
+
 #include "actor.h"
-#include "../sensors/sensor.h"
+#include "sensors/sensor.h"
 
 class Regulator : public Actor
 {
@@ -11,27 +14,54 @@ private:
 	float setPoint_ = 0;
 	float band_ = 1;
 	bool invert_ = false;
+	int timeout_ = 1800;
+	int safeValue_ = 0;
+	QTimer timer;
 
 	bool first = true;
 
+private slots:
+
+	void timeout();
+
 public slots:
 
 	void sensorEvent(Sensor sensor);
 
 	void setSensor(const Sensor sensor);
-    void setPoint( float setPoint );
-    void setBand ( float band );
-    void setInvert( bool invert );
+	void setPoint(float setPoint );
+	void setBand (float band );
+	void setInvert(bool invert );
+	void setSafeValue(int value);
+	void setTimeout(int value);
+	virtual void makeInactive() override;
 
 public:
 
-    float getBand() {return  band_;}
-    float getSetPoint() {return  setPoint_;}
+	float getBand()
+	{
+		return  band_;
+	}
+	float getSetPoint()
+	{
+		return  setPoint_;
+	}
+	int getSafeValue()
+	{
+		return safeValue_;
+	}
+	int getTimeout()
+	{
+		return timeout_;
+	}
 	Regulator(const Sensor sensor, QObject* parent = nullptr);
 	Regulator(QObject* parent = nullptr);
-    Sensor getSensor(){return sensor_;}
+	Sensor getSensor()
+	{
+		return sensor_;
+	}
 	virtual QString getName() const;
-    virtual ~Regulator(){}    
+	virtual ~Regulator() {}
 
 	virtual void store(QJsonObject& json);
 	virtual void load(const QJsonObject& json, bool preserve);

src/actors/sensoractor.cpp

@@ -21,8 +21,10 @@ void SensorActor::sensorEvent(Sensor sensor)
 {
 	if(sensor == sensor_)
 	{
-        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();
+		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;
 	}
 }

src/actors/sensoractor.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "actor.h"
-#include "../sensors/sensor.h"
+#include "sensors/sensor.h"
 
 class SensorActor : public Actor
 {
@@ -28,9 +28,12 @@ public:
 
 	SensorActor(const Sensor sensor, QObject* parent = nullptr);
 	SensorActor(QObject* parent = nullptr);
-    Sensor getSensor(){return sensor_;}
+	Sensor getSensor()
+	{
+		return sensor_;
+	}
 	virtual QString getName() const;
-    virtual ~SensorActor(){}
+	virtual ~SensorActor() {}
 
 	float getThreshold();
 	uint8_t getSloap();

src/alarmactions.cpp

@@ -1,14 +0,0 @@
-#include "alarmactions.h"
-#include <QProcess>
-
-AlarmActions::AlarmActions(QApplication* a, Microcontroller* micro, QObject *parent) : QObject(parent), _micro(micro), a_(a)
-{
-
-}
-
-void AlarmActions::syncoff()
-{
-    qDebug()<<"syncoff";
-    QProcess::execute ( "syncoff" );
-    a_->exit(0);
-}

src/alarmactions.h

@@ -1,25 +0,0 @@
-#ifndef POWER_H
-#define POWER_H
-
-#include <QApplication>
-#include "microcontroller.h"
-
-class AlarmActions : public QObject
-{
-private:
-    Q_OBJECT
-    Microcontroller* _micro;
-    QApplication* a_;
-
-public:
-    explicit AlarmActions(QApplication* a, Microcontroller* micro, QObject *parent = nullptr);
-
-signals:
-
-public slots:
-
-    void syncoff();
-
-};
-
-#endif // POWER_H

src/apgetconnected.cpp

@@ -53,6 +53,8 @@ static int nl80211Init(struct nl_sock* nl_sock, int* nl80211_id)
 
 static int errorHandler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg)
 {
+	(void)nla;
+	(void)err;
 	printf("netlink error\n");
 	*reinterpret_cast<int*>(arg) = 0;
 	return NL_STOP;
@@ -60,12 +62,14 @@ static int errorHandler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg
 
 static int finishHandler(struct nl_msg *msg, void *arg)
 {
+	(void)msg;
 	*reinterpret_cast<int*>(arg) = 0;
 	return NL_SKIP;
 }
 
 static int ackHandler(struct nl_msg *msg, void *arg)
 {
+	(void)msg;
 	*reinterpret_cast<int*>(arg) = 0;
 	return NL_STOP;
 }
@@ -150,7 +154,7 @@ std::vector<uint64_t> connectedDevices(const std::string& ifDevice, int& error)
 		}
 	}
 
-    nla_put_failure:
+nla_put_failure:
 	nl_cb_put(cb);
 	nl_cb_put(s_cb);
 	nlmsg_free(msg);

src/apgetconnected.h

@@ -6,14 +6,14 @@
 
 namespace ap
 {
-    enum ERRORS
-    {
+enum ERRORS
+{
 	SUCESS,
 	ERR_INIT,
 	ERR_NO_DEV,
 	ERR_ALLOC,
 	ERR_GENERAL
-    };
-    std::vector<uint64_t> connectedDevices(const std::string& ifDevice, int& error);
-    std::string macAddrToString(uint64_t macAddr);
+};
+std::vector<uint64_t> connectedDevices(const std::string& ifDevice, int& error);
+std::string macAddrToString(uint64_t macAddr);
 }

src/broadcast.cpp

@@ -1,134 +0,0 @@
-#include "broadcast.h"
-#include <QJsonDocument>
-#include <QJsonObject>
-#include <QJsonArray>
-#include <QDebug>
-
-BroadCast::BroadCast(QIODevice* const iodevice, bool master ):  master_(master), 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');
-        }
-    }
-    mBuffer.push_back('\n');
-    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);
-    QByteArray buffer("JSON: ");
-    buffer.append(jsonDocument.toJson());
-    write(buffer);
-}
-
-void BroadCast::sendSensors()
-{
-    if(iodevice_)for(auto& sensor: *globalSensors.getSensors())
-    {
-        iodevice_->write("bcst: "+sensor.toString().toLatin1()+'\n');
-    }
-}
-
-void BroadCast::requestSensors()
-{
-    if(iodevice_)iodevice_->write("bcst: GETSENSORS\n");
-}
-
-void BroadCast::requestJson()
-{
-    if(iodevice_)iodevice_->write("bcst: GETJSN\n");
-}
-
-void BroadCast::decodeMaster(const QByteArray& buffer)
-{
-    if(buffer.startsWith("GETJSN"))
-    {
-        qDebug()<<"json requested";
-        jsonRequested();
-    }
-    else if(buffer.startsWith("GETSENSORS") )
-    {
-        qDebug()<<"sensors requested";
-        sendSensors();
-    }
-}
-
-void BroadCast::decode(QByteArray buffer)
-{
-    qDebug()<<"decodeing: "<<buffer;
-    if(buffer.size() >= 6 && buffer[0] == 'J' && buffer[1] == 'S' && buffer[2] == 'O' && buffer[3] == 'N' && buffer[4] == ':')
-    {
-        qDebug()<<"got json";
-        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);
-            }
-        }
-
-        QJsonParseError error;
-        QJsonDocument document = QJsonDocument::fromJson(buffer, &error);
-
-        qDebug()<<"JSON:";
-        qDebug()<<document.toJson().data();
-        QJsonObject jsonObject = document.object();
-        if(error.error == QJsonParseError::NoError && !document.isEmpty() && !jsonObject.isEmpty()) gotJson(jsonObject);
-        else
-        {
-            qDebug()<<error.errorString();
-        }
-    }
-    else if(buffer.size() >= 6 && buffer[0] == 'S' && buffer[1] == 'E' && buffer[2] == 'N' && buffer[3] == 'S' && buffer[4] == 'O' && buffer[5] == 'R')
-    {
-        Sensor sensor = Sensor::sensorFromString(buffer);
-        if(sensor.type != Sensor::TYPE_DUMMY) gotSensorState(sensor);
-    }
-}
-
-void BroadCast::sendMessage(const QString &title, const QString &body)
-{
-    write(QByteArray("MESG ") + title.toLatin1() + " BODY " + body.toLatin1());
-}
-
-void BroadCast::readyRead()
-{
-    buffer_.append(iodevice_->readAll());
-    int newlineIndex = buffer_.indexOf('\n');
-    while( newlineIndex != -1 )
-    {
-        if(buffer_.startsWith("bcst: "))
-        {
-            QByteArray tmp = buffer_.mid(6,newlineIndex-6);
-            decode(tmp);
-            if(master_)decodeMaster(tmp);
-        }
-        buffer_.remove(0, newlineIndex+1);
-        newlineIndex = buffer_.indexOf('\n');
-    }
-}

src/broadcast.h

@@ -1,55 +0,0 @@
-#ifndef BROADCAST_H
-#define BROADCAST_H
-#include <QIODevice>
-#include <QObject>
-#include <QString>
-#include <QJsonObject>
-#include "sensors/sensor.h"
-
-class BroadCast: public QObject
-{
-    Q_OBJECT
-
-private:
-
-    bool master_;
-
-    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(QByteArray buffer);
-    void decodeMaster(const QByteArray& buffer);
-
-private slots:
-
-    void readyRead();
-
-public slots:
-
-    void requestJson();
-    void requestSensors();
-
-signals:
-
-    void jsonRequested();
-    void gotJson(QJsonObject json);
-    void gotSensorState(Sensor sensor);
-
-public:
-
-    BroadCast(QIODevice* const iodevice = nullptr, bool master = true);
-    void sendJson(const QJsonObject& json);
-    void sendSensors();
-    void sendMessage(const QString& title, const QString& body);
-
-};
-
-#endif // BROADCAST_H
-

src/iomuliplexer.cpp

@@ -1,76 +0,0 @@
-#include "iomuliplexer.h"
-#include<QDebug>
-
-VirutalIODevice::VirutalIODevice(QObject* parent): QBuffer(parent)
-{
-
-}
-
-qint64 VirutalIODevice::writeData(const char *data, qint64 len)
-{
-    blockSignals(true);
-    qint64 ret = QBuffer::writeData(data, len);
-    blockSignals(false);
-    masterReadyRead();
-    return ret;
-}
-
-qint64 VirutalIODevice::masterWrite(const QByteArray &byteArray)
-{
-    return masterWrite(byteArray.data(), byteArray.length());
-}
-
-qint64 VirutalIODevice::masterWrite(const char *data, qint64 maxSize)
-{
-    blockSignals(true);
-    qint64 ret = QBuffer::writeData(data, maxSize);
-    blockSignals(false);
-    readyRead();
-    return ret;
-}
-
-IoMuliplexer::IoMuliplexer(QIODevice* mainDevice, QObject* Parent): IoMuliplexer(Parent)
-{
-    setIoDevice(mainDevice);
-}
-
-IoMuliplexer::IoMuliplexer(QObject* Parent): QObject(Parent)
-{
-
-}
-
-IoMuliplexer::~IoMuliplexer()
-{
-    for(size_t i = 0; i < ioDevices_.size(); ++i) delete ioDevices_[i];
-    ioDevices_.clear();
-}
-
-void IoMuliplexer::setIoDevice(QIODevice* mainDevice)
-{
-    mainDevice_ = mainDevice;
-    connect(mainDevice_, &QIODevice::readyRead, this, &IoMuliplexer::mainIsReadyRead);
-}
-
-QIODevice* IoMuliplexer::getIoDevice()
-{
-    ioDevices_.push_back(new VirutalIODevice);
-    ioDevices_.back()->open(QIODevice::ReadWrite);
-    connect(ioDevices_.back(), &VirutalIODevice::masterReadyRead, this, &IoMuliplexer::clientIsReadyRead);
-    return ioDevices_.back();
-}
-
-void IoMuliplexer::clientIsReadyRead()
-{
-    VirutalIODevice* device = dynamic_cast<VirutalIODevice*>(sender());
-    if(device)
-    {
-        QByteArray array = device->readAll();
-        mainDevice_->write(array);
-    }
-}
-
-void IoMuliplexer::mainIsReadyRead()
-{
-    QByteArray array = mainDevice_->readAll();
-    for(size_t i = 0; i < ioDevices_.size(); ++i) ioDevices_[i]->masterWrite(array);
-}

src/iomuliplexer.h

@@ -1,54 +0,0 @@
-#ifndef IOMULIPLEXER_H
-#define IOMULIPLEXER_H
-
-#include <QObject>
-#include <vector>
-#include <QIODevice>
-#include <QBuffer>
-
-class VirutalIODevice: public QBuffer
-{
-    Q_OBJECT
-public:
-
-    VirutalIODevice(QObject* parent = nullptr);
-    virtual ~VirutalIODevice() override {}
-
-    virtual qint64 writeData(const char *data, qint64 len) override;
-
-    qint64 masterWrite(const QByteArray &byteArray);
-    qint64 masterWrite(const char *data, qint64 maxSize);
-
-signals:
-
-    void masterReadyRead();
-
-};
-
-
-class IoMuliplexer: public QObject
-{
-    Q_OBJECT
-private:
-
-    QIODevice* mainDevice_;
-    std::vector< VirutalIODevice* > ioDevices_;
-
-public:
-    explicit IoMuliplexer(QIODevice* mainDevice, QObject* Parent = nullptr);
-    explicit IoMuliplexer(QObject* Parent = nullptr);
-
-    ~IoMuliplexer();
-
-    void setIoDevice(QIODevice* mainDevice);
-
-    QIODevice* getIoDevice();
-
-private slots:
-
-    void mainIsReadyRead();
-    void clientIsReadyRead();
-
-};
-
-#endif // IOMULIPLEXER_H

src/items/auxitem.cpp

@@ -1,13 +1,14 @@
 #include "auxitem.h"
 
-AuxItem::AuxItem(Microcontroller* micro, uint32_t itemIdIn, QString name,  uint8_t value, QObject* parent): Item(itemIdIn, name, value, parent), micro_(micro)
+AuxItem::AuxItem(Microcontroller* micro, uint32_t itemIdIn, QString name,  uint8_t value,
+                 QObject* parent): Item(itemIdIn, name, value, parent), micro_(micro)
 {
-
+	type_ = ITEM_VALUE_UINT;
 }
 
-void AuxItem::setValue(uint8_t value)
+void AuxItem::enactValue(uint8_t value)
 {
-    Item::setValue(value);
+	assert(micro_);
 	micro_->setAuxPwm(value);
 }
 

src/items/auxitem.h

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

src/items/fixeditemsource.cpp

@@ -0,0 +1,14 @@
+#include "fixeditemsource.h"
+
+FixedItemSource::FixedItemSource(Microcontroller* micro, QObject *parent):
+	ItemSource{parent},
+	powerItem(new PowerItem(5487423)),
+	rgbItem(new RgbItem(micro, 5487422, "Rgb Lights")),
+	auxItem(new AuxItem(micro, 5487421, "Desk Light"))
+{
+}
+
+void FixedItemSource::refresh()
+{
+	gotItems({powerItem, rgbItem, auxItem});
+}

src/items/fixeditemsource.h

@@ -0,0 +1,22 @@
+#ifndef FIXEDITEMSOURCE_H
+#define FIXEDITEMSOURCE_H
+
+#include "itemsource.h"
+#include "poweritem.h"
+#include "rgbitem.h"
+#include "auxitem.h"
+#include "microcontroller.h"
+
+class FixedItemSource : public ItemSource
+{
+	Q_OBJECT
+	std::shared_ptr<PowerItem> powerItem;
+	std::shared_ptr<RgbItem> rgbItem;
+	std::shared_ptr<AuxItem> auxItem;
+
+public:
+	explicit FixedItemSource(Microcontroller* micro, QObject *parent = nullptr);
+	virtual void refresh() override;
+};
+
+#endif // FIXEDITEMSOURCE_H

src/items/item.cpp

@@ -1,14 +1,20 @@
 #include "item.h"
 
+#include "actors/sensoractor.h"
+#include "actors/regulator.h"
+#include "actors/polynomalactor.h"
+#include "programmode.h"
 #include "relay.h"
-#include "../microcontroller.h"
-#include "../actors/sensoractor.h"
-#include "../actors/regulator.h"
-#include "../actors/polynomalactor.h"
+#include "messageitem.h"
+#include "systemitem.h"
+#include "auxitem.h"
+#include "poweritem.h"
+#include "rgbitem.h"
 
 #include <QJsonArray>
 
-ItemData::ItemData(uint32_t itemIdIn, QString name, uint8_t value): name_(name), value_(value), itemId_(itemIdIn)
+ItemData::ItemData(uint32_t itemIdIn, QString name, uint8_t value, bool loaded, bool hidden, item_value_type_t type):
+	name_(name), value_(value), itemId_(itemIdIn), loaded_(loaded), hidden_(hidden), type_(type)
 {
 
 }
@@ -33,12 +39,65 @@ uint32_t ItemData::id() const
 	return  itemId_;
 }
 
+void ItemData::store(QJsonObject &json)
+{
+	json["Name"] = name_;
+	json["ItemId"] = static_cast<double>(itemId_);
+	json["Value"] = static_cast<double>(value_);
+}
+
+void ItemData::load(const QJsonObject &json, const bool preserve)
+{
+	if(!preserve)
+	{
+		name_ = json["Name"].toString(name_);
+		itemId_ = static_cast<uint32_t>(json["ItemId"].toDouble(0));
+		value_ = json["Value"].toInt();
+	}
+}
+
+bool ItemData::getLoaded() const
+{
+	return loaded_;
+}
+
+void ItemData::setLoaded(bool loaded)
+{
+	loaded_ = loaded;
+}
+
+bool ItemData::hasChanged(const ItemData& other)
+{
+	if(other != *this)
+		return false;
+	if(other.getName() != getName())
+		return true;
+	if(other.getValue() != getValue())
+		return true;
+	if(other.getLoaded() != getLoaded())
+		return true;
+	return false;
+}
+
+bool ItemData::isHidden()
+{
+	return hidden_;
+}
+
+void ItemData::setHidden(bool hidden)
+{
+	hidden_ = hidden;
+}
+
+item_value_type_t ItemData::getValueType()
+{
+	return type_;
+}
 
 //item
 
-bool Item::secondaryFlag = false;
-
-Item::Item(uint32_t itemIdIn, QString name, uint8_t value,  QObject *parent): QObject(parent), ItemData (itemIdIn, name, value)
+Item::Item(uint32_t itemIdIn, QString name, uint8_t value,  QObject *parent): QObject(parent), ItemData (itemIdIn, name,
+	        value)
 {
 
 }
@@ -54,8 +113,7 @@ Item::~Item()
 
 void Item::store(QJsonObject &json)
 {
-    json["Name"] = name_;
-    json["ItemId"] = static_cast<double>(itemId_);
+	ItemData::store(json);
 	json["override"] = override_;
 	QJsonArray actorsArray;
 	for(size_t i = 0; i < actors_.size(); ++i)
@@ -72,11 +130,7 @@ void Item::store(QJsonObject &json)
 
 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));
-    }
+	ItemData::load(json, preserve);
 	override_ = json["override"].toBool(false);
 	const QJsonArray actorsArray(json["Actors"].toArray(QJsonArray()));
 	for(int i = 0; i < actorsArray.size(); ++i)
@@ -84,45 +138,60 @@ void Item::load(const QJsonObject &json, const bool preserve)
 		if(actorsArray[i].isObject())
 		{
 			std::shared_ptr<Actor> actor = Actor::loadActor(actorsArray[i].toObject());
-            if(actor != nullptr) addActor(actor);
+			if(actor != nullptr)
+				addActor(actor);
 		}
 	}
 }
 
 void Item::actorSetValue(uint8_t value)
 {
-    if(!override_) setValue(value);
+	if(!override_ && (programMode == PROGRAM_MODE_PRIMARY || programMode == PROGRAM_MODE_HEADLESS_PRIMARY))
+		setValue(value);
 }
 
 void Item::setValue(uint8_t value)
 {
-    value_ = value;
-    valueChanged(value_);
+	qDebug()<<__func__;
+	informValue(value);
+	if(programMode == PROGRAM_MODE_PRIMARY || programMode == PROGRAM_MODE_HEADLESS_PRIMARY)
+		enactValue(value);
 }
 
 void Item::informValue(uint8_t value)
 {
-    Item::setValue(value);
+	if(value_ != value)
+	{
+		value_ = value;
+		valueChanged(value_);
+		updated(*this);
+	}
+}
+
+void Item::enactValue(uint8_t value)
+{
+	(void)value;
 }
 
 void Item::addActor(std::shared_ptr<Actor> actor)
 {
 	actor->setParent(this);
 	actors_.push_back(actor);
-    if(!secondaryFlag)
-    {
+	if(programMode == PROGRAM_MODE_PRIMARY || programMode == PROGRAM_MODE_HEADLESS_PRIMARY)
 		connect(actor.get(), &Actor::sigValue, this, &Item::actorSetValue);
-    }
 	connect(this, &Item::valueChanged, actor.get(), &Actor::onValueChanged);
 
 	std::shared_ptr<SensorActor> sensorActor = std::dynamic_pointer_cast<SensorActor>(actor);
-    if(sensorActor)connect(&globalSensors, &SensorStore::sensorChangedState, sensorActor.get(), &SensorActor::sensorEvent);
+	if(sensorActor)
+		connect(&globalSensors, &SensorStore::sensorChangedState, sensorActor.get(), &SensorActor::sensorEvent);
 
 	std::shared_ptr<Regulator> regulator = std::dynamic_pointer_cast<Regulator>(actor);
-    if(regulator)connect(&globalSensors, &SensorStore::sensorChangedState, regulator.get(), &Regulator::sensorEvent);
+	if(regulator)
+		connect(&globalSensors, &SensorStore::sensorChangedState, regulator.get(), &Regulator::sensorEvent);
 
 	std::shared_ptr<PolynomalActor> polynomalActor = std::dynamic_pointer_cast<PolynomalActor>(actor);
-    if(polynomalActor != nullptr )connect(&globalSensors, &SensorStore::sensorChangedState, polynomalActor.get(), &PolynomalActor::sensorEvent);
+	if(polynomalActor != nullptr )
+		connect(&globalSensors, &SensorStore::sensorChangedState, polynomalActor.get(), &PolynomalActor::sensorEvent);
 }
 
 bool Item::removeActor(std::shared_ptr<Actor> actor)
@@ -165,5 +234,50 @@ bool Item::hasActors()
 
 void Item::setActorsActive(bool in)
 {
-    for(unsigned i = 0; i < actors_.size(); i++) in ? actors_[i]->makeActive() : actors_[i]->makeInactive();
+	for(unsigned i = 0; i < actors_.size(); i++)
+		in ? actors_[i]->makeActive() : actors_[i]->makeInactive();
 }
+
+void Item::mergeLoaded(Item& item)
+{
+	name_ = item.name_;
+	actors_.clear();
+	for(std::shared_ptr<Actor> actor : item.actors_)
+		addActor(actor);
+}
+
+std::shared_ptr<Item> Item::loadItem(const QJsonObject& json)
+{
+	std::shared_ptr<Item> newItem = nullptr;
+	if(json["Type"].toString("") == "Relay")
+	{
+		newItem = std::shared_ptr<Relay>(new Relay);
+	}
+	else if(json["Type"].toString("") == "Message")
+	{
+		newItem = std::shared_ptr<MessageItem>(new MessageItem);
+	}
+	else if(json["Type"].toString("") == "System")
+	{
+		newItem = std::shared_ptr<SystemItem>(new SystemItem);
+	}
+	else if(json["Type"].toString("") == "Aux")
+	{
+		newItem = std::shared_ptr<AuxItem>(new AuxItem);
+	}
+	else if(json["Type"].toString("") == "Power")
+	{
+		newItem = std::shared_ptr<PowerItem>(new PowerItem);
+	}
+	else if(json["Type"].toString("") == "Rgb")
+	{
+		newItem = std::shared_ptr<RgbItem>(new RgbItem);
+	}
+	if(newItem)
+	{
+		newItem->load(json);
+		newItem->setLoaded(true);
+	}
+	return newItem;
+}
+

src/items/item.h

@@ -8,25 +8,52 @@
 
 class Actor;
 
+typedef enum {
+	ITEM_VALUE_BOOL = 0,
+	ITEM_VALUE_UINT,
+	ITEM_VALUE_NO_VALUE
+} item_value_type_t;
+
 class ItemData
 {
 protected:
 	QString name_;
 	uint8_t value_;
 	uint32_t itemId_;
+	bool loaded_;
+	bool hidden_;
+	item_value_type_t type_;
 
 public:
+	ItemData(uint32_t itemIdIn = QRandomGenerator::global()->generate(),
+			 QString name = "Item",
+			 uint8_t value = 0,
+			 bool loaded = false,
+			 bool hidden = false,
+			 item_value_type_t type = ITEM_VALUE_BOOL);
 
-    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_; }
+	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;
 
+	bool hasChanged(const ItemData& other);
 	void setName(QString name);
 	uint8_t getValue() const;
+	bool getLoaded() const;
+	void setLoaded(bool loaded);
+	bool isHidden();
+	void setHidden(bool hidden);
+	item_value_type_t getValueType();
 	virtual QString getName() const;
+	virtual void store(QJsonObject& json);
+	virtual void load(const QJsonObject& json, const bool preserve = false);
 };
 
 
@@ -38,24 +65,20 @@ private:
 
 	bool override_ = false;
 
-public:
-
-    static bool secondaryFlag;
-
 signals:
-
 	void valueChanged(uint8_t value);
+	void updated(ItemData data);
 
 private slots:
 	virtual void actorSetValue(uint8_t value);
 
 public slots:
-
-    virtual void setValue(uint8_t value);
+	void setValue(uint8_t value);
 
 public:
 
-    Item(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0,  QObject *parent = nullptr);
+	Item(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0,
+	     QObject *parent = nullptr);
 	Item(const ItemData& itemData,  QObject *parent = nullptr);
 
 	virtual ~Item();
@@ -69,9 +92,15 @@ public:
 	void setOverride(const bool in);
 	bool getOverride();
 	void informValue(uint8_t value);
+	void mergeLoaded(Item& item);
 
 	virtual void store(QJsonObject& json);
 	virtual void load(const QJsonObject& json, const bool preserve = false);
 
+	static std::shared_ptr<Item> loadItem(const QJsonObject& json);
+
+protected:
+	virtual void enactValue(uint8_t value);
+
 };
 

src/items/itemloadersource.cpp

@@ -0,0 +1,38 @@
+#include "itemloadersource.h"
+
+#include <QJsonArray>
+
+ItemLoaderSource::ItemLoaderSource(const QJsonObject& json, QObject *parent):
+	ItemSource{parent},
+	json(json)
+{
+}
+
+void ItemLoaderSource::refresh()
+{
+	std::vector<std::shared_ptr<Item>> items;
+	const QJsonArray itemsArray(json["Items"].toArray());
+	for(int i = 0; i < itemsArray.size(); ++i)
+	{
+		if(!itemsArray[i].isObject())
+			continue;
+
+		const QJsonObject itemObject = itemsArray[i].toObject();
+		std::shared_ptr<Item> newItem = Item::loadItem(itemObject);
+		if(newItem)
+		{
+			items.push_back(newItem);
+			qDebug()<<"Loaded item"<<newItem->getName();
+		}
+	}
+	gotItems(items);
+}
+
+void ItemLoaderSource::updateJson(const QJsonObject& json)
+{
+	this->json = json;
+}
+
+ItemLoaderSource::~ItemLoaderSource()
+{}
+

src/items/itemloadersource.h

@@ -0,0 +1,21 @@
+#ifndef ITEMLOADERSOURCE_H
+#define ITEMLOADERSOURCE_H
+
+#include <QJsonObject>
+
+#include "itemsource.h"
+
+class ItemLoaderSource : public ItemSource
+{
+	Q_OBJECT
+
+	QJsonObject json;
+
+public:
+	explicit ItemLoaderSource(const QJsonObject& json = QJsonObject(), QObject *parent = nullptr);
+	~ItemLoaderSource();
+	void updateJson(const QJsonObject& json);
+	virtual void refresh() override;
+};
+
+#endif // ITEMLOADERSOURCE_H

src/items/itemsource.cpp

@@ -0,0 +1,5 @@
+#include "itemsource.h"
+
+ItemSource::ItemSource(QObject *parent)
+	: QObject{parent}
+{}

src/items/itemsource.h

@@ -0,0 +1,25 @@
+#ifndef ITEMSOURCE_H
+#define ITEMSOURCE_H
+
+#include <QObject>
+#include <vector>
+#include <memory>
+
+#include "item.h"
+
+class ItemSource : public QObject
+{
+	Q_OBJECT
+public:
+	explicit ItemSource(QObject *parent = nullptr);
+
+public slots:
+	virtual void refresh() = 0;
+
+signals:
+	void gotItems(std::vector<std::shared_ptr<Item>> items, bool inform = true);
+	void requestReplaceItems(std::vector<std::shared_ptr<Item>> items);
+	void updateItems(std::vector<ItemData> items, bool inform = true);
+};
+
+#endif // ITEMSOURCE_H

src/items/itemstore.cpp

@@ -1,52 +1,42 @@
 #include "itemstore.h"
-#include "relay.h"
-#include "messageitem.h"
-#include "systemitem.h"
 #include <QJsonArray>
+#include <typeinfo>
 
 ItemStore::ItemStore(QObject *parent): QObject(parent)
 {
 }
 
-void ItemStore::addItem(std::shared_ptr<Item> item)
+void ItemStore::addItem(std::shared_ptr<Item> item, bool inform)
 {
-    bool mached = false;
-    for(unsigned i = 0; i < items_.size(); i++ ) if(*items_[i] == *item) mached = true;
-    if(!mached)
+	std::shared_ptr<Item> matched = nullptr;
+	for(unsigned i = 0; i < items_.size(); i++ )
+	{
+		if(*items_[i] == *item)
+		{
+			matched = items_[i];
+			break;
+		}
+	}
+	if(!matched)
 	{
 		items_.push_back(std::shared_ptr<Item>(item));
+		connect(item.get(), &Item::updated, this, &ItemStore::itemUpdateSlot);
+		qDebug()<<"Item"<<item->getName()<<"added"<<(item->getLoaded() ? "from loaded" : "");
 		itemAdded(std::weak_ptr<Item>(items_.back()));
 	}
+	else
+	{
+		if(item->getLoaded())
+			matched->mergeLoaded(*item);
+		else if(item->getValue() != matched->getValue())
+			updateItem(*item, inform);
+	}
 }
 
-void ItemStore::addItems(const std::vector<std::shared_ptr<Item>>& itemIn)
+void ItemStore::addItems(const std::vector<std::shared_ptr<Item>>& itemIn, bool inform)
 {
-    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]);
-
+	for(unsigned j = 0; j < itemIn.size(); j++)
+		addItem(itemIn[j], inform);
 }
 
 void ItemStore::removeItem(const ItemData& item)
@@ -55,12 +45,26 @@ void ItemStore::removeItem(const ItemData& item)
 	{
 		if(item == *items_[j])
 		{
+			qDebug()<<"Item"<<item.getName()<<"deleted";
+			itemDeleted(*items_[j]);
 			items_.erase(items_.begin()+j);
 			--j;
 		}
 	}
 }
 
+void ItemStore::replaceItems(const std::vector<std::shared_ptr<Item>>& items)
+{
+	addItems(items, true);
+	std::vector<ItemData> deletedItems;
+	for(std::shared_ptr<Item> item : items_)
+	{
+		if(std::find_if(items.begin(), items.end(), [item](const std::shared_ptr<Item> other){return *item == *other;}) == items.end())
+			deletedItems.push_back(*item);
+	}
+	for(const ItemData& item : deletedItems)
+		removeItem(item);
+}
 
 void ItemStore::clear()
 {
@@ -69,19 +73,33 @@ void ItemStore::clear()
 }
 
 
-void ItemStore::itemStateChanged(const ItemData& item)
+void ItemStore::updateItems(std::vector<ItemData> items, bool inform)
 {
+	for(const ItemData& item : items)
+		updateItem(item, inform);
+}
 
+void ItemStore::updateItem(const ItemData& item, bool inform)
+{
 	for(unsigned i = 0; i < items_.size(); i++ )
 	{
 		if(items_[i]->operator==(item))
 		{
-
-            if(items_[i]->getValue() != item.getValue())items_[i]->informValue(item.getValue());
+			if(items_[i]->hasChanged(item))
+			{
+				if(items_[i]->getValue() != item.getValue())
+				{
+					items_[i]->setLoaded(false);
+					if(inform)
+						items_[i]->informValue(item.getValue());
+					else
+						items_[i]->setValue(item.getValue());
+				}
+				qDebug()<<"Item"<<items_[i]->getName()<<"updated";
+				itemUpdated(items_[i]);
+			}
 		}
-
 	}
-
 }
 
 void ItemStore::store(QJsonObject& json)
@@ -96,35 +114,41 @@ void ItemStore::store(QJsonObject& json)
 	json["Items"] = itemsArray;
 }
 
-void ItemStore::load(const QJsonObject& json)
+void ItemStore::itemUpdateSlot(ItemData data)
 {
-    const QJsonArray itemsArray(json["Items"].toArray(QJsonArray()));
-    for(int i = 0; i < itemsArray.size(); ++i)
+	for(std::shared_ptr<Item>& item: items_)
 	{
-        if(itemsArray[i].isObject())
-        {
-            const QJsonObject itemObject = itemsArray[i].toObject();
-            std::shared_ptr<Item> newItem;
-            if(itemObject["Type"].toString("") == "Relay")
-            {
-                newItem = std::shared_ptr<Relay>(new Relay());
-            }
-            else if(itemObject["Type"].toString("") == "Message")
-            {
-                newItem = std::shared_ptr<MessageItem>(new MessageItem);
-            }
-            else if(itemObject["Type"].toString("") == "System")
-            {
-                newItem = std::shared_ptr<SystemItem>(new SystemItem());
-            }
-            else if(itemObject["Type"].toString("") == "Aux")
-            {
-            }
-            if(newItem)
-            {
-                newItem->load(itemObject);
-                addItem(newItem);
-            }
-        }
+		if(*item == data)
+			itemUpdated(std::weak_ptr<Item>(item));
 	}
 }
+
+std::shared_ptr<Item> ItemStore::getItem(uint32_t id)
+{
+	for(std::shared_ptr<Item>& item : items_)
+	{
+		if(item->id() == id)
+			return item;
+	}
+	return nullptr;
+}
+
+void ItemStore::registerItemSource(ItemSource* source)
+{
+	qDebug()<<__func__<<typeid(*source).name();
+	connect(source, &ItemSource::gotItems, this, &ItemStore::addItems);
+	connect(source, &ItemSource::updateItems, this, &ItemStore::updateItems);
+	connect(source, &ItemSource::requestReplaceItems, this, &ItemStore::replaceItems);
+	connect(this, &ItemStore::sigRefresh, source, &ItemSource::refresh);
+}
+
+void ItemStore::refresh()
+{
+	for(std::shared_ptr<Item>& item : items_)
+		itemDeleted(*item);
+	items_.clear();
+	sigRefresh();
+}
+
+ItemStore globalItems;
+

src/items/itemstore.h

@@ -2,7 +2,7 @@
 #include <vector>
 #include <memory>
 #include "item.h"
-#include "../sensors/sensor.h"
+#include "itemsource.h"
 
 #include <QJsonObject>
 
@@ -10,17 +10,22 @@ class ItemStore: public QObject
 {
 	Q_OBJECT
 private:
-    std::vector< std::shared_ptr<Item> > items_;
+	std::vector<std::shared_ptr<Item> > items_;
 
 public:
 
 	ItemStore(QObject *parent = nullptr);
-    virtual ~ItemStore(){}
+	virtual ~ItemStore() {}
 
-    inline std::vector< std::shared_ptr<Item> >* getItems(){ return &items_; }
+	inline std::vector< std::shared_ptr<Item> >* getItems()
+	{
+		return &items_;
+	}
 
+	std::shared_ptr<Item> getItem(uint32_t id);
+
+	void registerItemSource(ItemSource* source);
 	void store(QJsonObject &json);
-    void load(const QJsonObject &json);
 
 	void clear();
 
@@ -28,11 +33,21 @@ signals:
 
 	void itemDeleted(ItemData item);
 	void itemAdded(std::weak_ptr<Item> Item);
+	void itemUpdated(std::weak_ptr<Item> Item);
+	void sigRefresh();
 
 public slots:
 
 	void removeItem(const ItemData& item);
-    void addItem(std::shared_ptr<Item> item);
-    void addItems(const std::vector<std::shared_ptr<Item>>& itemsIn);
-    void itemStateChanged(const ItemData& item);
+	void addItem(std::shared_ptr<Item> item, bool inform = true);
+	void addItems(const std::vector<std::shared_ptr<Item>>& itemsIn, bool inform = true);
+	void replaceItems(const std::vector<std::shared_ptr<Item>>& items);
+	void updateItems(std::vector<ItemData> items, bool inform = true);
+	void updateItem(const ItemData& item, bool inform = true);
+	void refresh();
+
+private slots:
+	void itemUpdateSlot(ItemData data);
 };
+
+extern ItemStore globalItems;

src/items/messageitem.cpp

@@ -1,20 +1,19 @@
 #include "messageitem.h"
 
 #include <QTimer>
-#include <QSound>
-
-BroadCast* MessageItem::broadCast = nullptr;
+#include <QSoundEffect>
 
 MessageItem::MessageItem(uint32_t itemIdIn, QString name, uint8_t value,  QObject *parent):
 	Item(itemIdIn, name, value, parent)
 {
-
+	alertSound.setVolume(1.0);
+	type_ = ITEM_VALUE_NO_VALUE;
 }
 
 MessageItem::MessageItem(const ItemData& itemData,  QObject *parent):
 	Item(itemData, parent)
 {
-
+	alertSound.setVolume(1.0);
 }
 
 MessageItem::~MessageItem()
@@ -22,13 +21,12 @@ MessageItem::~MessageItem()
 	closeMessageBox();
 }
 
-void MessageItem::setValue(uint8_t value)
+void MessageItem::enactValue(uint8_t value)
 {
-   Item::setValue(value);
 	if(value && !messageBox_)
 	{
-       if(broadCast) broadCast->sendMessage(name_, message_);
-       if(!alertSoundFileName.isEmpty()) QSound::play(alertSoundFileName);
+		if(!alertSoundFileName.isEmpty())
+			alertSound.play();
 		messageBox_ = new QMessageBox(QMessageBox::NoIcon, name_, message_);
 		messageBox_->setModal(false);
 		connect(messageBox_, &QMessageBox::finished, this, &MessageItem::closeMessageBox);
@@ -60,6 +58,7 @@ QString MessageItem::getAlert()
 void MessageItem::setAlert(const QString &in)
 {
 	alertSoundFileName = in;
+	alertSound.setSource(QUrl::fromLocalFile(alertSoundFileName));
 }
 
 void MessageItem::setMessage(const QString& in)
@@ -77,7 +76,8 @@ void MessageItem::store(QJsonObject &json)
 	json["Type"] = "Message";
 	Item::store(json);
 	json["Message"] = message_;
-    if(!alertSoundFileName.isEmpty()) json["Alert"] = alertSoundFileName;
+	if(!alertSoundFileName.isEmpty())
+		json["Alert"] = alertSoundFileName;
 }
 
 void MessageItem::load(const QJsonObject &json, const bool preserve)
@@ -85,4 +85,6 @@ void MessageItem::load(const QJsonObject &json, const bool preserve)
 	Item::load(json,preserve);
 	message_ = json["Message"].toString("Invalid Message");
 	alertSoundFileName = json["Alert"].toString("");
+	if(!alertSoundFileName.isEmpty())
+		alertSound.setSource(QUrl::fromLocalFile(alertSoundFileName));
 }

src/items/messageitem.h

@@ -2,33 +2,30 @@
 #define MESSAGEITEM_H
 
 #include <QMessageBox>
+#include <QSoundEffect>
 
 #include "item.h"
-#include "../broadcast.h"
 
 class MessageItem : public Item
 {
-Q_OBJECT
+	Q_OBJECT
 private:
 
 	QString message_;
 	QMessageBox* messageBox_ = nullptr;
 	QString alertSoundFileName = "";
-
-public:
-    static BroadCast* broadCast;
+	QSoundEffect alertSound;
 
 private slots:
-
 	void closeMessageBox();
 
-public:
-
-    virtual void setValue(uint8_t value);
+protected:
+	virtual void enactValue(uint8_t value) override;
 
 public:
 
-    MessageItem(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0,  QObject *parent = nullptr);
+	MessageItem(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0,
+	            QObject *parent = nullptr);
 	MessageItem(const ItemData& itemData,  QObject *parent = nullptr);
 	~MessageItem();
 
@@ -37,8 +34,8 @@ public:
 	void setAlert(const QString& in);
 	QString getAlert();
 
-    virtual void store(QJsonObject& json);
-    virtual void load(const QJsonObject& json, const bool preserve = false);
+	virtual void store(QJsonObject& json) override;
+	virtual void load(const QJsonObject& json, const bool preserve = false) override;
 };
 
 #endif // MESSAGEITEM_H

src/items/poweritem.cpp

@@ -3,18 +3,20 @@
 #include <QApplication>
 #include <QDebug>
 
-PowerItem::PowerItem(uint32_t itemIdIn, QString name,  uint8_t value, QObject* parent): Item(itemIdIn, name, value, parent)
+PowerItem::PowerItem(uint32_t itemIdIn, QString name,  uint8_t value, QObject* parent):
+	Item(itemIdIn, name, value, parent)
 {
 	stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 0, "Shutdown Imminent", true));
-    setValue(true);
+	PowerItem::setValue(true);
+	hidden_ = true;
+	type_ = ITEM_VALUE_NO_VALUE;
 }
 
-void PowerItem::setValue(uint8_t value)
+void PowerItem::enactValue(uint8_t value)
 {
-    qDebug()<<"shutdown";
-    Item::setValue(value);
 	if(!value)
 	{
+		qDebug()<<"shutdown";
 		QTimer::singleShot(5000, this, &PowerItem::timeout);
 		stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 1, "Shutdown Imminent", true));
 	}
@@ -23,7 +25,7 @@ void PowerItem::setValue(uint8_t value)
 void PowerItem::timeout()
 {
 	qDebug()<<"shutdown timeout";
-    QProcess::startDetached("syncoff");
+	QProcess::startDetached("syncoff", QStringList());
 }
 
 void PowerItem::store(QJsonObject& json)

src/items/poweritem.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "item.h"
-#include "../sensors/sensor.h"
-#include "../microcontroller.h"
+#include "sensors/sensor.h"
+#include "microcontroller.h"
 
 #include <QTimer>
 
@@ -16,15 +16,17 @@ signals:
 	void stateChanged(Sensor sensor);
 
 private slots:
-
 	void timeout();
 
-public slots:
-
-    virtual void setValue(uint8_t value);
+protected:
+	virtual void enactValue(uint8_t value) override;
 
 public:
-    PowerItem(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, "Shutdown Imminent", true));}
-    virtual void store(QJsonObject& json);
+	PowerItem(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Power",  uint8_t value = 0,
+	          QObject* parent = nullptr);
+	void emmitSensor()
+	{
+		stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 0, "Shutdown Imminent", true));
+	}
+	virtual void store(QJsonObject& json) override;
 };

src/items/relay.cpp

@@ -5,19 +5,21 @@
 
 Microcontroller* Relay::micro_ = nullptr;
 
-Relay::Relay(uint8_t id, QString name, uint16_t address, bool state, QObject* parent): Item(0, name, state, parent), id_(id), address_(address)
+Relay::Relay(uint8_t id, QString name, uint16_t address, bool state, QObject* parent): Item(0, name, state, parent),
+	id_(id), address_(address)
 {
 	itemId_ = address | ((uint32_t)id << 16);
-    qDebug()<<"Relay "<<id_<<"Name "<<name<<" id "<<itemId_<<" state "<<state<<" addr: "<<address;
 }
 
-void Relay::setValue(uint8_t value)
+void Relay::enactValue(uint8_t value)
 {
-   Item::setValue(value);
+	qDebug()<<"Relay"<<__func__<<micro_;
 	if(micro_)
 	{
-       if(value)micro_->relayOn(id_);
-       else micro_->relayOff(id_);
+		if(value)
+			micro_->relayOn(id_);
+		else
+			micro_->relayOff(id_);
 	}
 }
 

src/items/relay.h

@@ -4,7 +4,7 @@
 #include<stdint.h>
 #include<QObject>
 
-#include "../sensors/sensor.h"
+#include "sensors/sensor.h"
 #include "item.h"
 
 class Microcontroller;
@@ -18,9 +18,10 @@ private:
 	uint8_t id_;
 	uint16_t address_;
 
-public slots:
+protected:
+	virtual void enactValue(uint8_t value) override;
 
-    virtual void setValue(uint8_t value);
+public slots:
 	void on();
 	void off();
 	void toggle();
@@ -32,9 +33,12 @@ public:
 	uint8_t getId() const;
 	void setId(uint8_t id);
 
-    inline static void setMicrocontroller(Microcontroller* micro){ micro_ = micro; }
+	inline static void setMicrocontroller(Microcontroller* micro)
+	{
+		micro_ = micro;
+	}
 
-    virtual void store(QJsonObject& json);
-    virtual void load(const QJsonObject& json, const bool preserve = false);
+	virtual void store(QJsonObject& json) override;
+	virtual void load(const QJsonObject& json, const bool preserve = false) override;
 };
 #endif // RELAY_H

src/items/rgbitem.cpp

@@ -1,13 +1,14 @@
 #include "rgbitem.h"
 
-RgbItem::RgbItem(Microcontroller* micro, uint32_t itemIdIn, QString name,  uint8_t value, QObject* parent): Item(itemIdIn, name, value, parent), micro_(micro)
+RgbItem::RgbItem(Microcontroller* micro, uint32_t itemIdIn, QString name,  uint8_t value,
+                 QObject* parent): Item(itemIdIn, name, value, parent), micro_(micro)
 {
 
 }
 
-void RgbItem::setValue(uint8_t value)
+void RgbItem::enactValue(uint8_t value)
 {
-    Item::setValue(value);
+	assert(micro_);
 	value ? micro_->rgbOn() : micro_->rgbOff();
 }
 

src/items/rgbitem.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../microcontroller.h"
+#include "microcontroller.h"
 #include "item.h"
 
 class RgbItem: public Item
@@ -9,12 +9,12 @@ class RgbItem: public Item
 private:
 	Microcontroller* micro_;
 
-public slots:
-
-    virtual void setValue(uint8_t value);
+protected:
+	virtual void enactValue(uint8_t value) override;
 
 public:
-    RgbItem(Microcontroller* micro, uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "",  uint8_t value = 0, QObject* parent = nullptr);
+	RgbItem(Microcontroller* micro = nullptr, uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "",
+	        uint8_t value = 0, QObject* parent = nullptr);
 
-    virtual void store(QJsonObject& json);
+	virtual void store(QJsonObject& json) override;
 };

src/items/systemitem.cpp

@@ -1,19 +1,19 @@
 #include "systemitem.h"
 #include <QProcess>
 
-void SystemItem::setValue(uint8_t value)
+void SystemItem::enactValue(uint8_t value)
 {
 	QProcess::execute(value ? onCommand_ : offCommand_);
 }
 
 SystemItem::SystemItem(uint32_t itemIdIn, QString name, uint8_t value,  QObject *parent):
-Item(itemIdIn, name, value, parent)
+	Item(itemIdIn, name, value, parent)
 {
 
 }
 
 SystemItem::SystemItem(const ItemData& itemData,  QObject *parent):
-Item(itemData, parent)
+	Item(itemData, parent)
 {
 
 }

src/items/systemitem.h

@@ -1,34 +1,37 @@
 #ifndef SYSTEMITEM_H
 #define SYSTEMITEM_H
 
-
 #include "item.h"
 
 class SystemItem : public Item
 {
-Q_OBJECT
+	Q_OBJECT
 private:
-
 	QString onCommand_;
 	QString offCommand_;
 
-public:
-
-    virtual void setValue(uint8_t value);
+protected:
+	virtual void enactValue(uint8_t value) override;
 
 public:
-
-    SystemItem(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0,  QObject *parent = nullptr);
+	SystemItem(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0,
+	           QObject *parent = nullptr);
 	SystemItem(const ItemData& itemData,  QObject *parent = nullptr);
 	~SystemItem() = default;
 
 	void setOnCommand(const QString& in);
 	void setOffCommand(const QString& in);
-    QString getOnCommand(){return onCommand_;}
-    QString getOffCommand(){return offCommand_;}
+	QString getOnCommand()
+	{
+		return onCommand_;
+	}
+	QString getOffCommand()
+	{
+		return offCommand_;
+	}
 
-    virtual void store(QJsonObject& json);
-    virtual void load(const QJsonObject& json, const bool preserve = false);
+	virtual void store(QJsonObject& json) override;
+	virtual void load(const QJsonObject& json, const bool preserve = false) override;
 };
 
 #endif // SYSTEMITEM_H

src/main.cpp

@@ -1,37 +1,23 @@
 #include <QtWidgets/QApplication>
-#include <stdio.h>
 #include <QDebug>
 #include <QTcpSocket>
 #include <QMessageBox>
-
-
-#ifndef Q_OS_ANDROID
+#include <QSettings>
 #include <QtSerialPort/QtSerialPort>
 #include <QtSerialPort/QSerialPortInfo>
 #include <QCommandLineParser>
-#endif
 
-#include "actors/alarmtime.h"
-#include "microcontroller.h"
 #include "ui/mainwindow.h"
-#include "sensors/speakersensor.h"
-#include "sensors/sunsensor.h"
-#include "sensors/ocupancysensor.h"
-#include "alarmactions.h"
-#include "sensors/sensor.h"
 #include "items/itemstore.h"
-#include "items/auxitem.h"
-#include "items/rgbitem.h"
-#include "items/poweritem.h"
 #include "mainobject.h"
-
-
-#define BAUD  QSerialPort::Baud38400
+#include "programmode.h"
 
 int main(int argc, char *argv[])
 {
 	QApplication a(argc, argv);
 
+	//pw_init(&argc, &argv);
+
 	//set info
 	QCoreApplication::setOrganizationName("UVOS");
 	QCoreApplication::setOrganizationDomain("uvos.xyz");
@@ -41,93 +27,113 @@ int main(int argc, char *argv[])
 	QDir::setCurrent(a.applicationDirPath());
 
 	//parse comand line
-    #ifndef Q_OS_ANDROID
 	QCommandLineParser parser;
 	parser.setApplicationDescription("Smart Home Interface");
 	parser.addHelpOption();
 	parser.addVersionOption();
-    QCommandLineOption tcpOption(QStringList() << "t" << "tcp", QCoreApplication::translate("main", "Use Tcp connection"));
-    parser.addOption(tcpOption);
-    QCommandLineOption hostOption(QStringList() << "H" << "host", QCoreApplication::translate("main", "Set server host ip addres"), "adress");
+	QCommandLineOption masterOption(QStringList() << "m" << "master", QCoreApplication::translate("main", "Use in master mode"));
+	parser.addOption(masterOption);
+	QCommandLineOption hostOption(QStringList() << "H" << "host", QCoreApplication::translate("main", "Set server host ip addres"), "address", "0.0.0.0");
 	parser.addOption(hostOption);
-    QCommandLineOption portOption(QStringList() << "p" << "port", QCoreApplication::translate("main", "Set server Port in TCP mode or Serial port in serial mode"), "port");
+	QCommandLineOption portOption(QStringList() << "p" << "port", QCoreApplication::translate("main", "Set server Port"), "port", "104476");
 	parser.addOption(portOption);
-    QCommandLineOption serialOption(QStringList() << "s" << "serial", QCoreApplication::translate("main", "Use serial connection"));
-    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");
+	QCommandLineOption settingsPathOption(QStringList()<<"c"<<"config", QCoreApplication::translate("main", "Set config file"), "configFilePath",
+										  QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json");
 	parser.addOption(settingsPathOption);
-    QCommandLineOption secondaryOption(QStringList() << "e" << "secondary", QCoreApplication::translate("main", "Set if instance is not main instance"));
-    parser.addOption(secondaryOption);
+	QCommandLineOption headlessOption(QStringList()<<"e"<<"headless", QCoreApplication::translate("main", "Dont start the gui"));
+	parser.addOption(headlessOption);
 	parser.process(a);
-    #endif
 
-    QIODevice* masterIODevice = nullptr;
+	int retVal;
 
-    #ifndef Q_OS_ANDROID
-    if(parser.isSet(tcpOption))
+	programMode = PROGRAM_MODE_UI_ONLY;
+	if(parser.isSet(masterOption))
 	{
+		programMode = PROGRAM_MODE_PRIMARY;
+		if(parser.isSet(headlessOption))
+			programMode = PROGRAM_MODE_HEADLESS_PRIMARY;
+	}
+	if(programMode == PROGRAM_MODE_PRIMARY || programMode == PROGRAM_MODE_HEADLESS_PRIMARY)
+	{
+		QString settingsPath = parser.value(settingsPathOption);
+		QJsonObject json = MainObject::getJsonObjectFromDisk(settingsPath);
+		bool tcpMicro = json["MicroTcp"].toBool(true);
+		json["MicroTcp"] = tcpMicro;
+
+		QIODevice* microDevice = nullptr;
+		if(tcpMicro)
+		{
+			int port = json["MicroTcpPort"].toInt(6856);
+			json["MicroTcpPort"] = port;
+			QString host = json["MicroTcpHost"].toString("127.0.0.1");
+			json["MicroTcpHost"] = host;
+
 			QTcpSocket* microSocket = new QTcpSocket;
 
-        int port = 6856;
-        if(parser.isSet(portOption)) port =  parser.value(portOption).toInt();
-
-        QString host("127.0.0.1");
-        if(parser.isSet(hostOption)) host = parser.value(hostOption);
-        std::cout<<"connecting to "<<host.toStdString()<<':'<<port<<'\n';
+			qInfo()<<"connecting to "<<host<<':'<<port<<" for tcp micro";
 			microSocket->connectToHost(host, port, QIODevice::ReadWrite);
+
 			if(!microSocket->waitForConnected(1000))
 			{
-            std::cout<<"Can not connect to to Server.\n";
-            QMessageBox::critical(nullptr, "Error", "Can not connect to to Server");
+				qCritical()<<"Can not connect to tcp micro";
+				MainObject::storeJsonObjectToDisk(settingsPath, json);
+				if(programMode == PROGRAM_MODE_PRIMARY)
+					QMessageBox::critical(nullptr, "Error", "Can not connect to tcp micro");
 				return 1;
 			}
-        masterIODevice = microSocket;
+			microDevice = microSocket;
 		}
 		else
 		{
-        QSerialPort* microPort = new QSerialPort;
-        if(parser.isSet(portOption)) microPort->setPortName(parser.value(portOption));
-        else microPort->setPortName("ttyUSB0");
+			QString port = json["MicroSerialPort"].toString("ttyUSB0");
+			json["MicroSerialPort"] = port;
+			int baud = json["MicroSerialBaud"].toInt(38400);
+			json["MicroSerialBaud"] = baud;
 
-        if(parser.isSet(portOption)) microPort->setBaudRate(parser.value(baudOption).toInt());
-        else microPort->setBaudRate(BAUD);
+			QSerialPort *microPort = new QSerialPort;
+			microPort->setPortName(port);
+			microPort->setBaudRate(baud);
+			microPort->open(QIODevice::ReadWrite);
 
-        if(!microPort->open(QIODevice::ReadWrite)) std::cout<<"Can not open serial port "<<microPort->portName().toStdString()<<". Continueing in demo mode"<<'\n';
-        masterIODevice = microPort;
-    }
-
-    MainObject mainObject(masterIODevice, parser.isSet(settingsPathOption) ? parser.value(settingsPathOption) : "", !parser.isSet(secondaryOption));
-
-    #else
-        QTcpSocket* microSocket = new QTcpSocket;
-        microSocket->connectToHost("10.0.0.1", 6856, QIODevice::ReadWrite);
-        if(!microSocket->waitForConnected(1000))
+			if(!microPort->isOpen())
 			{
-            std::cout<<"Can not connect to to Server.\n";
+				qCritical()<<"Can not open serial port"<<port;
+				MainObject::storeJsonObjectToDisk(settingsPath, json);
+				if(programMode == PROGRAM_MODE_PRIMARY)
+					QMessageBox::critical(nullptr, "Error", "Can not open serial port " + port);
 				return 1;
 			}
-        masterIODevice = microSocket;
+			microDevice = microPort;
+		}
+		PrimaryMainObject mainObject(microDevice, settingsPath, parser.value(hostOption), parser.value(portOption).toInt());
+		QObject::connect(mainObject.tcpServer, &TcpServer::sigRequestSave, &mainObject, [&mainObject, settingsPath](){mainObject.storeToDisk(settingsPath);});
+		MainWindow* w = nullptr;
+		if(programMode != PROGRAM_MODE_HEADLESS_PRIMARY)
+		{
+			w = new MainWindow(&mainObject);
+			QObject::connect(&mainObject.micro, SIGNAL(textRecived(QString)), w, SLOT(changeHeaderLableText(QString)));
+			QObject::connect(&mainObject.micro, SIGNAL(textRecived(QString)), w, SLOT(changeHeaderLableText(QString)));
+			QObject::connect(w, &MainWindow::sigSetRgb, &mainObject.micro, &Microcontroller::changeRgbColor);
+			QObject::connect(w, &MainWindow::sigSave, &mainObject, [&mainObject, settingsPath](){mainObject.storeToDisk(settingsPath);});
+			QObject::connect(w, &MainWindow::createdItem, &globalItems, [](std::shared_ptr<Item> item){globalItems.addItem(item, false);});
+			w->show();
+		}
+		retVal = a.exec();
 
-        MainObject mainObject(masterIODevice, parser.isSet(settingsPathOption) ? parser.value(settingsPathOption) : "", !parser.isSet(secondaryOption));
-    #endif
-
-
-    //mainwindow
+		delete w;
+		delete microDevice;
+	}
+	else
+	{
+		SecondaryMainObject mainObject(parser.value(hostOption), parser.value(portOption).toInt());
 		MainWindow w(&mainObject);
-    QObject::connect(&mainObject.micro, SIGNAL(textRecived(QString)), &w, SLOT(changeHeaderLableText(QString)));
-    QObject::connect(&w, &MainWindow::sigBrodcast, &mainObject, &MainObject::sendJson);
-	QObject::connect(&w, &MainWindow::sigSave, &mainObject, &MainObject::storeToDisk);
-    QObject::connect(&w, &MainWindow::createdItem, &mainObject.items, &ItemStore::addItem);
-    if(!mainObject.micro.connected()) w.changeHeaderLableText("No io debug only!");
-
+		QObject::connect(&w, &MainWindow::createdItem, &globalItems, [](std::shared_ptr<Item> item){globalItems.addItem(item, false);});
+		QObject::connect(&w, &MainWindow::sigSave, mainObject.tcpClient, &TcpClient::sendItems);
 		w.show();
 
-    int retVal = a.exec();
+		retVal = a.exec();
+	}
 
-	if(masterIODevice)
-		delete masterIODevice;
 	return retVal;
 }
 

src/mainobject.cpp

@@ -1,135 +1,35 @@
 #include "mainobject.h"
-#include "items/messageitem.h"
 
-MainObject::MainObject(QIODevice* ioDevice, const QString& settingsPathIn, const bool masterIn, QObject *parent) :
-    QObject(parent),
-    master(masterIn),
-    masterIODevice(ioDevice),
-    ioMultiplexer(masterIODevice),
-    micro(ioMultiplexer.getIoDevice()),
-    broadCast(ioMultiplexer.getIoDevice(), masterIn),
-    settingsPath(settingsPathIn),
-    sunSensorSource(49.884450, 8.650536),
-    powerItem(new PowerItem),
-    rgbItem(new RgbItem(&micro, 5487422, "Rgb Lights")),
-    auxItem(new AuxItem(&micro, 5487421, "Desk Light"))
+#include<QJsonObject>
+#include<QJsonArray>
+#include<QMessageBox>
 
+#include "items/itemstore.h"
+
+MainObject::MainObject(QObject *parent) :
+	QObject(parent)
 {
-    qDebug()<<"Is master:"<<master;
-    //connect sensors subsystem
-    QObject::connect(&micro, &Microcontroller::gotSensorState, &globalSensors, &SensorStore::sensorGotState);
-    QObject::connect(&sunSensorSource, &SunSensorSource::stateChanged, &globalSensors, &SensorStore::sensorGotState);
-    QObject::connect(&globalSensors, &SensorStore::sensorChangedState, &ocupancySensor, &OcupancySensorSource::sensorEvent);
-    QObject::connect(&ocupancySensor, &OcupancySensorSource::stateChanged, &globalSensors, &SensorStore::sensorGotState);
-
-    sunSensorSource.run();
-
-    //connect item store
-    QObject::connect(&micro, &Microcontroller::gotRelayList, &items, &ItemStore::addItems);
-    QObject::connect(&micro, &Microcontroller::itemChanged, &items, &ItemStore::itemStateChanged);
-
-    //special items
-    QObject::connect(powerItem.get(), &PowerItem::stateChanged, &globalSensors, &SensorStore::sensorGotState);
-    powerItem->emmitSensor();
-    items.addItem(rgbItem);
-    items.addItem(auxItem);
-    MessageItem::broadCast = &broadCast;
-
-
-    Relay::setMicrocontroller(&micro);
-
-    connect(&broadCast, &BroadCast::gotJson, this, &MainObject::recivedJson);
-    QObject::connect(&broadCast, &BroadCast::gotSensorState, &globalSensors, &SensorStore::sensorGotState);
-    if(master)connect(&broadCast, &BroadCast::jsonRequested, this, &MainObject::sendJson);
-
-    if(master) load(getJsonObjectFromDisk(settingsPath, &noSave));
-    else
-    {
-        broadCast.requestJson();
-        broadCast.requestSensors();
-    }
-
-    #ifndef Q_OS_ANDROID
-        Item::secondaryFlag = !master;
-    #endif
 }
 
 MainObject::~MainObject()
 {
 }
 
-void MainObject::store(QJsonObject &json)
+void MainObject::refresh()
 {
-    items.store(json);
-
-    QJsonObject powerObject;
-    powerItem->store(powerObject);
-    json.insert("Power", powerObject);
-    QJsonDocument pwrDoc(powerObject);
-
-    QJsonObject ocupancyObject;
-    ocupancySensor.store(ocupancyObject);
-    json.insert("Ocupancy", ocupancyObject);
+	globalItems.refresh();
 }
 
-void MainObject::load(const QJsonObject& json)
-{
-    items.clear();
-    rgbItem->removeAllActors();
-    auxItem->removeAllActors();
-    powerItem->removeAllActors();
-    items.addItem(rgbItem);
-    items.addItem(auxItem);
-    items.load(json);
-    powerItem->load(json["Power"].toObject());
-    ocupancySensor.load(json["Ocupancy"].toObject());
-    qDebug()<<"aray size: "<<json.isEmpty();
-    if(json["Items"].toArray().size() >= 2)
-    {
-        rgbItem->load(json["Items"].toArray()[0].toObject());
-        auxItem->load(json["Items"].toArray()[1].toObject());
-    }
-    micro.requestState();
-}
-
-void MainObject::storeToDisk()
-{
-	if(master && !noSave)
-	{
-		QJsonObject json;
-		store(json);
-		storeJsonObjectToDisk(json, settingsPath);
-	}
-}
-
-void MainObject::recivedJson(const QJsonObject json)
-{
-	if(master && !noSave)
-		storeJsonObjectToDisk(json, settingsPath);
-    load(json);
-}
-
-void MainObject::sendJson()
-{
-    QJsonObject json;
-    store(json);
-    broadCast.sendJson(json);
-}
-
-QJsonObject MainObject::getJsonObjectFromDisk(const QString& filePath, bool* error)
+QJsonObject MainObject::getJsonObjectFromDisk(const QString& filename, bool* error)
 {
 	QFile file;
+	file.setFileName(filename);
 
-    #ifndef Q_OS_ANDROID
-    if(filePath.size() > 0) file.setFileName(filePath);
-    else
-    #endif
+	bool ret = file.open(QIODevice::ReadOnly);
+	if(!file.isOpen() || !ret)
 	{
-       file.setFileName(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json");
+		std::cerr<<"Can not open config file: "<<filename.toLatin1().data()<<std::endl;
 	}
-
-    file.open(QIODevice::ReadOnly);
-    if(!file.isOpen()) std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
 	else
 	{
 		QJsonParseError qerror;
@@ -137,29 +37,24 @@ QJsonObject MainObject::getJsonObjectFromDisk(const QString& filePath, bool* err
 		file.close();
 		if(qerror.error != QJsonParseError::NoError)
 		{
-            qDebug()<<filePath<<" "<<qerror.errorString();
-            if(error) (*error) = true;
+			qDebug()<<filename<<" "<<qerror.errorString();
+			if(error)
+				(*error) = true;
 		}
 		return document.object();
 	}
 	return QJsonObject();
 }
 
-bool MainObject::storeJsonObjectToDisk(const QJsonObject& json, QString filePath)
+bool MainObject::storeJsonObjectToDisk(const QString& filename, const QJsonObject& json)
 {
-    #ifndef Q_OS_ANDROID
-    if(filePath.size() == 0)
-    #endif
-    {
-        filePath = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json";
-    }
-    QFile file(filePath + ".out");
+	QFile file(filename + ".out");
 
-    qDebug()<<"config file: "<<filePath;
-    file.open(QIODevice::WriteOnly);
-    if(!file.isOpen())
+	qDebug()<<"config file: "<<filename;
+	bool ret = file.open(QIODevice::WriteOnly);
+	if(!file.isOpen() || !ret)
 	{
-       std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
+		std::cerr<<"Can not open config file: "<<filename.toLatin1().data()<<std::endl;
 		return false;
 	}
 	else
@@ -167,9 +62,101 @@ bool MainObject::storeJsonObjectToDisk(const QJsonObject& json, QString filePath
 		QJsonDocument document(json);
 		file.write(document.toJson());
 		file.close();
-        QFile::remove(filePath);
-        file.rename(filePath);
+		QFile::remove(filename);
+		file.rename(filename);
 		return true;
 	}
 }
 
+PrimaryMainObject::PrimaryMainObject(QIODevice* microDevice, const QString& settingsPath, const QString& host, int port, QObject *parent) :
+	MainObject(parent),
+	settingsPath(settingsPath),
+	micro(microDevice),
+	tcpServer(new TcpServer),
+	sunSensorSource(49.824972, 8.702194),
+	fixedItems(&micro)
+{
+	//connect sensors subsystem
+	connect(&globalSensors, &SensorStore::sensorChangedState, tcpServer, &TcpServer::sensorEvent);
+	connect(tcpServer, &TcpServer::gotSensor, &globalSensors, &SensorStore::sensorGotState);
+	connect(&sunSensorSource, &SunSensorSource::stateChanged, &globalSensors, &SensorStore::sensorGotState);
+	connect(&micro, &Microcontroller::gotSensorState, &globalSensors, &SensorStore::sensorGotState);
+	connect(&mqttSensorSource, &MqttSensorSource::stateChanged, &globalSensors, &SensorStore::sensorGotState);
+
+	sunSensorSource.run();
+
+	globalItems.registerItemSource(&fixedItems);
+	globalItems.registerItemSource(tcpServer);
+	globalItems.registerItemSource(&micro);
+	globalItems.registerItemSource(&itemLoader);
+
+	Relay::setMicrocontroller(&micro);
+
+	loadFromDisk(settingsPath);
+
+	QJsonObject mqttJson = settings["Mqtt"].toObject();
+	mqttSensorSource.start(mqttJson);
+
+	tcpServer->launch(QHostAddress(host), port);
+	connect(&globalItems, &ItemStore::itemUpdated, tcpServer, &TcpServer::itemUpdated);
+}
+
+PrimaryMainObject::~PrimaryMainObject()
+{
+	storeToDisk(settingsPath);
+}
+
+void PrimaryMainObject::store(QJsonObject &json)
+{
+	globalItems.store(json);
+	QJsonObject mqttJson = json["Mqtt"].toObject();
+	mqttSensorSource.store(mqttJson);
+	json["Mqtt"] = mqttJson;
+}
+
+void PrimaryMainObject::load(const QJsonObject& json)
+{
+	settings = json;
+	itemLoader.updateJson(json);
+	globalItems.clear();
+	globalItems.refresh();
+}
+
+bool PrimaryMainObject::storeToDisk(const QString& filename)
+{
+	store(settings);
+	itemLoader.updateJson(settings);
+	return storeJsonObjectToDisk(filename, settings);
+}
+
+bool PrimaryMainObject::loadFromDisk(const QString& filename)
+{
+	bool error = false;
+	QJsonObject json = getJsonObjectFromDisk(filename, &error);
+	if(!error)
+		load(json);
+	return error;
+}
+
+SecondaryMainObject::SecondaryMainObject(QString host, int port, QObject *parent) :
+	MainObject(parent),
+	tcpClient(new TcpClient)
+{
+	connect(tcpClient, &TcpClient::gotSensor, &globalSensors, &SensorStore::sensorGotState);
+	globalItems.registerItemSource(tcpClient);
+
+	if(!tcpClient->launch(QHostAddress(host), port))
+	{
+		QMessageBox::critical(nullptr, "Error", "Could not connect to "+host+":"+QString::number(port));
+		QMetaObject::invokeMethod(this, [](){exit(1);}, Qt::QueuedConnection);
+	}
+
+	connect(&globalItems, &ItemStore::itemUpdated, tcpClient, &TcpClient::itemUpdated);
+
+	globalItems.refresh();
+}
+
+SecondaryMainObject::~SecondaryMainObject()
+{
+}
+

src/mainobject.h

@@ -2,7 +2,6 @@
 #define MAINOBJECT_H
 
 #include <QObject>
-#include <stdio.h>
 #include <QDir>
 #include <QDebug>
 #include <QString>
@@ -12,76 +11,66 @@
 #include <QStandardPaths>
 #include <memory>
 
-
-#ifndef Q_OS_ANDROID
-#include <QtSerialPort/QtSerialPort>
-#include <QtSerialPort/QSerialPortInfo>
-#include <QCommandLineParser>
-#endif
-
-#include "actors/alarmtime.h"
 #include "microcontroller.h"
 #include "ui/mainwindow.h"
-#include "sensors/speakersensor.h"
 #include "sensors/sunsensor.h"
-#include "sensors/ocupancysensor.h"
-#include "sensors/sensor.h"
-#include "items/itemstore.h"
-#include "items/auxitem.h"
-#include "items/rgbitem.h"
-#include "items/poweritem.h"
-#include "iomuliplexer.h"
-#include "broadcast.h"
+#include "sensors/mqttsensorsource.h"
+#include "items/fixeditemsource.h"
+#include "items/itemloadersource.h"
+#include "service/tcpclient.h"
+#include "service/tcpserver.h"
 
 class MainObject : public QObject
+{
+	Q_OBJECT
+
+public:
+	explicit MainObject(QObject *parent = nullptr);
+	~MainObject();
+	static QJsonObject getJsonObjectFromDisk(const QString& filename, bool* error = nullptr);
+	static bool storeJsonObjectToDisk(const QString& filename, const QJsonObject& json);
+
+public slots:
+	void refresh();
+};
+
+class PrimaryMainObject : public MainObject
 {
 	Q_OBJECT
 public:
 
-    //io
-    const bool master;
-
-    bool noSave = false;
-
-    QIODevice * const masterIODevice = nullptr;
-    IoMuliplexer ioMultiplexer;
+	QString settingsPath;
+	QJsonObject settings;
 
 	Microcontroller micro;
-    BroadCast broadCast;
-
-    const QString settingsPath;
+	TcpServer* tcpServer;
 
 	//sensors
 	SunSensorSource sunSensorSource;
-    OcupancySensorSource ocupancySensor;
+	MqttSensorSource mqttSensorSource;
 
-    //items
-    ItemStore items;
-
-    std::shared_ptr<PowerItem> powerItem;
-    std::shared_ptr<RgbItem> rgbItem;
-    std::shared_ptr<AuxItem> auxItem;
-
-private:
-
-    static QJsonObject getJsonObjectFromDisk(const QString& filePath = "", bool* error = nullptr);
-    static bool storeJsonObjectToDisk(const QJsonObject& json, QString filePath = "");
+	//item sources
+	FixedItemSource fixedItems;
+	ItemLoaderSource itemLoader;
 
 public:
-    explicit MainObject(QIODevice* ioDevice, const QString& settingsPathIn, const bool masterIn, QObject *parent = nullptr);
-    ~MainObject();
-
+	explicit PrimaryMainObject(QIODevice* microDevice, const QString& settingsPath, const QString& host, int port, QObject *parent = nullptr);
+	~PrimaryMainObject();
 	void store(QJsonObject& json);
-
 	void load(const QJsonObject& json);
+	bool storeToDisk(const QString& filename);
+	bool loadFromDisk(const QString& filename);
+};
 
-signals:
+class SecondaryMainObject : public MainObject
+{
+	Q_OBJECT
+public:
+	TcpClient* tcpClient;
 
-public slots:
-
-	void storeToDisk();
-    void sendJson();
-    void recivedJson(const QJsonObject json);
+public:
+	explicit SecondaryMainObject(QString host, int port, QObject *parent = nullptr);
+	~SecondaryMainObject();
 
 };
 

src/microcontroller.cpp

@@ -3,8 +3,6 @@
 #include <chrono>
 #include <thread>
 
-static constexpr bool debug = true;
-
 void Microcontroller::relayToggle(int state, int relay)
 {
 	char buffer[8];
@@ -40,11 +38,10 @@ 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());
 	write(buffer, length);
-        std::cout<<buffer;
-    }
+}
 
-    void Microcontroller::setAuxPwm(int duty)
-    {
+void Microcontroller::setAuxPwm(int duty)
+{
 	char buffer[64];
 	int length = sprintf(buffer, "aux set %03d\n", duty );
 	write(buffer, length);
@@ -52,9 +49,6 @@ void Microcontroller::changeRgbColor(const QColor color)
 
 void Microcontroller::write(const QByteArray& buffer)
 {
-    #ifndef Q_OS_ANDROID
-    if constexpr(debug) std::cerr<<buffer.data();
-    #endif
 	if(_port != nullptr)
 	{
 		_port->write(buffer);
@@ -65,9 +59,6 @@ void Microcontroller::write(const QByteArray& buffer)
 
 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);
@@ -95,7 +86,7 @@ bool Microcontroller::connected()
 	else return false;
 }
 
-void Microcontroller::requestState()
+void Microcontroller::refresh()
 {
 	write("state\n");
 }
@@ -127,10 +118,16 @@ std::shared_ptr<Relay> Microcontroller::processRelayLine(const QString& buffer)
 	if(bufferList.size() >= 9 && buffer.startsWith("ITEM NUMBER:"))
 	{
 		QString name;
-        for(int i = 10; 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));
-        return std::shared_ptr<Relay>( new Relay(bufferList[2].toInt(), name, bufferList[4].toInt(nullptr, 2), bufferList[8].toInt()));
+		for(int i = 10; 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));
+		return std::shared_ptr<Relay>(new Relay(bufferList[2].toInt(),
+												name,
+												bufferList[6].toInt(nullptr, 2),
+												bufferList[8].toInt()));
 	}
 	return  nullptr;
 }
@@ -145,8 +142,7 @@ void Microcontroller::processList(const QString& buffer)
 	else if(buffer.contains("EOL"))
 	{
 		listMode = false;
-        qDebug()<<"got relay list " << relayList.size();
-        gotRelayList(relayList);
+		gotItems(relayList);
 		relayList.clear();
 	}
 	else listMode = false;
@@ -154,19 +150,23 @@ void Microcontroller::processList(const QString& buffer)
 
 void Microcontroller::processRelayState(const QString& buffer)
 {
-    itemChanged(static_cast<ItemData>(*processRelayLine(buffer)));
+	updateItems({static_cast<ItemData>(*processRelayLine(buffer))});
 }
 
 void Microcontroller::processSensorState(const QString& buffer)
 {
 	Sensor sensor = Sensor::sensorFromString(buffer);
-    if(sensor.type != Sensor::TYPE_DUMMY) gotSensorState(sensor);
+	if(sensor.type != Sensor::TYPE_DUMMY)
+		gotSensorState(sensor);
 }
 
 
 void Microcontroller::processMicroReturn()
 {
-    if(listMode) processList(_buffer);
+	if(listMode)
+	{
+		processList(_buffer);
+	}
 	else
 	{
 		if(_buffer.startsWith("Items:"))
@@ -174,8 +174,14 @@ void Microcontroller::processMicroReturn()
 			listMode = true;
 			relayList.clear();
 		}
-        else if(_buffer.startsWith("ITEM NUMBER:"))processRelayState(_buffer);
-        else if(_buffer.startsWith("SENSOR")) processSensorState(_buffer);
+		else if(_buffer.startsWith("ITEM NUMBER:"))
+		{
+			processRelayState(_buffer);
+		}
+		else if(_buffer.startsWith("SENSOR"))
+		{
+			processSensorState(_buffer);
+		}
 	}
 
 }
@@ -186,7 +192,7 @@ void Microcontroller::isReadyRead()
 	while(_port->getChar(&charBuf))
 	{
 		_buffer.push_back(charBuf);
-        if( _buffer.endsWith('\n') )
+		if(_buffer.endsWith('\n') )
 		{
 			_buffer.remove('\n');
 			processMicroReturn();

src/microcontroller.h

@@ -1,8 +1,6 @@
 #ifndef MICROCONTROLLER_H
 #define MICROCONTROLLER_H
 
-#include <iostream>
-
 #include <QObject>
 #include <QColor>
 #include <QIODevice>
@@ -17,8 +15,9 @@
 #include "items/item.h"
 #include "items/relay.h"
 #include "sensors/sensor.h"
+#include "items/itemsource.h"
 
-class Microcontroller : public QObject
+class Microcontroller : public ItemSource
 {
 
 	Q_OBJECT
@@ -65,7 +64,7 @@ public slots:
 	void setPattern(int pattern);
 	void startSunrise();
 
-    void requestState();
+	void refresh() override;
 
 	void setAuxPwm(int duty);
 
@@ -79,10 +78,6 @@ private slots:
 
 signals:
 	void textRecived(const QString string);
-    void itemChanged(ItemData relay);
-    void auxStateChanged(int value);
-    void gotRelayList(std::vector< std::shared_ptr<Item> >&);
-
 	void gotSensorState(Sensor sensor);
 };
 

src/pipewire.cpp

@@ -0,0 +1,72 @@
+#include "pipewire.h"
+#include <stdexcept>
+#include <QDebug>
+
+static const struct pw_registry_events registry_events = {
+	.version = PW_VERSION_REGISTRY_EVENTS,
+	.global = &PipeWireHandler::registryEventHandler,
+	.global_remove = nullptr
+};
+
+PipeWireHandler::PipeWireHandler()
+{
+	loop = pw_thread_loop_new("SHinterface", nullptr);
+	if(!loop)
+		throw std::runtime_error("Could not create pipewire main loop");
+
+	context = pw_context_new(pw_thread_loop_get_loop(loop), nullptr, 0);
+	if(!context)
+		throw std::runtime_error("Could not create pipewire context");
+
+	core = pw_context_connect(context, NULL, 0);
+	if(!core)
+		throw std::runtime_error("Could not connect to pipewire");
+
+	registry = pw_core_get_registry(core, PW_VERSION_REGISTRY, 0);
+	if(!registry)
+		throw std::runtime_error("Could not get pipewire registry");
+
+	spa_zero(registryListener);
+	pw_registry_add_listener(registry, &registryListener, &registry_events, this);
+}
+
+bool PipeWireHandler::startLoop()
+{
+	if(!loop || !context || !core || !registry)
+		return false;
+	int ret = pw_thread_loop_start(loop);
+	return ret == 0;
+}
+
+struct pw_registry* PipeWireHandler::getRegistry()
+{
+	return registry;
+}
+
+void PipeWireHandler::registryEventHandler(void *data, uint32_t id,
+                                           uint32_t permissions, const char *type, uint32_t version,
+                                           const struct spa_dict *props)
+{
+	(void)permissions;
+	(void)version;
+
+	PipeWireHandler* handler = static_cast<PipeWireHandler*>(data);
+
+	if(std::string(type) == PW_TYPE_INTERFACE_Node)
+	{
+		const struct spa_dict_item *item = spa_dict_lookup_item(props, "node.name");
+		if(item)
+		{
+			qDebug()<<"got new pipewire node:"<<id<<"name:"<<item->value;
+			handler->nodeAdded({id, item->value});
+		}
+	}
+}
+
+PipeWireHandler::~PipeWireHandler()
+{
+	pw_core_disconnect(core);
+	pw_context_destroy(context);
+	pw_thread_loop_stop(loop);
+}
+

src/pipewire.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <pipewire/context.h>
+#include <pipewire/core.h>
+#include <pipewire/pipewire.h>
+#include <QObject>
+#include <string>
+#include <cstdint>
+
+class PipeWireHandler: public QObject
+{
+	Q_OBJECT
+
+public:
+	struct PwNode
+	{
+		uint32_t id;
+		std::string name;
+	};
+
+private:
+
+	struct pw_thread_loop* loop;
+	struct pw_context* context;
+	struct pw_core* core;
+	struct pw_registry* registry;
+	struct spa_hook registryListener;
+
+	void write(const char * const buffer, const size_t length);
+	void write(const QByteArray& buffer);
+
+	void decode(QByteArray buffer);
+	void decodeMaster(const QByteArray& buffer);
+
+public:
+
+	static void registryEventHandler(void *data, uint32_t id,
+									 uint32_t permissions, const char *type, uint32_t version,
+									 const struct spa_dict *props);
+
+signals:
+
+	void nodeAdded(PwNode node);
+	void nodeRemoved(PwNode node);
+
+public:
+
+	PipeWireHandler();
+	PipeWireHandler(const PipeWireHandler&) = delete;
+	PipeWireHandler operator=(const PipeWireHandler&) = delete;
+	bool startLoop();
+	struct pw_registry* getRegistry();
+
+	~PipeWireHandler();
+};
+

src/programmode.cpp

@@ -0,0 +1,3 @@
+#include "programmode.h"
+
+program_mode_t programMode = PROGRAM_MODE_PRIMARY;

src/programmode.h

@@ -0,0 +1,13 @@
+#ifndef PROGRAMMODE_H
+#define PROGRAMMODE_H
+
+typedef enum
+{
+	PROGRAM_MODE_PRIMARY = 0,
+	PROGRAM_MODE_HEADLESS_PRIMARY,
+	PROGRAM_MODE_UI_ONLY
+} program_mode_t;
+
+extern program_mode_t programMode;
+
+#endif // PROGRAMMODE_H

src/sensors/mqttsensorsource.cpp

@@ -0,0 +1,187 @@
+#include "mqttsensorsource.h"
+
+#include<QJsonArray>
+
+MqttSensorSource::MqttSensorSource(QObject *parent)
+	: QObject{parent}
+{
+}
+
+void MqttSensorSource::start(const QJsonObject& settings)
+{
+	baseTopicName = settings["BaseTopic"].toString("zigbee2mqtt");
+
+	connect(&client, &QMqttClient::stateChanged, this, &MqttSensorSource::onClientStateChanged);
+	connect(&client, &QMqttClient::errorChanged, this, &MqttSensorSource::onClientError);
+
+	client.setHostname(settings["Host"].toString("127.0.0.1"));
+	client.setPort(settings["Port"].toInt(1883));
+	if(settings.contains("User"))
+		client.setUsername(settings["User"].toString());
+	if(settings.contains("Password"))
+		client.setPassword(settings["Password"].toString());
+	client.setProtocolVersion(QMqttClient::MQTT_5_0);
+
+	client.connectToHost();
+
+	QJsonArray sensorsArray = settings["Sensors"].toArray();
+
+	for(QJsonValueRef sensorRef : sensorsArray)
+	{
+		QJsonObject sensorObject = sensorRef.toObject();
+		if(!sensorObject.contains("Topic"))
+			continue;
+		SensorSubscription sensor;
+		sensor.topic = sensorObject["Topic"].toString();
+		if(!sensorObject.contains("Name"))
+			sensor.name = sensor.topic;
+		else
+			sensor.name = sensorObject["Name"].toString();
+		sensor.id = qHash(baseTopicName + "/" + sensor.topic);
+		sensors.push_back(sensor);
+	}
+}
+
+void MqttSensorSource::onClientError(QMqttClient::ClientError error)
+{
+	qWarning()<<"MQTT Client error:"<<error;
+}
+
+MqttSensorSource::SensorSubscription& MqttSensorSource::findSubscription(const QString& topic)
+{
+	for(SensorSubscription& sensor : sensors)
+	{
+		if(baseTopicName + "/" + sensor.topic == topic)
+			return sensor;
+	}
+	assert(false);
+}
+
+void MqttSensorSource::onClientStateChanged(QMqttClient::ClientState state)
+{
+	if(state == QMqttClient::ClientState::Connected)
+	{
+		qInfo()<<"Connected to MQTT broker at "<<client.hostname()<<client.port();
+		for(SensorSubscription& sensor : sensors)
+		{
+			qDebug()<<"MQTT subscribeing to"<<baseTopicName + "/" + sensor.topic;
+			sensor.subscription = client.subscribe(baseTopicName + "/" + sensor.topic);
+			connect(sensor.subscription, &QMqttSubscription::messageReceived, this, &MqttSensorSource::onMessageReceived);
+		}
+	}
+	else if (state == QMqttClient::ClientState::Disconnected)
+	{
+		qWarning()<<"Lost connection to MQTT broker";
+		for(SensorSubscription& sensor : sensors)
+		{
+			if(sensor.subscription)
+			{
+				client.unsubscribe(sensor.topic);
+				sensor.subscription = nullptr;
+			}
+		}
+	}
+	else if(state == QMqttClient::ClientState::Connecting)
+	{
+		qInfo()<<"Connecting to MQTT broker at "<<client.hostname()<<client.port();
+	}
+}
+
+void MqttSensorSource::onMessageReceived(const QMqttMessage& message)
+{
+	Sensor sensor;
+	SensorSubscription& sensorSub = findSubscription(message.topic().name());
+	QString baseName = sensorSub.name;
+	sensor.id = sensorSub.id;
+	sensor.updateSeen();
+
+	QJsonDocument doc = QJsonDocument::fromJson(message.payload());
+	if(doc.isObject())
+	{
+		QJsonObject obj = doc.object();
+		if(obj.contains("temperature"))
+		{
+			sensor.name = baseName + " Temperature";
+			sensor.type = Sensor::TYPE_TEMPERATURE;
+			sensor.field = obj["temperature"].toDouble(0);
+			stateChanged(sensor);
+		}
+
+		if(obj.contains("humidity"))
+		{
+			sensor.name = baseName + " Humidity";
+			sensor.type = Sensor::TYPE_HUMIDITY;
+			sensor.field = obj["humidity"].toDouble(0);
+			stateChanged(sensor);
+		}
+
+		if(obj.contains("illuminance"))
+		{
+			sensor.name = baseName + " Illuminance";
+			sensor.type = Sensor::TYPE_BRIGHTNESS;
+			sensor.field = obj["illuminance"].toDouble(0);
+			stateChanged(sensor);
+		}
+
+		if(obj.contains("presence"))
+		{
+			sensor.name = baseName + " Presence";
+			sensor.type = Sensor::TYPE_OCUPANCY;
+			sensor.field = obj["presence"].toBool() ? 1 : 0;
+			stateChanged(sensor);
+		}
+
+		if(obj.contains("co2"))
+		{
+			sensor.name = baseName + " co2";
+			sensor.type = Sensor::TYPE_CO2;
+			sensor.field = obj["co2"].toDouble(0);
+			stateChanged(sensor);
+		}
+
+		if(obj.contains("formaldehyd"))
+		{
+			sensor.name = baseName + " Formaldehyd";
+			sensor.type = Sensor::TYPE_FORMALDEHYD;
+			sensor.field = obj["formaldehyd"].toDouble(0);
+			stateChanged(sensor);
+		}
+
+		if(obj.contains("pm25"))
+		{
+			sensor.name = baseName + " pm25";
+			sensor.type = Sensor::TYPE_PM25;
+			sensor.field = obj["pm25"].toDouble(0);
+			stateChanged(sensor);
+		}
+
+		if(obj.contains("voc"))
+		{
+			sensor.name = baseName + " VOC";
+			sensor.type = Sensor::TYPE_TOTAL_VOC;
+			sensor.field = obj["voc"].toDouble(0);
+			stateChanged(sensor);
+		}
+	}
+}
+
+void MqttSensorSource::store(QJsonObject& json)
+{
+	json["Host"] = client.hostname();
+	json["Port"] = client.port();
+	json["BaseTopic"] = baseTopicName;
+	if(client.username() != "")
+		json["User"] = client.username();
+	if(client.password() != "")
+		json["Password"] = client.password();
+	QJsonArray sensorsArray;
+	for(const SensorSubscription& sensor : sensors)
+	{
+		QJsonObject sensorObject;
+		sensorObject["Name"] = sensor.name;
+		sensorObject["Topic"] = sensor.topic;
+		sensorsArray.append(sensorObject);
+	}
+	json["Sensors"] = sensorsArray;
+}
+

src/sensors/mqttsensorsource.h

@@ -0,0 +1,44 @@
+#ifndef MQTTSENSORSOURCE_H
+#define MQTTSENSORSOURCE_H
+
+#include <QObject>
+#include <QJsonObject>
+#include <QtMqtt/QMqttClient>
+#include <vector>
+
+#include "sensor.h"
+
+class MqttSensorSource : public QObject
+{
+	Q_OBJECT
+
+	struct SensorSubscription
+	{
+		uint64_t id;
+		QString topic;
+		QString name;
+		QMqttSubscription* subscription = nullptr;
+	};
+
+	QString baseTopicName;
+	std::vector<SensorSubscription> sensors;
+	QMqttClient client;
+
+private:
+	SensorSubscription& findSubscription(const QString& topic);
+
+private slots:
+	void onClientStateChanged(QMqttClient::ClientState state);
+	void onMessageReceived(const QMqttMessage& message);
+	void onClientError(QMqttClient::ClientError error);
+
+public:
+	explicit MqttSensorSource(QObject *parent = nullptr);
+	void start(const QJsonObject& settings);
+	void store(QJsonObject& json);
+
+signals:
+	void stateChanged(Sensor sensor);
+};
+
+#endif // MQTTSENSORSOURCE_H

src/sensors/ocupancysensor.cpp

@@ -1,61 +0,0 @@
-#include "ocupancysensor.h"
-#include <QTimer>
-#include <QDebug>
-
-#include "../apgetconnected.h"
-
-
-OcupancySensorSource::OcupancySensorSource(QObject *parent,  const QString& device, const QString& deviceMac): QObject (parent), deviceMac_(deviceMac), device_(device)
-{
-    QTimer::singleShot(timeoutMs, this, &OcupancySensorSource::Timeout);
-}
-
-void OcupancySensorSource::sensorEvent(Sensor sensor)
-{
-    if(sensor.type == Sensor::TYPE_DOOR && sensor.id == 1 && sensor.field != 0.0f)
-    {
-        if(occupied == false) stateChanged(Sensor(Sensor::TYPE_OCUPANCY, 0, 1, "Occupancy"));
-        QTimer::singleShot(timeoutMs, this, &OcupancySensorSource::Timeout);
-    }
-}
-
-void OcupancySensorSource::Timeout()
-{
-    int error = 0;
-    qDebug()<<"testing for occupancy";
-    std::vector<uint64_t> devices = ap::connectedDevices(device_.toLatin1().toStdString(), error);
-    if(error == 0)
-    {
-        bool found = false;
-        for(size_t i = 0; i < devices.size(); ++i)
-        {
-            std::string mac = ap::macAddrToString(devices[i]);
-            if(mac.find(deviceMac_.toLatin1().toStdString()) != std::string::npos)
-            {
-                found = true;
-                qDebug()<<"occupied";
-                break;
-            }
-        }
-        stateChanged(Sensor(Sensor::TYPE_OCUPANCY, 0, found, "Occupancy"));
-        occupied = found;
-    }
-    else
-    {
-        stateChanged(Sensor(Sensor::TYPE_OCUPANCY, 0, true, "Occupancy"));
-        qDebug()<<"occupancy sensor error "<<error;
-    }
-
-}
-
-void OcupancySensorSource::store(QJsonObject &json)
-{
-    json["Device"] = device_;
-    json["MacAddres"] = deviceMac_;
-}
-
-void OcupancySensorSource::load(const QJsonObject &json)
-{
-    device_ = json["Device"].toString("wlan0");
-    deviceMac_ = json["MacAddres"].toString("60:BE:B5:25:8C:E0");
-}

src/sensors/ocupancysensor.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QJsonObject>
-#include "sensor.h"
-
-class OcupancySensorSource : public QObject
-{
-    Q_OBJECT
-private:
-
-    QString deviceMac_;
-    QString device_;
-    bool occupied = true;
-    static constexpr unsigned timeoutMs = (15 * 60) * 1000;
-
-public:
-    explicit OcupancySensorSource(QObject *parent = nullptr, const QString& device = "wlan0", const QString& deviceMac = "60:BE:B5:25:8C:E0");
-
-    void store(QJsonObject& json);
-    void load(const QJsonObject& json);
-
-public slots:
-    void sensorEvent(Sensor sensor);
-
-private slots:
-
-    void Timeout();
-
-signals:
-    void stateChanged(Sensor sensor);
-};

src/sensors/sensor.h

@@ -4,6 +4,7 @@
 #include<QDateTime>
 #include<QObject>
 #include<vector>
+#include<QJsonObject>
 
 class Sensor
 {
@@ -16,6 +17,10 @@ public:
 	static constexpr uint8_t TYPE_BRIGHTNESS = 4;
 	static constexpr uint8_t TYPE_BUTTON     = 5;
 	static constexpr uint8_t TYPE_ADC        = 6;
+	static constexpr uint8_t TYPE_CO2        = 7;
+	static constexpr uint8_t TYPE_FORMALDEHYD= 8;
+	static constexpr uint8_t TYPE_PM25       = 9;
+	static constexpr uint8_t TYPE_TOTAL_VOC  = 10;
 	static constexpr uint8_t TYPE_LOWBATTERY = 128;
 	static constexpr uint8_t TYPE_SHUTDOWN_IMMINENT = 251;
 	static constexpr uint8_t TYPE_OCUPANCY = 252;
@@ -24,49 +29,94 @@ public:
 	static constexpr uint8_t TYPE_DUMMY = 255;
 
 	uint8_t type;
-    uint8_t id;
+	uint64_t id;
 	float field;
 	QString name;
 	QDateTime lastSeen;
 	bool hidden;
 
-    Sensor(uint8_t typeIn, uint8_t idIn, float fieldIn = 0, QString nameIn = "", bool hiddenIn = false): type(typeIn), id(idIn), field(fieldIn), name(nameIn), hidden(hiddenIn)
+	Sensor(uint64_t typeIn, uint8_t idIn, float fieldIn = 0, QString nameIn = "", bool hiddenIn = false): type(typeIn),
+		id(idIn), field(fieldIn), name(nameIn), hidden(hiddenIn)
 	{
 		lastSeen = QDateTime::currentDateTime();
-        if(nameIn == "") generateName();
+		if(nameIn == "")
+			generateName();
 	}
 	Sensor(QString nameIn = "dummy"): type(TYPE_DUMMY), id(0), field(0), name(nameIn), hidden(false)
 	{
 		lastSeen = QDateTime::currentDateTime();
 	}
-    inline bool operator==(const Sensor& in) const{ return type==in.type && id == in.id; }
-    inline bool operator!=(const Sensor& in) const{ return !(*this==in); }
-    inline void updateSeen(){lastSeen = QDateTime::currentDateTime();}
+	Sensor(const QJsonObject& json)
+	{
+		type = json["SensorType"].toInt(0);
+		id = json["Id"].toInt(0);
+		field = json["Field"].toDouble(0);
+		name = json["Name"].toString("Sensor");
+		lastSeen = QDateTime::fromString(json["LastSeen"].toString(""));
+		hidden = json["Hidden"].toBool(false);
+	}
+	inline bool operator==(const Sensor& in) const
+	{
+		return type==in.type && id == in.id;
+	}
+	inline bool operator!=(const Sensor& in) const
+	{
+		return !(*this==in);
+	}
+	inline void updateSeen()
+	{
+		lastSeen = QDateTime::currentDateTime();
+	}
 	static Sensor sensorFromString(const QString& str)
 	{
 		QStringList bufferList = str.split(' ');
 		if(bufferList.size() >= 7)
 		{
 			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(sensor.type == Sensor::TYPE_HUMIDITY ||  sensor.type == Sensor::TYPE_TEMPERATURE)
+				sensor.field = sensor.field/10;
+
+			if(bufferList.size() >= 9)
+				sensor.lastSeen = QDateTime::fromSecsSinceEpoch(bufferList[8].toLongLong());
 			return sensor;
 		}
-        else return Sensor(TYPE_DUMMY, 0, 0, "", true);
+		else
+		{
+			return Sensor(TYPE_DUMMY, 0, 0, "", true);
+		}
 	}
 	QString toString()
 	{
 		return QString("SENSOR TYPE: ")+QString::number(type)+" ID: "+QString::number(id)+" FIELD: "+
-               QString::number((type == Sensor::TYPE_HUMIDITY ||  type == Sensor::TYPE_TEMPERATURE) ? field*10 : field);
+			   QString::number((type == Sensor::TYPE_HUMIDITY ||  type == Sensor::TYPE_TEMPERATURE) ? field*10 : field) +
+			   " TIME: " + QString::number(lastSeen.toSecsSinceEpoch());
+	}
+	inline void store(QJsonObject& json)
+	{
+		json["Type"] = "Sensor";
+		json["SensorType"] = static_cast<int>(type);
+		json["Id"] = static_cast<int>(id);
+		json["Field"] = field;
+		json["Name"] = name;
+		json["LastSeen"] = lastSeen.toString();
+		json["Hidden"] = hidden;
 	}
 	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_BUTTON)  name = "Button " + 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";
+		if(type == TYPE_TEMPERATURE)
+			name = "Temperature " + QString::number(id);
+		else if(type == TYPE_DOOR)
+			name = "Door " + QString::number(id);
+		else if(type == TYPE_BUTTON)
+			name = "Button " + 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);
 	}
 };
@@ -80,9 +130,12 @@ private:
 public:
 
 	SensorStore(QObject *parent = nullptr);
-    virtual ~SensorStore(){}
+	virtual ~SensorStore() {}
 
-    inline std::vector<Sensor>* getSensors(){ return &sensors_; }
+	inline std::vector<Sensor>* getSensors()
+	{
+		return &sensors_;
+	}
 
 
 public slots:

src/sensors/speakersensor.cpp

@@ -1,59 +0,0 @@
-#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

@@ -1,45 +0,0 @@
-#ifndef AMPMANAGER_H
-#define AMPMANAGER_H
-
-#include <iostream>
-
-#include <QObject>
-#include <QRunnable>
-#include <QScopedPointer>
-#include <QEventLoop>
-#include <QTimer>
-#include <QProcess>
-#include <QByteArray>
-
-#include "sensor.h"
-
-
-class SpeakerSensorSource : public QObject
-{
-    Q_OBJECT
-private:
-    QString name_;
-    bool state = true;
-    QTimer timer;
-
-public:
-    explicit SpeakerSensorSource(QString name = "", QObject *parent = nullptr);
-    ~SpeakerSensorSource();
-
-public slots:
-    void run();
-    void abort();
-
-signals:
-    void stateChanged(Sensor sensor);
-
-private slots:
-    void doTick();
-
-private:
-    long silenceCount = 0;
-
-    QProcess arecord;
-};
-
-#endif // AMPMANAGER_H

src/sensors/sunsensor.h

@@ -2,7 +2,7 @@
 
 #include <QTimer>
 
-#include "../sun.h"
+#include "sun.h"
 #include "sensor.h"
 
 

src/service/service.cpp

@@ -0,0 +1,104 @@
+#include <QTcpSocket>
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <iostream>
+
+#include "items/item.h"
+#include "items/itemstore.h"
+#include "service.h"
+
+
+Service::Service(QObject* parent):
+	ItemSource(parent)
+{}
+
+QJsonObject Service::createMessage(const QString& type, const QJsonArray& data)
+{
+	QJsonObject json;
+	json["MessageType"] = type;
+	json["Data"] = data;
+	return json;
+}
+
+void Service::sensorEvent(Sensor sensor)
+{
+	QJsonArray sensors;
+	QJsonObject sensorjson;
+	sensor.store(sensorjson);
+	sensors.append(sensorjson);
+	QJsonObject json = createMessage("SensorUpdate", sensors);
+	sendJson(json);
+}
+
+void Service::itemUpdated(std::weak_ptr<Item> item)
+{
+	qDebug()<<__func__;
+	QJsonArray items;
+	QJsonObject itemjson;
+	item.lock()->store(itemjson);
+	items.append(itemjson);
+	QJsonObject json = createMessage("ItemUpdate", items);
+	json["FullList"] = false;
+	sendJson(json);
+}
+
+void Service::refresh()
+{
+	sendJson(createMessage("GetSensors", QJsonArray()));
+	sendJson(createMessage("GetItems", QJsonArray()));
+}
+
+void Service::sendSensors()
+{
+	QJsonArray sensors;
+	for(auto& sensor: *globalSensors.getSensors())
+	{
+		QJsonObject sensorjson;
+		sensor.store(sensorjson);
+		sensors.append(sensorjson);
+	}
+	sendJson(createMessage("SensorUpdate", sensors));
+}
+
+void Service::sendItems()
+{
+	QJsonArray items;
+	for(auto& item: *globalItems.getItems())
+	{
+		QJsonObject itemjson;
+		item->store(itemjson);
+		items.append(itemjson);
+	}
+	QJsonObject json = createMessage("ItemUpdate", items);
+	json["FullList"] = true;
+	sendJson(json);
+}
+
+
+void Service::processIncomeingJson(const QByteArray& jsonbytes)
+{
+	QJsonDocument doc = QJsonDocument::fromJson(jsonbytes);
+	qDebug()<<"Got Json:"<<QString::fromLatin1(doc.toJson(QJsonDocument::JsonFormat::Indented));
+	QJsonObject json = doc.object();
+	QString type = json["MessageType"].toString();
+	if(type == "GetSensors")
+	{
+		qDebug()<<"Sending sensors";
+		sendSensors();
+	}
+	else if(type == "GetItems")
+	{
+		qDebug()<<"Sending Items";
+		sendItems();
+	}
+	else if(type == "SensorUpdate")
+	{
+		QJsonArray data = json["Data"].toArray();
+		for(QJsonValueRef sensorjson : data)
+		{
+			QJsonObject jsonobject = sensorjson.toObject();
+			Sensor sensor(jsonobject);
+			gotSensor(sensor);
+		}
+	}
+}

src/service/service.h

@@ -0,0 +1,42 @@
+#ifndef TCPSERVER_BASE_H
+#define TCPSERVER_BASE_H
+
+#include <QTcpServer>
+#include <vector>
+
+#include "sensors/sensor.h"
+#include "items/item.h"
+#include "items/itemsource.h"
+
+class Service : public ItemSource
+{
+	Q_OBJECT
+protected:
+
+	typedef enum
+	{
+		STATE_IDLE,
+		STATE_RECV_JSON,
+	} client_state_t;
+
+signals:
+	void gotSensor(Sensor sensor);
+
+public slots:
+	void sensorEvent(Sensor sensor);
+	void itemUpdated(std::weak_ptr<Item> item);
+	virtual void refresh() override;
+
+public:
+	Service(QObject* parent = nullptr);
+	void sendSensors();
+	void sendItems();
+	virtual void sendJson(const QJsonObject& json) = 0;
+	virtual bool launch(const QHostAddress &address = QHostAddress::Any, quint16 port = 0) = 0;
+
+protected:
+	static QJsonObject createMessage(const QString& type, const QJsonArray& data);
+	virtual void processIncomeingJson(const QByteArray& jsonbytes);
+};
+
+#endif // TCPSERVER_BASE_H

src/service/tcpclient.cpp

@@ -0,0 +1,100 @@
+#include <QTcpSocket>
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <iostream>
+
+#include "items/item.h"
+#include "service.h"
+#include "tcpclient.h"
+
+TcpClient::TcpClient(QObject* parent):
+	Service(parent),
+	socket(new QTcpSocket(this))
+{
+	connect(socket, &QTcpSocket::readyRead, this, &TcpClient::socketReadyRead);
+}
+
+void TcpClient::sendJson(const QJsonObject& json)
+{
+	QByteArray jsonData = QJsonDocument(json).toJson();
+	socket->write(QString("MSG JSON LEN " + QString::number(jsonData.size()) + "\n").toLatin1() + jsonData);
+}
+
+bool TcpClient::launch(const QHostAddress &address, quint16 port)
+{
+	socket->connectToHost(address, port);
+	return socket->waitForConnected(2000);
+}
+
+void TcpClient::processIncomeingJson(const QByteArray& jsonbytes)
+{
+	QJsonDocument doc = QJsonDocument::fromJson(jsonbytes);
+	QJsonObject json = doc.object();
+	QString type = json["MessageType"].toString();
+	if(type == "ItemUpdate")
+	{
+		std::cout<<"Got item json:\n"<<QString::fromLatin1(jsonbytes).toStdString();
+		QJsonArray data = json["Data"].toArray();
+		std::vector<std::shared_ptr<Item>> items;
+		for(QJsonValueRef itemjson : data)
+		{
+			QJsonObject jsonobject = itemjson.toObject();
+			std::shared_ptr<Item> item = Item::loadItem(jsonobject);
+			if(item)
+			{
+				item->setLoaded(false);
+				items.push_back(item);
+			}
+		}
+		if(!items.empty())
+			gotItems(items, true);
+	}
+	else
+	{
+		Service::processIncomeingJson(jsonbytes);
+	}
+}
+
+void TcpClient::processComand(const QByteArray& command)
+{
+	if(command.startsWith("MSG JSON LEN "))
+	{
+		state = STATE_RECV_JSON;
+		recievebytes = command.mid(13).toLongLong();
+	}
+}
+
+void TcpClient::socketReadyRead()
+{
+	buffer += socket->readAll();
+	bool remianing = true;
+	while(remianing)
+	{
+		remianing = false;
+		while(state == STATE_IDLE && buffer.contains('\n'))
+		{
+			size_t newlineIndex = buffer.indexOf('\n');
+			QByteArray command = buffer.left(newlineIndex);
+			buffer.remove(0, newlineIndex+1);
+			processComand(command);
+			remianing = true;
+		}
+		if(state == STATE_RECV_JSON)
+		{
+			if(recievebytes <= buffer.size())
+			{
+				QByteArray json = buffer.left(recievebytes);
+				buffer.remove(0, recievebytes);
+				recievebytes = 0;
+				state = STATE_IDLE;
+				processIncomeingJson(json);
+				remianing = true;
+			}
+		}
+	}
+}
+
+TcpClient::~TcpClient()
+{
+	delete socket;
+}

src/service/tcpclient.h

@@ -0,0 +1,33 @@
+#ifndef TCPSERVER_CLIENT_H
+#define TCPSERVER_CLIENT_H
+
+#include <QTcpSocket>
+#include <QJsonDocument>
+#include <QJsonArray>
+
+#include "service.h"
+
+class TcpClient : public Service
+{
+	Q_OBJECT
+
+	QTcpSocket* socket;
+	client_state_t state = STATE_IDLE;
+	long long recievebytes = 0;
+	QByteArray buffer;
+
+public:
+	TcpClient(QObject* parent = nullptr);
+	~TcpClient();
+	virtual bool launch(const QHostAddress &address = QHostAddress::Any, quint16 port = 0) override;
+	virtual void sendJson(const QJsonObject& json) override;
+
+protected:
+	virtual void processIncomeingJson(const QByteArray& jsonbytes) override;
+
+private slots:
+	void socketReadyRead();
+	void processComand(const QByteArray& command);
+};
+
+#endif // TCPSERVER_CLIENT_H

src/service/tcpserver.cpp

@@ -0,0 +1,153 @@
+#include <QTcpServer>
+#include <vector>
+#include <QTcpSocket>
+#include <QJsonArray>
+
+#include "items/item.h"
+#include "service.h"
+#include "tcpserver.h"
+
+TcpServer::TcpServer(QObject* parent):
+	Service(parent),
+	server(this)
+{
+	connect(&server, &QTcpServer::newConnection, this, &TcpServer::incomingConnection);
+}
+
+void TcpServer::sendJson(const QJsonObject& json)
+{
+	for(auto client: clients)
+	{
+		QByteArray jsonData = QJsonDocument(json).toJson();
+		client.socket->write(QString("MSG JSON LEN " + QString::number(jsonData.size()) + "\n").toLatin1() + jsonData);
+	}
+}
+
+void TcpServer::processIncomeingJson(const QByteArray& jsonbytes)
+{
+	QJsonDocument doc = QJsonDocument::fromJson(jsonbytes);
+	QJsonObject json = doc.object();
+	QString type = json["MessageType"].toString();
+	if(type == "ItemUpdate")
+	{
+		qDebug()<<"Got Items";
+		QJsonArray data = json["Data"].toArray();
+		bool FullList = json["FullList"].toBool(false);
+		std::vector<std::shared_ptr<Item>> items;
+		for(QJsonValueRef itemjson : data)
+		{
+			QJsonObject jsonobject = itemjson.toObject();
+			std::shared_ptr<Item> item = Item::loadItem(jsonobject);
+			item->setLoaded(FullList);
+			if(item)
+				items.push_back(item);
+		}
+		if(FullList && !items.empty())
+		{
+			requestReplaceItems(items);
+			sigRequestSave();
+		}
+		else if(!items.empty())
+		{
+			gotItems(items, false);
+		}
+	}
+	else
+	{
+		Service::processIncomeingJson(jsonbytes);
+	}
+}
+
+bool TcpServer::launch(const QHostAddress &address, quint16 port)
+{
+	return server.listen(address, port);
+}
+
+void TcpServer::incomingConnection()
+{
+	while(server.hasPendingConnections())
+	{
+		QTcpSocket* client = server.nextPendingConnection();
+		qDebug()<<"Got new client from"<<client->peerAddress().toString();
+		if(client)
+		{
+			clients.push_back({client});
+			connect(client, &QTcpSocket::errorOccurred, this, &TcpServer::socketError);
+			connect(client, &QTcpSocket::disconnected, this, &TcpServer::socketDisconnect);
+			connect(client, &QTcpSocket::readyRead, this, &TcpServer::socketReadyRead);
+		}
+	}
+}
+
+void TcpServer::socketError(QAbstractSocket::SocketError socketError)
+{
+	(void)socketError;
+	for(size_t i = 0; i < clients.size(); i++)
+	{
+		if(clients[i].socket == TcpServer::sender())
+		{
+			clients.erase(clients.begin()+i);
+			--i;
+		}
+	}
+}
+void TcpServer::socketDisconnect()
+{
+	for(size_t i = 0; i < clients.size(); i++)
+	{
+		if(clients[i].socket == TcpServer::sender())
+		{
+			clients.erase(clients.begin()+i);
+			--i;
+		}
+	}
+}
+
+void TcpServer::processComand(const QByteArray& command, Client& client)
+{
+	if(command.startsWith("MSG JSON LEN "))
+	{
+		client.state = STATE_RECV_JSON;
+		client.recievebytes = command.mid(13).toLongLong();
+		qDebug()<<"Got command:"<<QString::fromLatin1(command);
+	}
+}
+
+void TcpServer::socketReadyRead()
+{
+	for(size_t i = 0; i < clients.size(); i++)
+	{
+		if(clients[i].socket == sender())
+		{
+			QByteArray newChars = clients[i].socket->readAll();
+			clients[i].buffer += newChars;
+
+			bool remianing = true;
+			while(remianing)
+			{
+				qDebug()<<clients[i].buffer;
+				remianing = false;
+				while(clients[i].state == STATE_IDLE && clients[i].buffer.contains('\n'))
+				{
+					size_t newlineIndex = clients[i].buffer.indexOf('\n');
+					QByteArray command = clients[i].buffer.left(newlineIndex);
+					clients[i].buffer.remove(0, newlineIndex+1);
+					processComand(command, clients[i]);
+					remianing = true;
+				}
+				if(clients[i].state == STATE_RECV_JSON)
+				{
+					if(clients[i].recievebytes <= clients[i].buffer.size())
+					{
+						QByteArray json = clients[i].buffer.left(clients[i].recievebytes);
+						clients[i].buffer.remove(0, clients[i].recievebytes);
+						clients[i].recievebytes = 0;
+						clients[i].state = STATE_IDLE;
+						processIncomeingJson(json);
+						remianing = true;
+					}
+				}
+			}
+		}
+	}
+}

src/service/tcpserver.h

@@ -0,0 +1,45 @@
+#ifndef TCPSERVER_SERVER_H
+#define TCPSERVER_SERVER_H
+
+#include <QTcpServer>
+#include <vector>
+
+#include "service.h"
+
+class TcpServer : public Service
+{
+	Q_OBJECT
+
+	struct Client
+	{
+		QTcpSocket* socket;
+		QByteArray buffer;
+		client_state_t state = STATE_IDLE;
+		long long recievebytes = 0;
+	};
+
+	std::vector<Client> clients;
+	QTcpServer server;
+
+public:
+	TcpServer(QObject* parent = nullptr);
+	virtual  bool launch(const QHostAddress &address = QHostAddress::Any, quint16 port = 0) override;
+	virtual void sendJson(const QJsonObject& json) override;
+
+signals:
+	void sigRequestSave();
+
+private slots:
+	void incomingConnection();
+	void socketError(QAbstractSocket::SocketError socketError);
+	void socketDisconnect();
+	void socketReadyRead();
+
+protected:
+	virtual void processIncomeingJson(const QByteArray& jsonbytes) override;
+
+private:
+	void processComand(const QByteArray& command, Client& client);
+};
+
+#endif // TCPSERVER_SERVER_H

src/sun.cpp

@@ -63,7 +63,8 @@ std::time_t Sun::JdTime::toStdTime()
 	return millenniumTime;
 }
 
-Sun::Sun(double latitude, double longitude, double altitude): latitude_(latitude), longetude_(longitude), altitude_(altitude)
+Sun::Sun(double latitude, double longitude, double altitude): latitude_(latitude), longetude_(longitude),
+	altitude_(altitude)
 {}
 
 double Sun::nextMeanSolarNoonJD(const JdTime& time)
@@ -78,7 +79,8 @@ double Sun::meanSolarAnomaly(double meanSolarNoon)
 
 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);
+	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)
@@ -108,7 +110,8 @@ double Sun::hourAngle(double localSolarTime)
 
 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)));
+	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()
@@ -120,7 +123,8 @@ double Sun::altitude()
 	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);
+	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);
 }
@@ -133,7 +137,8 @@ double Sun::maximumAltitude()
 	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);
+	double cosZenithAngle = sin(latitude_*TO_RADS)*sin(declinationValue*TO_RADS)+cos(latitude_*TO_RADS)*cos(
+	                            declinationValue*TO_RADS);
 
 	return TO_DEGS*asin(cosZenithAngle);
 }
@@ -143,7 +148,6 @@ double Sun::azimuth()
 	return 0;
 }
 
-
 std::time_t Sun::riseTime()
 {
 	JdTime time;
@@ -153,10 +157,12 @@ std::time_t Sun::riseTime()
 	double declinationValue       = solarDeclination(eclipticLongitudeValue);
 	double hourAngleValue         = hourAngleAtSunset(declinationValue);
 
-	time.julianDate = meanSolarNoonValue + equationOfTime(meanSolarAnomalyValue, eclipticLongitudeValue) - hourAngleValue/360.0;
+	time.julianDate = meanSolarNoonValue + equationOfTime(meanSolarAnomalyValue,
+	                  eclipticLongitudeValue) - hourAngleValue/360.0;
 
 	return time.toStdTime();
 }
+
 std::time_t Sun::setTime()
 {
 	JdTime time;
@@ -166,12 +172,12 @@ std::time_t Sun::setTime()
 	double declinationValue       = solarDeclination(eclipticLongitudeValue);
 	double hourAngleValue         = hourAngleAtSunset(declinationValue);
 
-	time.julianDate = meanSolarNoonValue + equationOfTime(meanSolarAnomalyValue, eclipticLongitudeValue) + hourAngleValue/360.0;
+	time.julianDate = meanSolarNoonValue + equationOfTime(meanSolarAnomalyValue,
+	                  eclipticLongitudeValue) + hourAngleValue/360.0;
 
 	return time.toStdTime();
 }
 
-
 double Sun::declination()
 {
 	JdTime time;

src/ui/actorsettingsdialog.cpp

@@ -16,9 +16,9 @@ ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<AlarmTime> alarm, QWidg
 }
 
 ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<SensorActor> actor, QWidget *parent) :
-QDialog(parent),
-actor_(actor),
-ui(new Ui::ActorSettingsDialog)
+	QDialog(parent),
+	actor_(actor),
+	ui(new Ui::ActorSettingsDialog)
 {
 	init();
 
@@ -38,9 +38,9 @@ ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<Regulator> actor, QWidg
 }
 
 ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<TimerActor> actor, QWidget *parent) :
-QDialog(parent),
-actor_(actor),
-ui(new Ui::ActorSettingsDialog)
+	QDialog(parent),
+	actor_(actor),
+	ui(new Ui::ActorSettingsDialog)
 {
 	init();
 
@@ -49,9 +49,9 @@ ui(new Ui::ActorSettingsDialog)
 }
 
 ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<PolynomalActor> actor, QWidget *parent) :
-QDialog(parent),
-actor_(actor),
-ui(new Ui::ActorSettingsDialog)
+	QDialog(parent),
+	actor_(actor),
+	ui(new Ui::ActorSettingsDialog)
 {
 	init();
 
@@ -60,9 +60,9 @@ ui(new Ui::ActorSettingsDialog)
 }
 
 ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<MultiFactorActor> actor, QWidget *parent) :
-QDialog(parent),
-actor_(actor),
-ui(new Ui::ActorSettingsDialog)
+	QDialog(parent),
+	actor_(actor),
+	ui(new Ui::ActorSettingsDialog)
 {
 	init();
 	widget = new FactorActorWidget(actor, this);
@@ -70,9 +70,9 @@ ui(new Ui::ActorSettingsDialog)
 }
 
 ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<Actor> actor, QWidget *parent) :
-QDialog(parent),
-actor_(actor),
-ui(new Ui::ActorSettingsDialog)
+	QDialog(parent),
+	actor_(actor),
+	ui(new Ui::ActorSettingsDialog)
 {
 	init();
 }
@@ -83,14 +83,20 @@ void ActorSettingsDialog::init()
 	connect(ui->comboBox_action, SIGNAL(currentIndexChanged(int)), this, SLOT(changeAction(int)));
 	connect(ui->spinBox,  SIGNAL(valueChanged(int)), this, SLOT(valueChanged(int)));
 	connect(ui->pushButton_editItem, &QPushButton::clicked, this, &ActorSettingsDialog::editAsItem);
+	connect(ui->pushButton_enable, &QPushButton::clicked, this, &ActorSettingsDialog::setEnabled);
 	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);
+	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);
 
 	ui->label_Exausted->setText(actor_->isExausted() ? "True" : "False");
+	ui->label_Enabled->setText(actor_->isActive() ? "True" : "False");
+	ui->pushButton_enable->setText(actor_->isActive() ? "Disable" : "Enable");
 }
 
 ActorSettingsDialog::~ActorSettingsDialog()
@@ -104,6 +110,13 @@ void ActorSettingsDialog::editAsItem()
 	itemSettingsDiag.exec();
 }
 
+void ActorSettingsDialog::setEnabled()
+{
+	actor_->setActive(!actor_->isActive());
+	ui->label_Enabled->setText(actor_->isActive() ? "True" : "False");
+	ui->pushButton_enable->setText(actor_->isActive() ? "Disable" : "Enable");
+}
+
 void ActorSettingsDialog::valueChanged(int value)
 {
 	actor_->setTriggerValue(value);

src/ui/actorsettingsdialog.h

@@ -10,7 +10,8 @@
 #include "actorwidgets/polynomalactorwidget.h"
 #include "actorwidgets/factoractorwidget.h"
 
-namespace Ui {
+namespace Ui
+{
 class ActorSettingsDialog;
 }
 
@@ -40,6 +41,7 @@ private slots:
 	void changeAction(int index);
 	void valueChanged(int value);
 	void editAsItem();
+	void setEnabled();
 
 
 private:

src/ui/actorsettingsdialog.ui

@@ -85,6 +85,63 @@
          </property>
         </widget>
        </item>
+       <item>
+        <spacer name="horizontalSpacer_2">
+         <property name="orientation">
+          <enum>Qt::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </item>
+     <item>
+      <layout class="QHBoxLayout" name="horizontalLayout_3">
+       <item>
+        <widget class="QLabel" name="label_3">
+         <property name="text">
+          <string>Enabled:</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QLabel" name="label_Enabled">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="text">
+          <string>True</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="QPushButton" name="pushButton_enable">
+         <property name="text">
+          <string>Enable</string>
+         </property>
+        </widget>
+       </item>
       </layout>
      </item>
      <item>

src/ui/actorwidgets/alarmwidget.cpp

@@ -7,11 +7,6 @@ AlarmWidget::AlarmWidget(std::shared_ptr<AlarmTime> alarm, QWidget *parent) :
 	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());
 
@@ -31,11 +26,20 @@ AlarmWidget::AlarmWidget(std::shared_ptr<AlarmTime> alarm, QWidget *parent) :
 		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);
+	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->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);
 	connect(ui->dateTimeEdit, &QDateTimeEdit::dateTimeChanged, alarm.get(), &AlarmTime::changeTime);
 }
 
@@ -46,10 +50,14 @@ AlarmWidget::~AlarmWidget()
 
 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);
+	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)

src/ui/actorwidgets/alarmwidget.h

@@ -5,7 +5,8 @@
 #include <memory>
 #include "../../actors/alarmtime.h"
 
-namespace Ui {
+namespace Ui
+{
 class AlarmWidget;
 }
 

src/ui/actorwidgets/alarmwidget.ui

@@ -24,16 +24,16 @@
   </property>
   <layout class="QFormLayout" name="formLayout">
    <property name="fieldGrowthPolicy">
-    <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
+    <enum>QFormLayout::FieldGrowthPolicy::AllNonFixedFieldsGrow</enum>
    </property>
    <property name="rowWrapPolicy">
-    <enum>QFormLayout::DontWrapRows</enum>
+    <enum>QFormLayout::RowWrapPolicy::DontWrapRows</enum>
    </property>
    <property name="labelAlignment">
-    <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
+    <set>Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignVCenter</set>
    </property>
    <property name="formAlignment">
-    <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
+    <set>Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop</set>
    </property>
    <property name="horizontalSpacing">
     <number>50</number>
@@ -57,7 +57,7 @@
       <bool>false</bool>
      </property>
      <property name="currentSection">
-      <enum>QDateTimeEdit::DaySection</enum>
+      <enum>QDateTimeEdit::Section::DaySection</enum>
      </property>
      <property name="displayFormat">
       <string>dd.MM.yyyy hh:mm</string>

src/ui/actorwidgets/factoractorwidget.h

@@ -4,7 +4,8 @@
 #include <QWidget>
 #include "../../actors/factoractor.h"
 
-namespace Ui {
+namespace Ui
+{
 class FactorActorWidget;
 }
 

src/ui/actorwidgets/polynomalactorwidget.cpp

@@ -1,7 +1,8 @@
 #include "polynomalactorwidget.h"
 #include "ui_polynomalactorwidget.h"
 
-PolynomalActorWidget::PolynomalActorWidget(std::shared_ptr<PolynomalActor> actor, SensorStore* sensors, QWidget *parent):
+PolynomalActorWidget::PolynomalActorWidget(std::shared_ptr<PolynomalActor> actor, SensorStore* sensors,
+        QWidget *parent):
 	QWidget(parent),
 	sensors_(sensors),
 	actor_(actor),
@@ -39,10 +40,11 @@ PolynomalActorWidget::~PolynomalActorWidget()
 
 void PolynomalActorWidget::setPow()
 {
-    actor_->setCoeffiancts(ui->doubleSpinBox_pow3->value(), ui->doubleSpinBox_pow2->value(), ui->doubleSpinBox_pow1->value(), ui->doubleSpinBox_pow0->value());
+	actor_->setCoeffiancts(ui->doubleSpinBox_pow3->value(), ui->doubleSpinBox_pow2->value(),
+	                       ui->doubleSpinBox_pow1->value(), ui->doubleSpinBox_pow0->value());
 }
 
 void PolynomalActorWidget::setSensor(const QModelIndex &index)
 {
-    actor_->setSensor(sensors_->getSensors()->at(index.row()));
+	actor_->setSensor(ui->listView->getSensorForIndex(index));
 }

src/ui/actorwidgets/polynomalactorwidget.h

@@ -4,7 +4,8 @@
 #include <QWidget>
 #include "../../actors/polynomalactor.h"
 
-namespace Ui {
+namespace Ui
+{
 class PolynomalActorWidget;
 }
 
@@ -15,7 +16,8 @@ class PolynomalActorWidget : public QWidget
 	std::shared_ptr<PolynomalActor> actor_;
 
 public:
-    explicit PolynomalActorWidget(std::shared_ptr<PolynomalActor> regulator, SensorStore* sensors = nullptr, QWidget *parent = nullptr);
+	explicit PolynomalActorWidget(std::shared_ptr<PolynomalActor> regulator, SensorStore* sensors = nullptr,
+	                              QWidget *parent = nullptr);
 	~PolynomalActorWidget();
 
 private slots:

src/ui/actorwidgets/polynomalactorwidget.ui

@@ -132,7 +132,7 @@
   <customwidget>
    <class>SensorListWidget</class>
    <extends>QListView</extends>
-   <header location="global">../src/ui/sensorlistwidget.h</header>
+   <header location="local">ui/sensorlistwidget.h</header>
   </customwidget>
  </customwidgets>
  <resources/>

src/ui/actorwidgets/regulatorwdiget.cpp

@@ -24,12 +24,17 @@ RegulatorWdiget::RegulatorWdiget(std::shared_ptr<Regulator> regulator, SensorSto
 	}
 	ui->doubleSpinBox_setPoint->setValue(regulator->getSetPoint());
 	ui->doubleSpinBox_band->setValue(regulator->getBand());
+	ui->spinBox_safe->setValue(regulator_->getSafeValue());
+	ui->spinBox_timeout->setValue(regulator_->getTimeout());
 
 	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)));
+	connect(ui->spinBox_safe, SIGNAL(valueChanged(int)), regulator_.get(), SLOT(setSafeValue(int)));
+	connect(ui->spinBox_timeout, SIGNAL(valueChanged(int)), regulator_.get(), SLOT(setTimeout(int)));
 }
 
+
 void RegulatorWdiget::setPoint(double in)
 {
 	regulator_->setPoint(in);
@@ -42,7 +47,7 @@ void RegulatorWdiget::setBand(double 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);
+	regulator_->setSensor(ui->listView->getSensorForIndex(index));
+	setPoint(ui->listView->getSensorForIndex(index).field);
+	ui->doubleSpinBox_setPoint->setValue(ui->listView->getSensorForIndex(index).field);
 }

src/ui/actorwidgets/regulatorwdiget.h

@@ -4,7 +4,8 @@
 #include <QWidget>
 #include "../../actors/regulator.h"
 
-namespace Ui {
+namespace Ui
+{
 class RegulatorWdiget;
 }
 
@@ -16,7 +17,8 @@ class RegulatorWdiget : public QWidget
 	SensorStore* sensors_;
 
 public:
-    explicit RegulatorWdiget(std::shared_ptr<Regulator> regulator, SensorStore* sensors = nullptr, QWidget *parent = nullptr);
+	explicit RegulatorWdiget(std::shared_ptr<Regulator> regulator, SensorStore* sensors = nullptr,
+	                         QWidget *parent = nullptr);
 	~RegulatorWdiget();
 
 private slots:

src/ui/actorwidgets/regulatorwdiget.ui

@@ -38,15 +38,8 @@
     </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>
+    <layout class="QGridLayout" name="gridLayout">
+     <item row="0" column="1">
       <widget class="QDoubleSpinBox" name="doubleSpinBox_setPoint">
        <property name="minimum">
         <double>-9999.989999999999782</double>
@@ -56,7 +49,7 @@
        </property>
       </widget>
      </item>
-     <item>
+     <item row="0" column="2">
       <widget class="QLabel" name="label_2">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
@@ -69,9 +62,46 @@
        </property>
       </widget>
      </item>
-     <item>
+     <item row="1" column="2">
+      <widget class="QLabel" name="label_5">
+       <property name="text">
+        <string>Timeout</string>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="0">
+      <widget class="QLabel" name="label_3">
+       <property name="text">
+        <string>Set Point</string>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="3">
       <widget class="QDoubleSpinBox" name="doubleSpinBox_band"/>
      </item>
+     <item row="1" column="0">
+      <widget class="QLabel" name="label_4">
+       <property name="text">
+        <string>Safety Value</string>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="1">
+      <widget class="QSpinBox" name="spinBox_safe"/>
+     </item>
+     <item row="1" column="3">
+      <widget class="QSpinBox" name="spinBox_timeout">
+       <property name="suffix">
+        <string> s</string>
+       </property>
+       <property name="maximum">
+        <number>999999999</number>
+       </property>
+       <property name="value">
+        <number>1800</number>
+       </property>
+      </widget>
+     </item>
     </layout>
    </item>
   </layout>
@@ -80,7 +110,7 @@
   <customwidget>
    <class>SensorListWidget</class>
    <extends>QListView</extends>
-   <header location="global">../src/ui/sensorlistwidget.h</header>
+   <header location="local">ui/sensorlistwidget.h</header>
   </customwidget>
  </customwidgets>
  <resources/>

src/ui/actorwidgets/sensoractorwidget.cpp

@@ -17,9 +17,12 @@ SensorActorWidget::SensorActorWidget(std::shared_ptr<SensorActor> sensorActor, S
 		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);
+	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());
 
@@ -47,6 +50,5 @@ void SensorActorWidget::setSlope(int index)
 
 void SensorActorWidget::setSensor(const QModelIndex &index)
 {
-    sensorActor_->setSensor(sensors_->getSensors()->at(index.row()));
-    qDebug()<<"Selected "<<sensors_->getSensors()->at(index.row()).name;
+	sensorActor_->setSensor(ui->listView->getSensorForIndex(index));
 }

src/ui/actorwidgets/sensoractorwidget.h

@@ -5,7 +5,8 @@
 #include <QItemSelection>
 #include "../../actors/sensoractor.h"
 
-namespace Ui {
+namespace Ui
+{
 class SensorActorWidget;
 }
 
@@ -17,7 +18,8 @@ class SensorActorWidget : public QWidget
 	SensorStore* sensors_;
 
 public:
-    explicit SensorActorWidget(std::shared_ptr<SensorActor> sensorActor, SensorStore* sensors = nullptr, QWidget *parent = nullptr);
+	explicit SensorActorWidget(std::shared_ptr<SensorActor> sensorActor, SensorStore* sensors = nullptr,
+	                           QWidget *parent = nullptr);
 	~SensorActorWidget();
 
 private slots:

src/ui/actorwidgets/sensoractorwidget.ui

@@ -89,7 +89,7 @@
   <customwidget>
    <class>SensorListWidget</class>
    <extends>QListView</extends>
-   <header location="global">../src/ui/sensorlistwidget.h</header>
+   <header location="local">ui/sensorlistwidget.h</header>
   </customwidget>
  </customwidgets>
  <resources/>

src/ui/actorwidgets/timeractorwidget.h

@@ -4,7 +4,8 @@
 #include <QWidget>
 #include "../../actors/timeractor.h"
 
-namespace Ui {
+namespace Ui
+{
 class TimerActorWidget;
 }
 

src/ui/itemcreationdialog.h

@@ -5,7 +5,8 @@
 #include <memory>
 #include "../items/item.h"
 
-namespace Ui {
+namespace Ui
+{
 class ItemCreationDialog;
 }
 

src/ui/itemscrollbox.cpp

@@ -21,18 +21,9 @@ 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 if(dynamic_cast<MessageItem*>(workItem.get()))
-        {
-            widgets_.push_back(new ItemWidget(item, false, true));
-        }
-        else
-        {
+		if(workItem->isHidden())
+			return;
 		widgets_.push_back(new ItemWidget(item));
-        }
 		ui->relayWidgetVbox->addWidget(widgets_.back());
 		connect(widgets_.back(), &ItemWidget::deleteRequest, this, &ItemScrollBox::deleteRequest);
 		connect(widgets_.back(), &ItemWidget::deleteRequest, this, &ItemScrollBox::removeItem);

src/ui/itemscrollbox.h

@@ -11,7 +11,8 @@
 #include "../items/itemstore.h"
 
 
-namespace Ui {
+namespace Ui
+{
 class RelayScrollBox;
 }
 

src/ui/itemsettingsdialog.cpp

@@ -1,4 +1,4 @@
- #include "itemsettingsdialog.h"
+#include "itemsettingsdialog.h"
 #include "ui_itemsettingsdialog.h"
 #include "actorsettingsdialog.h"
 #include "../actors/alarmtime.h"
@@ -8,9 +8,9 @@
 #include "../actors/factoractor.h"
 #include "../items/messageitem.h"
 #include "../items/systemitem.h"
-#include "./itemsettingswidgets/messageitemsettingswidget.h"
-#include "./itemsettingswidgets/systemitemsettingswidget.h"
-#include "./itemsettingswidgets/relayitemsettingswidget.h"
+#include "itemsettingswidgets/messageitemsettingswidget.h"
+#include "itemsettingswidgets/systemitemsettingswidget.h"
+#include "itemsettingswidgets/relayitemsettingswidget.h"
 #include<memory>
 
 ItemSettingsDialog::ItemSettingsDialog(std::shared_ptr<Item> item, QWidget *parent) :
@@ -144,7 +144,7 @@ void ItemSettingsDialog::addActor()
 
 void ItemSettingsDialog::removeActor()
 {
-    if(item_->getActors().size() > ui->tableWidget->currentRow())
+	if(item_->getActors().size() > static_cast<size_t>(ui->tableWidget->currentRow()))
 	{
 		item_->removeActor(item_->getActors().at(ui->tableWidget->currentRow()));
 		loadActorList();
@@ -153,7 +153,7 @@ void ItemSettingsDialog::removeActor()
 
 void ItemSettingsDialog::editActor()
 {
-    if(item_->getActors().size() > ui->tableWidget->currentRow())
+	if(item_->getActors().size() > static_cast<size_t>(ui->tableWidget->currentRow()))
 	{
 		std::shared_ptr<Actor> actor = item_->getActors()[ui->tableWidget->currentRow()];
 
@@ -177,7 +177,7 @@ void ItemSettingsDialog::editActor()
 		dialog->show();
 		dialog->exec();
 
-        for(int i = 0; i < ui->tableWidget->rowCount() && i < item_->getActors().size(); ++i)
+		for(int i = 0; i < ui->tableWidget->rowCount() && i < static_cast<int>(item_->getActors().size()); ++i)
 		{
 			ui->tableWidget->item(i, 0)->setText(item_->getActors()[i]->getName());
 			ui->tableWidget->item(i, 1)->setText(item_->getActors()[i]->actionName());

src/ui/itemsettingsdialog.h

@@ -6,7 +6,8 @@
 #include <memory>
 #include "../items/relay.h"
 
-namespace Ui {
+namespace Ui
+{
 class ItemSettingsDialog;
 }
 

src/ui/itemsettingsdialog.ui

@@ -115,7 +115,7 @@
       <number>3</number>
      </property>
      <attribute name="horizontalHeaderVisible">
-      <bool>false</bool>
+      <bool>true</bool>
      </attribute>
      <attribute name="horizontalHeaderMinimumSectionSize">
       <number>32</number>

src/ui/itemsettingswidgets/messageitemsettingswidget.cpp

@@ -0,0 +1,48 @@
+#include "messageitemsettingswidget.h"
+#include "ui_messageitemsettingswidget.h"
+
+#include <QFileDialog>
+#include <QDebug>
+
+MessageItemSettingsWidget::MessageItemSettingsWidget(std::weak_ptr<MessageItem> item, QWidget *parent) :
+	QWidget(parent),
+	item_(item),
+	ui(new Ui::MessageItemSettingsWidget)
+{
+	ui->setupUi(this);
+	qDebug()<<"test";
+	if(auto workingItem = item_.lock())
+	{
+		ui->lineEdit->setText(workingItem->getMessage());
+		ui->lineEdit_alert->setText(workingItem->getAlert());
+	}
+
+	connect(ui->lineEdit, &QLineEdit::textChanged, this, &MessageItemSettingsWidget::setText);
+	connect(ui->lineEdit_alert, &QLineEdit::textChanged, this, &MessageItemSettingsWidget::setAlert);
+	connect(ui->pushButton, &QPushButton::pressed, [this]()
+	{
+		ui->lineEdit_alert->setText(QFileDialog::getOpenFileName(this, "Choose File"));
+	});
+}
+
+
+void MessageItemSettingsWidget::setText(const QString& text)
+{
+	if(auto workingItem = item_.lock())
+	{
+		workingItem->setMessage(text);
+	}
+}
+
+void MessageItemSettingsWidget::setAlert(const QString &in)
+{
+	if(auto workingItem = item_.lock())
+	{
+		workingItem->setAlert(in);
+	}
+}
+
+MessageItemSettingsWidget::~MessageItemSettingsWidget()
+{
+	delete ui;
+}

src/ui/itemsettingswidgets/messageitemsettingswidget.h

@@ -0,0 +1,31 @@
+#ifndef MESSAGEITEMSETTINGSWIDGET_H
+#define MESSAGEITEMSETTINGSWIDGET_H
+
+#include <QWidget>
+#include <memory>
+#include "../../items/messageitem.h"
+
+namespace Ui
+{
+class MessageItemSettingsWidget;
+}
+
+class MessageItemSettingsWidget : public QWidget
+{
+	Q_OBJECT
+	std::weak_ptr<MessageItem> item_;
+
+private slots:
+
+	void setText(const QString& text);
+	void setAlert(const QString &in);
+
+public:
+	explicit MessageItemSettingsWidget(std::weak_ptr<MessageItem> item, QWidget *parent = nullptr);
+	~MessageItemSettingsWidget();
+
+private:
+	Ui::MessageItemSettingsWidget *ui;
+};
+
+#endif // MESSAGEITEMSETTINGSWIDGET_H

src/ui/itemsettingswidgets/messageitemsettingswidget.ui

@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MessageItemSettingsWidget</class>
+ <widget class="QWidget" name="MessageItemSettingsWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>124</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_2">
+     <property name="topMargin">
+      <number>0</number>
+     </property>
+     <item>
+      <widget class="QLabel" name="label">
+       <property name="text">
+        <string>Text:</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLineEdit" name="lineEdit"/>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QLabel" name="label_2">
+       <property name="text">
+        <string>Alert:</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLineEdit" name="lineEdit_alert"/>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton">
+       <property name="text">
+        <string>Browse</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

src/ui/itemsettingswidgets/relayitemsettingswidget.h

@@ -5,7 +5,8 @@
 #include <memory>
 #include "../../items/relay.h"
 
-namespace Ui {
+namespace Ui
+{
 class RelayItemSettingsWidget;
 }
 

src/ui/itemsettingswidgets/systemitemsettingswidget.h

@@ -5,7 +5,8 @@
 #include <memory>
 #include "../../items/systemitem.h"
 
-namespace Ui {
+namespace Ui
+{
 class SystemItemSettingsWidget;
 }
 

src/ui/itemwidget.cpp

@@ -5,39 +5,47 @@
 #include <QDebug>
 #include <QSlider>
 
-ItemWidget::ItemWidget(std::weak_ptr<Item> item, bool analog, bool nameOnly, QWidget *parent) :
+ItemWidget::ItemWidget(std::weak_ptr<Item> item, QWidget *parent) :
 	QWidget(parent),
 	item_(item),
 	ui(new Ui::ItemWidget)
 {
 	ui->setupUi(this);
 
-    if(analog)
+	if(auto workingItem = item_.lock())
+	{
+		if(workingItem->getValueType() == ITEM_VALUE_UINT)
 		{
 			ui->horizontalSpacer->changeSize(0,0);
 			ui->checkBox->hide();
 		}
-    else if(nameOnly)
+		else if(workingItem->getValueType() == ITEM_VALUE_NO_VALUE)
 		{
 			ui->checkBox->hide();
 			ui->slider->hide();
 		}
-    else ui->slider->hide();
-
-    if(auto workingRelay = item_.lock())
+		else
 		{
-        ui->checkBox->setChecked(workingRelay->getValue());
+			ui->slider->hide();
+		}
 
-        ui->label->setText(workingRelay->getName());
+		ui->checkBox->setChecked(workingItem->getValue());
 
-        if(analog)connect(ui->slider, &QSlider::valueChanged, this, &ItemWidget::moveToValue);
-        else connect(ui->checkBox, &QCheckBox::toggled, this, &ItemWidget::moveToState);
+		ui->label->setText(workingItem->getName());
+
+		if(workingItem->getValueType() == ITEM_VALUE_UINT)
+			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);
+		connect(workingItem.get(), &Relay::valueChanged, this, &ItemWidget::stateChanged);
 		connect(ui->pushButton_Remove, &QPushButton::clicked, this, &ItemWidget::deleteItem);
 
 	}
-    else disable();
+	else
+	{
+		disable();
+	}
 }
 
 void ItemWidget::deleteItem()
@@ -50,14 +58,18 @@ void ItemWidget::deleteItem()
 
 void ItemWidget::moveToValue(int value)
 {
-    if(auto workingItem = item_.lock()) workingItem->setValue(value);
-    else disable();
+	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();
+	if(auto workingItem = item_.lock())
+		workingItem->setValue(state);
+	else
+		disable();
 }
 
 void ItemWidget::disable()
@@ -70,9 +82,9 @@ void ItemWidget::disable()
 
 bool ItemWidget::controles(const ItemData& relay)
 {
-    if(auto workingRelay = item_.lock())
+	if(auto workingItem = item_.lock())
 	{
-        if(relay == *workingRelay) return  true;
+		if(relay == *workingItem) return  true;
 		else return false;
 	}
 	return true;
@@ -80,9 +92,9 @@ bool ItemWidget::controles(const ItemData& relay)
 
 void ItemWidget::showSettingsDialog()
 {
-    if(auto workingRelay = item_.lock())
+	if(auto workingItem = item_.lock())
 	{
-        ItemSettingsDialog dialog(workingRelay, this);
+		ItemSettingsDialog dialog(workingItem, this);
 		dialog.exec();
 	}
 	else disable();
@@ -95,7 +107,6 @@ std::weak_ptr<Item> ItemWidget::getItem()
 
 void ItemWidget::stateChanged(int state)
 {
-    qDebug()<<"widget got state "<<state;
 	ui->slider->blockSignals(true);
 	ui->slider->setValue(state);
 	ui->slider->blockSignals(false);

src/ui/itemwidget.h

@@ -6,7 +6,8 @@
 #include "itemsettingsdialog.h"
 #include "../items/item.h"
 
-namespace Ui {
+namespace Ui
+{
 class ItemWidget;
 }
 
@@ -29,7 +30,7 @@ private slots:
 	void deleteItem();
 
 public:
-    explicit ItemWidget(std::weak_ptr<Item> item, bool analog = false,  bool nameOnly = false, QWidget *parent = nullptr);
+	explicit ItemWidget(std::weak_ptr<Item> item, QWidget *parent = nullptr);
 	std::weak_ptr<Item> getItem();
 	bool controles(const ItemData& relay);
 	~ItemWidget();

src/ui/itemwidget.ui

@@ -30,7 +30,7 @@
    <item>
     <spacer name="horizontalSpacer">
      <property name="orientation">
-      <enum>Qt::Horizontal</enum>
+      <enum>Qt::Orientation::Horizontal</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
@@ -46,10 +46,10 @@
       <number>255</number>
      </property>
      <property name="tracking">
-      <bool>true</bool>
+      <bool>false</bool>
      </property>
      <property name="orientation">
-      <enum>Qt::Horizontal</enum>
+      <enum>Qt::Orientation::Horizontal</enum>
      </property>
     </widget>
    </item>

src/ui/mainwindow-android.ui

@@ -245,13 +245,13 @@
   <customwidget>
    <class>ItemScrollBox</class>
    <extends>QWidget</extends>
-   <header location="global">../src/ui/itemscrollbox.h</header>
+   <header location="global">../ui/itemscrollbox.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>SensorListWidget</class>
    <extends>QListView</extends>
-   <header location="global">../src/ui/sensorlistwidget.h</header>
+   <header location="global">../ui/sensorlistwidget.h</header>
   </customwidget>
  </customwidgets>
  <resources>