diff --git a/src/Camera/QGCCameraControl.cc b/src/Camera/QGCCameraControl.cc
index 4928d527aaf076e06791c3b8ba180aad989f799b..3a5d8a5cf2ada70426b017ef022b0ed75cfdf1e2 100644
--- a/src/Camera/QGCCameraControl.cc
+++ b/src/Camera/QGCCameraControl.cc
@@ -1274,17 +1274,26 @@ QGCCameraControl::_processConditionTest(const QString conditionTest)
     qCDebug(CameraControlVerboseLog) << "_processConditionTest(" << conditionTest << ")";
     int op = TEST_NONE;
     QStringList test;
+
+    auto split = [&conditionTest](const QString& sep ) {
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
+        return conditionTest.split(sep, QString::SkipEmptyParts);
+#else
+        return conditionTest.split(sep, Qt::SkipEmptyParts);
+#endif
+    };
+
     if(conditionTest.contains("!=")) {
-        test = conditionTest.split("!=", QString::SkipEmptyParts);
+        test = split("!=");
         op = TEST_NOT_EQUAL;
     } else if(conditionTest.contains("=")) {
-        test = conditionTest.split("=", QString::SkipEmptyParts);
+        test = split("=");
         op = TEST_EQUAL;
     } else if(conditionTest.contains(">")) {
-        test = conditionTest.split(">", QString::SkipEmptyParts);
+        test = split(">");
         op = TEST_GREATER;
     } else if(conditionTest.contains("<")) {
-        test = conditionTest.split("<", QString::SkipEmptyParts);
+        test = split("<");
         op = TEST_SMALLER;
     }
     if(test.size() == 2) {
@@ -1319,7 +1328,11 @@ QGCCameraControl::_processCondition(const QString condition)
     bool result = true;
     bool andOp  = true;
     if(!condition.isEmpty()) {
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
         QStringList scond = condition.split(" ", QString::SkipEmptyParts);
+#else
+        QStringList scond = condition.split(" ", Qt::SkipEmptyParts);
+#endif
         while(scond.size()) {
             QString test = scond.first();
             scond.removeFirst();
diff --git a/src/FactSystem/FactMetaData.cc b/src/FactSystem/FactMetaData.cc
index 3da45368262104909bc89994338f161656934e48..c870a0b604a98e6de6caeec2e5a7614034fca2a4 100644
--- a/src/FactSystem/FactMetaData.cc
+++ b/src/FactSystem/FactMetaData.cc
@@ -232,7 +232,7 @@ QVariant FactMetaData::rawDefaultValue(void) const
 
 void FactMetaData::setRawDefaultValue(const QVariant& rawDefaultValue)
 {
-    if (_type == valueTypeString || (_rawMin <= rawDefaultValue && rawDefaultValue <= _rawMax)) {
+    if (_type == valueTypeString || (isInRawMinLimit(rawDefaultValue) && isInRawMaxLimit(rawDefaultValue))) {
         _rawDefaultValue = rawDefaultValue;
         _defaultValueAvailable = true;
     } else {
@@ -242,7 +242,7 @@ void FactMetaData::setRawDefaultValue(const QVariant& rawDefaultValue)
 
 void FactMetaData::setRawMin(const QVariant& rawMin)
 {
-    if (rawMin >= _minForType()) {
+    if (isInRawMinLimit(rawMin)) {
         _rawMin = rawMin;
         _minIsDefaultForType = false;
     } else {
@@ -255,13 +255,73 @@ void FactMetaData::setRawMin(const QVariant& rawMin)
 
 void FactMetaData::setRawMax(const QVariant& rawMax)
 {
-    if (rawMax > _maxForType()) {
-        qWarning() << "Attempt to set max above allowable value";
-        _rawMax = _maxForType();
-    } else {
+    if (isInRawMaxLimit(rawMax)) {
         _rawMax = rawMax;
         _maxIsDefaultForType = false;
+    } else {
+        qWarning() << "Attempt to set max above allowable value";
+        _rawMax = _maxForType();
+    }
+}
+
+bool FactMetaData::isInRawMinLimit(const QVariant& variantValue) const
+{
+    switch (_type) {
+    case valueTypeUint8:
+        return _rawMin.value<unsigned char>() <= variantValue.value<unsigned char>();
+    case valueTypeInt8:
+        return _rawMin.value<signed char>() <= variantValue.value<signed char>();
+    case valueTypeUint16:
+        return _rawMin.value<unsigned short int>() <= variantValue.value<unsigned short int>();
+    case valueTypeInt16:
+        return _rawMin.value<short int>() <= variantValue.value<short int>();
+    case valueTypeUint32:
+        return _rawMin.value<uint32_t>() <= variantValue.value<uint32_t>();
+    case valueTypeInt32:
+        return _rawMin.value<int32_t>() <= variantValue.value<int32_t>();
+    case valueTypeUint64:
+        return _rawMin.value<uint64_t>() <= variantValue.value<uint64_t>();
+    case valueTypeInt64:
+        return _rawMin.value<int64_t>() <= variantValue.value<int64_t>();
+    case valueTypeFloat:
+        return _rawMin.value<float>() <= variantValue.value<float>();
+    case valueTypeDouble:
+        return _rawMin.value<double>() <= variantValue.value<double>();
+    default:
+        return true;
+    }
+
+    return true;
+}
+
+bool FactMetaData::isInRawMaxLimit(const QVariant& variantValue) const
+{
+    switch (_type) {
+    case valueTypeUint8:
+        return _rawMax.value<unsigned char>() >= variantValue.value<unsigned char>();
+    case valueTypeInt8:
+        return _rawMax.value<signed char>() >= variantValue.value<signed char>();
+    case valueTypeUint16:
+        return _rawMax.value<unsigned short int>() >= variantValue.value<unsigned short int>();
+    case valueTypeInt16:
+        return _rawMax.value<short int>() >= variantValue.value<short int>();
+    case valueTypeUint32:
+        return _rawMax.value<uint32_t>() >= variantValue.value<uint32_t>();
+    case valueTypeInt32:
+        return _rawMax.value<int32_t>() >= variantValue.value<int32_t>();
+    case valueTypeUint64:
+        return _rawMax.value<uint64_t>() >= variantValue.value<uint64_t>();
+    case valueTypeInt64:
+        return _rawMax.value<int64_t>() >= variantValue.value<int64_t>();
+    case valueTypeFloat:
+        return _rawMax.value<float>() >= variantValue.value<float>();
+    case valueTypeDouble:
+        return _rawMax.value<double>() >= variantValue.value<double>();
+    default:
+        return true;
     }
+
+    return true;
 }
 
 QVariant FactMetaData::_minForType(void) const
@@ -349,7 +409,7 @@ bool FactMetaData::convertAndValidateRaw(const QVariant& rawValue, bool convertO
     case FactMetaData::valueTypeInt32:
         typedValue = QVariant(rawValue.toInt(&convertOk));
         if (!convertOnly && convertOk) {
-            if (typedValue < rawMin() || typedValue > rawMax()) {
+            if (!isInRawLimit<int32_t>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(rawMin().toInt()).arg(rawMax().toInt());
             }
         }
@@ -357,7 +417,7 @@ bool FactMetaData::convertAndValidateRaw(const QVariant& rawValue, bool convertO
     case FactMetaData::valueTypeInt64:
         typedValue = QVariant(rawValue.toLongLong(&convertOk));
         if (!convertOnly && convertOk) {
-            if (typedValue < rawMin() || typedValue > rawMax()) {
+            if (!isInRawLimit<int64_t>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(rawMin().toInt()).arg(rawMax().toInt());
             }
         }
@@ -367,7 +427,7 @@ bool FactMetaData::convertAndValidateRaw(const QVariant& rawValue, bool convertO
     case FactMetaData::valueTypeUint32:
         typedValue = QVariant(rawValue.toUInt(&convertOk));
         if (!convertOnly && convertOk) {
-            if (typedValue < rawMin() || typedValue > rawMax()) {
+            if (!isInRawLimit<uint32_t>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(rawMin().toUInt()).arg(rawMax().toUInt());
             }
         }
@@ -375,7 +435,7 @@ bool FactMetaData::convertAndValidateRaw(const QVariant& rawValue, bool convertO
     case FactMetaData::valueTypeUint64:
         typedValue = QVariant(rawValue.toULongLong(&convertOk));
         if (!convertOnly && convertOk) {
-            if (typedValue < rawMin() || typedValue > rawMax()) {
+            if (!isInRawLimit<uint64_t>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(rawMin().toUInt()).arg(rawMax().toUInt());
             }
         }
@@ -383,7 +443,7 @@ bool FactMetaData::convertAndValidateRaw(const QVariant& rawValue, bool convertO
     case FactMetaData::valueTypeFloat:
         typedValue = QVariant(rawValue.toFloat(&convertOk));
         if (!convertOnly && convertOk) {
-            if (typedValue < rawMin() || typedValue > rawMax()) {
+            if (!isInRawLimit<float>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(rawMin().toDouble()).arg(rawMax().toDouble());
             }
         }
@@ -392,7 +452,7 @@ bool FactMetaData::convertAndValidateRaw(const QVariant& rawValue, bool convertO
     case FactMetaData::valueTypeDouble:
         typedValue = QVariant(rawValue.toDouble(&convertOk));
         if (!convertOnly && convertOk) {
-            if (typedValue < rawMin() || typedValue > rawMax()) {
+            if (!isInRawLimit<double>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(rawMin().toDouble()).arg(rawMax().toDouble());
             }
         }
@@ -437,7 +497,7 @@ bool FactMetaData::convertAndValidateCooked(const QVariant& cookedValue, bool co
     case FactMetaData::valueTypeInt32:
         typedValue = QVariant(cookedValue.toInt(&convertOk));
         if (!convertOnly && convertOk) {
-            if (cookedMin() > typedValue || typedValue > cookedMax()) {
+            if (!isInCookedLimit<int32_t>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(cookedMin().toInt()).arg(cookedMax().toInt());
             }
         }
@@ -445,7 +505,7 @@ bool FactMetaData::convertAndValidateCooked(const QVariant& cookedValue, bool co
     case FactMetaData::valueTypeInt64:
         typedValue = QVariant(cookedValue.toLongLong(&convertOk));
         if (!convertOnly && convertOk) {
-            if (cookedMin() > typedValue || typedValue > cookedMax()) {
+            if (!isInCookedLimit<int64_t>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(cookedMin().toInt()).arg(cookedMax().toInt());
             }
         }
@@ -455,7 +515,7 @@ bool FactMetaData::convertAndValidateCooked(const QVariant& cookedValue, bool co
     case FactMetaData::valueTypeUint32:
         typedValue = QVariant(cookedValue.toUInt(&convertOk));
         if (!convertOnly && convertOk) {
-            if (cookedMin() > typedValue || typedValue > cookedMax()) {
+            if (!isInCookedLimit<uint32_t>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(cookedMin().toUInt()).arg(cookedMax().toUInt());
             }
         }
@@ -463,7 +523,7 @@ bool FactMetaData::convertAndValidateCooked(const QVariant& cookedValue, bool co
     case FactMetaData::valueTypeUint64:
         typedValue = QVariant(cookedValue.toULongLong(&convertOk));
         if (!convertOnly && convertOk) {
-            if (cookedMin() > typedValue || typedValue > cookedMax()) {
+            if (!isInCookedLimit<uint64_t>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(cookedMin().toUInt()).arg(cookedMax().toUInt());
             }
         }
@@ -471,7 +531,7 @@ bool FactMetaData::convertAndValidateCooked(const QVariant& cookedValue, bool co
     case FactMetaData::valueTypeFloat:
         typedValue = QVariant(cookedValue.toFloat(&convertOk));
         if (!convertOnly && convertOk) {
-            if (cookedMin() > typedValue || typedValue > cookedMax()) {
+            if (!isInCookedLimit<float>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(cookedMin().toFloat()).arg(cookedMax().toFloat());
             }
         }
@@ -480,7 +540,7 @@ bool FactMetaData::convertAndValidateCooked(const QVariant& cookedValue, bool co
     case FactMetaData::valueTypeDouble:
         typedValue = QVariant(cookedValue.toDouble(&convertOk));
         if (!convertOnly && convertOk) {
-            if (cookedMin() > typedValue || typedValue > cookedMax()) {
+            if (!isInCookedLimit<double>(typedValue)) {
                 errorString = tr("Value must be within %1 and %2").arg(cookedMin().toDouble()).arg(cookedMax().toDouble());
             }
         }
@@ -515,21 +575,13 @@ bool FactMetaData::clampValue(const QVariant& cookedValue, QVariant& typedValue)
     case FactMetaData::valueTypeInt32:
         typedValue = QVariant(cookedValue.toInt(&convertOk));
         if (convertOk) {
-            if (cookedMin() > typedValue) {
-                typedValue = cookedMin();
-            } else if(typedValue > cookedMax()) {
-                typedValue = cookedMax();
-            }
+            clamp<int32_t>(typedValue);
         }
         break;
     case FactMetaData::valueTypeInt64:
         typedValue = QVariant(cookedValue.toLongLong(&convertOk));
         if (convertOk) {
-            if (cookedMin() > typedValue) {
-                typedValue = cookedMin();
-            } else if(typedValue > cookedMax()) {
-                typedValue = cookedMax();
-            }
+            clamp<int64_t>(typedValue);
         }
         break;
     case FactMetaData::valueTypeUint8:
@@ -537,42 +589,26 @@ bool FactMetaData::clampValue(const QVariant& cookedValue, QVariant& typedValue)
     case FactMetaData::valueTypeUint32:
         typedValue = QVariant(cookedValue.toUInt(&convertOk));
         if (convertOk) {
-            if (cookedMin() > typedValue) {
-                typedValue = cookedMin();
-            } else if(typedValue > cookedMax()) {
-                typedValue = cookedMax();
-            }
+            clamp<uint32_t>(typedValue);
         }
         break;
     case FactMetaData::valueTypeUint64:
         typedValue = QVariant(cookedValue.toULongLong(&convertOk));
         if (convertOk) {
-            if (cookedMin() > typedValue) {
-                typedValue = cookedMin();
-            } else if(typedValue > cookedMax()) {
-                typedValue = cookedMax();
-            }
+            clamp<uint64_t>(typedValue);
         }
         break;
     case FactMetaData::valueTypeFloat:
         typedValue = QVariant(cookedValue.toFloat(&convertOk));
         if (convertOk) {
-            if (cookedMin() > typedValue) {
-                typedValue = cookedMin();
-            } else if(typedValue > cookedMax()) {
-                typedValue = cookedMax();
-            }
+            clamp<float>(typedValue);
         }
         break;
     case FactMetaData::valueTypeElapsedTimeInSeconds:
     case FactMetaData::valueTypeDouble:
         typedValue = QVariant(cookedValue.toDouble(&convertOk));
         if (convertOk) {
-            if (cookedMin() > typedValue) {
-                typedValue = cookedMin();
-            } else if(typedValue > cookedMax()) {
-                typedValue = cookedMax();
-            }
+            clamp<double>(typedValue);
         }
         break;
     case FactMetaData::valueTypeString:
diff --git a/src/FactSystem/FactMetaData.h b/src/FactSystem/FactMetaData.h
index e29b77966a3d556d96c0735bfe1f7fab64ef1ba4..6c555f225994fe675a00600bd50a6a934f8cd093 100644
--- a/src/FactSystem/FactMetaData.h
+++ b/src/FactSystem/FactMetaData.h
@@ -200,6 +200,62 @@ private:
     QVariant _maxForType(void) const;
     void _setAppSettingsTranslators(void);
 
+
+    /**
+     * @brief Clamp a value based in the cookedMin and CookedMax values
+     *
+     * @tparam T
+     * @param variantValue
+     */
+    template<class T>
+    void clamp(QVariant& variantValue) const {
+        if (cookedMin().value<T>() > variantValue.value<T>()) {
+            variantValue = cookedMin();
+        } else if(variantValue.value<T>() > cookedMax().value<T>()) {
+            variantValue = cookedMax();
+        }
+    }
+
+    /**
+     * @brief Check if value is inside cooked limits
+     *
+     * @tparam T
+     * @param variantValue
+     */
+    template<class T>
+    bool isInCookedLimit(const QVariant& variantValue) const {
+        return cookedMin().value<T>() < variantValue.value<T>() && variantValue.value<T>() < cookedMax().value<T>();
+    }
+
+    /**
+     * @brief Check if value is inside raw limits
+     *
+     * @tparam T
+     * @param variantValue
+     */
+    template<class T>
+    bool isInRawLimit(const QVariant& variantValue) const {
+        return rawMin().value<T>() <= variantValue.value<T>() && variantValue.value<T>() < rawMax().value<T>();
+    }
+
+    /**
+     * @brief Check if value if over min limit
+     *
+     * @param variantValue
+     * @return true
+     * @return false
+     */
+    bool isInRawMinLimit(const QVariant& variantValue) const;
+
+    /**
+     * @brief Check if value is lower than upper limit
+     *
+     * @param variantValue
+     * @return true
+     * @return false
+     */
+    bool isInRawMaxLimit(const QVariant& variantValue) const;
+
     // Built in translators
     static QVariant _defaultTranslator(const QVariant& from) { return from; }
     static QVariant _degreesToRadians(const QVariant& degrees);
diff --git a/src/FirmwarePlugin/APM/APMFirmwarePlugin.cc b/src/FirmwarePlugin/APM/APMFirmwarePlugin.cc
index dea65245274c135dd3a9b006655aeb237192a8f6..f5e303fc929152fd45c58004a1b327df42227279 100644
--- a/src/FirmwarePlugin/APM/APMFirmwarePlugin.cc
+++ b/src/FirmwarePlugin/APM/APMFirmwarePlugin.cc
@@ -793,7 +793,11 @@ void APMFirmwarePlugin::_soloVideoHandshake(Vehicle* vehicle, bool originalSoloF
 
     socket->connectToHost(_artooIP, _artooVideoHandshakePort);
     if (originalSoloFirmware) {
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
         QObject::connect(socket, static_cast<void (QTcpSocket::*)(QAbstractSocket::SocketError)>(&QTcpSocket::error), this, &APMFirmwarePlugin::_artooSocketError);
+#else
+        QObject::connect(socket, &QAbstractSocket::errorOccurred, this, &APMFirmwarePlugin::_artooSocketError);
+#endif
     }
 }
 
diff --git a/src/JsonHelper.cc b/src/JsonHelper.cc
index 91b6b7b87ec56b9132a5bac893aef6598512acb2..a1fcd9771c2b59a9a1340a6b10168e926c4a8a15 100644
--- a/src/JsonHelper.cc
+++ b/src/JsonHelper.cc
@@ -170,7 +170,11 @@ bool JsonHelper::_parseEnumWorker(const QJsonObject& jsonObject, QMap<QString, Q
     } else {
         // "enumStrings": "Auto,Manual,Shutter Priority,Aperture Priority",
         QString value = jsonObject.value(_enumStringsJsonKey).toString();
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
         enumStrings = defineMap.value(value, value).split(",", QString::SkipEmptyParts);
+#else
+        enumStrings = defineMap.value(value, value).split(",", Qt::SkipEmptyParts);
+#endif
     }
 
     if(jsonObject.value(_enumValuesJsonKey).isArray()) {
@@ -186,7 +190,11 @@ bool JsonHelper::_parseEnumWorker(const QJsonObject& jsonObject, QMap<QString, Q
     } else {
         // "enumValues": "0,1,2,3,4,5",
         QString value = jsonObject.value(_enumValuesJsonKey).toString();
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
         enumValues = defineMap.value(value, value).split(",", QString::SkipEmptyParts);
+#else
+        enumValues = defineMap.value(value, value).split(",", Qt::SkipEmptyParts);
+#endif
     }
 
     if (enumStrings.count() != enumValues.count()) {
diff --git a/src/LogCompressor.cc b/src/LogCompressor.cc
index 9f253690f0ce4f2a9e878e0e7fc8195bde837b4c..6cca25de851faeec80bb0e7b0d37c71ae78d3a65 100644
--- a/src/LogCompressor.cc
+++ b/src/LogCompressor.cc
@@ -55,7 +55,11 @@ void LogCompressor::run()
 
     QString outFileName;
 
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     QStringList parts = QFileInfo(infile.fileName()).absoluteFilePath().split(".", QString::SkipEmptyParts);
+#else
+    QStringList parts = QFileInfo(infile.fileName()).absoluteFilePath().split(".", Qt::SkipEmptyParts);
+#endif
 
     parts.replace(0, parts.first() + "_compressed");
     parts.replace(parts.size()-1, "txt");
diff --git a/src/MissionManager/ComplexMissionItem.cc b/src/MissionManager/ComplexMissionItem.cc
index 0d5ab83471282fe2a4b9daaf8a4df5743ebcfbc3..29399a8e9a80d15574090db458d4e67980f8664a 100644
--- a/src/MissionManager/ComplexMissionItem.cc
+++ b/src/MissionManager/ComplexMissionItem.cc
@@ -15,6 +15,7 @@
 #include "FlightPathSegment.h"
 #include "MissionController.h"
 
+#include <QCborValue>
 #include <QSettings>
 
 const char* ComplexMissionItem::jsonComplexItemTypeKey = "complexItemType";
@@ -78,7 +79,7 @@ void ComplexMissionItem::_savePresetJson(const QString& name, QJsonObject& prese
     QSettings settings;
     settings.beginGroup(presetsSettingsGroup());
     settings.beginGroup(_presetSettingsKey);
-    settings.setValue(name, QJsonDocument(presetObject).toBinaryData());
+    settings.setValue(name, QCborMap::fromJsonObject(presetObject).toCborValue().toByteArray());
 
     // Use this to save a survey preset as a JSON file to be included in the build
     // as a built-in survey preset that cannot be deleted.
@@ -107,7 +108,7 @@ QJsonObject ComplexMissionItem::_loadPresetJson(const QString& name)
     QSettings settings;
     settings.beginGroup(presetsSettingsGroup());
     settings.beginGroup(_presetSettingsKey);
-    return QJsonDocument::fromBinaryData(settings.value(name).toByteArray()).object();
+    return QCborValue(settings.value(name).toByteArray()).toMap().toJsonObject();
 }
 
 void ComplexMissionItem::addKMLVisuals(KMLPlanDomDocument& /* domDocument */)
diff --git a/src/MissionManager/MissionCommandUIInfo.cc b/src/MissionManager/MissionCommandUIInfo.cc
index 2d822e2d8f74839081d065470aba9293b2a145b5..81f1b1f4ea82e1658e637b2887f22764ec71519c 100644
--- a/src/MissionManager/MissionCommandUIInfo.cc
+++ b/src/MissionManager/MissionCommandUIInfo.cc
@@ -384,10 +384,14 @@ bool MissionCommandUIInfo::loadJsonInfo(const QJsonObject& jsonObject, bool requ
 
             paramInfo->_label =         paramObject.value(_labelJsonKey).toString();
             paramInfo->_decimalPlaces = paramObject.value(_decimalPlacesJsonKey).toInt(FactMetaData::kUnknownDecimalPlaces);
-            paramInfo->_enumStrings =   paramObject.value(_enumStringsJsonKey).toString().split(",", QString::SkipEmptyParts);
             paramInfo->_param =         i;
             paramInfo->_units =         paramObject.value(_unitsJsonKey).toString();
             paramInfo->_nanUnchanged =  paramObject.value(_nanUnchangedJsonKey).toBool(false);
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
+            paramInfo->_enumStrings =   paramObject.value(_enumStringsJsonKey).toString().split(",", QString::SkipEmptyParts);
+#else
+            paramInfo->_enumStrings =   paramObject.value(_enumStringsJsonKey).toString().split(",", Qt::SkipEmptyParts);
+#endif
 
             if (paramObject.contains(_defaultJsonKey)) {
                 if (paramInfo->_nanUnchanged) {
@@ -402,8 +406,11 @@ bool MissionCommandUIInfo::loadJsonInfo(const QJsonObject& jsonObject, bool requ
             } else {
                 paramInfo->_defaultValue = paramInfo->_nanUnchanged ? std::numeric_limits<double>::quiet_NaN() : 0;
             }
-
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
             QStringList enumValues = paramObject.value(_enumValuesJsonKey).toString().split(",", QString::SkipEmptyParts);
+#else
+            QStringList enumValues = paramObject.value(_enumValuesJsonKey).toString().split(",", Qt::SkipEmptyParts);
+#endif
             for (const QString &enumValue: enumValues) {
                 bool    convertOk;
                 double  value = enumValue.toDouble(&convertOk);
diff --git a/src/MissionManager/QGCMapPolygon.cc b/src/MissionManager/QGCMapPolygon.cc
index 8f088917ff67d0e96e3593f9da3dd38abf603c8b..e678099cec21b1727134751faea59166127fa5d5 100644
--- a/src/MissionManager/QGCMapPolygon.cc
+++ b/src/MissionManager/QGCMapPolygon.cc
@@ -453,7 +453,12 @@ void QGCMapPolygon::offset(double distance)
         QGeoCoordinate  tangentOrigin = vertexCoordinate(0);
         for (int i=0; i<rgOffsetEdges.count(); i++) {
             int prevIndex = i == 0 ? rgOffsetEdges.count() - 1 : i - 1;
-            if (rgOffsetEdges[prevIndex].intersect(rgOffsetEdges[i], &newVertex) == QLineF::NoIntersection) {
+#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
+            auto intersect = rgOffsetEdges[prevIndex].intersect(rgOffsetEdges[i], &newVertex);
+#else
+            auto intersect = rgOffsetEdges[prevIndex].intersects(rgOffsetEdges[i], &newVertex);
+#endif
+            if (intersect == QLineF::NoIntersection) {
                 // FIXME: Better error handling?
                 qWarning("Intersection failed");
                 return;
diff --git a/src/MissionManager/QGCMapPolyline.cc b/src/MissionManager/QGCMapPolyline.cc
index 5dcb0f4beb75bdf1c323703efb6ea6e2c93c3f16..8c111381b2e92e80a33d714f1e6499d7b55bc567 100644
--- a/src/MissionManager/QGCMapPolyline.cc
+++ b/src/MissionManager/QGCMapPolyline.cc
@@ -329,7 +329,12 @@ QList<QGeoCoordinate> QGCMapPolyline::offsetPolyline(double distance)
         // Intersect the offset edges to generate new central vertices
         QPointF  newVertex;
         for (int i=1; i<rgOffsetEdges.count(); i++) {
-            if (rgOffsetEdges[i - 1].intersect(rgOffsetEdges[i], &newVertex) == QLineF::NoIntersection) {
+#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
+            auto intersect = rgOffsetEdges[i - 1].intersect(rgOffsetEdges[i], &newVertex);
+#else
+            auto intersect = rgOffsetEdges[i - 1].intersects(rgOffsetEdges[i], &newVertex);
+#endif
+            if (intersect == QLineF::NoIntersection) {
                 // Two lines are colinear
                 newVertex = rgOffsetEdges[i].p2();
             }
diff --git a/src/MissionManager/SurveyComplexItem.cc b/src/MissionManager/SurveyComplexItem.cc
index 1edd4200bddb4144fa9e5528cd3df077a7ab88a5..f1c6461ae1ab0fdc416b9b6e694e1a9c28735eae 100644
--- a/src/MissionManager/SurveyComplexItem.cc
+++ b/src/MissionManager/SurveyComplexItem.cc
@@ -520,12 +520,20 @@ void SurveyComplexItem::_intersectLinesWithRect(const QList<QLineF>& lineList, c
         QLineF intersectLine;
         const QLineF& line = lineList[i];
 
+        auto isLineBoundedIntersect = [&line, &intersectPoint](const QLineF& linePosition) {
+#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
+            return line.intersect(linePosition, &intersectPoint) == QLineF::BoundedIntersection;
+#else
+            return line.intersects(linePosition, &intersectPoint) == QLineF::BoundedIntersection;
+#endif
+        };
+
         int foundCount = 0;
-        if (line.intersect(topLine, &intersectPoint) == QLineF::BoundedIntersection) {
+        if (isLineBoundedIntersect(topLine)) {
             intersectLine.setP1(intersectPoint);
             foundCount++;
         }
-        if (line.intersect(rightLine, &intersectPoint) == QLineF::BoundedIntersection) {
+        if (isLineBoundedIntersect(rightLine)) {
             if (foundCount == 0) {
                 intersectLine.setP1(intersectPoint);
             } else {
@@ -536,7 +544,7 @@ void SurveyComplexItem::_intersectLinesWithRect(const QList<QLineF>& lineList, c
             }
             foundCount++;
         }
-        if (line.intersect(bottomLine, &intersectPoint) == QLineF::BoundedIntersection) {
+        if (isLineBoundedIntersect(bottomLine)) {
             if (foundCount == 0) {
                 intersectLine.setP1(intersectPoint);
             } else {
@@ -547,7 +555,7 @@ void SurveyComplexItem::_intersectLinesWithRect(const QList<QLineF>& lineList, c
             }
             foundCount++;
         }
-        if (line.intersect(leftLine, &intersectPoint) == QLineF::BoundedIntersection) {
+        if (isLineBoundedIntersect(leftLine)) {
             if (foundCount == 0) {
                 intersectLine.setP1(intersectPoint);
             } else {
@@ -577,7 +585,13 @@ void SurveyComplexItem::_intersectLinesWithPolygon(const QList<QLineF>& lineList
         for (int j=0; j<polygon.count()-1; j++) {
             QPointF intersectPoint;
             QLineF polygonLine = QLineF(polygon[j], polygon[j+1]);
-            if (line.intersect(polygonLine, &intersectPoint) == QLineF::BoundedIntersection) {
+
+#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
+            auto intersect = line.intersect(polygonLine, &intersectPoint);
+#else
+            auto intersect = line.intersects(polygonLine, &intersectPoint);
+#endif
+            if (intersect == QLineF::BoundedIntersection) {
                 if (!intersections.contains(intersectPoint)) {
                     intersections.append(intersectPoint);
                 }
@@ -1102,7 +1116,12 @@ bool SurveyComplexItem::_VertexCanSeeOther(const QPolygonF& polygon, const QPoin
         if (vertexD == vertexB) continue;
         QLineF lineCD(*vertexC, *vertexD);
         QPointF intersection{};
+
+#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
         auto intersects = lineAB.intersect(lineCD, &intersection);
+#else
+        auto intersects = lineAB.intersects(lineCD, &intersection);
+#endif
         if (intersects == QLineF::IntersectType::BoundedIntersection) {
 //            auto diffIntersection = *vertexA - intersection;
 //            auto distanceIntersection = sqrtf(diffIntersection.x() * diffIntersection.x() + diffIntersection.y()*diffIntersection.y());
diff --git a/src/QGCComboBox.cc b/src/QGCComboBox.cc
index 990668d4cb3e9a1472d9dc0c8d705dc157538303..3f26b3595f037f50b33b796d749e58e170d868a3 100644
--- a/src/QGCComboBox.cc
+++ b/src/QGCComboBox.cc
@@ -24,5 +24,9 @@ void QGCComboBox::simulateUserSetCurrentIndex(int index)
     
     // We have to manually signal activated
     emit activated(index);
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     emit activated(itemText(index));
+#else
+    emit textActivated(itemText(index));
+#endif
 }
diff --git a/src/QGCFileDownload.cc b/src/QGCFileDownload.cc
index 191305a95bd2c0b6344fe57c75b87fa4864dfbab..62a0301cb3798131089129505b5e9fe0f72cc400 100644
--- a/src/QGCFileDownload.cc
+++ b/src/QGCFileDownload.cc
@@ -83,9 +83,12 @@ bool QGCFileDownload::download(const QString& remoteFile, bool redirect)
 
     connect(networkReply, &QNetworkReply::downloadProgress, this, &QGCFileDownload::downloadProgress);
     connect(networkReply, &QNetworkReply::finished, this, &QGCFileDownload::_downloadFinished);
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(networkReply, static_cast<void (QNetworkReply::*)(QNetworkReply::NetworkError)>(&QNetworkReply::error),
             this, &QGCFileDownload::_downloadError);
-
+#else
+    connect(networkReply, &QNetworkReply::errorOccurred, this, &QGCFileDownload::_downloadError);
+#endif
     return true;
 }
 
diff --git a/src/QGCTemporaryFile.cc b/src/QGCTemporaryFile.cc
index 0a1e9883fcc4ff4f3ada4948f185d4e269feaa46..400801fc8b2970379be15072afcfc01c3f39922f 100644
--- a/src/QGCTemporaryFile.cc
+++ b/src/QGCTemporaryFile.cc
@@ -18,6 +18,7 @@
 #include "QGCTemporaryFile.h"
 
 #include <QDir>
+#include <QRandomGenerator>
 #include <QStandardPaths>
 
 QGCTemporaryFile::QGCTemporaryFile(const QString& fileTemplate, QObject* parent) :
@@ -40,7 +41,7 @@ bool QGCTemporaryFile::open(QFile::OpenMode openMode)
     do {
         QString uniqueStr;
         for (int i=0; i<6; i++) {
-            uniqueStr += rgDigits[qrand() % 10];
+            uniqueStr += rgDigits[QRandomGenerator::global()->generate() % 10];
         }
         
         if (_template.contains("XXXXXX")) {
diff --git a/src/QmlControls/ParameterEditorController.cc b/src/QmlControls/ParameterEditorController.cc
index e28afe8e0a7360b9c78c497363160d0b72a9c4b3..8f2cb6b8dc9ec620b1095d39e9fd666a6b3019eb 100644
--- a/src/QmlControls/ParameterEditorController.cc
+++ b/src/QmlControls/ParameterEditorController.cc
@@ -168,7 +168,12 @@ bool ParameterEditorController::_shouldShow(Fact* fact)
 void ParameterEditorController::_updateParameters(void)
 {
     QObjectList newParameterList;
+
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     QStringList searchItems = _searchText.split(' ', QString::SkipEmptyParts);
+#else
+    QStringList searchItems = _searchText.split(' ', Qt::SkipEmptyParts);
+#endif
 
     if (searchItems.isEmpty() && !_showModifiedOnly) {
         int compId = _parameterMgr->getComponentId(_currentCategory);
diff --git a/src/QmlControls/QGroundControlQmlGlobal.cc b/src/QmlControls/QGroundControlQmlGlobal.cc
index 20ac868a18fa35972fefbcbbae3e67cd196fa04c..8ab82bcd7294afb06315666c20902244939fc55f 100644
--- a/src/QmlControls/QGroundControlQmlGlobal.cc
+++ b/src/QmlControls/QGroundControlQmlGlobal.cc
@@ -221,7 +221,13 @@ bool QGroundControlQmlGlobal::linesIntersect(QPointF line1A, QPointF line1B, QPo
 {
     QPointF intersectPoint;
 
-    return QLineF(line1A, line1B).intersect(QLineF(line2A, line2B), &intersectPoint) == QLineF::BoundedIntersection &&
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
+    auto intersect = QLineF(line1A, line1B).intersect(QLineF(line2A, line2B), &intersectPoint);
+#else
+    auto intersect = QLineF(line1A, line1B).intersects(QLineF(line2A, line2B), &intersectPoint);
+#endif
+
+    return  intersect == QLineF::BoundedIntersection &&
             intersectPoint != line1A && intersectPoint != line1B;
 }
 
diff --git a/src/QtLocationPlugin/GoogleMapProvider.cpp b/src/QtLocationPlugin/GoogleMapProvider.cpp
index d678780f3d51866b612b42fb8aa54a20c7209152..b2f2f3fbbdeb86c43494b06eea82178b5d5d4fcd 100644
--- a/src/QtLocationPlugin/GoogleMapProvider.cpp
+++ b/src/QtLocationPlugin/GoogleMapProvider.cpp
@@ -116,7 +116,11 @@ void GoogleMapProvider::_tryCorrectGoogleVersions(QNetworkAccessManager* network
         _googleReply = networkManager->get(qheader);
         connect(_googleReply, &QNetworkReply::finished, this, &GoogleMapProvider::_googleVersionCompleted);
         connect(_googleReply, &QNetworkReply::destroyed, this, &GoogleMapProvider::_replyDestroyed);
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
         connect(_googleReply, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &GoogleMapProvider::_networkReplyError);
+#else
+        connect(_googleReply, &QNetworkReply::errorOccurred, this, &GoogleMapProvider::_networkReplyError);
+#endif
         networkManager->setProxy(proxy);
     }
 }
diff --git a/src/QtLocationPlugin/QGCMapTileSet.cpp b/src/QtLocationPlugin/QGCMapTileSet.cpp
index 38bff888e4e801d6d6978621709b3387de0d00c7..878381f2afa9a45ebc579fc251513f8a122742ac 100644
--- a/src/QtLocationPlugin/QGCMapTileSet.cpp
+++ b/src/QtLocationPlugin/QGCMapTileSet.cpp
@@ -250,7 +250,11 @@ void QGCCachedTileSet::_prepareDownload()
             QNetworkReply* reply = _networkManager->get(request);
             reply->setParent(0);
             connect(reply, &QNetworkReply::finished, this, &QGCCachedTileSet::_networkReplyFinished);
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
             connect(reply, static_cast<void (QNetworkReply::*)(QNetworkReply::NetworkError)>(&QNetworkReply::error), this, &QGCCachedTileSet::_networkReplyError);
+#else
+            connect(reply, &QNetworkReply::errorOccurred, this, &QGCCachedTileSet::_networkReplyError);
+#endif
             _replies.insert(tile->hash(), reply);
 #if !defined(__mobile__)
             _networkManager->setProxy(proxy);
diff --git a/src/Settings/AppSettings.cc b/src/Settings/AppSettings.cc
index 46c277136092b226361190aca112f4789aea32a9..665358be6f949902b616f708b8b8d073850c40b3 100644
--- a/src/Settings/AppSettings.cc
+++ b/src/Settings/AppSettings.cc
@@ -243,7 +243,13 @@ MAV_TYPE AppSettings::offlineEditingVehicleTypeFromVehicleType(MAV_TYPE vehicleT
 QList<int> AppSettings::firstRunPromptsIdsVariantToList(const QVariant& firstRunPromptIds)
 {
     QList<int> rgIds;
+
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     QStringList strIdList = firstRunPromptIds.toString().split(",", QString::SkipEmptyParts);
+#else
+    QStringList strIdList = firstRunPromptIds.toString().split(",", Qt::SkipEmptyParts);
+#endif
+
     for (const QString& strId: strIdList) {
         rgIds.append(strId.toInt());
     }
diff --git a/src/Terrain/TerrainQuery.cc b/src/Terrain/TerrainQuery.cc
index b8dcc165527a1195a4fc14e289513665508fbc57..bcc9f147b7294310b693265fc13307c729655026 100644
--- a/src/Terrain/TerrainQuery.cc
+++ b/src/Terrain/TerrainQuery.cc
@@ -127,7 +127,12 @@ void TerrainAirMapQuery::_sendQuery(const QString& path, const QUrlQuery& urlQue
 
     connect(networkReply, &QNetworkReply::finished, this, &TerrainAirMapQuery::_requestFinished);
     connect(networkReply, &QNetworkReply::sslErrors, this, &TerrainAirMapQuery::_sslErrors);
+
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(networkReply, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &TerrainAirMapQuery::_requestError);
+#else
+    connect(networkReply, &QNetworkReply::errorOccurred, this, &TerrainAirMapQuery::_requestError);
+#endif
 }
 
 void TerrainAirMapQuery::_requestError(QNetworkReply::NetworkError code)
diff --git a/src/Vehicle/MAVLinkLogManager.cc b/src/Vehicle/MAVLinkLogManager.cc
index e7898968e2302abf8375b06e8c553249f57d8689..1b8d60fce45460b3e1f081f1b0d188134dd11575 100644
--- a/src/Vehicle/MAVLinkLogManager.cc
+++ b/src/Vehicle/MAVLinkLogManager.cc
@@ -150,7 +150,7 @@ MAVLinkLogProcessor::valid()
 bool
 MAVLinkLogProcessor::create(MAVLinkLogManager* manager, const QString path, uint8_t id)
 {
-    _fileName.sprintf("%s/%03d-%s%s",
+    _fileName.asprintf("%s/%03d-%s%s",
                       path.toLatin1().data(),
                       id,
                       QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz").toLocal8Bit().data(),
diff --git a/src/Vehicle/Vehicle.cc b/src/Vehicle/Vehicle.cc
index 9a2e05136b8ecd0f6bf0b0f16bf0a709e7e6a6b3..0e4232168a9bd2164ea460589429513be18f69b4 100644
--- a/src/Vehicle/Vehicle.cc
+++ b/src/Vehicle/Vehicle.cc
@@ -1535,7 +1535,7 @@ QString Vehicle::vehicleUIDStr()
 {
     QString uid;
     uint8_t* pUid = (uint8_t*)(void*)&_uid;
-    uid.sprintf("%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
+    uid.asprintf("%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
                 pUid[0] & 0xff,
             pUid[1] & 0xff,
             pUid[2] & 0xff,
@@ -4102,8 +4102,7 @@ QString Vehicle::hobbsMeter()
         int hours   = hobbsTimeSeconds / 3600;
         int minutes = (hobbsTimeSeconds % 3600) / 60;
         int seconds = hobbsTimeSeconds % 60;
-        QString timeStr;
-        timeStr.sprintf("%04d:%02d:%02d", hours, minutes, seconds);
+        QString timeStr = QString::asprintf("%04d:%02d:%02d", hours, minutes, seconds);
         qCDebug(VehicleLog) << "Hobbs Meter:" << timeStr << "(" << factHi->rawValue().toUInt() << factLo->rawValue().toUInt() << ")";
         return timeStr;
     }
diff --git a/src/comm/TCPLink.cc b/src/comm/TCPLink.cc
index 66c6e04b5be533a72981fc10e5926f8e72e0fd75..1dca2083ad75712322f67bba9f808a3f76f0b0e4 100644
--- a/src/comm/TCPLink.cc
+++ b/src/comm/TCPLink.cc
@@ -150,12 +150,21 @@ bool TCPLink::_hardwareConnect()
     Q_ASSERT(_socket == nullptr);
     _socket = new QTcpSocket();
 
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     QSignalSpy errorSpy(_socket, static_cast<void (QTcpSocket::*)(QAbstractSocket::SocketError)>(&QTcpSocket::error));
+#else
+    QSignalSpy errorSpy(_socket, &QAbstractSocket::errorOccurred);
+#endif
+
     _socket->connectToHost(_tcpConfig->address(), _tcpConfig->port());
     QObject::connect(_socket, &QTcpSocket::readyRead, this, &TCPLink::readBytes);
 
+#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     QObject::connect(_socket,static_cast<void (QTcpSocket::*)(QAbstractSocket::SocketError)>(&QTcpSocket::error),
                      this, &TCPLink::_socketError);
+#else
+    QObject::connect(_socket, &QAbstractSocket::errorOccurred, this, &TCPLink::_socketError);
+#endif
 
     // Give the socket a second to connect to the other side otherwise error out
     if (!_socket->waitForConnected(1000))
@@ -320,7 +329,7 @@ void TCPConfiguration::loadSettings(QSettings& settings, const QString& root)
     settings.beginGroup(root);
     _port = (quint16)settings.value("port", QGC_TCP_PORT).toUInt();
     QString address = settings.value("host", _address.toString()).toString();
-    _address = address;
+    _address = QHostAddress(address);
     settings.endGroup();
 }
 
diff --git a/src/qgcunittest/UnitTest.cc b/src/qgcunittest/UnitTest.cc
index 30cf1c4d42b5102a85dc880fa417b4861321eceb..77427e593b0baefc4d2e91379b41fe918966861d 100644
--- a/src/qgcunittest/UnitTest.cc
+++ b/src/qgcunittest/UnitTest.cc
@@ -20,6 +20,7 @@
 #include "AppSettings.h"
 #include "SettingsManager.h"
 
+#include <QRandomGenerator>
 #include <QTemporaryFile>
 #include <QTime>
 
@@ -464,12 +465,12 @@ QString UnitTest::createRandomFile(uint32_t byteCount)
     QTemporaryFile tempFile;
 
     QTime time = QTime::currentTime();
-    qsrand((uint)time.msec());
+    QRandomGenerator::global()->seed(time.msec());
 
     tempFile.setAutoRemove(false);
     if (tempFile.open()) {
         for (uint32_t bytesWritten=0; bytesWritten<byteCount; bytesWritten++) {
-            unsigned char byte = (qrand() * 0xFF) / RAND_MAX;
+            unsigned char byte = (QRandomGenerator::global()->generate() * 0xFF) / RAND_MAX;
             tempFile.write((char *)&byte, 1);
         }
         tempFile.close();