Scope: save/load traces memory: fixed trace length and pre trigger info propagation to GUI

sdrgui/dsp/scopevis.cpp

@@ -42,6 +42,7 @@ const uint ScopeVis::m_traceChunkSize = 4800;
 ScopeVis::ScopeVis(GLScope* glScope) :
     m_glScope(glScope),
     m_preTriggerDelay(0),
+    m_livePreTriggerDelay(0),
     m_currentTriggerIndex(0),
     m_focusedTriggerIndex(0),
     m_triggerState(TriggerUntriggered),
@@ -94,7 +95,7 @@ void ScopeVis::setSampleRate(int sampleRate)
     }
 }
 
-void ScopeVis::setTraceSize(uint32_t traceSize)
+void ScopeVis::setTraceSize(uint32_t traceSize, bool emitSignal)
 {
     m_traceSize = traceSize;
     m_traces.resize(m_traceSize);
@@ -102,7 +103,16 @@ void ScopeVis::setTraceSize(uint32_t traceSize)
     initTraceBuffers();
 
     if (m_glScope) {
-        m_glScope->setTraceSize(m_traceSize);
+        m_glScope->setTraceSize(m_traceSize, emitSignal);
+    }
+}
+
+void ScopeVis::setPreTriggerDelay(uint32_t preTriggerDelay, bool emitSignal)
+{
+    m_preTriggerDelay = preTriggerDelay;
+
+    if (m_glScope) {
+        m_glScope->setTriggerPre(m_preTriggerDelay, emitSignal);
     }
 }
 
@@ -652,11 +662,7 @@ bool ScopeVis::handleMessage(const Message& message)
 
         if (m_preTriggerDelay != triggerPre)
         {
-            m_preTriggerDelay = triggerPre;
+            setPreTriggerDelay(triggerPre);
-
-            if (m_glScope) {
-                m_glScope->setTriggerPre(m_preTriggerDelay);
-            }
         }
 
         if (freeRun != m_freeRun)
@@ -844,16 +850,20 @@ bool ScopeVis::handleMessage(const Message& message)
         if (memoryIndex != m_currentTraceMemoryIndex)
         {
             // transition from live mode
-            if (memoryIndex == 0) {
+            if (m_currentTraceMemoryIndex == 0)
+            {
                 m_liveTraceSize = m_traceSize;
+                m_livePreTriggerDelay = m_preTriggerDelay;
             }
 
             m_currentTraceMemoryIndex = memoryIndex;
 
-            if (m_currentTraceMemoryIndex == 0) // transition to live mode
+            // transition to live mode
+            if (m_currentTraceMemoryIndex == 0)
             {
                 setSampleRate(m_liveSampleRate); // reset to live rate
-                setTraceSize(m_liveTraceSize); // reset to live trace size
+                setTraceSize(m_liveTraceSize, true); // reset to live trace size
+                setPreTriggerDelay(m_livePreTriggerDelay, true); // reset to live pre-trigger delay
             }
             else
             {

sdrgui/dsp/scopevis.h

@@ -172,9 +172,10 @@ public:
         SimpleSerializer s(1);
 
         s.writeU32(1, m_traceSize);
-        s.writeS32(2, m_sampleRate);
+        s.writeU32(2, m_preTriggerDelay);
+        s.writeS32(3, m_sampleRate);
         QByteArray buffer = m_traceDiscreteMemory.serialize();
-        s.writeBlob(3, buffer);
+        s.writeBlob(4, buffer);
 
         return s.final();
     }
@@ -189,16 +190,18 @@ public:
 
         if (d.getVersion() == 1)
         {
-            uint32_t traceSize;
+            uint32_t traceSize, preTriggerDelay;
             int sampleRate;
             QByteArray buf;
             bool traceDiscreteMemorySuccess;
 
             d.readU32(1, &traceSize, m_traceChunkSize);
-            d.readS32(2, &sampleRate, 0);
+            d.readU32(2, &preTriggerDelay, 0);
+            d.readS32(3, &sampleRate, 0);
             setSampleRate(sampleRate);
-            setTraceSize(traceSize);
+            setTraceSize(traceSize, true);
-            d.readBlob(3, &buf);
+            setPreTriggerDelay(preTriggerDelay, true);
+            d.readBlob(4, &buf);
             traceDiscreteMemorySuccess = m_traceDiscreteMemory.deserialize(buf);
 
             if (traceDiscreteMemorySuccess && (m_glScope) && (m_currentTraceMemoryIndex > 0)) {
@@ -1087,6 +1090,7 @@ private:
 
     GLScope* m_glScope;
     uint32_t m_preTriggerDelay;                    //!< Pre-trigger delay in number of samples
+    uint32_t m_livePreTriggerDelay;                //!< Pre-trigger delay in number of samples in live mode
     std::vector<TriggerCondition*> m_triggerConditions; //!< Chain of triggers
     uint32_t m_currentTriggerIndex;                //!< Index of current index in the chain
     uint32_t m_focusedTriggerIndex;                //!< Index of the trigger that has focus
@@ -1170,7 +1174,12 @@ private:
     /**
      * Set the traces size
      */
-    void setTraceSize(uint32_t traceSize);
+    void setTraceSize(uint32_t traceSize, bool emitSignal = false);
+
+    /**
+     * Set the pre trigger delay
+     */
+    void setPreTriggerDelay(uint32_t preTriggerDelay, bool emitSignal = false);
 };
 
 

sdrgui/gui/glscope.cpp

@@ -938,11 +938,15 @@ void GLScope::setTimeBase(int timeBase)
     update();
 }
 
-void GLScope::setTriggerPre(uint32_t triggerPre)
+void GLScope::setTriggerPre(uint32_t triggerPre, bool emitSignal)
 {
     m_triggerPre = triggerPre;
     m_configChanged = true;
     update();
+
+    if (emitSignal) {
+        emit preTriggerChanged(m_triggerPre);
+    }
 }
 
 void GLScope::setTimeOfsProMill(int timeOfsProMill)
@@ -966,11 +970,15 @@ void GLScope::setDisplayMode(DisplayMode displayMode)
     update();
 }
 
-void GLScope::setTraceSize(int traceSize)
+void GLScope::setTraceSize(int traceSize, bool emitSignal)
 {
     m_traceSize = traceSize;
     m_configChanged = true;
     update();
+
+    if (emitSignal) {
+        emit traceSizeChanged(m_traceSize);
+    }
 }
 
 void GLScope::updateDisplay()

sdrgui/gui/glscope.h

@@ -58,13 +58,13 @@ public:
     int getSampleRate() const { return m_sampleRate; }
     int getTraceSize() const { return m_traceSize; }
 
-    void setTriggerPre(uint32_t triggerPre); //!< number of samples
+    void setTriggerPre(uint32_t triggerPre, bool emitSignal = false); //!< number of samples
     void setTimeOfsProMill(int timeOfsProMill);
     void setSampleRate(int sampleRate);
     void setTimeBase(int timeBase);
     void setFocusedTraceIndex(uint32_t traceIndex);
     void setDisplayMode(DisplayMode displayMode);
-    void setTraceSize(int trceSize);
+    void setTraceSize(int trceSize, bool emitSignal = false);
     void updateDisplay();
     void setDisplayGridIntensity(int intensity);
     void setDisplayTraceIntensity(int intensity);
@@ -78,6 +78,8 @@ public:
 
 signals:
     void sampleRateChanged(int);
+    void traceSizeChanged(uint32_t);
+    void preTriggerChanged(uint32_t); //!< number of samples
 
 private:
     std::vector<ScopeVis::TraceData> *m_tracesData;

sdrgui/gui/glscopegui.cpp

@@ -104,6 +104,8 @@ void GLScopeGUI::setBuddies(MessageQueue* messageQueue, ScopeVis* scopeVis, GLSc
 
     setEnabled(true);
     connect(m_glScope, SIGNAL(sampleRateChanged(int)), this, SLOT(on_scope_sampleRateChanged(int)));
+    connect(m_glScope, SIGNAL(traceSizeChanged(uint32_t)), this, SLOT(on_scope_traceSizeChanged(uint32_t)));
+    connect(m_glScope, SIGNAL(preTriggerChanged(uint32_t)), this, SLOT(on_scope_preTriggerChanged(uint32_t)));
 
     ui->traceMode->clear();
     fillProjectionCombo(ui->traceMode);
@@ -149,6 +151,21 @@ void GLScopeGUI::on_scope_sampleRateChanged(int sampleRate)
     setTrigDelayDisplay();
 }
 
+void GLScopeGUI::on_scope_traceSizeChanged(uint32_t traceNbSamples)
+{
+    qDebug("GLScopeGUI::on_scope_traceSizeChanged: %u", traceNbSamples);
+    m_traceLenMult = traceNbSamples / ScopeVis::m_traceChunkSize;
+    ui->traceLen->setValue(m_traceLenMult);
+    setTraceLenDisplay();
+}
+
+void GLScopeGUI::on_scope_preTriggerChanged(uint32_t preTriggerNbSamples)
+{
+    qDebug("GLScopeGUI::on_scope_preTriggerChanged: %u", preTriggerNbSamples);
+    ui->trigPre->setValue(preTriggerNbSamples*100 / m_glScope->getTraceSize()); // slider position is a percentage value of the trace size
+    setTrigPreDisplay();
+}
+
 void GLScopeGUI::resetToDefaults()
 {
 }

sdrgui/gui/glscopegui.h

@@ -185,6 +185,8 @@ private:
 
 private slots:
     void on_scope_sampleRateChanged(int value);
+    void on_scope_traceSizeChanged(uint32_t value);
+    void on_scope_preTriggerChanged(uint32_t value);
     // First row
     void on_onlyX_toggled(bool checked);
     void on_onlyY_toggled(bool checked);