Add QCBD::BitRateKey support for the TinyCan plugin

Change-Id: Ie457ce2e2ab5375e63f4b392f0eac0758d7d6601
Reviewed-by: Alex Blasche <alexander.blasche@theqtcompany.com>

2 files changed, 88 insertions, 9 deletions

diff --git a/src/plugins/canbus/tinycan/tinycanbackend.cpp b/src/plugins/canbus/tinycan/tinycanbackend.cpp
index 2714bc8..079e078 100644
--- a/src/plugins/canbus/tinycan/tinycanbackend.cpp
+++ b/src/plugins/canbus/tinycan/tinycanbackend.cpp
@@ -46,6 +46,8 @@
 #include <QtCore/qmutex.h>
 #include <QtCore/qcoreevent.h>
 
+#include <algorithm>
+
 QT_BEGIN_NAMESPACE
 
 #ifndef LINK_LIBMHSTCAN
@@ -128,14 +130,44 @@ TinyCanBackendPrivate::~TinyCanBackendPrivate()
     qChannels()->removeAll(this);
 }
 
-bool TinyCanBackendPrivate::open()
+struct BitrateItem
 {
-    Q_Q(TinyCanBackend);
+    int bitrate;
+    int code;
+};
 
-    if (int ret = ::CanSetSpeed(channelIndex, CAN_500K_BIT) < 0) {
-        q->setError(systemErrorString(ret), QCanBusDevice::CanBusError::ConnectionError);
-        return false;
+struct BitrateLessFunctor
+{
+    bool operator()( const BitrateItem &item1, const BitrateItem &item2) const
+    {
+        return item1.bitrate < item2.bitrate;
     }
+};
+
+static int bitrateCodeFromBitrate(int bitrate)
+{
+    static const BitrateItem bitratetable[] = {
+        { 10000, CAN_10K_BIT },
+        { 20000, CAN_20K_BIT },
+        { 50000, CAN_50K_BIT },
+        { 100000, CAN_100K_BIT },
+        { 125000, CAN_125K_BIT },
+        { 250000, CAN_250K_BIT },
+        { 500000, CAN_500K_BIT },
+        { 800000, CAN_800K_BIT },
+        { 1000000, CAN_1M_BIT }
+    };
+
+    static const BitrateItem *endtable = bitratetable + (sizeof(bitratetable) / sizeof(*bitratetable));
+
+    const BitrateItem item = { bitrate , 0 };
+    const BitrateItem *where = std::lower_bound(bitratetable, endtable, item, BitrateLessFunctor());
+    return where != endtable ? where->code : -1;
+}
+
+bool TinyCanBackendPrivate::open()
+{
+    Q_Q(TinyCanBackend);
 
     char options[] = "AutoConnect=1;AutoReopen=0";
     if (int ret = ::CanSetOptions(options) < 0) {
@@ -168,13 +200,17 @@ void TinyCanBackendPrivate::close()
     isOpen = false;
 }
 
-// TODO: Implement me
 bool TinyCanBackendPrivate::setConfigurationParameter(int key, const QVariant &value)
 {
-    Q_UNUSED(key);
-    Q_UNUSED(value);
+    Q_Q(TinyCanBackend);
 
-    return false;
+    switch (key) {
+    case QCanBusDevice::BitRateKey:
+        return setBitRate(value.toInt());
+    default:
+        q->setError(TinyCanBackend::tr("Unsuported configuration key"), QCanBusDevice::ConfigurationError);
+        return false;
+    }
 }
 
 // These error codes taked from the errors.h file, which
@@ -263,6 +299,14 @@ void TinyCanBackendPrivate::setupChannel(const QString &interfaceName)
     channelIndex = channelIndexFromName(interfaceName);
 }
 
+// Calls only in constructor
+void TinyCanBackendPrivate::setupDefaultConfigurations()
+{
+    Q_Q(TinyCanBackend);
+
+    q->setConfigurationParameter(QCanBusDevice::BitRateKey, 500000);
+}
+
 void TinyCanBackendPrivate::enableWriteNotification(bool enable)
 {
     Q_Q(TinyCanBackend);
@@ -411,6 +455,27 @@ void TinyCanBackendPrivate::cleanupDriver()
     }
 }
 
+bool TinyCanBackendPrivate::setBitRate(int bitrate)
+{
+    Q_Q(TinyCanBackend);
+
+    const int bitrateCode = bitrateCodeFromBitrate(bitrate);
+    if (bitrateCode == -1) {
+        q->setError(TinyCanBackend::tr("Unsupported bitrate value"),
+                    QCanBusDevice::ConfigurationError);
+        return false;
+    }
+
+    if (isOpen) {
+        if (int ret = ::CanSetSpeed(channelIndex, bitrateCode) < 0) {
+            q->setError(systemErrorString(ret), QCanBusDevice::CanBusError::ConfigurationError);
+            return false;
+        }
+    }
+
+    return true;
+}
+
 TinyCanBackend::TinyCanBackend(const QString &name, QObject *parent)
     : QCanBusDevice(parent)
     , d_ptr(new TinyCanBackendPrivate(this))
@@ -418,6 +483,7 @@ TinyCanBackend::TinyCanBackend(const QString &name, QObject *parent)
     Q_D(TinyCanBackend);
 
     d->setupChannel(name);
+    d->setupDefaultConfigurations();
 }
 
 TinyCanBackend::~TinyCanBackend()
@@ -435,6 +501,16 @@ bool TinyCanBackend::open()
             close(); // sets UnconnectedState
             return false;
         }
+
+        // apply all stored configurations
+        foreach (int key, configurationKeys()) {
+            const QVariant param = configurationParameter(key);
+            const bool success = d->setConfigurationParameter(key, param);
+            if (!success) {
+                qWarning() << "Cannot apply parameter:" << key
+                           << "with value:" << param;
+            }
+        }
     }
 
     setState(QCanBusDevice::ConnectedState);
diff --git a/src/plugins/canbus/tinycan/tinycanbackend_p.h b/src/plugins/canbus/tinycan/tinycanbackend_p.h
index e754b13..bd17c62 100644
--- a/src/plugins/canbus/tinycan/tinycanbackend_p.h
+++ b/src/plugins/canbus/tinycan/tinycanbackend_p.h
@@ -69,6 +69,7 @@ public:
 
     QString systemErrorString(int errorCode);
     void setupChannel(const QString &interfaceName);
+    void setupDefaultConfigurations();
     void enableWriteNotification(bool enable);
     void canWriteNotification();
     bool enableReadNotification();
@@ -76,6 +77,8 @@ public:
     void startupDriver();
     void cleanupDriver();
 
+    bool setBitRate(int bitrate);
+
     TinyCanBackend * const q_ptr;
     bool isOpen;
     int channelIndex;