Merge pull request #911 from fredzo/oscilloscope-download-progress-api

Oscilloscope download progress API

Author: azonenberg

scopehal/DemoOscilloscope.cpp

@@ -491,6 +491,9 @@ bool DemoOscilloscope::AcquireData()
 	if(!m_triggerArmed)
 		return false;
 
+	// prepare all channels to be 'about to download'
+	ChannelsDownloadStarted();
+
 	//cap waveform rate at 50 wfm/s to avoid saturating cpu
 	std::this_thread::sleep_for(std::chrono::microseconds(20 * 1000));
 
@@ -531,38 +534,51 @@ bool DemoOscilloscope::AcquireData()
 		if(!m_channelsEnabled[i])
 			continue;
 
+		// Lambda passed to generate waveform methods to update "download" percentage
+		auto updateProgress = [i,this](float progress)
+			{
+				this->ChannelsDownloadStatusUpdate(i, InstrumentChannel::DownloadState::DOWNLOAD_IN_PROGRESS, progress);
+			};
+		this->ChannelsDownloadStatusUpdate(i, InstrumentChannel::DownloadState::DOWNLOAD_IN_PROGRESS, 0.0);
 		switch(i)
 		{
 			case 0:
 				waveforms[i] = m_source[i]->GenerateNoisySinewave(
-					0.9, 0.0, 1e6, sampleperiod, depth, noise[0]);
+					0.9, 0.0, 1e6, sampleperiod, depth, updateProgress, noise[0]);
 				break;
 
 			case 1:
 				waveforms[i] = m_source[i]->GenerateNoisySinewaveSum(
-					0.9, 0.0, M_PI_4, 1e6, sweepPeriod, sampleperiod, depth, noise[1]);
+					0.9, 0.0, M_PI_4, 1e6, sweepPeriod, sampleperiod, depth, updateProgress, noise[1]);
 				break;
 
 			case 2:
+
 				waveforms[i] = m_source[i]->GeneratePRBS31(
-					*m_cmdBuf[i], m_queue[i], 0.9, 96969.6, sampleperiod, depth, lpf2, noise[2]);
+					*m_cmdBuf[i], m_queue[i], 0.9, 96969.6, sampleperiod, depth, 
+					updateProgress,
+					lpf2, noise[2]);
 				break;
 
 			case 3:
 				waveforms[i] = m_source[i]->Generate8b10b(
-					*m_cmdBuf[i], m_queue[i], 0.9, 800e3, sampleperiod, depth, lpf3, noise[3]);
+					*m_cmdBuf[i], m_queue[i], 0.9, 800e3, sampleperiod, depth, updateProgress, lpf3, noise[3]);
 				break;
 
 			default:
 				break;
 		}
 
 		waveforms[i]->MarkModifiedFromCpu();
+		this->ChannelsDownloadStatusUpdate(i, InstrumentChannel::DownloadState::DOWNLOAD_FINISHED, 1.0);
 	}
 
 	SequenceSet s;
 	for(int i=0; i<4; i++)
+	{
 		s[GetOscilloscopeChannel(i)] = waveforms[i];
+		this->ChannelsDownloadStatusUpdate(i, InstrumentChannel::DownloadState::DOWNLOAD_NONE, 0.0);
+	}
 
 	//Timestamp the waveform(s)
 	double now = GetTime();

scopehal/InstrumentChannel.cpp

@@ -151,3 +151,21 @@ bool InstrumentChannel::ShouldPersistWaveform()
 	//Default to persisting everything
 	return true;
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Download progress
+
+InstrumentChannel::DownloadState InstrumentChannel::GetDownloadState()
+{
+	return DownloadState::DOWNLOAD_UNKNOWN;
+}
+
+float InstrumentChannel::GetDownloadProgress()
+{
+	return 0.0;
+}
+
+double InstrumentChannel::GetDownloadStartTime()
+{
+	return 0.0;
+}

scopehal/InstrumentChannel.h

@@ -239,6 +239,32 @@ class InstrumentChannel : public FlowGraphNode
 		VIS_SHOW,
 	} m_visibilityMode;
 
+	/**
+		@brief Enum values to be mapped to GetDownloadState() int result value for specific channel download states
+	 */
+	enum DownloadState
+	{
+		DOWNLOAD_UNKNOWN,
+		DOWNLOAD_NONE,					///< No download is pending (e.g. the scope is in stop mode)
+		DOWNLOAD_WAITING,				///< This channel is waiting to be downloaded (i.e. scope is triggered but previous channels are currently beeing downloaded)
+		DOWNLOAD_IN_PROGRESS,				///< Download has started
+		DOWNLOAD_FINISHED				///< Download is finished
+	};
+
+	/**
+		@brief Returns the current download state of this channel.
+
+		The returned int value can either be an integer ranging from 0 to 100 corresponding to the percentage of the waveform that has already been downloaded
+		or a (negative) int value to be mapped to the OscilloscopeChannel::DownloadState enum
+	 */
+	virtual DownloadState GetDownloadState();
+
+	/// returns the current completion of the download (on the range [0, 1]), if not DOWNLOAD_UNKNOWN
+	virtual float GetDownloadProgress();
+
+	/// returns the start time of a download, if we are DOWNLOAD_IN_PROGRESS; undefined, otherwise
+	virtual double GetDownloadStartTime();
+
 protected:
 
 	virtual void ClearStreams();

scopehal/LeCroyOscilloscope.cpp

@@ -1054,6 +1054,7 @@ void LeCroyOscilloscope::FlushConfigCache()
 
 	m_channelVoltageRanges.clear();
 	m_channelOffsets.clear();
+	m_channelDigitalThresholds.clear();
 	m_channelsEnabled.clear();
 	m_channelDeskew.clear();
 	m_probeIsActive.clear();
@@ -4054,13 +4055,24 @@ float LeCroyOscilloscope::GetDigitalThreshold(size_t channel)
 	if( (channel < m_digitalChannelBase) || (m_digitalChannelCount == 0) )
 		return 0;
 
+	{
+		lock_guard<recursive_mutex> lock(m_cacheMutex);
+
+		if(m_channelDigitalThresholds.find(channel) != m_channelDigitalThresholds.end())
+			return m_channelDigitalThresholds[channel];
+	}
+
 	string reply;
 	if(channel <= m_digitalChannels[7]->GetIndex() )
 		reply = m_transport->SendCommandQueuedWithReply("VBS? 'return = app.LogicAnalyzer.MSxxThreshold0'");
 	else
 		reply = m_transport->SendCommandQueuedWithReply("VBS? 'return = app.LogicAnalyzer.MSxxThreshold1'");
 
-	return atof(reply.c_str());
+	float result = atof(reply.c_str());
+
+	lock_guard<recursive_mutex> lock(m_cacheMutex);
+	m_channelDigitalThresholds[channel] = result;
+	return result;
 }
 
 void LeCroyOscilloscope::SetDigitalHysteresis(size_t channel, float level)

scopehal/LeCroyOscilloscope.h

@@ -352,6 +352,7 @@ class LeCroyOscilloscope
 	//Cached configuration
 	std::map<size_t, float> m_channelVoltageRanges;
 	std::map<size_t, float> m_channelOffsets;
+	std::map<size_t, float> m_channelDigitalThresholds;
 	std::map<size_t, size_t> m_channelNavg;
 	std::map<int, bool> m_channelsEnabled;
 	bool m_sampleRateValid;

scopehal/Oscilloscope.cpp

@@ -856,6 +856,31 @@ bool Oscilloscope::IsInverted(size_t /*i*/)
 	return false;
 }
 
+void Oscilloscope::ChannelsDownloadStarted()
+{
+	for (size_t i = 0; i < m_channels.size(); i++)
+	{
+		auto chan = GetOscilloscopeChannel(i);
+		if (chan == nullptr)
+			continue;
+
+		chan->m_downloadState = InstrumentChannel::DownloadState::DOWNLOAD_WAITING;
+		chan->m_downloadProgress = 0.0;
+		chan->m_downloadStartTime = GetTime();
+	}
+}
+
+void Oscilloscope::ChannelsDownloadStatusUpdate(size_t ch, InstrumentChannel::DownloadState state, float progress)
+{
+	auto chan = GetOscilloscopeChannel(ch);
+	if (chan == nullptr)
+		return;
+
+	chan->m_downloadState = state;
+	chan->m_downloadProgress = progress;
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Trigger configuration
 

scopehal/Oscilloscope.h

@@ -384,6 +384,15 @@ class Oscilloscope	: public virtual Instrument
 	 */
 	virtual bool IsInverted(size_t i);
 
+protected:
+
+	/// @brief Helper method called by drivers to reset all channels to "waiting to download" state.
+	void ChannelsDownloadStarted();
+
+	/// @brief Helper method called by drivers to set one channel's download status.
+	void ChannelsDownloadStatusUpdate(size_t ch, InstrumentChannel::DownloadState state, float progress);
+
+public:
 	//Triggering
 	enum TriggerMode
 	{

scopehal/OscilloscopeChannel.cpp

@@ -61,6 +61,9 @@ OscilloscopeChannel::OscilloscopeChannel(
 	Stream::StreamType stype,
 	size_t index)
 	: InstrumentChannel(scope, hwname, color, xunit, yunit, stype, index)
+	, m_downloadState(DownloadState::DOWNLOAD_UNKNOWN)
+	, m_downloadProgress(0.0)
+	, m_downloadStartTime(0.0)
 	, m_refcount(0)
 {
 }
@@ -341,3 +344,18 @@ void OscilloscopeChannel::SetInputMux(size_t select)
 	if(m_instrument)
 		GetScope()->SetInputMux(m_index, select);
 }
+
+InstrumentChannel::DownloadState OscilloscopeChannel::GetDownloadState()
+{
+	return m_downloadState;
+}
+
+float OscilloscopeChannel::GetDownloadProgress()
+{
+	return m_downloadProgress;
+}
+
+double OscilloscopeChannel::GetDownloadStartTime()
+{
+	return m_downloadStartTime;
+}

scopehal/OscilloscopeChannel.h

@@ -145,6 +145,17 @@ class OscilloscopeChannel : public InstrumentChannel
 	virtual void SetInputMux(size_t select);
 
 	void SetDefaultDisplayName();
+
+	virtual DownloadState GetDownloadState() override;
+	virtual float GetDownloadProgress() override;
+	virtual double GetDownloadStartTime() override;
+
+private:
+	// to be accessed by Oscilloscope to update download status
+	DownloadState m_downloadState;
+	float m_downloadProgress;
+	double m_downloadStartTime;
+
 protected:
 	void SharedCtorInit(Unit unit);
 

scopehal/RSRTO6Oscilloscope.cpp

@@ -243,6 +243,7 @@ void RSRTO6Oscilloscope::FlushConfigCache()
 	m_channelOffsets.clear();
 	m_channelVoltageRanges.clear();
 	m_channelsEnabled.clear();
+	m_channelDigitalThresholds.clear();
 	m_channelCouplings.clear();
 	m_channelAttenuations.clear();
 
@@ -656,8 +657,21 @@ bool RSRTO6Oscilloscope::IsDigitalThresholdConfigurable()
 
 float RSRTO6Oscilloscope::GetDigitalThreshold(size_t channel)
 {
-	// Cache?
-	return stof(m_transport->SendCommandQueuedWithReply("DIG" + to_string(HWDigitalNumber(channel)) + ":THR?"));
+	if( (channel < m_digitalChannelBase) || (m_digitalChannelCount == 0) )
+		return 0;
+
+	{
+		lock_guard<recursive_mutex> lock(m_cacheMutex);
+
+		if(m_channelDigitalThresholds.find(channel) != m_channelDigitalThresholds.end())
+			return m_channelDigitalThresholds[channel];
+	}
+
+	float result = stof(m_transport->SendCommandQueuedWithReply("DIG" + to_string(HWDigitalNumber(channel)) + ":THR?"));
+
+	lock_guard<recursive_mutex> lock(m_cacheMutex);
+	m_channelDigitalThresholds[channel] = result;
+	return result;
 }
 
 void RSRTO6Oscilloscope::SetDigitalThreshold(size_t channel, float level)