13 changed files with 1 additions and 5438 deletions
@ -1,459 +0,0 @@
@@ -1,459 +0,0 @@
|
||||
#include "dsp/scopevis.h" |
||||
#include "gui/glscope.h" |
||||
#include "dsp/dspcommands.h" |
||||
#include "util/messagequeue.h" |
||||
#include <algorithm> |
||||
|
||||
#include <QDebug> |
||||
|
||||
#ifndef LINUX |
||||
inline double log2f(double n) |
||||
{ |
||||
return log(n) / log(2.0); |
||||
} |
||||
#endif |
||||
|
||||
MESSAGE_CLASS_DEFINITION(ScopeVis::MsgConfigureScopeVis, Message) |
||||
|
||||
const uint ScopeVis::m_traceChunkSize = 4800; |
||||
|
||||
ScopeVis::ScopeVis(Real scalef, GLScope* glScope) : |
||||
m_glScope(glScope), |
||||
m_scalef(scalef), |
||||
m_tracebackCount(0), |
||||
m_fill(0), |
||||
m_triggerState(Untriggered), |
||||
m_triggerIndex(0), |
||||
m_prevTrigger(false), |
||||
m_triggerPre(0), |
||||
m_triggerOneShot(false), |
||||
m_armed(false), |
||||
m_triggerDelayCount(0), |
||||
m_triggerCount(0), |
||||
m_sampleRate(0), |
||||
m_prevArg(0.0), |
||||
m_firstArg(true) |
||||
{ |
||||
setObjectName("ScopeVis"); |
||||
m_trace.reserve(100*m_traceChunkSize); |
||||
m_trace.resize(20*m_traceChunkSize); |
||||
m_traceback.resize(20*m_traceChunkSize); |
||||
|
||||
for (unsigned int i = 0; i < m_nbTriggers; i++) |
||||
{ |
||||
m_triggerChannel[i] = TriggerFreeRun; |
||||
m_triggerLevel[i] = 0.0; |
||||
m_triggerPositiveEdge[i] = true; |
||||
m_triggerBothEdges[i] = false; |
||||
m_triggerDelay[i] = 0; |
||||
m_triggerCounts[i] = 0; |
||||
} |
||||
} |
||||
|
||||
ScopeVis::~ScopeVis() |
||||
{ |
||||
} |
||||
|
||||
void ScopeVis::configure(MessageQueue* msgQueue, |
||||
uint triggerIndex, |
||||
TriggerChannel triggerChannel, |
||||
Real triggerLevel, |
||||
bool triggerPositiveEdge, |
||||
bool triggerBothEdges, |
||||
uint triggerPre, |
||||
uint triggerDelay, |
||||
uint triggerCounts, |
||||
uint traceSize) |
||||
{ |
||||
Message* cmd = MsgConfigureScopeVis::create(triggerIndex, |
||||
triggerChannel, |
||||
triggerLevel, |
||||
triggerPositiveEdge, |
||||
triggerBothEdges, |
||||
triggerPre, |
||||
triggerDelay, |
||||
triggerCounts, |
||||
traceSize); |
||||
msgQueue->push(cmd); |
||||
} |
||||
|
||||
void ScopeVis::feed(const SampleVector::const_iterator& cbegin, const SampleVector::const_iterator& end, bool positiveOnly __attribute__((unused))) |
||||
{ |
||||
SampleVector::const_iterator begin(cbegin); |
||||
|
||||
if (m_triggerChannel[m_triggerIndex] == TriggerFreeRun) { |
||||
m_triggerPoint = begin; |
||||
} |
||||
else if (m_triggerState == Triggered) { |
||||
m_triggerPoint = begin; |
||||
} |
||||
else if (m_triggerState == Untriggered) { |
||||
m_triggerPoint = end; |
||||
} |
||||
else if (m_triggerState == WaitForReset) { |
||||
m_triggerPoint = end; |
||||
} |
||||
else { |
||||
m_triggerPoint = begin; |
||||
} |
||||
|
||||
while(begin < end) |
||||
{ |
||||
if (m_triggerChannel[m_triggerIndex] == TriggerFreeRun) |
||||
{ |
||||
int count = end - begin; |
||||
|
||||
if(count > (int)(m_trace.size() - m_fill)) |
||||
{ |
||||
count = m_trace.size() - m_fill; |
||||
} |
||||
|
||||
std::vector<Complex>::iterator it = m_trace.begin() + m_fill; |
||||
|
||||
for(int i = 0; i < count; ++i) |
||||
{ |
||||
*it++ = Complex(begin->real() / m_scalef, begin->imag() / m_scalef); |
||||
++begin; |
||||
} |
||||
|
||||
m_fill += count; |
||||
|
||||
if(m_fill >= m_trace.size()) |
||||
{ |
||||
m_glScope->newTrace(m_trace, m_sampleRate); |
||||
m_fill = 0; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
if(m_triggerState == WaitForReset) |
||||
{ |
||||
break; |
||||
} |
||||
if(m_triggerState == Config) |
||||
{ |
||||
m_glScope->newTrace(m_trace, m_sampleRate); // send a dummy trace
|
||||
m_triggerState = Untriggered; |
||||
m_triggerIndex = 0; |
||||
} |
||||
if(m_triggerState == Delay) |
||||
{ |
||||
int count = end - begin; |
||||
if (count > (int)(m_trace.size() - m_fill)) |
||||
{ |
||||
count = m_trace.size() - m_fill; |
||||
} |
||||
begin += count; |
||||
m_fill += count; |
||||
if(m_fill >= m_trace.size()) |
||||
{ |
||||
m_fill = 0; |
||||
m_triggerDelayCount--; |
||||
if (m_triggerDelayCount == 0) |
||||
{ |
||||
if (nextTrigger()) |
||||
{ |
||||
m_triggerState = Untriggered; |
||||
} |
||||
else |
||||
{ |
||||
m_triggerState = Triggered; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
if(m_triggerState == Untriggered) |
||||
{ |
||||
m_firstArg = true; |
||||
|
||||
while(begin < end) |
||||
{ |
||||
bool triggerCdt = triggerCondition(begin); |
||||
|
||||
if (m_tracebackCount > m_triggerPre) |
||||
{ |
||||
bool trigger; |
||||
|
||||
if (m_triggerBothEdges[m_triggerIndex]) { |
||||
trigger = m_prevTrigger ^ triggerCdt; |
||||
} else { |
||||
trigger = triggerCdt ^ !m_triggerPositiveEdge[m_triggerIndex]; |
||||
} |
||||
|
||||
if (trigger) |
||||
{ |
||||
if (m_armed) |
||||
{ |
||||
m_armed = false; |
||||
if (m_triggerDelay[m_triggerIndex] > 0) |
||||
{ |
||||
m_triggerDelayCount = m_triggerDelay[m_triggerIndex]; |
||||
m_fill = 0; |
||||
m_triggerState = Delay; |
||||
} |
||||
else |
||||
{ |
||||
if (nextTrigger()) |
||||
{ |
||||
m_triggerState = Untriggered; |
||||
} |
||||
else |
||||
{ |
||||
m_triggerState = Triggered; |
||||
m_triggerPoint = begin; |
||||
// fill beginning of m_trace with delayed samples from the trace memory FIFO. Increment m_fill accordingly.
|
||||
if (m_triggerPre) { // do this process only if there is a pre-trigger delay
|
||||
std::copy(m_traceback.end() - m_triggerPre - 1, m_traceback.end() - 1, m_trace.begin()); |
||||
m_fill = m_triggerPre; // Increment m_fill accordingly (from 0).
|
||||
} |
||||
} |
||||
} |
||||
break; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
m_armed = true; |
||||
} |
||||
} |
||||
m_prevTrigger = triggerCdt; |
||||
++begin; |
||||
} |
||||
} |
||||
|
||||
if(m_triggerState == Triggered) |
||||
{ |
||||
int count = end - begin; |
||||
|
||||
if(count > (int)(m_trace.size() - m_fill)) |
||||
{ |
||||
count = m_trace.size() - m_fill; |
||||
} |
||||
|
||||
std::vector<Complex>::iterator it = m_trace.begin() + m_fill; |
||||
|
||||
for(int i = 0; i < count; ++i) |
||||
{ |
||||
*it++ = Complex(begin->real() / m_scalef, begin->imag() / m_scalef); |
||||
++begin; |
||||
} |
||||
|
||||
m_fill += count; |
||||
|
||||
if(m_fill >= m_trace.size()) |
||||
{ |
||||
m_glScope->newTrace(m_trace, m_sampleRate); |
||||
m_fill = 0; |
||||
|
||||
if (m_triggerOneShot) { |
||||
m_triggerState = WaitForReset; |
||||
} else { |
||||
m_tracebackCount = 0; |
||||
m_triggerState = Untriggered; |
||||
m_triggerIndex = 0; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
void ScopeVis::start() |
||||
{ |
||||
} |
||||
|
||||
void ScopeVis::stop() |
||||
{ |
||||
} |
||||
|
||||
bool ScopeVis::handleMessage(const Message& message) |
||||
{ |
||||
qDebug() << "ScopeVis::handleMessage"; |
||||
|
||||
if (DSPSignalNotification::match(message)) |
||||
{ |
||||
DSPSignalNotification& notif = (DSPSignalNotification&) message; |
||||
m_sampleRate = notif.getSampleRate(); |
||||
qDebug() << " - DSPSignalNotification: m_sampleRate: " << m_sampleRate; |
||||
|
||||
return true; |
||||
} |
||||
else if (MsgConfigureScopeVis::match(message)) |
||||
{ |
||||
MsgConfigureScopeVis& conf = (MsgConfigureScopeVis&) message; |
||||
|
||||
m_tracebackCount = 0; |
||||
m_triggerState = Config; |
||||
uint index = conf.getTriggerIndex(); |
||||
m_triggerChannel[index] = (TriggerChannel) conf.getTriggerChannel(); |
||||
m_triggerLevel[index] = conf.getTriggerLevel(); |
||||
m_triggerPositiveEdge[index] = conf.getTriggerPositiveEdge(); |
||||
m_triggerBothEdges[index] = conf.getTriggerBothEdges(); |
||||
m_triggerPre = conf.getTriggerPre(); |
||||
|
||||
if (m_triggerChannel[index] == TriggerDPhase) |
||||
{ |
||||
m_firstArg = true; |
||||
} |
||||
|
||||
if (m_triggerPre >= m_traceback.size()) |
||||
{ |
||||
m_triggerPre = m_traceback.size() - 1; // top sample in FIFO is always the triggering one (pre-trigger delay = 0)
|
||||
} |
||||
|
||||
m_triggerDelay[index] = conf.getTriggerDelay(); |
||||
m_triggerCounts[index] = conf.getTriggerCounts(); |
||||
uint newSize = conf.getTraceSize(); |
||||
|
||||
if (newSize != m_trace.size()) |
||||
{ |
||||
m_trace.resize(newSize); |
||||
} |
||||
|
||||
if (newSize > m_traceback.size()) // fitting the exact required space is not a requirement for the back trace
|
||||
{ |
||||
m_traceback.resize(newSize); |
||||
} |
||||
|
||||
qDebug() << " - MsgConfigureScopeVis:" |
||||
<< " triggerIndex: " << index |
||||
<< " m_triggerChannel: " << m_triggerChannel[index] |
||||
<< " m_triggerLevel: " << m_triggerLevel[index] |
||||
<< " m_triggerPositiveEdge: " << (m_triggerPositiveEdge[index] ? "edge+" : "edge-") |
||||
<< " m_triggerBothEdges: " << (m_triggerBothEdges[index] ? "yes" : "no") |
||||
<< " m_preTrigger: " << m_triggerPre |
||||
<< " m_triggerDelay: " << m_triggerDelay[index] |
||||
<< " m_triggerCounts: " << m_triggerCounts[index] |
||||
<< " m_traceSize: " << m_trace.size(); |
||||
|
||||
return true; |
||||
} |
||||
else |
||||
{ |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
void ScopeVis::setSampleRate(int sampleRate) |
||||
{ |
||||
m_sampleRate = sampleRate; |
||||
} |
||||
|
||||
bool ScopeVis::triggerCondition(SampleVector::const_iterator& it) |
||||
{ |
||||
Complex c(it->real()/m_scalef, it->imag()/m_scalef); |
||||
m_traceback.push_back(c); // store into trace memory FIFO
|
||||
|
||||
if (m_tracebackCount < m_traceback.size()) |
||||
{ // increment count up to trace memory size
|
||||
m_tracebackCount++; |
||||
} |
||||
|
||||
if (m_triggerChannel[m_triggerIndex] == TriggerChannelI) |
||||
{ |
||||
return c.real() > m_triggerLevel[m_triggerIndex]; |
||||
} |
||||
else if (m_triggerChannel[m_triggerIndex] == TriggerChannelQ) |
||||
{ |
||||
return c.imag() > m_triggerLevel[m_triggerIndex]; |
||||
} |
||||
else if (m_triggerChannel[m_triggerIndex] == TriggerMagLin) |
||||
{ |
||||
return abs(c) > m_triggerLevel[m_triggerIndex]; |
||||
} |
||||
else if (m_triggerChannel[m_triggerIndex] == TriggerMagDb) |
||||
{ |
||||
Real mult = (10.0f / log2f(10.0f)); |
||||
Real v = c.real() * c.real() + c.imag() * c.imag(); |
||||
return mult * log2f(v) > m_triggerLevel[m_triggerIndex]; |
||||
} |
||||
else if (m_triggerChannel[m_triggerIndex] == TriggerPhase) |
||||
{ |
||||
return arg(c) / M_PI > m_triggerLevel[m_triggerIndex]; |
||||
} |
||||
else if (m_triggerChannel[m_triggerIndex] == TriggerDPhase) |
||||
{ |
||||
Real curArg = arg(c) - m_prevArg; |
||||
m_prevArg = arg(c); |
||||
|
||||
if (curArg < -M_PI) { |
||||
curArg += 2.0 * M_PI; |
||||
} else if (curArg > M_PI) { |
||||
curArg -= 2.0 * M_PI; |
||||
} |
||||
|
||||
if (m_firstArg) |
||||
{ |
||||
m_firstArg = false; |
||||
return false; |
||||
} |
||||
else |
||||
{ |
||||
return curArg / M_PI > m_triggerLevel[m_triggerIndex]; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
void ScopeVis::setOneShot(bool oneShot) |
||||
{ |
||||
m_triggerOneShot = oneShot; |
||||
|
||||
if ((m_triggerState == WaitForReset) && !oneShot) { |
||||
m_tracebackCount = 0; |
||||
m_triggerState = Untriggered; |
||||
m_triggerIndex = 0; |
||||
} |
||||
} |
||||
|
||||
void ScopeVis::blockTrigger(bool blocked) |
||||
{ |
||||
if (blocked) |
||||
{ |
||||
m_triggerState = WaitForReset; |
||||
} |
||||
else |
||||
{ |
||||
if (!m_triggerOneShot) { |
||||
m_tracebackCount = 0; |
||||
m_triggerState = Untriggered; |
||||
m_triggerIndex = 0; |
||||
} |
||||
} |
||||
} |
||||
|
||||
bool ScopeVis::nextTrigger() |
||||
{ |
||||
if (m_triggerCount < m_triggerCounts[m_triggerIndex]) |
||||
{ |
||||
m_triggerCount++; |
||||
return true; |
||||
} |
||||
else |
||||
{ |
||||
m_triggerIndex++; |
||||
m_prevTrigger = false; |
||||
m_triggerDelayCount = 0; |
||||
m_triggerCount = 0; |
||||
m_armed = false; |
||||
|
||||
if (m_triggerIndex == m_nbTriggers) |
||||
{ |
||||
m_triggerIndex = 0; |
||||
return false; |
||||
} |
||||
else if (m_triggerChannel[m_triggerIndex] == TriggerFreeRun) |
||||
{ |
||||
m_triggerIndex = 0; |
||||
return false; |
||||
} |
||||
else |
||||
{ |
||||
return true; |
||||
} |
||||
} |
||||
} |
||||
@ -1,171 +0,0 @@
@@ -1,171 +0,0 @@
|
||||
#ifndef INCLUDE_SCOPEVIS_H |
||||
#define INCLUDE_SCOPEVIS_H |
||||
|
||||
#include <boost/circular_buffer.hpp> |
||||
#include <dsp/basebandsamplesink.h> |
||||
#include "export.h" |
||||
#include "util/message.h" |
||||
|
||||
class GLScope; |
||||
class MessageQueue; |
||||
|
||||
class SDRGUI_API ScopeVis : public BasebandSampleSink { |
||||
public: |
||||
enum TriggerChannel { |
||||
TriggerFreeRun, |
||||
TriggerChannelI, |
||||
TriggerChannelQ, |
||||
TriggerMagLin, |
||||
TriggerMagDb, |
||||
TriggerPhase, |
||||
TriggerDPhase |
||||
}; |
||||
|
||||
static const uint m_traceChunkSize; |
||||
static const uint m_nbTriggers = 10; |
||||
|
||||
ScopeVis(Real scalef, GLScope* glScope = 0); |
||||
virtual ~ScopeVis(); |
||||
|
||||
void configure(MessageQueue* msgQueue, |
||||
uint triggerIndex, |
||||
TriggerChannel triggerChannel, |
||||
Real triggerLevel, |
||||
bool triggerPositiveEdge, |
||||
bool triggerBothEdges, |
||||
uint triggerPre, |
||||
uint triggerDelay, |
||||
uint triggerCounts, |
||||
uint traceSize); |
||||
void setOneShot(bool oneShot); |
||||
void blockTrigger(bool blecked); |
||||
|
||||
virtual void feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, bool positiveOnly); |
||||
virtual void start(); |
||||
virtual void stop(); |
||||
virtual bool handleMessage(const Message& message); |
||||
|
||||
void setSampleRate(int sampleRate); |
||||
int getSampleRate() const { return m_sampleRate; } |
||||
SampleVector::const_iterator getTriggerPoint() const { return m_triggerPoint; } |
||||
|
||||
private: |
||||
class MsgConfigureScopeVis : public Message { |
||||
MESSAGE_CLASS_DECLARATION |
||||
|
||||
public: |
||||
uint getTriggerIndex() const { return m_triggerIndex; } |
||||
int getTriggerChannel() const { return m_triggerChannel; } |
||||
Real getTriggerLevel() const { return m_triggerLevel; } |
||||
bool getTriggerPositiveEdge() const { return m_triggerPositiveEdge; } |
||||
bool getTriggerBothEdges() const { return m_triggerBothEdges; } |
||||
uint getTriggerPre() const { return m_triggerPre; } |
||||
uint getTriggerDelay() const { return m_triggerDelay; } |
||||
uint getTriggerCounts() const { return m_triggerCounts; } |
||||
uint getTraceSize() const { return m_traceSize; } |
||||
|
||||
static MsgConfigureScopeVis* create(uint triggerIndex, |
||||
int triggerChannel, |
||||
Real triggerLevel, |
||||
bool triggerPositiveEdge, |
||||
bool triggerBothEdges, |
||||
uint triggerPre, |
||||
uint triggerDelay, |
||||
uint triggerCounts, |
||||
uint traceSize) |
||||
{ |
||||
return new MsgConfigureScopeVis(triggerIndex, |
||||
triggerChannel, |
||||
triggerLevel, |
||||
triggerPositiveEdge, |
||||
triggerBothEdges, |
||||
triggerPre, |
||||
triggerDelay, |
||||
triggerCounts, |
||||
traceSize); |
||||
} |
||||
|
||||
private: |
||||
uint m_triggerIndex; |
||||
int m_triggerChannel; |
||||
Real m_triggerLevel; |
||||
bool m_triggerPositiveEdge; |
||||
bool m_triggerBothEdges; |
||||
uint m_triggerPre; |
||||
uint m_triggerDelay; |
||||
uint m_triggerCounts; |
||||
uint m_traceSize; |
||||
|
||||
MsgConfigureScopeVis(uint triggerIndex, |
||||
int triggerChannel, |
||||
Real triggerLevel, |
||||
bool triggerPositiveEdge, |
||||
bool triggerBothEdges, |
||||
uint triggerPre, |
||||
uint triggerDelay, |
||||
uint triggerCounts, |
||||
uint traceSize) : |
||||
Message(), |
||||
m_triggerIndex(triggerIndex), |
||||
m_triggerChannel(triggerChannel), |
||||
m_triggerLevel(triggerLevel), |
||||
m_triggerPositiveEdge(triggerPositiveEdge), |
||||
m_triggerBothEdges(triggerBothEdges), |
||||
m_triggerPre(triggerPre), |
||||
m_triggerDelay(triggerDelay), |
||||
m_triggerCounts(triggerCounts), |
||||
m_traceSize(traceSize) |
||||
{ } |
||||
}; |
||||
|
||||
/**
|
||||
* TriggerState: (repeat at each successive non freerun trigger) |
||||
* |
||||
* send a Trigger condition +--------------------+ |
||||
* dummy trace - Immediate m_triggerOneShot | | |
||||
* Config -------------> Untriggered ----------------------------------> Triggered ----------------> WaitForReset | |
||||
* ^ ^ | ^ | | ^ | |
||||
* | | | - Delayed Delay expired | | | | setOneShot(true)| |
||||
* | | +---------------------> Delay ----------------+ | | +-----------------+ |
||||
* | | !m_triggerOneShot | | |
||||
* | +--------------------------------------------------+ setOneShot(false) | |
||||
* +-------------------------------------------------------------------------------+ |
||||
*/ |
||||
enum TriggerState { |
||||
Untriggered, //!< Search for trigger
|
||||
Config, //!< New configuration has just been received
|
||||
Triggered, //!< Trigger was kicked off
|
||||
WaitForReset, //!< Wait for release from GUI
|
||||
Delay //!< Trigger delay engaged
|
||||
}; |
||||
|
||||
GLScope* m_glScope; |
||||
Real m_scalef; //!< Sample scale factor from [-1,+1] to integer sample size range
|
||||
std::vector<Complex> m_trace; //!< Raw trace to be used by GLScope
|
||||
boost::circular_buffer<Complex> m_traceback; //!< FIFO for samples prior to triggering point to support pre-trigger (when in triggered mode)
|
||||
uint m_tracebackCount; //!< Count of samples stored into trace memory since triggering is active up to trace memory size
|
||||
uint m_fill; |
||||
TriggerState m_triggerState; |
||||
uint m_triggerIndex; //!< current active trigger index
|
||||
TriggerChannel m_triggerChannel[m_nbTriggers]; |
||||
Real m_triggerLevel[m_nbTriggers]; |
||||
bool m_triggerPositiveEdge[m_nbTriggers]; |
||||
bool m_triggerBothEdges[m_nbTriggers]; |
||||
bool m_prevTrigger; |
||||
uint m_triggerPre; //!< Pre-trigger delay in number of samples
|
||||
bool m_triggerOneShot; |
||||
bool m_armed; |
||||
uint m_triggerDelay[m_nbTriggers]; //!< Trigger delay in number of trace sizes
|
||||
uint m_triggerDelayCount; //!< trace sizes delay counter
|
||||
uint m_triggerCounts[m_nbTriggers]; //!< Number of trigger events before the actual trigger is kicked off
|
||||
uint m_triggerCount; |
||||
int m_sampleRate; |
||||
SampleVector::const_iterator m_triggerPoint; |
||||
Real m_prevArg; |
||||
bool m_firstArg; |
||||
|
||||
bool triggerCondition(SampleVector::const_iterator& it); |
||||
bool nextTrigger(); //!< move to next trigger. Returns true if next trigger is active.
|
||||
}; |
||||
|
||||
#endif // INCLUDE_SCOPEVIS_H
|
||||
@ -1,41 +0,0 @@
@@ -1,41 +0,0 @@
|
||||
#include "dsp/spectrumscopecombovis.h" |
||||
#include "dsp/dspcommands.h" |
||||
#include "util/messagequeue.h" |
||||
|
||||
SpectrumScopeComboVis::SpectrumScopeComboVis(SpectrumVis* spectrumVis, ScopeVis* scopeVis) : |
||||
m_spectrumVis(spectrumVis), |
||||
m_scopeVis(scopeVis) |
||||
{ |
||||
setObjectName("SpectrumScopeComboVis"); |
||||
} |
||||
|
||||
SpectrumScopeComboVis::~SpectrumScopeComboVis() |
||||
{ |
||||
} |
||||
|
||||
void SpectrumScopeComboVis::feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, bool positiveOnly __attribute__((unused))) |
||||
{ |
||||
m_scopeVis->feed(begin, end, false); |
||||
SampleVector::const_iterator triggerPoint = m_scopeVis->getTriggerPoint(); |
||||
m_spectrumVis->feedTriggered(triggerPoint, end, positiveOnly); |
||||
} |
||||
|
||||
void SpectrumScopeComboVis::start() |
||||
{ |
||||
m_spectrumVis->start(); |
||||
m_scopeVis->start(); |
||||
} |
||||
|
||||
void SpectrumScopeComboVis::stop() |
||||
{ |
||||
m_spectrumVis->stop(); |
||||
m_scopeVis->stop(); |
||||
} |
||||
|
||||
bool SpectrumScopeComboVis::handleMessage(const Message& message) |
||||
{ |
||||
bool spectDone = m_spectrumVis->handleMessage(message); |
||||
bool scopeDone = m_scopeVis->handleMessage(message); |
||||
|
||||
return (spectDone || scopeDone); |
||||
} |
||||
@ -1,27 +0,0 @@
@@ -1,27 +0,0 @@
|
||||
#ifndef INCLUDE_SPECTRUMSCOPECOMBOVIS_H |
||||
#define INCLUDE_SPECTRUMSCOPECOMBOVIS_H |
||||
|
||||
#include <dsp/basebandsamplesink.h> |
||||
#include "dsp/spectrumvis.h" |
||||
#include "dsp/scopevis.h" |
||||
#include "export.h" |
||||
|
||||
class Message; |
||||
|
||||
class SDRGUI_API SpectrumScopeComboVis : public BasebandSampleSink { |
||||
public: |
||||
|
||||
SpectrumScopeComboVis(SpectrumVis* spectrumVis, ScopeVis* scopeVis); |
||||
virtual ~SpectrumScopeComboVis(); |
||||
|
||||
virtual void feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, bool positiveOnly); |
||||
virtual void start(); |
||||
virtual void stop(); |
||||
virtual bool handleMessage(const Message& message); |
||||
|
||||
private: |
||||
SpectrumVis* m_spectrumVis; |
||||
ScopeVis* m_scopeVis; |
||||
}; |
||||
|
||||
#endif // INCLUDE_SPECTRUMSCOPECOMBOVIS_H
|
||||
@ -1,193 +0,0 @@
@@ -1,193 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2016 F4EXB //
|
||||
// written by Edouard Griffiths //
|
||||
// //
|
||||
// OpenGL interface modernization. //
|
||||
// See: http://doc.qt.io/qt-5/qopenglshaderprogram.html //
|
||||
// //
|
||||
// This program is free software; you can redistribute it and/or modify //
|
||||
// it under the terms of the GNU General Public License as published by //
|
||||
// the Free Software Foundation as version 3 of the License, or //
|
||||
// //
|
||||
// This program is distributed in the hope that it will be useful, //
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
||||
// GNU General Public License V3 for more details. //
|
||||
// //
|
||||
// You should have received a copy of the GNU General Public License //
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef INCLUDE_GLSCOPE_H |
||||
#define INCLUDE_GLSCOPE_H |
||||
|
||||
#include <QGLWidget> |
||||
#include <QPen> |
||||
#include <QTimer> |
||||
#include <QMutex> |
||||
#include <QFont> |
||||
#include <QMatrix4x4> |
||||
#include "dsp/dsptypes.h" |
||||
#include "dsp/scopevis.h" |
||||
#include "gui/scaleengine.h" |
||||
#include "gui/glshadersimple.h" |
||||
#include "gui/glshadertextured.h" |
||||
#include "export.h" |
||||
#include "util/bitfieldindex.h" |
||||
#include "util/incrementalarray.h" |
||||
|
||||
class ScopeVis; |
||||
class QPainter; |
||||
|
||||
class SDRGUI_API GLScope: public QGLWidget { |
||||
Q_OBJECT |
||||
|
||||
public: |
||||
enum Mode { |
||||
ModeIQ, |
||||
ModeMagLinPha, |
||||
ModeMagdBPha, |
||||
ModeMagLinDPha, |
||||
ModeMagdBDPha, |
||||
ModeDerived12, |
||||
ModeCyclostationary, |
||||
ModeIQPolar |
||||
}; |
||||
|
||||
enum Displays { |
||||
DisplayBoth, |
||||
DisplayFirstOnly, |
||||
DisplaySecondOnly |
||||
}; |
||||
|
||||
GLScope(QWidget* parent = NULL); |
||||
~GLScope(); |
||||
|
||||
// void setDSPEngine(DSPEngine* dspEngine);
|
||||
void setAmp1(Real amp); |
||||
void setAmp1Ofs(Real ampOfs); |
||||
void setAmp2(Real amp); |
||||
void setAmp2Ofs(Real ampOfs); |
||||
void setTimeBase(int timeBase); |
||||
void setTimeOfsProMill(int timeOfsProMill); |
||||
void setMode(Mode mode); |
||||
void setDisplays(Displays displays); |
||||
void setOrientation(Qt::Orientation orientation); |
||||
void setDisplayGridIntensity(int intensity); |
||||
void setDisplayTraceIntensity(int intensity); |
||||
void setTriggerChannel(ScopeVis::TriggerChannel triggerChannel); |
||||
void setTriggerLevel(Real triggerLevel); |
||||
void setTriggerPre(Real triggerPre); |
||||
void setMemHistoryShift(int value); |
||||
|
||||
void newTrace(const std::vector<Complex>& trace, int sampleRate); |
||||
int getTraceSize() const { return m_rawTrace[m_memTraceIndex - m_memTraceHistory].size(); } |
||||
|
||||
void setSampleRate(int sampleRate); |
||||
int getSampleRate() const { return m_sampleRates[m_memTraceIndex - m_memTraceHistory]; } |
||||
Mode getDataMode() const { return m_mode; } |
||||
void connectTimer(const QTimer& timer); |
||||
|
||||
static const int m_memHistorySizeLog2 = 5; |
||||
|
||||
signals: |
||||
void traceSizeChanged(int); |
||||
void sampleRateChanged(int); |
||||
|
||||
private: |
||||
// state
|
||||
QTimer m_timer; |
||||
QMutex m_mutex; |
||||
bool m_dataChanged; |
||||
bool m_configChanged; |
||||
Mode m_mode; |
||||
Displays m_displays; |
||||
Qt::Orientation m_orientation; |
||||
|
||||
// traces
|
||||
std::vector<Complex> m_rawTrace[1<<m_memHistorySizeLog2]; |
||||
int m_sampleRates[1<<m_memHistorySizeLog2]; |
||||
BitfieldIndex<m_memHistorySizeLog2> m_memTraceIndex; //!< current index of trace being written
|
||||
BitfieldIndex<m_memHistorySizeLog2> m_memTraceHistory; //!< trace index shift into history
|
||||
int m_memTraceIndexMax; |
||||
bool m_memTraceRecall; |
||||
std::vector<Complex> m_mathTrace; |
||||
std::vector<Complex>* m_displayTrace; |
||||
std::vector<Real> m_powTrace; |
||||
Real m_maxPow; |
||||
Real m_sumPow; |
||||
int m_oldTraceSize; |
||||
int m_sampleRate; |
||||
Real m_amp1; |
||||
Real m_amp2; |
||||
Real m_ofs1; |
||||
Real m_ofs2; |
||||
|
||||
// config
|
||||
int m_timeBase; |
||||
int m_timeOfsProMill; |
||||
ScopeVis::TriggerChannel m_triggerChannel; |
||||
Real m_triggerLevel; |
||||
Real m_triggerPre; |
||||
Real m_triggerLevelDis1; |
||||
Real m_triggerLevelDis2; |
||||
int m_nbPow; |
||||
Real m_prevArg; |
||||
|
||||
// graphics stuff
|
||||
QRectF m_glScopeRect1; |
||||
QRectF m_glScopeRect2; |
||||
QMatrix4x4 m_glScopeMatrix1; |
||||
QMatrix4x4 m_glScopeMatrix2; |
||||
QMatrix4x4 m_glLeft1ScaleMatrix; |
||||
QMatrix4x4 m_glRight1ScaleMatrix; |
||||
QMatrix4x4 m_glLeft2ScaleMatrix; |
||||
QMatrix4x4 m_glBot1ScaleMatrix; |
||||
QMatrix4x4 m_glBot2ScaleMatrix; |
||||
|
||||
QPixmap m_left1ScalePixmap; |
||||
QPixmap m_left2ScalePixmap; |
||||
QPixmap m_bot1ScalePixmap; |
||||
QPixmap m_bot2ScalePixmap; |
||||
QPixmap m_powerOverlayPixmap1; |
||||
|
||||
int m_displayGridIntensity; |
||||
int m_displayTraceIntensity; |
||||
|
||||
ScaleEngine m_x1Scale; |
||||
ScaleEngine m_x2Scale; |
||||
ScaleEngine m_y1Scale; |
||||
ScaleEngine m_y2Scale; |
||||
|
||||
QFont m_powerOverlayFont; |
||||
|
||||
GLShaderSimple m_glShaderSimple; |
||||
GLShaderTextured m_glShaderLeft1Scale; |
||||
GLShaderTextured m_glShaderBottom1Scale; |
||||
GLShaderTextured m_glShaderLeft2Scale; |
||||
GLShaderTextured m_glShaderBottom2Scale; |
||||
GLShaderTextured m_glShaderPowerOverlay; |
||||
|
||||
IncrementalArray<GLfloat> m_q3Trace; |
||||
IncrementalArray<GLfloat> m_q3TickY1; |
||||
IncrementalArray<GLfloat> m_q3TickY2; |
||||
IncrementalArray<GLfloat> m_q3TickX1; |
||||
IncrementalArray<GLfloat> m_q3TickX2; |
||||
|
||||
void initializeGL(); |
||||
void resizeGL(int width, int height); |
||||
void paintGL(); |
||||
|
||||
void mousePressEvent(QMouseEvent*); |
||||
|
||||
void handleMode(); |
||||
void applyConfig(); |
||||
void applyTraceConfig(uint32_t size); |
||||
void drawPowerOverlay(); |
||||
|
||||
protected slots: |
||||
void cleanup(); |
||||
void tick(); |
||||
}; |
||||
|
||||
#endif // INCLUDE_GLSCOPE_H
|
||||
@ -1,919 +0,0 @@
@@ -1,919 +0,0 @@
|
||||
#include "gui/glscopegui.h" |
||||
#include "dsp/scopevis.h" |
||||
#include "dsp/dspcommands.h" |
||||
#include "gui/glscope.h" |
||||
#include "util/simpleserializer.h" |
||||
#include "ui_glscopegui.h" |
||||
|
||||
#include <QDebug> |
||||
|
||||
const qreal GLScopeGUI::amps[11] = { 0.2, 0.1, 0.05, 0.02, 0.01, 0.005, 0.002, 0.001, 0.0005, 0.0002, 0.0001 }; |
||||
|
||||
GLScopeGUI::GLScopeGUI(QWidget* parent) : |
||||
QWidget(parent), |
||||
ui(new Ui::GLScopeGUI), |
||||
m_messageQueue(0), |
||||
m_scopeVis(0), |
||||
m_glScope(0), |
||||
m_sampleRate(1), |
||||
m_displayData(GLScope::ModeIQ), |
||||
m_displayOrientation(Qt::Horizontal), |
||||
m_displays(GLScope::DisplayBoth), |
||||
m_timeBase(1), |
||||
m_timeOffset(0), |
||||
m_amplification1(0), |
||||
m_amp1OffsetCoarse(0), |
||||
m_amp1OffsetFine(0), |
||||
m_amplification2(0), |
||||
m_amp2OffsetCoarse(0), |
||||
m_amp2OffsetFine(0), |
||||
m_displayGridIntensity(1), |
||||
m_displayTraceIntensity(50), |
||||
m_triggerIndex(0), |
||||
m_triggerPre(0), |
||||
m_traceLenMult(20) |
||||
{ |
||||
for (unsigned int i = 0; i < ScopeVis::m_nbTriggers; i++) |
||||
{ |
||||
m_triggerChannel[i] = ScopeVis::TriggerFreeRun; |
||||
m_triggerLevelCoarse[i] = 0; |
||||
m_triggerLevelFine[i] = 0; |
||||
m_triggerPositiveEdge[i] = true; |
||||
m_triggerBothEdges[i] = false; |
||||
m_triggerDelay[i] = 0; |
||||
m_triggerCounts[i] = 0; |
||||
} |
||||
|
||||
ui->setupUi(this); |
||||
} |
||||
|
||||
GLScopeGUI::~GLScopeGUI() |
||||
{ |
||||
delete ui; |
||||
} |
||||
|
||||
void GLScopeGUI::setBuddies(MessageQueue* messageQueue, ScopeVis* scopeVis, GLScope* glScope) |
||||
{ |
||||
m_messageQueue = messageQueue; |
||||
m_scopeVis = scopeVis; |
||||
m_glScope = glScope; |
||||
ui->memIndex->setMaximum((1<<GLScope::m_memHistorySizeLog2)-1); |
||||
connect(m_glScope, SIGNAL(traceSizeChanged(int)), this, SLOT(on_scope_traceSizeChanged(int))); |
||||
connect(m_glScope, SIGNAL(sampleRateChanged(int)), this, SLOT(on_scope_sampleRateChanged(int))); |
||||
applySettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::setSampleRate(int sampleRate) |
||||
{ |
||||
m_sampleRate = sampleRate; |
||||
} |
||||
|
||||
void GLScopeGUI::resetToDefaults() |
||||
{ |
||||
m_displayData = GLScope::ModeIQ; |
||||
m_displayOrientation = Qt::Horizontal; |
||||
m_timeBase = 1; |
||||
m_timeOffset = 0; |
||||
m_amplification1 = 0; |
||||
m_amp1OffsetCoarse = 0; |
||||
m_amp1OffsetFine = 0; |
||||
m_amplification2 = 0; |
||||
m_amp2OffsetCoarse = 0; |
||||
m_amp2OffsetFine = 0; |
||||
m_displayGridIntensity = 5; |
||||
m_triggerPre = 0; |
||||
m_traceLenMult = 20; |
||||
|
||||
for (unsigned int i = 0; i < ScopeVis::m_nbTriggers; i++) |
||||
{ |
||||
m_triggerChannel[i] = ScopeVis::TriggerFreeRun; |
||||
m_triggerLevelCoarse[i] = 0; |
||||
m_triggerLevelFine[i] = 0; |
||||
m_triggerPositiveEdge[i] = true; |
||||
m_triggerBothEdges[i] = false; |
||||
m_triggerDelay[i] = 0; |
||||
m_triggerCounts[i] = 0; |
||||
} |
||||
|
||||
applySettings(); |
||||
} |
||||
|
||||
QByteArray GLScopeGUI::serialize() const |
||||
{ |
||||
SimpleSerializer s(1); |
||||
|
||||
s.writeS32(1, m_displayData); |
||||
s.writeS32(2, m_displayOrientation); |
||||
s.writeS32(3, m_timeBase); |
||||
s.writeS32(4, m_timeOffset); |
||||
s.writeS32(5, m_amplification1); |
||||
s.writeS32(6, m_displayGridIntensity); |
||||
s.writeS32(7, m_amp1OffsetCoarse); |
||||
s.writeS32(8, m_displays); |
||||
s.writeS32(12, m_displayTraceIntensity); |
||||
s.writeS32(13, m_triggerPre); |
||||
s.writeS32(14, m_traceLenMult); |
||||
s.writeS32(18, m_amp1OffsetFine); |
||||
s.writeS32(19, m_amplification2); |
||||
s.writeS32(20, m_amp2OffsetCoarse); |
||||
s.writeS32(21, m_amp2OffsetFine); |
||||
|
||||
for (unsigned int i = 0; i < ScopeVis::m_nbTriggers; i++) |
||||
{ |
||||
s.writeS32(50 + 10*i, m_triggerChannel[i]); |
||||
s.writeS32(51 + 10*i, m_triggerLevelCoarse[i]); |
||||
s.writeS32(52 + 10*i, m_triggerLevelFine[i]); |
||||
s.writeBool(53 + 10*i, m_triggerPositiveEdge[i]); |
||||
s.writeBool(54 + 10*i, m_triggerBothEdges[i]); |
||||
s.writeS32(55 + 10*i, m_triggerDelay[i]); |
||||
s.writeS32(56 + 10*i, m_triggerCounts[i]); |
||||
} |
||||
|
||||
return s.final(); |
||||
} |
||||
|
||||
bool GLScopeGUI::deserialize(const QByteArray& data) |
||||
{ |
||||
SimpleDeserializer d(data); |
||||
|
||||
if(!d.isValid()) { |
||||
resetToDefaults(); |
||||
return false; |
||||
} |
||||
|
||||
if(d.getVersion() == 1) { |
||||
d.readS32(1, &m_displayData, GLScope::ModeIQ); |
||||
d.readS32(2, &m_displayOrientation, Qt::Horizontal); |
||||
d.readS32(3, &m_timeBase, 1); |
||||
d.readS32(4, &m_timeOffset, 0); |
||||
d.readS32(5, &m_amplification1, 0); |
||||
d.readS32(6, &m_displayGridIntensity, 5); |
||||
if(m_timeBase < 0) |
||||
m_timeBase = 1; |
||||
d.readS32(7, &m_amp1OffsetCoarse, 0); |
||||
d.readS32(8, &m_displays, GLScope::DisplayBoth); |
||||
d.readS32(12, &m_displayTraceIntensity, 50); |
||||
d.readS32(13, &m_triggerPre, 0); |
||||
ui->trigPre->setValue(m_triggerPre); |
||||
setTrigPreDisplay(); |
||||
d.readS32(14, &m_traceLenMult, 20); |
||||
ui->traceLen->setValue(m_traceLenMult); |
||||
setTraceLenDisplay(); |
||||
setTrigDelayDisplay(); |
||||
d.readS32(18, &m_amp1OffsetFine, 0); |
||||
d.readS32(19, &m_amplification2, 0); |
||||
d.readS32(20, &m_amp2OffsetCoarse, 0); |
||||
d.readS32(21, &m_amp2OffsetFine, 0); |
||||
|
||||
for (unsigned int i = 0; i < ScopeVis::m_nbTriggers; i++) |
||||
{ |
||||
d.readS32(50 + 10*i, &m_triggerChannel[i], ScopeVis::TriggerFreeRun); |
||||
d.readS32(51 + 10*i, &m_triggerLevelCoarse[i], 0); |
||||
d.readS32(52 + 10*i, &m_triggerLevelFine[i], 0); |
||||
d.readBool(53 + 10*i, &m_triggerPositiveEdge[i], true); |
||||
d.readBool(54 + 10*i, &m_triggerBothEdges[i], false); |
||||
d.readS32(55 + 10*i, &m_triggerDelay[i], 0); |
||||
d.readS32(56 + 10*i, &m_triggerCounts[i], 0); |
||||
m_triggerIndex = i; |
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
m_triggerIndex = 0; |
||||
|
||||
setTrigUI(m_triggerIndex); |
||||
setTrigLevelDisplay(); |
||||
applySettings(); |
||||
return true; |
||||
} else { |
||||
resetToDefaults(); |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::applyAllTriggerSettings() |
||||
{ |
||||
quint32 currentTriggerIndex = m_triggerIndex; |
||||
|
||||
for (unsigned int i = 0; i < ScopeVis::m_nbTriggers; i++) |
||||
{ |
||||
m_triggerIndex = i; |
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
m_triggerIndex = currentTriggerIndex; |
||||
} |
||||
|
||||
void GLScopeGUI::setTrigUI(uint index) |
||||
{ |
||||
index %= ScopeVis::m_nbTriggers; |
||||
|
||||
ui->trigMode->setCurrentIndex(m_triggerChannel[index]); |
||||
ui->trigLevelCoarse->setValue(m_triggerLevelCoarse[index]); |
||||
ui->trigLevelFine->setValue(m_triggerLevelFine[index]); |
||||
ui->trigDelay->setValue(m_triggerDelay[index]); |
||||
ui->trigCount->setValue(m_triggerCounts[index]); |
||||
|
||||
if (m_triggerBothEdges[index]) { |
||||
ui->slopePos->setChecked(false); |
||||
ui->slopeNeg->setChecked(false); |
||||
ui->slopeBoth->setChecked(true); |
||||
} else { |
||||
ui->slopeBoth->setChecked(false); |
||||
ui->slopePos->setChecked(m_triggerPositiveEdge[index]); |
||||
ui->slopeNeg->setChecked(!m_triggerPositiveEdge[index]); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::applySettings() |
||||
{ |
||||
ui->dataMode->setCurrentIndex(m_displayData); |
||||
if (m_displays == GLScope::DisplayBoth) |
||||
{ |
||||
if(m_displayOrientation == Qt::Horizontal) { |
||||
m_glScope->setOrientation(Qt::Horizontal); |
||||
ui->horizView->setChecked(true); |
||||
ui->vertView->setChecked(false); |
||||
ui->onlyPrimeView->setChecked(false); |
||||
ui->onlySecondView->setChecked(false); |
||||
} else { |
||||
m_glScope->setOrientation(Qt::Vertical); |
||||
ui->horizView->setChecked(false); |
||||
ui->vertView->setChecked(true); |
||||
ui->onlyPrimeView->setChecked(false); |
||||
ui->onlySecondView->setChecked(false); |
||||
} |
||||
} |
||||
else if (m_displays == GLScope::DisplayFirstOnly) |
||||
{ |
||||
m_glScope->setDisplays(GLScope::DisplayFirstOnly); |
||||
ui->onlyPrimeView->setChecked(true); |
||||
ui->horizView->setChecked(false); |
||||
ui->vertView->setChecked(false); |
||||
ui->onlySecondView->setChecked(false); |
||||
} |
||||
else if (m_displays == GLScope::DisplaySecondOnly) |
||||
{ |
||||
m_glScope->setDisplays(GLScope::DisplaySecondOnly); |
||||
ui->onlySecondView->setChecked(true); |
||||
ui->onlyPrimeView->setChecked(false); |
||||
ui->horizView->setChecked(false); |
||||
ui->vertView->setChecked(false); |
||||
} |
||||
ui->time->setValue(m_timeBase); |
||||
ui->timeOfs->setValue(m_timeOffset); |
||||
ui->amp1->setValue(m_amplification1); |
||||
ui->amp1OfsCoarse->setValue(m_amp1OffsetCoarse); |
||||
ui->amp1OfsFine->setValue(m_amp1OffsetFine); |
||||
ui->amp2->setValue(m_amplification2); |
||||
ui->amp2OfsCoarse->setValue(m_amp2OffsetCoarse); |
||||
ui->amp2OfsFine->setValue(m_amp2OffsetFine); |
||||
ui->gridIntensity->setSliderPosition(m_displayGridIntensity); |
||||
ui->traceIntensity->setSliderPosition(m_displayTraceIntensity); |
||||
} |
||||
|
||||
void GLScopeGUI::applyTriggerSettings() |
||||
{ |
||||
qreal t = (m_triggerLevelCoarse[m_triggerIndex] / 100.0) + (m_triggerLevelFine[m_triggerIndex] / 20000.0); // [-1.0, 1.0]
|
||||
qreal triggerLevel; |
||||
quint32 preTriggerSamples = (m_glScope->getTraceSize() * m_triggerPre) / 100; |
||||
|
||||
if (m_triggerChannel[m_triggerIndex] == ScopeVis::TriggerMagDb) { |
||||
triggerLevel = 100.0 * (t - 1.0); // [-200.0, 0.0]
|
||||
} |
||||
else if (m_triggerChannel[m_triggerIndex] == ScopeVis::TriggerMagLin) { |
||||
triggerLevel = 1.0 + t; // [0.0, 2.0]
|
||||
} |
||||
else { |
||||
triggerLevel = t; // [-1.0, 1.0]
|
||||
} |
||||
|
||||
m_glScope->setTriggerChannel((ScopeVis::TriggerChannel) m_triggerChannel[m_triggerIndex]); |
||||
m_glScope->setTriggerLevel(t); // [-1.0, 1.0]
|
||||
m_glScope->setTriggerPre(m_triggerPre/100.0); // [0.0, 1.0]
|
||||
|
||||
m_scopeVis->configure(m_messageQueue, |
||||
m_triggerIndex, |
||||
(ScopeVis::TriggerChannel) m_triggerChannel[m_triggerIndex], |
||||
triggerLevel, |
||||
m_triggerPositiveEdge[m_triggerIndex], |
||||
m_triggerBothEdges[m_triggerIndex], |
||||
preTriggerSamples, |
||||
m_triggerDelay[m_triggerIndex], |
||||
m_triggerCounts[m_triggerIndex], |
||||
m_traceLenMult * ScopeVis::m_traceChunkSize); |
||||
} |
||||
|
||||
void GLScopeGUI::setTrigLevelDisplay() |
||||
{ |
||||
qreal t = (m_triggerLevelCoarse[m_triggerIndex] / 100.0) + (m_triggerLevelFine[m_triggerIndex] / 20000.0); |
||||
|
||||
ui->trigLevelCoarse->setToolTip(QString("Trigger level coarse: %1 %").arg(m_triggerLevelCoarse[m_triggerIndex])); |
||||
ui->trigLevelFine->setToolTip(QString("Trigger level fine: %1 ppm").arg(m_triggerLevelFine[m_triggerIndex] * 50)); |
||||
|
||||
if (m_triggerChannel[m_triggerIndex] == ScopeVis::TriggerMagDb) { |
||||
ui->trigText->setText(tr("%1\ndB").arg(100.0 * (t - 1.0), 0, 'f', 1)); |
||||
} |
||||
else |
||||
{ |
||||
qreal a; |
||||
|
||||
if (m_triggerChannel[m_triggerIndex] == ScopeVis::TriggerMagLin) { |
||||
a = 1.0 + t; |
||||
} else { |
||||
a = t; |
||||
} |
||||
|
||||
if(fabs(a) < 0.000001) |
||||
ui->trigText->setText(tr("%1\nn").arg(a * 1000000000.0)); |
||||
else if(fabs(a) < 0.001) |
||||
ui->trigText->setText(tr("%1\nµ").arg(a * 1000000.0)); |
||||
else if(fabs(a) < 1.0) |
||||
ui->trigText->setText(tr("%1\nm").arg(a * 1000.0)); |
||||
else |
||||
ui->trigText->setText(tr("%1").arg(a * 1.0)); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::setAmp1ScaleDisplay() |
||||
{ |
||||
if ((m_glScope->getDataMode() == GLScope::ModeMagdBPha) || (m_glScope->getDataMode() == GLScope::ModeMagdBDPha)) |
||||
{ |
||||
ui->amp1Text->setText(tr("%1\ndB").arg(amps[m_amplification1]*500.0, 0, 'f', 1)); |
||||
} |
||||
else |
||||
{ |
||||
qreal a = amps[m_amplification1]*10.0; |
||||
|
||||
if(a < 0.000001) |
||||
ui->amp1Text->setText(tr("%1\nn").arg(a * 1000000000.0)); |
||||
else if(a < 0.001) |
||||
ui->amp1Text->setText(tr("%1\nµ").arg(a * 1000000.0)); |
||||
else if(a < 1.0) |
||||
ui->amp1Text->setText(tr("%1\nm").arg(a * 1000.0)); |
||||
else |
||||
ui->amp1Text->setText(tr("%1").arg(a * 1.0)); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::setAmp2ScaleDisplay() |
||||
{ |
||||
if ((m_glScope->getDataMode() == GLScope::ModeMagdBPha) |
||||
|| (m_glScope->getDataMode() == GLScope::ModeMagdBDPha) |
||||
|| (m_glScope->getDataMode() == GLScope::ModeMagLinPha) |
||||
|| (m_glScope->getDataMode() == GLScope::ModeMagLinDPha)) |
||||
{ |
||||
ui->amp2Text->setText(tr("%1").arg(amps[m_amplification2]*5.0, 0, 'f', 3)); |
||||
} |
||||
else |
||||
{ |
||||
qreal a = amps[m_amplification2]*10.0; |
||||
|
||||
if(a < 0.000001) |
||||
ui->amp2Text->setText(tr("%1\nn").arg(a * 1000000000.0)); |
||||
else if(a < 0.001) |
||||
ui->amp2Text->setText(tr("%1\nµ").arg(a * 1000000.0)); |
||||
else if(a < 1.0) |
||||
ui->amp2Text->setText(tr("%1\nm").arg(a * 1000.0)); |
||||
else |
||||
ui->amp2Text->setText(tr("%1").arg(a * 1.0)); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::setAmp1OfsDisplay() |
||||
{ |
||||
qreal o = (m_amp1OffsetCoarse * 10.0) + (m_amp1OffsetFine / 20.0); |
||||
|
||||
if ((m_glScope->getDataMode() == GLScope::ModeMagdBPha) || (m_glScope->getDataMode() == GLScope::ModeMagdBDPha)) |
||||
{ |
||||
ui->amp1OfsText->setText(tr("%1\ndB").arg(o/10.0 - 100.0, 0, 'f', 1)); |
||||
} |
||||
else |
||||
{ |
||||
qreal a; |
||||
|
||||
if ((m_glScope->getDataMode() == GLScope::ModeMagLinPha) || (m_glScope->getDataMode() == GLScope::ModeMagLinDPha)) |
||||
{ |
||||
a = o/2000.0; |
||||
} |
||||
else |
||||
{ |
||||
a = o/1000.0; |
||||
} |
||||
|
||||
if(fabs(a) < 0.000001) |
||||
ui->amp1OfsText->setText(tr("%1\nn").arg(a * 1000000000.0)); |
||||
else if(fabs(a) < 0.001) |
||||
ui->amp1OfsText->setText(tr("%1\nµ").arg(a * 1000000.0)); |
||||
else if(fabs(a) < 1.0) |
||||
ui->amp1OfsText->setText(tr("%1\nm").arg(a * 1000.0)); |
||||
else |
||||
ui->amp1OfsText->setText(tr("%1").arg(a * 1.0)); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::setAmp2OfsDisplay() |
||||
{ |
||||
qreal o = (m_amp2OffsetCoarse * 10.0) + (m_amp2OffsetFine / 20.0); |
||||
|
||||
if ((m_glScope->getDataMode() == GLScope::ModeMagdBPha) |
||||
|| (m_glScope->getDataMode() == GLScope::ModeMagdBDPha) |
||||
|| (m_glScope->getDataMode() == GLScope::ModeMagLinPha) |
||||
|| (m_glScope->getDataMode() == GLScope::ModeMagLinDPha)) |
||||
{ |
||||
ui->amp2OfsText->setText(tr("%1").arg(o/1000.0, 0, 'f', 4)); |
||||
} |
||||
else |
||||
{ |
||||
qreal a = o/1000.0; |
||||
|
||||
if(fabs(a) < 0.000001) |
||||
ui->amp2OfsText->setText(tr("%1\nn").arg(a * 1000000000.0)); |
||||
else if(fabs(a) < 0.001) |
||||
ui->amp2OfsText->setText(tr("%1\nµ").arg(a * 1000000.0)); |
||||
else if(fabs(a) < 1.0) |
||||
ui->amp2OfsText->setText(tr("%1\nm").arg(a * 1000.0)); |
||||
else |
||||
ui->amp2OfsText->setText(tr("%1").arg(a * 1.0)); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::on_amp1_valueChanged(int value) |
||||
{ |
||||
m_amplification1 = value; |
||||
setAmp1ScaleDisplay(); |
||||
m_glScope->setAmp1(0.2 / amps[m_amplification1]); |
||||
} |
||||
|
||||
void GLScopeGUI::on_amp1OfsCoarse_valueChanged(int value) |
||||
{ |
||||
m_amp1OffsetCoarse = value; |
||||
setAmp1OfsDisplay(); |
||||
qreal o = (m_amp1OffsetCoarse * 10.0) + (m_amp1OffsetFine / 20.0); |
||||
m_glScope->setAmp1Ofs(o/1000.0); // scale to [-1.0,1.0]
|
||||
} |
||||
|
||||
void GLScopeGUI::on_amp1OfsFine_valueChanged(int value) |
||||
{ |
||||
m_amp1OffsetFine = value; |
||||
setAmp1OfsDisplay(); |
||||
qreal o = (m_amp1OffsetCoarse * 10.0) + (m_amp1OffsetFine / 20.0); |
||||
m_glScope->setAmp1Ofs(o/1000.0); // scale to [-1.0,1.0]
|
||||
} |
||||
|
||||
void GLScopeGUI::on_amp2_valueChanged(int value) |
||||
{ |
||||
m_amplification2 = value; |
||||
setAmp2ScaleDisplay(); |
||||
m_glScope->setAmp2(0.2 / amps[m_amplification2]); |
||||
} |
||||
|
||||
void GLScopeGUI::on_amp2OfsCoarse_valueChanged(int value) |
||||
{ |
||||
m_amp2OffsetCoarse = value; |
||||
setAmp2OfsDisplay(); |
||||
qreal o = (m_amp2OffsetCoarse * 10.0) + (m_amp2OffsetFine / 20.0); |
||||
m_glScope->setAmp2Ofs(o/1000.0); // scale to [-1.0,1.0]
|
||||
} |
||||
|
||||
void GLScopeGUI::on_amp2OfsFine_valueChanged(int value) |
||||
{ |
||||
m_amp2OffsetFine = value; |
||||
setAmp2OfsDisplay(); |
||||
qreal o = (m_amp2OffsetCoarse * 10.0) + (m_amp2OffsetFine / 20.0); |
||||
m_glScope->setAmp2Ofs(o/1000.0); // scale to [-1.0,1.0]
|
||||
} |
||||
|
||||
void GLScopeGUI::on_scope_traceSizeChanged(int) |
||||
{ |
||||
setTimeScaleDisplay(); |
||||
setTraceLenDisplay(); |
||||
setTimeOfsDisplay(); |
||||
setTrigPreDisplay(); |
||||
setTrigDelayDisplay(); |
||||
applySettings(); |
||||
|
||||
if (m_triggerPre > 0) { |
||||
applyAllTriggerSettings(); // change of trace size changes number of pre-trigger samples
|
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::on_scope_sampleRateChanged(int) |
||||
{ |
||||
m_sampleRate = m_glScope->getSampleRate(); |
||||
ui->sampleRateText->setText(tr("%1\nkS/s").arg(m_sampleRate / 1000.0f, 0, 'f', 2)); |
||||
setTimeScaleDisplay(); |
||||
setTraceLenDisplay(); |
||||
setTimeOfsDisplay(); |
||||
setTrigPreDisplay(); |
||||
setTrigDelayDisplay(); |
||||
applySettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::setTimeScaleDisplay() |
||||
{ |
||||
m_sampleRate = m_glScope->getSampleRate(); |
||||
double t = (m_glScope->getTraceSize() * 1.0 / m_sampleRate) / (qreal)m_timeBase; |
||||
|
||||
if(t < 0.000001) |
||||
{ |
||||
t = round(t * 100000000000.0) / 100.0; |
||||
ui->timeText->setText(tr("%1\nns").arg(t)); |
||||
} |
||||
else if(t < 0.001) |
||||
{ |
||||
t = round(t * 100000000.0) / 100.0; |
||||
ui->timeText->setText(tr("%1\nµs").arg(t)); |
||||
} |
||||
else if(t < 1.0) |
||||
{ |
||||
t = round(t * 100000.0) / 100.0; |
||||
ui->timeText->setText(tr("%1\nms").arg(t)); |
||||
} |
||||
else |
||||
{ |
||||
t = round(t * 100.0) / 100.0; |
||||
ui->timeText->setText(tr("%1\ns").arg(t)); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::setTraceLenDisplay() |
||||
{ |
||||
uint n_samples = m_traceLenMult * ScopeVis::m_traceChunkSize; |
||||
|
||||
if (n_samples < 1000) { |
||||
ui->traceLenText->setToolTip(tr("%1S").arg(n_samples)); |
||||
} else if (n_samples < 1000000) { |
||||
ui->traceLenText->setToolTip(tr("%1kS").arg(n_samples/1000.0)); |
||||
} else { |
||||
ui->traceLenText->setToolTip(tr("%1MS").arg(n_samples/1000000.0)); |
||||
} |
||||
|
||||
m_sampleRate = m_glScope->getSampleRate(); |
||||
qreal t = (m_glScope->getTraceSize() * 1.0 / m_sampleRate); |
||||
|
||||
if(t < 0.000001) |
||||
ui->traceLenText->setText(tr("%1\nns").arg(t * 1000000000.0)); |
||||
else if(t < 0.001) |
||||
ui->traceLenText->setText(tr("%1\nµs").arg(t * 1000000.0)); |
||||
else if(t < 1.0) |
||||
ui->traceLenText->setText(tr("%1\nms").arg(t * 1000.0)); |
||||
else |
||||
ui->traceLenText->setText(tr("%1\ns").arg(t * 1.0)); |
||||
} |
||||
|
||||
void GLScopeGUI::setTrigDelayDisplay() |
||||
{ |
||||
uint n_samples_delay = m_traceLenMult * ScopeVis::m_traceChunkSize * m_triggerDelay[m_triggerIndex]; |
||||
|
||||
if (n_samples_delay < 1000) { |
||||
ui->trigDelayText->setToolTip(tr("%1S").arg(n_samples_delay)); |
||||
} else if (n_samples_delay < 1000000) { |
||||
ui->trigDelayText->setToolTip(tr("%1kS").arg(n_samples_delay/1000.0)); |
||||
} else if (n_samples_delay < 1000000000) { |
||||
ui->trigDelayText->setToolTip(tr("%1MS").arg(n_samples_delay/1000000.0)); |
||||
} else { |
||||
ui->trigDelayText->setToolTip(tr("%1GS").arg(n_samples_delay/1000000000.0)); |
||||
} |
||||
|
||||
m_sampleRate = m_glScope->getSampleRate(); |
||||
qreal t = (n_samples_delay * 1.0 / m_sampleRate); |
||||
|
||||
if(t < 0.000001) |
||||
ui->trigDelayText->setText(tr("%1\nns").arg(t * 1000000000.0)); |
||||
else if(t < 0.001) |
||||
ui->trigDelayText->setText(tr("%1\nµs").arg(t * 1000000.0)); |
||||
else if(t < 1.0) |
||||
ui->trigDelayText->setText(tr("%1\nms").arg(t * 1000.0)); |
||||
else |
||||
ui->trigDelayText->setText(tr("%1\ns").arg(t * 1.0)); |
||||
} |
||||
|
||||
void GLScopeGUI::setTimeOfsDisplay() |
||||
{ |
||||
qreal dt = m_glScope->getTraceSize() * (m_timeOffset/100.0) / m_sampleRate; |
||||
|
||||
if(dt < 0.000001) |
||||
ui->timeOfsText->setText(tr("%1\nns").arg(dt * 1000000000.0)); |
||||
else if(dt < 0.001) |
||||
ui->timeOfsText->setText(tr("%1\nµs").arg(dt * 1000000.0)); |
||||
else if(dt < 1.0) |
||||
ui->timeOfsText->setText(tr("%1\nms").arg(dt * 1000.0)); |
||||
else |
||||
ui->timeOfsText->setText(tr("%1\ns").arg(dt * 1.0)); |
||||
|
||||
//ui->timeOfsText->setText(tr("%1").arg(value/100.0, 0, 'f', 2));
|
||||
} |
||||
|
||||
void GLScopeGUI::setTrigPreDisplay() |
||||
{ |
||||
qreal dt = m_glScope->getTraceSize() * (m_triggerPre/100.0) / m_sampleRate; |
||||
|
||||
if(dt < 0.000001) |
||||
ui->trigPreText->setText(tr("%1\nns").arg(dt * 1000000000.0)); |
||||
else if(dt < 0.001) |
||||
ui->trigPreText->setText(tr("%1\nµs").arg(dt * 1000000.0)); |
||||
else if(dt < 1.0) |
||||
ui->trigPreText->setText(tr("%1\nms").arg(dt * 1000.0)); |
||||
else |
||||
ui->trigPreText->setText(tr("%1\ns").arg(dt * 1.0)); |
||||
} |
||||
|
||||
void GLScopeGUI::on_time_valueChanged(int value) |
||||
{ |
||||
m_timeBase = value; |
||||
setTimeScaleDisplay(); |
||||
m_glScope->setTimeBase(m_timeBase); |
||||
} |
||||
|
||||
void GLScopeGUI::on_traceLen_valueChanged(int value) |
||||
{ |
||||
if ((value < 1) || (value > 100)) { |
||||
return; |
||||
} |
||||
m_traceLenMult = value; |
||||
setTraceLenDisplay(); |
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_timeOfs_valueChanged(int value) |
||||
{ |
||||
if ((value < 0) || (value > 100)) { |
||||
return; |
||||
} |
||||
m_timeOffset = value; |
||||
setTimeOfsDisplay(); |
||||
m_glScope->setTimeOfsProMill(value*10); |
||||
} |
||||
|
||||
void GLScopeGUI::on_trigPre_valueChanged(int value) |
||||
{ |
||||
if ((value < 0) || (value > 100)) { |
||||
return; |
||||
} |
||||
m_triggerPre = value; |
||||
setTrigPreDisplay(); |
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_trigDelay_valueChanged(int value) |
||||
{ |
||||
if ((value < 0) || (value > 100)) { |
||||
return; |
||||
} |
||||
m_triggerDelay[m_triggerIndex] = value; |
||||
setTrigDelayDisplay(); |
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_dataMode_currentIndexChanged(int index) |
||||
{ |
||||
m_displayData = index; |
||||
|
||||
switch(index) { |
||||
case 0: // i+q
|
||||
m_glScope->setMode(GLScope::ModeIQ); |
||||
break; |
||||
case 1: // clostationary
|
||||
m_glScope->setMode(GLScope::ModeIQPolar); |
||||
break; |
||||
case 2: // mag(lin)+pha
|
||||
m_glScope->setMode(GLScope::ModeMagLinPha); |
||||
break; |
||||
case 3: // mag(dB)+pha
|
||||
m_glScope->setMode(GLScope::ModeMagdBPha); |
||||
break; |
||||
case 4: // mag(lin)+dPha
|
||||
m_glScope->setMode(GLScope::ModeMagLinDPha); |
||||
break; |
||||
case 5: // mag(dB)+dPha
|
||||
m_glScope->setMode(GLScope::ModeMagdBDPha); |
||||
break; |
||||
case 6: // derived1+derived2
|
||||
m_glScope->setMode(GLScope::ModeDerived12); |
||||
break; |
||||
case 7: // clostationary
|
||||
m_glScope->setMode(GLScope::ModeCyclostationary); |
||||
break; |
||||
|
||||
default: |
||||
break; |
||||
} |
||||
|
||||
setAmp1ScaleDisplay(); |
||||
setAmp1OfsDisplay(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_horizView_clicked() |
||||
{ |
||||
m_displayOrientation = Qt::Horizontal; |
||||
m_displays = GLScope::DisplayBoth; |
||||
if(ui->horizView->isChecked()) { |
||||
ui->vertView->setChecked(false); |
||||
ui->onlyPrimeView->setChecked(false); |
||||
ui->onlySecondView->setChecked(false); |
||||
m_glScope->setOrientation(Qt::Horizontal); |
||||
m_glScope->setDisplays(GLScope::DisplayBoth); |
||||
} else { |
||||
ui->horizView->setChecked(true); |
||||
m_glScope->setOrientation(Qt::Horizontal); |
||||
m_glScope->setDisplays(GLScope::DisplayBoth); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::on_vertView_clicked() |
||||
{ |
||||
m_displayOrientation = Qt::Vertical; |
||||
m_displays = GLScope::DisplayBoth; |
||||
if(ui->vertView->isChecked()) { |
||||
ui->horizView->setChecked(false); |
||||
ui->onlyPrimeView->setChecked(false); |
||||
ui->onlySecondView->setChecked(false); |
||||
m_glScope->setOrientation(Qt::Vertical); |
||||
m_glScope->setDisplays(GLScope::DisplayBoth); |
||||
} else { |
||||
ui->vertView->setChecked(true); |
||||
m_glScope->setOrientation(Qt::Vertical); |
||||
m_glScope->setDisplays(GLScope::DisplayBoth); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::on_onlyPrimeView_clicked() |
||||
{ |
||||
m_displays = GLScope::DisplayFirstOnly; |
||||
if(ui->onlyPrimeView->isChecked()) { |
||||
ui->horizView->setChecked(false); |
||||
ui->vertView->setChecked(false); |
||||
ui->onlySecondView->setChecked(false); |
||||
m_glScope->setDisplays(GLScope::DisplayFirstOnly); |
||||
} else { |
||||
ui->onlyPrimeView->setChecked(true); |
||||
m_glScope->setDisplays(GLScope::DisplayFirstOnly); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::on_onlySecondView_clicked() |
||||
{ |
||||
m_displays = GLScope::DisplaySecondOnly; |
||||
if(ui->onlySecondView->isChecked()) { |
||||
ui->horizView->setChecked(false); |
||||
ui->vertView->setChecked(false); |
||||
ui->onlyPrimeView->setChecked(false); |
||||
m_glScope->setDisplays(GLScope::DisplaySecondOnly); |
||||
} else { |
||||
ui->onlySecondView->setChecked(true); |
||||
m_glScope->setDisplays(GLScope::DisplaySecondOnly); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::on_gridIntensity_valueChanged(int index) |
||||
{ |
||||
m_displayGridIntensity = index; |
||||
ui->gridIntensity->setToolTip(QString("Grid intensity: %1").arg(m_displayGridIntensity)); |
||||
if(m_glScope != 0) |
||||
m_glScope->setDisplayGridIntensity(m_displayGridIntensity); |
||||
} |
||||
|
||||
void GLScopeGUI::on_traceIntensity_valueChanged(int index) |
||||
{ |
||||
m_displayTraceIntensity = index; |
||||
ui->traceIntensity->setToolTip(QString("Trace intensity: %1").arg(m_displayTraceIntensity)); |
||||
if(m_glScope != 0) |
||||
m_glScope->setDisplayTraceIntensity(m_displayTraceIntensity); |
||||
} |
||||
|
||||
void GLScopeGUI::on_trigMode_currentIndexChanged(int index) |
||||
{ |
||||
m_triggerChannel[m_triggerIndex] = index; |
||||
setTrigLevelDisplay(); |
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_trigLevelCoarse_valueChanged(int value) |
||||
{ |
||||
m_triggerLevelCoarse[m_triggerIndex] = value; |
||||
setTrigLevelDisplay(); |
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_trigLevelFine_valueChanged(int value) |
||||
{ |
||||
m_triggerLevelFine[m_triggerIndex] = value; |
||||
setTrigLevelDisplay(); |
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_memIndex_valueChanged(int value) |
||||
{ |
||||
QString text; |
||||
text.sprintf("%02d", value % (1<<GLScope::m_memHistorySizeLog2)); |
||||
ui->memIndexText->setText(text); |
||||
|
||||
if(m_glScope != 0) |
||||
{ |
||||
// If entering memory history block new triggers and all trigger controls
|
||||
m_scopeVis->blockTrigger(value != 0); |
||||
ui->traceLen->setDisabled(value != 0); |
||||
ui->trigIndex->setDisabled(value != 0); |
||||
ui->trigCount->setDisabled(value != 0); |
||||
ui->trigMode->setDisabled(value != 0); |
||||
ui->slopePos->setDisabled(value != 0); |
||||
ui->slopeNeg->setDisabled(value != 0); |
||||
ui->slopeBoth->setDisabled(value != 0); |
||||
ui->oneShot->setDisabled(value != 0); |
||||
ui->trigLevelCoarse->setDisabled(value != 0); |
||||
ui->trigLevelFine->setDisabled(value != 0); |
||||
ui->trigDelay->setDisabled(value != 0); |
||||
ui->trigPre->setDisabled(value != 0); |
||||
// Set value
|
||||
m_glScope->setMemHistoryShift(value); |
||||
ui->sampleRateText->setText(tr("%1\nkS/s").arg(m_glScope->getSampleRate() / 1000.0f, 0, 'f', 2)); |
||||
} |
||||
} |
||||
|
||||
void GLScopeGUI::on_trigCount_valueChanged(int value) |
||||
{ |
||||
m_triggerCounts[m_triggerIndex] = value; |
||||
|
||||
QString text; |
||||
text.sprintf("%02d", value); |
||||
ui->trigCountText->setText(text); |
||||
|
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_trigIndex_valueChanged(int value) |
||||
{ |
||||
m_triggerIndex = value; |
||||
QString text; |
||||
text.sprintf("%d", value); |
||||
ui->trigIndexText->setText(text); |
||||
setTrigLevelDisplay(); |
||||
setTrigUI(m_triggerIndex); |
||||
} |
||||
|
||||
void GLScopeGUI::on_slopePos_clicked() |
||||
{ |
||||
m_triggerPositiveEdge[m_triggerIndex] = true; |
||||
m_triggerBothEdges[m_triggerIndex] = false; |
||||
|
||||
ui->slopeBoth->setChecked(false); |
||||
|
||||
if(ui->slopePos->isChecked()) { |
||||
ui->slopeNeg->setChecked(false); |
||||
} else { |
||||
ui->slopePos->setChecked(true); |
||||
} |
||||
|
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_slopeNeg_clicked() |
||||
{ |
||||
m_triggerPositiveEdge[m_triggerIndex] = false; |
||||
m_triggerBothEdges[m_triggerIndex] = false; |
||||
|
||||
ui->slopeBoth->setChecked(false); |
||||
|
||||
if(ui->slopeNeg->isChecked()) { |
||||
ui->slopePos->setChecked(false); |
||||
} else { |
||||
ui->slopeNeg->setChecked(true); |
||||
} |
||||
|
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_slopeBoth_clicked() |
||||
{ |
||||
qDebug() << "GLScopeGUI::on_slopeBoth_clicked"; |
||||
ui->slopePos->setChecked(false); |
||||
ui->slopeNeg->setChecked(false); |
||||
ui->slopeBoth->setChecked(true); |
||||
m_triggerBothEdges[m_triggerIndex] = true; |
||||
|
||||
applyTriggerSettings(); |
||||
} |
||||
|
||||
void GLScopeGUI::on_oneShot_clicked() |
||||
{ |
||||
m_scopeVis->setOneShot(ui->oneShot->isChecked()); |
||||
} |
||||
|
||||
bool GLScopeGUI::handleMessage(Message* cmd __attribute__((unused))) |
||||
{ |
||||
return false; |
||||
/*
|
||||
if(DSPSignalNotification::match(cmd)) |
||||
{ |
||||
DSPSignalNotification* signal = (DSPSignalNotification*)cmd; |
||||
//fprintf(stderr, "GLScopeGUI::handleMessage: %d samples/sec, %lld Hz offset", signal->getSampleRate(), signal->getFrequencyOffset());
|
||||
m_sampleRate = signal->getSampleRate(); |
||||
cmd->completed(); |
||||
return true; |
||||
} |
||||
else |
||||
{ |
||||
return false; |
||||
} |
||||
*/ |
||||
} |
||||
@ -1,119 +0,0 @@
@@ -1,119 +0,0 @@
|
||||
#ifndef INCLUDE_GLSCOPEGUI_H |
||||
#define INCLUDE_GLSCOPEGUI_H |
||||
|
||||
#include <QWidget> |
||||
#include "dsp/dsptypes.h" |
||||
#include "export.h" |
||||
#include "util/message.h" |
||||
#include "dsp/scopevis.h" |
||||
#include "settings/serializable.h" |
||||
|
||||
namespace Ui { |
||||
class GLScopeGUI; |
||||
} |
||||
|
||||
class MessageQueue; |
||||
class GLScope; |
||||
|
||||
class SDRGUI_API GLScopeGUI : public QWidget, public Serializable { |
||||
Q_OBJECT |
||||
|
||||
public: |
||||
explicit GLScopeGUI(QWidget* parent = NULL); |
||||
~GLScopeGUI(); |
||||
|
||||
void setBuddies(MessageQueue* messageQueue, ScopeVis* scopeVis, GLScope* glScope); |
||||
|
||||
void setSampleRate(int sampleRate); |
||||
void resetToDefaults(); |
||||
virtual QByteArray serialize() const; |
||||
virtual bool deserialize(const QByteArray& data); |
||||
|
||||
bool handleMessage(Message* message); |
||||
|
||||
private: |
||||
Ui::GLScopeGUI* ui; |
||||
|
||||
MessageQueue* m_messageQueue; |
||||
ScopeVis* m_scopeVis; |
||||
GLScope* m_glScope; |
||||
|
||||
int m_sampleRate; |
||||
|
||||
qint32 m_displayData; |
||||
qint32 m_displayOrientation; |
||||
qint32 m_displays; |
||||
qint32 m_timeBase; |
||||
qint32 m_timeOffset; |
||||
qint32 m_amplification1; |
||||
qint32 m_amp1OffsetCoarse; |
||||
qint32 m_amp1OffsetFine; |
||||
qint32 m_amplification2; |
||||
qint32 m_amp2OffsetCoarse; |
||||
qint32 m_amp2OffsetFine; |
||||
int m_displayGridIntensity; |
||||
int m_displayTraceIntensity; |
||||
quint32 m_triggerIndex; |
||||
qint32 m_triggerChannel[ScopeVis::m_nbTriggers]; |
||||
qint32 m_triggerLevelCoarse[ScopeVis::m_nbTriggers]; // percent of full range
|
||||
qint32 m_triggerLevelFine[ScopeVis::m_nbTriggers]; // percent of coarse
|
||||
bool m_triggerPositiveEdge[ScopeVis::m_nbTriggers]; |
||||
bool m_triggerBothEdges[ScopeVis::m_nbTriggers]; |
||||
qint32 m_triggerPre; |
||||
qint32 m_triggerDelay[ScopeVis::m_nbTriggers]; |
||||
qint32 m_triggerCounts[ScopeVis::m_nbTriggers]; |
||||
qint32 m_traceLenMult; |
||||
|
||||
static const qreal amps[11]; |
||||
|
||||
void applySettings(); |
||||
void applyTriggerSettings(); |
||||
void applyAllTriggerSettings(); |
||||
void setTimeScaleDisplay(); |
||||
void setTraceLenDisplay(); |
||||
void setTimeOfsDisplay(); |
||||
void setAmp1ScaleDisplay(); |
||||
void setAmp1OfsDisplay(); |
||||
void setAmp2ScaleDisplay(); |
||||
void setAmp2OfsDisplay(); |
||||
void setTrigLevelDisplay(); |
||||
void setTrigPreDisplay(); |
||||
void setTrigDelayDisplay(); |
||||
void setTrigUI(uint index); |
||||
|
||||
private slots: |
||||
void on_amp1_valueChanged(int value); |
||||
void on_amp1OfsCoarse_valueChanged(int value); |
||||
void on_amp1OfsFine_valueChanged(int value); |
||||
void on_amp2_valueChanged(int value); |
||||
void on_amp2OfsCoarse_valueChanged(int value); |
||||
void on_amp2OfsFine_valueChanged(int value); |
||||
void on_scope_traceSizeChanged(int value); |
||||
void on_scope_sampleRateChanged(int value); |
||||
void on_time_valueChanged(int value); |
||||
void on_traceLen_valueChanged(int value); |
||||
void on_timeOfs_valueChanged(int value); |
||||
void on_dataMode_currentIndexChanged(int index); |
||||
void on_gridIntensity_valueChanged(int index); |
||||
void on_traceIntensity_valueChanged(int index); |
||||
void on_trigPre_valueChanged(int value); |
||||
void on_trigDelay_valueChanged(int value); |
||||
void on_memIndex_valueChanged(int value); |
||||
void on_trigCount_valueChanged(int value); |
||||
void on_trigIndex_valueChanged(int value); |
||||
|
||||
void on_horizView_clicked(); |
||||
void on_vertView_clicked(); |
||||
void on_onlyPrimeView_clicked(); |
||||
void on_onlySecondView_clicked(); |
||||
|
||||
void on_trigMode_currentIndexChanged(int index); |
||||
void on_slopePos_clicked(); |
||||
void on_slopeNeg_clicked(); |
||||
void on_slopeBoth_clicked(); |
||||
void on_oneShot_clicked(); |
||||
void on_trigLevelCoarse_valueChanged(int value); |
||||
void on_trigLevelFine_valueChanged(int value); |
||||
}; |
||||
|
||||
#endif // INCLUDE_GLSCOPEGUI_H
|
||||
Loading…
Reference in new issue