uvos/UvosSmartHomeInterface
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

move from tabs to spaces

Browse source
This commit is contained in:
uvos 2022-04-15 13:28:47 +02:00
parent a6aad07f05
commit fa45072998
86 changed files with 2611 additions and 2486 deletions
Download patch file Download diff file Expand all files Collapse all files

78
src/actors/actor.cpp
View file

@ -19,71 +19,71 @@ Actor::~Actor()
void Actor::performAction() void Actor::performAction()
{ {
if(active) if(active)
{ {
sigValue(triggerValue); sigValue(triggerValue);
} }
} }
void Actor::makeActive() void Actor::makeActive()
{ {
active = true; active = true;
} }
void Actor::makeInactive() void Actor::makeInactive()
{ {
active = false; active = false;
} }
QString Actor::actionName() QString Actor::actionName()
{ {
QString string; QString string;
if(triggerValue == 0 ) string = "off"; if(triggerValue == 0 ) string = "off";
else if(triggerValue == 1 ) string = "on"; else if(triggerValue == 1 ) string = "on";
else string = "value to " + QString::number(triggerValue); else string = "value to " + QString::number(triggerValue);
return string; return string;
} }
void Actor::setActive(uint8_t state) void Actor::setActive(uint8_t state)
{ {
state ? makeActive() : makeInactive(); state ? makeActive() : makeInactive();
} }
bool Actor::isActive() bool Actor::isActive()
{ {
return active; return active;
} }
bool Actor::isExausted() bool Actor::isExausted()
{ {
return exausted; return exausted;
} }
void Actor::store(QJsonObject& json) void Actor::store(QJsonObject& json)
{ {
Item::store(json); Item::store(json);
json["Active"] = active; json["Active"] = active;
json["Exausted"] = exausted; json["Exausted"] = exausted;
json["TriggerValue"] = triggerValue; json["TriggerValue"] = triggerValue;
} }
void Actor::load(const QJsonObject& json, const bool preserve) void Actor::load(const QJsonObject& json, const bool preserve)
{ {
Item::load(json, preserve); Item::load(json, preserve);
active = json["Active"].toBool(); active = json["Active"].toBool();
exausted = json["Exausted"].toBool(); exausted = json["Exausted"].toBool();
triggerValue = json["TriggerValue"].toInt(); triggerValue = json["TriggerValue"].toInt();
} }
void Actor::setTriggerValue(uint8_t value) void Actor::setTriggerValue(uint8_t value)
{ {
triggerValue=value; triggerValue=value;
} }
uint8_t Actor::getTriggerValue() uint8_t Actor::getTriggerValue()
{ {
return triggerValue; return triggerValue;
} }
void Actor::onValueChanged(uint8_t value) void Actor::onValueChanged(uint8_t value)
@ -93,28 +93,28 @@ void Actor::onValueChanged(uint8_t value)
std::shared_ptr<Actor> Actor::createActor(const QString& type) std::shared_ptr<Actor> Actor::createActor(const QString& type)
{ {
std::shared_ptr<Actor> actor; std::shared_ptr<Actor> actor;
if(type == "Alarm") actor = std::shared_ptr<Actor>(new AlarmTime()); if(type == "Alarm") actor = std::shared_ptr<Actor>(new AlarmTime());
else if(type == "Sensor") actor = std::shared_ptr<Actor>(new SensorActor()); else if(type == "Sensor") actor = std::shared_ptr<Actor>(new SensorActor());
else if(type == "Timer") actor = std::shared_ptr<Actor>(new TimerActor()); else if(type == "Timer") actor = std::shared_ptr<Actor>(new TimerActor());
else if(type == "Regulator") actor = std::shared_ptr<Actor>(new Regulator()); else if(type == "Regulator") actor = std::shared_ptr<Actor>(new Regulator());
else if(type == "Polynomal") actor = std::shared_ptr<Actor>(new PolynomalActor()); else if(type == "Polynomal") actor = std::shared_ptr<Actor>(new PolynomalActor());
else if(type == "MultiFactor") actor = std::shared_ptr<Actor>(new MultiFactorActor()); else if(type == "MultiFactor") actor = std::shared_ptr<Actor>(new MultiFactorActor());
else if(type == "Actor") actor = std::shared_ptr<Actor>(new Actor()); else if(type == "Actor") actor = std::shared_ptr<Actor>(new Actor());
return actor; return actor;
} }
std::shared_ptr<Actor> Actor::loadActor(const QJsonObject &json) std::shared_ptr<Actor> Actor::loadActor(const QJsonObject &json)
{ {
QString type = json["Type"].toString("Actor"); QString type = json["Type"].toString("Actor");
std::shared_ptr<Actor> actor = createActor(type); std::shared_ptr<Actor> actor = createActor(type);
if(actor) actor->load(json); if(actor) actor->load(json);
return actor; return actor;
} }
void Actor::setValue(uint8_t value) void Actor::setValue(uint8_t value)
{ {
Item::setValue(value); Item::setValue(value);
setActive(value); setActive(value);
} }

44
src/actors/actor.h
View file

@ -9,46 +9,46 @@
class Actor : public Item class Actor : public Item
{ {
Q_OBJECT Q_OBJECT
public: public:
uint8_t triggerValue = 0; uint8_t triggerValue = 0;
protected: protected:
bool active = true; bool active = true;
bool exausted = false; bool exausted = false;
void performAction(); void performAction();
signals: signals:
void sigValue(uint8_t value); void sigValue(uint8_t value);
public slots: public slots:
virtual void makeActive(); virtual void makeActive();
virtual void makeInactive(); virtual void makeInactive();
virtual void setActive(uint8_t state); virtual void setActive(uint8_t state);
virtual void onValueChanged(uint8_t state); virtual void onValueChanged(uint8_t state);
virtual void setValue(uint8_t value); virtual void setValue(uint8_t value);
public: public:
Actor(QObject* parent = nullptr); Actor(QObject* parent = nullptr);
virtual ~Actor(); virtual ~Actor();
bool isExausted(); bool isExausted();
virtual QString actionName(); virtual QString actionName();
bool isActive(); bool isActive();
void setTriggerValue(uint8_t value); void setTriggerValue(uint8_t value);
uint8_t getTriggerValue(); uint8_t getTriggerValue();
static std::shared_ptr<Actor> createActor(const QString& type); static std::shared_ptr<Actor> createActor(const QString& type);
virtual void store(QJsonObject& json); virtual void store(QJsonObject& json);
virtual void load(const QJsonObject& json, const bool preserve = false); virtual void load(const QJsonObject& json, const bool preserve = false);
static std::shared_ptr<Actor> loadActor(const QJsonObject& json); static std::shared_ptr<Actor> loadActor(const QJsonObject& json);
}; };
#endif // ACTOR_H #endif // ACTOR_H

152
src/actors/alarmtime.cpp
View file

@ -2,132 +2,132 @@
AlarmTime::AlarmTime(const QDateTime time, QObject *parent) : Actor(parent), time_(time) AlarmTime::AlarmTime(const QDateTime time, QObject *parent) : Actor(parent), time_(time)
{ {
connect(&timer, SIGNAL(timeout()), this, SLOT(doTick())); connect(&timer, SIGNAL(timeout()), this, SLOT(doTick()));
timer.setInterval(1000); timer.setInterval(1000);
run(); run();
} }
AlarmTime::~AlarmTime() AlarmTime::~AlarmTime()
{ {
makeInactive(); makeInactive();
} }
void AlarmTime::run() void AlarmTime::run()
{ {
makeInactive(); makeInactive();
active = true; active = true;
timer.start(); timer.start();
} }
void AlarmTime::makeActive() void AlarmTime::makeActive()
{ {
run(); run();
} }
QString AlarmTime::getName() const QString AlarmTime::getName() const
{ {
if(name_.size() > 0)return name_; if(name_.size() > 0)return name_;
else else
{ {
QString string; QString string;
string = "Alarm: "; string = "Alarm: ";
if(repeat_ == REPEAT_DAILY) if(repeat_ == REPEAT_DAILY)
{ {
string.append("daily "); string.append("daily ");
string.append(time_.toString("HH:mm")); string.append(time_.toString("HH:mm"));
} }
else if(repeat_ == REPEAT_WEEKLY) else if(repeat_ == REPEAT_WEEKLY)
{ {
string.append("weekly "); string.append("weekly ");
string.append(time_.toString("ddd HH:mm")); string.append(time_.toString("ddd HH:mm"));
} }
else if(repeat_ == REPEAT_MONTHLY) else if(repeat_ == REPEAT_MONTHLY)
{ {
string.append("monthly "); string.append("monthly ");
string.append(time_.toString("dd HH:mm")); string.append(time_.toString("dd HH:mm"));
} }
else if(repeat_ == REPEAT_YEARLY) else if(repeat_ == REPEAT_YEARLY)
{ {
string.append("yearly "); string.append("yearly ");
string.append(time_.toString("dd.mm HH:mm")); string.append(time_.toString("dd.mm HH:mm"));
} }
else string.append(time_.toString("dd.mm.yyyy HH:mm")); else string.append(time_.toString("dd.mm.yyyy HH:mm"));
return string; return string;
} }
} }
void AlarmTime::setRepeat(const uint8_t repeat) void AlarmTime::setRepeat(const uint8_t repeat)
{ {
repeat_=repeat; repeat_=repeat;
exausted = false; exausted = false;
} }
uint8_t AlarmTime::getRepeat() uint8_t AlarmTime::getRepeat()
{ {
return repeat_; return repeat_;
} }
QDateTime AlarmTime::getDateTime() QDateTime AlarmTime::getDateTime()
{ {
return time_; return time_;
} }
void AlarmTime::makeInactive() void AlarmTime::makeInactive()
{ {
timer.stop(); timer.stop();
active = false; active = false;
} }
void AlarmTime::doTick() void AlarmTime::doTick()
{ {
if( if(
( (
(triggerd_ == false) && (triggerd_ == false) &&
(time_.date().year() == QDate::currentDate().year() || repeat_ != REPEAT_NEVER) && (time_.date().year() == QDate::currentDate().year() || repeat_ != REPEAT_NEVER) &&
(time_.date().month() == QDate::currentDate().month() || repeat_ == REPEAT_MONTHLY || repeat_ == REPEAT_DAILY) && (time_.date().month() == QDate::currentDate().month() || repeat_ == REPEAT_MONTHLY || repeat_ == REPEAT_DAILY) &&
(time_.date().day() == QDate::currentDate().day() || repeat_ == REPEAT_DAILY) (time_.date().day() == QDate::currentDate().day() || repeat_ == REPEAT_DAILY)
) )
|| ||
( (
(repeat_ == REPEAT_WEEKLY) && (repeat_ == REPEAT_WEEKLY) &&
(time_.date().dayOfWeek() == QDate::currentDate().dayOfWeek()) (time_.date().dayOfWeek() == QDate::currentDate().dayOfWeek())
) )
) )
{ {
if(time_.time().hour() == QTime::currentTime().hour() && time_.time().minute() == QTime::currentTime().minute()) if(time_.time().hour() == QTime::currentTime().hour() && time_.time().minute() == QTime::currentTime().minute())
{ {
triggerd_=true; triggerd_=true;
performAction(); performAction();
if(repeat_ == REPEAT_NEVER) exausted = true; if(repeat_ == REPEAT_NEVER) exausted = true;
} }
} }
else if( repeat_ != REPEAT_NEVER && time_.time().hour() != QTime::currentTime().hour() ) triggerd_=false; else if( repeat_ != REPEAT_NEVER && time_.time().hour() != QTime::currentTime().hour() ) triggerd_=false;
} }
void AlarmTime::changeTime(const QDateTime& time) void AlarmTime::changeTime(const QDateTime& time)
{ {
time_=time; time_=time;
exausted = false; exausted = false;
qDebug()<<"time: "<<time_; qDebug()<<"time: "<<time_;
} }
void AlarmTime::store(QJsonObject& json) void AlarmTime::store(QJsonObject& json)
{ {
json["Type"] = "Alarm"; json["Type"] = "Alarm";
Actor::store(json); Actor::store(json);
json["Time"] = time_.toString(); json["Time"] = time_.toString();
json["Repeat"] = repeat_; json["Repeat"] = repeat_;
} }
void AlarmTime::load(const QJsonObject& json, const bool preserve) void AlarmTime::load(const QJsonObject& json, const bool preserve)
{ {
bool oldActive = isActive(); bool oldActive = isActive();
Actor::load(json, preserve); Actor::load(json, preserve);
time_ = QDateTime::fromString(json["Time"].toString("")); time_ = QDateTime::fromString(json["Time"].toString(""));
repeat_ = json["Repeat"].toInt(REPEAT_NEVER); repeat_ = json["Repeat"].toInt(REPEAT_NEVER);
if(oldActive != isActive()) setActive(isActive()); if(oldActive != isActive()) setActive(isActive());
} }

46
src/actors/alarmtime.h
View file

@ -14,41 +14,41 @@
class AlarmTime : public Actor, public QRunnable class AlarmTime : public Actor, public QRunnable
{ {
Q_OBJECT Q_OBJECT
public: public:
static const uint8_t REPEAT_NEVER = 0; static const uint8_t REPEAT_NEVER = 0;
static const uint8_t REPEAT_DAILY = 1; static const uint8_t REPEAT_DAILY = 1;
static const uint8_t REPEAT_WEEKLY = 2; static const uint8_t REPEAT_WEEKLY = 2;
static const uint8_t REPEAT_MONTHLY = 3; static const uint8_t REPEAT_MONTHLY = 3;
static const uint8_t REPEAT_YEARLY = 4; static const uint8_t REPEAT_YEARLY = 4;
private: private:
bool triggerd_ = false; bool triggerd_ = false;
QDateTime time_; QDateTime time_;
QTimer timer; QTimer timer;
uint8_t repeat_ = REPEAT_NEVER; uint8_t repeat_ = REPEAT_NEVER;
public: public:
explicit AlarmTime(const QDateTime time = QDateTime::currentDateTime(), QObject *parent = nullptr); explicit AlarmTime(const QDateTime time = QDateTime::currentDateTime(), QObject *parent = nullptr);
~AlarmTime(); ~AlarmTime();
QDateTime getDateTime(); QDateTime getDateTime();
virtual void store(QJsonObject& json); virtual void store(QJsonObject& json);
virtual void load(const QJsonObject& json, const bool preserve = false); virtual void load(const QJsonObject& json, const bool preserve = false);
uint8_t getRepeat(); uint8_t getRepeat();
public slots: public slots:
void run(); void run();
virtual void makeActive(); virtual void makeActive();
virtual void makeInactive(); virtual void makeInactive();
virtual QString getName() const; virtual QString getName() const;
void doTick(); void doTick();
void changeTime(const QDateTime& time); void changeTime(const QDateTime& time);
void setRepeat(const uint8_t repeat); void setRepeat(const uint8_t repeat);
}; };
#endif // ALARMTIME_H #endif // ALARMTIME_H

96
src/actors/factoractor.cpp
View file

@ -1,79 +1,79 @@
#include "factoractor.h" #include "factoractor.h"
MultiFactorActor::MultiFactorActor(Actor* factorActor, const uint preCancleMin, QObject *parent): MultiFactorActor::MultiFactorActor(Actor* factorActor, const uint preCancleMin, QObject *parent):
Actor(parent), Actor(parent),
factorActor_(factorActor), factorActor_(factorActor),
preCancleMin_(preCancleMin) preCancleMin_(preCancleMin)
{ {
activationTime.setMSecsSinceEpoch(0); activationTime.setMSecsSinceEpoch(0);
if(factorActor) connect(factorActor, &Actor::sigValue, this, &MultiFactorActor::factorActorSlot); if(factorActor) connect(factorActor, &Actor::sigValue, this, &MultiFactorActor::factorActorSlot);
} }
void MultiFactorActor::factorActorSlot(uint8_t value) void MultiFactorActor::factorActorSlot(uint8_t value)
{ {
if(value == factorDirection) if(value == factorDirection)
{ {
activationTime = QDateTime::currentDateTime(); activationTime = QDateTime::currentDateTime();
} }
} }
void MultiFactorActor::setValue(uint8_t value) void MultiFactorActor::setValue(uint8_t value)
{ {
if(value) if(value)
{ {
QDateTime current = QDateTime::currentDateTime(); QDateTime current = QDateTime::currentDateTime();
if(current.addSecs(-preCancleMin_*60) > activationTime ) if(current.addSecs(-preCancleMin_*60) > activationTime )
{ {
performAction(); performAction();
} }
bool exausted = true; bool exausted = true;
for(size_t i = 0; i < getActors().size(); ++i) if(!getActors()[i]->isExausted()) exausted = false; for(size_t i = 0; i < getActors().size(); ++i) if(!getActors()[i]->isExausted()) exausted = false;
} }
} }
QString MultiFactorActor::getName() const QString MultiFactorActor::getName() const
{ {
if(name_.size() > 0) return name_; if(name_.size() > 0) return name_;
else else
{ {
QString string; QString string;
string = "Multi Factor \"" + (factorActor_ ? factorActor_->getName() : "NULL") + "\""; string = "Multi Factor \"" + (factorActor_ ? factorActor_->getName() : "NULL") + "\"";
return string; return string;
} }
} }
void MultiFactorActor::setFactorActor(std::shared_ptr<Actor> factorActor) void MultiFactorActor::setFactorActor(std::shared_ptr<Actor> factorActor)
{ {
factorActor_=factorActor; factorActor_=factorActor;
connect(factorActor_.get(), &Actor::sigValue, this, &MultiFactorActor::factorActorSlot); connect(factorActor_.get(), &Actor::sigValue, this, &MultiFactorActor::factorActorSlot);
} }
void MultiFactorActor::store(QJsonObject &json) void MultiFactorActor::store(QJsonObject &json)
{ {
json["Type"] = "MultiFactor"; json["Type"] = "MultiFactor";
Actor::store(json); Actor::store(json);
json["PreCancleMinutes"] = static_cast<int>(preCancleMin_); json["PreCancleMinutes"] = static_cast<int>(preCancleMin_);
json["FactorDirection"] = factorDirection; json["FactorDirection"] = factorDirection;
QJsonObject factorActorObject; QJsonObject factorActorObject;
if(factorActor_) if(factorActor_)
{ {
factorActor_->store(factorActorObject); factorActor_->store(factorActorObject);
} }
} }
void MultiFactorActor::load(const QJsonObject &json, bool preserve) void MultiFactorActor::load(const QJsonObject &json, bool preserve)
{ {
Actor::load(json, preserve); Actor::load(json, preserve);
preCancleMin_ = static_cast<uint>(json["PreCancleMinutes"].toInt(10)); preCancleMin_ = static_cast<uint>(json["PreCancleMinutes"].toInt(10));
factorDirection = json["FacotorDirection"].toBool(true); factorDirection = json["FacotorDirection"].toBool(true);
if(json["FactorActor"].isObject()) if(json["FactorActor"].isObject())
{ {
factorActor_ = Actor::loadActor(json["FactorActor"].toObject()); factorActor_ = Actor::loadActor(json["FactorActor"].toObject());
} }
if(factorActor_) if(factorActor_)
{ {
connect(factorActor_.get(), &Actor::sigValue, this, &MultiFactorActor::factorActorSlot); connect(factorActor_.get(), &Actor::sigValue, this, &MultiFactorActor::factorActorSlot);
} }
} }

49
src/actors/factoractor.h
View file

@ -8,37 +8,52 @@ class MultiFactorActor: public Actor
{ {
private: private:
std::shared_ptr<Actor> factorActor_; std::shared_ptr<Actor> factorActor_;
QDateTime activationTime; QDateTime activationTime;
uint preCancleMin_; uint preCancleMin_;
bool factorDirection = true; bool factorDirection = true;
private slots: private slots:
void factorActorSlot(uint8_t value); void factorActorSlot(uint8_t value);
public slots: public slots:
virtual void setValue(uint8_t value); virtual void setValue(uint8_t value);
public: public:
MultiFactorActor(Actor* FactorActor = nullptr, const uint preCancleMin = 10, QObject *parent = nullptr); MultiFactorActor(Actor* FactorActor = nullptr, const uint preCancleMin = 10, QObject *parent = nullptr);
virtual QString getName() const; virtual QString getName() const;
void setFactorActor(std::shared_ptr<Actor> factorActor); void setFactorActor(std::shared_ptr<Actor> factorActor);
std::shared_ptr<Actor> getFactorActor(){return factorActor_;} std::shared_ptr<Actor> getFactorActor()
void setFactorDirection(const bool direction){factorDirection = direction;} {
bool getFactorDirection(){return factorDirection;} return factorActor_;
uint getPreCancleTime(){return preCancleMin_;} }
void setPreCancleTime(uint minutes){preCancleMin_ = minutes;} 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 store(QJsonObject& json);
virtual void load(const QJsonObject& json, bool preserve); virtual void load(const QJsonObject& json, bool preserve);
}; };
#endif // REMINDERACTOR_H #endif // REMINDERACTOR_H

88
src/actors/polynomalactor.cpp
View file

@ -12,72 +12,74 @@ PolynomalActor::PolynomalActor(QObject* parent): Actor(parent)
void PolynomalActor::setSensor(const Sensor sensor) void PolynomalActor::setSensor(const Sensor sensor)
{ {
sensor_ = sensor; sensor_ = sensor;
} }
void PolynomalActor::setCoeffiancts( const double pow3, const double pow2, const double pow1, const double pow0 ) void PolynomalActor::setCoeffiancts( const double pow3, const double pow2, const double pow1, const double pow0 )
{ {
pow3_=pow3; pow3_=pow3;
pow2_=pow2; pow2_=pow2;
pow1_=pow1; pow1_=pow1;
pow0_=pow0; pow0_=pow0;
} }
void PolynomalActor::getCoeffiancts( double& pow3, double& pow2, double& pow1, double& pow0 ) void PolynomalActor::getCoeffiancts( double& pow3, double& pow2, double& pow1, double& pow0 )
{ {
pow3=pow3_; pow3=pow3_;
pow2=pow2_; pow2=pow2_;
pow1=pow1_; pow1=pow1_;
pow0=pow0_; pow0=pow0_;
} }
void PolynomalActor::sensorEvent(Sensor sensor) void PolynomalActor::sensorEvent(Sensor sensor)
{ {
if(active && 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
if(result < 0) result = 0; +pow0_;
else if(result > 254) result = 255; if(result < 0) result = 0;
if(result != prevValue)sigValue(static_cast<uint8_t>(result)); else if(result > 254) result = 255;
prevValue = result; if(result != prevValue)sigValue(static_cast<uint8_t>(result));
} prevValue = result;
}
} }
void PolynomalActor::store(QJsonObject& json) void PolynomalActor::store(QJsonObject& json)
{ {
json["Type"] = "Polynomal"; json["Type"] = "Polynomal";
Actor::store(json); Actor::store(json);
json["Pow3"] = pow3_; json["Pow3"] = pow3_;
json["Pow2"] = pow2_; json["Pow2"] = pow2_;
json["Pow1"] = pow1_; json["Pow1"] = pow1_;
json["Pow0"] = pow0_; json["Pow0"] = pow0_;
json["SensorType"] = static_cast<int>(sensor_.type); json["SensorType"] = static_cast<int>(sensor_.type);
json["SensorId"] = static_cast<int>(sensor_.id); json["SensorId"] = static_cast<int>(sensor_.id);
json["SensorField"] = sensor_.field; json["SensorField"] = sensor_.field;
json["SensorName"] = sensor_.name; json["SensorName"] = sensor_.name;
} }
void PolynomalActor::load(const QJsonObject& json, bool preserve) void PolynomalActor::load(const QJsonObject& json, bool preserve)
{ {
Actor::load(json, preserve); Actor::load(json, preserve);
pow3_ = json["Pow3"].toDouble(0); pow3_ = json["Pow3"].toDouble(0);
pow2_ = json["Pow2"].toDouble(0); pow2_ = json["Pow2"].toDouble(0);
pow1_ = json["Pow1"].toDouble(1); pow1_ = json["Pow1"].toDouble(1);
pow0_ = json["Pow0"].toDouble(0); pow0_ = json["Pow0"].toDouble(0);
sensor_.type = json["SensorType"].toInt(0); sensor_.type = json["SensorType"].toInt(0);
sensor_.id = json["SensorId"].toInt(0); sensor_.id = json["SensorId"].toInt(0);
sensor_.field = json["SensorField"].toInt(0); sensor_.field = json["SensorField"].toInt(0);
sensor_.name = json["SensorName"].toString("Sensor"); sensor_.name = json["SensorName"].toString("Sensor");
} }
QString PolynomalActor::getName() const QString PolynomalActor::getName() const
{ {
if(name_.size() > 0) return name_; if(name_.size() > 0) return name_;
else else
{ {
QString string; 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(
return string; pow1_) + "x + " + QString::number(pow0_) + " (x: " + sensor_.name + ")";
} return string;
}
} }

39
src/actors/polynomalactor.h
View file

@ -5,35 +5,38 @@
class PolynomalActor: public Actor class PolynomalActor: public Actor
{ {
Q_OBJECT Q_OBJECT
private: private:
Sensor sensor_; Sensor sensor_;
double pow3_ = 0; double pow3_ = 0;
double pow2_ = 0; double pow2_ = 0;
double pow1_ = 1; double pow1_ = 1;
double pow0_ = 0; double pow0_ = 0;
double prevValue = -1; double prevValue = -1;
public slots: public slots:
void sensorEvent(Sensor sensor); void sensorEvent(Sensor sensor);
public: public:
void setCoeffiancts( const double pow3, const double pow2, const double pow1, const double pow0 ); void setCoeffiancts( const double pow3, const double pow2, const double pow1, const double pow0 );
void getCoeffiancts( double& pow3, double& pow2, double& pow1, double& pow0 ); void getCoeffiancts( double& pow3, double& pow2, double& pow1, double& pow0 );
PolynomalActor(const Sensor sensor, QObject* parent = nullptr); PolynomalActor(const Sensor sensor, QObject* parent = nullptr);
PolynomalActor(QObject* parent = nullptr); PolynomalActor(QObject* parent = nullptr);
void setSensor(const Sensor sensor); void setSensor(const Sensor sensor);
Sensor getSensor(){return sensor_;} Sensor getSensor()
virtual QString getName() const; {
virtual ~PolynomalActor(){} return sensor_;
}
virtual QString getName() const;
virtual ~PolynomalActor() {}
virtual void store(QJsonObject& json); virtual void store(QJsonObject& json);
virtual void load(const QJsonObject& json, bool preserve); virtual void load(const QJsonObject& json, bool preserve);
}; };
#endif // POLYNOMALACTOR_H #endif // POLYNOMALACTOR_H

80
src/actors/regulator.cpp
View file

@ -14,72 +14,72 @@ Regulator::Regulator(QObject* parent): Actor(parent)
void Regulator::setSensor(const Sensor sensor) void Regulator::setSensor(const Sensor sensor)
{ {
sensor_ = sensor; sensor_ = sensor;
} }
void Regulator::sensorEvent(Sensor sensor) void Regulator::sensorEvent(Sensor sensor)
{ {
if(active && sensor == sensor_) if(active && sensor == sensor_)
{ {
if( sensor.field < setPoint_-band_ && (sensor.field < sensor_.field || sensor_.field > setPoint_-band_ || first) ) if( sensor.field < setPoint_-band_ && (sensor.field < sensor_.field || sensor_.field > setPoint_-band_ || first) )
{ {
sigValue(triggerValue); sigValue(triggerValue);
} }
else if( sensor.field > setPoint_+band_ && (sensor.field > sensor_.field || sensor_.field < setPoint_+band_ || first) ) else if( sensor.field > setPoint_+band_ && (sensor.field > sensor_.field || sensor_.field < setPoint_+band_ || first) )
{ {
sigValue(!triggerValue); sigValue(!triggerValue);
} }
first = false; first = false;
sensor_ = sensor; sensor_ = sensor;
} }
} }
void Regulator::setPoint(float setPoint) void Regulator::setPoint(float setPoint)
{ {
setPoint_ = setPoint; setPoint_ = setPoint;
} }
void Regulator::setBand ( float band ) void Regulator::setBand ( float band )
{ {
band_ = band; band_ = band;
} }
void Regulator::setInvert( bool invert ) void Regulator::setInvert( bool invert )
{ {
invert_ = invert; invert_ = invert;
} }
void Regulator::store(QJsonObject& json) void Regulator::store(QJsonObject& json)
{ {
json["Type"] = "Regulator"; json["Type"] = "Regulator";
Actor::store(json); Actor::store(json);
json["Band"] = band_; json["Band"] = band_;
json["SetPoint"] = setPoint_; json["SetPoint"] = setPoint_;
json["SensorType"] = static_cast<int>(sensor_.type); json["SensorType"] = static_cast<int>(sensor_.type);
json["SensorId"] = static_cast<int>(sensor_.id); json["SensorId"] = static_cast<int>(sensor_.id);
json["SensorField"] = sensor_.field; json["SensorField"] = sensor_.field;
json["SensorName"] = sensor_.name; json["SensorName"] = sensor_.name;
} }
void Regulator::load(const QJsonObject& json, bool preserve) void Regulator::load(const QJsonObject& json, bool preserve)
{ {
Actor::load(json, preserve); Actor::load(json, preserve);
band_ = json["Band"].toDouble(1); band_ = json["Band"].toDouble(1);
setPoint_ = json["SetPoint"].toDouble(22); setPoint_ = json["SetPoint"].toDouble(22);
sensor_.type = json["SensorType"].toInt(0); sensor_.type = json["SensorType"].toInt(0);
sensor_.id = json["SensorId"].toInt(0); sensor_.id = json["SensorId"].toInt(0);
sensor_.field = json["SensorField"].toInt(0); sensor_.field = json["SensorField"].toInt(0);
sensor_.name = json["SensorName"].toString("Sensor"); sensor_.name = json["SensorName"].toString("Sensor");
} }
QString Regulator::getName() const QString Regulator::getName() const
{ {
if(name_.size() > 0) return name_; if(name_.size() > 0) return name_;
else else
{ {
QString string; QString string;
string = "Regulate \"" + sensor_.name + "\" to "; string = "Regulate \"" + sensor_.name + "\" to ";
string.append(QString::number(setPoint_) + " "); string.append(QString::number(setPoint_) + " ");
return string; return string;
} }
} }

49
src/actors/regulator.h
View file

@ -4,35 +4,44 @@
class Regulator : public Actor class Regulator : public Actor
{ {
Q_OBJECT Q_OBJECT
private: private:
Sensor sensor_; Sensor sensor_;
float setPoint_ = 0; float setPoint_ = 0;
float band_ = 1; float band_ = 1;
bool invert_ = false; bool invert_ = false;
bool first = true; bool first = true;
public slots: public slots:
void sensorEvent(Sensor sensor); void sensorEvent(Sensor sensor);
void setSensor(const Sensor sensor); void setSensor(const Sensor sensor);
void setPoint( float setPoint ); void setPoint( float setPoint );
void setBand ( float band ); void setBand ( float band );
void setInvert( bool invert ); void setInvert( bool invert );
public: public:
float getBand() {return band_;} float getBand()
float getSetPoint() {return setPoint_;} {
Regulator(const Sensor sensor, QObject* parent = nullptr); return band_;
Regulator(QObject* parent = nullptr); }
Sensor getSensor(){return sensor_;} float getSetPoint()
virtual QString getName() const; {
virtual ~Regulator(){} return setPoint_;
}
Regulator(const Sensor sensor, QObject* parent = nullptr);
Regulator(QObject* parent = nullptr);
Sensor getSensor()
{
return sensor_;
}
virtual QString getName() const;
virtual ~Regulator() {}
virtual void store(QJsonObject& json); virtual void store(QJsonObject& json);
virtual void load(const QJsonObject& json, bool preserve); virtual void load(const QJsonObject& json, bool preserve);
}; };

76
src/actors/sensoractor.cpp
View file

@ -14,74 +14,76 @@ SensorActor::SensorActor(QObject* parent): Actor(parent)
void SensorActor::setSensor(const Sensor sensor) void SensorActor::setSensor(const Sensor sensor)
{ {
sensor_ = sensor; sensor_ = sensor;
} }
void SensorActor::sensorEvent(Sensor sensor) void SensorActor::sensorEvent(Sensor sensor)
{ {
if(sensor == sensor_) if(sensor == sensor_)
{ {
if((sloap_ == SLOPE_UP || sloap_ == SLOPE_BOTH) && sensor_.field < threshold_ && sensor.field >= threshold_ ) performAction(); if((sloap_ == SLOPE_UP || sloap_ == SLOPE_BOTH) && sensor_.field < threshold_
else if((sloap_ == SLOPE_DOWN || sloap_ == SLOPE_BOTH) && sensor_.field > threshold_ && sensor.field <= threshold_) performAction(); && sensor.field >= threshold_ ) performAction();
sensor_ = sensor; else if((sloap_ == SLOPE_DOWN || sloap_ == SLOPE_BOTH) && sensor_.field > threshold_
} && sensor.field <= threshold_) performAction();
sensor_ = sensor;
}
} }
void SensorActor::setSloap(uint8_t sloap) void SensorActor::setSloap(uint8_t sloap)
{ {
sloap_=sloap; sloap_=sloap;
} }
void SensorActor::setThreshold(float threshold) void SensorActor::setThreshold(float threshold)
{ {
threshold_ = threshold; threshold_ = threshold;
} }
float SensorActor::getThreshold() float SensorActor::getThreshold()
{ {
return threshold_; return threshold_;
} }
uint8_t SensorActor::getSloap() uint8_t SensorActor::getSloap()
{ {
return sloap_; return sloap_;
} }
void SensorActor::store(QJsonObject& json) void SensorActor::store(QJsonObject& json)
{ {
json["Type"] = "Sensor"; json["Type"] = "Sensor";
Actor::store(json); Actor::store(json);
json["Sloap"] = sloap_; json["Sloap"] = sloap_;
json["Threshold"] = threshold_; json["Threshold"] = threshold_;
json["SensorType"] = static_cast<int>(sensor_.type); json["SensorType"] = static_cast<int>(sensor_.type);
json["SensorId"] = static_cast<int>(sensor_.id); json["SensorId"] = static_cast<int>(sensor_.id);
json["SensorField"] = sensor_.field; json["SensorField"] = sensor_.field;
json["SensorName"] = sensor_.name; json["SensorName"] = sensor_.name;
} }
void SensorActor::load(const QJsonObject& json, bool preserve) void SensorActor::load(const QJsonObject& json, bool preserve)
{ {
Actor::load(json, preserve); Actor::load(json, preserve);
sloap_ = json["Sloap"].toInt(0); sloap_ = json["Sloap"].toInt(0);
threshold_ = json["Threshold"].toDouble(0); threshold_ = json["Threshold"].toDouble(0);
sensor_.type = json["SensorType"].toInt(0); sensor_.type = json["SensorType"].toInt(0);
sensor_.id = json["SensorId"].toInt(0); sensor_.id = json["SensorId"].toInt(0);
sensor_.field = json["SensorField"].toInt(0); sensor_.field = json["SensorField"].toInt(0);
sensor_.name = json["SensorName"].toString("Sensor"); sensor_.name = json["SensorName"].toString("Sensor");
} }
QString SensorActor::getName() const QString SensorActor::getName() const
{ {
if(name_.size() > 0) return name_; if(name_.size() > 0) return name_;
else else
{ {
QString string; QString string;
string = "Sensor \"" + sensor_.name + "\""; string = "Sensor \"" + sensor_.name + "\"";
if(sloap_ == SLOPE_UP) string.append(" rises to "); if(sloap_ == SLOPE_UP) string.append(" rises to ");
else if (sloap_ == SLOPE_DOWN) string.append(" drops to "); else if (sloap_ == SLOPE_DOWN) string.append(" drops to ");
else if (sloap_ == SLOPE_BOTH) string.append(" passes "); else if (sloap_ == SLOPE_BOTH) string.append(" passes ");
string.append(QString::number(threshold_) + " "); string.append(QString::number(threshold_) + " ");
return string; return string;
} }
} }

43
src/actors/sensoractor.h
View file

@ -4,39 +4,42 @@
class SensorActor : public Actor class SensorActor : public Actor
{ {
Q_OBJECT Q_OBJECT
public: public:
static constexpr uint8_t SLOPE_UP = 0; static constexpr uint8_t SLOPE_UP = 0;
static constexpr uint8_t SLOPE_DOWN = 1; static constexpr uint8_t SLOPE_DOWN = 1;
static constexpr uint8_t SLOPE_BOTH = 2; static constexpr uint8_t SLOPE_BOTH = 2;
private: private:
Sensor sensor_; Sensor sensor_;
uint8_t sloap_ = SLOPE_UP; uint8_t sloap_ = SLOPE_UP;
float threshold_ = 0; float threshold_ = 0;
public slots: public slots:
void sensorEvent(Sensor sensor); void sensorEvent(Sensor sensor);
void setSloap(uint8_t sloap); void setSloap(uint8_t sloap);
void setSensor(const Sensor sensor); void setSensor(const Sensor sensor);
void setThreshold( float threshold ); void setThreshold( float threshold );
public: public:
SensorActor(const Sensor sensor, QObject* parent = nullptr); SensorActor(const Sensor sensor, QObject* parent = nullptr);
SensorActor(QObject* parent = nullptr); SensorActor(QObject* parent = nullptr);
Sensor getSensor(){return sensor_;} Sensor getSensor()
virtual QString getName() const; {
virtual ~SensorActor(){} return sensor_;
}
virtual QString getName() const;
virtual ~SensorActor() {}
float getThreshold(); float getThreshold();
uint8_t getSloap(); uint8_t getSloap();
virtual void store(QJsonObject& json); virtual void store(QJsonObject& json);
virtual void load(const QJsonObject& json, bool preserve); virtual void load(const QJsonObject& json, bool preserve);
}; };

46
src/actors/timeractor.cpp
View file

@ -3,55 +3,55 @@
TimerActor::TimerActor(const int timeoutSec, QObject *parent): Actor(parent), timeoutMsec_(timeoutSec*1000) TimerActor::TimerActor(const int timeoutSec, QObject *parent): Actor(parent), timeoutMsec_(timeoutSec*1000)
{ {
connect(&timer, &QTimer::timeout, this, &TimerActor::timeout); connect(&timer, &QTimer::timeout, this, &TimerActor::timeout);
timer.setSingleShot(true); timer.setSingleShot(true);
} }
void TimerActor::onValueChanged(uint8_t state) void TimerActor::onValueChanged(uint8_t state)
{ {
if((state && !triggerValue) || (!state && triggerValue)) if((state && !triggerValue) || (!state && triggerValue))
{ {
if(timer.isActive()) timer.stop(); if(timer.isActive()) timer.stop();
timer.setInterval(timeoutMsec_); timer.setInterval(timeoutMsec_);
timer.start(); timer.start();
} }
} }
void TimerActor::store(QJsonObject& json) void TimerActor::store(QJsonObject& json)
{ {
json["Type"] = "Timer"; json["Type"] = "Timer";
Actor::store(json); Actor::store(json);
json["Timeout"] = timeoutMsec_; json["Timeout"] = timeoutMsec_;
} }
void TimerActor::load(const QJsonObject& json, bool preserve) void TimerActor::load(const QJsonObject& json, bool preserve)
{ {
Actor::load(json, preserve); Actor::load(json, preserve);
timeoutMsec_ = json["Timeout"].toInt(10000); timeoutMsec_ = json["Timeout"].toInt(10000);
} }
void TimerActor::setTimeout(const int timeoutSec) void TimerActor::setTimeout(const int timeoutSec)
{ {
timeoutMsec_ = timeoutSec*1000; timeoutMsec_ = timeoutSec*1000;
} }
int TimerActor::getTimeout() int TimerActor::getTimeout()
{ {
return timeoutMsec_/1000; return timeoutMsec_/1000;
} }
void TimerActor::timeout() void TimerActor::timeout()
{ {
performAction(); performAction();
} }
QString TimerActor::getName() const QString TimerActor::getName() const
{ {
if(name_.size() > 0) return name_; if(name_.size() > 0) return name_;
else else
{ {
QString string; QString string;
string = "Timeout after " + QString::number(timeoutMsec_/1000) + " seconds. "; string = "Timeout after " + QString::number(timeoutMsec_/1000) + " seconds. ";
return string; return string;
} }
} }

22
src/actors/timeractor.h
View file

@ -4,27 +4,27 @@
class TimerActor: public Actor class TimerActor: public Actor
{ {
Q_OBJECT Q_OBJECT
private: private:
int timeoutMsec_; int timeoutMsec_;
QTimer timer; QTimer timer;
private slots: private slots:
void timeout(); void timeout();
public slots: public slots:
virtual void onValueChanged(uint8_t state); virtual void onValueChanged(uint8_t state);
void setTimeout(const int timeoutSec); void setTimeout(const int timeoutSec);
public: public:
explicit TimerActor(const int timeoutSec = 60, QObject *parent = nullptr); explicit TimerActor(const int timeoutSec = 60, QObject *parent = nullptr);
virtual QString getName() const; virtual QString getName() const;
int getTimeout(); int getTimeout();
virtual void store(QJsonObject& json); virtual void store(QJsonObject& json);
virtual void load(const QJsonObject& json, bool preserve); virtual void load(const QJsonObject& json, bool preserve);
}; };

9
src/alarmactions.cpp
View file

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

10
src/alarmactions.h
View file

@ -7,18 +7,18 @@
class AlarmActions : public QObject class AlarmActions : public QObject
{ {
private: private:
Q_OBJECT Q_OBJECT
Microcontroller* _micro; Microcontroller* _micro;
QApplication* a_; QApplication* a_;
public: public:
explicit AlarmActions(QApplication* a, Microcontroller* micro, QObject *parent = nullptr); explicit AlarmActions(QApplication* a, Microcontroller* micro, QObject *parent = nullptr);
signals: signals:
public slots: public slots:
void syncoff(); void syncoff();
}; };

206
src/apgetconnected.cpp
View file

@ -17,156 +17,156 @@ namespace ap
static int nl80211Init(struct nl_sock* nl_sock, int* nl80211_id) static int nl80211Init(struct nl_sock* nl_sock, int* nl80211_id)
{ {
int err; int err;
if (!nl_sock) if (!nl_sock)
{ {
std::cerr<<"Failed to allocate netlink socket.\n"; std::cerr<<"Failed to allocate netlink socket.\n";
return -ENOMEM; return -ENOMEM;
} }
if (genl_connect(nl_sock)) if (genl_connect(nl_sock))
{ {
std::cerr<<"Failed to connect to generic netlink.\n"; std::cerr<<"Failed to connect to generic netlink.\n";
err = -ENOLINK; err = -ENOLINK;
nl_socket_free(nl_sock); nl_socket_free(nl_sock);
return err; return err;
} }
nl_socket_set_buffer_size(nl_sock, 8192, 8192); nl_socket_set_buffer_size(nl_sock, 8192, 8192);
/* try to set NETLINK_EXT_ACK to 1, ignoring errors */ /* try to set NETLINK_EXT_ACK to 1, ignoring errors */
err = 1; err = 1;
setsockopt(nl_socket_get_fd(nl_sock), SOL_NETLINK, NETLINK_EXT_ACK, &err, sizeof(err)); setsockopt(nl_socket_get_fd(nl_sock), SOL_NETLINK, NETLINK_EXT_ACK, &err, sizeof(err));
*nl80211_id = genl_ctrl_resolve(nl_sock, "nl80211"); *nl80211_id = genl_ctrl_resolve(nl_sock, "nl80211");
if (*nl80211_id < 0) if (*nl80211_id < 0)
{ {
std::cerr<<"nl80211 not found.\n"; std::cerr<<"nl80211 not found.\n";
err = -ENOENT; err = -ENOENT;
nl_socket_free(nl_sock); nl_socket_free(nl_sock);
return err; return err;
} }
return 0; return 0;
} }
static int errorHandler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg) static int errorHandler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg)
{ {
printf("netlink error\n"); printf("netlink error\n");
*reinterpret_cast<int*>(arg) = 0; *reinterpret_cast<int*>(arg) = 0;
return NL_STOP; return NL_STOP;
} }
static int finishHandler(struct nl_msg *msg, void *arg) static int finishHandler(struct nl_msg *msg, void *arg)
{ {
*reinterpret_cast<int*>(arg) = 0; *reinterpret_cast<int*>(arg) = 0;
return NL_SKIP; return NL_SKIP;
} }
static int ackHandler(struct nl_msg *msg, void *arg) static int ackHandler(struct nl_msg *msg, void *arg)
{ {
*reinterpret_cast<int*>(arg) = 0; *reinterpret_cast<int*>(arg) = 0;
return NL_STOP; return NL_STOP;
} }
static int extractDeviceMac(struct nl_msg *msg, void *arg) static int extractDeviceMac(struct nl_msg *msg, void *arg)
{ {
struct nlattr* tb[NL80211_ATTR_MAX + 1]; struct nlattr* tb[NL80211_ATTR_MAX + 1];
struct genlmsghdr* gnlh = (struct genlmsghdr*)nlmsg_data(nlmsg_hdr(msg)); struct genlmsghdr* gnlh = (struct genlmsghdr*)nlmsg_data(nlmsg_hdr(msg));
std::vector<uint64_t>* deviceMacAddrs = reinterpret_cast<std::vector<uint64_t>*>(arg); std::vector<uint64_t>* deviceMacAddrs = reinterpret_cast<std::vector<uint64_t>*>(arg);
nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL); nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL);
if (!tb[NL80211_ATTR_STA_INFO]) if (!tb[NL80211_ATTR_STA_INFO])
{ {
std::cerr<<"sta stats missing!\n"; std::cerr<<"sta stats missing!\n";
return -1; return -1;
} }
const unsigned char* macChar = reinterpret_cast<const unsigned char*>(nla_data(tb[NL80211_ATTR_MAC])); const unsigned char* macChar = reinterpret_cast<const unsigned char*>(nla_data(tb[NL80211_ATTR_MAC]));
uint64_t macAddr = 0; uint64_t macAddr = 0;
memcpy(&macAddr, macChar, 6); memcpy(&macAddr, macChar, 6);
deviceMacAddrs->push_back(macAddr); deviceMacAddrs->push_back(macAddr);
return 0; return 0;
} }
std::vector<uint64_t> connectedDevices(const std::string& ifDevice, int& error) std::vector<uint64_t> connectedDevices(const std::string& ifDevice, int& error)
{ {
struct nl_sock* nl_sock = nl_socket_alloc(); struct nl_sock* nl_sock = nl_socket_alloc();
int nl80211_id = 0; int nl80211_id = 0;
error = 0; error = 0;
if(nl80211Init(nl_sock, &nl80211_id)) if(nl80211Init(nl_sock, &nl80211_id))
{ {
std::cerr<<"Can not init nl80211\n"; std::cerr<<"Can not init nl80211\n";
error = ERR_INIT; error = ERR_INIT;
} }
signed long long devidx = if_nametoindex(ifDevice.c_str()); signed long long devidx = if_nametoindex(ifDevice.c_str());
if(!devidx) if(!devidx)
{ {
std::cerr<<ifDevice<<" is not a valid if device\n"; std::cerr<<ifDevice<<" is not a valid if device\n";
error = ERR_NO_DEV; error = ERR_NO_DEV;
} }
struct nl_msg *msg; struct nl_msg *msg;
msg = nlmsg_alloc(); msg = nlmsg_alloc();
if(!msg) error = ERR_ALLOC; if(!msg) error = ERR_ALLOC;
struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT); struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
struct nl_cb *s_cb = nl_cb_alloc(NL_CB_DEFAULT); struct nl_cb *s_cb = nl_cb_alloc(NL_CB_DEFAULT);
if (!cb || !s_cb) error = ERR_ALLOC; if (!cb || !s_cb) error = ERR_ALLOC;
std::vector<uint64_t> deviceMacAddrs; std::vector<uint64_t> deviceMacAddrs;
if(error == 0) if(error == 0)
{ {
if(!genlmsg_put(msg, 0, 0, nl80211_id, 0, NLM_F_DUMP, NL80211_CMD_GET_STATION, 0)) if(!genlmsg_put(msg, 0, 0, nl80211_id, 0, NLM_F_DUMP, NL80211_CMD_GET_STATION, 0))
{ {
std::cerr<<"genlmsg_put() failed\n"; std::cerr<<"genlmsg_put() failed\n";
error = ERR_GENERAL; error = ERR_GENERAL;
} }
if(error == 0) if(error == 0)
{ {
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx); NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx);
nl_socket_set_cb(nl_sock, s_cb); nl_socket_set_cb(nl_sock, s_cb);
nl_send_auto_complete(nl_sock, msg); nl_send_auto_complete(nl_sock, msg);
{ {
int ret = 1; int ret = 1;
nl_cb_err(cb, NL_CB_CUSTOM, errorHandler, &ret); nl_cb_err(cb, NL_CB_CUSTOM, errorHandler, &ret);
nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finishHandler, &ret); nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finishHandler, &ret);
nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ackHandler, &ret); nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ackHandler, &ret);
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, extractDeviceMac, &deviceMacAddrs); nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, extractDeviceMac, &deviceMacAddrs);
while (ret > 0) nl_recvmsgs(nl_sock, cb); while (ret > 0) nl_recvmsgs(nl_sock, cb);
} }
} }
} }
nla_put_failure: nla_put_failure:
nl_cb_put(cb); nl_cb_put(cb);
nl_cb_put(s_cb); nl_cb_put(s_cb);
nlmsg_free(msg); nlmsg_free(msg);
nl_socket_free(nl_sock); nl_socket_free(nl_sock);
return deviceMacAddrs; return deviceMacAddrs;
} }
std::string macAddrToString(uint64_t macAddr) std::string macAddrToString(uint64_t macAddr)
{ {
unsigned char* macAddrPtr = reinterpret_cast<unsigned char*>(&macAddr); unsigned char* macAddrPtr = reinterpret_cast<unsigned char*>(&macAddr);
std::stringstream ss; std::stringstream ss;
ss<<std::uppercase<<std::setfill('0')<<std::setw(2)<<std::hex; ss<<std::uppercase<<std::setfill('0')<<std::setw(2)<<std::hex;
for(unsigned int i = 0; i < 6; ++i) ss<<+macAddrPtr[i]<<':'; for(unsigned int i = 0; i < 6; ++i) ss<<+macAddrPtr[i]<<':';
std::string macString = ss.str(); std::string macString = ss.str();
macString.pop_back(); macString.pop_back();
return macString; return macString;
} }
} }

20
src/apgetconnected.h
View file

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

168
src/broadcast.cpp
View file

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

40
src/broadcast.h
View file

@ -8,46 +8,46 @@
class BroadCast: public QObject class BroadCast: public QObject
{ {
Q_OBJECT Q_OBJECT
private: private:
bool master_; bool master_;
static constexpr uint8_t MODE_PREPACKET = 0; static constexpr uint8_t MODE_PREPACKET = 0;
static constexpr uint8_t MODE_PACKET = 1; static constexpr uint8_t MODE_PACKET = 1;
QByteArray buffer_; QByteArray buffer_;
QIODevice* const iodevice_; QIODevice* const iodevice_;
void write(const char * const buffer, const size_t length); void write(const char * const buffer, const size_t length);
void write(const QByteArray& buffer); void write(const QByteArray& buffer);
void decode(QByteArray buffer); void decode(QByteArray buffer);
void decodeMaster(const QByteArray& buffer); void decodeMaster(const QByteArray& buffer);
private slots: private slots:
void readyRead(); void readyRead();
public slots: public slots:
void requestJson(); void requestJson();
void requestSensors(); void requestSensors();
signals: signals:
void jsonRequested(); void jsonRequested();
void gotJson(QJsonObject json); void gotJson(QJsonObject json);
void gotSensorState(Sensor sensor); void gotSensorState(Sensor sensor);
public: public:
BroadCast(QIODevice* const iodevice = nullptr, bool master = true); BroadCast(QIODevice* const iodevice = nullptr, bool master = true);
void sendJson(const QJsonObject& json); void sendJson(const QJsonObject& json);
void sendSensors(); void sendSensors();
void sendMessage(const QString& title, const QString& body); void sendMessage(const QString& title, const QString& body);
}; };

56
src/iomuliplexer.cpp
View file

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

34
src/iomuliplexer.h
View file

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

11
src/items/auxitem.cpp
View file

@ -1,18 +1,19 @@
#include "auxitem.h" #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)
{ {
} }
void AuxItem::setValue(uint8_t value) void AuxItem::setValue(uint8_t value)
{ {
Item::setValue(value); Item::setValue(value);
micro_->setAuxPwm(value); micro_->setAuxPwm(value);
} }
void AuxItem::store(QJsonObject &json) void AuxItem::store(QJsonObject &json)
{ {
json["Type"] = "Aux"; json["Type"] = "Aux";
Item::store(json); Item::store(json);
} }

11
src/items/auxitem.h
View file

@ -5,16 +5,17 @@
class AuxItem: public Item class AuxItem: public Item
{ {
Q_OBJECT Q_OBJECT
private: private:
Microcontroller* micro_; Microcontroller* micro_;
public slots: public slots:
virtual void setValue(uint8_t value); virtual void setValue(uint8_t value);
public: public:
AuxItem(Microcontroller* micro, uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "", uint8_t value = 0, QObject* parent = nullptr); 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);
}; };

134
src/items/item.cpp
View file

@ -15,22 +15,22 @@ ItemData::ItemData(uint32_t itemIdIn, QString name, uint8_t value): name_(name),
QString ItemData::getName() const QString ItemData::getName() const
{ {
return name_; return name_;
} }
void ItemData::setName(QString name) void ItemData::setName(QString name)
{ {
name_ = name; name_ = name;
} }
uint8_t ItemData::getValue() const uint8_t ItemData::getValue() const
{ {
return value_; return value_;
} }
uint32_t ItemData::id() const uint32_t ItemData::id() const
{ {
return itemId_; return itemId_;
} }
@ -38,7 +38,8 @@ uint32_t ItemData::id() const
bool Item::secondaryFlag = false; 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,116 +55,117 @@ Item::~Item()
void Item::store(QJsonObject &json) void Item::store(QJsonObject &json)
{ {
json["Name"] = name_; json["Name"] = name_;
json["ItemId"] = static_cast<double>(itemId_); json["ItemId"] = static_cast<double>(itemId_);
json["override"] = override_; json["override"] = override_;
QJsonArray actorsArray; QJsonArray actorsArray;
for(size_t i = 0; i < actors_.size(); ++i) for(size_t i = 0; i < actors_.size(); ++i)
{ {
if(!actors_[i]->isExausted()) if(!actors_[i]->isExausted())
{ {
QJsonObject actorObject; QJsonObject actorObject;
actors_[i]->store(actorObject); actors_[i]->store(actorObject);
actorsArray.append(actorObject); actorsArray.append(actorObject);
} }
} }
json["Actors"] = actorsArray; json["Actors"] = actorsArray;
} }
void Item::load(const QJsonObject &json, const bool preserve) void Item::load(const QJsonObject &json, const bool preserve)
{ {
if(!preserve) if(!preserve)
{ {
name_ = json["Name"].toString(name_); name_ = json["Name"].toString(name_);
itemId_ = static_cast<uint32_t>(json["ItemId"].toDouble(0)); itemId_ = static_cast<uint32_t>(json["ItemId"].toDouble(0));
} }
override_ = json["override"].toBool(false); override_ = json["override"].toBool(false);
const QJsonArray actorsArray(json["Actors"].toArray(QJsonArray())); const QJsonArray actorsArray(json["Actors"].toArray(QJsonArray()));
for(int i = 0; i < actorsArray.size(); ++i) for(int i = 0; i < actorsArray.size(); ++i)
{ {
if(actorsArray[i].isObject()) if(actorsArray[i].isObject())
{ {
std::shared_ptr<Actor> actor = Actor::loadActor(actorsArray[i].toObject()); 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) void Item::actorSetValue(uint8_t value)
{ {
if(!override_) setValue(value); if(!override_) setValue(value);
} }
void Item::setValue(uint8_t value) void Item::setValue(uint8_t value)
{ {
value_ = value; value_ = value;
valueChanged(value_); valueChanged(value_);
} }
void Item::informValue(uint8_t value) void Item::informValue(uint8_t value)
{ {
Item::setValue(value); Item::setValue(value);
} }
void Item::addActor(std::shared_ptr<Actor> actor) void Item::addActor(std::shared_ptr<Actor> actor)
{ {
actor->setParent(this); actor->setParent(this);
actors_.push_back(actor); actors_.push_back(actor);
if(!secondaryFlag) if(!secondaryFlag)
{ {
connect(actor.get(), &Actor::sigValue, this, &Item::actorSetValue); connect(actor.get(), &Actor::sigValue, this, &Item::actorSetValue);
} }
connect(this, &Item::valueChanged, actor.get(), &Actor::onValueChanged); connect(this, &Item::valueChanged, actor.get(), &Actor::onValueChanged);
std::shared_ptr<SensorActor> sensorActor = std::dynamic_pointer_cast<SensorActor>(actor); 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); 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); 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) bool Item::removeActor(std::shared_ptr<Actor> actor)
{ {
for(unsigned int i = 0; i < actors_.size(); i++) for(unsigned int i = 0; i < actors_.size(); i++)
{ {
if(actors_[i] == actor) if(actors_[i] == actor)
{ {
actors_.erase(actors_.begin()+i); actors_.erase(actors_.begin()+i);
return true; return true;
} }
} }
return false; return false;
} }
void Item::setOverride(const bool in) void Item::setOverride(const bool in)
{ {
override_ = in; override_ = in;
} }
bool Item::getOverride() bool Item::getOverride()
{ {
return override_; return override_;
} }
void Item::removeAllActors() void Item::removeAllActors()
{ {
actors_.clear(); actors_.clear();
} }
std::vector< std::shared_ptr<Actor> >& Item::getActors() std::vector< std::shared_ptr<Actor> >& Item::getActors()
{ {
return actors_; return actors_;
} }
bool Item::hasActors() bool Item::hasActors()
{ {
return actors_.size() > 0; return actors_.size() > 0;
} }
void Item::setActorsActive(bool in) 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();
} }

69
src/items/item.h
View file

@ -11,67 +11,74 @@ class Actor;
class ItemData class ItemData
{ {
protected: protected:
QString name_; QString name_;
uint8_t value_; uint8_t value_;
uint32_t itemId_; uint32_t itemId_;
public: public:
ItemData(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "Item", uint8_t value = 0); 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
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_;
}
uint32_t id() const; uint32_t id() const;
void setName(QString name); void setName(QString name);
uint8_t getValue() const; uint8_t getValue() const;
virtual QString getName() const; virtual QString getName() const;
}; };
class Item: public QObject, public ItemData class Item: public QObject, public ItemData
{ {
Q_OBJECT Q_OBJECT
private: private:
std::vector< std::shared_ptr<Actor> > actors_; std::vector< std::shared_ptr<Actor> > actors_;
bool override_ = false; bool override_ = false;
public: public:
static bool secondaryFlag; static bool secondaryFlag;
signals: signals:
void valueChanged(uint8_t value); void valueChanged(uint8_t value);
private slots: private slots:
virtual void actorSetValue(uint8_t value); virtual void actorSetValue(uint8_t value);
public slots: public slots:
virtual void setValue(uint8_t value); virtual void setValue(uint8_t value);
public: 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,
Item(const ItemData& itemData, QObject *parent = nullptr); QObject *parent = nullptr);
Item(const ItemData& itemData, QObject *parent = nullptr);
virtual ~Item(); virtual ~Item();
std::vector< std::shared_ptr<Actor> >& getActors(); std::vector< std::shared_ptr<Actor> >& getActors();
bool hasActors(); bool hasActors();
void addActor(std::shared_ptr<Actor> actor); void addActor(std::shared_ptr<Actor> actor);
bool removeActor(std::shared_ptr<Actor> actor); bool removeActor(std::shared_ptr<Actor> actor);
void removeAllActors(); void removeAllActors();
void setActorsActive(bool in); void setActorsActive(bool in);
void setOverride(const bool in); void setOverride(const bool in);
bool getOverride(); bool getOverride();
void informValue(uint8_t value); void informValue(uint8_t value);
virtual void store(QJsonObject& json); virtual void store(QJsonObject& json);
virtual void load(const QJsonObject& json, const bool preserve = false); virtual void load(const QJsonObject& json, const bool preserve = false);
}; };

168
src/items/itemstore.cpp
View file

@ -10,121 +10,121 @@ ItemStore::ItemStore(QObject *parent): QObject(parent)
void ItemStore::addItem(std::shared_ptr<Item> item) void ItemStore::addItem(std::shared_ptr<Item> item)
{ {
bool mached = false; bool mached = false;
for(unsigned i = 0; i < items_.size(); i++ ) if(*items_[i] == *item) mached = true; for(unsigned i = 0; i < items_.size(); i++ ) if(*items_[i] == *item) mached = true;
if(!mached) if(!mached)
{ {
items_.push_back(std::shared_ptr<Item>(item)); items_.push_back(std::shared_ptr<Item>(item));
itemAdded(std::weak_ptr<Item>(items_.back())); itemAdded(std::weak_ptr<Item>(items_.back()));
} }
} }
void ItemStore::addItems(const std::vector<std::shared_ptr<Item>>& itemIn) void ItemStore::addItems(const std::vector<std::shared_ptr<Item>>& itemIn)
{ {
for(unsigned i = 0; i < items_.size(); i++ ) for(unsigned i = 0; i < items_.size(); i++ )
{ {
if(Relay* relay = dynamic_cast<Relay*>(items_[i].get())) if(Relay* relay = dynamic_cast<Relay*>(items_[i].get()))
{ {
bool mached = false; bool mached = false;
for(unsigned j = 0; j < itemIn.size(); j++) if(*(items_[i]) == *(itemIn[j])) for(unsigned j = 0; j < itemIn.size(); j++) if(*(items_[i]) == *(itemIn[j]))
{ {
mached = true; mached = true;
if(itemIn[j]->getValue() != items_[i]->getValue()) items_[i]->informValue(itemIn[j]->getValue()); if(itemIn[j]->getValue() != items_[i]->getValue()) items_[i]->informValue(itemIn[j]->getValue());
Relay* relayIn = dynamic_cast<Relay*>(itemIn[j].get()); Relay* relayIn = dynamic_cast<Relay*>(itemIn[j].get());
if(relayIn) if(relayIn)
{ {
if(relay->getId() != relayIn->getId()) relay->setId(relayIn->getId()); if(relay->getId() != relayIn->getId()) relay->setId(relayIn->getId());
} }
} }
if(!mached) if(!mached)
{ {
itemDeleted(*items_[i].get()); itemDeleted(*items_[i].get());
items_.erase(items_.begin()+i); 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]);
} }
void ItemStore::removeItem(const ItemData& item) void ItemStore::removeItem(const ItemData& item)
{ {
for(unsigned j = 0; j < items_.size(); j++) for(unsigned j = 0; j < items_.size(); j++)
{ {
if(item == *items_[j]) if(item == *items_[j])
{ {
items_.erase(items_.begin()+j); items_.erase(items_.begin()+j);
--j; --j;
} }
} }
} }
void ItemStore::clear() void ItemStore::clear()
{ {
for(size_t i = 0; i < items_.size(); ++i) itemDeleted(*items_[i]); for(size_t i = 0; i < items_.size(); ++i) itemDeleted(*items_[i]);
items_.clear(); items_.clear();
} }
void ItemStore::itemStateChanged(const ItemData& item) void ItemStore::itemStateChanged(const ItemData& item)
{ {
for(unsigned i = 0; i < items_.size(); i++ ) for(unsigned i = 0; i < items_.size(); i++ )
{ {
if(items_[i]->operator==(item)) if(items_[i]->operator==(item))
{ {
if(items_[i]->getValue() != item.getValue())items_[i]->informValue(item.getValue()); if(items_[i]->getValue() != item.getValue())items_[i]->informValue(item.getValue());
} }
} }
} }
void ItemStore::store(QJsonObject& json) void ItemStore::store(QJsonObject& json)
{ {
QJsonArray itemsArray; QJsonArray itemsArray;
for(size_t i = 0; i < items_.size(); ++i) for(size_t i = 0; i < items_.size(); ++i)
{ {
QJsonObject itemObject; QJsonObject itemObject;
items_[i]->store(itemObject); items_[i]->store(itemObject);
itemsArray.append(itemObject); itemsArray.append(itemObject);
} }
json["Items"] = itemsArray; json["Items"] = itemsArray;
} }
void ItemStore::load(const QJsonObject& json) void ItemStore::load(const QJsonObject& json)
{ {
const QJsonArray itemsArray(json["Items"].toArray(QJsonArray())); const QJsonArray itemsArray(json["Items"].toArray(QJsonArray()));
for(int i = 0; i < itemsArray.size(); ++i) for(int i = 0; i < itemsArray.size(); ++i)
{ {
if(itemsArray[i].isObject()) if(itemsArray[i].isObject())
{ {
const QJsonObject itemObject = itemsArray[i].toObject(); const QJsonObject itemObject = itemsArray[i].toObject();
std::shared_ptr<Item> newItem; std::shared_ptr<Item> newItem;
if(itemObject["Type"].toString("") == "Relay") if(itemObject["Type"].toString("") == "Relay")
{ {
newItem = std::shared_ptr<Relay>(new Relay()); newItem = std::shared_ptr<Relay>(new Relay());
} }
else if(itemObject["Type"].toString("") == "Message") else if(itemObject["Type"].toString("") == "Message")
{ {
newItem = std::shared_ptr<MessageItem>(new MessageItem); newItem = std::shared_ptr<MessageItem>(new MessageItem);
} }
else if(itemObject["Type"].toString("") == "System") else if(itemObject["Type"].toString("") == "System")
{ {
newItem = std::shared_ptr<SystemItem>(new SystemItem()); newItem = std::shared_ptr<SystemItem>(new SystemItem());
} }
else if(itemObject["Type"].toString("") == "Aux") else if(itemObject["Type"].toString("") == "Aux")
{ {
} }
if(newItem) if(newItem)
{ {
newItem->load(itemObject); newItem->load(itemObject);
addItem(newItem); addItem(newItem);
} }
} }
} }
} }

31
src/items/itemstore.h
View file

@ -8,31 +8,34 @@
class ItemStore: public QObject class ItemStore: public QObject
{ {
Q_OBJECT Q_OBJECT
private: private:
std::vector< std::shared_ptr<Item> > items_; std::vector< std::shared_ptr<Item> > items_;
public: public:
ItemStore(QObject *parent = nullptr); 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_;
}
void store(QJsonObject &json); void store(QJsonObject &json);
void load(const QJsonObject &json); void load(const QJsonObject &json);
void clear(); void clear();
signals: signals:
void itemDeleted(ItemData item); void itemDeleted(ItemData item);
void itemAdded(std::weak_ptr<Item> Item); void itemAdded(std::weak_ptr<Item> Item);
public slots: public slots:
void removeItem(const ItemData& item); void removeItem(const ItemData& item);
void addItem(std::shared_ptr<Item> item); void addItem(std::shared_ptr<Item> item);
void addItems(const std::vector<std::shared_ptr<Item>>& itemsIn); void addItems(const std::vector<std::shared_ptr<Item>>& itemsIn);
void itemStateChanged(const ItemData& item); void itemStateChanged(const ItemData& item);
}; };

70
src/items/messageitem.cpp
View file

@ -6,83 +6,83 @@
BroadCast* MessageItem::broadCast = nullptr; BroadCast* MessageItem::broadCast = nullptr;
MessageItem::MessageItem(uint32_t itemIdIn, QString name, uint8_t value, QObject *parent): MessageItem::MessageItem(uint32_t itemIdIn, QString name, uint8_t value, QObject *parent):
Item(itemIdIn, name, value, parent) Item(itemIdIn, name, value, parent)
{ {
} }
MessageItem::MessageItem(const ItemData& itemData, QObject *parent): MessageItem::MessageItem(const ItemData& itemData, QObject *parent):
Item(itemData, parent) Item(itemData, parent)
{ {
} }
MessageItem::~MessageItem() MessageItem::~MessageItem()
{ {
closeMessageBox(); closeMessageBox();
} }
void MessageItem::setValue(uint8_t value) void MessageItem::setValue(uint8_t value)
{ {
Item::setValue(value); Item::setValue(value);
if(value && !messageBox_) if(value && !messageBox_)
{ {
if(broadCast) broadCast->sendMessage(name_, message_); if(broadCast) broadCast->sendMessage(name_, message_);
if(!alertSoundFileName.isEmpty()) QSound::play(alertSoundFileName); if(!alertSoundFileName.isEmpty()) QSound::play(alertSoundFileName);
messageBox_ = new QMessageBox(QMessageBox::NoIcon, name_, message_); messageBox_ = new QMessageBox(QMessageBox::NoIcon, name_, message_);
messageBox_->setModal(false); messageBox_->setModal(false);
connect(messageBox_, &QMessageBox::finished, this, &MessageItem::closeMessageBox); connect(messageBox_, &QMessageBox::finished, this, &MessageItem::closeMessageBox);
messageBox_->show(); messageBox_->show();
} }
else if(!value && messageBox_) else if(!value && messageBox_)
{ {
closeMessageBox(); closeMessageBox();
} }
} }
void MessageItem::closeMessageBox() void MessageItem::closeMessageBox()
{ {
if(messageBox_) if(messageBox_)
{ {
value_ = 0; value_ = 0;
messageBox_->hide(); messageBox_->hide();
delete messageBox_; delete messageBox_;
messageBox_ = nullptr; messageBox_ = nullptr;
} }
} }
QString MessageItem::getAlert() QString MessageItem::getAlert()
{ {
return alertSoundFileName; return alertSoundFileName;
} }
void MessageItem::setAlert(const QString &in) void MessageItem::setAlert(const QString &in)
{ {
alertSoundFileName = in; alertSoundFileName = in;
} }
void MessageItem::setMessage(const QString& in) void MessageItem::setMessage(const QString& in)
{ {
message_ = in; message_ = in;
} }
QString MessageItem::getMessage() QString MessageItem::getMessage()
{ {
return message_; return message_;
} }
void MessageItem::store(QJsonObject &json) void MessageItem::store(QJsonObject &json)
{ {
json["Type"] = "Message"; json["Type"] = "Message";
Item::store(json); Item::store(json);
json["Message"] = message_; json["Message"] = message_;
if(!alertSoundFileName.isEmpty()) json["Alert"] = alertSoundFileName; if(!alertSoundFileName.isEmpty()) json["Alert"] = alertSoundFileName;
} }
void MessageItem::load(const QJsonObject &json, const bool preserve) void MessageItem::load(const QJsonObject &json, const bool preserve)
{ {
Item::load(json,preserve); Item::load(json,preserve);
message_ = json["Message"].toString("Invalid Message"); message_ = json["Message"].toString("Invalid Message");
alertSoundFileName = json["Alert"].toString(""); alertSoundFileName = json["Alert"].toString("");
} }

33
src/items/messageitem.h
View file

@ -8,37 +8,38 @@
class MessageItem : public Item class MessageItem : public Item
{ {
Q_OBJECT Q_OBJECT
private: private:
QString message_; QString message_;
QMessageBox* messageBox_ = nullptr; QMessageBox* messageBox_ = nullptr;
QString alertSoundFileName = ""; QString alertSoundFileName = "";
public: public:
static BroadCast* broadCast; static BroadCast* broadCast;
private slots: private slots:
void closeMessageBox(); void closeMessageBox();
public: public:
virtual void setValue(uint8_t value); virtual void setValue(uint8_t value);
public: 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,
MessageItem(const ItemData& itemData, QObject *parent = nullptr); QObject *parent = nullptr);
~MessageItem(); MessageItem(const ItemData& itemData, QObject *parent = nullptr);
~MessageItem();
void setMessage(const QString& in); void setMessage(const QString& in);
QString getMessage(); QString getMessage();
void setAlert(const QString& in); void setAlert(const QString& in);
QString getAlert(); QString getAlert();
virtual void store(QJsonObject& json); virtual void store(QJsonObject& json);
virtual void load(const QJsonObject& json, const bool preserve = false); virtual void load(const QJsonObject& json, const bool preserve = false);
}; };
#endif // MESSAGEITEM_H #endif // MESSAGEITEM_H

29
src/items/poweritem.cpp
View file

@ -3,31 +3,32 @@
#include <QApplication> #include <QApplication>
#include <QDebug> #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)); stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 0, "Shutdown Imminent", true));
setValue(true); setValue(true);
} }
void PowerItem::setValue(uint8_t value) void PowerItem::setValue(uint8_t value)
{ {
qDebug()<<"shutdown"; qDebug()<<"shutdown";
Item::setValue(value); Item::setValue(value);
if(!value) if(!value)
{ {
QTimer::singleShot(5000, this, &PowerItem::timeout); QTimer::singleShot(5000, this, &PowerItem::timeout);
stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 1, "Shutdown Imminent", true)); stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 1, "Shutdown Imminent", true));
} }
} }
void PowerItem::timeout() void PowerItem::timeout()
{ {
qDebug()<<"shutdown timeout"; qDebug()<<"shutdown timeout";
QProcess::startDetached("syncoff"); QProcess::startDetached("syncoff");
} }
void PowerItem::store(QJsonObject& json) void PowerItem::store(QJsonObject& json)
{ {
json["Type"] = "Power"; json["Type"] = "Power";
Item::store(json); Item::store(json);
} }

18
src/items/poweritem.h
View file

@ -8,23 +8,27 @@
class PowerItem: public Item class PowerItem: public Item
{ {
Q_OBJECT Q_OBJECT
private: private:
signals: signals:
void stateChanged(Sensor sensor); void stateChanged(Sensor sensor);
private slots: private slots:
void timeout(); void timeout();
public slots: public slots:
virtual void setValue(uint8_t value); virtual void setValue(uint8_t value);
public: public:
PowerItem(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "", uint8_t value = 0, QObject* parent = nullptr); PowerItem(uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "", uint8_t value = 0,
void emmitSensor(){stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 0, "Shutdown Imminent", true));} QObject* parent = nullptr);
virtual void store(QJsonObject& json); void emmitSensor()
{
stateChanged(Sensor(Sensor::TYPE_SHUTDOWN_IMMINENT, 0, 0, "Shutdown Imminent", true));
}
virtual void store(QJsonObject& json);
}; };

49
src/items/relay.cpp
View file

@ -5,66 +5,67 @@
Microcontroller* Relay::micro_ = nullptr; 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); itemId_ = address | ((uint32_t)id << 16);
qDebug()<<"Relay "<<id_<<"Name "<<name<<" id "<<itemId_<<" state "<<state<<" addr: "<<address; qDebug()<<"Relay "<<id_<<"Name "<<name<<" id "<<itemId_<<" state "<<state<<" addr: "<<address;
} }
void Relay::setValue(uint8_t value) void Relay::setValue(uint8_t value)
{ {
Item::setValue(value); Item::setValue(value);
if(micro_) if(micro_)
{ {
if(value)micro_->relayOn(id_); if(value)micro_->relayOn(id_);
else micro_->relayOff(id_); else micro_->relayOff(id_);
} }
} }
void Relay::on() void Relay::on()
{ {
setValue(true); setValue(true);
} }
void Relay::off() void Relay::off()
{ {
setValue(false); setValue(false);
} }
void Relay::toggle() void Relay::toggle()
{ {
value_ ? off() : on(); value_ ? off() : on();
} }
void Relay::store(QJsonObject& json) void Relay::store(QJsonObject& json)
{ {
json["Type"] = "Relay"; json["Type"] = "Relay";
Item::store(json); Item::store(json);
json["Id"] = static_cast<double>(id_); json["Id"] = static_cast<double>(id_);
json["Address"] = address_; json["Address"] = address_;
} }
void Relay::load(const QJsonObject& json, const bool preserve) void Relay::load(const QJsonObject& json, const bool preserve)
{ {
Item::load(json, preserve); Item::load(json, preserve);
id_ = static_cast<uint8_t>(json["Id"].toInt(0)); id_ = static_cast<uint8_t>(json["Id"].toInt(0));
address_ = static_cast<uint16_t>(json["Address"].toInt(0)); address_ = static_cast<uint16_t>(json["Address"].toInt(0));
itemId_ = address_ | (static_cast<uint32_t>(id_) << 16); itemId_ = address_ | (static_cast<uint32_t>(id_) << 16);
} }
uint16_t Relay::getAddress() const uint16_t Relay::getAddress() const
{ {
return address_; return address_;
} }
uint8_t Relay::getId() const uint8_t Relay::getId() const
{ {
return id_; return id_;
} }
void Relay::setId(uint8_t id) void Relay::setId(uint8_t id)
{ {
id_=id; id_=id;
itemId_ = address_ | ((uint32_t)id << 16); itemId_ = address_ | ((uint32_t)id << 16);
} }

33
src/items/relay.h
View file

@ -11,30 +11,33 @@ class Microcontroller;
class Relay : public Item class Relay : public Item
{ {
Q_OBJECT Q_OBJECT
private: private:
static Microcontroller* micro_; static Microcontroller* micro_;
uint8_t id_; uint8_t id_;
uint16_t address_; uint16_t address_;
public slots: public slots:
virtual void setValue(uint8_t value); virtual void setValue(uint8_t value);
void on(); void on();
void off(); void off();
void toggle(); void toggle();
public: public:
Relay(uint8_t id = 0, QString name = "", uint16_t address = 0, bool state = false, QObject* parent = nullptr); Relay(uint8_t id = 0, QString name = "", uint16_t address = 0, bool state = false, QObject* parent = nullptr);
uint16_t getAddress() const; uint16_t getAddress() const;
uint8_t getId() const; uint8_t getId() const;
void setId(uint8_t id); 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 store(QJsonObject& json);
virtual void load(const QJsonObject& json, const bool preserve = false); virtual void load(const QJsonObject& json, const bool preserve = false);
}; };
#endif // RELAY_H #endif // RELAY_H

11
src/items/rgbitem.cpp
View file

@ -1,18 +1,19 @@
#include "rgbitem.h" #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::setValue(uint8_t value)
{ {
Item::setValue(value); Item::setValue(value);
value ? micro_->rgbOn() : micro_->rgbOff(); value ? micro_->rgbOn() : micro_->rgbOff();
} }
void RgbItem::store(QJsonObject &json) void RgbItem::store(QJsonObject &json)
{ {
json["Type"] = "Rgb"; json["Type"] = "Rgb";
Item::store(json); Item::store(json);
} }

11
src/items/rgbitem.h
View file

@ -5,16 +5,17 @@
class RgbItem: public Item class RgbItem: public Item
{ {
Q_OBJECT Q_OBJECT
private: private:
Microcontroller* micro_; Microcontroller* micro_;
public slots: public slots:
virtual void setValue(uint8_t value); virtual void setValue(uint8_t value);
public: public:
RgbItem(Microcontroller* micro, uint32_t itemIdIn = QRandomGenerator::global()->generate(), QString name = "", uint8_t value = 0, QObject* parent = nullptr); 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);
}; };

24
src/items/systemitem.cpp
View file

@ -3,41 +3,41 @@
void SystemItem::setValue(uint8_t value) void SystemItem::setValue(uint8_t value)
{ {
QProcess::execute(value ? onCommand_ : offCommand_); QProcess::execute(value ? onCommand_ : offCommand_);
} }
SystemItem::SystemItem(uint32_t itemIdIn, QString name, uint8_t value, QObject *parent): 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): SystemItem::SystemItem(const ItemData& itemData, QObject *parent):
Item(itemData, parent) Item(itemData, parent)
{ {
} }
void SystemItem::setOnCommand(const QString& in) void SystemItem::setOnCommand(const QString& in)
{ {
onCommand_ = in; onCommand_ = in;
} }
void SystemItem::setOffCommand(const QString& in) void SystemItem::setOffCommand(const QString& in)
{ {
offCommand_ = in; offCommand_ = in;
} }
void SystemItem::store(QJsonObject& json) void SystemItem::store(QJsonObject& json)
{ {
json["Type"] = "System"; json["Type"] = "System";
Item::store(json); Item::store(json);
json["OnCommand"] = onCommand_; json["OnCommand"] = onCommand_;
json["OffCommand"] = offCommand_; json["OffCommand"] = offCommand_;
} }
void SystemItem::load(const QJsonObject& json, const bool preserve) void SystemItem::load(const QJsonObject& json, const bool preserve)
{ {
Item::load(json,preserve); Item::load(json,preserve);
onCommand_ = json["OnCommand"].toString(""); onCommand_ = json["OnCommand"].toString("");
offCommand_ = json["OffCommand"].toString(""); offCommand_ = json["OffCommand"].toString("");
} }

33
src/items/systemitem.h
View file

@ -6,29 +6,36 @@
class SystemItem : public Item class SystemItem : public Item
{ {
Q_OBJECT Q_OBJECT
private: private:
QString onCommand_; QString onCommand_;
QString offCommand_; QString offCommand_;
public: public:
virtual void setValue(uint8_t value); virtual void setValue(uint8_t value);
public: 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,
SystemItem(const ItemData& itemData, QObject *parent = nullptr); QObject *parent = nullptr);
~SystemItem() = default; SystemItem(const ItemData& itemData, QObject *parent = nullptr);
~SystemItem() = default;
void setOnCommand(const QString& in); void setOnCommand(const QString& in);
void setOffCommand(const QString& in); void setOffCommand(const QString& in);
QString getOnCommand(){return onCommand_;} QString getOnCommand()
QString getOffCommand(){return offCommand_;} {
return onCommand_;
}
QString getOffCommand()
{
return offCommand_;
}
virtual void store(QJsonObject& json); virtual void store(QJsonObject& json);
virtual void load(const QJsonObject& json, const bool preserve = false); virtual void load(const QJsonObject& json, const bool preserve = false);
}; };
#endif // SYSTEMITEM_H #endif // SYSTEMITEM_H

166
src/main.cpp
View file

@ -30,104 +30,112 @@
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
QApplication a(argc, argv); QApplication a(argc, argv);
//set info //set info
QCoreApplication::setOrganizationName("UVOS"); QCoreApplication::setOrganizationName("UVOS");
QCoreApplication::setOrganizationDomain("uvos.xyz"); QCoreApplication::setOrganizationDomain("uvos.xyz");
QCoreApplication::setApplicationName("SHinterface"); QCoreApplication::setApplicationName("SHinterface");
QCoreApplication::setApplicationVersion("0.6"); QCoreApplication::setApplicationVersion("0.6");
QDir::setCurrent(a.applicationDirPath()); QDir::setCurrent(a.applicationDirPath());
//parse comand line //parse comand line
#ifndef Q_OS_ANDROID #ifndef Q_OS_ANDROID
QCommandLineParser parser; QCommandLineParser parser;
parser.setApplicationDescription("Smart Home Interface"); parser.setApplicationDescription("Smart Home Interface");
parser.addHelpOption(); parser.addHelpOption();
parser.addVersionOption(); parser.addVersionOption();
QCommandLineOption tcpOption(QStringList() << "t" << "tcp", QCoreApplication::translate("main", "Use Tcp connection")); QCommandLineOption tcpOption(QStringList() << "t" << "tcp", QCoreApplication::translate("main", "Use Tcp connection"));
parser.addOption(tcpOption); parser.addOption(tcpOption);
QCommandLineOption hostOption(QStringList() << "H" << "host", QCoreApplication::translate("main", "Set server host ip addres"), "adress"); QCommandLineOption hostOption(QStringList() << "H" << "host", QCoreApplication::translate("main",
parser.addOption(hostOption); "Set server host ip addres"), "adress");
QCommandLineOption portOption(QStringList() << "p" << "port", QCoreApplication::translate("main", "Set server Port in TCP mode or Serial port in serial mode"), "port"); parser.addOption(hostOption);
parser.addOption(portOption); QCommandLineOption portOption(QStringList() << "p" << "port", QCoreApplication::translate("main",
QCommandLineOption serialOption(QStringList() << "s" << "serial", QCoreApplication::translate("main", "Use serial connection")); "Set server Port in TCP mode or Serial port in serial mode"), "port");
parser.addOption(serialOption); parser.addOption(portOption);
QCommandLineOption baudOption(QStringList() << "b" << "baud", QCoreApplication::translate("main", "Set Baud Rate")); QCommandLineOption serialOption(QStringList() << "s" << "serial", QCoreApplication::translate("main",
parser.addOption(baudOption); "Use serial connection"));
QCommandLineOption settingsPathOption(QStringList() << "c" << "config", QCoreApplication::translate("main", "Set config file"), "configFilePath"); parser.addOption(serialOption);
parser.addOption(settingsPathOption); QCommandLineOption baudOption(QStringList() << "b" << "baud", QCoreApplication::translate("main", "Set Baud Rate"));
QCommandLineOption secondaryOption(QStringList() << "e" << "secondary", QCoreApplication::translate("main", "Set if instance is not main instance")); parser.addOption(baudOption);
parser.addOption(secondaryOption); QCommandLineOption settingsPathOption(QStringList() << "c" << "config", QCoreApplication::translate("main",
parser.process(a); "Set config file"), "configFilePath");
#endif parser.addOption(settingsPathOption);
QCommandLineOption secondaryOption(QStringList() << "e" << "secondary", QCoreApplication::translate("main",
"Set if instance is not main instance"));
parser.addOption(secondaryOption);
parser.process(a);
#endif
QIODevice* masterIODevice = nullptr; QIODevice* masterIODevice = nullptr;
#ifndef Q_OS_ANDROID #ifndef Q_OS_ANDROID
if(parser.isSet(tcpOption)) if(parser.isSet(tcpOption))
{ {
QTcpSocket* microSocket = new QTcpSocket; QTcpSocket* microSocket = new QTcpSocket;
int port = 6856; int port = 6856;
if(parser.isSet(portOption)) port = parser.value(portOption).toInt(); if(parser.isSet(portOption)) port = parser.value(portOption).toInt();
QString host("127.0.0.1"); QString host("127.0.0.1");
if(parser.isSet(hostOption)) host = parser.value(hostOption); if(parser.isSet(hostOption)) host = parser.value(hostOption);
std::cout<<"connecting to "<<host.toStdString()<<':'<<port<<'\n'; std::cout<<"connecting to "<<host.toStdString()<<':'<<port<<'\n';
microSocket->connectToHost(host, port, QIODevice::ReadWrite); microSocket->connectToHost(host, port, QIODevice::ReadWrite);
if(!microSocket->waitForConnected(1000)) if(!microSocket->waitForConnected(1000))
{ {
std::cout<<"Can not connect to to Server.\n"; std::cout<<"Can not connect to to Server.\n";
QMessageBox::critical(nullptr, "Error", "Can not connect to to Server"); QMessageBox::critical(nullptr, "Error", "Can not connect to to Server");
return 1; return 1;
} }
masterIODevice = microSocket; masterIODevice = microSocket;
} }
else else
{ {
QSerialPort* microPort = new QSerialPort; QSerialPort* microPort = new QSerialPort;
if(parser.isSet(portOption)) microPort->setPortName(parser.value(portOption)); if(parser.isSet(portOption)) microPort->setPortName(parser.value(portOption));
else microPort->setPortName("ttyUSB0"); else microPort->setPortName("ttyUSB0");
if(parser.isSet(portOption)) microPort->setBaudRate(parser.value(baudOption).toInt()); if(parser.isSet(portOption)) microPort->setBaudRate(parser.value(baudOption).toInt());
else microPort->setBaudRate(BAUD); else microPort->setBaudRate(BAUD);
if(!microPort->open(QIODevice::ReadWrite)) std::cout<<"Can not open serial port "<<microPort->portName().toStdString()<<". Continueing in demo mode"<<'\n'; if(!microPort->open(QIODevice::ReadWrite)) std::cout<<"Can not open serial port "<<microPort->portName().toStdString()
masterIODevice = microPort; <<". Continueing in demo mode"<<'\n';
} masterIODevice = microPort;
}
MainObject mainObject(masterIODevice, parser.isSet(settingsPathOption) ? parser.value(settingsPathOption) : "", !parser.isSet(secondaryOption)); MainObject mainObject(masterIODevice, parser.isSet(settingsPathOption) ? parser.value(settingsPathOption) : "",
!parser.isSet(secondaryOption));
#else #else
QTcpSocket* microSocket = new QTcpSocket; QTcpSocket* microSocket = new QTcpSocket;
microSocket->connectToHost("10.0.0.1", 6856, QIODevice::ReadWrite); microSocket->connectToHost("10.0.0.1", 6856, QIODevice::ReadWrite);
if(!microSocket->waitForConnected(1000)) if(!microSocket->waitForConnected(1000))
{ {
std::cout<<"Can not connect to to Server.\n"; std::cout<<"Can not connect to to Server.\n";
return 1; return 1;
} }
masterIODevice = microSocket; masterIODevice = microSocket;
MainObject mainObject(masterIODevice, parser.isSet(settingsPathOption) ? parser.value(settingsPathOption) : "", !parser.isSet(secondaryOption)); MainObject mainObject(masterIODevice, parser.isSet(settingsPathOption) ? parser.value(settingsPathOption) : "",
#endif !parser.isSet(secondaryOption));
#endif
//mainwindow //mainwindow
MainWindow w(&mainObject); MainWindow w(&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::sigBrodcast, &mainObject, &MainObject::sendJson); QObject::connect(&w, &MainWindow::sigBrodcast, &mainObject, &MainObject::sendJson);
QObject::connect(&w, &MainWindow::sigSave, &mainObject, &MainObject::storeToDisk); QObject::connect(&w, &MainWindow::sigSave, &mainObject, &MainObject::storeToDisk);
QObject::connect(&w, &MainWindow::createdItem, &mainObject.items, &ItemStore::addItem); QObject::connect(&w, &MainWindow::createdItem, &mainObject.items, &ItemStore::addItem);
if(!mainObject.micro.connected()) w.changeHeaderLableText("No io debug only!"); if(!mainObject.micro.connected()) w.changeHeaderLableText("No io debug only!");
w.show(); w.show();
int retVal = a.exec(); int retVal = a.exec();
if(masterIODevice) if(masterIODevice)
delete masterIODevice; delete masterIODevice;
return retVal; return retVal;
} }

226
src/mainobject.cpp
View file

@ -2,56 +2,56 @@
#include "items/messageitem.h" #include "items/messageitem.h"
MainObject::MainObject(QIODevice* ioDevice, const QString& settingsPathIn, const bool masterIn, QObject *parent) : MainObject::MainObject(QIODevice* ioDevice, const QString& settingsPathIn, const bool masterIn, QObject *parent) :
QObject(parent), QObject(parent),
master(masterIn), master(masterIn),
masterIODevice(ioDevice), masterIODevice(ioDevice),
ioMultiplexer(masterIODevice), ioMultiplexer(masterIODevice),
micro(ioMultiplexer.getIoDevice()), micro(ioMultiplexer.getIoDevice()),
broadCast(ioMultiplexer.getIoDevice(), masterIn), broadCast(ioMultiplexer.getIoDevice(), masterIn),
settingsPath(settingsPathIn), settingsPath(settingsPathIn),
sunSensorSource(49.884450, 8.650536), sunSensorSource(49.884450, 8.650536),
powerItem(new PowerItem), powerItem(new PowerItem),
rgbItem(new RgbItem(&micro, 5487422, "Rgb Lights")), rgbItem(new RgbItem(&micro, 5487422, "Rgb Lights")),
auxItem(new AuxItem(&micro, 5487421, "Desk Light")) auxItem(new AuxItem(&micro, 5487421, "Desk Light"))
{ {
qDebug()<<"Is master:"<<master; qDebug()<<"Is master:"<<master;
//connect sensors subsystem //connect sensors subsystem
QObject::connect(&micro, &Microcontroller::gotSensorState, &globalSensors, &SensorStore::sensorGotState); QObject::connect(&micro, &Microcontroller::gotSensorState, &globalSensors, &SensorStore::sensorGotState);
QObject::connect(&sunSensorSource, &SunSensorSource::stateChanged, &globalSensors, &SensorStore::sensorGotState); QObject::connect(&sunSensorSource, &SunSensorSource::stateChanged, &globalSensors, &SensorStore::sensorGotState);
QObject::connect(&globalSensors, &SensorStore::sensorChangedState, &ocupancySensor, &OcupancySensorSource::sensorEvent); QObject::connect(&globalSensors, &SensorStore::sensorChangedState, &ocupancySensor, &OcupancySensorSource::sensorEvent);
QObject::connect(&ocupancySensor, &OcupancySensorSource::stateChanged, &globalSensors, &SensorStore::sensorGotState); QObject::connect(&ocupancySensor, &OcupancySensorSource::stateChanged, &globalSensors, &SensorStore::sensorGotState);
sunSensorSource.run(); sunSensorSource.run();
//connect item store //connect item store
QObject::connect(&micro, &Microcontroller::gotRelayList, &items, &ItemStore::addItems); QObject::connect(&micro, &Microcontroller::gotRelayList, &items, &ItemStore::addItems);
QObject::connect(&micro, &Microcontroller::itemChanged, &items, &ItemStore::itemStateChanged); QObject::connect(&micro, &Microcontroller::itemChanged, &items, &ItemStore::itemStateChanged);
//special items //special items
QObject::connect(powerItem.get(), &PowerItem::stateChanged, &globalSensors, &SensorStore::sensorGotState); QObject::connect(powerItem.get(), &PowerItem::stateChanged, &globalSensors, &SensorStore::sensorGotState);
powerItem->emmitSensor(); powerItem->emmitSensor();
items.addItem(rgbItem); items.addItem(rgbItem);
items.addItem(auxItem); items.addItem(auxItem);
MessageItem::broadCast = &broadCast; MessageItem::broadCast = &broadCast;
Relay::setMicrocontroller(&micro); Relay::setMicrocontroller(&micro);
connect(&broadCast, &BroadCast::gotJson, this, &MainObject::recivedJson); connect(&broadCast, &BroadCast::gotJson, this, &MainObject::recivedJson);
QObject::connect(&broadCast, &BroadCast::gotSensorState, &globalSensors, &SensorStore::sensorGotState); QObject::connect(&broadCast, &BroadCast::gotSensorState, &globalSensors, &SensorStore::sensorGotState);
if(master)connect(&broadCast, &BroadCast::jsonRequested, this, &MainObject::sendJson); if(master)connect(&broadCast, &BroadCast::jsonRequested, this, &MainObject::sendJson);
if(master) load(getJsonObjectFromDisk(settingsPath, &noSave)); if(master) load(getJsonObjectFromDisk(settingsPath, &noSave));
else else
{ {
broadCast.requestJson(); broadCast.requestJson();
broadCast.requestSensors(); broadCast.requestSensors();
} }
#ifndef Q_OS_ANDROID #ifndef Q_OS_ANDROID
Item::secondaryFlag = !master; Item::secondaryFlag = !master;
#endif #endif
} }
MainObject::~MainObject() MainObject::~MainObject()
@ -60,36 +60,36 @@ MainObject::~MainObject()
void MainObject::store(QJsonObject &json) void MainObject::store(QJsonObject &json)
{ {
items.store(json); items.store(json);
QJsonObject powerObject; QJsonObject powerObject;
powerItem->store(powerObject); powerItem->store(powerObject);
json.insert("Power", powerObject); json.insert("Power", powerObject);
QJsonDocument pwrDoc(powerObject); QJsonDocument pwrDoc(powerObject);
QJsonObject ocupancyObject; QJsonObject ocupancyObject;
ocupancySensor.store(ocupancyObject); ocupancySensor.store(ocupancyObject);
json.insert("Ocupancy", ocupancyObject); json.insert("Ocupancy", ocupancyObject);
} }
void MainObject::load(const QJsonObject& json) void MainObject::load(const QJsonObject& json)
{ {
items.clear(); items.clear();
rgbItem->removeAllActors(); rgbItem->removeAllActors();
auxItem->removeAllActors(); auxItem->removeAllActors();
powerItem->removeAllActors(); powerItem->removeAllActors();
items.addItem(rgbItem); items.addItem(rgbItem);
items.addItem(auxItem); items.addItem(auxItem);
items.load(json); items.load(json);
powerItem->load(json["Power"].toObject()); powerItem->load(json["Power"].toObject());
ocupancySensor.load(json["Ocupancy"].toObject()); ocupancySensor.load(json["Ocupancy"].toObject());
qDebug()<<"aray size: "<<json.isEmpty(); qDebug()<<"aray size: "<<json.isEmpty();
if(json["Items"].toArray().size() >= 2) if(json["Items"].toArray().size() >= 2)
{ {
rgbItem->load(json["Items"].toArray()[0].toObject()); rgbItem->load(json["Items"].toArray()[0].toObject());
auxItem->load(json["Items"].toArray()[1].toObject()); auxItem->load(json["Items"].toArray()[1].toObject());
} }
micro.requestState(); micro.requestState();
} }
void MainObject::storeToDisk() void MainObject::storeToDisk()
@ -106,70 +106,70 @@ void MainObject::recivedJson(const QJsonObject json)
{ {
if(master && !noSave) if(master && !noSave)
storeJsonObjectToDisk(json, settingsPath); storeJsonObjectToDisk(json, settingsPath);
load(json); load(json);
} }
void MainObject::sendJson() void MainObject::sendJson()
{ {
QJsonObject json; QJsonObject json;
store(json); store(json);
broadCast.sendJson(json); broadCast.sendJson(json);
} }
QJsonObject MainObject::getJsonObjectFromDisk(const QString& filePath, bool* error) QJsonObject MainObject::getJsonObjectFromDisk(const QString& filePath, bool* error)
{ {
QFile file; QFile file;
#ifndef Q_OS_ANDROID #ifndef Q_OS_ANDROID
if(filePath.size() > 0) file.setFileName(filePath); if(filePath.size() > 0) file.setFileName(filePath);
else else
#endif #endif
{ {
file.setFileName(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json"); file.setFileName(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json");
} }
file.open(QIODevice::ReadOnly); file.open(QIODevice::ReadOnly);
if(!file.isOpen()) std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl; if(!file.isOpen()) std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
else else
{ {
QJsonParseError qerror; QJsonParseError qerror;
QJsonDocument document(QJsonDocument::fromJson(file.readAll(), &qerror)); QJsonDocument document(QJsonDocument::fromJson(file.readAll(), &qerror));
file.close(); file.close();
if(qerror.error != QJsonParseError::NoError) if(qerror.error != QJsonParseError::NoError)
{ {
qDebug()<<filePath<<" "<<qerror.errorString(); qDebug()<<filePath<<" "<<qerror.errorString();
if(error) (*error) = true; if(error) (*error) = true;
} }
return document.object(); return document.object();
} }
return QJsonObject(); return QJsonObject();
} }
bool MainObject::storeJsonObjectToDisk(const QJsonObject& json, QString filePath) bool MainObject::storeJsonObjectToDisk(const QJsonObject& json, QString filePath)
{ {
#ifndef Q_OS_ANDROID #ifndef Q_OS_ANDROID
if(filePath.size() == 0) if(filePath.size() == 0)
#endif #endif
{ {
filePath = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json"; filePath = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/shinterface.json";
} }
QFile file(filePath + ".out"); QFile file(filePath + ".out");
qDebug()<<"config file: "<<filePath; qDebug()<<"config file: "<<filePath;
file.open(QIODevice::WriteOnly); file.open(QIODevice::WriteOnly);
if(!file.isOpen()) if(!file.isOpen())
{ {
std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl; std::cerr<<"Can not open config file: "<<filePath.toLatin1().data()<<std::endl;
return false; return false;
} }
else else
{ {
QJsonDocument document(json); QJsonDocument document(json);
file.write(document.toJson()); file.write(document.toJson());
file.close(); file.close();
QFile::remove(filePath); QFile::remove(filePath);
file.rename(filePath); file.rename(filePath);
return true; return true;
} }
} }

50
src/mainobject.h
View file

@ -35,53 +35,53 @@
class MainObject : public QObject class MainObject : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
//io //io
const bool master; const bool master;
bool noSave = false; bool noSave = false;
QIODevice * const masterIODevice = nullptr; QIODevice * const masterIODevice = nullptr;
IoMuliplexer ioMultiplexer; IoMuliplexer ioMultiplexer;
Microcontroller micro; Microcontroller micro;
BroadCast broadCast; BroadCast broadCast;
const QString settingsPath; const QString settingsPath;
//sensors //sensors
SunSensorSource sunSensorSource; SunSensorSource sunSensorSource;
OcupancySensorSource ocupancySensor; OcupancySensorSource ocupancySensor;
//items //items
ItemStore items; ItemStore items;
std::shared_ptr<PowerItem> powerItem; std::shared_ptr<PowerItem> powerItem;
std::shared_ptr<RgbItem> rgbItem; std::shared_ptr<RgbItem> rgbItem;
std::shared_ptr<AuxItem> auxItem; std::shared_ptr<AuxItem> auxItem;
private: private:
static QJsonObject getJsonObjectFromDisk(const QString& filePath = "", bool* error = nullptr); static QJsonObject getJsonObjectFromDisk(const QString& filePath = "", bool* error = nullptr);
static bool storeJsonObjectToDisk(const QJsonObject& json, QString filePath = ""); static bool storeJsonObjectToDisk(const QJsonObject& json, QString filePath = "");
public: public:
explicit MainObject(QIODevice* ioDevice, const QString& settingsPathIn, const bool masterIn, QObject *parent = nullptr); explicit MainObject(QIODevice* ioDevice, const QString& settingsPathIn, const bool masterIn, QObject *parent = nullptr);
~MainObject(); ~MainObject();
void store(QJsonObject& json); void store(QJsonObject& json);
void load(const QJsonObject& json); void load(const QJsonObject& json);
signals: signals:
public slots: public slots:
void storeToDisk(); void storeToDisk();
void sendJson(); void sendJson();
void recivedJson(const QJsonObject json); void recivedJson(const QJsonObject json);
}; };

191
src/microcontroller.cpp
View file

@ -7,104 +7,104 @@ static constexpr bool debug = true;
void Microcontroller::relayToggle(int state, int relay) void Microcontroller::relayToggle(int state, int relay)
{ {
char buffer[8]; char buffer[8];
int length = sprintf(buffer, "%d \n", relay); int length = sprintf(buffer, "%d \n", relay);
state ? write("item on ") : write("item off "); state ? write("item on ") : write("item off ");
write(buffer, length); write(buffer, length);
} }
void Microcontroller::relayOn(int relay) void Microcontroller::relayOn(int relay)
{ {
relayToggle(true, relay); relayToggle(true, relay);
} }
void Microcontroller::relayOff(int relay) void Microcontroller::relayOff(int relay)
{ {
relayToggle(false, relay); relayToggle(false, relay);
} }
//rgb lights //rgb lights
void Microcontroller::rgbOn() void Microcontroller::rgbOn()
{ {
write("rgb on\n"); write("rgb on\n");
} }
void Microcontroller::rgbOff() void Microcontroller::rgbOff()
{ {
write( "rgb off\n"); write( "rgb off\n");
} }
void Microcontroller::changeRgbColor(const QColor color) void Microcontroller::changeRgbColor(const QColor color)
{ {
char buffer[64]; char buffer[64];
int length = sprintf(buffer, "rgb set %03d %03d %03d\n", color.red(), color.green(), color.blue()); int length = sprintf(buffer, "rgb set %03d %03d %03d\n", color.red(), color.green(), color.blue());
write(buffer, length); write(buffer, length);
std::cout<<buffer; std::cout<<buffer;
} }
void Microcontroller::setAuxPwm(int duty) void Microcontroller::setAuxPwm(int duty)
{ {
char buffer[64]; char buffer[64];
int length = sprintf(buffer, "aux set %03d\n", duty ); int length = sprintf(buffer, "aux set %03d\n", duty );
write(buffer, length); write(buffer, length);
} }
void Microcontroller::write(const QByteArray& buffer) void Microcontroller::write(const QByteArray& buffer)
{ {
#ifndef Q_OS_ANDROID #ifndef Q_OS_ANDROID
if constexpr(debug) std::cerr<<buffer.data(); if constexpr(debug) std::cerr<<buffer.data();
#endif #endif
if(_port != nullptr) if(_port != nullptr)
{ {
_port->write(buffer); _port->write(buffer);
_port->waitForBytesWritten(1000); _port->waitForBytesWritten(1000);
} }
std::this_thread::sleep_for(std::chrono::milliseconds(40)); std::this_thread::sleep_for(std::chrono::milliseconds(40));
} }
void Microcontroller::write(char* buffer, const size_t length) void Microcontroller::write(char* buffer, const size_t length)
{ {
#ifndef Q_OS_ANDROID #ifndef Q_OS_ANDROID
if constexpr(debug) std::cerr<<buffer; if constexpr(debug) std::cerr<<buffer;
#endif #endif
if(_port != nullptr) if(_port != nullptr)
{ {
_port->write(buffer, length); _port->write(buffer, length);
_port->waitForBytesWritten(1000); _port->waitForBytesWritten(1000);
} }
std::this_thread::sleep_for(std::chrono::milliseconds(40)); std::this_thread::sleep_for(std::chrono::milliseconds(40));
} }
void Microcontroller::setPattern(int pattern) void Microcontroller::setPattern(int pattern)
{ {
char buffer[4]; char buffer[4];
write("rgb pattern "); write("rgb pattern ");
int length = sprintf(buffer, "%d\n", pattern); int length = sprintf(buffer, "%d\n", pattern);
write(buffer, length); write(buffer, length);
} }
void Microcontroller::startSunrise() void Microcontroller::startSunrise()
{ {
setPattern(4); setPattern(4);
} }
bool Microcontroller::connected() bool Microcontroller::connected()
{ {
if(_port != nullptr) return _port->isOpen(); if(_port != nullptr) return _port->isOpen();
else return false; else return false;
} }
void Microcontroller::requestState() void Microcontroller::requestState()
{ {
write("state\n"); write("state\n");
} }
//housekeeping //housekeeping
Microcontroller::Microcontroller(QIODevice* port) Microcontroller::Microcontroller(QIODevice* port)
{ {
setIODevice(port); setIODevice(port);
} }
Microcontroller::Microcontroller() Microcontroller::Microcontroller()
@ -117,81 +117,82 @@ Microcontroller::~Microcontroller()
void Microcontroller::setIODevice(QIODevice *port) void Microcontroller::setIODevice(QIODevice *port)
{ {
_port = port; _port = port;
QObject::connect(_port, &QIODevice::readyRead, this, &Microcontroller::isReadyRead); QObject::connect(_port, &QIODevice::readyRead, this, &Microcontroller::isReadyRead);
} }
std::shared_ptr<Relay> Microcontroller::processRelayLine(const QString& buffer) std::shared_ptr<Relay> Microcontroller::processRelayLine(const QString& buffer)
{ {
QStringList bufferList = buffer.split(' '); QStringList bufferList = buffer.split(' ');
if(bufferList.size() >= 9 && buffer.startsWith("ITEM NUMBER:")) if(bufferList.size() >= 9 && buffer.startsWith("ITEM NUMBER:"))
{ {
QString name; QString name;
for(int i = 10; i < bufferList.size(); i++) name.append(bufferList[i] + ' '); for(int i = 10; i < bufferList.size(); i++) name.append(bufferList[i] + ' ');
if(name.size() > 1)name.remove(name.size()-1, 1); if(name.size() > 1)name.remove(name.size()-1, 1);
else name = "Relay " + QString::number(bufferList[1].toInt(nullptr, 2)); 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())); return std::shared_ptr<Relay>( new Relay(bufferList[2].toInt(), name, bufferList[4].toInt(nullptr, 2),
} bufferList[8].toInt()));
return nullptr; }
return nullptr;
} }
void Microcontroller::processList(const QString& buffer) void Microcontroller::processList(const QString& buffer)
{ {
QStringList bufferList = buffer.split(' '); QStringList bufferList = buffer.split(' ');
if(bufferList.size() >= 8 && buffer.startsWith("ITEM NUMBER:")) if(bufferList.size() >= 8 && buffer.startsWith("ITEM NUMBER:"))
{ {
relayList.push_back(processRelayLine(buffer)); relayList.push_back(processRelayLine(buffer));
} }
else if(buffer.contains("EOL")) else if(buffer.contains("EOL"))
{ {
listMode = false; listMode = false;
qDebug()<<"got relay list " << relayList.size(); qDebug()<<"got relay list " << relayList.size();
gotRelayList(relayList); gotRelayList(relayList);
relayList.clear(); relayList.clear();
} }
else listMode = false; else listMode = false;
} }
void Microcontroller::processRelayState(const QString& buffer) void Microcontroller::processRelayState(const QString& buffer)
{ {
itemChanged(static_cast<ItemData>(*processRelayLine(buffer))); itemChanged(static_cast<ItemData>(*processRelayLine(buffer)));
} }
void Microcontroller::processSensorState(const QString& buffer) void Microcontroller::processSensorState(const QString& buffer)
{ {
Sensor sensor = Sensor::sensorFromString(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() void Microcontroller::processMicroReturn()
{ {
if(listMode) processList(_buffer); if(listMode) processList(_buffer);
else else
{ {
if(_buffer.startsWith("Items:")) if(_buffer.startsWith("Items:"))
{ {
listMode = true; listMode = true;
relayList.clear(); relayList.clear();
} }
else if(_buffer.startsWith("ITEM NUMBER:"))processRelayState(_buffer); else if(_buffer.startsWith("ITEM NUMBER:"))processRelayState(_buffer);
else if(_buffer.startsWith("SENSOR")) processSensorState(_buffer); else if(_buffer.startsWith("SENSOR")) processSensorState(_buffer);
} }
} }
void Microcontroller::isReadyRead() void Microcontroller::isReadyRead()
{ {
char charBuf; char charBuf;
while(_port->getChar(&charBuf)) while(_port->getChar(&charBuf))
{ {
_buffer.push_back(charBuf); _buffer.push_back(charBuf);
if( _buffer.endsWith('\n') ) if( _buffer.endsWith('\n') )
{ {
_buffer.remove('\n'); _buffer.remove('\n');
processMicroReturn(); processMicroReturn();
textRecived(_buffer); textRecived(_buffer);
_buffer.clear(); _buffer.clear();
} }
} }
} }

76
src/microcontroller.h
View file

@ -21,69 +21,69 @@
class Microcontroller : public QObject class Microcontroller : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
static constexpr char AMP_RELAY = 0; static constexpr char AMP_RELAY = 0;
static constexpr char SENSOR_TEMPERATURE = 1; static constexpr char SENSOR_TEMPERATURE = 1;
static constexpr char SENSOR_DOOR = 0 ; static constexpr char SENSOR_DOOR = 0 ;
private: private:
bool listMode = false; bool listMode = false;
//uint8_t _auxState = 0; //uint8_t _auxState = 0;
QIODevice* _port = nullptr; QIODevice* _port = nullptr;
std::vector< std::shared_ptr<Item> > relayList; std::vector< std::shared_ptr<Item> > relayList;
QScopedPointer<QEventLoop> loop; QScopedPointer<QEventLoop> loop;
QString _buffer; QString _buffer;
void processMicroReturn(); void processMicroReturn();
void processList(const QString& buffer); void processList(const QString& buffer);
void processRelayState(const QString& buffer); void processRelayState(const QString& buffer);
void processSensorState(const QString& buffer); void processSensorState(const QString& buffer);
std::shared_ptr<Relay> processRelayLine(const QString& buffer); std::shared_ptr<Relay> processRelayLine(const QString& buffer);
void write(char *buffer, const size_t length); void write(char *buffer, const size_t length);
void write(const QByteArray& buffer); void write(const QByteArray& buffer);
public: public:
Microcontroller(QIODevice* port); Microcontroller(QIODevice* port);
Microcontroller(); Microcontroller();
~Microcontroller(); ~Microcontroller();
bool connected(); bool connected();
void setIODevice(QIODevice* port); void setIODevice(QIODevice* port);
public slots: public slots:
void rgbOn(); void rgbOn();
void rgbOff(); void rgbOff();
void changeRgbColor(const QColor color); void changeRgbColor(const QColor color);
void setPattern(int pattern); void setPattern(int pattern);
void startSunrise(); void startSunrise();
void requestState(); void requestState();
void setAuxPwm(int duty); void setAuxPwm(int duty);
void relayOn(int relay); void relayOn(int relay);
void relayOff(int relay); void relayOff(int relay);
void relayToggle(int state, int id); void relayToggle(int state, int id);
private slots: private slots:
void isReadyRead(); void isReadyRead();
signals: signals:
void textRecived(const QString string); void textRecived(const QString string);
void itemChanged(ItemData relay); void itemChanged(ItemData relay);
void auxStateChanged(int value); void auxStateChanged(int value);
void gotRelayList(std::vector< std::shared_ptr<Item> >&); void gotRelayList(std::vector< std::shared_ptr<Item> >&);
void gotSensorState(Sensor sensor); void gotSensorState(Sensor sensor);
}; };
#endif // MICROCONTROLLER_H #endif // MICROCONTROLLER_H

71
src/sensors/ocupancysensor.cpp
View file

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

23
src/sensors/ocupancysensor.h
View file

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

66
src/sensors/sensor.cpp
View file

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

147
src/sensors/sensor.h
View file

@ -9,91 +9,104 @@ class Sensor
{ {
public: public:
static constexpr uint8_t TYPE_DOOR = 0; static constexpr uint8_t TYPE_DOOR = 0;
static constexpr uint8_t TYPE_TEMPERATURE = 1; static constexpr uint8_t TYPE_TEMPERATURE = 1;
static constexpr uint8_t TYPE_HUMIDITY = 2; static constexpr uint8_t TYPE_HUMIDITY = 2;
static constexpr uint8_t TYPE_PRESSURE = 3; static constexpr uint8_t TYPE_PRESSURE = 3;
static constexpr uint8_t TYPE_BRIGHTNESS = 4; static constexpr uint8_t TYPE_BRIGHTNESS = 4;
static constexpr uint8_t TYPE_BUTTON = 5; static constexpr uint8_t TYPE_BUTTON = 5;
static constexpr uint8_t TYPE_ADC = 6; static constexpr uint8_t TYPE_ADC = 6;
static constexpr uint8_t TYPE_LOWBATTERY = 128; static constexpr uint8_t TYPE_LOWBATTERY = 128;
static constexpr uint8_t TYPE_SHUTDOWN_IMMINENT = 251; static constexpr uint8_t TYPE_SHUTDOWN_IMMINENT = 251;
static constexpr uint8_t TYPE_OCUPANCY = 252; static constexpr uint8_t TYPE_OCUPANCY = 252;
static constexpr uint8_t TYPE_SUN_ALTITUDE = 253; static constexpr uint8_t TYPE_SUN_ALTITUDE = 253;
static constexpr uint8_t TYPE_AUDIO_OUTPUT = 254; static constexpr uint8_t TYPE_AUDIO_OUTPUT = 254;
static constexpr uint8_t TYPE_DUMMY = 255; static constexpr uint8_t TYPE_DUMMY = 255;
uint8_t type; uint8_t type;
uint8_t id; uint8_t id;
float field; float field;
QString name; QString name;
QDateTime lastSeen; QDateTime lastSeen;
bool hidden; 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(uint8_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(); lastSeen = QDateTime::currentDateTime();
} if(nameIn == "") generateName();
Sensor(QString nameIn = "dummy"): type(TYPE_DUMMY), id(0), field(0), name(nameIn), hidden(false) }
{ Sensor(QString nameIn = "dummy"): type(TYPE_DUMMY), id(0), field(0), name(nameIn), hidden(false)
lastSeen = QDateTime::currentDateTime(); {
} 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 bool operator==(const Sensor& in) const
inline void updateSeen(){lastSeen = QDateTime::currentDateTime();} {
static Sensor sensorFromString(const QString& str) return type==in.type && id == in.id;
{ }
QStringList bufferList = str.split(' '); inline bool operator!=(const Sensor& in) const
if(bufferList.size() >= 7) {
{ return !(*this==in);
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; inline void updateSeen()
return sensor; {
} lastSeen = QDateTime::currentDateTime();
else return Sensor(TYPE_DUMMY, 0, 0, "", true); }
} static Sensor sensorFromString(const QString& str)
QString toString() {
{ QStringList bufferList = str.split(' ');
return QString("SENSOR TYPE: ")+QString::number(type)+" ID: "+QString::number(id)+" FIELD: "+ if(bufferList.size() >= 7)
QString::number((type == Sensor::TYPE_HUMIDITY || type == Sensor::TYPE_TEMPERATURE) ? field*10 : field); {
} Sensor sensor(bufferList[2].toUInt(), bufferList[4].toUInt(), bufferList[6].toUInt());
inline void generateName() if(sensor.type == Sensor::TYPE_HUMIDITY || sensor.type == Sensor::TYPE_TEMPERATURE) sensor.field = sensor.field/10;
{ return sensor;
if(type == TYPE_TEMPERATURE) name = "Temperature " + QString::number(id); }
else if(type == TYPE_DOOR) name = "Door " + QString::number(id); else return Sensor(TYPE_DUMMY, 0, 0, "", true);
else if(type == TYPE_BUTTON) name = "Button " + QString::number(id); }
else if(type == TYPE_AUDIO_OUTPUT) name = "Speakers " + QString::number(id); QString toString()
else if(type == TYPE_HUMIDITY) name = "Humidity " + QString::number(id); {
else if(type == TYPE_SUN_ALTITUDE) name = "Solar Altitude"; return QString("SENSOR TYPE: ")+QString::number(type)+" ID: "+QString::number(id)+" FIELD: "+
else if(type == TYPE_SHUTDOWN_IMMINENT) name = "Shutdown Imminent"; QString::number((type == Sensor::TYPE_HUMIDITY || type == Sensor::TYPE_TEMPERATURE) ? field*10 : field);
else name = "Sensor Type " + QString::number(type) + " Id " + QString::number(id); }
} 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";
else name = "Sensor Type " + QString::number(type) + " Id " + QString::number(id);
}
}; };
class SensorStore: public QObject class SensorStore: public QObject
{ {
Q_OBJECT Q_OBJECT
private: private:
std::vector<Sensor> sensors_; std::vector<Sensor> sensors_;
public: public:
SensorStore(QObject *parent = nullptr); SensorStore(QObject *parent = nullptr);
virtual ~SensorStore(){} virtual ~SensorStore() {}
inline std::vector<Sensor>* getSensors(){ return &sensors_; } inline std::vector<Sensor>* getSensors()
{
return &sensors_;
}
public slots: public slots:
void sensorGotState(const Sensor& sensor); void sensorGotState(const Sensor& sensor);
signals: signals:
void stateChenged(std::vector<Sensor> sensors); void stateChenged(std::vector<Sensor> sensors);
void sensorChangedState(Sensor sensor); void sensorChangedState(Sensor sensor);
void sensorDeleted(Sensor sensor); void sensorDeleted(Sensor sensor);
}; };

66
src/sensors/speakersensor.cpp
View file

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

24
src/sensors/speakersensor.h
View file

@ -16,30 +16,30 @@
class SpeakerSensorSource : public QObject class SpeakerSensorSource : public QObject
{ {
Q_OBJECT Q_OBJECT
private: private:
QString name_; QString name_;
bool state = true; bool state = true;
QTimer timer; QTimer timer;
public: public:
explicit SpeakerSensorSource(QString name = "", QObject *parent = nullptr); explicit SpeakerSensorSource(QString name = "", QObject *parent = nullptr);
~SpeakerSensorSource(); ~SpeakerSensorSource();
public slots: public slots:
void run(); void run();
void abort(); void abort();
signals: signals:
void stateChanged(Sensor sensor); void stateChanged(Sensor sensor);
private slots: private slots:
void doTick(); void doTick();
private: private:
long silenceCount = 0; long silenceCount = 0;
QProcess arecord; QProcess arecord;
}; };
#endif // AMPMANAGER_H #endif // AMPMANAGER_H

14
src/sensors/sunsensor.cpp
View file

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

16
src/sensors/sunsensor.h
View file

@ -8,22 +8,22 @@
class SunSensorSource : public QObject class SunSensorSource : public QObject
{ {
Q_OBJECT Q_OBJECT
private: private:
Sun sun_; Sun sun_;
QTimer timer; QTimer timer;
public: public:
explicit SunSensorSource(double lat, double lon, QObject *parent = nullptr); explicit SunSensorSource(double lat, double lon, QObject *parent = nullptr);
public slots: public slots:
void run(); void run();
void abort(); void abort();
signals: signals:
void stateChanged(Sensor sensor); void stateChanged(Sensor sensor);
private slots: private slots:
void doTick(); void doTick();
}; };

23
src/sun.cpp
View file

@ -34,7 +34,7 @@ void Sun::JdTime::update()
void Sun::JdTime::fromStdTime(std::time_t time) void Sun::JdTime::fromStdTime(std::time_t time)
{ {
std::tm ltime = *std::localtime( &time ); std::tm ltime = *std::localtime( &time );
localHour = ltime.tm_hour + ltime.tm_min/60.0 + ltime.tm_sec/3600.0; localHour = ltime.tm_hour + ltime.tm_min/60.0 + ltime.tm_sec/3600.0;
utcHour = localHour - ltime.tm_gmtoff/3600.0; utcHour = localHour - ltime.tm_gmtoff/3600.0;
@ -63,7 +63,8 @@ std::time_t Sun::JdTime::toStdTime()
return millenniumTime; 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) double Sun::nextMeanSolarNoonJD(const JdTime& time)
@ -78,7 +79,8 @@ double Sun::meanSolarAnomaly(double meanSolarNoon)
double Sun::eqOfCenter(double meanSolarAnomaly) 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) double Sun::eclipticLongitude(double eqOfCenter, double meanSolarAnomaly)
@ -108,7 +110,8 @@ double Sun::hourAngle(double localSolarTime)
double Sun::hourAngleAtSunset(double solarDeclination) 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() double Sun::altitude()
@ -120,7 +123,8 @@ double Sun::altitude()
double localSolarTimeValue = localSolarTime(time, equationOfTime(meanSolarAnomalyValue, eclipticLongitudeValue)); double localSolarTimeValue = localSolarTime(time, equationOfTime(meanSolarAnomalyValue, eclipticLongitudeValue));
double declinationValue = solarDeclination(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); return TO_DEGS*asin(cosZenithAngle);
} }
@ -133,7 +137,8 @@ double Sun::maximumAltitude()
double eclipticLongitudeValue = eclipticLongitude(eqOfCenter(meanSolarAnomalyValue), meanSolarAnomalyValue); double eclipticLongitudeValue = eclipticLongitude(eqOfCenter(meanSolarAnomalyValue), meanSolarAnomalyValue);
double declinationValue = solarDeclination(eclipticLongitudeValue); 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); return TO_DEGS*asin(cosZenithAngle);
} }
@ -153,7 +158,8 @@ std::time_t Sun::riseTime()
double declinationValue = solarDeclination(eclipticLongitudeValue); double declinationValue = solarDeclination(eclipticLongitudeValue);
double hourAngleValue = hourAngleAtSunset(declinationValue); 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(); return time.toStdTime();
} }
@ -166,7 +172,8 @@ std::time_t Sun::setTime()
double declinationValue = solarDeclination(eclipticLongitudeValue); double declinationValue = solarDeclination(eclipticLongitudeValue);
double hourAngleValue = hourAngleAtSunset(declinationValue); 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(); return time.toStdTime();
} }

26
src/sun.h
View file

@ -17,23 +17,23 @@ class Sun
{ {
private: private:
static constexpr double TO_DEGS = 180.0/M_PI; static constexpr double TO_DEGS = 180.0/M_PI;
static constexpr double TO_RADS = M_PI/180.0; static constexpr double TO_RADS = M_PI/180.0;
static constexpr double SUN_DIA = 0.53; //degrees static constexpr double SUN_DIA = 0.53; //degrees
static constexpr double AIR_REFRACTION = 34.0/60.0; static constexpr double AIR_REFRACTION = 34.0/60.0;
static constexpr double ARGUMENT_OF_PERIHELION = 102.9372; static constexpr double ARGUMENT_OF_PERIHELION = 102.9372;
static constexpr double PLANETARY_AXIAL_TILT = 23.44; static constexpr double PLANETARY_AXIAL_TILT = 23.44;
class JdTime; class JdTime;
double latitude_; double latitude_;
double longetude_; double longetude_;
double altitude_; double altitude_;
private: private:
double nextMeanSolarNoonJD(const JdTime& time); double nextMeanSolarNoonJD(const JdTime& time);
double meanSolarAnomaly(double meanSolarNoon); double meanSolarAnomaly(double meanSolarNoon);
double eqOfCenter(double meanSolarAnomaly); double eqOfCenter(double meanSolarAnomaly);
double eclipticLongitude(double eqOfCenter, double meanSolarAnomaly); double eclipticLongitude(double eqOfCenter, double meanSolarAnomaly);
@ -46,11 +46,11 @@ private:
public: public:
Sun(double latitude, double longitude, double altitude = 0); Sun(double latitude, double longitude, double altitude = 0);
double altitude(); double altitude();
double maximumAltitude(); double maximumAltitude();
double azimuth(); double azimuth();
double declination(); double declination();
std::time_t riseTime(); std::time_t riseTime();
std::time_t setTime(); std::time_t setTime();
}; };

4
src/suntest.cpp
View file

@ -6,7 +6,7 @@
int main() int main()
{ {
std::cout<<std::setprecision(15); std::cout<<std::setprecision(15);
Sun sun(49.884450, 8.650536); Sun sun(49.884450, 8.650536);
std::time_t time = sun.setTime(); std::time_t time = sun.setTime();
tm setTime = *localtime(&time); tm setTime = *localtime(&time);
time = sun.riseTime(); time = sun.riseTime();
@ -16,5 +16,5 @@ int main()
std::cout<<"current Alt: "<<sun.altitude()<<std::endl; std::cout<<"current Alt: "<<sun.altitude()<<std::endl;
std::cout<<"maximum Alt: "<<sun.maximumAltitude()<<std::endl; std::cout<<"maximum Alt: "<<sun.maximumAltitude()<<std::endl;
std::cout<<"declination: "<<sun.declination()<<std::endl; std::cout<<"declination: "<<sun.declination()<<std::endl;
return 0; return 0;
} }

124
src/ui/actorsettingsdialog.cpp
View file

@ -5,108 +5,108 @@
#include <QSpinBox> #include <QSpinBox>
ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<AlarmTime> alarm, QWidget *parent): ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<AlarmTime> alarm, QWidget *parent):
QDialog(parent), QDialog(parent),
actor_(alarm), actor_(alarm),
ui(new Ui::ActorSettingsDialog) ui(new Ui::ActorSettingsDialog)
{ {
init(); init();
widget = new AlarmWidget(alarm, this); widget = new AlarmWidget(alarm, this);
ui->vertlayout->addWidget(widget); ui->vertlayout->addWidget(widget);
} }
ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<SensorActor> actor, QWidget *parent) : ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<SensorActor> actor, QWidget *parent) :
QDialog(parent), QDialog(parent),
actor_(actor), actor_(actor),
ui(new Ui::ActorSettingsDialog) ui(new Ui::ActorSettingsDialog)
{ {
init(); init();
widget = new SensorActorWidget(actor, &globalSensors, this); widget = new SensorActorWidget(actor, &globalSensors, this);
ui->vertlayout->addWidget(widget); ui->vertlayout->addWidget(widget);
} }
ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<Regulator> actor, QWidget *parent) : ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<Regulator> actor, QWidget *parent) :
QDialog(parent), QDialog(parent),
actor_(actor), actor_(actor),
ui(new Ui::ActorSettingsDialog) ui(new Ui::ActorSettingsDialog)
{ {
init(); init();
widget = new RegulatorWdiget(actor, &globalSensors, this); widget = new RegulatorWdiget(actor, &globalSensors, this);
ui->vertlayout->addWidget(widget); ui->vertlayout->addWidget(widget);
} }
ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<TimerActor> actor, QWidget *parent) : ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<TimerActor> actor, QWidget *parent) :
QDialog(parent), QDialog(parent),
actor_(actor), actor_(actor),
ui(new Ui::ActorSettingsDialog) ui(new Ui::ActorSettingsDialog)
{ {
init(); init();
widget = new TimerActorWidget(actor, this); widget = new TimerActorWidget(actor, this);
ui->vertlayout->addWidget(widget); ui->vertlayout->addWidget(widget);
} }
ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<PolynomalActor> actor, QWidget *parent) : ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<PolynomalActor> actor, QWidget *parent) :
QDialog(parent), QDialog(parent),
actor_(actor), actor_(actor),
ui(new Ui::ActorSettingsDialog) ui(new Ui::ActorSettingsDialog)
{ {
init(); init();
widget = new PolynomalActorWidget(actor, &globalSensors, this); widget = new PolynomalActorWidget(actor, &globalSensors, this);
ui->vertlayout->addWidget(widget); ui->vertlayout->addWidget(widget);
} }
ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<MultiFactorActor> actor, QWidget *parent) : ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<MultiFactorActor> actor, QWidget *parent) :
QDialog(parent), QDialog(parent),
actor_(actor), actor_(actor),
ui(new Ui::ActorSettingsDialog) ui(new Ui::ActorSettingsDialog)
{ {
init(); init();
widget = new FactorActorWidget(actor, this); widget = new FactorActorWidget(actor, this);
ui->vertlayout->addWidget(widget); ui->vertlayout->addWidget(widget);
} }
ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<Actor> actor, QWidget *parent) : ActorSettingsDialog::ActorSettingsDialog(std::shared_ptr<Actor> actor, QWidget *parent) :
QDialog(parent), QDialog(parent),
actor_(actor), actor_(actor),
ui(new Ui::ActorSettingsDialog) ui(new Ui::ActorSettingsDialog)
{ {
init(); init();
} }
void ActorSettingsDialog::init() void ActorSettingsDialog::init()
{ {
ui->setupUi(this); ui->setupUi(this);
connect(ui->comboBox_action, SIGNAL(currentIndexChanged(int)), this, SLOT(changeAction(int))); connect(ui->comboBox_action, SIGNAL(currentIndexChanged(int)), this, SLOT(changeAction(int)));
connect(ui->spinBox, SIGNAL(valueChanged(int)), this, SLOT(valueChanged(int))); connect(ui->spinBox, SIGNAL(valueChanged(int)), this, SLOT(valueChanged(int)));
connect(ui->pushButton_editItem, &QPushButton::clicked, this, &ActorSettingsDialog::editAsItem); connect(ui->pushButton_editItem, &QPushButton::clicked, this, &ActorSettingsDialog::editAsItem);
ui->spinBox->hide(); ui->spinBox->hide();
ui->spinBox->setValue(actor_->getTriggerValue()); ui->spinBox->setValue(actor_->getTriggerValue());
if(actor_->getTriggerValue() == 0) ui->comboBox_action->setCurrentIndex(0); if(actor_->getTriggerValue() == 0) ui->comboBox_action->setCurrentIndex(0);
else if(actor_->getTriggerValue() == 1) ui->comboBox_action->setCurrentIndex(1); else if(actor_->getTriggerValue() == 1) ui->comboBox_action->setCurrentIndex(1);
else ui->comboBox_action->setCurrentIndex(2); else ui->comboBox_action->setCurrentIndex(2);
ui->label_Exausted->setText(actor_->isExausted() ? "True" : "False"); ui->label_Exausted->setText(actor_->isExausted() ? "True" : "False");
} }
ActorSettingsDialog::~ActorSettingsDialog() ActorSettingsDialog::~ActorSettingsDialog()
{ {
delete ui; delete ui;
} }
void ActorSettingsDialog::editAsItem() void ActorSettingsDialog::editAsItem()
{ {
ItemSettingsDialog itemSettingsDiag(actor_, this); ItemSettingsDialog itemSettingsDiag(actor_, this);
itemSettingsDiag.exec(); itemSettingsDiag.exec();
} }
void ActorSettingsDialog::valueChanged(int value) void ActorSettingsDialog::valueChanged(int value)
{ {
actor_->setTriggerValue(value); actor_->setTriggerValue(value);
} }
void ActorSettingsDialog::hideCancle([[maybe_unused]] const bool hide) void ActorSettingsDialog::hideCancle([[maybe_unused]] const bool hide)
@ -116,13 +116,13 @@ void ActorSettingsDialog::hideCancle([[maybe_unused]] const bool hide)
void ActorSettingsDialog::changeAction(int index) void ActorSettingsDialog::changeAction(int index)
{ {
if(index == 0) actor_->setTriggerValue(0); if(index == 0) actor_->setTriggerValue(0);
else if(index == 1) actor_->setTriggerValue(1); else if(index == 1) actor_->setTriggerValue(1);
else if(index == 2) else if(index == 2)
{ {
ui->spinBox->show(); ui->spinBox->show();
actor_->setTriggerValue(ui->spinBox->value()); actor_->setTriggerValue(ui->spinBox->value());
} }
if(index != 2)ui->spinBox->hide(); if(index != 2)ui->spinBox->hide();
} }

37
src/ui/actorsettingsdialog.h
View file

@ -10,40 +10,41 @@
#include "actorwidgets/polynomalactorwidget.h" #include "actorwidgets/polynomalactorwidget.h"
#include "actorwidgets/factoractorwidget.h" #include "actorwidgets/factoractorwidget.h"
namespace Ui { namespace Ui
{
class ActorSettingsDialog; class ActorSettingsDialog;
} }
class ActorSettingsDialog : public QDialog class ActorSettingsDialog : public QDialog
{ {
Q_OBJECT Q_OBJECT
private: private:
std::shared_ptr<Actor> actor_; std::shared_ptr<Actor> actor_;
QWidget* widget; QWidget* widget;
void init(); void init();
public: public:
ActorSettingsDialog(std::shared_ptr<AlarmTime> actor, QWidget *parent = nullptr); ActorSettingsDialog(std::shared_ptr<AlarmTime> actor, QWidget *parent = nullptr);
ActorSettingsDialog(std::shared_ptr<SensorActor> actor, QWidget *parent = nullptr); ActorSettingsDialog(std::shared_ptr<SensorActor> actor, QWidget *parent = nullptr);
ActorSettingsDialog(std::shared_ptr<Regulator> actor, QWidget *parent = nullptr); ActorSettingsDialog(std::shared_ptr<Regulator> actor, QWidget *parent = nullptr);
ActorSettingsDialog(std::shared_ptr<TimerActor> actor, QWidget *parent = nullptr); ActorSettingsDialog(std::shared_ptr<TimerActor> actor, QWidget *parent = nullptr);
ActorSettingsDialog(std::shared_ptr<PolynomalActor> actor, QWidget *parent = nullptr); ActorSettingsDialog(std::shared_ptr<PolynomalActor> actor, QWidget *parent = nullptr);
ActorSettingsDialog(std::shared_ptr<MultiFactorActor> actor, QWidget *parent = nullptr); ActorSettingsDialog(std::shared_ptr<MultiFactorActor> actor, QWidget *parent = nullptr);
ActorSettingsDialog(std::shared_ptr<Actor> actor, QWidget *parent); ActorSettingsDialog(std::shared_ptr<Actor> actor, QWidget *parent);
~ActorSettingsDialog(); ~ActorSettingsDialog();
void hideCancle(const bool hide); void hideCancle(const bool hide);
private slots: private slots:
void changeAction(int index); void changeAction(int index);
void valueChanged(int value); void valueChanged(int value);
void editAsItem(); void editAsItem();
private: private:
Ui::ActorSettingsDialog *ui; Ui::ActorSettingsDialog *ui;
}; };
#endif // ACTORSETTINGSDIALOG_H #endif // ACTORSETTINGSDIALOG_H

102
src/ui/actorwidgets/alarmwidget.cpp
View file

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

17
src/ui/actorwidgets/alarmwidget.h
View file

@ -5,26 +5,27 @@
#include <memory> #include <memory>
#include "../../actors/alarmtime.h" #include "../../actors/alarmtime.h"
namespace Ui { namespace Ui
{
class AlarmWidget; class AlarmWidget;
} }
class AlarmWidget : public QWidget class AlarmWidget : public QWidget
{ {
Q_OBJECT Q_OBJECT
std::shared_ptr<AlarmTime> alarm_; std::shared_ptr<AlarmTime> alarm_;
public: public:
explicit AlarmWidget(std::shared_ptr<AlarmTime> alarm, QWidget *parent = nullptr); explicit AlarmWidget(std::shared_ptr<AlarmTime> alarm, QWidget *parent = nullptr);
~AlarmWidget(); ~AlarmWidget();
private slots: private slots:
void toggleRepeating(int state); void toggleRepeating(int state);
void setRepeatingType(); void setRepeatingType();
private: private:
Ui::AlarmWidget *ui; Ui::AlarmWidget *ui;
}; };
#endif // ALARMWIDGET_H #endif // ALARMWIDGET_H

114
src/ui/actorwidgets/factoractorwidget.cpp
View file

@ -3,82 +3,82 @@
#include "../actorsettingsdialog.h" #include "../actorsettingsdialog.h"
FactorActorWidget::FactorActorWidget(std::shared_ptr<MultiFactorActor> actor, QWidget *parent) : FactorActorWidget::FactorActorWidget(std::shared_ptr<MultiFactorActor> actor, QWidget *parent) :
QWidget(parent), QWidget(parent),
actor_(actor), actor_(actor),
ui(new Ui::FactorActorWidget) ui(new Ui::FactorActorWidget)
{ {
ui->setupUi(this); ui->setupUi(this);
ui->comboBox->setCurrentText(actor_->getFactorDirection() ? "True" : "False"); ui->comboBox->setCurrentText(actor_->getFactorDirection() ? "True" : "False");
ui->spinBox->setValue(actor_->getPreCancleTime()); ui->spinBox->setValue(actor_->getPreCancleTime());
if(actor_->getFactorActor()) ui->label_FactorActor->setText(actor_->getFactorActor()->getName()); if(actor_->getFactorActor()) ui->label_FactorActor->setText(actor_->getFactorActor()->getName());
connect(ui->pushButton, &QPushButton::clicked, this, &FactorActorWidget::createFactorActor); connect(ui->pushButton, &QPushButton::clicked, this, &FactorActorWidget::createFactorActor);
connect(ui->comboBox_Direcion, &QComboBox::currentTextChanged, this, &FactorActorWidget::setDirection); connect(ui->comboBox_Direcion, &QComboBox::currentTextChanged, this, &FactorActorWidget::setDirection);
connect(ui->spinBox, qOverload<int>(&QSpinBox::valueChanged), this, &FactorActorWidget::setPreCancleTime); connect(ui->spinBox, qOverload<int>(&QSpinBox::valueChanged), this, &FactorActorWidget::setPreCancleTime);
} }
FactorActorWidget::~FactorActorWidget() FactorActorWidget::~FactorActorWidget()
{ {
delete ui; delete ui;
} }
void FactorActorWidget::createFactorActor() void FactorActorWidget::createFactorActor()
{ {
ActorSettingsDialog* dialog = nullptr; ActorSettingsDialog* dialog = nullptr;
std::shared_ptr<Actor> actor = nullptr; std::shared_ptr<Actor> actor = nullptr;
if(ui->comboBox->currentText() == "Alarm") if(ui->comboBox->currentText() == "Alarm")
{ {
std::shared_ptr<AlarmTime> alarm = std::shared_ptr<AlarmTime>(new AlarmTime); std::shared_ptr<AlarmTime> alarm = std::shared_ptr<AlarmTime>(new AlarmTime);
actor = alarm; actor = alarm;
dialog = new ActorSettingsDialog(alarm, this); dialog = new ActorSettingsDialog(alarm, this);
} }
else if(ui->comboBox->currentText() == "Sensor") else if(ui->comboBox->currentText() == "Sensor")
{ {
std::shared_ptr<SensorActor> sensorActor = std::shared_ptr<SensorActor>(new SensorActor()); std::shared_ptr<SensorActor> sensorActor = std::shared_ptr<SensorActor>(new SensorActor());
actor = sensorActor; actor = sensorActor;
dialog = new ActorSettingsDialog(sensorActor, this); dialog = new ActorSettingsDialog(sensorActor, this);
} }
else if(ui->comboBox->currentText() == "Timer" ) else if(ui->comboBox->currentText() == "Timer" )
{ {
std::shared_ptr<TimerActor> timerActor = std::shared_ptr<TimerActor>(new TimerActor()); std::shared_ptr<TimerActor> timerActor = std::shared_ptr<TimerActor>(new TimerActor());
actor = timerActor; actor = timerActor;
dialog = new ActorSettingsDialog(timerActor, this); dialog = new ActorSettingsDialog(timerActor, this);
} }
else if(ui->comboBox->currentText() == "Regulator") else if(ui->comboBox->currentText() == "Regulator")
{ {
std::shared_ptr<Regulator> regulator = std::shared_ptr<Regulator>(new Regulator()); std::shared_ptr<Regulator> regulator = std::shared_ptr<Regulator>(new Regulator());
actor = regulator; actor = regulator;
dialog = new ActorSettingsDialog(regulator, this); dialog = new ActorSettingsDialog(regulator, this);
} }
else if(ui->comboBox->currentText() == "Polynomal") else if(ui->comboBox->currentText() == "Polynomal")
{ {
std::shared_ptr<PolynomalActor> polynomalActor = std::shared_ptr<PolynomalActor>(new PolynomalActor()); std::shared_ptr<PolynomalActor> polynomalActor = std::shared_ptr<PolynomalActor>(new PolynomalActor());
actor = polynomalActor; actor = polynomalActor;
dialog = new ActorSettingsDialog(polynomalActor, this); dialog = new ActorSettingsDialog(polynomalActor, this);
} }
if(dialog != nullptr) if(dialog != nullptr)
{ {
dialog->setParent(this); dialog->setParent(this);
dialog->show(); dialog->show();
if(dialog->exec() == QDialog::Accepted) if(dialog->exec() == QDialog::Accepted)
{ {
actor_->setFactorActor(actor); actor_->setFactorActor(actor);
ui->label_FactorActor->setText(actor->getName()); ui->label_FactorActor->setText(actor->getName());
} }
delete dialog; delete dialog;
} }
} }
void FactorActorWidget::setDirection(const QString& type) void FactorActorWidget::setDirection(const QString& type)
{ {
if(type == "True") actor_->setFactorDirection(true); if(type == "True") actor_->setFactorDirection(true);
else actor_->setFactorDirection(false); else actor_->setFactorDirection(false);
} }
void FactorActorWidget::setPreCancleTime(int time) void FactorActorWidget::setPreCancleTime(int time)
{ {
actor_->setPreCancleTime(time); actor_->setPreCancleTime(time);
} }

19
src/ui/actorwidgets/factoractorwidget.h
View file

@ -4,27 +4,28 @@
#include <QWidget> #include <QWidget>
#include "../../actors/factoractor.h" #include "../../actors/factoractor.h"
namespace Ui { namespace Ui
{
class FactorActorWidget; class FactorActorWidget;
} }
class FactorActorWidget : public QWidget class FactorActorWidget : public QWidget
{ {
Q_OBJECT Q_OBJECT
std::shared_ptr<MultiFactorActor> actor_; std::shared_ptr<MultiFactorActor> actor_;
public: public:
explicit FactorActorWidget(std::shared_ptr<MultiFactorActor> actor, QWidget *parent = nullptr); explicit FactorActorWidget(std::shared_ptr<MultiFactorActor> actor, QWidget *parent = nullptr);
~FactorActorWidget(); ~FactorActorWidget();
private slots: private slots:
void createFactorActor(); void createFactorActor();
void setDirection(const QString& direction); void setDirection(const QString& direction);
void setPreCancleTime(int time); void setPreCancleTime(int time);
private: private:
Ui::FactorActorWidget *ui; Ui::FactorActorWidget *ui;
}; };
#endif // FACTORACTORWIDGET_H #endif // FACTORACTORWIDGET_H

54
src/ui/actorwidgets/polynomalactorwidget.cpp
View file

@ -1,48 +1,50 @@
#include "polynomalactorwidget.h" #include "polynomalactorwidget.h"
#include "ui_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), QWidget(parent),
actor_(actor), sensors_(sensors),
ui(new Ui::PolynomalActorWidget) actor_(actor),
ui(new Ui::PolynomalActorWidget)
{ {
ui->setupUi(this); ui->setupUi(this);
if(sensors)ui->listView->sensorsChanged(*(sensors->getSensors())); if(sensors)ui->listView->sensorsChanged(*(sensors->getSensors()));
else else
{ {
ui->listView->hide(); ui->listView->hide();
ui->label->hide(); ui->label->hide();
} }
double pow3, pow2, pow1, pow0; double pow3, pow2, pow1, pow0;
actor_->getCoeffiancts(pow3, pow2, pow1, pow0); actor_->getCoeffiancts(pow3, pow2, pow1, pow0);
ui->doubleSpinBox_pow0->setValue(pow0); ui->doubleSpinBox_pow0->setValue(pow0);
ui->doubleSpinBox_pow1->setValue(pow1); ui->doubleSpinBox_pow1->setValue(pow1);
ui->doubleSpinBox_pow2->setValue(pow2); ui->doubleSpinBox_pow2->setValue(pow2);
ui->doubleSpinBox_pow3->setValue(pow3); ui->doubleSpinBox_pow3->setValue(pow3);
connect(ui->doubleSpinBox_pow3, &QDoubleSpinBox::editingFinished, this, &PolynomalActorWidget::setPow); connect(ui->doubleSpinBox_pow3, &QDoubleSpinBox::editingFinished, this, &PolynomalActorWidget::setPow);
connect(ui->doubleSpinBox_pow2, &QDoubleSpinBox::editingFinished, this, &PolynomalActorWidget::setPow); connect(ui->doubleSpinBox_pow2, &QDoubleSpinBox::editingFinished, this, &PolynomalActorWidget::setPow);
connect(ui->doubleSpinBox_pow1, &QDoubleSpinBox::editingFinished, this, &PolynomalActorWidget::setPow); connect(ui->doubleSpinBox_pow1, &QDoubleSpinBox::editingFinished, this, &PolynomalActorWidget::setPow);
connect(ui->doubleSpinBox_pow0, &QDoubleSpinBox::editingFinished, this, &PolynomalActorWidget::setPow); connect(ui->doubleSpinBox_pow0, &QDoubleSpinBox::editingFinished, this, &PolynomalActorWidget::setPow);
connect(ui->listView, &SensorListWidget::clicked, this, &PolynomalActorWidget::setSensor); connect(ui->listView, &SensorListWidget::clicked, this, &PolynomalActorWidget::setSensor);
} }
PolynomalActorWidget::~PolynomalActorWidget() PolynomalActorWidget::~PolynomalActorWidget()
{ {
delete ui; delete ui;
} }
void PolynomalActorWidget::setPow() 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) void PolynomalActorWidget::setSensor(const QModelIndex &index)
{ {
actor_->setSensor(sensors_->getSensors()->at(index.row())); actor_->setSensor(sensors_->getSensors()->at(index.row()));
} }

20
src/ui/actorwidgets/polynomalactorwidget.h
View file

@ -4,27 +4,29 @@
#include <QWidget> #include <QWidget>
#include "../../actors/polynomalactor.h" #include "../../actors/polynomalactor.h"
namespace Ui { namespace Ui
{
class PolynomalActorWidget; class PolynomalActorWidget;
} }
class PolynomalActorWidget : public QWidget class PolynomalActorWidget : public QWidget
{ {
Q_OBJECT Q_OBJECT
SensorStore* sensors_; SensorStore* sensors_;
std::shared_ptr<PolynomalActor> actor_; std::shared_ptr<PolynomalActor> actor_;
public: public:
explicit PolynomalActorWidget(std::shared_ptr<PolynomalActor> regulator, SensorStore* sensors = nullptr, QWidget *parent = nullptr); explicit PolynomalActorWidget(std::shared_ptr<PolynomalActor> regulator, SensorStore* sensors = nullptr,
~PolynomalActorWidget(); QWidget *parent = nullptr);
~PolynomalActorWidget();
private slots: private slots:
void setPow(); void setPow();
void setSensor(const QModelIndex &index); void setSensor(const QModelIndex &index);
private: private:
Ui::PolynomalActorWidget *ui; Ui::PolynomalActorWidget *ui;
}; };
#endif // POLYNOMALACTORWIDGET_H #endif // POLYNOMALACTORWIDGET_H

44
src/ui/actorwidgets/regulatorwdiget.cpp
View file

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

22
src/ui/actorwidgets/regulatorwdiget.h
View file

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

50
src/ui/actorwidgets/sensoractorwidget.cpp
View file

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

22
src/ui/actorwidgets/sensoractorwidget.h
View file

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

12
src/ui/actorwidgets/timeractorwidget.cpp
View file

@ -4,17 +4,17 @@
#include <QSpinBox> #include <QSpinBox>
TimerActorWidget::TimerActorWidget(std::shared_ptr<TimerActor> actor, QWidget *parent) : TimerActorWidget::TimerActorWidget(std::shared_ptr<TimerActor> actor, QWidget *parent) :
QWidget(parent), QWidget(parent),
ui(new Ui::TimerActorWidget) ui(new Ui::TimerActorWidget)
{ {
ui->setupUi(this); ui->setupUi(this);
ui->spinBox->setValue(actor->getTimeout()); ui->spinBox->setValue(actor->getTimeout());
connect(ui->spinBox, SIGNAL(valueChanged(int)), actor.get(), SLOT(setTimeout(int))); connect(ui->spinBox, SIGNAL(valueChanged(int)), actor.get(), SLOT(setTimeout(int)));
} }
TimerActorWidget::~TimerActorWidget() TimerActorWidget::~TimerActorWidget()
{ {
delete ui; delete ui;
} }

11
src/ui/actorwidgets/timeractorwidget.h
View file

@ -4,20 +4,21 @@
#include <QWidget> #include <QWidget>
#include "../../actors/timeractor.h" #include "../../actors/timeractor.h"
namespace Ui { namespace Ui
{
class TimerActorWidget; class TimerActorWidget;
} }
class TimerActorWidget : public QWidget class TimerActorWidget : public QWidget
{ {
Q_OBJECT Q_OBJECT
public: public:
explicit TimerActorWidget(std::shared_ptr<TimerActor> actor, QWidget *parent = nullptr); explicit TimerActorWidget(std::shared_ptr<TimerActor> actor, QWidget *parent = nullptr);
~TimerActorWidget(); ~TimerActorWidget();
private: private:
Ui::TimerActorWidget *ui; Ui::TimerActorWidget *ui;
}; };
#endif // TIMERACTORWIDGET_H #endif // TIMERACTORWIDGET_H

62
src/ui/itemcreationdialog.cpp
View file

@ -5,49 +5,49 @@
#include "itemsettingswidgets/systemitemsettingswidget.h" #include "itemsettingswidgets/systemitemsettingswidget.h"
ItemCreationDialog::ItemCreationDialog(QWidget *parent) : ItemCreationDialog::ItemCreationDialog(QWidget *parent) :
QDialog(parent), QDialog(parent),
ui(new Ui::ItemCreationDialog) ui(new Ui::ItemCreationDialog)
{ {
ui->setupUi(this); ui->setupUi(this);
std::shared_ptr<MessageItem> messageItem(new MessageItem); std::shared_ptr<MessageItem> messageItem(new MessageItem);
item = messageItem; item = messageItem;
widget = new MessageItemSettingsWidget(messageItem, this); widget = new MessageItemSettingsWidget(messageItem, this);
ui->verticalLayout->addWidget(widget); ui->verticalLayout->addWidget(widget);
connect(ui->comboBox, &QComboBox::currentTextChanged, this, &ItemCreationDialog::itemTypeChanged); connect(ui->comboBox, &QComboBox::currentTextChanged, this, &ItemCreationDialog::itemTypeChanged);
connect(ui->lineEdit, &QLineEdit::textChanged, this, &ItemCreationDialog::itemNameChanged); connect(ui->lineEdit, &QLineEdit::textChanged, this, &ItemCreationDialog::itemNameChanged);
} }
ItemCreationDialog::~ItemCreationDialog() ItemCreationDialog::~ItemCreationDialog()
{ {
delete ui; delete ui;
delete widget; delete widget;
} }
void ItemCreationDialog::itemTypeChanged(const QString& type) void ItemCreationDialog::itemTypeChanged(const QString& type)
{ {
ui->verticalLayout->removeWidget(widget); ui->verticalLayout->removeWidget(widget);
delete widget; delete widget;
if(type == "Message") if(type == "Message")
{ {
std::shared_ptr<MessageItem> messageItem(new MessageItem); std::shared_ptr<MessageItem> messageItem(new MessageItem);
item = messageItem; item = messageItem;
widget = new MessageItemSettingsWidget(messageItem, this); widget = new MessageItemSettingsWidget(messageItem, this);
ui->verticalLayout->addWidget(widget); ui->verticalLayout->addWidget(widget);
} }
if(type == "System") if(type == "System")
{ {
std::shared_ptr<SystemItem> systemItem(new SystemItem); std::shared_ptr<SystemItem> systemItem(new SystemItem);
item = systemItem; item = systemItem;
widget = new SystemItemSettingsWidget(systemItem, this); widget = new SystemItemSettingsWidget(systemItem, this);
ui->verticalLayout->addWidget(widget); ui->verticalLayout->addWidget(widget);
} }
} }
void ItemCreationDialog::itemNameChanged(const QString& name) void ItemCreationDialog::itemNameChanged(const QString& name)
{ {
if(item) if(item)
{ {
item->setName(name); item->setName(name);
} }
} }

19
src/ui/itemcreationdialog.h
View file

@ -5,29 +5,30 @@
#include <memory> #include <memory>
#include "../items/item.h" #include "../items/item.h"
namespace Ui { namespace Ui
{
class ItemCreationDialog; class ItemCreationDialog;
} }
class ItemCreationDialog : public QDialog class ItemCreationDialog : public QDialog
{ {
Q_OBJECT Q_OBJECT
QWidget* widget; QWidget* widget;
public: public:
explicit ItemCreationDialog(QWidget *parent = nullptr); explicit ItemCreationDialog(QWidget *parent = nullptr);
~ItemCreationDialog(); ~ItemCreationDialog();
std::shared_ptr<Item> item; std::shared_ptr<Item> item;
private slots: private slots:
void itemTypeChanged(const QString& type); void itemTypeChanged(const QString& type);
void itemNameChanged(const QString& name); void itemNameChanged(const QString& name);
private: private:
Ui::ItemCreationDialog *ui; Ui::ItemCreationDialog *ui;
}; };
#endif // ITEMCREATIONDIALOG_H #endif // ITEMCREATIONDIALOG_H

66
src/ui/itemscrollbox.cpp
View file

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

21
src/ui/itemscrollbox.h
View file

@ -11,33 +11,34 @@
#include "../items/itemstore.h" #include "../items/itemstore.h"
namespace Ui { namespace Ui
{
class RelayScrollBox; class RelayScrollBox;
} }
class ItemScrollBox : public QWidget class ItemScrollBox : public QWidget
{ {
Q_OBJECT Q_OBJECT
private: private:
std::vector< ItemWidget* > widgets_; std::vector< ItemWidget* > widgets_;
signals: signals:
void deleteRequest(const ItemData& item); void deleteRequest(const ItemData& item);
public: public:
explicit ItemScrollBox(QWidget *parent = nullptr); explicit ItemScrollBox(QWidget *parent = nullptr);
~ItemScrollBox(); ~ItemScrollBox();
void setItemStore(ItemStore* itemStore); void setItemStore(ItemStore* itemStore);
public slots: public slots:
void addItem(std::weak_ptr<Item> item); void addItem(std::weak_ptr<Item> item);
void removeItem(const ItemData& item); void removeItem(const ItemData& item);
private: private:
Ui::RelayScrollBox *ui; Ui::RelayScrollBox *ui;
}; };
#endif // RELAYSCROLLBOX_H #endif // RELAYSCROLLBOX_H

254
src/ui/itemsettingsdialog.cpp
View file

@ -1,4 +1,4 @@
#include "itemsettingsdialog.h" #include "itemsettingsdialog.h"
#include "ui_itemsettingsdialog.h" #include "ui_itemsettingsdialog.h"
#include "actorsettingsdialog.h" #include "actorsettingsdialog.h"
#include "../actors/alarmtime.h" #include "../actors/alarmtime.h"
@ -14,174 +14,174 @@
#include<memory> #include<memory>
ItemSettingsDialog::ItemSettingsDialog(std::shared_ptr<Item> item, QWidget *parent) : ItemSettingsDialog::ItemSettingsDialog(std::shared_ptr<Item> item, QWidget *parent) :
QDialog(parent), QDialog(parent),
item_(item), item_(item),
ui(new Ui::ItemSettingsDialog) ui(new Ui::ItemSettingsDialog)
{ {
ui->setupUi(this); ui->setupUi(this);
setModal(false); setModal(false);
ui->label_name->setText(item_->getName()); ui->label_name->setText(item_->getName());
ui->checkBox_Override->setChecked(item_->getOverride()); ui->checkBox_Override->setChecked(item_->getOverride());
if(std::shared_ptr<Relay> relay = std::dynamic_pointer_cast<Relay>(item_)) if(std::shared_ptr<Relay> relay = std::dynamic_pointer_cast<Relay>(item_))
{ {
itemSpecificWidget_ = new RelayItemSettingsWidget(relay); itemSpecificWidget_ = new RelayItemSettingsWidget(relay);
} }
else if(std::shared_ptr<MessageItem> msgItem = std::dynamic_pointer_cast<MessageItem>(item_)) else if(std::shared_ptr<MessageItem> msgItem = std::dynamic_pointer_cast<MessageItem>(item_))
{ {
itemSpecificWidget_ = new MessageItemSettingsWidget(msgItem); itemSpecificWidget_ = new MessageItemSettingsWidget(msgItem);
} }
else if(std::shared_ptr<SystemItem> sysItem = std::dynamic_pointer_cast<SystemItem>(item_)) else if(std::shared_ptr<SystemItem> sysItem = std::dynamic_pointer_cast<SystemItem>(item_))
{ {
itemSpecificWidget_ = new SystemItemSettingsWidget(sysItem); itemSpecificWidget_ = new SystemItemSettingsWidget(sysItem);
} }
if(itemSpecificWidget_) if(itemSpecificWidget_)
{ {
ui->verticalLayout_2->addWidget(itemSpecificWidget_); ui->verticalLayout_2->addWidget(itemSpecificWidget_);
} }
connect(ui->pushButton_add, &QPushButton::clicked, this, &ItemSettingsDialog::addActor); connect(ui->pushButton_add, &QPushButton::clicked, this, &ItemSettingsDialog::addActor);
connect(ui->pushButton_remove, &QPushButton::clicked, this, &ItemSettingsDialog::removeActor); connect(ui->pushButton_remove, &QPushButton::clicked, this, &ItemSettingsDialog::removeActor);
connect(ui->pushButton_edit, &QPushButton::clicked, this, &ItemSettingsDialog::editActor); connect(ui->pushButton_edit, &QPushButton::clicked, this, &ItemSettingsDialog::editActor);
connect(ui->checkBox_Override, &QPushButton::clicked, this, &ItemSettingsDialog::changeOverride); connect(ui->checkBox_Override, &QPushButton::clicked, this, &ItemSettingsDialog::changeOverride);
ui->tableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem("Actor")); ui->tableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem("Actor"));
ui->tableWidget->setHorizontalHeaderItem(1, new QTableWidgetItem("Action")); ui->tableWidget->setHorizontalHeaderItem(1, new QTableWidgetItem("Action"));
ui->tableWidget->setHorizontalHeaderItem(2, new QTableWidgetItem("Enabled")); ui->tableWidget->setHorizontalHeaderItem(2, new QTableWidgetItem("Enabled"));
ui->tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch); ui->tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
ui->tableWidget->horizontalHeader()->resizeSection(1, 60); ui->tableWidget->horizontalHeader()->resizeSection(1, 60);
ui->tableWidget->horizontalHeader()->resizeSection(2, 75); ui->tableWidget->horizontalHeader()->resizeSection(2, 75);
loadActorList(); loadActorList();
} }
ItemSettingsDialog::~ItemSettingsDialog() ItemSettingsDialog::~ItemSettingsDialog()
{ {
if(itemSpecificWidget_) delete itemSpecificWidget_; if(itemSpecificWidget_) delete itemSpecificWidget_;
delete ui; delete ui;
} }
void ItemSettingsDialog::changeOverride() void ItemSettingsDialog::changeOverride()
{ {
item_->setOverride(ui->checkBox_Override->isChecked()); item_->setOverride(ui->checkBox_Override->isChecked());
} }
void ItemSettingsDialog::loadActorList() void ItemSettingsDialog::loadActorList()
{ {
//ui->listWidget->clear(); //ui->listWidget->clear();
ui->tableWidget->setRowCount(item_->getActors().size()); ui->tableWidget->setRowCount(item_->getActors().size());
for(unsigned i = 0; i < item_->getActors().size(); i++) for(unsigned i = 0; i < item_->getActors().size(); i++)
{ {
ui->tableWidget->setItem(i, 0, new QTableWidgetItem(item_->getActors()[i]->getName())); ui->tableWidget->setItem(i, 0, new QTableWidgetItem(item_->getActors()[i]->getName()));
ui->tableWidget->setItem(i, 1, new QTableWidgetItem(item_->getActors()[i]->actionName())); ui->tableWidget->setItem(i, 1, new QTableWidgetItem(item_->getActors()[i]->actionName()));
ui->tableWidget->setItem(i, 2, new QTableWidgetItem(item_->getActors()[i]->isActive() ? "Y" : "N")); ui->tableWidget->setItem(i, 2, new QTableWidgetItem(item_->getActors()[i]->isActive() ? "Y" : "N"));
} }
} }
void ItemSettingsDialog::addActor() void ItemSettingsDialog::addActor()
{ {
ActorSettingsDialog* dialog = nullptr; ActorSettingsDialog* dialog = nullptr;
std::shared_ptr<Actor> actor = nullptr; std::shared_ptr<Actor> actor = nullptr;
if(ui->comboBox->currentText() == "Alarm") if(ui->comboBox->currentText() == "Alarm")
{ {
std::shared_ptr<AlarmTime> alarm = std::shared_ptr<AlarmTime>(new AlarmTime); std::shared_ptr<AlarmTime> alarm = std::shared_ptr<AlarmTime>(new AlarmTime);
actor = alarm; actor = alarm;
dialog = new ActorSettingsDialog(alarm, this); dialog = new ActorSettingsDialog(alarm, this);
} }
else if(ui->comboBox->currentText() == "Sensor") else if(ui->comboBox->currentText() == "Sensor")
{ {
std::shared_ptr<SensorActor> sensorActor = std::shared_ptr<SensorActor>(new SensorActor); std::shared_ptr<SensorActor> sensorActor = std::shared_ptr<SensorActor>(new SensorActor);
actor = sensorActor; actor = sensorActor;
dialog = new ActorSettingsDialog(sensorActor, this); dialog = new ActorSettingsDialog(sensorActor, this);
} }
else if(ui->comboBox->currentText() == "Timer" ) else if(ui->comboBox->currentText() == "Timer" )
{ {
std::shared_ptr<TimerActor> timerActor = std::shared_ptr<TimerActor>(new TimerActor); std::shared_ptr<TimerActor> timerActor = std::shared_ptr<TimerActor>(new TimerActor);
actor = timerActor; actor = timerActor;
dialog = new ActorSettingsDialog(timerActor, this); dialog = new ActorSettingsDialog(timerActor, this);
} }
else if(ui->comboBox->currentText() == "Regulator") else if(ui->comboBox->currentText() == "Regulator")
{ {
std::shared_ptr<Regulator> regulator = std::shared_ptr<Regulator>(new Regulator); std::shared_ptr<Regulator> regulator = std::shared_ptr<Regulator>(new Regulator);
actor = regulator; actor = regulator;
dialog = new ActorSettingsDialog(regulator, this); dialog = new ActorSettingsDialog(regulator, this);
} }
else if(ui->comboBox->currentText() == "Polynomal") else if(ui->comboBox->currentText() == "Polynomal")
{ {
std::shared_ptr<PolynomalActor> polynomalActor = std::shared_ptr<PolynomalActor>(new PolynomalActor); std::shared_ptr<PolynomalActor> polynomalActor = std::shared_ptr<PolynomalActor>(new PolynomalActor);
actor = polynomalActor; actor = polynomalActor;
dialog = new ActorSettingsDialog(polynomalActor, this); dialog = new ActorSettingsDialog(polynomalActor, this);
} }
else if(ui->comboBox->currentText() == "Multi Factor") else if(ui->comboBox->currentText() == "Multi Factor")
{ {
std::shared_ptr<MultiFactorActor> polynomalActor = std::shared_ptr<MultiFactorActor>(new MultiFactorActor); std::shared_ptr<MultiFactorActor> polynomalActor = std::shared_ptr<MultiFactorActor>(new MultiFactorActor);
actor = polynomalActor; actor = polynomalActor;
dialog = new ActorSettingsDialog(polynomalActor, this); dialog = new ActorSettingsDialog(polynomalActor, this);
} }
if(dialog != nullptr) if(dialog != nullptr)
{ {
dialog->setParent(this); dialog->setParent(this);
dialog->show(); dialog->show();
if(dialog->exec() == QDialog::Accepted) if(dialog->exec() == QDialog::Accepted)
{ {
item_->addActor(actor); item_->addActor(actor);
loadActorList(); loadActorList();
} }
delete dialog; delete dialog;
} }
} }
void ItemSettingsDialog::removeActor() void ItemSettingsDialog::removeActor()
{ {
if(item_->getActors().size() > ui->tableWidget->currentRow()) if(item_->getActors().size() > ui->tableWidget->currentRow())
{ {
item_->removeActor(item_->getActors().at(ui->tableWidget->currentRow())); item_->removeActor(item_->getActors().at(ui->tableWidget->currentRow()));
loadActorList(); loadActorList();
} }
} }
void ItemSettingsDialog::editActor() void ItemSettingsDialog::editActor()
{ {
if(item_->getActors().size() > ui->tableWidget->currentRow()) if(item_->getActors().size() > ui->tableWidget->currentRow())
{ {
std::shared_ptr<Actor> actor = item_->getActors()[ui->tableWidget->currentRow()]; std::shared_ptr<Actor> actor = item_->getActors()[ui->tableWidget->currentRow()];
std::shared_ptr<AlarmTime> alarmTime = std::dynamic_pointer_cast<AlarmTime>(actor); std::shared_ptr<AlarmTime> alarmTime = std::dynamic_pointer_cast<AlarmTime>(actor);
std::shared_ptr<Regulator> regulator = std::dynamic_pointer_cast<Regulator>(actor); std::shared_ptr<Regulator> regulator = std::dynamic_pointer_cast<Regulator>(actor);
std::shared_ptr<SensorActor> sensorActor = std::dynamic_pointer_cast<SensorActor>(actor); std::shared_ptr<SensorActor> sensorActor = std::dynamic_pointer_cast<SensorActor>(actor);
std::shared_ptr<TimerActor> timerActor = std::dynamic_pointer_cast<TimerActor>(actor); std::shared_ptr<TimerActor> timerActor = std::dynamic_pointer_cast<TimerActor>(actor);
std::shared_ptr<PolynomalActor> polynomalActor = std::dynamic_pointer_cast<PolynomalActor>(actor); std::shared_ptr<PolynomalActor> polynomalActor = std::dynamic_pointer_cast<PolynomalActor>(actor);
std::shared_ptr<MultiFactorActor> factorActor = std::dynamic_pointer_cast<MultiFactorActor>(actor); std::shared_ptr<MultiFactorActor> factorActor = std::dynamic_pointer_cast<MultiFactorActor>(actor);
ActorSettingsDialog* dialog; ActorSettingsDialog* dialog;
if(alarmTime) dialog = new ActorSettingsDialog(alarmTime, this); if(alarmTime) dialog = new ActorSettingsDialog(alarmTime, this);
else if(regulator) dialog = new ActorSettingsDialog(regulator, this); else if(regulator) dialog = new ActorSettingsDialog(regulator, this);
else if(sensorActor) dialog = new ActorSettingsDialog(sensorActor, this); else if(sensorActor) dialog = new ActorSettingsDialog(sensorActor, this);
else if(timerActor) dialog = new ActorSettingsDialog(timerActor, this); else if(timerActor) dialog = new ActorSettingsDialog(timerActor, this);
else if(polynomalActor) dialog = new ActorSettingsDialog(polynomalActor, this); else if(polynomalActor) dialog = new ActorSettingsDialog(polynomalActor, this);
else if(factorActor) dialog = new ActorSettingsDialog(factorActor, this); else if(factorActor) dialog = new ActorSettingsDialog(factorActor, this);
else dialog = new ActorSettingsDialog(actor, this); else dialog = new ActorSettingsDialog(actor, this);
dialog->setParent(this); dialog->setParent(this);
dialog->show(); dialog->show();
dialog->exec(); dialog->exec();
for(int i = 0; i < ui->tableWidget->rowCount() && i < item_->getActors().size(); ++i) for(int i = 0; i < ui->tableWidget->rowCount() && i < item_->getActors().size(); ++i)
{ {
ui->tableWidget->item(i, 0)->setText(item_->getActors()[i]->getName()); ui->tableWidget->item(i, 0)->setText(item_->getActors()[i]->getName());
ui->tableWidget->item(i, 1)->setText(item_->getActors()[i]->actionName()); ui->tableWidget->item(i, 1)->setText(item_->getActors()[i]->actionName());
ui->tableWidget->item(i, 2)->setText(item_->getActors()[i]->isActive() ? "Y" : "N"); ui->tableWidget->item(i, 2)->setText(item_->getActors()[i]->isActive() ? "Y" : "N");
} }
} }
} }

25
src/ui/itemsettingsdialog.h
View file

@ -6,32 +6,33 @@
#include <memory> #include <memory>
#include "../items/relay.h" #include "../items/relay.h"
namespace Ui { namespace Ui
{
class ItemSettingsDialog; class ItemSettingsDialog;
} }
class ItemSettingsDialog : public QDialog class ItemSettingsDialog : public QDialog
{ {
Q_OBJECT Q_OBJECT
std::shared_ptr<Item> item_; std::shared_ptr<Item> item_;
QWidget* itemSpecificWidget_ = nullptr; QWidget* itemSpecificWidget_ = nullptr;
private: private:
void loadActorList(); void loadActorList();
public: public:
explicit ItemSettingsDialog(std::shared_ptr<Item> item, QWidget *parent = nullptr); explicit ItemSettingsDialog(std::shared_ptr<Item> item, QWidget *parent = nullptr);
~ItemSettingsDialog(); ~ItemSettingsDialog();
private slots: private slots:
void removeActor(); void removeActor();
void addActor(); void addActor();
void editActor(); void editActor();
void changeOverride(); void changeOverride();
private: private:
Ui::ItemSettingsDialog *ui; Ui::ItemSettingsDialog *ui;
}; };
#endif // RELAYSETTINGSDIALOG_H #endif // RELAYSETTINGSDIALOG_H

47
src/ui/itemsettingswidgets/messageitemsettingswidget.cpp
View file

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

17
src/ui/itemsettingswidgets/messageitemsettingswidget.h
View file

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

20
src/ui/itemsettingswidgets/relayitemsettingswidget.cpp
View file

@ -3,19 +3,19 @@
RelayItemSettingsWidget::RelayItemSettingsWidget(std::weak_ptr<Relay> relay, QWidget *parent) : RelayItemSettingsWidget::RelayItemSettingsWidget(std::weak_ptr<Relay> relay, QWidget *parent) :
QWidget(parent), QWidget(parent),
ui(new Ui::RelayItemSettingsWidget) ui(new Ui::RelayItemSettingsWidget)
{ {
ui->setupUi(this); ui->setupUi(this);
auto relayPtr = relay.lock(); auto relayPtr = relay.lock();
if(relayPtr) if(relayPtr)
{ {
ui->label_ID->setText(QString::number(relayPtr->getId())); ui->label_ID->setText(QString::number(relayPtr->getId()));
ui->label_Addr->setText(QString::number(relayPtr->getAddress(),2)); ui->label_Addr->setText(QString::number(relayPtr->getAddress(),2));
} }
} }
RelayItemSettingsWidget::~RelayItemSettingsWidget() RelayItemSettingsWidget::~RelayItemSettingsWidget()
{ {
delete ui; delete ui;
} }

11
src/ui/itemsettingswidgets/relayitemsettingswidget.h
View file

@ -5,20 +5,21 @@
#include <memory> #include <memory>
#include "../../items/relay.h" #include "../../items/relay.h"
namespace Ui { namespace Ui
{
class RelayItemSettingsWidget; class RelayItemSettingsWidget;
} }
class RelayItemSettingsWidget : public QWidget class RelayItemSettingsWidget : public QWidget
{ {
Q_OBJECT Q_OBJECT
public: public:
explicit RelayItemSettingsWidget(std::weak_ptr<Relay> relay, QWidget *parent = nullptr); explicit RelayItemSettingsWidget(std::weak_ptr<Relay> relay, QWidget *parent = nullptr);
~RelayItemSettingsWidget(); ~RelayItemSettingsWidget();
private: private:
Ui::RelayItemSettingsWidget *ui; Ui::RelayItemSettingsWidget *ui;
}; };
#endif // RELAYITEMSETTINGSWIDGET_H #endif // RELAYITEMSETTINGSWIDGET_H

42
src/ui/itemsettingswidgets/systemitemsettingswidget.cpp
View file

@ -2,39 +2,39 @@
#include "ui_systemitemsettingswidget.h" #include "ui_systemitemsettingswidget.h"
SystemItemSettingsWidget::SystemItemSettingsWidget(std::weak_ptr<SystemItem> item, QWidget *parent) : SystemItemSettingsWidget::SystemItemSettingsWidget(std::weak_ptr<SystemItem> item, QWidget *parent) :
QWidget(parent), QWidget(parent),
item_(item), item_(item),
ui(new Ui::SystemItemSettingsWidget) ui(new Ui::SystemItemSettingsWidget)
{ {
ui->setupUi(this); ui->setupUi(this);
if(auto itemPtr = item_.lock()) if(auto itemPtr = item_.lock())
{ {
ui->lineEdit_on->setText(itemPtr->getOnCommand()); ui->lineEdit_on->setText(itemPtr->getOnCommand());
ui->lineEdit_off->setText(itemPtr->getOffCommand()); ui->lineEdit_off->setText(itemPtr->getOffCommand());
} }
else setDisabled(true); else setDisabled(true);
connect(ui->lineEdit_on, &QLineEdit::textChanged, this, &SystemItemSettingsWidget::setOn); connect(ui->lineEdit_on, &QLineEdit::textChanged, this, &SystemItemSettingsWidget::setOn);
connect(ui->lineEdit_off, &QLineEdit::textChanged, this, &SystemItemSettingsWidget::setOff); connect(ui->lineEdit_off, &QLineEdit::textChanged, this, &SystemItemSettingsWidget::setOff);
} }
void SystemItemSettingsWidget::setOn(const QString& in) void SystemItemSettingsWidget::setOn(const QString& in)
{ {
if(auto itemPtr = item_.lock()) if(auto itemPtr = item_.lock())
{ {
itemPtr->setOnCommand(in); itemPtr->setOnCommand(in);
} }
} }
void SystemItemSettingsWidget::setOff(const QString& in) void SystemItemSettingsWidget::setOff(const QString& in)
{ {
if(auto itemPtr = item_.lock()) if(auto itemPtr = item_.lock())
{ {
itemPtr->setOffCommand(in); itemPtr->setOffCommand(in);
} }
} }
SystemItemSettingsWidget::~SystemItemSettingsWidget() SystemItemSettingsWidget::~SystemItemSettingsWidget()
{ {
delete ui; delete ui;
} }

17
src/ui/itemsettingswidgets/systemitemsettingswidget.h
View file

@ -5,26 +5,27 @@
#include <memory> #include <memory>
#include "../../items/systemitem.h" #include "../../items/systemitem.h"
namespace Ui { namespace Ui
{
class SystemItemSettingsWidget; class SystemItemSettingsWidget;
} }
class SystemItemSettingsWidget : public QWidget class SystemItemSettingsWidget : public QWidget
{ {
Q_OBJECT Q_OBJECT
std::weak_ptr<SystemItem> item_; std::weak_ptr<SystemItem> item_;
private slots: private slots:
void setOn(const QString &in); void setOn(const QString &in);
void setOff(const QString &in); void setOff(const QString &in);
public: public:
explicit SystemItemSettingsWidget(std::weak_ptr<SystemItem> item, QWidget *parent = nullptr); explicit SystemItemSettingsWidget(std::weak_ptr<SystemItem> item, QWidget *parent = nullptr);
~SystemItemSettingsWidget(); ~SystemItemSettingsWidget();
private: private:
Ui::SystemItemSettingsWidget *ui; Ui::SystemItemSettingsWidget *ui;
}; };
#endif // SYSTEMITEMSETTINGSWIDGET_H #endif // SYSTEMITEMSETTINGSWIDGET_H

118
src/ui/itemwidget.cpp
View file

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

31
src/ui/itemwidget.h
View file

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

92
src/ui/mainwindow.cpp
View file

@ -7,13 +7,13 @@
#include <QMessageBox> #include <QMessageBox>
MainWindow::MainWindow(MainObject * const mainObject, QWidget *parent) : MainWindow::MainWindow(MainObject * const mainObject, QWidget *parent) :
QMainWindow(parent), QMainWindow(parent),
ui(new Ui::MainWindow), ui(new Ui::MainWindow),
colorChooser(this), colorChooser(this),
_micro(&mainObject->micro), _micro(&mainObject->micro),
_powerItem(mainObject->powerItem) _powerItem(mainObject->powerItem)
{ {
ui->setupUi(this); ui->setupUi(this);
if(!mainObject->master) if(!mainObject->master)
{ {
@ -25,47 +25,47 @@ MainWindow::MainWindow(MainObject * const mainObject, QWidget *parent) :
connect(ui->pushButton_broadcast, &QPushButton::clicked, this, &MainWindow::saved); connect(ui->pushButton_broadcast, &QPushButton::clicked, this, &MainWindow::saved);
} }
connect(ui->pushButton_power, SIGNAL(clicked()), this, SLOT(showPowerItemDialog())); connect(ui->pushButton_power, SIGNAL(clicked()), this, SLOT(showPowerItemDialog()));
//Relays //Relays
if(mainObject->master)connect(ui->pushButton_refesh, &QPushButton::clicked, _micro, &Microcontroller::requestState); if(mainObject->master)connect(ui->pushButton_refesh, &QPushButton::clicked, _micro, &Microcontroller::requestState);
else else
{ {
connect(ui->pushButton_refesh, &QPushButton::clicked, &mainObject->broadCast, &BroadCast::requestJson); connect(ui->pushButton_refesh, &QPushButton::clicked, &mainObject->broadCast, &BroadCast::requestJson);
connect(ui->pushButton_refesh, &QPushButton::clicked, &mainObject->broadCast, &BroadCast::requestSensors); connect(ui->pushButton_refesh, &QPushButton::clicked, &mainObject->broadCast, &BroadCast::requestSensors);
} }
connect(&mainObject->items, &ItemStore::itemAdded, ui->relayList, &ItemScrollBox::addItem); connect(&mainObject->items, &ItemStore::itemAdded, ui->relayList, &ItemScrollBox::addItem);
connect(&mainObject->items, &ItemStore::itemDeleted, ui->relayList, &ItemScrollBox::removeItem); 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 < mainObject->items.getItems()->size(); ++i)
{ {
ui->relayList->addItem(mainObject->items.getItems()->at(i)); ui->relayList->addItem(mainObject->items.getItems()->at(i));
} }
//Sensors //Sensors
ui->sensorListView->setShowHidden(false); ui->sensorListView->setShowHidden(false);
ui->sensorListView->sensorsChanged(*globalSensors.getSensors()); ui->sensorListView->sensorsChanged(*globalSensors.getSensors());
connect(&globalSensors, &SensorStore::stateChenged, ui->sensorListView, &SensorListWidget::sensorsChanged); connect(&globalSensors, &SensorStore::stateChenged, ui->sensorListView, &SensorListWidget::sensorsChanged);
//RGB Leds //RGB Leds
connect(&colorChooser, SIGNAL(colorSelected(QColor)), this, SLOT(slotChangedRgb(QColor))); connect(&colorChooser, SIGNAL(colorSelected(QColor)), this, SLOT(slotChangedRgb(QColor)));
connect(ui->button_quit, SIGNAL(clicked()), this, SLOT(close())); connect(ui->button_quit, SIGNAL(clicked()), this, SLOT(close()));
connect(ui->button_color, SIGNAL(clicked()), &colorChooser, SLOT(show())); connect(ui->button_color, SIGNAL(clicked()), &colorChooser, SLOT(show()));
connect(ui->pushButton_addItem, &QPushButton::clicked, this, &MainWindow::showItemCreationDialog); connect(ui->pushButton_addItem, &QPushButton::clicked, this, &MainWindow::showItemCreationDialog);
connect(ui->relayList, &ItemScrollBox::deleteRequest, &mainObject->items, &ItemStore::removeItem); connect(ui->relayList, &ItemScrollBox::deleteRequest, &mainObject->items, &ItemStore::removeItem);
} }
MainWindow::~MainWindow() MainWindow::~MainWindow()
{ {
delete ui; delete ui;
} }
void MainWindow::showPowerItemDialog() void MainWindow::showPowerItemDialog()
{ {
ItemSettingsDialog diag(std::shared_ptr<Item>(_powerItem), this); ItemSettingsDialog diag(std::shared_ptr<Item>(_powerItem), this);
diag.show(); diag.show();
diag.exec(); diag.exec();
} }
void MainWindow::saved() void MainWindow::saved()
@ -75,25 +75,25 @@ void MainWindow::saved()
void MainWindow::slotChangedRgb(const QColor color) void MainWindow::slotChangedRgb(const QColor color)
{ {
_micro->changeRgbColor(color); _micro->changeRgbColor(color);
} }
void MainWindow::showItemCreationDialog() void MainWindow::showItemCreationDialog()
{ {
ItemCreationDialog diag(this); ItemCreationDialog diag(this);
diag.show(); diag.show();
if(diag.exec()) if(diag.exec())
{ {
createdItem(diag.item); createdItem(diag.item);
} }
} }
void MainWindow::changeHeaderLableText(QString string) void MainWindow::changeHeaderLableText(QString string)
{ {
if(string.size() > 28) if(string.size() > 28)
{ {
string.remove(28, string.size()-(28)); string.remove(28, string.size()-(28));
string.append("..."); string.append("...");
} }
ui->label_serialRecive->setText(string); ui->label_serialRecive->setText(string);
} }

26
src/ui/mainwindow.h
View file

@ -23,33 +23,33 @@ class MainWindow;
class MainWindow : public QMainWindow class MainWindow : public QMainWindow
{ {
Q_OBJECT Q_OBJECT
public: public:
explicit MainWindow(MainObject * const mainObject, QWidget *parent = nullptr); explicit MainWindow(MainObject * const mainObject, QWidget *parent = nullptr);
~MainWindow(); ~MainWindow();
private: private:
Ui::MainWindow *ui; Ui::MainWindow *ui;
QColorDialog colorChooser; QColorDialog colorChooser;
Microcontroller *_micro; Microcontroller *_micro;
std::shared_ptr<PowerItem> _powerItem; std::shared_ptr<PowerItem> _powerItem;
signals: signals:
void sigBrodcast(); void sigBrodcast();
void sigSave(); void sigSave();
void createdItem(std::shared_ptr<Item> item); void createdItem(std::shared_ptr<Item> item);
private slots: private slots:
//RGB //RGB
void slotChangedRgb(const QColor color); void slotChangedRgb(const QColor color);
void showPowerItemDialog(); void showPowerItemDialog();
void showItemCreationDialog(); void showItemCreationDialog();
void saved(); void saved();
public slots: public slots:

102
src/ui/sensorlistwidget.cpp
View file

@ -4,69 +4,71 @@
#include <QHeaderView> #include <QHeaderView>
#include <QScroller> #include <QScroller>
SensorListWidget::SensorListWidget(const bool showHidden, QWidget *parent): QTableWidget(parent), showHidden_(showHidden) SensorListWidget::SensorListWidget(const bool showHidden, QWidget *parent): QTableWidget(parent),
showHidden_(showHidden)
{ {
setColumnCount(2); setColumnCount(2);
setSelectionBehavior(QAbstractItemView::SelectRows); setSelectionBehavior(QAbstractItemView::SelectRows);
horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch); horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
QScroller::grabGesture(this, QScroller::LeftMouseButtonGesture); QScroller::grabGesture(this, QScroller::LeftMouseButtonGesture);
setAutoScroll(true); setAutoScroll(true);
setVerticalScrollMode(QAbstractItemView::ScrollPerPixel); setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
setHorizontalHeaderItem(0, new QTableWidgetItem("Sensor")); setHorizontalHeaderItem(0, new QTableWidgetItem("Sensor"));
setHorizontalHeaderItem(1, new QTableWidgetItem("Value")); setHorizontalHeaderItem(1, new QTableWidgetItem("Value"));
} }
SensorListWidget::SensorListWidget(SensorStore& sensorStore, const bool showHidden, QWidget* parent): QTableWidget (parent), showHidden_(showHidden) SensorListWidget::SensorListWidget(SensorStore& sensorStore, const bool showHidden,
QWidget* parent): QTableWidget (parent), showHidden_(showHidden)
{ {
sensorsChanged(*(sensorStore.getSensors())); sensorsChanged(*(sensorStore.getSensors()));
} }
void SensorListWidget::sensorsChanged(std::vector<Sensor> sensors) void SensorListWidget::sensorsChanged(std::vector<Sensor> sensors)
{ {
clear(); clear();
setHorizontalHeaderItem(0, new QTableWidgetItem("Sensor")); setHorizontalHeaderItem(0, new QTableWidgetItem("Sensor"));
setHorizontalHeaderItem(1, new QTableWidgetItem("Value")); setHorizontalHeaderItem(1, new QTableWidgetItem("Value"));
size_t nonHiddenCount = sensors.size(); size_t nonHiddenCount = sensors.size();
if(!showHidden_) if(!showHidden_)
{ {
nonHiddenCount = 0; nonHiddenCount = 0;
for(size_t i = 0; i < sensors.size(); ++i) for(size_t i = 0; i < sensors.size(); ++i)
{ {
if(!sensors[i].hidden) nonHiddenCount++; if(!sensors[i].hidden) nonHiddenCount++;
} }
} }
size_t listLen = 0; size_t listLen = 0;
for(size_t i = 0; i < sensors.size(); ++i) if(showHidden_ || !sensors[i].hidden) ++listLen; for(size_t i = 0; i < sensors.size(); ++i) if(showHidden_ || !sensors[i].hidden) ++listLen;
setRowCount(static_cast<int>(listLen)); setRowCount(static_cast<int>(listLen));
size_t row = 0; size_t row = 0;
for(size_t i = 0; i < sensors.size(); ++i) for(size_t i = 0; i < sensors.size(); ++i)
{ {
if(showHidden_ || !sensors[i].hidden) if(showHidden_ || !sensors[i].hidden)
{ {
QString itemString; QString itemString;
itemString.append(QString::number(sensors[i].field)); itemString.append(QString::number(sensors[i].field));
itemString.append(' '); itemString.append(' ');
if(sensors[i].type == Sensor::TYPE_DOOR) if(sensors[i].type == Sensor::TYPE_DOOR)
{ {
if(static_cast<bool>(sensors[i].field)) itemString.append("\"Open\""); if(static_cast<bool>(sensors[i].field)) itemString.append("\"Open\"");
else itemString.append("\"Closed\""); else itemString.append("\"Closed\"");
} }
else if(sensors[i].type == Sensor::TYPE_AUDIO_OUTPUT) else if(sensors[i].type == Sensor::TYPE_AUDIO_OUTPUT)
{ {
if(static_cast<bool>(sensors[i].field)) itemString.append("\"Playing\""); if(static_cast<bool>(sensors[i].field)) itemString.append("\"Playing\"");
else itemString.append("\"Silent\""); else itemString.append("\"Silent\"");
} }
setItem(static_cast<int>(row), 0, new QTableWidgetItem(sensors[i].name + (sensors[i].hidden ? "(H)" : ""))); setItem(static_cast<int>(row), 0, new QTableWidgetItem(sensors[i].name + (sensors[i].hidden ? "(H)" : "")));
setItem(static_cast<int>(row), 1, new QTableWidgetItem(itemString)); setItem(static_cast<int>(row), 1, new QTableWidgetItem(itemString));
++row; ++row;
} }
} }
} }
void SensorListWidget::setShowHidden(const bool showHidden) void SensorListWidget::setShowHidden(const bool showHidden)
{ {
showHidden_=showHidden; showHidden_=showHidden;
} }

14
src/ui/sensorlistwidget.h
View file

@ -5,19 +5,19 @@
class SensorListWidget : public QTableWidget class SensorListWidget : public QTableWidget
{ {
Q_OBJECT Q_OBJECT
bool showHidden_; bool showHidden_;
public: public:
SensorListWidget(const bool showHidden = true, QWidget *parent = nullptr); SensorListWidget(const bool showHidden = true, QWidget *parent = nullptr);
SensorListWidget(SensorStore& sensorStore, const bool showHidden = true, QWidget* parent = nullptr); SensorListWidget(SensorStore& sensorStore, const bool showHidden = true, QWidget* parent = nullptr);
virtual ~SensorListWidget(){} virtual ~SensorListWidget() {}
void setShowHidden(const bool showHidden); void setShowHidden(const bool showHidden);
public slots: public slots:
void sensorsChanged(std::vector<Sensor> sensors); void sensorsChanged(std::vector<Sensor> sensors);
}; };