ngscopeclient · Dec 18, 2021 · Dec 18, 2021 · Dec 18, 2021 · Dec 18, 2021
diff --git a/scopehal/AgilentOscilloscope.cpp b/scopehal/AgilentOscilloscope.cpp
@@ -422,7 +422,7 @@ void AgilentOscilloscope::SetChannelBandwidthLimit(size_t /*i*/, unsigned int /*
 	//FIXME
 }
 
-double AgilentOscilloscope::GetChannelVoltageRange(size_t i)
+float AgilentOscilloscope::GetChannelVoltageRange(size_t i, size_t /*stream*/)
 {
 	if(m_channels[i]->GetType() != OscilloscopeChannel::CHANNEL_TYPE_ANALOG)
 		return 1;
@@ -442,13 +442,13 @@ double AgilentOscilloscope::GetChannelVoltageRange(size_t i)
 		reply = m_transport->ReadReply();
 	}
 
-	double range = stod(reply);
+	float range = stof(reply);
 	lock_guard<recursive_mutex> lock(m_cacheMutex);
 	m_channelVoltageRanges[i] = range;
 	return range;
 }
 
-void AgilentOscilloscope::SetChannelVoltageRange(size_t i, double range)
+void AgilentOscilloscope::SetChannelVoltageRange(size_t i, size_t /*stream*/, float range)
 {
 	{
 		lock_guard<recursive_mutex> lock(m_cacheMutex);
@@ -467,7 +467,7 @@ OscilloscopeChannel* AgilentOscilloscope::GetExternalTrigger()
 	return NULL;
 }
 
-double AgilentOscilloscope::GetChannelOffset(size_t i)
+float AgilentOscilloscope::GetChannelOffset(size_t i, size_t /*stream*/)
 {
 	if(!IsAnalogChannel(i))
 		return 0;
@@ -486,15 +486,15 @@ double AgilentOscilloscope::GetChannelOffset(size_t i)
 		reply = m_transport->ReadReply();
 	}
 
-	double offset = stod(reply);
+	float offset = stof(reply);
 	offset = -offset;
 
 	lock_guard<recursive_mutex> lock(m_cacheMutex);
 	m_channelOffsets[i] = offset;
 	return offset;
 }
 
-void AgilentOscilloscope::SetChannelOffset(size_t i, double offset)
+void AgilentOscilloscope::SetChannelOffset(size_t i, size_t /*stream*/, float offset)
 {
 	{
 		lock_guard<recursive_mutex> lock(m_cacheMutex);

diff --git a/scopehal/AgilentOscilloscope.h b/scopehal/AgilentOscilloscope.h
@@ -62,11 +62,11 @@ class AgilentOscilloscope : public SCPIOscilloscope
 	virtual void SetChannelAttenuation(size_t i, double atten);
 	virtual int GetChannelBandwidthLimit(size_t i);
 	virtual void SetChannelBandwidthLimit(size_t i, unsigned int limit_mhz);
-	virtual double GetChannelVoltageRange(size_t i);
-	virtual void SetChannelVoltageRange(size_t i, double range);
+	virtual float GetChannelVoltageRange(size_t i, size_t stream);
+	virtual void SetChannelVoltageRange(size_t i, size_t stream, float range);
 	virtual OscilloscopeChannel* GetExternalTrigger();
-	virtual double GetChannelOffset(size_t i);
-	virtual void SetChannelOffset(size_t i, double offset);
+	virtual float GetChannelOffset(size_t i, size_t stream);
+	virtual void SetChannelOffset(size_t i, size_t stream, float offset);
 
 	//Triggering
 	virtual Oscilloscope::TriggerMode PollTrigger();
@@ -112,8 +112,8 @@ class AgilentOscilloscope : public SCPIOscilloscope
 	};
 
 	//config cache
-	std::map<size_t, double> m_channelOffsets;
-	std::map<size_t, double> m_channelVoltageRanges;
+	std::map<size_t, float> m_channelOffsets;
+	std::map<size_t, float> m_channelVoltageRanges;
 	std::map<size_t, OscilloscopeChannel::CouplingType> m_channelCouplings;
 	std::map<size_t, double> m_channelAttenuations;
 	std::map<size_t, int> m_channelBandwidthLimits;

diff --git a/scopehal/AntikernelLabsOscilloscope.cpp b/scopehal/AntikernelLabsOscilloscope.cpp
@@ -257,7 +257,7 @@ void AntikernelLabsOscilloscope::SetChannelBandwidthLimit(size_t /*i*/, unsigned
 	LogWarning("AntikernelLabsOscilloscope::SetChannelBandwidthLimit unimplemented\n");
 }
 
-double AntikernelLabsOscilloscope::GetChannelVoltageRange(size_t i)
+float AntikernelLabsOscilloscope::GetChannelVoltageRange(size_t i, size_t /*stream*/)
 {
 	{
 		lock_guard<recursive_mutex> lock(m_cacheMutex);
@@ -288,7 +288,7 @@ double AntikernelLabsOscilloscope::GetChannelVoltageRange(size_t i)
 	return vfs;
 }
 
-void AntikernelLabsOscilloscope::SetChannelVoltageRange(size_t i, double range)
+void AntikernelLabsOscilloscope::SetChannelVoltageRange(size_t i, size_t /*stream*/, float range)
 {
 	//Convert requested range to gain
 	float frac_gain = 2.0 / range;
@@ -324,7 +324,7 @@ OscilloscopeChannel* AntikernelLabsOscilloscope::GetExternalTrigger()
 	return NULL;
 }
 
-double AntikernelLabsOscilloscope::GetChannelOffset(size_t i)
+float AntikernelLabsOscilloscope::GetChannelOffset(size_t i, size_t /*stream*/)
 {
 	{
 		lock_guard<recursive_mutex> lock(m_cacheMutex);
@@ -338,14 +338,14 @@ double AntikernelLabsOscilloscope::GetChannelOffset(size_t i)
 	m_transport->SendCommand(m_channels[i]->GetHwname() + ":OFFS?");
 
 	string reply = m_transport->ReadReply();
-	double offset;
-	sscanf(reply.c_str(), "%lf", &offset);
+	float offset;
+	sscanf(reply.c_str(), "%f", &offset);
 	lock_guard<recursive_mutex> lock(m_cacheMutex);
 	m_channelOffsets[i] = offset;
 	return offset;
 }
 
-void AntikernelLabsOscilloscope::SetChannelOffset(size_t i, double offset)
+void AntikernelLabsOscilloscope::SetChannelOffset(size_t i, size_t /*stream*/, float offset)
 {
 	lock_guard<recursive_mutex> lock(m_mutex);
 
@@ -383,9 +383,9 @@ bool AntikernelLabsOscilloscope::AcquireData()
 	cap->m_startFemtoseconds = (t - cap->m_startTimestamp) * FS_PER_SECOND;
 
 	//Process the samples
-	float fullscale = GetChannelVoltageRange(0);
+	float fullscale = GetChannelVoltageRange(0, 0);
 	float scale = fullscale / 256.0f;
-	float offset = GetChannelOffset(0);
+	float offset = GetChannelOffset(0, 0);
 	cap->Resize(depth);
 	for(size_t i=0; i<depth; i++)
 	{

diff --git a/scopehal/AntikernelLabsOscilloscope.h b/scopehal/AntikernelLabsOscilloscope.h
@@ -57,11 +57,11 @@ class AntikernelLabsOscilloscope : public SCPIOscilloscope
 	virtual void SetChannelAttenuation(size_t i, double atten);
 	virtual int GetChannelBandwidthLimit(size_t i);
 	virtual void SetChannelBandwidthLimit(size_t i, unsigned int limit_mhz);
-	virtual double GetChannelVoltageRange(size_t i);
-	virtual void SetChannelVoltageRange(size_t i, double range);
+	virtual float GetChannelVoltageRange(size_t i, size_t stream);
+	virtual void SetChannelVoltageRange(size_t i, size_t stream, float range);
 	virtual OscilloscopeChannel* GetExternalTrigger();
-	virtual double GetChannelOffset(size_t i);
-	virtual void SetChannelOffset(size_t i, double offset);
+	virtual float GetChannelOffset(size_t i, size_t stream);
+	virtual void SetChannelOffset(size_t i, size_t stream, float offset);
 
 	//Triggering
 	virtual Oscilloscope::TriggerMode PollTrigger();
@@ -101,8 +101,8 @@ class AntikernelLabsOscilloscope : public SCPIOscilloscope
 	unsigned int m_analogChannelCount;
 
 	//config cache
-	std::map<size_t, double> m_channelOffsets;
-	std::map<size_t, double> m_channelVoltageRanges;
+	std::map<size_t, float> m_channelOffsets;
+	std::map<size_t, float> m_channelVoltageRanges;
 	/*
 	std::map<int, bool> m_channelsEnabled;
 	bool m_triggerChannelValid;

diff --git a/scopehal/AntikernelLogicAnalyzer.cpp b/scopehal/AntikernelLogicAnalyzer.cpp
@@ -519,12 +519,12 @@ void AntikernelLogicAnalyzer::SetChannelBandwidthLimit(size_t /*i*/, unsigned in
 	//no-op, all channels are digital
 }
 
-double AntikernelLogicAnalyzer::GetChannelVoltageRange(size_t /*i*/)
+float AntikernelLogicAnalyzer::GetChannelVoltageRange(size_t /*i*/, size_t /*stream*/)
 {
 	return 1;
 }
 
-void AntikernelLogicAnalyzer::SetChannelVoltageRange(size_t /*i*/, double /*range*/)
+void AntikernelLogicAnalyzer::SetChannelVoltageRange(size_t /*i*/, size_t /*stream*/, float /*range*/)
 {
 	//no-op, all channels are digital
 }
@@ -534,12 +534,12 @@ OscilloscopeChannel* AntikernelLogicAnalyzer::GetExternalTrigger()
 	return NULL;
 }
 
-double AntikernelLogicAnalyzer::GetChannelOffset(size_t /*i*/)
+float AntikernelLogicAnalyzer::GetChannelOffset(size_t /*i*/, size_t /*stream*/)
 {
 	return 0;
 }
 
-void AntikernelLogicAnalyzer::SetChannelOffset(size_t /*i*/, double /*offset*/)
+void AntikernelLogicAnalyzer::SetChannelOffset(size_t /*i*/, size_t /*stream*/, float /*offset*/)
 {
 	//no-op, all channels are digital
 }

diff --git a/scopehal/AntikernelLogicAnalyzer.h b/scopehal/AntikernelLogicAnalyzer.h
@@ -68,11 +68,11 @@ class AntikernelLogicAnalyzer
 	virtual void SetChannelAttenuation(size_t i, double atten);
 	virtual int GetChannelBandwidthLimit(size_t i);
 	virtual void SetChannelBandwidthLimit(size_t i, unsigned int limit_mhz);
-	virtual double GetChannelVoltageRange(size_t i);
-	virtual void SetChannelVoltageRange(size_t i, double range);
+	virtual float GetChannelVoltageRange(size_t i, size_t stream);
+	virtual void SetChannelVoltageRange(size_t i, size_t stream, float range);
 	virtual OscilloscopeChannel* GetExternalTrigger();
-	virtual double GetChannelOffset(size_t i);
-	virtual void SetChannelOffset(size_t i, double offset);
+	virtual float GetChannelOffset(size_t i, size_t stream);
+	virtual void SetChannelOffset(size_t i, size_t stream, float offset);
 
 	//Triggering
 	virtual Oscilloscope::TriggerMode PollTrigger();

diff --git a/scopehal/CMakeLists.txt b/scopehal/CMakeLists.txt
@@ -93,7 +93,6 @@ set(SCOPEHAL_SOURCES
 	PicoOscilloscope.cpp
 	RigolOscilloscope.cpp
 	SiglentSCPIOscilloscope.cpp
-	SignalGeneratorOscilloscope.cpp
 	TektronixOscilloscope.cpp
 	RohdeSchwarzOscilloscope.cpp
 	RohdeSchwarzHMC8012Multimeter.cpp

diff --git a/scopehal/DemoOscilloscope.cpp b/scopehal/DemoOscilloscope.cpp
@@ -272,12 +272,12 @@ void DemoOscilloscope::SetChannelBandwidthLimit(size_t i, unsigned int limit_mhz
 	m_channelBandwidth[i] = limit_mhz;
 }
 
-double DemoOscilloscope::GetChannelVoltageRange(size_t i)
+float DemoOscilloscope::GetChannelVoltageRange(size_t i, size_t /*stream*/)
 {
 	return m_channelVoltageRange[i];
 }
 
-void DemoOscilloscope::SetChannelVoltageRange(size_t i, double range)
+void DemoOscilloscope::SetChannelVoltageRange(size_t i, size_t /*stream*/, float range)
 {
 	m_channelVoltageRange[i] = range;
 }
@@ -287,12 +287,12 @@ OscilloscopeChannel* DemoOscilloscope::GetExternalTrigger()
 	return m_extTrigger;
 }
 
-double DemoOscilloscope::GetChannelOffset(size_t i)
+float DemoOscilloscope::GetChannelOffset(size_t i, size_t /*stream*/)
 {
 	return m_channelOffset[i];
 }
 
-void DemoOscilloscope::SetChannelOffset(size_t i, double offset)
+void DemoOscilloscope::SetChannelOffset(size_t i, size_t /*stream*/, float offset)
 {
 	m_channelOffset[i] = offset;
 }

diff --git a/scopehal/DemoOscilloscope.h b/scopehal/DemoOscilloscope.h
@@ -65,11 +65,11 @@ class DemoOscilloscope : public SCPIOscilloscope
 	virtual void SetChannelAttenuation(size_t i, double atten);
 	virtual int GetChannelBandwidthLimit(size_t i);
 	virtual void SetChannelBandwidthLimit(size_t i, unsigned int limit_mhz);
-	virtual double GetChannelVoltageRange(size_t i);
-	virtual void SetChannelVoltageRange(size_t i, double range);
+	virtual float GetChannelVoltageRange(size_t i, size_t stream);
+	virtual void SetChannelVoltageRange(size_t i, size_t stream, float range);
 	virtual OscilloscopeChannel* GetExternalTrigger();
-	virtual double GetChannelOffset(size_t i);
-	virtual void SetChannelOffset(size_t i, double offset);
+	virtual float GetChannelOffset(size_t i, size_t stream);
+	virtual void SetChannelOffset(size_t i, size_t stream, float offset);
 
 	//Triggering
 	virtual Oscilloscope::TriggerMode PollTrigger();
@@ -114,8 +114,8 @@ class DemoOscilloscope : public SCPIOscilloscope
 	std::map<size_t, OscilloscopeChannel::CouplingType> m_channelCoupling;
 	std::map<size_t, double> m_channelAttenuation;
 	std::map<size_t, unsigned int> m_channelBandwidth;
-	std::map<size_t, double> m_channelVoltageRange;
-	std::map<size_t, double> m_channelOffset;
+	std::map<size_t, float> m_channelVoltageRange;
+	std::map<size_t, float> m_channelOffset;
 	std::map<size_t, size_t> m_channelModes;
 
 	enum ChannelModes

diff --git a/scopehal/Filter.cpp b/scopehal/Filter.cpp
@@ -803,10 +803,20 @@ string Filter::SerializeConfiguration(IDTable& table, size_t /*indent*/)
 	config += tmp;
 
 	//Save gain and offset (not applicable to all filters, but save it just in case)
-	snprintf(tmp, sizeof(tmp), "        vrange:          %f\n", GetVoltageRange());
-	config += tmp;
-	snprintf(tmp, sizeof(tmp), "        offset:          %f\n", GetOffset());
+	snprintf(tmp, sizeof(tmp), "        streams:\n");
 	config += tmp;
+	for(size_t i=0; i<GetStreamCount(); i++)
+	{
+		snprintf(tmp, sizeof(tmp), "            stream%zu:\n", i);
+		config += tmp;
+
+		snprintf(tmp, sizeof(tmp), "                index:           %zu\n", i);
+		config += tmp;
+		snprintf(tmp, sizeof(tmp), "                vrange:          %f\n", GetVoltageRange(i));
+		config += tmp;
+		snprintf(tmp, sizeof(tmp), "                offset:          %f\n", GetOffset(i));
+		config += tmp;
+	}
 
 	return config;
 }
@@ -819,10 +829,28 @@ void Filter::LoadParameters(const YAML::Node& node, IDTable& table)
 	m_displayname = node["nick"].as<string>();
 	m_hwname = node["name"].as<string>();
 
+	//Load legacy single-stream range/offset parameters
 	if(node["vrange"])
-		SetVoltageRange(node["vrange"].as<double>());
+		SetVoltageRange(node["vrange"].as<float>(), 0);
 	if(node["offset"])
-		SetOffset(node["offset"].as<double>());
+		SetOffset(node["offset"].as<float>(), 0);
+
+	//Load stream configuration
+	auto streams = node["streams"];
+	if(streams)
+	{
+		for(auto it : streams)
+		{
+			auto snode = it.second;
+			if(!snode["index"])
+				continue;
+			auto index = snode["index"].as<int>();
+			if(snode["vrange"])
+				SetVoltageRange(snode["vrange"].as<float>(), index);
+			if(snode["offset"])
+				SetOffset(snode["offset"].as<float>(), index);
+		}
+	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

diff --git a/scopehal/FlowGraphNode.h b/scopehal/FlowGraphNode.h
@@ -61,6 +61,9 @@ class StreamDescriptor
 	OscilloscopeChannel* m_channel;
 	size_t m_stream;
 
+	Unit GetYAxisUnits()
+	{ return m_channel->GetYAxisUnits(m_stream); }
+
 	WaveformBase* GetData()
 	{ return m_channel->GetData(m_stream); }
 
@@ -79,6 +82,18 @@ class StreamDescriptor
 
 		return false;
 	}
+
+	float GetVoltageRange()
+	{ return m_channel->GetVoltageRange(m_stream); }
+
+	float GetOffset()
+	{ return m_channel->GetOffset(m_stream); }
+
+	void SetVoltageRange(float v)
+	{  m_channel->SetVoltageRange(v, m_stream); }
+
+	void SetOffset(float v)
+	{  m_channel->SetOffset(v, m_stream); }
 };
 
 /**