small improvements to fan testing

lib/src/fan.h

@@ -43,7 +43,7 @@ public:
     void reset() Q_DECL_OVERRIDE;
 
     virtual int pwm() const { return 255; }
-    virtual void setPwm(int, bool) { }
+    virtual bool setPwm(int, bool) { return false; }
 
 
 signals:

lib/src/pwmfan.cpp

@@ -25,11 +25,11 @@
 
 #include "hwmon.h"
 
-#include <QTextStream>
-#include <QTimer>
-#include <QDir>
-#include <QFile>
-#include <QDebug>
+#include <QtCore/QTextStream>
+#include <QtCore/QTimer>
+#include <QtCore/QDir>
+#include <QtCore/QFile>
+#include <QtCore/QDebug>
 
 #include <KConfigCore/KConfigGroup>
 #include <KConfigCore/KSharedConfig>
@@ -42,10 +42,8 @@
 PwmFan::PwmFan(Hwmon *parent, uint index) : Fan(parent, index),
     m_pwmStream(new QTextStream),
     m_modeStream(new QTextStream),
-    m_testTimer(new QTimer(this)),
     m_temp(Q_NULLPTR),
     m_hasTemp(false),
-    m_testing(false),
     m_minTemp(0),
     m_maxTemp(100),
     m_minPwm(255),
@@ -53,10 +51,8 @@ PwmFan::PwmFan(Hwmon *parent, uint index) : Fan(parent, index),
     m_minStart(255),
     m_minStop(255),
     m_zeroRpm(0),
-    m_testStatus(notTesting)
+    m_testStatus(NotStarted)
 {
-    m_testTimer->setSingleShot(true);
-
     connect(this, SIGNAL(tempChanged()), parent, SLOT(updateConfig()));
     connect(this, SIGNAL(hasTempChanged()), parent, SLOT(updateConfig()));
     connect(this, SIGNAL(minTempChanged()), parent, SLOT(updateConfig()));
@@ -65,7 +61,6 @@ PwmFan::PwmFan(Hwmon *parent, uint index) : Fan(parent, index),
     connect(this, SIGNAL(maxPwmChanged()), parent, SLOT(updateConfig()));
     connect(this, SIGNAL(minStartChanged()), parent, SLOT(updateConfig()));
     connect(this, SIGNAL(minStopChanged()), parent, SLOT(updateConfig()));
-    connect(m_testTimer, SIGNAL(timeout()), this, SLOT(continueTest()));
 
     if (QDir(parent->path()).isReadable())
     {
@@ -157,7 +152,7 @@ void PwmFan::reset()
             qDebug() << "Can't open pwmModeFile " << pwmModeFile->fileName();
 }
 
-void PwmFan::setPwm(int pwm, bool write)
+bool PwmFan::setPwm(int pwm, bool write)
 {
     if (m_pwm != pwm)
     {
@@ -172,6 +167,12 @@ void PwmFan::setPwm(int pwm, bool write)
             {
                 KAuth::Action action("fancontrol.gui.helper.action");
                 action.setHelperId("fancontrol.gui.helper");
+                if (!action.isValid())
+                {
+                    qDebug() << "setPwm action is invalid";
+                    return false;
+                }
+                
                 QVariantMap map;
                 map["action"] = "write";
                 map["filename"] = qobject_cast<QFile *>(m_pwmStream->device())->fileName();
@@ -180,13 +181,17 @@ void PwmFan::setPwm(int pwm, bool write)
                 KAuth::ExecuteJob *reply = action.execute();
 
                 if (!reply->exec())
-                    qDebug() << reply->errorString() << reply->errorText();
+                {
+                    qDebug() << "setPwm error:" << reply->errorString() << reply->errorText();
+                    return false;
+                }
             }
         }
     }
+    return true;
 }
 
-void PwmFan::setPwmMode(int pwmMode, bool write)
+bool PwmFan::setPwmMode(int pwmMode, bool write)
 {
     if (m_pwmMode != pwmMode)
     {
@@ -197,10 +202,17 @@ void PwmFan::setPwmMode(int pwmMode, bool write)
         {
             if (m_modeStream->device()->isWritable())
                 *m_modeStream << pwmMode;
+
             else
             {
                 KAuth::Action action("fancontrol.gui.helper.action");
                 action.setHelperId("fancontrol.gui.helper");
+                if (!action.isValid())
+                {
+                    qDebug() << "setPwmMode action is invalid";
+                    return false;
+                }
+                
                 QVariantMap map;
                 map["action"] = "write";
                 map["filename"] = qobject_cast<QFile *>(m_modeStream->device())->fileName();
@@ -209,31 +221,41 @@ void PwmFan::setPwmMode(int pwmMode, bool write)
                 KAuth::ExecuteJob *reply = action.execute();
 
                 if (!reply->exec())
-                    qDebug() << reply->errorString() << reply->errorText();
+                {
+                    qDebug() << "setPwmMode error:" << reply->errorString() << reply->errorText();
+                    return false;
+                }
             }
         }
     }
+    return true;
 }
 
-void PwmFan::test()
+bool PwmFan::test()
 {
-    m_testing = true;
-    emit testingChanged();
-
-    m_testStatus = findingStop1;
-    setPwmMode(1);
-    setPwm(255);
-    m_testTimer->setInterval(500);
-    m_testTimer->start();
-    qDebug() << "Start testing...";
+    if (setPwmMode(1) && setPwm(255))
+    {
+        m_testStatus = FindingStop1;
+        emit testingChanged();
+        
+        QTimer::singleShot(500, this, SLOT(continueTest()));
+        qDebug() << "Start testing...";
+    }
+    else
+    {
+        qDebug() << "Testing failed";
+        return false;
+    }
+    
+    return true;
 }
 
 void PwmFan::abortTest()
 {
     setPwm(255);
-    m_testTimer->stop();
+    disconnect(0, 0, this, SLOT(continueTest()));
 
-    m_testing = false;
+    m_testStatus = Cancelled;
     emit testingChanged();
 }
 
@@ -242,7 +264,7 @@ void PwmFan::continueTest()
     update();
     switch (m_testStatus)
     {
-    case findingStop1:
+    case FindingStop1:
         if (m_rpm > 0)
         {
             setPwm(qMin(m_pwm * 0.95, m_pwm - 5.0));
@@ -256,74 +278,60 @@ void PwmFan::continueTest()
             }
             else
             {
-                m_testStatus = findingStart;
+                m_testStatus = FindingStart;
                 m_zeroRpm = 0;
-                m_testTimer->setInterval(500);
                 qDebug() << "Start finding start value...";
             }
         }
-        m_testTimer->start();
+        QTimer::singleShot(500, this, SLOT(continueTest()));
         break;
 
-    case findingStart:
+    case FindingStart:
         if (m_rpm == 0)
             setPwm(m_pwm + 2);
         else
         {
-            m_testStatus = findingStop2;
-            m_testTimer->setInterval(1000);
+            m_testStatus = FindingStop2;
             setMinStart(m_pwm);
             qDebug() << "Start finding stop value...";
         }
-        m_testTimer->start();
+        QTimer::singleShot(1000, this, SLOT(continueTest()));
         break;
 
-    case findingStop2:
+    case FindingStop2:
         if (m_rpm > 0)
         {
             setPwm(m_pwm - 1);
             m_zeroRpm = 0;
-            m_testTimer->start();
+            QTimer::singleShot(1000, this, SLOT(continueTest()));
         }
         else
         {
             if (m_zeroRpm < MAX_ERRORS_FOR_RPM_ZERO)
             {
                 m_zeroRpm++;
-                m_testTimer->start();
+                QTimer::singleShot(500, this, SLOT(continueTest()));
             }
             else
             {
-                m_testStatus = notTesting;
-                m_zeroRpm = 0;
-                m_testing = false;
+                m_testStatus = Finished;
                 emit testingChanged();
+                m_zeroRpm = 0;
                 setMinStop(m_pwm + 5);
                 qDebug() << "Finished testing!";
             }
         }
         break;
 
-    case notTesting:
-        m_testing = false;
-        emit testingChanged();
-        break;
-
     default:
         break;
     }
 }
 
-// void PwmFan::reset()
-// {
-//     setTemp(Q_NULLPTR);
-//     setMinTemp(0);
-//     setMaxTemp(100);
-//     setMinPwm(255);
-//     setMaxPwm(255);
-//     setMinStart(255);
-//     setMinStop(255);
-// }
+bool PwmFan::testing() const
+{
+    return m_testStatus == FindingStop1 || m_testStatus == FindingStop2 || m_testStatus == FindingStart;
+}
 
 bool PwmFan::active() const
 {

lib/src/pwmfan.h

@@ -29,7 +29,6 @@
 #include "fan.h"
 
 
-class QTimer;
 class QTextStream;
 
 class PwmFan : public Fan
@@ -64,8 +63,8 @@ public:
     int minStop() const { return m_minStop; }
     int pwmMode() const { return m_pwmMode; }
     bool active() const;
-    bool testing() const { return m_testing; }
-    void setPwm(int pwm, bool write = true);
+    bool testing() const;
+    bool setPwm(int pwm, bool write = true);
     void setTemp(Temp *temp) { setHasTemp(temp != Q_NULLPTR); if (temp != m_temp) { m_temp = temp; emit tempChanged(); } }
     void setHasTemp(bool hasTemp) { if (hasTemp != m_hasTemp) { m_hasTemp = hasTemp; emit hasTempChanged(); } }
     void setMinTemp(int minTemp) { if (minTemp != m_minTemp) { m_minTemp = minTemp; emit minTempChanged(); } }
@@ -74,10 +73,10 @@ public:
     void setMaxPwm(int maxPwm) { if (maxPwm != m_maxPwm) { m_maxPwm = maxPwm; emit maxPwmChanged(); } }
     void setMinStart(int minStart) { if (minStart != m_minStart) { m_minStart = minStart; emit minStartChanged(); } }
     void setMinStop(int minStop) { if (minStop != m_minStop) { m_minStop = minStop; emit minStopChanged(); } }
-    void setPwmMode(int pwmMode, bool write = true);
+    bool setPwmMode(int pwmMode, bool write = true);
     void setActive(bool active);
     void reset() Q_DECL_OVERRIDE;
-    Q_INVOKABLE void test();
+    Q_INVOKABLE bool test();
     Q_INVOKABLE void abortTest();
 
 
@@ -101,6 +100,8 @@ protected slots:
 
     void update();
     void continueTest();
+//     void handlePwmActionReply();
+//     void handlePwmModeActionReply();
 
 
 private:
@@ -108,10 +109,8 @@ private:
     int m_pwm;
     QTextStream *m_pwmStream;
     QTextStream *m_modeStream;
-    QTimer *m_testTimer;
     Temp *m_temp;
     bool m_hasTemp;
-    bool m_testing;
     int m_minTemp;
     int m_maxTemp;
     int m_minPwm;
@@ -123,10 +122,13 @@ private:
 
     enum
     {
-        findingStop1,
-        findingStop2,
-        findingStart,
-        notTesting
+        NotStarted,
+        FindingStop1,
+        FindingStop2,
+        FindingStart,
+        Finished,
+        Cancelled,
+        Error
     } m_testStatus;
 };
 #endif // PWMFAN_H

package/contents/ui/PwmFan.qml

@@ -379,8 +379,10 @@ Rectangle {
                     } else {
                         reactivateAfterTesting = systemdCom.serviceActive;
                         systemdCom.serviceActive = false;
-                        minStartInput.value = Qt.binding(function() { return fan.minStart });
-                        fan.test();
+                        minStartInput.value = Qt.binding(function() { return Math.round(fan.minStart / 2.55) });
+                        if (!fan.test()) {
+                            systemdCom.serviceActive = reactivateAfterTesting;
+                        }
                     }
                 }