Merge pull request #122 from sophiekovalevsky/implement-scpi-result-name

scpi/app: unify result name
2022-07-02 23:58:32 +02:00 · 2022-07-02 23:58:32 +02:00 · ade970b35a
commit ade970b35a
parent 506502ce02 d392229c4d
6 changed files with 165 additions and 142 deletions
--- a/Software/PC_Application/Generator/generator.cpp
+++ b/Software/PC_Application/Generator/generator.cpp
@ -70,10 +70,10 @@ void Generator::setupSCPI()
    add(new SCPICommand("FREQuency", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            central->setFrequency(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(central->getDeviceStatus().frequency);
@ -82,10 +82,10 @@ void Generator::setupSCPI()
        double newval;
        if(!SCPI::paramToDouble(params, 0, newval)) {

-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            central->setLevel(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(central->getDeviceStatus().cdbm_level / 100.0);
@ -93,10 +93,10 @@ void Generator::setupSCPI()
    add(new SCPICommand("PORT", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval) || newval > 2) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            central->setPort(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(central->getDeviceStatus().activePort);
--- a/Software/PC_Application/SpectrumAnalyzer/spectrumanalyzer.cpp
+++ b/Software/PC_Application/SpectrumAnalyzer/spectrumanalyzer.cpp
@ -837,10 +837,10 @@ void SpectrumAnalyzer::SetupSCPI()
    scpi_freq->add(new SCPICommand("SPAN", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetSpan(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.f_stop - settings.f_start, 'f', 0);
@ -848,10 +848,10 @@ void SpectrumAnalyzer::SetupSCPI()
    scpi_freq->add(new SCPICommand("START", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetStartFreq(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.f_start, 'f', 0);
@ -859,10 +859,10 @@ void SpectrumAnalyzer::SetupSCPI()
    scpi_freq->add(new SCPICommand("CENTer", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetCenterFreq(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number((settings.f_start + settings.f_stop)/2, 'f', 0);
@ -870,10 +870,10 @@ void SpectrumAnalyzer::SetupSCPI()
    scpi_freq->add(new SCPICommand("STOP", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetStopFreq(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.f_stop, 'f', 0);
@ -881,29 +881,29 @@ void SpectrumAnalyzer::SetupSCPI()
    scpi_freq->add(new SCPICommand("FULL", [=](QStringList params) -> QString {
        Q_UNUSED(params)
        SetFullSpan();
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));
    scpi_freq->add(new SCPICommand("ZERO", [=](QStringList params) -> QString {
        Q_UNUSED(params)
        SetZeroSpan();
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));
    auto scpi_acq = new SCPINode("ACQuisition");
    SCPINode::add(scpi_acq);
    scpi_acq->add(new SCPICommand("RBW", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetRBW(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.RBW);
    }));
    scpi_acq->add(new SCPICommand("WINDow", [=](QStringList params) -> QString {
        if (params.size() != 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        if (params[0] == "NONE") {
            SetWindow(Window::None);
@ -916,19 +916,19 @@ void SpectrumAnalyzer::SetupSCPI()
        } else {
            return "INVALID WINDOW";
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        switch((Window) settings.WindowType) {
        case Window::None: return "NONE";
        case Window::Kaiser: return "KAISER";
        case Window::Hann: return "HANN";
        case Window::FlatTop: return "FLATTOP";
-        default: return "ERROR";
+        default: return SCPI::getResultName(SCPI::Result::Error);
        }
    }));
    scpi_acq->add(new SCPICommand("DETector", [=](QStringList params) -> QString {
        if (params.size() != 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        if (params[0] == "+PEAK") {
            SetDetector(Detector::PPeak);
@ -943,7 +943,7 @@ void SpectrumAnalyzer::SetupSCPI()
        } else {
            return "INVALID MDOE";
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        switch((Detector) settings.Detector) {
        case Detector::PPeak: return "+PEAK";
@ -951,16 +951,16 @@ void SpectrumAnalyzer::SetupSCPI()
        case Detector::Normal: return "NORMAL";
        case Detector::Sample: return "SAMPLE";
        case Detector::Average: return "AVERAGE";
-        default: return "ERROR";
+        default: return SCPI::getResultName(SCPI::Result::Error);
        }
    }));
    scpi_acq->add(new SCPICommand("AVG", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetAveraging(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(averages);
@ -976,59 +976,59 @@ void SpectrumAnalyzer::SetupSCPI()
    }));
    scpi_acq->add(new SCPICommand("SIGid", [=](QStringList params) -> QString {
        if (params.size() != 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        if(params[0] == "1" || params[0] == "TRUE") {
            SetSignalID(true);
        } else if(params[0] == "0" || params[0] == "FALSE") {
            SetSignalID(false);
        } else {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
-        return settings.SignalID ? "TRUE" : "FALSE";
+        return settings.SignalID ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
    }));
    scpi_acq->add(new SCPICommand("SINGLE", [=](QStringList params) -> QString {
        bool single;
        if(!SCPI::paramToBool(params, 0, single)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetSingleSweep(single);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
-        return singleSweep ? "TRUE" : "FALSE";
+        return singleSweep ? SCPI::getResultName(SCPI::Result::True): SCPI::getResultName(SCPI::Result::False);
    }));
    auto scpi_tg = new SCPINode("TRACKing");
    SCPINode::add(scpi_tg);
    scpi_tg->add(new SCPICommand("ENable", [=](QStringList params) -> QString {
        if (params.size() != 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        if(params[0] == "1" || params[0] == "TRUE") {
            SetTGEnabled(true);
        } else if(params[0] == "0" || params[0] == "FALSE") {
            SetTGEnabled(false);
        } else {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
-        return settings.trackingGenerator ? "TRUE" : "FALSE";
+        return settings.trackingGenerator ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
    }));
    scpi_tg->add(new SCPICommand("Port", [=](QStringList params) -> QString {
        if (params.size() != 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        if(params[0] == "1") {
            SetTGPort(0);
        } else if(params[0] == "2") {
            SetTGPort(1);
        } else {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        return settings.trackingGeneratorPort ? "2" : "1";
    }));
@ -1036,10 +1036,10 @@ void SpectrumAnalyzer::SetupSCPI()
        double newval;
        if(!SCPI::paramToDouble(params, 0, newval)) {

-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetTGLevel(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.trackingPower / 100.0);
@ -1047,10 +1047,10 @@ void SpectrumAnalyzer::SetupSCPI()
    scpi_tg->add(new SCPICommand("OFFset", [=](QStringList params) -> QString {
        long newval;
        if(!SCPI::paramToLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetTGOffset(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.trackingGeneratorOffset);
@ -1059,18 +1059,18 @@ void SpectrumAnalyzer::SetupSCPI()
    scpi_tg->add(scpi_norm);
    scpi_norm->add(new SCPICommand("ENable", [=](QStringList params) -> QString {
        if (params.size() != 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        if(params[0] == "1" || params[0] == "TRUE") {
            EnableNormalization(true);
        } else if(params[0] == "0" || params[0] == "FALSE") {
            EnableNormalization(false);
        } else {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
-        return normalize.active ? "TRUE" : "FALSE";
+        return normalize.active ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
    }));
    scpi_norm->add(new SCPICommand("MEASure", [=](QStringList params) -> QString {
        Q_UNUSED(params)
@ -1080,10 +1080,10 @@ void SpectrumAnalyzer::SetupSCPI()
    scpi_norm->add(new SCPICommand("LVL", [=](QStringList params) -> QString {
        double newval;
        if(!SCPI::paramToDouble(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetNormalizationLevel(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(normalize.Level->value());
--- a/Software/PC_Application/VNA/vna.cpp
+++ b/Software/PC_Application/VNA/vna.cpp
@ -1290,11 +1290,11 @@ void VNA::SetupSCPI()
                return "";
            } else if(params[0] == "POWER") {
                SetSweepType(SweepType::Power);
-                return "";
+                return SCPI::getResultName(SCPI::Result::Empty);
            }
        }
        // either no parameter or invalid
-        return "ERROR";
+        return SCPI::getResultName(SCPI::Result::Error);
    }, [=](QStringList) -> QString {
        return settings.sweepType == SweepType::Frequency ? "FREQUENCY" : "POWER";
    }));
@ -1303,10 +1303,10 @@ void VNA::SetupSCPI()
    scpi_freq->add(new SCPICommand("SPAN", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetSpan(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.Freq.stop - settings.Freq.start, 'f', 0);
@ -1314,10 +1314,10 @@ void VNA::SetupSCPI()
    scpi_freq->add(new SCPICommand("START", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetStartFreq(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.Freq.start, 'f', 0);
@ -1325,10 +1325,10 @@ void VNA::SetupSCPI()
    scpi_freq->add(new SCPICommand("CENTer", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetCenterFreq(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number((settings.Freq.start + settings.Freq.stop)/2, 'f', 0);
@ -1336,10 +1336,10 @@ void VNA::SetupSCPI()
    scpi_freq->add(new SCPICommand("STOP", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetStopFreq(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.Freq.stop, 'f', 0);
@ -1347,22 +1347,22 @@ void VNA::SetupSCPI()
    scpi_freq->add(new SCPICommand("FULL", [=](QStringList params) -> QString {
        Q_UNUSED(params)
        SetFullSpan();
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));
    scpi_freq->add(new SCPICommand("ZERO", [=](QStringList params) -> QString {
        Q_UNUSED(params)
        SetZeroSpan();
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));
    auto scpi_power = new SCPINode("POWer");
    SCPINode::add(scpi_power);
    scpi_power->add(new SCPICommand("START", [=](QStringList params) -> QString {
        double newval;
        if(!SCPI::paramToDouble(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetStartPower(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.Power.start);
@ -1370,10 +1370,10 @@ void VNA::SetupSCPI()
    scpi_power->add(new SCPICommand("STOP", [=](QStringList params) -> QString {
        double newval;
        if(!SCPI::paramToDouble(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetStopPower(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.Power.stop);
@ -1383,10 +1383,10 @@ void VNA::SetupSCPI()
    scpi_acq->add(new SCPICommand("IFBW", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetIFBandwidth(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.bandwidth);
@ -1394,10 +1394,10 @@ void VNA::SetupSCPI()
    scpi_acq->add(new SCPICommand("POINTS", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetPoints(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.npoints);
@ -1405,10 +1405,10 @@ void VNA::SetupSCPI()
    scpi_acq->add(new SCPICommand("AVG", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetAveraging(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(averages);
@ -1417,7 +1417,7 @@ void VNA::SetupSCPI()
        return QString::number(average.getLevel());
    }));
    scpi_acq->add(new SCPICommand("FINished", nullptr, [=](QStringList) -> QString {
-        return average.getLevel() == averages ? "TRUE" : "FALSE";
+        return average.getLevel() == averages ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
    }));
    scpi_acq->add(new SCPICommand("LIMit", nullptr, [=](QStringList) -> QString {
        return central->allLimitsPassing() ? "PASS" : "FAIL";
@ -1425,23 +1425,23 @@ void VNA::SetupSCPI()
    scpi_acq->add(new SCPICommand("SINGLE", [=](QStringList params) -> QString {
        bool single;
        if(!SCPI::paramToBool(params, 0, single)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetSingleSweep(single);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
-        return singleSweep ? "TRUE" : "FALSE";
+        return singleSweep ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
    }));
    auto scpi_stim = new SCPINode("STIMulus");
    SCPINode::add(scpi_stim);
    scpi_stim->add(new SCPICommand("LVL", [=](QStringList params) -> QString {
        double newval;
        if(!SCPI::paramToDouble(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetSourceLevel(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.Freq.excitation_power);
@ -1449,10 +1449,10 @@ void VNA::SetupSCPI()
    scpi_stim->add(new SCPICommand("FREQuency", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetPowerSweepFrequency(newval);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.Power.frequency, 'f', 0);
@ -1462,12 +1462,12 @@ void VNA::SetupSCPI()
    SCPINode::add(scpi_cal);
    scpi_cal->add(new SCPICommand("TYPE", [=](QStringList params) -> QString {
        if(params.size() != 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            auto type = Calibration::TypeFromString(params[0].replace('_', ' '));
            if(type == Calibration::Type::Last) {
                // failed to parse string
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            } else if(type == Calibration::Type::None) {
                DisableCalibration();
            } else {
@ -1475,11 +1475,11 @@ void VNA::SetupSCPI()
                if(cal.calculationPossible(type)) {
                    ApplyCalibration(type);
                } else {
-                    return "ERROR";
+                    return SCPI::getResultName(SCPI::Result::Error);
                }
            }
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        auto ret = Calibration::TypeToString(cal.getType());
        ret.replace(' ', '_');
@ -1488,43 +1488,43 @@ void VNA::SetupSCPI()
    scpi_cal->add(new SCPICommand("MEASure", [=](QStringList params) -> QString {
        if(params.size() != 1 || CalibrationMeasurementActive() || !window->getDevice() || Mode::getActiveMode() != this) {
            // no measurement specified, still busy or invalid mode
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            auto meas = Calibration::MeasurementFromString(params[0].replace('_', ' '));
            if(meas == Calibration::Measurement::Last) {
                // failed to parse string
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            } else {
                std::set<Calibration::Measurement> m;
                m.insert(meas);
                StartCalibrationMeasurements(m);
            }
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));
    scpi_cal->add(new SCPICommand("BUSy", nullptr, [=](QStringList) -> QString {
-        return CalibrationMeasurementActive() ? "TRUE" : "FALSE";
+        return CalibrationMeasurementActive() ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
    }));
    scpi_cal->add(new SCPICommand("SAVE", [=](QStringList params) -> QString {
        if(params.size() != 1 || !calValid) {
            // no filename given or no calibration active
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        if(!cal.saveToFile(params[0])) {
            // some error when writing the calibration file
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        calEdited = false;
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));
    scpi_cal->add(new SCPICommand("LOAD", nullptr, [=](QStringList params) -> QString {
        if(params.size() != 1) {
            // no filename given or no calibration active
-            return "FALSE";
+            return SCPI::getResultName(SCPI::Result::False);
        }
        if(!cal.openFromFile(params[0])) {
            // some error when loading the calibration file
-            return "FALSE";
+            return SCPI::getResultName(SCPI::Result::False);
        }
        if(cal.getType() == Calibration::Type::None) {
            DisableCalibration();
@ -1532,7 +1532,7 @@ void VNA::SetupSCPI()
            ApplyCalibration(cal.getType());
        }
        calEdited = false;
-        return "TRUE";
+        return SCPI::getResultName(SCPI::Result::True);
    }));
 }

--- a/Software/PC_Application/appwindow.cpp
+++ b/Software/PC_Application/appwindow.cpp
@ -475,7 +475,7 @@ void AppWindow::SetupSCPI()
    scpi_dev->add(new SCPICommand("DISConnect", [=](QStringList params) -> QString {
        Q_UNUSED(params)
        DisconnectDevice();
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));
    scpi_dev->add(new SCPICommand("CONNect", [=](QStringList params) -> QString {
        QString serial;
@ -485,7 +485,7 @@ void AppWindow::SetupSCPI()
        if(!ConnectToDevice(serial)) {
            return "Device not found";
        } else {
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        if(device) {
@ -507,7 +507,7 @@ void AppWindow::SetupSCPI()
    scpi_dev->add(scpi_ref);
    scpi_ref->add(new SCPICommand("OUT", [=](QStringList params) -> QString {
        if(params.size() != 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else if(params[0] == "0" || params[0] == "OFF") {
            int index = toolbars.reference.outFreq->findData((int)Reference::OutFreq::Off);
            toolbars.reference.outFreq->setCurrentIndex(index);
@ -518,21 +518,21 @@ void AppWindow::SetupSCPI()
            int index = toolbars.reference.outFreq->findData((int)Reference::OutFreq::MHZ100);
            toolbars.reference.outFreq->setCurrentIndex(index);
        } else {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        Reference::OutFreq f = static_cast<Reference::OutFreq>(toolbars.reference.outFreq->currentData().toInt());
        switch(f) {
        case Reference::OutFreq::Off: return "OFF";
        case Reference::OutFreq::MHZ10: return "10";
        case Reference::OutFreq::MHZ100: return "100";
-        default: return "ERROR";
+        default: return SCPI::getResultName(SCPI::Result::Error);
        }
    }));
    scpi_ref->add(new SCPICommand("IN", [=](QStringList params) -> QString {
        if(params.size() != 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        } else if(params[0] == "INT") {
            int index = toolbars.reference.type->findData((int)Reference::TypeIn::Internal);
            toolbars.reference.type->setCurrentIndex(index);
@ -543,19 +543,19 @@ void AppWindow::SetupSCPI()
            int index = toolbars.reference.type->findData((int)Reference::TypeIn::Auto);
            toolbars.reference.type->setCurrentIndex(index);
        } else {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        switch(Device::StatusV1(getDevice()).extRefInUse) {
        case 0: return "INT";
        case 1: return "EXT";
-        default: return "ERROR";
+        default: return SCPI::getResultName(SCPI::Result::Error);
        }
    }));
    scpi_dev->add(new SCPICommand("MODE", [=](QStringList params) -> QString {
        if (params.size() != 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        Mode *mode = nullptr;
        if (params[0] == "VNA") {
@ -569,9 +569,9 @@ void AppWindow::SetupSCPI()
        }
        if(mode) {
            mode->activate();
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        } else {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
    }, [=](QStringList) -> QString {
        auto active = Mode::getActiveMode();
@ -582,7 +582,7 @@ void AppWindow::SetupSCPI()
            case Mode::Type::SA: return "SA";
            }
        }
-        return "ERROR";
+        return SCPI::getResultName(SCPI::Result::Error);
    }));
    auto scpi_status = new SCPINode("STAtus");
    scpi_dev->add(scpi_status);
@ -643,29 +643,29 @@ void AppWindow::SetupSCPI()
    auto scpi_manual = new SCPINode("MANual");
    scpi_manual->add(new SCPICommand("STArt",[=](QStringList) -> QString {
        StartManualControl();
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));
    scpi_manual->add(new SCPICommand("STOp",[=](QStringList) -> QString {
        manual->close();
        delete manual;
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));

    auto addBooleanManualSetting = [=](QString cmd, void(ManualControlDialog::*set)(bool), bool(ManualControlDialog::*get)(void)) {
        scpi_manual->add(new SCPICommand(cmd, [=](QStringList params) -> QString {
            bool enable;
            if(!manual || !SCPI::paramToBool(params, 0, enable)) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto set_fn = std::bind(set, manual, std::placeholders::_1);
            set_fn(enable);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }, [=](QStringList) -> QString {
            if(!manual) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto get_fn = std::bind(get, manual);
-            return get_fn() ? "TRUE" : "FALSE";
+            return get_fn() ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
        }));
    };

@ -673,14 +673,14 @@ void AppWindow::SetupSCPI()
        scpi_manual->add(new SCPICommand(cmd, [=](QStringList params) -> QString {
            double value;
            if(!manual || !SCPI::paramToDouble(params, 0, value)) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto set_fn = std::bind(set, manual, std::placeholders::_1);
            set_fn(value);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }, [=](QStringList) -> QString {
            if(!manual) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto get_fn = std::bind(get, manual);
            return QString::number(get_fn());
@ -690,14 +690,14 @@ void AppWindow::SetupSCPI()
        scpi_manual->add(new SCPICommand(cmd, [=](QStringList params) -> QString {
            double value;
            if(!manual || !SCPI::paramToDouble(params, 0, value)) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto set_fn = std::bind(set, manual, std::placeholders::_1);
            set_fn(value);
-            return "";
+            return SCPI::getResultName(SCPI::Result::Empty);
        }, [=](QStringList) -> QString {
            if(!manual) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto get_fn = std::bind(get, manual);
            return QString::number(get_fn());
@ -707,17 +707,17 @@ void AppWindow::SetupSCPI()
        scpi_manual->add(new SCPICommand(cmd, [=](QStringList params) -> QString {
            double value;
            if(!manual || !SCPI::paramToDouble(params, 0, value)) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto set_fn = std::bind(set, manual, std::placeholders::_1);
            if(set_fn(value)) {
-                return "";
+                return SCPI::getResultName(SCPI::Result::Empty);
            } else {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
        }, [=](QStringList) -> QString {
            if(!manual) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto get_fn = std::bind(get, manual);
            return QString::number(get_fn());
@ -726,7 +726,7 @@ void AppWindow::SetupSCPI()
    auto addIntegerManualQuery = [=](QString cmd, int(ManualControlDialog::*get)(void)) {
        scpi_manual->add(new SCPICommand(cmd, nullptr, [=](QStringList) -> QString {
            if(!manual) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto get_fn = std::bind(get, manual);
            return QString::number(get_fn());
@ -735,7 +735,7 @@ void AppWindow::SetupSCPI()
    auto addDoubleManualQuery = [=](QString cmd, double(ManualControlDialog::*get)(void)) {
        scpi_manual->add(new SCPICommand(cmd, nullptr, [=](QStringList) -> QString {
            if(!manual) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto get_fn = std::bind(get, manual);
            return QString::number(get_fn());
@ -744,16 +744,16 @@ void AppWindow::SetupSCPI()
    auto addBooleanManualQuery = [=](QString cmd, bool(ManualControlDialog::*get)(void)) {
        scpi_manual->add(new SCPICommand(cmd, nullptr, [=](QStringList) -> QString {
            if(!manual) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto get_fn = std::bind(get, manual);
-            return get_fn() ? "TRUE" : "FALSE";
+            return get_fn() ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
        }));
    };
    auto addComplexManualQuery = [=](QString cmd, std::complex<double>(ManualControlDialog::*get)(void)) {
        scpi_manual->add(new SCPICommand(cmd, nullptr, [=](QStringList) -> QString {
            if(!manual) {
-                return "ERROR";
+                return SCPI::getResultName(SCPI::Result::Error);
            }
            auto get_fn = std::bind(get, manual);
            auto res = get_fn();
@ -769,7 +769,7 @@ void AppWindow::SetupSCPI()
    scpi_manual->add(new SCPICommand("HSRC_LPF", [=](QStringList params) -> QString {
        long value;
        if(!manual || !SCPI::paramToLong(params, 0, value)) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        switch(value) {
        case 947:
@ -785,12 +785,12 @@ void AppWindow::SetupSCPI()
            manual->setHighSourceLPF(ManualControlDialog::LPF::None);
            break;
        default:
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        if(!manual) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        auto lpf = manual->getHighSourceLPF();
        switch(lpf) {
@ -798,7 +798,7 @@ void AppWindow::SetupSCPI()
        case ManualControlDialog::LPF::M1880: return "1880";
        case ManualControlDialog::LPF::M3500: return "3500";
        case ManualControlDialog::LPF::None: return "0";
-        default: return "ERROR";
+        default: return SCPI::getResultName(SCPI::Result::Error);
        }
    }));
    addBooleanManualSetting("LSRC_EN", &ManualControlDialog::setLowSourceEnable, &ManualControlDialog::getLowSourceEnable);
@ -822,7 +822,7 @@ void AppWindow::SetupSCPI()
    addIntegerManualSetting("SAMPLES", &ManualControlDialog::setNumSamples, &ManualControlDialog::getNumSamples);
    scpi_manual->add(new SCPICommand("WINdow", [=](QStringList params) -> QString {
        if(!manual || params.size() < 1) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        if (params[0] == "NONE") {
            manual->setWindow(ManualControlDialog::Window::None);
@ -835,17 +835,17 @@ void AppWindow::SetupSCPI()
        } else {
            return "INVALID WINDOW";
        }
-        return "";
+        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        if(!manual) {
-            return "ERROR";
+            return SCPI::getResultName(SCPI::Result::Error);
        }
        switch((ManualControlDialog::Window) manual->getWindow()) {
        case ManualControlDialog::Window::None: return "NONE";
        case ManualControlDialog::Window::Kaiser: return "KAISER";
        case ManualControlDialog::Window::Hann: return "HANN";
        case ManualControlDialog::Window::FlatTop: return "FLATTOP";
-        default: return "ERROR";
+        default: return SCPI::getResultName(SCPI::Result::Error);
        }
    }));
    addIntegerManualQuery("PORT1_MIN", &ManualControlDialog::getPort1MinADC);
--- a/Software/PC_Application/scpi.cpp
+++ b/Software/PC_Application/scpi.cpp
@ -79,6 +79,20 @@ bool SCPI::paramToBool(QStringList params, int index, bool &dest)
    return okay;
 }

+QString SCPI::getResultName(SCPI::Result r)
+{
+    switch (r) {
+    case Result::Empty:
+        return "";
+    case Result::Error:
+        return "ERROR";
+    case Result::False:
+        return "FALSE";
+    case Result::True:
+        return "TRUE";
+    }
+}
+
 void SCPI::input(QString line)
 {
    auto cmds = line.split(";");
@ -191,7 +205,7 @@ QString SCPINode::parse(QString cmd, SCPINode* &lastNode)
            }
        }
        // unable to find subnode
-        return "ERROR";
+        return SCPI::getResultName(SCPI::Result::Error);
    } else {
        // no more levels, search for command
        auto params = cmd.split(" ");
@ -214,14 +228,14 @@ QString SCPINode::parse(QString cmd, SCPINode* &lastNode)
            }
        }
        // couldn't find command
-        return "ERROR";
+        return SCPI::getResultName(SCPI::Result::Error);
    }
 }

 QString SCPICommand::execute(QStringList params)
 {
    if(fn_cmd == nullptr) {
-        return "ERROR";
+        return SCPI::getResultName(SCPI::Result::Error);
    } else {
        return fn_cmd(params);
    }
@ -230,7 +244,7 @@ QString SCPICommand::execute(QStringList params)
 QString SCPICommand::query(QStringList params)
 {
    if(fn_query == nullptr) {
-        return "ERROR";
+        return SCPI::getResultName(SCPI::Result::Error);
    } else {
        return fn_query(params);
    }
--- a/Software/PC_Application/scpi.h
+++ b/Software/PC_Application/scpi.h
@ -59,6 +59,15 @@ public:
    static bool paramToLong(QStringList params, int index, long &dest);
    static bool paramToBool(QStringList params, int index, bool &dest);

+    enum class Result {
+        Empty,
+        Error,
+        False,
+        True
+    };
+
+    static QString getResultName(SCPI::Result r);
+
 public slots:
    void input(QString line);
 signals: