Test 24 million points extraction to CSV in small chunks.

 This is just a draft of the idea - code optimisation strongly needed.

OscScreenGrabLAN.py

@@ -1,14 +1,22 @@
 #!/usr/bin/env python
 __author__ = 'RoGeorge'
 #
+"""
+# TODO: Use "waveform:data?" multiple times to extract the whole 12M points
+          in order to overcome the "Memory lack in waveform reading!" screen message
+"""
+# TODO: Detect if the osc is in RUN or in STOP mode (looking at the length of data extracted)
+# TODO: Investigate scaling. Sometimes 3.0e-008 instead of expected 3.0e-000
 # TODO: Add timestamp and mark the trigger point as t0
 # TODO: Use channels label instead of chan1, chan2, chan3, chan4, math
 # TODO: Add command line parameters file path
+# TODO: Speed-up the transfer, try to replace Telnet with direct TCP
 # TODO: Add GUI
 # TODO: Add browse and custom filename selection
 # TODO: Create executable distributions
 #
-import telnetlib_receive_all
+from telnetlib_receive_all import Telnet
+from Rigol_functions import *
 import time
 import Image
 import StringIO
@@ -95,7 +103,7 @@ if response != 0:
 # Open a modified telnet session
 # The default telnetlib drops 0x00 characters,
 #   so a modified library 'telnetlib_receive_all' is used instead
-tn = telnetlib_receive_all.Telnet(IP_DS1104Z, port)
+tn = Telnet(IP_DS1104Z, port)
 tn.write("*idn?")  # ask for instrument ID
 instrument_id = tn.read_until("\n", 1)
 
@@ -161,42 +169,76 @@ elif file_format == "csv":
     print "Active channels on the display:", channel_list
 
     csv_buff = ""
+    depth = get_memory_depth(tn)
 
     # for each active channel
     for channel in channel_list:
-        # Read WAVE parameters
+        print
 
         # Set WAVE parameters
         tn.write("waveform:source " + channel)
         time.sleep(0.2)
 
-        # Maximum - only displayed data when osc. in RUN mode, or full memory data when STOPed
-        tn.write("waveform:mode normal")
+        tn.write("waveform:form asc")
         time.sleep(0.2)
 
-        tn.write("waveform:format ASCII")
+        # Maximum - only displayed data when osc. in RUN mode, or full memory data when STOPed
+        tn.write("waveform:mode max")
         time.sleep(0.2)
 
-        # Get data
-        tn.write("waveform:data?")
+        # Get all possible data
+        buff = ""
+        data_available = True
+
+        # max_chunk is dependent of the wav:mode and the oscilloscope type
+        # if you get on the oscilloscope screen the error message
+        # "Memory lack in waveform reading!", then decrease max_chunk value
+        max_chunk = 100000.0  # tested for DS1104Z
+        if max_chunk > depth:
+            max_chunk = depth
+
+        n1 = 1.0
+        n2 = max_chunk
+        data_available = True
+
+        while data_available:
+            display_n1 = n1
+            stop_point = is_waveform_from_to(tn, n1, n2)
+            if stop_point == 0:
+                data_available = False
+                print "ERROR: Stop data point index lower then start data point index"
+                sys.exit("ERROR")
+            elif stop_point < n1:
+                break
+            elif stop_point < n2:
+                n2 = stop_point
+                is_waveform_from_to(tn, n1, n2)
+                data_available = False
+            else:
+                data_available = True
+                n1 = n2 + 1
+                n2 += max_chunk
 
-        print "Receiving data for channel " + str(channel) + "..."
-        buff = tn.read_until("\n", big_wait)
+            tn.write("waveform:data?")
 
-        # Just in case the transfer did not complete in the expected time
-        while buff[-1] != "\n":
-            tmp = tn.read_until("\n", small_wait)
-            if len(tmp) == 0:
-                break
-            buff += tmp
+            print "Data from channel " + str(channel) + ", points " +\
+                  str(int(display_n1)) + "-" + str(int(stop_point)) + ": Receiving..."
+            buff_chunks = tn.read_until("\n", big_wait)
 
-        # Append each value to csv_buff
+            # Just in case the transfer did not complete in the expected time
+            while buff_chunks[-1] != "\n":
+                tmp = tn.read_until("\n", small_wait)
+                if len(tmp) == 0:
+                    break
+                buff_chunks += tmp
+
+            # Append data chunks
+            # Strip TMC Blockheader and terminator bytes
+            buff += buff_chunks[TMC_header_len:-1] + ","
 
-        # Strip headers (TMC and points number)
-        TMC_header = buff[:TMC_header_len]
-        data_points = float(TMC_header[2:])
-        # Strip TMC Blockheader and terminator bytes
-        buff = buff[TMC_header_len:-1]
+        buff = buff[:-1]
+
+        # Append each value to csv_buff
 
         # Process data
 

Rigol_functions.py

@@ -0,0 +1,71 @@
+__author__ = 'RoGeorge'
+
+import time
+
+def get_memory_depth(tn):
+	# Define number of horizontal grid divisions for DS1054Z
+	h_grid = 12
+
+	# ACQuire:MDEPth
+	tn.write("ACQ:MDEP?")
+	mdep = tn.read_until("\n", 1)
+
+	# if mdep is "AUTO"
+	if mdep == "AUTO\n":
+		# ACQuire:SRATe
+		tn.write("ACQ:SRAT?")
+		srate = tn.read_until("\n", 1)
+
+		# TIMebase[:MAIN]:SCALe
+		tn.write("TIM:SCAL?")
+		scal = tn.read_until("\n", 1)
+
+		# mdep = h_grid * scal * srate
+		mdep = h_grid * float(scal) * float(srate)
+
+	# return mdep
+	return float(mdep)
+
+
+# return maximum achieved stop point, or 0 for wrong input parameters
+# if achieved == requested, then set the start and stop waveform as n1_d and n2_d
+def is_waveform_from_to(tn, n1_d, n2_d):
+	# read current
+	# WAVeform:STARt
+	tn.write("WAV:STAR?")
+	n1_c = float(tn.read_until("\n", 1))
+
+	# WAVeform:STOP
+	tn.write("WAV:STOP?")
+	n2_c = float(tn.read_until("\n", 1))
+
+	if (n1_d > n2_d) or (n1_d < 1) or (n2_d < 1):
+		# wrong parameters
+		return 0
+
+	elif n2_d < n1_c:
+		# first set n1_d then set n2_d
+		tn.write("WAV:STAR " + str(n1_d))
+		time.sleep(0.3)
+		tn.write("WAV:STOP " + str(n2_d))
+		time.sleep(0.3)
+
+	else:
+		# first set n2_d then set n1_d
+		tn.write("WAV:STOP " + str(n2_d))
+		time.sleep(0.3)
+		tn.write("WAV:STAR " + str(n1_d))
+		time.sleep(0.3)
+
+	# read achieved n2
+	tn.write("WAV:STOP?")
+	n2_a = float(tn.read_until("\n", 1))
+
+	if n2_a < n2_d:
+		# restore n1_c, n2_c
+		is_waveform_from_to(tn, n1_c, n2_c)
+
+	# return n2_a
+	return n2_a
+
+