setupwizard.cpp

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>
 */

#include "setupwizard.h"
#include "pages/tlstartpage.h"
#include "pages/tlendpage.h"
#include "pages/boardtype_unknown.h"
#include "pages/controllerpage.h"
#include "pages/vehiclepage.h"
#include "pages/multipage.h"
#include "pages/fixedwingpage.h"
#include "pages/helipage.h"
#include "pages/surfacepage.h"
#include "pages/inputpage.h"
#include "pages/inputpage_notsupported.h"
#include "pages/outputpage.h"
#include "pages/biascalibrationpage.h"
#include "pages/summarypage.h"
#include "pages/savepage.h"
#include "pages/notyetimplementedpage.h"
#include "pages/rebootpage.h"
#include "pages/outputcalibrationpage.h"
#include "extensionsystem/pluginmanager.h"
#include "vehicleconfigurationhelper.h"
#include "actuatorsettings.h"

SetupWizard::SetupWizard(bool autoLaunched, QWidget *parent)
    : QWizard(parent)
    , VehicleConfigurationSource()
    , m_controllerType(NULL)
    , m_vehicleType(VEHICLE_UNKNOWN)
    , m_inputType(Core::IBoardType::INPUT_TYPE_UNKNOWN)
    , m_escType(ESC_UNKNOWN)
    , m_calibrationPerformed(false)
    , m_restartNeeded(false)
    , m_autoLaunched(autoLaunched)
    , m_connectionManager(nullptr)
{
    connect(this, &QWizard::rejected, this, &SetupWizard::boardIgnorePrompt);
    setWindowTitle(tr("dRonin Setup Wizard"));
    setOption(QWizard::IndependentPages, false);
    for (quint16 i = 0; i < ActuatorSettings::CHANNELMAX_NUMELEM; i++) {
        m_actuatorSettings << actuatorChannelSettings();
    }
    setWizardStyle(QWizard::ModernStyle);
    setMinimumSize(600, 500);
    resize(600, 500);
    createPages();
}

int SetupWizard::nextId() const
{
    switch (currentId()) {
    case PAGE_START:
        return PAGE_CONTROLLER;

    case PAGE_CONTROLLER: {
        ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
        Q_ASSERT(pm);
        UAVObjectUtilManager *utilMngr = pm->getObject<UAVObjectUtilManager>();
        Q_ASSERT(utilMngr);

        const QString fwHash = utilMngr->getFirmwareHash();
        const QString gcsHash = utilMngr->getGcsHash();
        if (!fwHash.length() || fwHash != gcsHash) {
            qobject_cast<BoardtypeUnknown *>(page(PAGE_BOARDTYPE_UNKNOWN))
                ->setFailureType(BoardtypeUnknown::UNKNOWN_FIRMWARE);
            return PAGE_BOARDTYPE_UNKNOWN;
        }

        Core::IBoardType *type = getControllerType();
        if (type == NULL) {
            qobject_cast<BoardtypeUnknown *>(page(PAGE_BOARDTYPE_UNKNOWN))
                ->setFailureType(BoardtypeUnknown::UNKNOWN_BOARD);
            return PAGE_BOARDTYPE_UNKNOWN;
        }

        if (type->isInputConfigurationSupported())
            return PAGE_INPUT;
        else
            return PAGE_INPUT_NOT_SUPPORTED;
    }
    case PAGE_VEHICLES: {
        switch (getVehicleType()) {
        case VEHICLE_MULTI:
            return PAGE_MULTI;

        case VEHICLE_FIXEDWING:
            return PAGE_FIXEDWING;

        case VEHICLE_HELI:
            return PAGE_HELI;

        case VEHICLE_SURFACE:
            return PAGE_SURFACE;

        default:
            return PAGE_NOTYETIMPLEMENTED;
        }
    }
    case PAGE_MULTI:
        return PAGE_OUTPUT;

    case PAGE_INPUT:
        if (isRestartNeeded()) {
            saveHardwareSettings();
            return PAGE_REBOOT;
        } else {
            return PAGE_VEHICLES;
        }
    case PAGE_REBOOT:
        return PAGE_VEHICLES;

    case PAGE_OUTPUT:
        return PAGE_SUMMARY;

    case PAGE_BIAS_CALIBRATION:
        return PAGE_OUTPUT_CALIBRATION;

    case PAGE_OUTPUT_CALIBRATION:
        return PAGE_SAVE;

    case PAGE_SUMMARY: {
        Core::IBoardType *type = getControllerType();
        if (type != NULL)
            return PAGE_BIAS_CALIBRATION;
        else
            return PAGE_NOTYETIMPLEMENTED;
    }
    case PAGE_SAVE:
        return PAGE_END;

    case PAGE_INPUT_NOT_SUPPORTED:
        // The user is informed on this page to configure manually and restart the wizard
        // but if they advance assume they have configured the input.
        return PAGE_VEHICLES;

    case PAGE_BOARDTYPE_UNKNOWN:
    case PAGE_NOTYETIMPLEMENTED:
        return PAGE_END;

    default:
        return -1;
    }
}

QString SetupWizard::getSummaryText()
{
    QString summary = "";

    summary.append("<b>").append(tr("Controller type: ")).append("</b>");
    Core::IBoardType *type = getControllerType();
    if (type != NULL)
        summary.append(type->shortName());
    else
        summary.append(tr("Unknown"));

    summary.append("<br>");
    summary.append("<b>").append(tr("Vehicle type: ")).append("</b>");
    switch (getVehicleType()) {
    case VEHICLE_MULTI:
        summary.append(tr("Multirotor"));

        summary.append("<br>");
        summary.append("<b>").append(tr("Vehicle sub type: ")).append("</b>");
        switch (getVehicleSubType()) {
        case SetupWizard::MULTI_ROTOR_TRI_Y:
            summary.append(tr("Tricopter"));
            break;
        case SetupWizard::MULTI_ROTOR_QUAD_X:
            summary.append(tr("Quadcopter X"));
            break;
        case SetupWizard::MULTI_ROTOR_QUAD_PLUS:
            summary.append(tr("Quadcopter +"));
            break;
        case SetupWizard::MULTI_ROTOR_HEXA:
            summary.append(tr("Hexacopter"));
            break;
        case SetupWizard::MULTI_ROTOR_HEXA_COAX_Y:
            summary.append(tr("Hexacopter Coax (Y6)"));
            break;
        case SetupWizard::MULTI_ROTOR_HEXA_H:
            summary.append(tr("Hexacopter X"));
            break;
        case SetupWizard::MULTI_ROTOR_OCTO:
            summary.append(tr("Octocopter"));
            break;
        case SetupWizard::MULTI_ROTOR_OCTO_COAX_X:
            summary.append(tr("Octocopter Coax X"));
            break;
        case SetupWizard::MULTI_ROTOR_OCTO_COAX_PLUS:
            summary.append(tr("Octocopter Coax +"));
            break;
        case SetupWizard::MULTI_ROTOR_OCTO_V:
            summary.append(tr("Octocopter V"));
            break;
        default:
            summary.append(tr("Unknown"));
            break;
        }

        break;
    case VEHICLE_FIXEDWING:
        summary.append(tr("Fixed wing"));
        break;
    case VEHICLE_HELI:
        summary.append(tr("Helicopter"));
        break;
    case VEHICLE_SURFACE:
        summary.append(tr("Surface vehicle"));
        break;
    default:
        summary.append(tr("Unknown"));
    }

    summary.append("<br>");
    summary.append("<b>").append(tr("Input type: ")).append("</b>");
    switch (getInputType()) {
    case Core::IBoardType::INPUT_TYPE_PWM:
        summary.append(tr("PWM (One cable per channel)"));
        break;
    case Core::IBoardType::INPUT_TYPE_PPM:
        summary.append(tr("PPM (One cable for all channels)"));
        break;
    case Core::IBoardType::INPUT_TYPE_SBUS:
        summary.append(tr("Futaba S.Bus"));
        break;
    case Core::IBoardType::INPUT_TYPE_SBUSNONINVERTED:
        summary.append(tr("Futaba S.Bus Non-inverted"));
        break;
    case Core::IBoardType::INPUT_TYPE_DSM:
        summary.append(tr("Spektrum satellite (DSM)"));
        break;
    case Core::IBoardType::INPUT_TYPE_HOTTSUMD:
        summary.append(tr("Graupner HoTT (SUMD)"));
        break;
    case Core::IBoardType::INPUT_TYPE_HOTTSUMH:
        summary.append(tr("Graupner HoTT (SUMH)"));
        break;
    case Core::IBoardType::INPUT_TYPE_IBUS:
        summary.append(tr("FlySky I-Bus"));
        break;
    case Core::IBoardType::INPUT_TYPE_SRXL:
        summary.append(tr("Multiplex SRXL"));
        break;
    case Core::IBoardType::INPUT_TYPE_TBSCROSSFIRE:
        summary.append(tr("Team BlackSheep Crossfire"));
        break;
    default:
        summary.append(tr("Unknown"));
    }

    summary.append("<br>");
    summary.append("<b>").append(tr("ESC type: ")).append("</b>");
    switch (getESCType()) {
    case ESC_LEGACY:
        summary.append(tr("Legacy ESC (50 Hz)"));
        break;
    case ESC_RAPID:
        summary.append(tr("Rapid ESC (400 Hz)"));
        break;
    case ESC_ONESHOT125:
        summary.append(tr("Oneshot125 (SyncPwm + 125-250us)"));
        break;
    case ESC_ONESHOT42:
        summary.append(tr("Oneshot42 (SyncPWM + 42-83us"));
        break;
    case ESC_DSHOT300:
        summary.append(tr("Dshot300"));
        break;
    case ESC_DSHOT600:
        summary.append(tr("Dshot600"));
        break;
    case ESC_DSHOT1200:
        summary.append(tr("Dshot1200"));
        break;
    default:
        summary.append(tr("Unknown"));
    }

    /*
       summary.append("<br>");
       summary.append("<b>").append(tr("Reboot required: ")).append("</b>");
       summary.append(isRestartNeeded() ? tr("<font color='red'>Yes</font>") : tr("<font
       color='green'>No</font>"));
     */
    return summary;
}

void SetupWizard::createPages()
{
    setPage(PAGE_START, new TLStartPage(this));
    setPage(PAGE_CONTROLLER, new ControllerPage(this));
    setPage(PAGE_VEHICLES, new VehiclePage(this));
    setPage(PAGE_MULTI, new MultiPage(this));
    setPage(PAGE_FIXEDWING, new FixedWingPage(this));
    setPage(PAGE_HELI, new HeliPage(this));
    setPage(PAGE_SURFACE, new SurfacePage(this));
    setPage(PAGE_INPUT, new InputPage(this));
    setPage(PAGE_INPUT_NOT_SUPPORTED, new InputPageNotSupported(this));
    setPage(PAGE_OUTPUT, new OutputPage(this));
    setPage(PAGE_BIAS_CALIBRATION, new BiasCalibrationPage(this));
    setPage(PAGE_OUTPUT_CALIBRATION, new OutputCalibrationPage(this));
    setPage(PAGE_SUMMARY, new SummaryPage(this));
    setPage(PAGE_SAVE, new SavePage(this));
    setPage(PAGE_REBOOT, new RebootPage(this));
    setPage(PAGE_NOTYETIMPLEMENTED, new NotYetImplementedPage(this));
    setPage(PAGE_BOARDTYPE_UNKNOWN, new BoardtypeUnknown(this));
    setPage(PAGE_END, new TLEndPage(this));

    setStartId(PAGE_START);

    connect(button(QWizard::CustomButton1), &QAbstractButton::clicked, this,
            &SetupWizard::customBackClicked);
    setButtonText(QWizard::CustomButton1, buttonText(QWizard::BackButton));
    QList<QWizard::WizardButton> button_layout;
    button_layout << QWizard::Stretch << QWizard::CustomButton1 << QWizard::NextButton
                  << QWizard::CancelButton << QWizard::FinishButton;
    setButtonLayout(button_layout);
    connect(this, &QWizard::currentIdChanged, this, &SetupWizard::pageChanged);
}

void SetupWizard::customBackClicked()
{
    if (currentId() == PAGE_OUTPUT_CALIBRATION) {
        static_cast<OutputCalibrationPage *>(currentPage())->customBackClicked();
    } else {
        back();
    }
}

void SetupWizard::pageChanged(int currId)
{
    button(QWizard::CustomButton1)->setVisible(currId != PAGE_START);
    button(QWizard::CancelButton)->setVisible(currId != PAGE_END);
}

bool SetupWizard::saveHardwareSettings() const
{
    VehicleConfigurationHelper helper(const_cast<SetupWizard *>(this));

    return helper.setupHardwareSettings();
}

void SetupWizard::boardIgnorePrompt()
{
    if (!m_autoLaunched)
        return;

    QMessageBox prompt(QMessageBox::Question, tr("Setup Wizard Cancelled"),
                       tr("Would you like to prevent the setup wizard from automatically opening"
                       " for the remainder of this session?"), QMessageBox::Yes | QMessageBox::No, this);
    if (prompt.exec() == QMessageBox::No)
        return;

    ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
    UAVObjectUtilManager *utilMngr = pm->getObject<UAVObjectUtilManager>();
    if (!utilMngr) {
        qWarning() << "Can't get UAVObjectUtilManager";
        Q_ASSERT(false);
        return;
    }
    emit boardIgnored(utilMngr->getBoardCPUSerial());
    qInfo() << "Setup wizard will be ignored for this board";
}