Allow multiple calibration measurements at once

Software/PC_Application/Calibration/calibration.cpp

@@ -25,6 +25,38 @@ Calibration::Calibration()
     type = Type::None;
 }
 
+Calibration::Standard Calibration::getPort1Standard(Calibration::Measurement m)
+{
+    switch(m) {
+    case Measurement::Port1Open: return Standard::Open;
+    case Measurement::Port1Short: return Standard::Short;
+    case Measurement::Port1Load: return Standard::Load;
+    case Measurement::Port2Open: return Standard::Any;
+    case Measurement::Port2Short: return Standard::Any;
+    case Measurement::Port2Load: return Standard::Any;
+    case Measurement::Through: return Standard::Through;
+    case Measurement::Isolation: return Standard::Load;
+    case Measurement::Line: return Standard::Through;
+    default: return Standard::Any;
+    }
+}
+
+Calibration::Standard Calibration::getPort2Standard(Calibration::Measurement m)
+{
+    switch(m) {
+    case Measurement::Port1Open: return Standard::Any;
+    case Measurement::Port1Short: return Standard::Any;
+    case Measurement::Port1Load: return Standard::Any;
+    case Measurement::Port2Open: return Standard::Open;
+    case Measurement::Port2Short: return Standard::Short;
+    case Measurement::Port2Load: return Standard::Load;
+    case Measurement::Through: return Standard::Through;
+    case Measurement::Isolation: return Standard::Load;
+    case Measurement::Line: return Standard::Through;
+    default: return Standard::Any;
+    }
+}
+
 void Calibration::clearMeasurements()
 {
     qDebug() << "Clearing all calibration measurements...";
@@ -33,6 +65,13 @@ void Calibration::clearMeasurements()
     }
 }
 
+void Calibration::clearMeasurements(std::set<Calibration::Measurement> types)
+{
+    for(auto t : types) {
+        clearMeasurement(t);
+    }
+}
+
 void Calibration::clearMeasurement(Calibration::Measurement type)
 {
     measurements[type].datapoints.clear();
@@ -46,6 +85,13 @@ void Calibration::addMeasurement(Calibration::Measurement type, Protocol::Datapo
     measurements[type].timestamp = QDateTime::currentDateTime();
 }
 
+void Calibration::addMeasurements(std::set<Calibration::Measurement> types, Protocol::Datapoint &d)
+{
+    for(auto t : types) {
+        addMeasurement(t, d);
+    }
+}
+
 bool Calibration::calculationPossible(Calibration::Type type)
 {
     if(type == Type::None) {

Software/PC_Application/Calibration/calibration.h

@@ -29,9 +29,23 @@ public:
         Line,
         Last,
     };
+
+    enum class Standard {
+        Open,
+        Short,
+        Load,
+        Through,
+        Any,
+    };
+
+    static Standard getPort1Standard(Measurement m);
+    static Standard getPort2Standard(Measurement m);
+
     void clearMeasurements();
+    void clearMeasurements(std::set<Measurement> types);
     void clearMeasurement(Measurement type);
     void addMeasurement(Measurement type, Protocol::Datapoint &d);
+    void addMeasurements(std::set<Measurement> types, Protocol::Datapoint &d);
 
     enum class Type {
         Port1SOL,

Software/PC_Application/Calibration/calibrationtracedialog.cpp

@@ -40,6 +40,13 @@ CalibrationTraceDialog::~CalibrationTraceDialog()
     delete ui;
 }
 
+void CalibrationTraceDialog::measurementsComplete(std::set<Calibration::Measurement> m)
+{
+    for(auto t : m) {
+        measurementComplete(t);
+    }
+}
+
 void CalibrationTraceDialog::measurementComplete(Calibration::Measurement m)
 {
     model->measurementUpdated(m);
@@ -69,8 +76,49 @@ void CalibrationTraceDialog::on_bDelete_clicked()
 
 void CalibrationTraceDialog::on_bMeasure_clicked()
 {
-    auto measurement = measurements[ui->tableView->currentIndex().row()];
+    std::set<Calibration::Measurement> m;
-    emit triggerMeasurement(measurement);
+    auto selected = ui->tableView->selectionModel()->selectedRows();
+    for(auto s : selected) {
+        m.insert(measurements[s.row()]);
+    }
+
+    // check if incompatible measurements are selected
+    auto p1Standard = Calibration::Standard::Any;
+    auto p2Standard = Calibration::Standard::Any;
+
+    bool okay = true;
+    for(auto type : m) {
+        auto p1Required = Calibration::getPort1Standard(type);
+        auto p2Required = Calibration::getPort2Standard(type);
+        if(p1Required != Calibration::Standard::Any) {
+            if(p1Standard == Calibration::Standard::Any) {
+                // first calibration measurement type that needs a specific standard
+                p1Standard = p1Required;
+            } else if(p1Required != p1Standard) {
+                // needs different standard than other measurement that has also been selected
+                okay = false;
+                break;
+            }
+        }
+        // same check for port 2
+        if(p2Required != Calibration::Standard::Any) {
+            if(p2Standard == Calibration::Standard::Any) {
+                // first calibration measurement type that needs a specific standard
+                p2Standard = p2Required;
+            } else if(p2Required != p2Standard) {
+                // needs different standard than other measurement that has also been selected
+                okay = false;
+                break;
+            }
+        }
+    }
+    if(!okay) {
+        // these measurements should not be taken at once, get user confirmation before continuing
+        okay = InformationBox::AskQuestion("Confirm selection", "The selected calibration measurements require different standards. Are you sure you want to measure them at the same time?", false);
+    }
+    if(okay) {
+        emit triggerMeasurements(m);
+    }
 }
 
 void CalibrationTraceDialog::on_bApply_clicked()

Software/PC_Application/Calibration/calibrationtracedialog.h

@@ -19,9 +19,10 @@ public:
     ~CalibrationTraceDialog();
 
 public slots:
+    void measurementsComplete(std::set<Calibration::Measurement> m);
     void measurementComplete(Calibration::Measurement m);
 signals:
-    void triggerMeasurement(Calibration::Measurement m);
+    void triggerMeasurements(std::set<Calibration::Measurement> m);
     void applyCalibration(Calibration::Type type);
     void calibrationInvalidated();
 

Software/PC_Application/VNA/vna.cpp

@@ -715,11 +715,10 @@ void VNA::NewDatapoint(Protocol::Datapoint d)
             // this is the last averaging sweep, use values for calibration
             if(!calWaitFirst || d.pointNum == 0) {
                 calWaitFirst = false;
-                cal.addMeasurement(calMeasurement, d);
+                cal.addMeasurements(calMeasurements, d);
                 if(d.pointNum == settings.npoints - 1) {
                     calMeasuring = false;
-                    qDebug() << "Calibration measurement" << cal.MeasurementToString(calMeasurement) << "complete";
+                    emit CalibrationMeasurementsComplete(calMeasurements);
-                    emit CalibrationMeasurementComplete(calMeasurement);
                 }
             }
         }
@@ -1025,7 +1024,7 @@ void VNA::ApplyCalibration(Calibration::Type type)
     }
 }
 
-void VNA::StartCalibrationMeasurement(Calibration::Measurement m)
+void VNA::StartCalibrationMeasurements(std::set<Calibration::Measurement> m)
 {
     auto device = window->getDevice();
     if(!device) {
@@ -1033,14 +1032,19 @@ void VNA::StartCalibrationMeasurement(Calibration::Measurement m)
     }
     // Stop sweep
     StopSweep();
-    qDebug() << "Taking" << Calibration::MeasurementToString(m) << "measurement";
+    calMeasurements = m;
-    calMeasurement = m;
     // Delete any already captured data of this measurement
-    cal.clearMeasurement(m);
+    cal.clearMeasurements(m);
     calWaitFirst = true;
-    QString text = "Measuring \"";
+    // show messagebox
-    text.append(Calibration::MeasurementToString(m));
+    QString text = "Measuring ";
-    text.append("\" parameters.");
+    if(m.size() == 1) {
+        text.append("\"");
+        text.append(Calibration::MeasurementToString(*m.begin()));
+        text.append("\" parameters.");
+    } else {
+        text.append("multiple calibration standards.");
+    }
     calDialog.setLabelText(text);
     calDialog.setCancelButtonText("Abort");
     calDialog.setWindowTitle("Taking calibration measurement...");
@@ -1051,7 +1055,7 @@ void VNA::StartCalibrationMeasurement(Calibration::Measurement m)
     connect(&calDialog, &QProgressDialog::canceled, [=]() {
         // the user aborted the calibration measurement
         calMeasuring = false;
-        cal.clearMeasurement(calMeasurement);
+        cal.clearMeasurements(calMeasurements);
     });
     // Trigger sweep to start from beginning
     SettingsChanged([=](Device::TransmissionResult){
@@ -1256,7 +1260,9 @@ void VNA::SetupSCPI()
                 // failed to parse string
                 return "ERROR";
             } else {
-                StartCalibrationMeasurement(meas);
+                std::set<Calibration::Measurement> m;
+                m.insert(meas);
+                StartCalibrationMeasurements(m);
             }
         }
         return "";
@@ -1340,9 +1346,9 @@ void VNA::StopSweep()
 void VNA::StartCalibrationDialog(Calibration::Type type)
 {
     auto traceDialog = new CalibrationTraceDialog(&cal, settings.Freq.start, settings.Freq.stop, type);
-    connect(traceDialog, &CalibrationTraceDialog::triggerMeasurement, this, &VNA::StartCalibrationMeasurement);
+    connect(traceDialog, &CalibrationTraceDialog::triggerMeasurements, this, &VNA::StartCalibrationMeasurements);
     connect(traceDialog, &CalibrationTraceDialog::applyCalibration, this, &VNA::ApplyCalibration);
-    connect(this, &VNA::CalibrationMeasurementComplete, traceDialog, &CalibrationTraceDialog::measurementComplete);
+    connect(this, &VNA::CalibrationMeasurementsComplete, traceDialog, &CalibrationTraceDialog::measurementsComplete);
     connect(traceDialog, &CalibrationTraceDialog::calibrationInvalidated, [=](){
        DisableCalibration(true);
        InformationBox::ShowMessageBlocking("Calibration disabled", "The currently active calibration is no longer supported by the available measurements and was disabled.");

Software/PC_Application/VNA/vna.h

@@ -77,11 +77,11 @@ private slots:
     // Calibration
     void DisableCalibration(bool force = false);
     void ApplyCalibration(Calibration::Type type);
-    void StartCalibrationMeasurement(Calibration::Measurement m);
+    void StartCalibrationMeasurements(std::set<Calibration::Measurement> m);
 
 
 signals:
-    void CalibrationMeasurementComplete(Calibration::Measurement m);
+    void CalibrationMeasurementsComplete(std::set<Calibration::Measurement> m);
     void graphColorsChanged();
 
 private:
@@ -109,7 +109,7 @@ private:
     Calibration cal;
     bool calValid;
     bool calEdited;
-    Calibration::Measurement calMeasurement;
+    std::set<Calibration::Measurement> calMeasurements;
     bool calMeasuring;
     bool calWaitFirst;
     QProgressDialog calDialog;