From c6ef075f4f662e51765c5d6948d256a3d996b3f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20K=C3=A4berich?= Date: Sun, 3 Apr 2022 20:26:30 +0200 Subject: [PATCH] split device info and status protocol messages --- .../Calibration/amplitudecaldialog.cpp | 6 +- Software/PC_Application/Device/device.cpp | 82 +++++++++++++------ Software/PC_Application/Device/device.h | 19 +++-- .../Device/manualcontroldialog.cpp | 4 +- .../Device/manualcontroldialog.h | 2 +- .../PC_Application/Generator/generator.cpp | 2 +- .../Generator/signalgenwidget.cpp | 29 +++---- .../Generator/signalgenwidget.h | 3 +- .../SpectrumAnalyzer/spectrumanalyzer.cpp | 56 ++++++------- Software/PC_Application/VNA/vna.cpp | 50 +++++------ Software/PC_Application/appwindow.cpp | 48 +++++------ Software/PC_Application/appwindow.h | 4 +- Software/VNA_embedded/Application/App.cpp | 15 +++- .../Application/Communication/Protocol.cpp | 5 +- .../Application/Communication/Protocol.hpp | 42 ++++++---- .../VNA_embedded/Application/Generator.cpp | 2 +- .../VNA_embedded/Application/Hardware.cpp | 26 +++--- .../VNA_embedded/Application/Hardware.hpp | 13 +-- Software/VNA_embedded/Application/Manual.cpp | 34 ++++---- Software/VNA_embedded/Application/Manual.hpp | 2 +- .../Application/SpectrumAnalyzer.cpp | 4 +- Software/VNA_embedded/Application/VNA.cpp | 4 +- 22 files changed, 248 insertions(+), 204 deletions(-) diff --git a/Software/PC_Application/Calibration/amplitudecaldialog.cpp b/Software/PC_Application/Calibration/amplitudecaldialog.cpp index adb0b0c..b75e7df 100644 --- a/Software/PC_Application/Calibration/amplitudecaldialog.cpp +++ b/Software/PC_Application/Calibration/amplitudecaldialog.cpp @@ -253,7 +253,7 @@ void AmplitudeCalDialog::RemoveAllPoints() bool AmplitudeCalDialog::AddPoint(AmplitudeCalDialog::CorrectionPoint &p) { - if (points.size() >= Device::Info().limits_maxAmplitudePoints) { + if (points.size() >= Device::Info(dev).limits_maxAmplitudePoints) { // already at limit return false; } @@ -299,8 +299,8 @@ void AmplitudeCalDialog::AddPointDialog() ui->stopFreq->setUnit("Hz"); ui->stopFreq->setPrefixes(" kMG"); ui->frequency->setValue(1000000000.0); - ui->startFreq->setValue(Device::Info().limits_minFreq); - ui->stopFreq->setValue(Device::Info().limits_maxFreq); + ui->startFreq->setValue(Device::Info(dev).limits_minFreq); + ui->stopFreq->setValue(Device::Info(dev).limits_maxFreq); connect(ui->singlePoint, &QRadioButton::toggled, [=](bool single) { ui->stopFreq->setEnabled(!single); ui->startFreq->setEnabled(!single); diff --git a/Software/PC_Application/Device/device.cpp b/Software/PC_Application/Device/device.cpp index f97ff45..a07718d 100644 --- a/Software/PC_Application/Device/device.cpp +++ b/Software/PC_Application/Device/device.cpp @@ -120,16 +120,6 @@ static constexpr Protocol::DeviceInfo defaultInfo = { .FW_minor = 0, .FW_patch = 0, .HW_Revision = '0', - .extRefAvailable = 0, - .extRefInUse = 0, - .FPGA_configured = 0, - .source_locked = 0, - .LO1_locked = 0, - .ADC_overload = 0, - .unlevel = 0, - .temp_source = 0, - .temp_LO1 = 0, - .temp_MCU = 0, .limits_minFreq = 0, .limits_maxFreq = 6000000000, .limits_minIFBW = 10, @@ -143,14 +133,25 @@ static constexpr Protocol::DeviceInfo defaultInfo = { .limits_maxFreqHarmonic = 18000000000, }; -Protocol::DeviceInfo Device::lastInfo = defaultInfo; +static constexpr Protocol::DeviceStatusV1 defaultStatusV1 = { + .extRefAvailable = 0, + .extRefInUse = 0, + .FPGA_configured = 0, + .source_locked = 0, + .LO1_locked = 0, + .ADC_overload = 0, + .unlevel = 0, + .temp_source = 0, + .temp_LO1 = 0, + .temp_MCU = 0, +}; Device::Device(QString serial) { - lastInfo = defaultInfo; + info = defaultInfo; m_handle = nullptr; - lastInfoValid = false; + infoValid = false; libusb_init(&m_context); #if LIBUSB_API_VERSION >= 0x01000106 libusb_set_option(m_context, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_INFO); @@ -261,10 +262,10 @@ bool Device::Configure(Protocol::SpectrumAnalyzerSettings settings) return SendPacket(p); } -bool Device::SetManual(Protocol::ManualControl manual) +bool Device::SetManual(Protocol::ManualControlV1 manual) { Protocol::PacketInfo p; - p.type = Protocol::PacketType::ManualControl; + p.type = Protocol::PacketType::ManualControlV1; p.manual = manual; return SendPacket(p); } @@ -393,25 +394,48 @@ void Device::SearchDevices(std::function const Protocol::DeviceInfo &Device::Info() { - return lastInfo; + return info; +} + +const Protocol::DeviceInfo &Device::Info(Device *dev) +{ + if(dev) { + return dev->Info(); + } else { + return defaultInfo; + } +} + +Protocol::DeviceStatusV1 &Device::StatusV1() +{ + return status.v1; +} + +const Protocol::DeviceStatusV1 &Device::StatusV1(Device *dev) +{ + if(dev) { + return dev->StatusV1(); + } else { + return defaultStatusV1; + } } QString Device::getLastDeviceInfoString() { QString ret; - if(!lastInfoValid) { + if(!infoValid) { ret.append("No device information available yet"); } else { ret.append("HW Rev."); - ret.append(lastInfo.HW_Revision); - ret.append(" FW "+QString::number(lastInfo.FW_major)+"."+QString::number(lastInfo.FW_minor)+"."+QString::number(lastInfo.FW_patch)); - ret.append(" Temps: "+QString::number(lastInfo.temp_source)+"°C/"+QString::number(lastInfo.temp_LO1)+"°C/"+QString::number(lastInfo.temp_MCU)+"°C"); + ret.append(info.HW_Revision); + ret.append(" FW "+QString::number(info.FW_major)+"."+QString::number(info.FW_minor)+"."+QString::number(info.FW_patch)); + ret.append(" Temps: "+QString::number(status.v1.temp_source)+"°C/"+QString::number(status.v1.temp_LO1)+"°C/"+QString::number(status.v1.temp_MCU)+"°C"); ret.append(" Reference:"); - if(lastInfo.extRefInUse) { + if(status.v1.extRefInUse) { ret.append("External"); } else { ret.append("Internal"); - if(lastInfo.extRefAvailable) { + if(status.v1.extRefAvailable) { ret.append(" (External available)"); } } @@ -431,8 +455,8 @@ void Device::ReceivedData() case Protocol::PacketType::Datapoint: emit DatapointReceived(packet.datapoint); break; - case Protocol::PacketType::Status: - emit ManualStatusReceived(packet.status); + case Protocol::PacketType::ManualStatusV1: + emit ManualStatusReceived(packet.manualStatusV1); break; case Protocol::PacketType::SpectrumAnalyzerResult: emit SpectrumResultReceived(packet.spectrumResult); @@ -443,15 +467,19 @@ void Device::ReceivedData() break; case Protocol::PacketType::DeviceInfo: if(packet.info.ProtocolVersion != Protocol::Version) { - if(!lastInfoValid) { + if(!infoValid) { emit NeedsFirmwareUpdate(packet.info.ProtocolVersion, Protocol::Version); } } else { - lastInfo = packet.info; + info = packet.info; } - lastInfoValid = true; + infoValid = true; emit DeviceInfoUpdated(); break; + case Protocol::PacketType::DeviceStatusV1: + status.v1 = packet.statusV1; + emit DeviceStatusUpdated(); + break; case Protocol::PacketType::Ack: emit AckReceived(); emit receivedAnswer(TransmissionResult::Ack); diff --git a/Software/PC_Application/Device/device.h b/Software/PC_Application/Device/device.h index ef144bd..38b81fb 100644 --- a/Software/PC_Application/Device/device.h +++ b/Software/PC_Application/Device/device.h @@ -13,7 +13,7 @@ #include Q_DECLARE_METATYPE(Protocol::Datapoint); -Q_DECLARE_METATYPE(Protocol::ManualStatus); +Q_DECLARE_METATYPE(Protocol::ManualStatusV1); Q_DECLARE_METATYPE(Protocol::SpectrumAnalyzerResult); Q_DECLARE_METATYPE(Protocol::AmplitudeCorrectionPoint); @@ -61,23 +61,27 @@ public: bool SendPacket(const Protocol::PacketInfo& packet, std::function cb = nullptr, unsigned int timeout = 500); bool Configure(Protocol::SweepSettings settings, std::function cb = nullptr); bool Configure(Protocol::SpectrumAnalyzerSettings settings); - bool SetManual(Protocol::ManualControl manual); + bool SetManual(Protocol::ManualControlV1 manual); bool SetIdle(); bool SendFirmwareChunk(Protocol::FirmwarePacket &fw); bool SendCommandWithoutPayload(Protocol::PacketType type); QString serial() const; - static const Protocol::DeviceInfo& Info(); + const Protocol::DeviceInfo& Info(); + static const Protocol::DeviceInfo& Info(Device *dev); + Protocol::DeviceStatusV1& StatusV1(); + static const Protocol::DeviceStatusV1& StatusV1(Device *dev); QString getLastDeviceInfoString(); // Returns serial numbers of all connected devices static std::set GetDevices(); signals: void DatapointReceived(Protocol::Datapoint); - void ManualStatusReceived(Protocol::ManualStatus); + void ManualStatusReceived(Protocol::ManualStatusV1); void SpectrumResultReceived(Protocol::SpectrumAnalyzerResult); void AmplitudeCorrectionPointReceived(Protocol::AmplitudeCorrectionPoint); void FrequencyCorrectionReceived(float ppm); void DeviceInfoUpdated(); + void DeviceStatusUpdated(); void ConnectionLost(); void AckReceived(); void NackReceived(); @@ -122,8 +126,11 @@ private: QString m_serial; bool m_connected; std::thread *m_receiveThread; - static Protocol::DeviceInfo lastInfo; - bool lastInfoValid; + Protocol::DeviceInfo info; + bool infoValid; + union { + Protocol::DeviceStatusV1 v1; + } status; }; #endif // DEVICE_H diff --git a/Software/PC_Application/Device/manualcontroldialog.cpp b/Software/PC_Application/Device/manualcontroldialog.cpp index b776887..02d8e35 100644 --- a/Software/PC_Application/Device/manualcontroldialog.cpp +++ b/Software/PC_Application/Device/manualcontroldialog.cpp @@ -580,7 +580,7 @@ double ManualControlDialog::getRefPhase() return ui->refphase->text().toDouble(); } -void ManualControlDialog::NewStatus(Protocol::ManualStatus status) +void ManualControlDialog::NewStatus(Protocol::ManualStatusV1 status) { // ADC values ui->port1min->setText(QString::number(status.port1min)); @@ -616,7 +616,7 @@ void ManualControlDialog::NewStatus(Protocol::ManualStatus status) void ManualControlDialog::UpdateDevice() { - Protocol::ManualControl m; + Protocol::ManualControlV1 m; // Source highband m.SourceHighCE = ui->SourceCE->isChecked(); m.SourceHighRFEN = ui->SourceRFEN->isChecked(); diff --git a/Software/PC_Application/Device/manualcontroldialog.h b/Software/PC_Application/Device/manualcontroldialog.h index ab0f048..553d549 100644 --- a/Software/PC_Application/Device/manualcontroldialog.h +++ b/Software/PC_Application/Device/manualcontroldialog.h @@ -103,7 +103,7 @@ public: double getRefPhase(); public slots: - void NewStatus(Protocol::ManualStatus status); + void NewStatus(Protocol::ManualStatusV1 status); private: void UpdateDevice(); diff --git a/Software/PC_Application/Generator/generator.cpp b/Software/PC_Application/Generator/generator.cpp index f7cc411..d0e0bcf 100644 --- a/Software/PC_Application/Generator/generator.cpp +++ b/Software/PC_Application/Generator/generator.cpp @@ -6,7 +6,7 @@ Generator::Generator(AppWindow *window) : Mode(window, "Signal Generator") , SCPINode("GENerator") { - central = new SignalgeneratorWidget(window); + central = new SignalgeneratorWidget(window->getDevice(), window); auto pref = Preferences::getInstance(); diff --git a/Software/PC_Application/Generator/signalgenwidget.cpp b/Software/PC_Application/Generator/signalgenwidget.cpp index 187debb..3347804 100644 --- a/Software/PC_Application/Generator/signalgenwidget.cpp +++ b/Software/PC_Application/Generator/signalgenwidget.cpp @@ -2,9 +2,10 @@ #include "ui_signalgenwidget.h" -SignalgeneratorWidget::SignalgeneratorWidget(QWidget *parent) : +SignalgeneratorWidget::SignalgeneratorWidget(Device *&dev, QWidget *parent) : QWidget(parent), - ui(new Ui::SignalgeneratorWidget) + ui(new Ui::SignalgeneratorWidget), + dev(dev) { ui->setupUi(this); ui->frequency->setUnit("Hz"); @@ -31,16 +32,16 @@ SignalgeneratorWidget::SignalgeneratorWidget(QWidget *parent) : ui->steps->setPrecision(0); connect(ui->frequency, &SIUnitEdit::valueChanged, [=](double newval) { - if(newval < Device::Info().limits_minFreq) { - newval = Device::Info().limits_minFreq; - } else if (newval > Device::Info().limits_maxFreq) { - newval = Device::Info().limits_maxFreq; + if(newval < Device::Info(dev).limits_minFreq) { + newval = Device::Info(dev).limits_minFreq; + } else if (newval > Device::Info(dev).limits_maxFreq) { + newval = Device::Info(dev).limits_maxFreq; } ui->frequency->setValueQuiet(newval); if (newval < ui->span->value()/2) ui->span->setValueQuiet(newval/2); - if (newval + ui->span->value()/2 > Device::Info().limits_maxFreq) - ui->span->setValueQuiet((Device::Info().limits_maxFreq - newval)*2); + if (newval + ui->span->value()/2 > Device::Info(dev).limits_maxFreq) + ui->span->setValueQuiet((Device::Info(dev).limits_maxFreq - newval)*2); newval = ui->frequency->value() - ui->span->value()/2; ui->current->setValueQuiet(newval); emit SettingsChanged(); @@ -49,8 +50,8 @@ SignalgeneratorWidget::SignalgeneratorWidget(QWidget *parent) : connect(ui->span, &SIUnitEdit::valueChanged, [=](double newval) { if(newval < 0 ) { newval = 0; - } else if (newval > Device::Info().limits_maxFreq - Device::Info().limits_minFreq) { - newval = Device::Info().limits_maxFreq - Device::Info().limits_minFreq; + } else if (newval > Device::Info(dev).limits_maxFreq - Device::Info(dev).limits_minFreq) { + newval = Device::Info(dev).limits_maxFreq - Device::Info(dev).limits_minFreq; } ui->span->setValueQuiet(newval); @@ -59,8 +60,8 @@ SignalgeneratorWidget::SignalgeneratorWidget(QWidget *parent) : ui->frequency->setValueQuiet(ui->span->value()/2); } newF = ui->frequency->value() + ui->span->value()/2; - if (newF > Device::Info().limits_maxFreq) { - ui->frequency->setValueQuiet(Device::Info().limits_maxFreq - ui->span->value()/2); + if (newF > Device::Info(dev).limits_maxFreq) { + ui->frequency->setValueQuiet(Device::Info(dev).limits_maxFreq - ui->span->value()/2); } newval = ui->frequency->value() - ui->span->value()/2; @@ -71,8 +72,8 @@ SignalgeneratorWidget::SignalgeneratorWidget(QWidget *parent) : connect(ui->current, &SIUnitEdit::valueChanged, [=](double newval) { if(newval < 0 ) { newval = 0; - } else if (newval > Device::Info().limits_maxFreq - Device::Info().limits_minFreq) { - newval = Device::Info().limits_maxFreq - Device::Info().limits_minFreq; + } else if (newval > Device::Info(dev).limits_maxFreq - Device::Info(dev).limits_minFreq) { + newval = Device::Info(dev).limits_maxFreq - Device::Info(dev).limits_minFreq; } ui->current->setValueQuiet(newval); emit SettingsChanged(); diff --git a/Software/PC_Application/Generator/signalgenwidget.h b/Software/PC_Application/Generator/signalgenwidget.h index e64a054..6573140 100644 --- a/Software/PC_Application/Generator/signalgenwidget.h +++ b/Software/PC_Application/Generator/signalgenwidget.h @@ -15,7 +15,7 @@ class SignalgeneratorWidget : public QWidget, public Savable Q_OBJECT public: - explicit SignalgeneratorWidget(QWidget *parent = nullptr); + explicit SignalgeneratorWidget(Device*&dev, QWidget *parent = nullptr); ~SignalgeneratorWidget(); Protocol::GeneratorSettings getDeviceStatus(); @@ -36,6 +36,7 @@ protected: private: Ui::SignalgeneratorWidget *ui; int m_timerId; + Device*&dev; }; #endif // SIGNALGENERATOR_H diff --git a/Software/PC_Application/SpectrumAnalyzer/spectrumanalyzer.cpp b/Software/PC_Application/SpectrumAnalyzer/spectrumanalyzer.cpp index a649dcc..5d8d08e 100644 --- a/Software/PC_Application/SpectrumAnalyzer/spectrumanalyzer.cpp +++ b/Software/PC_Application/SpectrumAnalyzer/spectrumanalyzer.cpp @@ -555,14 +555,14 @@ void SpectrumAnalyzer::SetStopFreq(double freq) void SpectrumAnalyzer::SetCenterFreq(double freq) { auto old_span = settings.f_stop - settings.f_start; - if (freq - old_span / 2 <= Device::Info().limits_minFreq) { + if (freq - old_span / 2 <= Device::Info(window->getDevice()).limits_minFreq) { // would shift start frequency below minimum settings.f_start = 0; settings.f_stop = 2 * freq; - } else if(freq + old_span / 2 >= Device::Info().limits_maxFreq) { + } else if(freq + old_span / 2 >= Device::Info(window->getDevice()).limits_maxFreq) { // would shift stop frequency above maximum - settings.f_start = 2 * freq - Device::Info().limits_maxFreq; - settings.f_stop = Device::Info().limits_maxFreq; + settings.f_start = 2 * freq - Device::Info(window->getDevice()).limits_maxFreq; + settings.f_stop = Device::Info(window->getDevice()).limits_maxFreq; } else { settings.f_start = freq - old_span / 2; settings.f_stop = freq + old_span / 2; @@ -573,14 +573,14 @@ void SpectrumAnalyzer::SetCenterFreq(double freq) void SpectrumAnalyzer::SetSpan(double span) { auto old_center = (settings.f_start + settings.f_stop) / 2; - if(old_center < Device::Info().limits_minFreq + span / 2) { + if(old_center < Device::Info(window->getDevice()).limits_minFreq + span / 2) { // would shift start frequency below minimum - settings.f_start = Device::Info().limits_minFreq; - settings.f_stop = Device::Info().limits_minFreq + span; - } else if(old_center > Device::Info().limits_maxFreq - span / 2) { + settings.f_start = Device::Info(window->getDevice()).limits_minFreq; + settings.f_stop = Device::Info(window->getDevice()).limits_minFreq + span; + } else if(old_center > Device::Info(window->getDevice()).limits_maxFreq - span / 2) { // would shift stop frequency above maximum - settings.f_start = Device::Info().limits_maxFreq - span; - settings.f_stop = Device::Info().limits_maxFreq; + settings.f_start = Device::Info(window->getDevice()).limits_maxFreq - span; + settings.f_stop = Device::Info(window->getDevice()).limits_maxFreq; } else { settings.f_start = old_center - span / 2; settings.f_stop = settings.f_start + span; @@ -590,8 +590,8 @@ void SpectrumAnalyzer::SetSpan(double span) void SpectrumAnalyzer::SetFullSpan() { - settings.f_start = Device::Info().limits_minFreq; - settings.f_stop = Device::Info().limits_maxFreq; + settings.f_start = Device::Info(window->getDevice()).limits_minFreq; + settings.f_stop = Device::Info(window->getDevice()).limits_maxFreq; ConstrainAndUpdateFrequencies(); } @@ -619,10 +619,10 @@ void SpectrumAnalyzer::SpanZoomOut() void SpectrumAnalyzer::SetRBW(double bandwidth) { - if(bandwidth > Device::Info().limits_maxRBW) { - bandwidth = Device::Info().limits_maxRBW; - } else if(bandwidth < Device::Info().limits_minRBW) { - bandwidth = Device::Info().limits_minRBW; + if(bandwidth > Device::Info(window->getDevice()).limits_maxRBW) { + bandwidth = Device::Info(window->getDevice()).limits_maxRBW; + } else if(bandwidth < Device::Info(window->getDevice()).limits_minRBW) { + bandwidth = Device::Info(window->getDevice()).limits_minRBW; } settings.RBW = bandwidth; emit RBWChanged(settings.RBW); @@ -690,10 +690,10 @@ void SpectrumAnalyzer::SetTGPort(int port) void SpectrumAnalyzer::SetTGLevel(double level) { - if(level > Device::Info().limits_cdbm_max / 100.0) { - level = Device::Info().limits_cdbm_max / 100.0; - } else if(level < Device::Info().limits_cdbm_min / 100.0) { - level = Device::Info().limits_cdbm_min / 100.0; + if(level > Device::Info(window->getDevice()).limits_cdbm_max / 100.0) { + level = Device::Info(window->getDevice()).limits_cdbm_max / 100.0; + } else if(level < Device::Info(window->getDevice()).limits_cdbm_min / 100.0) { + level = Device::Info(window->getDevice()).limits_cdbm_min / 100.0; } emit TGLevelChanged(level); settings.trackingPower = level * 100; @@ -1015,24 +1015,24 @@ void SpectrumAnalyzer::UpdateAverageCount() void SpectrumAnalyzer::ConstrainAndUpdateFrequencies() { - if(settings.f_stop > Device::Info().limits_maxFreq) { - settings.f_stop = Device::Info().limits_maxFreq; + if(settings.f_stop > Device::Info(window->getDevice()).limits_maxFreq) { + settings.f_stop = Device::Info(window->getDevice()).limits_maxFreq; } if(settings.f_start > settings.f_stop) { settings.f_start = settings.f_stop; } - if(settings.f_start < Device::Info().limits_minFreq) { - settings.f_start = Device::Info().limits_minFreq; + if(settings.f_start < Device::Info(window->getDevice()).limits_minFreq) { + settings.f_start = Device::Info(window->getDevice()).limits_minFreq; } bool trackingOffset_limited = false; - if(settings.f_stop + settings.trackingGeneratorOffset > Device::Info().limits_maxFreq) { + if(settings.f_stop + settings.trackingGeneratorOffset > Device::Info(window->getDevice()).limits_maxFreq) { trackingOffset_limited = true; - settings.trackingGeneratorOffset = Device::Info().limits_maxFreq - settings.f_stop; + settings.trackingGeneratorOffset = Device::Info(window->getDevice()).limits_maxFreq - settings.f_stop; } - if((long) settings.f_start + settings.trackingGeneratorOffset < (long) Device::Info().limits_minFreq) { + if((long) settings.f_start + settings.trackingGeneratorOffset < (long) Device::Info(window->getDevice()).limits_minFreq) { trackingOffset_limited = true; - settings.trackingGeneratorOffset = Device::Info().limits_minFreq - settings.f_start; + settings.trackingGeneratorOffset = Device::Info(window->getDevice()).limits_minFreq - settings.f_start; } if(trackingOffset_limited) { InformationBox::ShowMessage("Warning", "The selected tracking generator offset is not reachable for all frequencies with the current span. " diff --git a/Software/PC_Application/VNA/vna.cpp b/Software/PC_Application/VNA/vna.cpp index 955ad53..44c4fd9 100644 --- a/Software/PC_Application/VNA/vna.cpp +++ b/Software/PC_Application/VNA/vna.cpp @@ -997,14 +997,14 @@ void VNA::SetStopFreq(double freq) void VNA::SetCenterFreq(double freq) { auto old_span = settings.Freq.stop - settings.Freq.start; - if (freq - old_span / 2 <= Device::Info().limits_minFreq) { + if (freq - old_span / 2 <= Device::Info(window->getDevice()).limits_minFreq) { // would shift start frequency below minimum settings.Freq.start = 0; settings.Freq.stop = 2 * freq; - } else if(freq + old_span / 2 >= Device::Info().limits_maxFreq) { + } else if(freq + old_span / 2 >= Device::Info(window->getDevice()).limits_maxFreq) { // would shift stop frequency above maximum - settings.Freq.start = 2 * freq - Device::Info().limits_maxFreq; - settings.Freq.stop = Device::Info().limits_maxFreq; + settings.Freq.start = 2 * freq - Device::Info(window->getDevice()).limits_maxFreq; + settings.Freq.stop = Device::Info(window->getDevice()).limits_maxFreq; } else { settings.Freq.start = freq - old_span / 2; settings.Freq.stop = freq + old_span / 2; @@ -1014,12 +1014,12 @@ void VNA::SetCenterFreq(double freq) void VNA::SetSpan(double span) { - auto maxFreq = Preferences::getInstance().Acquisition.harmonicMixing ? Device::Info().limits_maxFreqHarmonic : Device::Info().limits_maxFreq; + auto maxFreq = Preferences::getInstance().Acquisition.harmonicMixing ? Device::Info(window->getDevice()).limits_maxFreqHarmonic : Device::Info(window->getDevice()).limits_maxFreq; auto old_center = (settings.Freq.start + settings.Freq.stop) / 2; - if(old_center < Device::Info().limits_minFreq + span / 2) { + if(old_center < Device::Info(window->getDevice()).limits_minFreq + span / 2) { // would shift start frequency below minimum - settings.Freq.start = Device::Info().limits_minFreq; - settings.Freq.stop = Device::Info().limits_minFreq + span; + settings.Freq.start = Device::Info(window->getDevice()).limits_minFreq; + settings.Freq.stop = Device::Info(window->getDevice()).limits_minFreq + span; } else if(old_center > maxFreq - span / 2) { // would shift stop frequency above maximum settings.Freq.start = maxFreq - span; @@ -1033,8 +1033,8 @@ void VNA::SetSpan(double span) void VNA::SetFullSpan() { - settings.Freq.start = Device::Info().limits_minFreq; - settings.Freq.stop = Device::Info().limits_maxFreq; + settings.Freq.start = Device::Info(window->getDevice()).limits_minFreq; + settings.Freq.stop = Device::Info(window->getDevice()).limits_maxFreq; ConstrainAndUpdateFrequencies(); } @@ -1072,10 +1072,10 @@ void VNA::SetLogSweep(bool log) void VNA::SetSourceLevel(double level) { - if(level > Device::Info().limits_cdbm_max / 100.0) { - level = Device::Info().limits_cdbm_max / 100.0; - } else if(level < Device::Info().limits_cdbm_min / 100.0) { - level = Device::Info().limits_cdbm_min / 100.0; + if(level > Device::Info(window->getDevice()).limits_cdbm_max / 100.0) { + level = Device::Info(window->getDevice()).limits_cdbm_max / 100.0; + } else if(level < Device::Info(window->getDevice()).limits_cdbm_min / 100.0) { + level = Device::Info(window->getDevice()).limits_cdbm_min / 100.0; } emit sourceLevelChanged(level); settings.Freq.excitation_power = level; @@ -1105,15 +1105,15 @@ void VNA::SetPowerSweepFrequency(double freq) void VNA::SetPoints(unsigned int points) { - unsigned int maxPoints = Preferences::getInstance().Acquisition.allowSegmentedSweep ? UINT16_MAX : Device::Info().limits_maxPoints; + unsigned int maxPoints = Preferences::getInstance().Acquisition.allowSegmentedSweep ? UINT16_MAX : Device::Info(window->getDevice()).limits_maxPoints; if(points > maxPoints) { points = maxPoints; } else if (points < 2) { points = 2; } - if (points > Device::Info().limits_maxPoints) { + if (points > Device::Info(window->getDevice()).limits_maxPoints) { // needs segmented sweep - settings.segments = ceil((double) points / Device::Info().limits_maxPoints); + settings.segments = ceil((double) points / Device::Info(window->getDevice()).limits_maxPoints); settings.activeSegment = 0; } else { // can fit all points into one segment @@ -1127,10 +1127,10 @@ void VNA::SetPoints(unsigned int points) void VNA::SetIFBandwidth(double bandwidth) { - if(bandwidth > Device::Info().limits_maxIFBW) { - bandwidth = Device::Info().limits_maxIFBW; - } else if(bandwidth < Device::Info().limits_minIFBW) { - bandwidth = Device::Info().limits_minIFBW; + if(bandwidth > Device::Info(window->getDevice()).limits_maxIFBW) { + bandwidth = Device::Info(window->getDevice()).limits_maxIFBW; + } else if(bandwidth < Device::Info(window->getDevice()).limits_minIFBW) { + bandwidth = Device::Info(window->getDevice()).limits_minIFBW; } settings.bandwidth = bandwidth; emit IFBandwidthChanged(settings.bandwidth); @@ -1478,9 +1478,9 @@ void VNA::ConstrainAndUpdateFrequencies() auto pref = Preferences::getInstance(); double maxFreq; if(pref.Acquisition.harmonicMixing) { - maxFreq = Device::Info().limits_maxFreqHarmonic; + maxFreq = Device::Info(window->getDevice()).limits_maxFreqHarmonic; } else { - maxFreq = Device::Info().limits_maxFreq; + maxFreq = Device::Info(window->getDevice()).limits_maxFreq; } if(settings.Freq.stop > maxFreq) { settings.Freq.stop = maxFreq; @@ -1488,8 +1488,8 @@ void VNA::ConstrainAndUpdateFrequencies() if(settings.Freq.start > settings.Freq.stop) { settings.Freq.start = settings.Freq.stop; } - if(settings.Freq.start < Device::Info().limits_minFreq) { - settings.Freq.start = Device::Info().limits_minFreq; + if(settings.Freq.start < Device::Info(window->getDevice()).limits_minFreq) { + settings.Freq.start = Device::Info(window->getDevice()).limits_minFreq; } emit startFreqChanged(settings.Freq.start); emit stopFreqChanged(settings.Freq.stop); diff --git a/Software/PC_Application/appwindow.cpp b/Software/PC_Application/appwindow.cpp index 6da7c3c..2f46774 100644 --- a/Software/PC_Application/appwindow.cpp +++ b/Software/PC_Application/appwindow.cpp @@ -235,7 +235,7 @@ AppWindow::AppWindow(QWidget *parent) vna->activate(); qRegisterMetaType("Datapoint"); - qRegisterMetaType("Manual"); + qRegisterMetaType("ManualV1"); qRegisterMetaType("SpectrumAnalyzerResult"); qRegisterMetaType("AmplitudeCorrection"); @@ -309,7 +309,7 @@ bool AppWindow::ConnectToDevice(QString serial) UpdateStatusBar(AppWindow::DeviceStatusBar::Connected); connect(device, &Device::LogLineReceived, &deviceLog, &DeviceLog::addLine); connect(device, &Device::ConnectionLost, this, &AppWindow::DeviceConnectionLost); - connect(device, &Device::DeviceInfoUpdated, this, &AppWindow::DeviceInfoUpdated); + connect(device, &Device::DeviceStatusUpdated, this, &AppWindow::DeviceStatusUpdated); connect(device, &Device::NeedsFirmwareUpdate, this, &AppWindow::DeviceNeedsUpdate); ui->actionDisconnect->setEnabled(true); ui->actionManual_Control->setEnabled(true); @@ -465,7 +465,7 @@ void AppWindow::SetupSCPI() } return ""; }, [=](QStringList) -> QString { - switch(Device::Info().extRefInUse) { + switch(Device::StatusV1(getDevice()).extRefInUse) { case 0: return "INT"; case 1: return "EXT"; default: return "ERROR"; @@ -500,57 +500,57 @@ void AppWindow::SetupSCPI() auto scpi_status = new SCPINode("STAtus"); scpi_dev->add(scpi_status); scpi_status->add(new SCPICommand("UNLOcked", nullptr, [=](QStringList){ - bool locked = Device::Info().source_locked && Device::Info().LO1_locked; + bool locked = Device::StatusV1(getDevice()).source_locked && Device::StatusV1(getDevice()).LO1_locked; return locked ? "FALSE" : "TRUE"; })); scpi_status->add(new SCPICommand("ADCOVERload", nullptr, [=](QStringList){ - return Device::Info().ADC_overload ? "TRUE" : "FALSE"; + return Device::StatusV1(getDevice()).ADC_overload ? "TRUE" : "FALSE"; })); scpi_status->add(new SCPICommand("UNLEVel", nullptr, [=](QStringList){ - return Device::Info().unlevel ? "TRUE" : "FALSE"; + return Device::StatusV1(getDevice()).unlevel ? "TRUE" : "FALSE"; })); auto scpi_info = new SCPINode("INFo"); scpi_dev->add(scpi_info); scpi_info->add(new SCPICommand("FWREVision", nullptr, [=](QStringList){ - return QString::number(Device::Info().FW_major)+"."+QString::number(Device::Info().FW_minor)+"."+QString::number(Device::Info().FW_patch); + return QString::number(Device::Info(getDevice()).FW_major)+"."+QString::number(Device::Info(getDevice()).FW_minor)+"."+QString::number(Device::Info(getDevice()).FW_patch); })); scpi_info->add(new SCPICommand("HWREVision", nullptr, [=](QStringList){ - return QString(Device::Info().HW_Revision); + return QString(Device::Info(getDevice()).HW_Revision); })); scpi_info->add(new SCPICommand("TEMPeratures", nullptr, [=](QStringList){ - return QString::number(Device::Info().temp_source)+"/"+QString::number(Device::Info().temp_LO1)+"/"+QString::number(Device::Info().temp_MCU); + return QString::number(Device::StatusV1(getDevice()).temp_source)+"/"+QString::number(Device::StatusV1(getDevice()).temp_LO1)+"/"+QString::number(Device::StatusV1(getDevice()).temp_MCU); })); auto scpi_limits = new SCPINode("LIMits"); scpi_info->add(scpi_limits); scpi_limits->add(new SCPICommand("MINFrequency", nullptr, [=](QStringList){ - return QString::number(Device::Info().limits_minFreq); + return QString::number(Device::Info(getDevice()).limits_minFreq); })); scpi_limits->add(new SCPICommand("MAXFrequency", nullptr, [=](QStringList){ - return QString::number(Device::Info().limits_maxFreq); + return QString::number(Device::Info(getDevice()).limits_maxFreq); })); scpi_limits->add(new SCPICommand("MINIFBW", nullptr, [=](QStringList){ - return QString::number(Device::Info().limits_minIFBW); + return QString::number(Device::Info(getDevice()).limits_minIFBW); })); scpi_limits->add(new SCPICommand("MAXIFBW", nullptr, [=](QStringList){ - return QString::number(Device::Info().limits_maxIFBW); + return QString::number(Device::Info(getDevice()).limits_maxIFBW); })); scpi_limits->add(new SCPICommand("MAXPoints", nullptr, [=](QStringList){ - return QString::number(Device::Info().limits_maxPoints); + return QString::number(Device::Info(getDevice()).limits_maxPoints); })); scpi_limits->add(new SCPICommand("MINPOWer", nullptr, [=](QStringList){ - return QString::number(Device::Info().limits_cdbm_min / 100.0); + return QString::number(Device::Info(getDevice()).limits_cdbm_min / 100.0); })); scpi_limits->add(new SCPICommand("MAXPOWer", nullptr, [=](QStringList){ - return QString::number(Device::Info().limits_cdbm_max / 100.0); + return QString::number(Device::Info(getDevice()).limits_cdbm_max / 100.0); })); scpi_limits->add(new SCPICommand("MINRBW", nullptr, [=](QStringList){ - return QString::number(Device::Info().limits_minRBW); + return QString::number(Device::Info(getDevice()).limits_minRBW); })); scpi_limits->add(new SCPICommand("MAXRBW", nullptr, [=](QStringList){ - return QString::number(Device::Info().limits_maxRBW); + return QString::number(Device::Info(getDevice()).limits_maxRBW); })); scpi_limits->add(new SCPICommand("MAXHARMonicfrequency", nullptr, [=](QStringList){ - return QString::number(Device::Info().limits_maxFreqHarmonic); + return QString::number(Device::Info(getDevice()).limits_maxFreqHarmonic); })); scpi.add(vna); @@ -918,7 +918,7 @@ void AppWindow::DeviceNeedsUpdate(int reported, int expected) } } -void AppWindow::DeviceInfoUpdated() +void AppWindow::DeviceStatusUpdated() { UpdateStatusBar(DeviceStatusBar::Updated); } @@ -1024,7 +1024,7 @@ void AppWindow::LoadSetup(nlohmann::json j) } } -Device *AppWindow::getDevice() const +Device *&AppWindow::getDevice() { return device; } @@ -1104,9 +1104,9 @@ void AppWindow::UpdateStatusBar(DeviceStatusBar status) break; case DeviceStatusBar::Updated: lDeviceInfo.setText(device->getLastDeviceInfoString()); - lADCOverload.setVisible(device->Info().ADC_overload); - lUnlevel.setVisible(device->Info().unlevel); - lUnlock.setVisible(!device->Info().LO1_locked || !device->Info().source_locked); + lADCOverload.setVisible(device->StatusV1().ADC_overload); + lUnlevel.setVisible(device->StatusV1().unlevel); + lUnlock.setVisible(!device->StatusV1().LO1_locked || !device->StatusV1().source_locked); break; default: // invalid status diff --git a/Software/PC_Application/appwindow.h b/Software/PC_Application/appwindow.h index 5dbd92a..95f92c8 100644 --- a/Software/PC_Application/appwindow.h +++ b/Software/PC_Application/appwindow.h @@ -41,7 +41,7 @@ public: Ui::MainWindow *getUi() const; QStackedWidget *getCentral() const; - Device *getDevice() const; + Device*&getDevice(); const QString& getAppVersion() const; const QString& getAppGitHash() const; @@ -59,7 +59,7 @@ private slots: void UpdateAcquisitionFrequencies(); void StartFirmwareUpdateDialog(); void DeviceNeedsUpdate(int reported, int expected); - void DeviceInfoUpdated(); + void DeviceStatusUpdated(); void SourceCalibrationDialog(); void ReceiverCalibrationDialog(); void FrequencyCalibrationDialog(); diff --git a/Software/VNA_embedded/Application/App.cpp b/Software/VNA_embedded/Application/App.cpp index ee82562..72437a3 100644 --- a/Software/VNA_embedded/Application/App.cpp +++ b/Software/VNA_embedded/Application/App.cpp @@ -117,7 +117,7 @@ inline void App_Process() { sweepActive = VNA::Setup(recv_packet.settings); Communication::SendWithoutPayload(Protocol::PacketType::Ack); break; - case Protocol::PacketType::ManualControl: + case Protocol::PacketType::ManualControlV1: sweepActive = false; last_measure_packet = recv_packet; Manual::Setup(recv_packet.manual); @@ -145,12 +145,21 @@ inline void App_Process() { SA::Setup(recv_packet.spectrumSettings); Communication::SendWithoutPayload(Protocol::PacketType::Ack); break; - case Protocol::PacketType::RequestDeviceInfo: + case Protocol::PacketType::RequestDeviceInfo: { Communication::SendWithoutPayload(Protocol::PacketType::Ack); Protocol::PacketInfo p; p.type = Protocol::PacketType::DeviceInfo; - HW::fillDeviceInfo(&p.info); + p.info = HW::Info; Communication::Send(p); + } + break; + case Protocol::PacketType::RequestDeviceStatus: { + Communication::SendWithoutPayload(Protocol::PacketType::Ack); + Protocol::PacketInfo p; + p.type = Protocol::PacketType::DeviceStatusV1; + HW::getDeviceStatus(&p.statusV1); + Communication::Send(p); + } break; case Protocol::PacketType::SetIdle: HW::SetMode(HW::Mode::Idle); diff --git a/Software/VNA_embedded/Application/Communication/Protocol.cpp b/Software/VNA_embedded/Application/Communication/Protocol.cpp index 2384d39..99b0654 100644 --- a/Software/VNA_embedded/Application/Communication/Protocol.cpp +++ b/Software/VNA_embedded/Application/Communication/Protocol.cpp @@ -91,8 +91,9 @@ uint16_t Protocol::EncodePacket(const PacketInfo &packet, uint8_t *dest, uint16_ case PacketType::SweepSettings: payload_size = sizeof(packet.settings); break; case PacketType::Reference: payload_size = sizeof(packet.reference); break; case PacketType::DeviceInfo: payload_size = sizeof(packet.info); break; - case PacketType::Status: payload_size = sizeof(packet.status); break; - case PacketType::ManualControl: payload_size = sizeof(packet.manual); break; + case PacketType::DeviceStatusV1: payload_size = sizeof(packet.statusV1); break; + case PacketType::ManualStatusV1: payload_size = sizeof(packet.manualStatusV1); break; + case PacketType::ManualControlV1: payload_size = sizeof(packet.manual); break; case PacketType::FirmwarePacket: payload_size = sizeof(packet.firmware); break; case PacketType::Generator: payload_size = sizeof(packet.generator); break; case PacketType::SpectrumAnalyzerSettings: payload_size = sizeof(packet.spectrumSettings); break; diff --git a/Software/VNA_embedded/Application/Communication/Protocol.hpp b/Software/VNA_embedded/Application/Communication/Protocol.hpp index 009ab1d..1a7dc56 100644 --- a/Software/VNA_embedded/Application/Communication/Protocol.hpp +++ b/Software/VNA_embedded/Application/Communication/Protocol.hpp @@ -4,7 +4,7 @@ namespace Protocol { -static constexpr uint16_t Version = 9; +static constexpr uint16_t Version = 10; #pragma pack(push, 1) @@ -50,17 +50,8 @@ using DeviceInfo = struct _deviceInfo { uint8_t FW_major; uint8_t FW_minor; uint8_t FW_patch; + uint8_t hardware_version; char HW_Revision; - uint8_t extRefAvailable:1; - uint8_t extRefInUse:1; - uint8_t FPGA_configured:1; - uint8_t source_locked:1; - uint8_t LO1_locked:1; - uint8_t ADC_overload:1; - uint8_t unlevel:1; - uint8_t temp_source; - uint8_t temp_LO1; - uint8_t temp_MCU; uint64_t limits_minFreq; uint64_t limits_maxFreq; uint32_t limits_minIFBW; @@ -74,7 +65,21 @@ using DeviceInfo = struct _deviceInfo { uint64_t limits_maxFreqHarmonic; }; -using ManualStatus = struct _manualstatus { +using DeviceStatusV1 = struct _deviceStatusV1 { + uint8_t extRefAvailable:1; + uint8_t extRefInUse:1; + uint8_t FPGA_configured:1; + uint8_t source_locked:1; + uint8_t LO1_locked:1; + uint8_t ADC_overload:1; + uint8_t unlevel:1; + uint8_t temp_source; + uint8_t temp_LO1; + uint8_t temp_MCU; +}; + + +using ManualStatusV1 = struct _manualstatusV1 { int16_t port1min, port1max; int16_t port2min, port2max; int16_t refmin, refmax; @@ -87,7 +92,7 @@ using ManualStatus = struct _manualstatus { uint8_t LO_locked :1; }; -using ManualControl = struct _manualControl { +using ManualControlV1 = struct _manualControlV1 { // Highband Source uint8_t SourceHighCE :1; uint8_t SourceHighRFEN :1; @@ -170,8 +175,8 @@ enum class PacketType : uint8_t { None = 0, Datapoint = 1, SweepSettings = 2, - Status = 3, - ManualControl = 4, + ManualStatusV1 = 3, + ManualControlV1 = 4, DeviceInfo = 5, FirmwarePacket = 6, Ack = 7, @@ -192,6 +197,8 @@ enum class PacketType : uint8_t { FrequencyCorrection = 22, RequestAcquisitionFrequencySettings = 23, AcquisitionFrequencySettings = 24, + DeviceStatusV1 = 25, + RequestDeviceStatus = 26, }; using PacketInfo = struct _packetinfo { @@ -201,10 +208,11 @@ using PacketInfo = struct _packetinfo { SweepSettings settings; ReferenceSettings reference; GeneratorSettings generator; + DeviceStatusV1 statusV1; DeviceInfo info; - ManualControl manual; + ManualControlV1 manual; FirmwarePacket firmware; - ManualStatus status; + ManualStatusV1 manualStatusV1; SpectrumAnalyzerSettings spectrumSettings; SpectrumAnalyzerResult spectrumResult; AmplitudeCorrectionPoint amplitudePoint; diff --git a/Software/VNA_embedded/Application/Generator.cpp b/Software/VNA_embedded/Application/Generator.cpp index ee8a2cb..acbb85c 100644 --- a/Software/VNA_embedded/Application/Generator.cpp +++ b/Software/VNA_embedded/Application/Generator.cpp @@ -11,7 +11,7 @@ void Generator::Setup(Protocol::GeneratorSettings g) { HW::SetIdle(); return; } - Protocol::ManualControl m; + Protocol::ManualControlV1 m; // LOs not required m.LO1CE = 0; m.LO1Frequency = 1000000000; diff --git a/Software/VNA_embedded/Application/Hardware.cpp b/Software/VNA_embedded/Application/Hardware.cpp index 8afb45c..ab3bd90 100644 --- a/Software/VNA_embedded/Application/Hardware.cpp +++ b/Software/VNA_embedded/Application/Hardware.cpp @@ -299,9 +299,7 @@ void HW::SetOutputUnlevel(bool unlev) { unlevel = unlev; } -void HW::fillDeviceInfo(Protocol::DeviceInfo *info, bool updateEvenWhenBusy) { - // copy constant default values - memcpy(info, &HW::Info, sizeof(HW::Info)); +void HW::getDeviceStatus(Protocol::DeviceStatusV1 *status, bool updateEvenWhenBusy) { if(activeMode == Mode::Idle || updateEvenWhenBusy) { // updating values from FPGA allowed @@ -318,21 +316,21 @@ void HW::fillDeviceInfo(Protocol::DeviceInfo *info, bool updateEvenWhenBusy) { if(limits.P1min < -ADC_LIMIT || limits.P1max > ADC_LIMIT || limits.P2min < -ADC_LIMIT || limits.P2max > ADC_LIMIT || limits.Rmin < -ADC_LIMIT || limits.Rmax > ADC_LIMIT) { - info->ADC_overload = true; + status->ADC_overload = true; } else { - info->ADC_overload = false; + status->ADC_overload = false; } - auto status = FPGA::GetStatus(); - info->LO1_locked = (status & (int) FPGA::Interrupt::LO1Unlock) ? 0 : 1; - info->source_locked = (status & (int) FPGA::Interrupt::SourceUnlock) ? 0 : 1; - info->extRefAvailable = Ref::available(); - info->extRefInUse = extRefInUse; - info->unlevel = unlevel; - info->temp_LO1 = tempLO; - info->temp_source = tempSource; + auto FPGA_status = FPGA::GetStatus(); + status->LO1_locked = (FPGA_status & (int) FPGA::Interrupt::LO1Unlock) ? 0 : 1; + status->source_locked = (FPGA_status & (int) FPGA::Interrupt::SourceUnlock) ? 0 : 1; + status->extRefAvailable = Ref::available(); + status->extRefInUse = extRefInUse; + status->unlevel = unlevel; + status->temp_LO1 = tempLO; + status->temp_source = tempSource; FPGA::ResetADCLimits(); } - info->temp_MCU = STM::getTemperature(); + status->temp_MCU = STM::getTemperature(); } bool HW::Ref::available() { diff --git a/Software/VNA_embedded/Application/Hardware.hpp b/Software/VNA_embedded/Application/Hardware.hpp index 656569f..c0ce9ff 100644 --- a/Software/VNA_embedded/Application/Hardware.hpp +++ b/Software/VNA_embedded/Application/Hardware.hpp @@ -70,17 +70,8 @@ static constexpr Protocol::DeviceInfo Info = { .FW_major = FW_MAJOR, .FW_minor = FW_MINOR, .FW_patch = FW_PATCH, + .hardware_version = 1, .HW_Revision = HW_REVISION, - .extRefAvailable = 0, - .extRefInUse = 0, - .FPGA_configured = 0, - .source_locked = 0, - .LO1_locked = 0, - .ADC_overload = 0, - .unlevel = 0, - .temp_source = 0, - .temp_LO1 = 0, - .temp_MCU = 0, .limits_minFreq = 0, .limits_maxFreq = 6000000000, .limits_minIFBW = DefaultADCSamplerate / MaxSamples, @@ -120,7 +111,7 @@ using AmplitudeSettings = struct _amplitudeSettings { AmplitudeSettings GetAmplitudeSettings(int16_t cdbm, uint64_t freq = 0, bool applyCorrections = false, bool port2 = false); bool GetTemps(uint8_t *source, uint8_t *lo); -void fillDeviceInfo(Protocol::DeviceInfo *info, bool updateEvenWhenBusy = false); +void getDeviceStatus(Protocol::DeviceStatusV1 *status, bool updateEvenWhenBusy = false); namespace Ref { bool available(); bool usingExternal(); diff --git a/Software/VNA_embedded/Application/Manual.cpp b/Software/VNA_embedded/Application/Manual.cpp index e48f334..54bf7f8 100644 --- a/Software/VNA_embedded/Application/Manual.cpp +++ b/Software/VNA_embedded/Application/Manual.cpp @@ -6,11 +6,11 @@ static bool active = false; static uint32_t samples; -static Protocol::ManualStatus status; +static Protocol::ManualStatusV1 status; using namespace HWHAL; -void Manual::Setup(Protocol::ManualControl m) { +void Manual::Setup(Protocol::ManualControlV1 m) { HW::SetMode(HW::Mode::Manual); samples = m.Samples; FPGA::AbortSweep(); @@ -99,38 +99,38 @@ void Manual::Work() { return; } Protocol::PacketInfo p; - p.type = Protocol::PacketType::Status; - p.status = status; + p.type = Protocol::PacketType::ManualStatusV1; + p.manualStatusV1 = status; uint16_t isr_flags = FPGA::GetStatus(); if (!(isr_flags & 0x0002)) { - p.status.source_locked = 1; + p.manualStatusV1.source_locked = 1; } else { - p.status.source_locked = 0; + p.manualStatusV1.source_locked = 0; } if (!(isr_flags & 0x0001)) { - p.status.LO_locked = 1; + p.manualStatusV1.LO_locked = 1; } else { - p.status.LO_locked = 0; + p.manualStatusV1.LO_locked = 0; } auto limits = FPGA::GetADCLimits(); FPGA::ResetADCLimits(); - p.status.port1min = limits.P1min; - p.status.port1max = limits.P1max; - p.status.port2min = limits.P2min; - p.status.port2max = limits.P2max; - p.status.refmin = limits.Rmin; - p.status.refmax = limits.Rmax; - HW::GetTemps(&p.status.temp_source, &p.status.temp_LO); + p.manualStatusV1.port1min = limits.P1min; + p.manualStatusV1.port1max = limits.P1max; + p.manualStatusV1.port2min = limits.P2min; + p.manualStatusV1.port2max = limits.P2max; + p.manualStatusV1.refmin = limits.Rmin; + p.manualStatusV1.refmax = limits.Rmax; + HW::GetTemps(&p.manualStatusV1.temp_source, &p.manualStatusV1.temp_LO); Communication::Send(p); HW::Ref::update(); Protocol::PacketInfo packet; - packet.type = Protocol::PacketType::DeviceInfo; + packet.type = Protocol::PacketType::DeviceStatusV1; // Enable PLL chips for temperature reading bool srcEn = FPGA::IsEnabled(FPGA::Periphery::SourceChip); bool LOEn = FPGA::IsEnabled(FPGA::Periphery::LO1Chip); FPGA::Enable(FPGA::Periphery::SourceChip); FPGA::Enable(FPGA::Periphery::LO1Chip); - HW::fillDeviceInfo(&packet.info, true); + HW::getDeviceStatus(&packet.statusV1, true); // restore PLL state FPGA::Enable(FPGA::Periphery::SourceChip, srcEn); FPGA::Enable(FPGA::Periphery::LO1Chip, LOEn); diff --git a/Software/VNA_embedded/Application/Manual.hpp b/Software/VNA_embedded/Application/Manual.hpp index 35e6517..e13ed81 100644 --- a/Software/VNA_embedded/Application/Manual.hpp +++ b/Software/VNA_embedded/Application/Manual.hpp @@ -5,7 +5,7 @@ namespace Manual { -void Setup(Protocol::ManualControl m); +void Setup(Protocol::ManualControlV1 m); bool MeasurementDone(const FPGA::SamplingResult &result); void Work(); void Stop(); diff --git a/Software/VNA_embedded/Application/SpectrumAnalyzer.cpp b/Software/VNA_embedded/Application/SpectrumAnalyzer.cpp index c5cc48d..f616251 100644 --- a/Software/VNA_embedded/Application/SpectrumAnalyzer.cpp +++ b/Software/VNA_embedded/Application/SpectrumAnalyzer.cpp @@ -385,8 +385,8 @@ void SA::Work() { // send device info every nth point FPGA::Enable(FPGA::Periphery::SourceChip); // needs to enable the chip to get a valid temperature reading Protocol::PacketInfo packet; - packet.type = Protocol::PacketType::DeviceInfo; - HW::fillDeviceInfo(&packet.info, true); + packet.type = Protocol::PacketType::DeviceStatusV1; + HW::getDeviceStatus(&packet.statusV1, true); FPGA::Disable(FPGA::Periphery::SourceChip); Communication::Send(packet); } diff --git a/Software/VNA_embedded/Application/VNA.cpp b/Software/VNA_embedded/Application/VNA.cpp index 8a856dc..4e3e4e5 100644 --- a/Software/VNA_embedded/Application/VNA.cpp +++ b/Software/VNA_embedded/Application/VNA.cpp @@ -367,8 +367,8 @@ void VNA::Work() { HW::Ref::update(); // Compile info packet Protocol::PacketInfo packet; - packet.type = Protocol::PacketType::DeviceInfo; - HW::fillDeviceInfo(&packet.info, true); + packet.type = Protocol::PacketType::DeviceStatusV1; + HW::getDeviceStatus(&packet.statusV1, true); Communication::Send(packet); // do not reset unlevel flag here, as it is calculated only once at the setup of the sweep // Start next sweep