Merge remote-tracking branch 'origin/5.8' into dev

Change-Id: Iab1b4ac1c44d161a91f7f51cd0da4fc4a674964d

12 files changed, 86 insertions, 45 deletions

diff --git a/src/plugins/canbus/peakcan/main.cpp b/src/plugins/canbus/peakcan/main.cpp
index 6606cc2..d4886a9 100644
--- a/src/plugins/canbus/peakcan/main.cpp
+++ b/src/plugins/canbus/peakcan/main.cpp
@@ -55,7 +55,7 @@ public:
     {
         QString errorReason;
         if (!PeakCanBackend::canCreate(&errorReason)) {
-            qWarning("%s", qPrintable(errorReason));
+            qWarning("%s", qUtf8Printable(errorReason));
             if (errorMessage)
                 *errorMessage = errorReason;
             return nullptr;
diff --git a/src/plugins/canbus/peakcan/peakcanbackend.cpp b/src/plugins/canbus/peakcan/peakcanbackend.cpp
index 7959cc0..68091e1 100644
--- a/src/plugins/canbus/peakcan/peakcanbackend.cpp
+++ b/src/plugins/canbus/peakcan/peakcanbackend.cpp
@@ -65,7 +65,7 @@ bool PeakCanBackend::canCreate(QString *errorReason)
 #else
     static bool symbolsResolved = resolveSymbols(pcanLibrary());
     if (!symbolsResolved) {
-        *errorReason = tr("The PCAN runtime library is not found");
+        *errorReason = pcanLibrary()->errorString();
         return false;
     }
     return true;
@@ -398,17 +398,19 @@ void PeakCanBackendPrivate::startRead()
 
         const TPCANStatus st = ::CAN_Read(channelIndex, &message, &timestamp);
         if (st != PCAN_ERROR_OK) {
-            if (st != PCAN_ERROR_XMTFULL)
+            if (st != PCAN_ERROR_QRCVEMPTY)
                 q->setError(systemErrorString(st), QCanBusDevice::ReadError);
             break;
         }
 
         QCanBusFrame frame(message.ID, QByteArray(reinterpret_cast<const char *>(message.DATA), int(message.LEN)));
-        frame.setTimeStamp(QCanBusFrame::TimeStamp(timestamp.millis / 1000, timestamp.micros));
+        const quint64 millis = timestamp.millis + Q_UINT64_C(0xFFFFFFFF) * timestamp.millis_overflow;
+        const quint64 micros = Q_UINT64_C(1000) * millis + timestamp.micros;
+        frame.setTimeStamp(QCanBusFrame::TimeStamp::fromMicroSeconds(micros));
         frame.setExtendedFrameFormat(message.MSGTYPE & PCAN_MESSAGE_EXTENDED);
         frame.setFrameType((message.MSGTYPE & PCAN_MESSAGE_RTR) ? QCanBusFrame::RemoteRequestFrame : QCanBusFrame::DataFrame);
 
-        newFrames.append(frame);
+        newFrames.append(std::move(frame));
     }
 
     q->enqueueReceivedFrames(newFrames);
diff --git a/src/plugins/canbus/socketcan/socketcanbackend.cpp b/src/plugins/canbus/socketcan/socketcanbackend.cpp
index 7580c60..c9781d1 100644
--- a/src/plugins/canbus/socketcan/socketcanbackend.cpp
+++ b/src/plugins/canbus/socketcan/socketcanbackend.cpp
@@ -35,7 +35,6 @@
 ****************************************************************************/
 
 #include "socketcanbackend.h"
-#include <QtSerialBus/qcanbusdevice.h>
 
 #include <QtCore/qdebug.h>
 #include <QtCore/qdatastream.h>
@@ -266,7 +265,7 @@ bool SocketCanBackend::connectSocket()
         return false;
     }
 
-    strcpy(interface.ifr_name, canSocketName.toLatin1().data());
+    qstrncpy(interface.ifr_name, canSocketName.toLatin1().constData(), sizeof(interface.ifr_name));
     if (ioctl(canSocket, SIOCGIFINDEX, &interface) < 0) {
         setError(qt_error_string(errno),
                  QCanBusDevice::CanBusError::ConnectionError);
@@ -595,8 +594,7 @@ void SocketCanBackend::readSocket()
         if (ioctl(canSocket, SIOCGSTAMP, &timeStamp) < 0) {
             setError(qt_error_string(errno),
                      QCanBusDevice::CanBusError::ReadError);
-            timeStamp.tv_sec = 0;
-            timeStamp.tv_usec = 0;
+            memset(&timeStamp, 0, sizeof(timeStamp));
         }
 
         const QCanBusFrame::TimeStamp stamp(timeStamp.tv_sec, timeStamp.tv_usec);
@@ -613,10 +611,10 @@ void SocketCanBackend::readSocket()
 
         bufferedFrame.setFrameId(frame.can_id & CAN_EFF_MASK);
 
-        QByteArray load(reinterpret_cast<char *>(frame.data), frame.len);
+        const QByteArray load(reinterpret_cast<char *>(frame.data), frame.len);
         bufferedFrame.setPayload(load);
 
-        newFrames.append(bufferedFrame);
+        newFrames.append(std::move(bufferedFrame));
     }
 
     enqueueReceivedFrames(newFrames);
diff --git a/src/plugins/canbus/tinycan/main.cpp b/src/plugins/canbus/tinycan/main.cpp
index 65a4784..5bce912 100644
--- a/src/plugins/canbus/tinycan/main.cpp
+++ b/src/plugins/canbus/tinycan/main.cpp
@@ -55,7 +55,7 @@ public:
     {
         QString errorReason;
         if (!TinyCanBackend::canCreate(&errorReason)) {
-            qWarning("%s", qPrintable(errorReason));
+            qWarning("%s", qUtf8Printable(errorReason));
             if (errorMessage)
                 *errorMessage = errorReason;
             return nullptr;
diff --git a/src/plugins/canbus/tinycan/tinycanbackend.cpp b/src/plugins/canbus/tinycan/tinycanbackend.cpp
index ee2b347..0961813 100644
--- a/src/plugins/canbus/tinycan/tinycanbackend.cpp
+++ b/src/plugins/canbus/tinycan/tinycanbackend.cpp
@@ -61,7 +61,7 @@ bool TinyCanBackend::canCreate(QString *errorReason)
 #else
     static bool symbolsResolved = resolveSymbols(mhstcanLibrary());
     if (!symbolsResolved) {
-        *errorReason = tr("The MHSTCAN runtime library is not found");
+        *errorReason = mhstcanLibrary()->errorString();
         return false;
     }
     return true;
@@ -411,7 +411,7 @@ void TinyCanBackendPrivate::startRead()
         else
             frame.setFrameType(QCanBusFrame::DataFrame);
 
-        newFrames.append(frame);
+        newFrames.append(std::move(frame));
     }
 
     q->enqueueReceivedFrames(newFrames);
diff --git a/src/plugins/canbus/vectorcan/vectorcanbackend.cpp b/src/plugins/canbus/vectorcan/vectorcanbackend.cpp
index c178b50..005b726 100644
--- a/src/plugins/canbus/vectorcan/vectorcanbackend.cpp
+++ b/src/plugins/canbus/vectorcan/vectorcanbackend.cpp
@@ -324,8 +324,7 @@ void VectorCanBackendPrivate::startRead()
 
         QCanBusFrame frame(msg.id, QByteArray(reinterpret_cast<const char *>(msg.data),
                                               int(msg.dlc)));
-        const quint64 usecs = event.timeStamp / 1000;
-        frame.setTimeStamp(QCanBusFrame::TimeStamp(usecs / 1000000, usecs % 1000000));
+        frame.setTimeStamp(QCanBusFrame::TimeStamp::fromMicroSeconds(event.timeStamp / 1000));
         frame.setExtendedFrameFormat(msg.id & XL_CAN_EXT_MSG_ID);
         frame.setFrameType((msg.flags & XL_CAN_MSG_FLAG_REMOTE_FRAME)
                            ? QCanBusFrame::RemoteRequestFrame
@@ -333,7 +332,7 @@ void VectorCanBackendPrivate::startRead()
                              ? QCanBusFrame::ErrorFrame
                              : QCanBusFrame::DataFrame);
 
-        newFrames.append(frame);
+        newFrames.append(std::move(frame));
     }
 
     q->enqueueReceivedFrames(newFrames);
diff --git a/src/serialbus/doc/qtserialbus.qdocconf b/src/serialbus/doc/qtserialbus.qdocconf
index c84064c..d80d953 100644
--- a/src/serialbus/doc/qtserialbus.qdocconf
+++ b/src/serialbus/doc/qtserialbus.qdocconf
@@ -43,3 +43,4 @@ imagedirs   += images
 
 navigation.landingpage = "Qt Serial Bus"
 navigation.cppclassespage = "Qt Serial Bus C++ Classes"
+navigation.homepage       = "Qt Documentation (Technology Preview)"
diff --git a/src/serialbus/doc/src/qtserialbus-index.qdoc b/src/serialbus/doc/src/qtserialbus-index.qdoc
index c5136d4..790341f 100644
--- a/src/serialbus/doc/src/qtserialbus-index.qdoc
+++ b/src/serialbus/doc/src/qtserialbus-index.qdoc
@@ -33,7 +33,6 @@
 
     The Qt Serial Bus API provides classes and functions to access the various
     industrial serial buses and protocols, such as CAN, ModBus, and others.
-    This module is currently released as a \b {Technology Preview}.
 
     \section1 Getting Started
 
diff --git a/src/serialbus/doc/src/socketcan.qdoc b/src/serialbus/doc/src/socketcan.qdoc
index 1b1f959..b92be97 100644
--- a/src/serialbus/doc/src/socketcan.qdoc
+++ b/src/serialbus/doc/src/socketcan.qdoc
@@ -34,6 +34,51 @@
     This API is a set of open source CAN drivers and a networking stack contributed by
     Volkswagen Research to the Linux kernel.
 
+    \section1 SocketCAN usage
+
+    To list all (including unconfigured) network interfaces, the command
+    \c{ifconfig -a} can be used.
+
+    To use SocketCAN, the corresponding Linux Kernel modules must be loaded
+    and the network interface must be configured.
+
+    \section2 Setting up real CAN hardware
+
+    This section assumes, that the device driver is already loaded
+    (most likely automatically when connecting the CAN hardware).
+
+    To set the device can0 to a bitrate of 250 kBit/s:
+    \code
+        sudo ip link set can0 type can bitrate 250000
+        sudo ip link set up can0
+    \endcode
+
+    \section2 Setting up a virtual CAN bus
+
+    \note For CAN FD usage, the MTU (Maximum Transmission Unit) has to be set
+    to 72 byte.
+
+    \code
+        sudo modprobe vcan
+        sudo ip link add dev vcan0 type vcan
+        sudo ip link set vcan0 mtu 72
+        sudo ip link set up vcan0
+    \endcode
+
+    The command line test programs used in the following are from
+    the \l{https://github.com/linux-can/can-utils}{can-utils} package:
+
+    \code
+        # Display received CAN messages
+        candump vcan0
+
+        # Send a CAN message
+        cansend vcan0 123##3112233445566778899aabbccddeeff
+
+        # Generate random CAN messages
+        cangen vcan0
+    \endcode
+
     \section1 Creating CAN Bus Devices
 
     At first it is necessary to check that QCanBus provides the desired backend:
diff --git a/src/serialbus/qcanbusdevice.h b/src/serialbus/qcanbusdevice.h
index 973619b..6a015af 100644
--- a/src/serialbus/qcanbusdevice.h
+++ b/src/serialbus/qcanbusdevice.h
@@ -97,8 +97,7 @@ public:
 
     explicit QCanBusDevice(QObject *parent = nullptr);
 
-    virtual void setConfigurationParameter(int key,
-                                           const QVariant &value);
+    virtual void setConfigurationParameter(int key, const QVariant &value);
     QVariant configurationParameter(int key) const;
     QVector<int> configurationKeys() const;
 
diff --git a/src/serialbus/qcanbusframe.cpp b/src/serialbus/qcanbusframe.cpp
index da8a595..34a6aa9 100644
--- a/src/serialbus/qcanbusframe.cpp
+++ b/src/serialbus/qcanbusframe.cpp
@@ -54,13 +54,15 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn QCanBusFrame::QCanBusFrame(QCanBusFrame::FrameType type)
+    \fn QCanBusFrame::QCanBusFrame(QCanBusFrame::FrameType type = DataFrame)
+    \since 5.8
 
     Constructs a CAN frame of the specified \a type.
 */
 
 /*!
     \fn QCanBusFrame::QCanBusFrame(quint32 identifier, const QByteArray &data)
+    \since 5.8
 
     Constructs a CAN frame using \a identifier as the frame identifier and \a data as the payload.
 */
@@ -108,7 +110,8 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn QCanBusFrame::setTimeStamp(const TimeStamp &ts)
+    \fn QCanBusFrame::setTimeStamp(TimeStamp ts)
+    \since 5.8
 
     Sets \a ts as the timestamp for the CAN frame. Usually, this function is not needed, because the
     timestamp is created during the read operation and not needed during the write operation.
@@ -243,38 +246,31 @@ QT_BEGIN_NAMESPACE
     \fn TimeStamp::TimeStamp(qint64 s, qint64 usec)
 
     Constructs a TimeStamp in seconds, \a s, and microseconds, \a usec.
-*/
-
-/*!
-    \fn qint64 TimeStamp::seconds() const
-
-    Returns the seconds of the timestamp.
 
-    \sa TimeStamp::setSeconds()
+    \note The TimeStamp is not normalized, i.e. microseconds greater 1000000 are not
+    converted to seconds.
 */
 
 /*!
-    \fn qint64 TimeStamp::microSeconds() const
+    \fn static TimeStamp TimeStamp::fromMicroSeconds(qint64 usec)
+    \since 5.8
 
-    Returns the microseconds of the timestamp.
+    Constructs a normalized TimeStamp from microseconds \a usec.
 
-    \sa TimeStamp::setMicroSeconds
+    The created TimeStamp is normalized, i.e. microsconds greater 1000000 are converted
+    to seconds.
 */
 
 /*!
-    \fn TimeStamp::setSeconds(qint64 s)
-
-    Sets the seconds in the timestamp type to \a s.
+    \fn qint64 TimeStamp::seconds() const
 
-    \sa TimeStamp::seconds()
+    Returns the seconds of the timestamp.
 */
 
 /*!
-    \fn TimeStamp::setMicroSeconds(qint64 usec)
-
-    Sets the microseconds in the timestamp type to \a usec.
+    \fn qint64 TimeStamp::microSeconds() const
 
-    \sa TimeStamp::microSeconds
+    Returns the microseconds of the timestamp.
 */
 
 /*!
diff --git a/src/serialbus/qcanbusframe.h b/src/serialbus/qcanbusframe.h
index 5658f94..beb347e 100644
--- a/src/serialbus/qcanbusframe.h
+++ b/src/serialbus/qcanbusframe.h
@@ -52,11 +52,13 @@ public:
     public:
         Q_DECL_CONSTEXPR TimeStamp(qint64 s = 0, qint64 usec = 0) Q_DECL_NOTHROW
             : secs(s), usecs(usec) {}
+
+        Q_DECL_CONSTEXPR static TimeStamp fromMicroSeconds(qint64 usec) Q_DECL_NOTHROW
+        { return TimeStamp(usec / 1000000, usec % 1000000); }
+
         Q_DECL_CONSTEXPR qint64 seconds() const Q_DECL_NOTHROW { return secs; }
         Q_DECL_CONSTEXPR qint64 microSeconds() const Q_DECL_NOTHROW { return usecs; }
 
-        Q_DECL_RELAXED_CONSTEXPR void setSeconds(qint64 s) Q_DECL_NOTHROW { secs = s; }
-        Q_DECL_RELAXED_CONSTEXPR void setMicroSeconds(qint64 usec) Q_DECL_NOTHROW { usecs = usec; }
     private:
         qint64 secs;
         qint64 usecs;
@@ -70,7 +72,7 @@ public:
         InvalidFrame        = 0x4
     };
 
-    explicit QCanBusFrame(QCanBusFrame::FrameType type) :
+    explicit QCanBusFrame(QCanBusFrame::FrameType type = DataFrame) :
         canId(0x0),
         isExtendedFrame(0x0),
         version(0x0)
@@ -96,7 +98,7 @@ public:
     Q_DECLARE_FLAGS(FrameErrors, FrameError)
     Q_FLAGS(FrameErrors)
 
-    explicit QCanBusFrame(quint32 identifier = 0, const QByteArray &data = QByteArray()) :
+    explicit QCanBusFrame(quint32 identifier, const QByteArray &data) :
         canId(identifier & 0x1FFFFFFFU),
         format(DataFrame),
         isExtendedFrame((identifier & 0x1FFFF800U) ? 0x1 : 0x0),
@@ -171,7 +173,7 @@ public:
     }
 
     inline void setPayload(const QByteArray &data) { load = data; }
-    inline void setTimeStamp(const TimeStamp &ts) { stamp = ts; }
+    inline void setTimeStamp(TimeStamp ts) { stamp = ts; }
 
     QByteArray payload() const { return load; }
     TimeStamp timeStamp() const { return stamp; }