AutoConnect list dried from json file

qgroundcontrol.qrc

@@ -167,6 +167,7 @@
         <file alias="QGroundControlQmlGlobal.json">src/QmlControls/QGroundControlQmlGlobal.json</file>
         <file alias="RallyPoint.FactMetaData.json">src/MissionManager/RallyPoint.FactMetaData.json</file>
         <file alias="Survey.FactMetaData.json">src/MissionManager/Survey.FactMetaData.json</file>
+        <file alias="USBBoardInfo.json">src/comm/USBBoardInfo.json</file>
     </qresource>
     <qresource prefix="/MockLink">
         <file alias="APMArduCopterMockLink.params">src/comm/APMArduCopterMockLink.params</file>

src/VehicleSetup/Bootloader.h

@@ -61,15 +61,15 @@ public:
     bool reboot(QextSerialPort* port);
     
     // Supported bootloader board ids
-    static const int boardIDPX4FMUV1 = 5;   ///< PX4 V1 board, as from USB PID
-    static const int boardIDPX4FMUV2 = 9;   ///< PX4 V2 board, as from USB PID
-    static const int boardIDPX4FMUV4 = 11;   ///< PX4 V4 board, as from USB PID
-    static const int boardIDPX4Flow = 6;    ///< PX4 Flow board, as from USB PID
-    static const int boardIDAeroCore = 98;  ///< Gumstix AeroCore board, as from USB PID
-    static const int boardID3DRRadio = 78;  ///< 3DR Radio. This is an arbitrary value unrelated to the PID
-    static const int boardIDMINDPXFMUV2 = 88;  ///< MindPX V2 board, as from USB PID
-    static const int boardIDTAPV1 = 64;     ///< TAP V1 board, as from USB PID
-    static const int boardIDASCV1 = 65;     ///< ASC V1 board, as from USB PID
+    static const int boardIDPX4FMUV1 = 5;       ///< PX4 V1 board, as from USB PID
+    static const int boardIDPX4FMUV2 = 9;       ///< PX4 V2 board, as from USB PID
+    static const int boardIDPX4FMUV4 = 11;      ///< PX4 V4 board, as from USB PID
+    static const int boardIDPX4Flow = 6;        ///< PX4 Flow board, as from USB PID
+    static const int boardIDAeroCore = 98;      ///< Gumstix AeroCore board, as from USB PID
+    static const int boardID3DRRadio = 78;      ///< 3DR Radio. This is an arbitrary value unrelated to the PID
+    static const int boardIDMINDPXFMUV2 = 88;   ///< MindPX V2 board, as from USB PID
+    static const int boardIDTAPV1 = 64;         ///< TAP V1 board, as from USB PID
+    static const int boardIDASCV1 = 65;         ///< ASC V1 board, as from USB PID
     
 signals:
     /// @brief Signals progress indicator for long running bootloader utility routines

src/VehicleSetup/FirmwareUpgrade.qml

@@ -97,7 +97,7 @@ QGCView {
             } else {
                 // We end up here when we detect a board plugged in after we've started upgrade
                 statusTextArea.append(highlightPrefix + qsTr("Found device") + highlightSuffix + ": " + controller.boardType)
-                if (controller.boardType == "Pixhawk" || controller.boardType == "AeroCore" || controller.boardType == "PX4 Flow" || controller.boardType == "PX4 FMU V1" || controller.boardType == "MindPX" || controller.boardType == "TAP V1" || controller.boardType == "ASC V1") {
+                if (controller.pixhawkBoard || controller.px4FlowBoard) {
                     showDialog(pixhawkFirmwareSelectDialogComponent, title, qgcView.showDialogDefaultWidth, StandardButton.Ok | StandardButton.Cancel)
                 }
             }
@@ -124,7 +124,7 @@ QGCView {
             anchors.fill:   parent
 
             property bool showFirmwareTypeSelection:    _advanced.checked
-            property bool px4Flow:                      controller.boardType == "PX4 Flow"
+            property bool px4Flow:                      controller.px4FlowBoard
 
             function updatePX4VersionDisplay() {
                 var versionString = ""

src/VehicleSetup/FirmwareUpgradeController.cc

@@ -116,43 +116,14 @@ void FirmwareUpgradeController::cancel(void)
     _threadController->cancel();
 }
 
-void FirmwareUpgradeController::_foundBoard(bool firstAttempt, const QSerialPortInfo& info, int boardType)
+void FirmwareUpgradeController::_foundBoard(bool firstAttempt, const QSerialPortInfo& info, int boardType, QString boardName)
 {
     _foundBoardInfo = info;
     _foundBoardType = (QGCSerialPortInfo::BoardType_t)boardType;
+    _foundBoardTypeName = boardName;
+    _startFlashWhenBootloaderFound = false;
 
-    switch (boardType) {
-    case QGCSerialPortInfo::BoardTypePX4FMUV1:
-        _foundBoardTypeName = "PX4 FMU V1";
-        _startFlashWhenBootloaderFound = false;
-        break;
-    case QGCSerialPortInfo::BoardTypePX4FMUV2:
-    case QGCSerialPortInfo::BoardTypePX4FMUV4:
-        _foundBoardTypeName = "Pixhawk";
-        _startFlashWhenBootloaderFound = false;
-        break;
-    case QGCSerialPortInfo::BoardTypeAeroCore:
-        _foundBoardTypeName = "AeroCore";
-        _startFlashWhenBootloaderFound = false;
-        break;
-    case QGCSerialPortInfo::BoardTypeMINDPXFMUV2:
-        _foundBoardTypeName = "MindPX";
-        _startFlashWhenBootloaderFound = false;
-        break;
-    case QGCSerialPortInfo::BoardTypeTAPV1:
-        _foundBoardTypeName = "TAP V1";
-        _startFlashWhenBootloaderFound = false;
-        break;
-    case QGCSerialPortInfo::BoardTypeASCV1:
-        _foundBoardTypeName = "ASC V1";
-        _startFlashWhenBootloaderFound = false;
-        break;
-    case QGCSerialPortInfo::BoardTypePX4Flow:
-        _foundBoardTypeName = "PX4 Flow";
-        _startFlashWhenBootloaderFound = false;
-        break;
-    case QGCSerialPortInfo::BoardTypeSikRadio:
-        _foundBoardTypeName = "SiK Radio";
+    if (_foundBoardType == QGCSerialPortInfo::BoardTypeSiKRadio) {
         if (!firstAttempt) {
             // Radio always flashes latest firmware, so we can start right away without
             // any further user input.
@@ -161,12 +132,10 @@ void FirmwareUpgradeController::_foundBoard(bool firstAttempt, const QSerialPort
                                                                                 StableFirmware,
                                                                                 DefaultVehicleFirmware);
         }
-        break;
     }
     
-    qCDebug(FirmwareUpgradeLog) << _foundBoardType;
+    qCDebug(FirmwareUpgradeLog) << _foundBoardType << _foundBoardTypeName;
     emit boardFound();
-    _loadAPMVersions(_foundBoardType);
 }
 
 
@@ -197,6 +166,8 @@ void FirmwareUpgradeController::_foundBootloader(int bootloaderVersion, int boar
     if (_startFlashWhenBootloaderFound) {
         flash(_startFlashWhenBootloaderFoundFirmwareIdentity);
     }
+
+    _loadAPMVersions(_bootloaderBoardID);
 }
 
 
@@ -463,48 +434,6 @@ QHash<FirmwareUpgradeController::FirmwareIdentifier, QString>* FirmwareUpgradeCo
     }
 }
 
-QHash<FirmwareUpgradeController::FirmwareIdentifier, QString>* FirmwareUpgradeController::_firmwareHashForBoardType(QGCSerialPortInfo::BoardType_t boardType)
-{
-    int boardId = Bootloader::boardIDPX4FMUV2;
-
-    switch (boardType) {
-    case QGCSerialPortInfo::BoardTypePX4FMUV1:
-        boardId = Bootloader::boardIDPX4FMUV1;
-        break;
-    case QGCSerialPortInfo::BoardTypePX4FMUV2:
-        boardId = Bootloader::boardIDPX4FMUV2;
-        break;
-    case QGCSerialPortInfo::BoardTypePX4FMUV4:
-        boardId = Bootloader::boardIDPX4FMUV4;
-        break;
-    case QGCSerialPortInfo::BoardTypeAeroCore:
-        boardId = Bootloader::boardIDAeroCore;
-        break;
-    case QGCSerialPortInfo::BoardTypeMINDPXFMUV2:
-        boardId = Bootloader::boardIDMINDPXFMUV2;
-        break;
-    case QGCSerialPortInfo::BoardTypeTAPV1:
-        boardId = Bootloader::boardIDTAPV1;
-        break;
-    case QGCSerialPortInfo::BoardTypeASCV1:
-        boardId = Bootloader::boardIDASCV1;
-        break;
-    case QGCSerialPortInfo::BoardTypePX4Flow:
-        boardId = Bootloader::boardIDPX4Flow;
-        break;
-    case QGCSerialPortInfo::BoardTypeSikRadio:
-        boardId = Bootloader::boardID3DRRadio;
-        break;
-    default:
-        qWarning() << "Internal error: invalid board type for flashing" << boardType;
-        boardId = Bootloader::boardIDPX4FMUV2;
-        break;
-    }
-
-    return _firmwareHashForBoardId(boardId);
-}
-
-
 /// @brief Prompts the user to select a firmware file if needed and moves the state machine to the next state.
 void FirmwareUpgradeController::_getFirmwareFile(FirmwareIdentifier firmwareId)
 {
@@ -697,11 +626,11 @@ void FirmwareUpgradeController::_eraseComplete(void)
     _eraseTimer.stop();
 }
 
-void FirmwareUpgradeController::_loadAPMVersions(QGCSerialPortInfo::BoardType_t boardType)
+void FirmwareUpgradeController::_loadAPMVersions(uint32_t bootloaderBoardID)
 {
     _apmVersionMap.clear();
 
-    QHash<FirmwareIdentifier, QString>* prgFirmware = _firmwareHashForBoardType(boardType);
+    QHash<FirmwareIdentifier, QString>* prgFirmware = _firmwareHashForBoardId(bootloaderBoardID);
 
     foreach (FirmwareIdentifier firmwareId, prgFirmware->keys()) {
         if (firmwareId.autopilotStackType == AutoPilotStackAPM) {
@@ -740,7 +669,7 @@ void FirmwareUpgradeController::_apmVersionDownloadFinished(QString remoteFile,
 
     // In order to determine the firmware and vehicle type for this file we find the matching entry in the firmware list
 
-    QHash<FirmwareIdentifier, QString>* prgFirmware = _firmwareHashForBoardType(_foundBoardType);
+    QHash<FirmwareIdentifier, QString>* prgFirmware = _firmwareHashForBoardId(_bootloaderBoardID);
 
     QString remotePath = QFileInfo(remoteFile).path();
     foreach (FirmwareIdentifier firmwareId, prgFirmware->keys()) {

src/VehicleSetup/FirmwareUpgradeController.h

@@ -96,6 +96,8 @@ public:
     Q_PROPERTY(QString          boardPort                   READ boardPort                                              NOTIFY boardFound)
     Q_PROPERTY(QString          boardDescription            READ boardDescription                                       NOTIFY boardFound)
     Q_PROPERTY(QString          boardType                   MEMBER _foundBoardTypeName                                  NOTIFY boardFound)
+    Q_PROPERTY(bool             pixhawkBoard                READ pixhawkBoard                                           NOTIFY boardFound)
+    Q_PROPERTY(bool             px4FlowBoard                READ px4FlowBoard                                           NOTIFY boardFound)
     Q_PROPERTY(FirmwareType_t   selectedFirmwareType        READ selectedFirmwareType   WRITE setSelectedFirmwareType   NOTIFY selectedFirmwareTypeChanged)
     Q_PROPERTY(QStringList      apmAvailableVersions        READ apmAvailableVersions                                   NOTIFY apmAvailableVersionsChanged)
     Q_PROPERTY(QString          px4StableVersion            READ px4StableVersion                                       NOTIFY px4StableVersionChanged)
@@ -142,6 +144,9 @@ public:
     QString px4StableVersion(void) { return _px4StableVersion; }
     QString px4BetaVersion(void) { return _px4BetaVersion; }
 
+    bool pixhawkBoard(void) const { return _foundBoardType == QGCSerialPortInfo::BoardTypePixhawk; }
+    bool px4FlowBoard(void) const { return _foundBoardType == QGCSerialPortInfo::BoardTypePX4Flow; }
+
 signals:
     void boardFound(void);
     void noBoardFound(void);
@@ -158,7 +163,7 @@ private slots:
     void _firmwareDownloadProgress(qint64 curr, qint64 total);
     void _firmwareDownloadFinished(QString remoteFile, QString localFile);
     void _firmwareDownloadError(QString errorMsg);
-    void _foundBoard(bool firstAttempt, const QSerialPortInfo& portInfo, int boardType);
+    void _foundBoard(bool firstAttempt, const QSerialPortInfo& portInfo, int boardType, QString boardName);
     void _noBoardFound(void);
     void _boardGone();
     void _foundBootloader(int bootloaderVersion, int boardID, int flashSize);
@@ -180,9 +185,8 @@ private:
     void _downloadFirmware(void);
     void _appendStatusLog(const QString& text, bool critical = false);
     void _errorCancel(const QString& msg);
-    void _loadAPMVersions(QGCSerialPortInfo::BoardType_t boardType);
+    void _loadAPMVersions(uint32_t bootloaderBoardID);
     QHash<FirmwareIdentifier, QString>* _firmwareHashForBoardId(int boardId);
-    QHash<FirmwareIdentifier, QString>* _firmwareHashForBoardType(QGCSerialPortInfo::BoardType_t boardType);
     void _determinePX4StableVersion(void);
 
     QString _portName;

src/VehicleSetup/PX4FirmwareUpgradeThread.cc

@@ -86,14 +86,15 @@ void PX4FirmwareUpgradeThreadWorker::_findBoardOnce(void)
     
     QGCSerialPortInfo               portInfo;
     QGCSerialPortInfo::BoardType_t  boardType;
+    QString                         boardName;
     
-    if (_findBoardFromPorts(portInfo, boardType)) {
+    if (_findBoardFromPorts(portInfo, boardType, boardName)) {
         if (!_foundBoard) {
             _foundBoard = true;
             _foundBoardPortInfo = portInfo;
-            emit foundBoard(_findBoardFirstAttempt, portInfo, boardType);
+            emit foundBoard(_findBoardFirstAttempt, portInfo, boardType, boardName);
             if (!_findBoardFirstAttempt) {
-                if (boardType == QGCSerialPortInfo::BoardTypeSikRadio) {
+                if (boardType == QGCSerialPortInfo::BoardTypeSiKRadio) {
                     _3drRadioForceBootloader(portInfo);
                     return;
                 } else {
@@ -116,18 +117,20 @@ void PX4FirmwareUpgradeThreadWorker::_findBoardOnce(void)
     _timerRetry->start();
 }
 
-bool PX4FirmwareUpgradeThreadWorker::_findBoardFromPorts(QGCSerialPortInfo& portInfo, QGCSerialPortInfo::BoardType_t& boardType)
+bool PX4FirmwareUpgradeThreadWorker::_findBoardFromPorts(QGCSerialPortInfo& portInfo, QGCSerialPortInfo::BoardType_t& boardType, QString& boardName)
 {
     foreach (QGCSerialPortInfo info, QGCSerialPortInfo::availablePorts()) {
+        info.getBoardInfo(boardType, boardName);
+
         qCDebug(FirmwareUpgradeVerboseLog) << "Serial Port --------------";
-        qCDebug(FirmwareUpgradeVerboseLog) << "\tboard type" << info.boardType();
+        qCDebug(FirmwareUpgradeVerboseLog) << "\tboard type" << boardType;
+        qCDebug(FirmwareUpgradeVerboseLog) << "\tboard name" << boardName;
         qCDebug(FirmwareUpgradeVerboseLog) << "\tport name:" << info.portName();
         qCDebug(FirmwareUpgradeVerboseLog) << "\tdescription:" << info.description();
         qCDebug(FirmwareUpgradeVerboseLog) << "\tsystem location:" << info.systemLocation();
         qCDebug(FirmwareUpgradeVerboseLog) << "\tvendor ID:" << info.vendorIdentifier();
         qCDebug(FirmwareUpgradeVerboseLog) << "\tproduct ID:" << info.productIdentifier();
         
-        boardType = info.boardType();
         if (info.canFlash()) {
             portInfo = info;
             return true;

src/VehicleSetup/PX4FirmwareUpgradeThread.h

@@ -43,7 +43,7 @@ public:
     
 signals:
     void updateProgress(int curr, int total);
-    void foundBoard(bool firstAttempt, const QGCSerialPortInfo& portInfo, int type);
+    void foundBoard(bool firstAttempt, const QGCSerialPortInfo& portInfo, int type, QString boardName);
     void noBoardFound(void);
     void boardGone(void);
     void foundBootloader(int bootloaderVersion, int boardID, int flashSize);
@@ -64,7 +64,7 @@ private slots:
     void _cancel(void);
     
 private:
-    bool _findBoardFromPorts(QGCSerialPortInfo& portInfo, QGCSerialPortInfo::BoardType_t& boardType);
+    bool _findBoardFromPorts(QGCSerialPortInfo& portInfo, QGCSerialPortInfo::BoardType_t& boardType, QString& boardName);
     bool _findBootloader(const QGCSerialPortInfo& portInfo, bool radioMode, bool errorOnNotFound);
     void _3drRadioForceBootloader(const QGCSerialPortInfo& portInfo);
     bool _erase(void);
@@ -107,7 +107,7 @@ public:
     
 signals:
     /// @brief Emitted by the find board process when it finds a board.
-    void foundBoard(bool firstAttempt, const QGCSerialPortInfo &portInfo, int boardType);
+    void foundBoard(bool firstAttempt, const QGCSerialPortInfo &portInfo, int boardType, QString boardName);
     
     void noBoardFound(void);
     
@@ -142,7 +142,7 @@ signals:
     void _cancel(void);
     
 private slots:
-    void _foundBoard(bool firstAttempt, const QGCSerialPortInfo& portInfo, int type) { emit foundBoard(firstAttempt, portInfo, type); }
+    void _foundBoard(bool firstAttempt, const QGCSerialPortInfo& portInfo, int type, QString name) { emit foundBoard(firstAttempt, portInfo, type, name); }
     void _noBoardFound(void) { emit noBoardFound(); }
     void _boardGone(void) { emit boardGone(); }
     void _foundBootloader(int bootloaderVersion, int boardID, int flashSize) { emit foundBootloader(bootloaderVersion, boardID, flashSize); }

src/comm/LinkManager.cc

@@ -524,9 +524,10 @@ void LinkManager::_updateAutoConnectLinks(void)
         // Save port name
         currentPorts << portInfo.systemLocation();
 
-        QGCSerialPortInfo::BoardType_t boardType = portInfo.boardType();
+        QGCSerialPortInfo::BoardType_t boardType;
+        QString boardName;
 
-        if (boardType != QGCSerialPortInfo::BoardTypeUnknown) {
+        if (portInfo.getBoardInfo(boardType, boardName)) {
             if (portInfo.isBootloader()) {
                 // Don't connect to bootloader
                 qCDebug(LinkManagerLog) << "Waiting for bootloader to finish" << portInfo.systemLocation();
@@ -547,51 +548,25 @@ void LinkManager::_updateAutoConnectLinks(void)
                 _autoconnectWaitList.remove(portInfo.systemLocation());
 
                 switch (boardType) {
-                case QGCSerialPortInfo::BoardTypePX4FMUV1:
-                case QGCSerialPortInfo::BoardTypePX4FMUV2:
-                case QGCSerialPortInfo::BoardTypePX4FMUV4:
+                case QGCSerialPortInfo::BoardTypePixhawk:
                     if (_autoconnectPixhawk) {
-                        pSerialConfig = new SerialConfiguration(tr("Pixhawk on %1 (AutoConnect)").arg(portInfo.portName().trimmed()));
-                        pSerialConfig->setUsbDirect(true);
-                    }
-                    break;
-                case QGCSerialPortInfo::BoardTypeAeroCore:
-                    if (_autoconnectPixhawk) {
-                        pSerialConfig = new SerialConfiguration(tr("AeroCore on %1 (AutoConnect)").arg(portInfo.portName().trimmed()));
-                        pSerialConfig->setUsbDirect(true);
-                    }
-                    break;
-                case QGCSerialPortInfo::BoardTypeMINDPXFMUV2:
-                    if (_autoconnectPixhawk) {
-                        pSerialConfig = new SerialConfiguration(tr("MindPX on %1 (AutoConnect)").arg(portInfo.portName().trimmed()));
-                        pSerialConfig->setUsbDirect(true);
-                    }
-                    break;
-                case QGCSerialPortInfo::BoardTypeTAPV1:
-                    if (_autoconnectPixhawk) {
-                        pSerialConfig = new SerialConfiguration(tr("TAP on %1 (AutoConnect)").arg(portInfo.portName().trimmed()));
-                        pSerialConfig->setUsbDirect(true);
-                    }
-                    break;
-                case QGCSerialPortInfo::BoardTypeASCV1:
-                    if (_autoconnectPixhawk) {
-                        pSerialConfig = new SerialConfiguration(tr("ASC on %1 (AutoConnect)").arg(portInfo.portName().trimmed()));
+                        pSerialConfig = new SerialConfiguration(tr("%1 on %2 (AutoConnect)").arg(boardName).arg(portInfo.portName().trimmed()));
                         pSerialConfig->setUsbDirect(true);
                     }
                     break;
                 case QGCSerialPortInfo::BoardTypePX4Flow:
                     if (_autoconnectPX4Flow) {
-                        pSerialConfig = new SerialConfiguration(tr("PX4Flow on %1 (AutoConnect)").arg(portInfo.portName().trimmed()));
+                        pSerialConfig = new SerialConfiguration(tr("%1 on %2 (AutoConnect)").arg(boardName).arg(portInfo.portName().trimmed()));
                     }
                     break;
-                case QGCSerialPortInfo::BoardTypeSikRadio:
+                case QGCSerialPortInfo::BoardTypeSiKRadio:
                     if (_autoconnect3DRRadio) {
-                        pSerialConfig = new SerialConfiguration(tr("SiK Radio on %1 (AutoConnect)").arg(portInfo.portName().trimmed()));
+                        pSerialConfig = new SerialConfiguration(tr("%1 on %2 (AutoConnect)").arg(boardName).arg(portInfo.portName().trimmed()));
                     }
                     break;
-                case QGCSerialPortInfo::BoardTypeLibrePilot:
+                case QGCSerialPortInfo::BoardTypeOpenPilot:
                     if (_autoconnectLibrePilot) {
-                        pSerialConfig = new SerialConfiguration(tr("LibrePilot on %1 (AutoConnect)").arg(portInfo.portName().trimmed()));
+                        pSerialConfig = new SerialConfiguration(tr("%1 on %2 (AutoConnect)").arg(boardName).arg(portInfo.portName().trimmed()));
                     }
                     break;
 #ifndef __mobile__
@@ -609,7 +584,7 @@ void LinkManager::_updateAutoConnectLinks(void)
 
                 if (pSerialConfig) {
                     qCDebug(LinkManagerLog) << "New auto-connect port added: " << pSerialConfig->name() << portInfo.systemLocation();
-                    pSerialConfig->setBaud(boardType == QGCSerialPortInfo::BoardTypeSikRadio ? 57600 : 115200);
+                    pSerialConfig->setBaud(boardType == QGCSerialPortInfo::BoardTypeSiKRadio ? 57600 : 115200);
                     pSerialConfig->setDynamic(true);
                     pSerialConfig->setPortName(portInfo.systemLocation());
                     _sharedAutoconnectConfigurations.append(SharedLinkConfigurationPointer(pSerialConfig));

src/comm/QGCSerialPortInfo.h

@@ -27,25 +27,19 @@ class QGCSerialPortInfo : public QSerialPortInfo
 {
 public:
     typedef enum {
-        BoardTypePX4FMUV1,
-        BoardTypePX4FMUV2,
-        BoardTypePX4FMUV4,
+        BoardTypePixhawk,
+        BoardTypeSiKRadio,
         BoardTypePX4Flow,
-        BoardTypeSikRadio,
-        BoardTypeAeroCore,
+        BoardTypeOpenPilot,
         BoardTypeRTKGPS,
-        BoardTypeMINDPXFMUV2,
-        BoardTypeTAPV1,
-        BoardTypeASCV1,
-        BoardTypeLibrePilot,
         BoardTypeUnknown
     } BoardType_t;
 
     // Vendor and products ids for the boards we care about
 
-    static const int px4VendorId =                          9900;   ///< Vendor ID for Pixhawk board (V2 and V1) and PX4 Flow
-
-    static const int pixhawkFMUV4ProductId =                18;     ///< Product ID for Pixhawk V2 board
+    static const int px4VendorId =                          9900;   ///< Vendor ID for all Pixhawk boards and PX4 Flow
+    static const int pixhawkFMUV4ProductId =                18;     ///< Product ID for Pixhawk V4 board
+    static const int pixhawkFMUV4ProProductId =             19;     ///< Product ID for Pixhawk V4 Pro board
     static const int pixhawkFMUV2ProductId =                17;     ///< Product ID for Pixhawk V2 board
     static const int pixhawkFMUV2OldBootloaderProductId =   22;     ///< Product ID for Bootloader on older Pixhawk V2 boards
     static const int pixhawkFMUV1ProductId =                16;     ///< Product ID for PX4 FMU V1 board
@@ -79,18 +73,51 @@ public:
     /// Override of QSerialPortInfo::availablePorts
     static QList<QGCSerialPortInfo> availablePorts(void);
 
-    BoardType_t boardType(void) const;
+    bool getBoardInfo(BoardType_t& boardType, QString& name) const;
 
     /// @return true: we can flash this board type
     bool canFlash(void);
 
-    /// @return true: board is a Pixhawk board
-    bool boardTypePixhawk(void) const;
-
     /// @return true: Board is currently in bootloader
     bool isBootloader(void) const;
 
 private:
+    typedef struct {
+        const char* classString;
+        BoardType_t boardType;
+    } BoardClassString2BoardType_t;
+
+    typedef struct {
+        int         vendorId;
+        int         productId;
+        BoardType_t boardType;
+        QString     name;
+    } BoardInfo_t;
+
+    typedef struct {
+        QString     regExp;
+        BoardType_t boardType;
+        bool        androidOnly;
+    } BoardFallback_t;
+
+    static void _loadJsonData(void);
+    static BoardType_t _boardClassStringToType(const QString& boardClass);
+    static QString _boardTypeToString(BoardType_t boardType);
+
+    static bool         _jsonLoaded;
+    static const char*  _jsonFileTypeValue;
+    static const char*  _jsonBoardInfoKey;
+    static const char*  _jsonBoardFallbackKey;
+    static const char*  _jsonVendorIDKey;
+    static const char*  _jsonProductIDKey;
+    static const char*  _jsonBoardClassKey;
+    static const char*  _jsonNameKey;
+    static const char*  _jsonRegExpKey;
+    static const char*  _jsonAndroidOnlyKey;
+
+    static const BoardClassString2BoardType_t   _rgBoardClass2BoardType[BoardTypeUnknown];
+    static QList<BoardInfo_t>                   _boardInfoList;
+    static QList<BoardFallback_t>               _boardFallbackList;
 };
 
 #endif

src/comm/USBBoardInfo.json

+{
+    "comment":  "AutoConnect usb board info",
+
+    "version":          1,
+    "fileType":         "USBBoardInfo",
+    "groundStation":    "QGroundControl",
+
+    "boardInfo": [
+        { "vendorID": 9900, "productID": 16,        "boardClass": "Pixhawk",    "name": "PX4 FMU V1" },
+        { "vendorID": 9900, "productID": 17,        "boardClass": "Pixhawk",    "name": "PX4 FMU V2" },
+        { "vendorID": 9900, "productID": 18,        "boardClass": "Pixhawk",    "name": "PX4 FMU V4" },
+        { "vendorID": 9900, "productID": 22,        "boardClass": "Pixhawk",    "name": "PX4 FMU V2",           "comment": "Bootloader on older Pixhawk V2 boards" },
+        { "vendorID": 9900, "productID": 4097,      "boardClass": "Pixhawk",    "name": "AeroCore" },
+        { "vendorID": 9900, "productID": 48,        "boardClass": "Pixhawk",    "name": "MindPX FMU V2" },
+        { "vendorID": 9900, "productID": 64,        "boardClass": "Pixhawk",    "name": "TAP V1" },
+        { "vendorID": 9900, "productID": 65,        "boardClass": "Pixhawk",    "name": "ASC V1" },
+
+        { "vendorID": 9900, "productID": 21,        "boardClass": "PX4 Flow",   "name": "PX4 Flow" },
+
+        { "vendorID": 1027, "productID": 24597,     "boardClass": "SiK Radio",  "name": "SiK Radio",            "comment": "3DR Radio" },
+        { "vendorID": 4292, "productID": 600000,    "boardClass": "SiK Radio",  "name": "SiK Radio",            "comment": "SILabs Radio" },
+
+        { "vendorID": 546, "productID": 424,        "boardClass": "RTK GPS",    "name": "RTK GPS",              "comment": "Ublox RTK GPS" },
+
+        { "vendorID": 8352, "productID": 16732,     "boardClass": "OpenPilot",  "name": "OpenPilot OPLink" },
+        { "vendorID": 8352, "productID": 16733,     "boardClass": "OpenPilot",  "name": "OpenPilot CC3D" },
+        { "vendorID": 8352, "productID": 16734,     "boardClass": "OpenPilot",  "name": "OpenPilot Revolution" },
+        { "vendorID": 8352, "productID": 16848,     "boardClass": "OpenPilot",  "name": "Taulabs Sparky2" }
+    ],
+
+    "boardFallback": [
+        { "regExp": "^PX4 FMU v4.x$",       "boardClass": "Pixhawk" },
+        { "regExp": "^PX4 BL FMU v4.x$",    "boardClass": "Pixhawk" },
+        { "regExp": "^PX4 FMU v2.x$",       "boardClass": "Pixhawk" },
+        { "regExp": "^PX4 BL FMU v2.x$",    "boardClass": "Pixhawk" },
+        { "regExp": "^PX4 FMU v1.x$",       "boardClass": "Pixhawk" },
+        { "regExp": "^PX4 BL FMU v1.x$",    "boardClass": "Pixhawk" },
+        { "regExp": "^MindPX FMU v2.x$",    "boardClass": "Pixhawk" },
+        { "regExp": "^MindPX FMU v2.x$",    "boardClass": "Pixhawk" },
+        { "regExp": "^MindPX BL FMU v2.x$", "boardClass": "Pixhawk" },
+        { "regExp": "^PX4 TAP v1.x$",       "boardClass": "Pixhawk" },
+        { "regExp": "^PX4 BL TAP v1.x$",    "boardClass": "Pixhawk" },
+        { "regExp": "^PX4 ASC v1.x$",       "boardClass": "Pixhawk" },
+        { "regExp": "^PX4 BL ASC v1.x$",    "boardClass": "Pixhawk" },
+        { "regExp": "^PX4 FMU",             "boardClass": "Pixhawk" },
+        { "regExp": "PX4.*Flow",            "boardClass": "PX4 Flow" },
+        { "regExp": "^FT231X USB UART$",    "boardClass": "SiK Radio" },
+        { "regExp": "USB UART$",            "boardClass": "SiK Radio",  "androidOnly": true, "comment": "Very broad fallback, too dangerous for non-android" }
+    ]
+}