waterfall display

dmi.py

@@ -3,6 +3,7 @@ import numpy as np
 import gc
 
 from noptica import *
+from gui import GUI
 
 
 def main():
@@ -11,20 +12,26 @@ def main():
 
     freq_sample = 1e6
     freq_base = 1088230e3
-    bufsize = 4096
+    block_size = 4096
 
+    gui = GUI()
+    try:
         induction = InductionHeater("/dev/ttyUSB0", 350e3, 445e3)
         induction.start()
         try:
-        stabilizer = Stabilizer(bufsize, 80.0, 1088.1e6 - freq_base, 10e-6, induction)
+            def stabilizer_cb(spectrum, tuning):
-        position_tracker = PositionTracker(int(0.1*freq_sample/bufsize))
+                gui.update_beat_spectrum(spectrum)
+                induction.set(tuning)
+
+            stabilizer = Stabilizer(block_size, 80.0, 1088.1e6 - freq_base, 10e-6, stabilizer_cb)
+            position_tracker = PositionTracker(int(0.1*freq_sample/block_size))
 
             sdr = SoapySDR.Device()
             for channel in range(2):
                 sdr.setSampleRate(SoapySDR.SOAPY_SDR_RX, channel, freq_sample)
                 sdr.setFrequency(SoapySDR.SOAPY_SDR_RX, channel, freq_base)
 
-        buf_sdr = BufferedSDR(sdr, [0, 1], bufsize, 256)
+            buf_sdr = BufferedSDR(sdr, [0, 1], block_size, 256)
             buf_sdr.start()
             try:
                 stabilizer_throttle = 0
@@ -47,6 +54,8 @@ def main():
                 buf_sdr.stop()
         finally:
             induction.stop()
+    finally:
+        gui.close()
 
 
 if __name__ == "__main__":

gui.py

@@ -47,17 +47,28 @@ class ParentComm:
         os.close(self.c_wfd)
 
 
+class GUI:
+    def __init__(self):
+        self.impl = ParentComm()
+        self.impl.create_subprocess([sys.executable,
+                                     os.path.join(os.path.dirname(os.path.abspath(__file__)), "gui_impl.py")])
+
+    def update_beat_spectrum(self, data):
+        obj = {"action": "update_beat_spectrum", "data": data}
+        self.impl.write_pyon(obj)
+
+    def close(self):
+        obj = {"action": "terminate"}
+        self.impl.write_pyon(obj)
+        self.impl.close()
+
 
 def main():
-    gui = ParentComm()
+    gui = GUI()
     try:
-        gui.create_subprocess([sys.executable, os.path.join(os.path.dirname(os.path.abspath(__file__)), "gui_impl.py")])
+        for i in range(200):
-        for i in range(600):
+            gui.update_beat_spectrum(np.random.normal(size=4096))
-            obj = {"action": "update", "data": np.random.normal(size=4096)}
-            gui.write_pyon(obj)
             time.sleep(1/60)
-        obj = {"action": "terminate"}
-        gui.write_pyon(obj)
     finally:
         gui.close()
 

gui_impl.py

@@ -32,7 +32,7 @@ class SpectrogramWidget(pg.PlotWidget):
 
     def update(self, block):
         self.img_array = np.roll(self.img_array, -1, 0)
-        self.img_array[-1:] = block 
+        self.img_array[-1:] = np.fft.fftshift(block) 
         self.img.setImage(self.img_array, autoLevels=True)
 
 
@@ -49,7 +49,7 @@ class IPCClient(AsyncioChildComm):
             obj = await self.read_pyon()
             try:
                 action = obj["action"]
-                if action == "update":
+                if action == "update_beat_spectrum":
                     spectrogram.update(obj["data"])
                 if action == "terminate":
                     self.close_cb()

noptica.py

@@ -104,13 +104,14 @@ class InductionHeater:
         self.thread.join()
         self.serial.close()
 
+
 class Stabilizer:
-    def __init__(self, fft_size, amp_threshold, freq_target, k, tuner):
+    def __init__(self, fft_size, amp_threshold, freq_target, k, cb):
         self.freqs = np.fft.fftfreq(fft_size)
         self.amp_threshold = amp_threshold
         self.freq_target = freq_target
         self.k = k
-        self.tuner = tuner
+        self.cb = cb
 
     def input(self, samples):
         spectrum = np.abs(np.fft.fft(samples*blackmanharris(len(samples))))
@@ -122,7 +123,7 @@ class Stabilizer:
             tuning = (freq - self.freq_target)*self.k
         else:
             tuning = 0.0
-        self.tuner.set(tuning)
+        self.cb(spectrum, tuning)
 
 
 def continuous_unwrap(last_phase, last_phase_unwrapped, p):