draft of getRawWaveform for SDS800XHD

1 files changed, 123 insertions, 2 deletions

diff --git a/qolab/hardware/scope/sds800xhd.py b/qolab/hardware/scope/sds800xhd.py
index 561f308..436254f 100644
--- a/qolab/hardware/scope/sds800xhd.py
+++ b/qolab/hardware/scope/sds800xhd.py
@@ -24,12 +24,11 @@ class SDS800XHD(SDS1104X):
         super().__init__(resource, *args, **kwds)
         self.config["Device model"] = "SDS800XHD"
         self.resource.read_termination = "\n"
-        self.resource.timeout=1000
+        self.resource.timeout = 1000
         self.numberOfChannels = 4
         self.maxRequiredPoints = 1000
         # desired number of points per channel, can return twice more
 
-
     @BasicInstrument.tsdb_append
     def getTimePerDiv(self):
         qstr = "TDIV?"
@@ -46,6 +45,128 @@ class SDS800XHD(SDS1104X):
         )
         return float(numberString)
 
+    def getRawWaveform(
+        self, chNum, availableNpnts=None, maxRequiredPoints=None, decimate=True
+    ):
+        """
+        Get raw channel waveform in binary format.
+
+        Parameters
+        ----------
+        chNum : int
+            Scope channel to use: 1, 2, 3, or 4
+        availableNpnts : int or None (default)
+            Available number of points. Do not set it if you want it auto detected.
+        maxRequiredPoints : int
+            Maximum number of required points, if we ask less than available
+            we well get sparse set which proportionally fills all available time range.
+        decimate : False or True (default)
+            Decimate should be read as apply the low pass filter or not, technically
+            for both setting we get decimation (i.e. smaller than available
+            at the scope number of points). The name came from
+            ``scipy.signal.decimate`` filtering function.
+            If ``decimate=True`` is used, we get all available points
+            and then low-pass filter them to get ``maxRequiredPoints``
+            The result is less noisy then, but transfer time from the instrument
+            is longer.
+            If ``decimate=False``, then it we are skipping points to get needed number
+            but we might see aliasing, if there is a high frequency noise
+            and sparing > 1. Unless you know what you doing, it is recommended
+            to use ``decimate=True``.
+        """
+
+        rawChanCfg = {}
+        # switching to binary data transfer
+        self.write(":WAVeform:WIDTh WORD")  # two bytes per data point
+        rawChanCfg["WaveformWidth"] = "WORD"
+        self.write(":WAVeform:BYTeorder LSB")
+        rawChanCfg["WaveformByteorder"] = "LSB"
+
+        if availableNpnts is None:
+            # using channel 1 to get availableNpnts
+            availableNpnts = self.getAvailableNumberOfPoints(1)
+            rawChanCfg["availableNpnts"] = availableNpnts
+
+        if maxRequiredPoints is None:
+            maxRequiredPoints = self.maxRequiredPoints
+        (
+            sparsing,
+            Npnts,
+            availableNpnts,
+            maxRequiredPoints,
+        ) = calcSparsingAndNumPoints(availableNpnts, maxRequiredPoints)
+        rawChanCfg["Npnts"] = Npnts
+        rawChanCfg["sparsing"] = sparsing
+        if decimate:
+            Npnts = availableNpnts  # get all of them and decimate later
+        if (sparsing == 1 and Npnts == availableNpnts) or decimate:
+            # We are getting all points of the trace
+            self.write(":WAVeform:STARt 0")  # start point to read from the scope memory
+            self.write(f":WAVeform:MAXPoint {availableNpnts}")  # last point to read
+            self.write(":WAVeform:INTerval 1")  # sparsing of 1, i.e. read every point
+            self.write(f":WAVeform:POINt {availableNpnts}")  # transfer all points
+        else:
+            # we just ask every point with 'sparsing' interval
+            # fast to grab but we could do better with more advance decimate
+            # method, which allow better precision for the price
+            # of longer acquisition time
+            self.write(":WAVeform:STARt 0")  # start point to read from the scope memory
+            self.write(f":WAVeform:MAXPoint {availableNpnts}")  # last point to read
+            self.write(f":WAVeform:INTerval {sparsing}")  #  interval between points
+            # Note: it is not enough to provide sparsing
+            # number of requested points needed to be asked too.
+            # However this scope is smart enough to truncate the output to
+            # physically available points, if you request more no harm is done.
+            self.write(f":WAVeform:POINt {Npnts}")  # transfer all points
+
+        trRaw = Trace(f"Ch{chNum}")
+        self.write(":WAVeform:SOURce C{chNum}")
+        qstr = f":WAVeform:DATA?"
+        if self.resource.interface_type == InterfaceType.usb:
+            # Setting chunk size to 496 bytes, it seems that SDS sends data
+            # in 512 bytes chunks via USB.
+            # Which is 8 packets of 64 bytes, but each packet takes 2 bytes for a header.
+            # Thus useful payload is 512-8*2 = 496
+            # see https://patchwork.ozlabs.org/project/qemu-devel/patch/20200317095049.28486-4-kraxel@redhat.com/
+            # Setting chunk_size for a large number has *catastrophic* results
+            # on data transfer rate, since we wait for more data
+            # which is not going to come until timeout expires
+            # Setting it low is not as bad but still slows down the transfer.
+            # NOTE: I am not sure if it is a Linux driver issue or more global.
+            # The transfer rate is about
+            #       5550 kB/S, for 10k points
+            #       1400 kB/S, for 50k points
+            #       1000 kB/S, for 100k points
+            #       500  kB/S, for 500k points
+            #       160  kB/S, for 1000k points
+            #       55   kB/S, for 2.5M points
+            # It is about factor of 2 slower (for 100k points),
+            # if the scope is in the Run mode, i.e. not Stopped.
+            # FIXME find why speed depends on number of points.
+            wfRaw = self.query_binary_values(
+                qstr,
+                datatype="h",
+                header_fmt="ieee",
+                container=np.array,
+                chunk_size=496,
+            )
+        else:
+            wfRaw = self.query_binary_values(
+                qstr, datatype="h", header_fmt="ieee", container=np.array
+            )
+        trRaw.values = wfRaw.reshape(wfRaw.size, 1)
+        if decimate and sparsing != 1:
+            numtaps = 3
+            # not sure it is the best case
+            trRaw.values = scipy.signal.decimate(
+                trRaw.values, sparsing, numtaps, axis=0
+            )
+
+        trRaw.config["unit"] = "Count"
+        trRaw.config["tags"]["Decimate"] = decimate
+        trRaw.config["tags"]["rawChanConfig"] = rawChanCfg
+        return trRaw
+
 
 if __name__ == "__main__":
     import pyvisa