Finish refactoring of data flow from USBDevice->HantekDSOControl->DataAnalyser->DSOWidget->GLGenerator. Less thread locks, no deadlocks by design

Author: David Graeff

openhantek/CMakeLists.txt

@@ -10,7 +10,7 @@ set(CMAKE_AUTORCC ON)
 
 # include directories
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
-include_directories(src/ src/dso src/hantek)
+include_directories(src/ src/hantek src/analyse src/widgets src/docks src/configdialog)
 
 # collect sources and other files
 file(GLOB_RECURSE SRC "src/*.cpp")

openhantek/src/analyse/dataanalyzer.cpp

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+#pragma once
+
+#include <vector>
+
+#include <QThread>
+#include <QMutex>
+#include <memory>
+
+#include "definitions.h"
+#include "utils/printutils.h"
+#include "dataanalyzerresult.h"
+#include "dsosamples.h"
+
+struct DsoSettingsScope;
+
+////////////////////////////////////////////////////////////////////////////////
+/// \class DataAnalyzer                                           dataanalyzer.h
+/// \brief Analyzes the data from the dso.
+/// Calculates the spectrum and various data about the signal and saves the
+/// time-/frequencysteps between two values.
+class DataAnalyzer : public QObject {
+  Q_OBJECT
+
+public:
+    void applySettings(DsoSettingsScope* scope);
+    void setSourceData(const DSOsamples* data);
+    std::unique_ptr<DataAnalyzerResult> getNextResult();
+    /**
+     * Call this if the source data changed.
+     */
+    void samplesAvailable();
+private:
+    static std::unique_ptr<DataAnalyzerResult> convertData(const DSOsamples *data, const DsoSettingsScope *scope);
+    static void spectrumAnalysis(DataAnalyzerResult* result,
+                                 Dso::WindowFunction &lastWindow,
+                                 unsigned int lastRecordLength,
+                                 const DsoSettingsScope* scope);
+private:
+    DsoSettingsScope* scope;
+    unsigned int lastRecordLength=0; ///< The record length of the previously analyzed data
+    Dso::WindowFunction lastWindow=(Dso::WindowFunction)-1; ///< The previously used dft window function
+    const DSOsamples *sourceData=nullptr;
+    std::unique_ptr<DataAnalyzerResult> lastResult;
+signals:
+  void analyzed();
+};

openhantek/src/analyse/dataanalyzer.h

@@ -0,0 +1,44 @@
+#include "dataanalyzerresult.h"
+#include <stdexcept>
+
+DataAnalyzerResult::DataAnalyzerResult(unsigned int channelCount)
+{
+    analyzedData.resize(channelCount);
+}
+
+/// \brief Returns the analyzed data.
+/// \param channel Channel, whose data should be returned.
+/// \return Analyzed data as AnalyzedData struct.
+const DataChannel *DataAnalyzerResult::data(int channel) const {
+  if (channel >= (int)this->analyzedData.size())
+    return 0;
+
+  return &this->analyzedData[(size_t)channel];
+}
+
+DataChannel *DataAnalyzerResult::modifyData(int channel) {
+  if (channel >= (int)this->analyzedData.size())
+    throw new std::runtime_error("If you modfiy the DataAnalyzerResult, you need to set the channels first!");
+
+  return &this->analyzedData[(size_t)channel];
+}
+
+/// \brief Returns the sample count of the analyzed data.
+/// \return The maximum sample count of the last analyzed data.
+unsigned int DataAnalyzerResult::sampleCount() const { return this->maxSamples; }
+
+unsigned int DataAnalyzerResult::channelCount() const
+{
+    return analyzedData.size();
+}
+
+void DataAnalyzerResult::challengeMaxSamples(unsigned int newMaxSamples)
+{
+    if (newMaxSamples > this->maxSamples)
+        this->maxSamples = newMaxSamples;
+}
+
+unsigned int DataAnalyzerResult::getMaxSamples() const
+{
+    return maxSamples;
+}

openhantek/src/analyse/dataanalyzerresult.cpp

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+#pragma once
+
+#include <vector>
+
+////////////////////////////////////////////////////////////////////////////////
+/// \struct SampleValues                                          dataanalyzer.h
+/// \brief Struct for a array of sample values.
+struct SampleValues {
+  std::vector<double> sample; ///< Vector holding the sampling data
+  double interval=0.0;            ///< The interval between two sample values
+};
+
+////////////////////////////////////////////////////////////////////////////////
+/// \struct AnalyzedData                                          dataanalyzer.h
+/// \brief Struct for the analyzed data.
+struct DataChannel {
+    SampleValues voltage;  ///< The time-domain voltage levels (V)
+    SampleValues spectrum; ///< The frequency-domain power levels (dB)
+    double amplitude = 0.0;   ///< The amplitude of the signal
+    double frequency = 0.0;   ///< The frequency of the signal
+};
+
+class DataAnalyzerResult
+{
+public:
+    DataAnalyzerResult(unsigned int channelCount);
+    const DataChannel *data(int channel) const;
+    DataChannel *modifyData(int channel);
+    unsigned int sampleCount() const;
+    unsigned int channelCount() const;
+    double *window = nullptr;                 ///< The array for the dft window factors
+
+    /**
+     * Applies a new maximum samples value, if the given value is higher than the already stored one
+     * @param newMaxSamples Maximum samples value
+     */
+    void challengeMaxSamples(unsigned int newMaxSamples);
+    unsigned int getMaxSamples() const;
+private:
+    std::vector<DataChannel> analyzedData;          ///< The analyzed data for each channel
+    unsigned int maxSamples = 0; ///< The maximum record length of the analyzed data
+};