Major wip refactor

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

SHinterface.pro

@@ -4,7 +4,7 @@
 #
 #-------------------------------------------------
 
-QT += core gui widgets network multimedia httpserver
+QT += core gui widgets network multimedia
 
 QT += serialport
 
@@ -26,7 +26,7 @@ QMAKE_CXXFLAGS += -std=c++17 -O2
 SOURCES += \
     src/actors/factoractor.cpp \
 	src/actors/polynomalactor.cpp \
-	src/broadcast.cpp \
+	src/tcpserver.cpp \
 	src/iomuliplexer.cpp \
 	src/items/messageitem.cpp \
 	src/items/systemitem.cpp \
@@ -61,27 +61,29 @@ SOURCES += \
 
 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
+	src/items/rgbitem.cpp \
+	src/items/itemsource.cpp
 
 SOURCES += \
 	src/main.cpp \
 	src/microcontroller.cpp \
-	src/sun.cpp
+	src/sun.cpp \
+	src/programmode.cpp
 
 
 HEADERS  += \
     src/actors/factoractor.h \
 	src/actors/polynomalactor.h \
-	src/broadcast.h \
+    src/items/itemsource.h \
+    src/programmode.h \
+	src/tcpserver.h \
 	src/iomuliplexer.h \
 	src/items/messageitem.h \
 	src/items/systemitem.h \
@@ -116,20 +118,20 @@ HEADERS  += \
 
 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
+	src/items/rgbitem.h \
+	src/items/itemsource.h
 
 HEADERS += \
 	src/microcontroller.h \
-	src/sun.h
+	src/sun.h \
+	src/programmode.h
 
 FORMS    += \
     src/ui/actorwidgets/factoractorwidget.ui \

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();

src/items/auxitem.cpp

@@ -6,9 +6,8 @@ AuxItem::AuxItem(Microcontroller* micro, uint32_t itemIdIn, QString name,  uint8
 
 }
 
-void AuxItem::setValue(uint8_t value)
+void AuxItem::enactValue(uint8_t value)
 {
-	Item::setValue(value);
 	micro_->setAuxPwm(value);
 }
 

src/items/auxitem.h

@@ -9,13 +9,12 @@ class AuxItem: public Item
 private:
 	Microcontroller* micro_;
 
-public slots:
+protected:
-
+	virtual void enactValue(uint8_t value) override;
-	virtual void setValue(uint8_t value);
 
 public:
 	AuxItem(Microcontroller* micro, uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "",
 	        uint8_t value = 0, QObject* parent = nullptr);
 
-	virtual void store(QJsonObject& json);
+	virtual void store(QJsonObject& json) override;
 };

src/items/item.cpp

@@ -1,10 +1,12 @@
 #include "item.h"
 
+#include "src/actors/sensoractor.h"
+#include "src/actors/regulator.h"
+#include "src/actors/polynomalactor.h"
+#include "src/programmode.h"
 #include "relay.h"
-#include "../microcontroller.h"
+#include "messageitem.h"
-#include "../actors/sensoractor.h"
+#include "systemitem.h"
-#include "../actors/regulator.h"
-#include "../actors/polynomalactor.h"
 
 #include <QJsonArray>
 
@@ -33,11 +35,25 @@ 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));
+	}
+}
+
 
 //item
 
-bool Item::secondaryFlag = false;
-
 Item::Item(uint32_t itemIdIn, QString name, uint8_t value,  QObject *parent): QObject(parent), ItemData (itemIdIn, name,
 	        value)
 {
@@ -55,8 +71,7 @@ Item::~Item()
 
 void Item::store(QJsonObject &json)
 {
-	json["Name"] = name_;
+	ItemData::store(json);
-	json["ItemId"] = static_cast<double>(itemId_);
 	json["override"] = override_;
 	QJsonArray actorsArray;
 	for(size_t i = 0; i < actors_.size(); ++i)
@@ -73,11 +88,7 @@ void Item::store(QJsonObject &json)
 
 void Item::load(const QJsonObject &json, const bool preserve)
 {
-	if(!preserve)
+	ItemData::load(json, preserve);
-	{
-		name_ = json["Name"].toString(name_);
-		itemId_ = static_cast<uint32_t>(json["ItemId"].toDouble(0));
-	}
 	override_ = json["override"].toBool(false);
 	const QJsonArray actorsArray(json["Actors"].toArray(QJsonArray()));
 	for(int i = 0; i < actorsArray.size(); ++i)
@@ -92,28 +103,35 @@ void Item::load(const QJsonObject &json, const bool preserve)
 
 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;
+	informValue(value);
-	valueChanged(value_);
+	if(programMode == PROGRAM_MODE_PRIMARY || programMode == PROGRAM_MODE_HEADLESS_PRIMARY)
+		enactValue(value);
 }
 
 void Item::informValue(uint8_t value)
 {
-	Item::setValue(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);
@@ -167,5 +185,29 @@ 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();
+}
+
+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")
+	{
+	}
+	if(newItem)
+		newItem->load(json);
+	return newItem;
 }

src/items/item.h

@@ -16,16 +16,15 @@ protected:
 	uint32_t itemId_;
 
 public:
-
 	ItemData(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0);
 
 	inline bool operator==(const ItemData& in) const
 	{
-		return itemId_==in.itemId_;
+		return itemId_ == in.itemId_;
 	}
 	inline bool operator!=(const ItemData& in) const
 	{
-		return itemId_!=in.itemId_;
+		return itemId_ != in.itemId_;
 	}
 
 	uint32_t id() const;
@@ -33,6 +32,8 @@ public:
 	void setName(QString name);
 	uint8_t getValue() const;
 	virtual QString getName() const;
+	virtual void store(QJsonObject& json);
+	virtual void load(const QJsonObject& json, const bool preserve = false);
 };
 
 
@@ -44,20 +45,15 @@ 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:
-
+	void setValue(uint8_t value);
-	virtual void setValue(uint8_t value);
 
 public:
 
@@ -80,5 +76,10 @@ public:
 	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/itemsource.cpp

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

src/items/itemsource.h

@@ -0,0 +1,24 @@
+#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 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;
+	std::shared_ptr<Item> matched = nullptr;
-	for(unsigned i = 0; i < items_.size(); i++ ) if(*items_[i] == *item) mached = true;
+	for(unsigned i = 0; i < items_.size(); i++ )
-	if(!mached)
+	{
+		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";
 		itemAdded(std::weak_ptr<Item>(items_.back()));
 	}
+	else if(item->getValue() != matched->getValue())
+	{
+		if(inform)
+			matched->informValue(item->getValue());
+		else
+			matched->setValue(item->getValue());
+	}
 }
 
-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++ )
+	for(unsigned j = 0; j < itemIn.size(); j++)
-	{
+		addItem(itemIn[j], inform);
-		if(Relay* relay = dynamic_cast<Relay*>(items_[i].get()))
-		{
-			bool mached = false;
-			for(unsigned j = 0; j < itemIn.size(); j++) if(*(items_[i]) == *(itemIn[j]))
-				{
-					mached = true;
-					if(itemIn[j]->getValue() != items_[i]->getValue()) items_[i]->informValue(itemIn[j]->getValue());
-					Relay* relayIn = dynamic_cast<Relay*>(itemIn[j].get());
-					if(relayIn)
-					{
-						if(relay->getId() != relayIn->getId()) relay->setId(relayIn->getId());
-					}
-
-				}
-			if(!mached)
-			{
-				itemDeleted(*items_[i].get());
-				items_.erase(items_.begin()+i);
-			}
-		}
-	}
-
-	for(unsigned j = 0; j < itemIn.size(); j++)addItem(itemIn[j]);
-
 }
 
 void ItemStore::removeItem(const ItemData& item)
@@ -55,13 +45,14 @@ 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::clear()
 {
 	for(size_t i = 0; i < items_.size(); ++i) itemDeleted(*items_[i]);
@@ -69,19 +60,30 @@ 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())
-			if(items_[i]->getValue() != item.getValue())items_[i]->informValue(item.getValue());
+			{
+				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)
@@ -101,30 +103,51 @@ void ItemStore::load(const QJsonObject& json)
 	const QJsonArray itemsArray(json["Items"].toArray(QJsonArray()));
 	for(int i = 0; i < itemsArray.size(); ++i)
 	{
-		if(itemsArray[i].isObject())
+		if(!itemsArray[i].isObject())
-		{
+			continue;
-			const QJsonObject itemObject = itemsArray[i].toObject();
+
-			std::shared_ptr<Item> newItem;
+		const QJsonObject itemObject = itemsArray[i].toObject();
-			if(itemObject["Type"].toString("") == "Relay")
+		std::shared_ptr<Item> newItem = Item::loadItem(itemObject);
-			{
+		if(newItem)
-				newItem = std::shared_ptr<Relay>(new Relay());
+			addItem(newItem);
-			}
-			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);
-			}
-		}
 	}
 }
+
+void ItemStore::itemUpdateSlot(ItemData data)
+{
+	qDebug()<<__func__;
+	for(std::shared_ptr<Item>& item: items_)
+	{
+		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(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 "src/sensors/sensor.h"
+#include "itemsource.h"
 
 #include <QJsonObject>
 
@@ -10,7 +10,7 @@ class ItemStore: public QObject
 {
 	Q_OBJECT
 private:
-	std::vector< std::shared_ptr<Item> > items_;
+	std::vector<std::shared_ptr<Item> > items_;
 
 public:
 
@@ -22,6 +22,9 @@ public:
 		return &items_;
 	}
 
+	std::shared_ptr<Item> getItem(uint32_t id);
+
+	void registerItemSource(ItemSource* source);
 	void store(QJsonObject &json);
 	void load(const QJsonObject &json);
 
@@ -31,11 +34,20 @@ 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 addItem(std::shared_ptr<Item> item, bool inform = true);
-	void addItems(const std::vector<std::shared_ptr<Item>>& itemsIn);
+	void addItems(const std::vector<std::shared_ptr<Item>>& itemsIn, bool inform = true);
-	void itemStateChanged(const ItemData& item);
+	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

@@ -20,9 +20,8 @@ MessageItem::~MessageItem()
 	closeMessageBox();
 }
 
-void MessageItem::setValue(uint8_t value)
+void MessageItem::enactValue(uint8_t value)
 {
-	Item::setValue(value);
 	if(value && !messageBox_)
 	{
 		if(!alertSoundFileName.isEmpty())

src/items/messageitem.h

@@ -17,12 +17,10 @@ private:
 	QSoundEffect alertSound;
 
 private slots:
-
 	void closeMessageBox();
 
-public:
+protected:
-
+	virtual void enactValue(uint8_t value) override;
-	virtual void setValue(uint8_t value);
 
 public:
 
@@ -36,8 +34,8 @@ public:
 	void setAlert(const QString& in);
 	QString getAlert();
 
-	virtual void store(QJsonObject& json);
+	virtual void store(QJsonObject& json) override;
-	virtual void load(const QJsonObject& json, const bool preserve = false);
+	virtual void load(const QJsonObject& json, const bool preserve = false) override;
 };
 
 #endif // MESSAGEITEM_H

src/items/poweritem.cpp

@@ -7,15 +7,14 @@ PowerItem::PowerItem(uint32_t itemIdIn, QString name,  uint8_t value, QObject* p
 	        parent)
 {
 	stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 0, "Shutdown Imminent", true));
-	setValue(true);
+	PowerItem::setValue(true);
 }
 
-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));
 	}

src/items/poweritem.h

@@ -16,12 +16,10 @@ signals:
 	void stateChanged(Sensor sensor);
 
 private slots:
-
 	void timeout();
 
-public slots:
+protected:
-
+	virtual void enactValue(uint8_t value) override;
-	virtual void setValue(uint8_t value);
 
 public:
 	PowerItem(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "",  uint8_t value = 0,
@@ -30,5 +28,5 @@ public:
 	{
 		stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 0, "Shutdown Imminent", true));
 	}
-	virtual void store(QJsonObject& json);
+	virtual void store(QJsonObject& json) override;
 };

src/items/relay.cpp

@@ -12,13 +12,14 @@ Relay::Relay(uint8_t id, QString name, uint16_t address, bool state, QObject* pa
 	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);
 	if(micro_)
 	{
-		if(value)micro_->relayOn(id_);
+		if(value)
-		else micro_->relayOff(id_);
+			micro_->relayOn(id_);
+		else
+			micro_->relayOff(id_);
 	}
 }
 

src/items/relay.h

@@ -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();
@@ -37,7 +38,7 @@ public:
 		micro_ = micro;
 	}
 
-	virtual void store(QJsonObject& json);
+	virtual void store(QJsonObject& json) override;
-	virtual void load(const QJsonObject& json, const bool preserve = false);
+	virtual void load(const QJsonObject& json, const bool preserve = false) override;
 };
 #endif // RELAY_H

src/items/rgbitem.cpp

@@ -6,9 +6,8 @@ RgbItem::RgbItem(Microcontroller* micro, uint32_t itemIdIn, QString name,  uint8
 
 }
 
-void RgbItem::setValue(uint8_t value)
+void RgbItem::enactValue(uint8_t value)
 {
-	Item::setValue(value);
 	value ? micro_->rgbOn() : micro_->rgbOff();
 }
 

src/items/rgbitem.h

@@ -9,13 +9,12 @@ class RgbItem: public Item
 private:
 	Microcontroller* micro_;
 
-public slots:
+protected:
-
+	virtual void enactValue(uint8_t value) override;
-	virtual void setValue(uint8_t value);
 
 public:
 	RgbItem(Microcontroller* micro, uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "",
 	        uint8_t value = 0, QObject* parent = nullptr);
 
-	virtual void store(QJsonObject& json);
+	virtual void store(QJsonObject& json) override;
 };

src/items/systemitem.cpp

@@ -1,7 +1,7 @@
 #include "systemitem.h"
 #include <QProcess>
 
-void SystemItem::setValue(uint8_t value)
+void SystemItem::enactValue(uint8_t value)
 {
 	QProcess::execute(value ? onCommand_ : offCommand_);
 }

src/items/systemitem.h

@@ -7,16 +7,13 @@ class SystemItem : public Item
 {
 	Q_OBJECT
 private:
-
 	QString onCommand_;
 	QString offCommand_;
 
-public:
+protected:
-
+	virtual void enactValue(uint8_t value) override;
-	virtual void setValue(uint8_t value);
 
 public:
-
 	SystemItem(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0,
 	           QObject *parent = nullptr);
 	SystemItem(const ItemData& itemData,  QObject *parent = nullptr);
@@ -33,8 +30,8 @@ public:
 		return offCommand_;
 	}
 
-	virtual void store(QJsonObject& json);
+	virtual void store(QJsonObject& json) override;
-	virtual void load(const QJsonObject& json, const bool preserve = false);
+	virtual void load(const QJsonObject& json, const bool preserve = false) override;
 };
 
 #endif // SYSTEMITEM_H

src/main.cpp

@@ -1,26 +1,64 @@
 #include <QtWidgets/QApplication>
-#include <stdio.h>
 #include <QDebug>
 #include <QTcpSocket>
 #include <QMessageBox>
-
+#include <QSettings>
-//Currently pipewire support is disabled
-//#include <pipewire/pipewire.h>
-
-
-#ifndef Q_OS_ANDROID
 #include <QtSerialPort/QtSerialPort>
 #include <QtSerialPort/QSerialPortInfo>
 #include <QCommandLineParser>
-#endif
 
-#include "microcontroller.h"
 #include "ui/mainwindow.h"
 #include "items/itemstore.h"
 #include "mainobject.h"
+#include "programmode.h"
 
 
-#define BAUD  QSerialPort::Baud38400
+QJsonObject getJsonObjectFromDisk(const QString& filePath, bool* error = nullptr)
+{
+	QFile file;
+	file.setFileName(filePath);
+
+	bool ret = file.open(QIODevice::ReadOnly);
+	if(!file.isOpen() || !ret)
+	{
+		std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
+	}
+	else
+	{
+		QJsonParseError qerror;
+		QJsonDocument document(QJsonDocument::fromJson(file.readAll(), &qerror));
+		file.close();
+		if(qerror.error != QJsonParseError::NoError)
+		{
+			qDebug()<<filePath<<" "<<qerror.errorString();
+			if(error) (*error) = true;
+		}
+		return document.object();
+	}
+	return QJsonObject();
+}
+
+bool storeJsonObjectToDisk(const QJsonObject& json, QString filePath)
+{
+	QFile file(filePath + ".out");
+
+	qDebug()<<"config file: "<<filePath;
+	bool ret = file.open(QIODevice::WriteOnly);
+	if(!file.isOpen() || !ret)
+	{
+		std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
+		return false;
+	}
+	else
+	{
+		QJsonDocument document(json);
+		file.write(document.toJson());
+		file.close();
+		QFile::remove(filePath);
+		file.rename(filePath);
+		return true;
+	}
+}
 
 int main(int argc, char *argv[])
 {
@@ -37,102 +75,111 @@ 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"));
+	QCommandLineOption masterOption(QStringList() << "m" << "master", QCoreApplication::translate("main", "Use in master mode"));
-	parser.addOption(tcpOption);
+	parser.addOption(masterOption);
-	QCommandLineOption hostOption(QStringList() << "H" << "host", QCoreApplication::translate("main",
+	QCommandLineOption hostOption(QStringList() << "H" << "host", QCoreApplication::translate("main", "Set server host ip addres"), "address", "0.0.0.0");
-	                              "Set server host ip addres"), "adress");
 	parser.addOption(hostOption);
-	QCommandLineOption portOption(QStringList() << "p" << "port", QCoreApplication::translate("main",
+	QCommandLineOption portOption(QStringList() << "p" << "port", QCoreApplication::translate("main", "Set server Port"), "port", "104476");
-	                              "Set server Port in TCP mode or Serial port in serial mode"), "port");
 	parser.addOption(portOption);
-	QCommandLineOption serialOption(QStringList() << "s" << "serial", QCoreApplication::translate("main",
+	QCommandLineOption settingsPathOption(QStringList()<<"c"<<"config", QCoreApplication::translate("main", "Set config file"), "configFilePath",
-	                                "Use serial connection"));
+										  QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json");
-	parser.addOption(serialOption);
-	QCommandLineOption baudOption(QStringList() << "b" << "baud", QCoreApplication::translate("main", "Set Baud Rate"));
-	parser.addOption(baudOption);
-	QCommandLineOption settingsPathOption(QStringList() << "c" << "config", QCoreApplication::translate("main",
-	                                      "Set config file"), "configFilePath");
 	parser.addOption(settingsPathOption);
-	QCommandLineOption secondaryOption(QStringList() << "e" << "secondary", QCoreApplication::translate("main",
+	QCommandLineOption headlessOption(QStringList()<<"e"<<"headless", QCoreApplication::translate("main", "Dont start the gui"));
-	                                   "Set if instance is not main instance"));
+	parser.addOption(headlessOption);
-	parser.addOption(secondaryOption);
 	parser.process(a);
-#endif
 
-	QIODevice* masterIODevice = nullptr;
+	int retVal;
 
-#ifndef Q_OS_ANDROID
+	programMode = PROGRAM_MODE_UI_ONLY;
-	if(parser.isSet(tcpOption))
+	if(parser.isSet(masterOption))
 	{
-		QTcpSocket* microSocket = new QTcpSocket;
+		programMode = PROGRAM_MODE_PRIMARY;
+		if(parser.isSet(headlessOption))
+			programMode = PROGRAM_MODE_HEADLESS_PRIMARY;
+	}
+	if(programMode == PROGRAM_MODE_PRIMARY || programMode == PROGRAM_MODE_HEADLESS_PRIMARY)
+	{
+		QJsonObject json = getJsonObjectFromDisk(parser.value(settingsPathOption));
+		bool tcpMicro = json["MicroTcp"].toBool(true);
+		json["MicroTcp"] = tcpMicro;
 
-		int port = 6856;
+		QIODevice* microDevice = nullptr;
-		if(parser.isSet(portOption)) port =  parser.value(portOption).toInt();
+		if(tcpMicro)
-
-		QString host("127.0.0.1");
-		if(parser.isSet(hostOption)) host = parser.value(hostOption);
-		std::cout<<"connecting to "<<host.toStdString()<<':'<<port<<'\n';
-		microSocket->connectToHost(host, port, QIODevice::ReadWrite);
-		if(!microSocket->waitForConnected(1000))
 		{
-			std::cout<<"Can not connect to to Server.\n";
+			int port = json["MicroTcpPort"].toInt(6856);
-			QMessageBox::critical(nullptr, "Error", "Can not connect to to Server");
+			json["MicroTcpPort"] = port;
-			return 1;
+			QString host = json["MicroTcpHost"].toString("127.0.0.1");
+			json["MicroTcpHost"] = host;
+
+			QTcpSocket* microSocket = new QTcpSocket;
+
+			qInfo()<<"connecting to "<<host.toStdString()<<':'<<port<<" for tcp micro";
+			microSocket->connectToHost(host, port, QIODevice::ReadWrite);
+
+			if(!microSocket->waitForConnected(1000))
+			{
+				qCritical()<<"Can not connect to tcp micro";
+				storeJsonObjectToDisk(json, parser.value(settingsPathOption));
+				if(programMode == PROGRAM_MODE_PRIMARY)
+					QMessageBox::critical(nullptr, "Error", "Can not connect to tcp micro");
+				return 1;
+			}
+			microDevice = microSocket;
 		}
-		masterIODevice = microSocket;
+		else
+		{
+			QString port = json["MicroSerialPort"].toString("ttyUSB0");
+			json["MicroSerialPort"] = port;
+			int baud = json["MicroSerialBaud"].toInt(38400);
+			json["MicroSerialBaud"] = baud;
+
+			QSerialPort *microPort = new QSerialPort;
+			microPort->setPortName(port);
+			microPort->setBaudRate(baud);
+			microPort->open(QIODevice::ReadWrite);
+
+			if(!microPort->isOpen())
+			{
+				qCritical()<<"Can not open serial port"<<port;
+				storeJsonObjectToDisk(json, parser.value(settingsPathOption));
+				if(programMode == PROGRAM_MODE_PRIMARY)
+					QMessageBox::critical(nullptr, "Error", "Can not open serial port " + port);
+				return 1;
+			}
+			microDevice = microPort;
+		}
+		PrimaryMainObject mainObject(microDevice, &json, parser.value(hostOption), parser.value(portOption).toInt());
+		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::sigSave, &mainObject, &MainObject::storeToDisk);
+			QObject::connect(w, &MainWindow::createdItem, &globalItems, [](std::shared_ptr<Item> item){globalItems.addItem(item, false);});
+			w->show();
+		}
+		retVal = a.exec();
+
+		delete w;
+		delete microDevice;
+		mainObject.store(json);
+		storeJsonObjectToDisk(json, parser.value(settingsPathOption));
 	}
 	else
 	{
-		QSerialPort* microPort = new QSerialPort;
+		SecondaryMainObject mainObject(parser.value(hostOption), parser.value(portOption).toInt());
-		if(parser.isSet(portOption)) microPort->setPortName(parser.value(portOption));
+		MainWindow w(&mainObject);
-		else microPort->setPortName("ttyUSB0");
+		//QObject::connect(&w, &MainWindow::sigSave, &mainObject, &MainObject::sendJson);
+		w.show();
 
-		if(parser.isSet(portOption)) microPort->setBaudRate(parser.value(baudOption).toInt());
+		retVal = a.exec();
-		else microPort->setBaudRate(BAUD);
-
-		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))
-	{
-		std::cout<<"Can not connect to to Server.\n";
-		return 1;
-	}
-	masterIODevice = microSocket;
-
-	MainObject mainObject(masterIODevice, parser.isSet(settingsPathOption) ? parser.value(settingsPathOption) : "",
-	                      !parser.isSet(secondaryOption));
-#endif
-
-
-	//mainwindow
-	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!");
-
-	w.show();
-
-	int retVal = a.exec();
-
-	if(masterIODevice)
-		delete masterIODevice;
 	return retVal;
 }
 

src/mainobject.cpp

@@ -1,179 +1,94 @@
 #include "mainobject.h"
-#include "items/messageitem.h"
 
-MainObject::MainObject(QIODevice* ioDevice, const QString& settingsPathIn, const bool masterIn, QObject *parent) :
+#include<QJsonObject>
-	QObject(parent),
+#include<QJsonArray>
-	master(masterIn),
+#include<QMessageBox>
-	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 "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();
-	//pwHandler.startLoop();
-
-	//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);
+	globalItems.refresh();
-
-	QJsonObject powerObject;
-	powerItem->store(powerObject);
-	json.insert("Power", powerObject);
-	QJsonDocument pwrDoc(powerObject);
-
-	QJsonObject ocupancyObject;
-	ocupancySensor.store(ocupancyObject);
-	json.insert("Ocupancy", ocupancyObject);
 }
 
-void MainObject::load(const QJsonObject& json)
+PrimaryMainObject::PrimaryMainObject(QIODevice* microDevice, QJsonObject* settings, QString host, int port, QObject *parent) :
+	MainObject(parent),
+	settings(settings),
+	microDevice(microDevice),
+	ioMultiplexer(microDevice),
+	micro(microDevice),
+	tcpServer(new TcpServer),
+	sunSensorSource(49.824972, 8.702194),
+	powerItem(new PowerItem),
+	rgbItem(new RgbItem(&micro, 5487422, "Rgb Lights")),
+	auxItem(new AuxItem(&micro, 5487421, "Desk Light"))
 {
-	items.clear();
+	//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);
+
+	globalItems.registerItemSource(tcpServer);
+	globalItems.registerItemSource(&micro);
+
+	load(*settings);
+
+	tcpServer->launch(QHostAddress(host), port);
+}
+
+PrimaryMainObject::~PrimaryMainObject()
+{
+	store(*settings);
+}
+
+void PrimaryMainObject::store(QJsonObject &json)
+{
+	globalItems.store(json);
+}
+
+void PrimaryMainObject::load(const QJsonObject& json)
+{
+	globalItems.clear();
 	rgbItem->removeAllActors();
 	auxItem->removeAllActors();
 	powerItem->removeAllActors();
-	items.addItem(rgbItem);
+	globalItems.addItem(rgbItem);
-	items.addItem(auxItem);
+	globalItems.addItem(auxItem);
-	items.load(json);
+	globalItems.addItem(powerItem);
-	powerItem->load(json["Power"].toObject());
+	globalItems.load(json);
-	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();
+	globalItems.refresh();
 }
 
-void MainObject::storeToDisk()
+SecondaryMainObject::SecondaryMainObject(QString host, int port, QObject *parent) :
+	MainObject(parent),
+	tcpClient(new TcpClient)
 {
-	if(master && !noSave)
+	connect(tcpClient, &TcpClient::gotSensor, &globalSensors, &SensorStore::sensorGotState);
+	globalItems.registerItemSource(tcpClient);
+
+	if(!tcpClient->launch(QHostAddress(host), port))
 	{
-		QJsonObject json;
+		QMessageBox::critical(nullptr, "Error", "Could not connect to "+host+":"+QString::number(port));
-		store(json);
+		exit(1);
-		storeJsonObjectToDisk(json, settingsPath);
 	}
 }
 
-void MainObject::recivedJson(const QJsonObject json)
+SecondaryMainObject::~SecondaryMainObject()
 {
-	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)
-{
-	QFile file;
-
-#ifndef Q_OS_ANDROID
-	if(filePath.size() > 0) file.setFileName(filePath);
-	else
-#endif
-	{
-		file.setFileName(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json");
-	}
-
-	file.open(QIODevice::ReadOnly);
-	if(!file.isOpen()) std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
-	else
-	{
-		QJsonParseError qerror;
-		QJsonDocument document(QJsonDocument::fromJson(file.readAll(), &qerror));
-		file.close();
-		if(qerror.error != QJsonParseError::NoError)
-		{
-			qDebug()<<filePath<<" "<<qerror.errorString();
-			if(error) (*error) = true;
-		}
-		return document.object();
-	}
-	return QJsonObject();
-}
-
-bool MainObject::storeJsonObjectToDisk(const QJsonObject& json, QString filePath)
-{
-#ifndef Q_OS_ANDROID
-	if(filePath.size() == 0)
-#endif
-	{
-		filePath = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json";
-	}
-	QFile file(filePath + ".out");
-
-	qDebug()<<"config file: "<<filePath;
-	file.open(QIODevice::WriteOnly);
-	if(!file.isOpen())
-	{
-		std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
-		return false;
-	}
-	else
-	{
-		QJsonDocument document(json);
-		file.write(document.toJson());
-		file.close();
-		QFile::remove(filePath);
-		file.rename(filePath);
-		return true;
-	}
 }
 

src/mainobject.h

@@ -2,7 +2,6 @@
 #define MAINOBJECT_H
 
 #include <QObject>
-#include <stdio.h>
 #include <QDir>
 #include <QDebug>
 #include <QString>
@@ -12,80 +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 "pipewire.h"
+#include "tcpserver.h"
 
 class MainObject : public QObject
+{
+	Q_OBJECT
+
+public:
+	explicit MainObject(QObject *parent = nullptr);
+	~MainObject();
+
+public slots:
+	void refresh();
+};
+
+class PrimaryMainObject : public MainObject
 {
 	Q_OBJECT
 public:
 
+	QJsonObject* settings;
+
 	//io
-	const bool master;
+	QIODevice * const microDevice = nullptr;
-
-	bool noSave = false;
-
-	QIODevice * const masterIODevice = nullptr;
 	IoMuliplexer ioMultiplexer;
 
 	Microcontroller micro;
-    BroadCast broadCast;
+	TcpServer* tcpServer;
-
-
-	const QString settingsPath;
 
 	//sensors
-	SunSensorSource     sunSensorSource;
+	SunSensorSource sunSensorSource;
-	OcupancySensorSource ocupancySensor;
 
 	//items
-	ItemStore items;
-
 	std::shared_ptr<PowerItem> powerItem;
 	std::shared_ptr<RgbItem> rgbItem;
 	std::shared_ptr<AuxItem> auxItem;
 
-	//PipeWireHandler pwHandler;
+public:
+	explicit PrimaryMainObject(QIODevice* microDevice, QJsonObject* settings, QString host, int port, QObject *parent = nullptr);
+	~PrimaryMainObject();
+	void store(QJsonObject& json);
+	void load(const QJsonObject& json);
+};
 
-private:
+class SecondaryMainObject : public MainObject
-
+{
-	static QJsonObject getJsonObjectFromDisk(const QString& filePath = "", bool* error = nullptr);
+	Q_OBJECT
-	static bool storeJsonObjectToDisk(const QJsonObject& json, QString filePath = "");
+public:
+	TcpClient* tcpClient;
 
 public:
-	explicit MainObject(QIODevice* ioDevice, const QString& settingsPathIn, const bool masterIn, QObject *parent = nullptr);
+	explicit SecondaryMainObject(QString host, int port, QObject *parent = nullptr);
-	~MainObject();
+	~SecondaryMainObject();
-
-	void store(QJsonObject& json);
-
-	void load(const QJsonObject& json);
-
-signals:
-
-public slots:
-
-	void storeToDisk();
-	void sendJson();
-	void recivedJson(const QJsonObject json);
 
 };
 

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,7 +38,6 @@ 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)
@@ -52,9 +49,6 @@ void Microcontroller::setAuxPwm(int duty)
 
 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");
 }
@@ -147,12 +138,13 @@ void Microcontroller::processList(const QString& buffer)
 	if(bufferList.size() >= 8 && buffer.startsWith("ITEM NUMBER:"))
 	{
 		relayList.push_back(processRelayLine(buffer));
+		qDebug()<<"Micro item recived:"<<relayList.back()->getName();
 	}
 	else if(buffer.contains("EOL"))
 	{
 		listMode = false;
 		qDebug()<<"got relay list " << relayList.size();
-		gotRelayList(relayList);
+		gotItems(relayList);
 		relayList.clear();
 	}
 	else listMode = false;
@@ -160,7 +152,7 @@ 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)
@@ -172,7 +164,11 @@ void Microcontroller::processSensorState(const QString& buffer)
 
 void Microcontroller::processMicroReturn()
 {
-	if(listMode) processList(_buffer);
+	qDebug()<<_buffer;
+	if(listMode)
+	{
+		processList(_buffer);
+	}
 	else
 	{
 		if(_buffer.startsWith("Items:"))
@@ -192,7 +188,9 @@ void Microcontroller::isReadyRead()
 	while(_port->getChar(&charBuf))
 	{
 		_buffer.push_back(charBuf);
-		if( _buffer.endsWith('\n') )
+
+		qDebug()<<_buffer;
+		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/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/ocupancysensor.cpp

@@ -1,62 +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,33 +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/pipewiresensor.cpp

@@ -1,74 +0,0 @@
-#include "pipewiresensor.h"
-#include <QDebug>
-
-static const struct pw_node_events node_events = {
-	.version = PW_VERSION_NODE_EVENTS,
-	.info = &PipeWireSensorSource::nodeEventHandler,
-	.param = nullptr
-};
-
-PipeWireSensorSource::PipeWireSensorSource(PipeWireHandler* handler, const std::string& nodeName, uint8_t id, QObject *parent)
-	: QObject{parent}, handler_(handler), nodeName_(nodeName), id_(id)
-{
-	connect(handler_, &PipeWireHandler::nodeAdded, this, &PipeWireSensorSource::nodeAdded);
-	connect(&timer, &QTimer::timeout, this, &PipeWireSensorSource::offTimeout);
-	timer.setSingleShot(true);
-}
-
-void PipeWireSensorSource::offTimeout()
-{
-	if(state == false)
-		return;
-	state = false;
-	stateChanged(Sensor(Sensor::TYPE_AUDIO_OUTPUT, id_, state));
-}
-
-void PipeWireSensorSource::nodeEventHandler(void* data, const struct pw_node_info *info)
-{
-	PipeWireSensorSource* source = static_cast<PipeWireSensorSource*>(data);
-
-	if(info->state == source->prevState)
-		return;
-
-	source->prevState = info->state;
-
-	switch (info->state)
-	{
-		case PW_NODE_STATE_ERROR:
-		case PW_NODE_STATE_CREATING:
-			source->state = false;
-			source->stateChanged(Sensor(Sensor::TYPE_AUDIO_OUTPUT, source->id_, 0));
-			break;
-		case PW_NODE_STATE_SUSPENDED:
-		case PW_NODE_STATE_IDLE:
-			if(source->state == true)
-				source->timer.start(10000);
-			break;
-		case PW_NODE_STATE_RUNNING:
-			if(source->state == false)
-			{
-				source->state = true;
-				source->stateChanged(Sensor(Sensor::TYPE_AUDIO_OUTPUT, source->id_, source->state));
-			}
-			break;
-		default:
-			break;
-	}
-}
-
-void PipeWireSensorSource::nodeAdded(PipeWireHandler::PwNode node)
-{
-	if(node.name == nodeName_)
-	{
-
-		sinkNode = static_cast<struct pw_node*>(pw_registry_bind(handler_->getRegistry(), node.id, PW_TYPE_INTERFACE_Node, PW_VERSION_CLIENT, 0));
-		if(sinkNode)
-		{
-			qDebug()<<"Failed to register to required pipewire node"<<node.name.c_str()<<"as id"<<node.id;
-			return;
-		}
-		pw_node_add_listener(sinkNode, &sinkListener, &node_events, this);
-		qDebug()<<"Found required pipewire node"<<node.name.c_str()<<"as id"<<node.id;
-	}
-}
-

src/sensors/pipewiresensor.h

@@ -1,40 +0,0 @@
-#ifndef PIPEWIRESENSOR_H
-#define PIPEWIRESENSOR_H
-
-#include <QObject>
-#include <string>
-#include <pipewire/core.h>
-#include <pipewire/pipewire.h>
-#include <QTimer>
-
-#include "sensor.h"
-#include "../pipewire.h"
-
-class PipeWireSensorSource : public QObject
-{
-	Q_OBJECT
-
-	PipeWireHandler* handler_;
-	std::string nodeName_;
-	struct pw_node* sinkNode = nullptr;
-	struct spa_hook sinkListener;
-	pw_node_state prevState = PW_NODE_STATE_SUSPENDED;
-	QTimer timer;
-	uint8_t id_;
-	bool state = false;
-
-private slots:
-	void offTimeout();
-
-public:
-	explicit PipeWireSensorSource(PipeWireHandler* handler, const std::string& nodeName, uint8_t id, QObject *parent = nullptr);
-	static void nodeEventHandler(void* data, const struct pw_node_info *info);
-
-signals:
-	void stateChanged(Sensor sensor);
-
-private slots:
-	void nodeAdded(PipeWireHandler::PwNode node);
-};
-
-#endif // PIPEWIRESENSOR_H

src/sensors/sensor.h

@@ -4,6 +4,7 @@
 #include<QDateTime>
 #include<QObject>
 #include<vector>
+#include<QJsonObject>
 
 class Sensor
 {
@@ -41,6 +42,15 @@ public:
 	{
 		lastSeen = QDateTime::currentDateTime();
 	}
+	Sensor(const QJsonObject& json)
+	{
+		type = json["SensorType"].toInt(0);
+		id = json["Id"].toInt(0);
+		field = json["Field"].toInt(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;
@@ -77,15 +87,32 @@ public:
 			   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);
+		if(type == TYPE_TEMPERATURE)
-		else if(type == TYPE_DOOR)  name = "Door " + QString::number(id);
+			name = "Temperature " + QString::number(id);
-		else if(type == TYPE_BUTTON)  name = "Button " + QString::number(id);
+		else if(type == TYPE_DOOR)
-		else if(type == TYPE_AUDIO_OUTPUT)  name = "Speakers " + QString::number(id);
+			name = "Door " + QString::number(id);
-		else if(type == TYPE_HUMIDITY)  name = "Humidity " + QString::number(id);
+		else if(type == TYPE_BUTTON)
-		else if(type == TYPE_SUN_ALTITUDE)  name = "Solar Altitude";
+			name = "Button " + QString::number(id);
-		else if(type == TYPE_SHUTDOWN_IMMINENT)  name = "Shutdown Imminent";
+		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);
 	}
 };

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/tcpserver.cpp

@@ -0,0 +1,277 @@
+#include <QTcpSocket>
+#include <QJsonDocument>
+#include <QJsonArray>
+
+#include "items/item.h"
+#include "items/itemstore.h"
+#include "tcpserver.h"
+
+
+TcpService::TcpService(QObject* parent):
+	ItemSource(parent)
+{}
+
+QJsonObject TcpService::createMessage(const QString& type, const QJsonArray& data)
+{
+	QJsonObject json;
+	json["MesageType"] = type;
+	json["Data"] = data;
+	return json;
+}
+
+void TcpService::sensorEvent(Sensor sensor)
+{
+	QJsonArray sensors;
+	QJsonObject sensorjson;
+	sensor.store(sensorjson);
+	sensors.append(sensorjson);
+	QJsonObject json = createMessage("SensorUpdate", sensors);
+
+	sendJson(json);
+}
+
+void TcpService::itemUpdated(std::weak_ptr<Item> item)
+{
+	QJsonArray items;
+	QJsonObject itemjson;
+	item.lock()->store(itemjson);
+	items.append(itemjson);
+	QJsonObject json = createMessage("ItemUpdate", items);
+	sendJson(json);
+}
+
+void TcpService::refresh()
+{
+	sendJson(createMessage("GetSensors", QJsonArray()));
+	sendJson(createMessage("GetItems", QJsonArray()));
+}
+
+void TcpService::sendSensors()
+{
+	QJsonArray sensors;
+	for(auto& sensor: *globalSensors.getSensors())
+	{
+		QJsonObject sensorjson;
+		sensor.store(sensorjson);
+		sensors.append(sensorjson);
+	}
+	sendJson(createMessage("SensorUpdate", sensors));
+}
+
+void TcpService::sendItems()
+{
+	QJsonArray items;
+	for(auto& item: *globalItems.getItems())
+	{
+		QJsonObject itemjson;
+		item->store(itemjson);
+		items.append(itemjson);
+	}
+	sendJson(createMessage("ItemUpdate", items));
+}
+
+
+void TcpService::processIncomeingJson(const QByteArray& jsonbytes)
+{
+	qDebug()<<__func__<<jsonbytes;
+	QJsonDocument doc = QJsonDocument::fromJson(jsonbytes);
+	QJsonObject json = doc.object();
+	QString type = json["MessageType"].toString();
+	if(type == "GetSensors")
+	{
+		sendSensors();
+	}
+	else if(type == "GetItems")
+	{
+		sendItems();
+	}
+	else if(type == "SensorUpdate")
+	{
+		QJsonArray data = json["Data"].toArray();
+		for(QJsonValueRef sensorjson : data)
+		{
+			QJsonObject jsonobject = sensorjson.toObject();
+			Sensor sensor(jsonobject);
+			gotSensor(sensor);
+		}
+	}
+}
+
+TcpClient::TcpClient(QObject* parent):
+	TcpService(parent),
+	socket(new QTcpSocket(this))
+{
+}
+
+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")
+	{
+		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)
+				items.push_back(item);
+		}
+		if(!items.empty())
+			gotItems(items, true);
+	}
+	else
+	{
+		TcpService::processIncomeingJson(jsonbytes);
+	}
+}
+
+TcpClient::~TcpClient()
+{
+	delete socket;
+}
+
+TcpServer::TcpServer(QObject* parent):
+	TcpService(parent),
+	server(this)
+{
+}
+
+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")
+	{
+		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)
+				items.push_back(item);
+		}
+		if(!items.empty())
+			gotItems(items, false);
+	}
+	else
+	{
+		TcpService::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();
+		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)
+{
+	qDebug()<<__func__<<command;
+	if(command.startsWith("MSG JSON LEN "))
+	{
+		client.state = STATE_RECV_JSON;
+		client.recievebytes = command.mid(13).toLongLong();
+	}
+}
+
+void TcpServer::socketReadyRead()
+{
+	for(size_t i = 0; i < clients.size(); i++)
+	{
+		if(clients[i].socket == sender())
+		{
+			clients[i].buffer += clients[i].socket->readAll();
+			bool remianing = true;
+			while(remianing)
+			{
+				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.chopped(newlineIndex);
+					clients[i].buffer.chop(newlineIndex);
+					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.chopped(clients[i].recievebytes);
+						clients[i].buffer.chop(clients[i].recievebytes);
+						clients[i].recievebytes = 0;
+						clients[i].state = STATE_IDLE;
+						processIncomeingJson(json);
+						remianing = true;
+					}
+				}
+			}
+		}
+	}
+}
+

src/tcpserver.h

@@ -0,0 +1,89 @@
+#ifndef TCPSERVER_H
+#define TCPSERVER_H
+
+#include <QTcpServer>
+#include <vector>
+
+#include "sensors/sensor.h"
+#include "items/item.h"
+#include "items/itemsource.h"
+
+class TcpService : public ItemSource
+{
+	Q_OBJECT
+signals:
+	void gotSensor(Sensor sensor);
+
+public slots:
+	void sensorEvent(Sensor sensor);
+	void itemUpdated(std::weak_ptr<Item> item);
+	virtual void refresh() override;
+
+public:
+	TcpService(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);
+};
+
+class TcpClient : public TcpService
+{
+	Q_OBJECT
+
+	QTcpSocket* socket;
+
+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;
+};
+
+class TcpServer : public TcpService
+{
+	Q_OBJECT
+
+	typedef enum
+	{
+		STATE_IDLE,
+		STATE_RECV_JSON,
+	} client_state_t;
+
+	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;
+
+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_H

src/ui/mainwindow.cpp

@@ -9,38 +9,20 @@
 MainWindow::MainWindow(MainObject * const mainObject, QWidget *parent) :
 	QMainWindow(parent),
 	ui(new Ui::MainWindow),
-	colorChooser(this),
+	colorChooser(this)
-	_micro(&mainObject->micro),
-	_powerItem(mainObject->powerItem)
 {
 	ui->setupUi(this);
-
+	connect(ui->pushButton_broadcast, &QPushButton::clicked, this, &MainWindow::sigSave);
-	if(!mainObject->master)
+	connect(ui->pushButton_broadcast, &QPushButton::clicked, this, [this](){QMessageBox::information(this, "Saved", "Settings where saved");});
-	{
-		connect(ui->pushButton_broadcast, &QPushButton::clicked, this, &MainWindow::sigBrodcast);
-	}
-	else
-	{
-		connect(ui->pushButton_broadcast, &QPushButton::clicked, this, &MainWindow::sigSave);
-		connect(ui->pushButton_broadcast, &QPushButton::clicked, this, &MainWindow::saved);
-	}
 
 	connect(ui->pushButton_power, SIGNAL(clicked()), this, SLOT(showPowerItemDialog()));
 
-	//Relays
+	connect(ui->pushButton_refesh, &QPushButton::clicked, mainObject, &MainObject::refresh);
-	if(mainObject->master)connect(ui->pushButton_refesh, &QPushButton::clicked, _micro, &Microcontroller::requestState);
+	connect(&globalItems, &ItemStore::itemAdded, ui->relayList, &ItemScrollBox::addItem);
-	else
+	connect(&globalItems, &ItemStore::itemDeleted, ui->relayList, &ItemScrollBox::removeItem);
-	{
-		connect(ui->pushButton_refesh, &QPushButton::clicked, &mainObject->broadCast, &BroadCast::requestJson);
-		connect(ui->pushButton_refesh, &QPushButton::clicked, &mainObject->broadCast, &BroadCast::requestSensors);
-	}
-	connect(&mainObject->items, &ItemStore::itemAdded, ui->relayList, &ItemScrollBox::addItem);
-	connect(&mainObject->items, &ItemStore::itemDeleted, ui->relayList, &ItemScrollBox::removeItem);
 
-	for(size_t i = 0; i < mainObject->items.getItems()->size(); ++i)
+	for(size_t i = 0; i < globalItems.getItems()->size(); ++i)
-	{
+		ui->relayList->addItem(globalItems.getItems()->at(i));
-		ui->relayList->addItem(mainObject->items.getItems()->at(i));
-	}
 
 	//Sensors
 	ui->sensorListView->setShowHidden(false);
@@ -53,7 +35,7 @@ MainWindow::MainWindow(MainObject * const mainObject, QWidget *parent) :
 	connect(ui->button_color, SIGNAL(clicked()), &colorChooser, SLOT(show()));
 
 	connect(ui->pushButton_addItem, &QPushButton::clicked, this, &MainWindow::showItemCreationDialog);
-	connect(ui->relayList, &ItemScrollBox::deleteRequest, &mainObject->items, &ItemStore::removeItem);
+	connect(ui->relayList, &ItemScrollBox::deleteRequest, &globalItems, &ItemStore::removeItem);
 
 	ui->splitter->setStretchFactor(1, 1);
 }
@@ -70,14 +52,10 @@ void MainWindow::showPowerItemDialog()
 	diag.exec();
 }
 
-void MainWindow::saved()
-{
-	QMessageBox::information(this, "Saved", "Settings where saved");
-}
-
 void MainWindow::slotChangedRgb(const QColor color)
 {
-	_micro->changeRgbColor(color);
+	(void)color;
+	//_micro->changeRgbColor(color);
 }
 
 void MainWindow::showItemCreationDialog()

src/ui/mainwindow.h

@@ -5,13 +5,8 @@
 #include <QColorDialog>
 #include <QListWidgetItem>
 #include <QTime>
-#include <vector>
+#include <memory>
-#include "../actors/alarmtime.h"
+#include "src/items/poweritem.h"
-#include "../microcontroller.h"
-#include "../sensors/sensor.h"
-#include "../items/itemstore.h"
-#include "../items/poweritem.h"
-#include "../broadcast.h"
 
 
 class MainObject;
@@ -34,13 +29,10 @@ private:
 
 	QColorDialog colorChooser;
 
-	Microcontroller *_micro;
-
 	std::shared_ptr<PowerItem> _powerItem;
 
 signals:
 
-	void sigBrodcast();
 	void sigSave();
 	void createdItem(std::shared_ptr<Item> item);
 
@@ -50,7 +42,6 @@ private slots:
 	void slotChangedRgb(const QColor color);
 	void showPowerItemDialog();
 	void showItemCreationDialog();
-	void saved();
 
 public slots: