Fixed bug where transition_to_manual would complete when the PrawnBlaster was a secondary pseudoclock even if it hadn't finished (e.g. was still running or waiting for a trigger).

Also formatted files with black.

Author: philipstarkey

labscript_devices/PrawnBlaster/blacs_workers.py

@@ -229,7 +229,12 @@ def transition_to_buffered(self, device_name, h5file, initial_values, fresh):
                 if self.smart_cache[pseudoclock][i] != instruction:
                     self.prawnblaster.write(
                         b"set %d %d %d %d\r\n"
-                        % (pseudoclock, i, instruction["half_period"], instruction["reps"])
+                        % (
+                            pseudoclock,
+                            i,
+                            instruction["half_period"],
+                            instruction["reps"],
+                        )
                     )
                     response = self.prawnblaster.readline().decode()
                     assert (
@@ -273,7 +278,9 @@ def wait_for_trigger(self):
             # if we are not in TRANSITION_TO_RUNNING, then something has gone wrong
             # and we should raise an exception
             elif run_status != 1:
-                raise RuntimeError(f"Prawnblaster did not return an expected status. Status was {run_status}")
+                raise RuntimeError(
+                    f"Prawnblaster did not return an expected status. Status was {run_status}"
+                )
             time.sleep(0.01)
 
         # set started = True
@@ -302,6 +309,22 @@ def transition_to_manual(self):
                 hdf5_file.create_dataset("/data/waits", data=data)
 
             self.wait_durations_analysed.post(self.h5_file)
+
+        # If PrawnBlaster is master pseudoclock, then it will have it's status checked
+        # in the BLACS tab status check before any transition to manual is called.
+        # However, if it's not the master pseudoclock, we need to check here instead!
+        if not self.is_master_pseudoclock:
+            # Wait until shot completes
+            while True:
+                run_status, clock_status = self.read_status()
+                if run_status == 0:
+                    break
+                if run_status in [3, 4, 5]:
+                    raise RuntimeError(
+                        f"Prawnblaster status returned run-status={run_status} during transition to manual"
+                    )
+                time.sleep(0.01)
+
         return True
 
     def shutdown(self):

labscript_devices/PrawnBlaster/labscript_devices.py

@@ -339,7 +339,9 @@ def generate_code(self, hdf5_file):
                     reduced_instructions[-1]["reps"] += reps
                 else:
                     # New instruction
-                    reduced_instructions.append({"half_period": half_period, "reps": reps})
+                    reduced_instructions.append(
+                        {"half_period": half_period, "reps": reps}
+                    )
 
             # Only add this if there is room in the instruction table. The PrawnBlaster
             # firmware has extre room at the end for an instruction that is always 0

labscript_devices/PrawnBlaster/runviewer_parsers.py

@@ -37,10 +37,10 @@ def get_traces(self, add_trace, clock=None):
 
         # get the pulse program
         pulse_programs = []
-        with h5py.File(self.path, 'r') as f:
+        with h5py.File(self.path, "r") as f:
             # Get the device properties
-            device_props = properties.get(f, self.name, 'device_properties')
-            conn_props = properties.get(f, self.name, 'connection_table_properties')
+            device_props = properties.get(f, self.name, "device_properties")
+            conn_props = properties.get(f, self.name, "connection_table_properties")
 
             self.clock_resolution = device_props["clock_resolution"]
             self.trigger_delay = device_props["trigger_delay"]
@@ -49,8 +49,8 @@ def get_traces(self, add_trace, clock=None):
             # Extract the pulse programs
             num_pseudoclocks = conn_props["num_pseudoclocks"]
             for i in range(num_pseudoclocks):
-                pulse_programs.append(f[f'devices/{self.name}/PULSE_PROGRAM_{i}'][:])
-        
+                pulse_programs.append(f[f"devices/{self.name}/PULSE_PROGRAM_{i}"][:])
+
         # Generate clocklines and triggers
         clocklines_and_triggers = {}
         for pulse_program in pulse_programs:
@@ -64,7 +64,7 @@ def get_traces(self, add_trace, clock=None):
 
             last_instruction_was_wait = False
             for row in pulse_program:
-                if row['reps'] == 0 and not last_instruction_was_wait: # WAIT
+                if row["reps"] == 0 and not last_instruction_was_wait:  # WAIT
                     last_instruction_was_wait = True
                     if clock is not None:
                         t = clock_ticks[trigger_index] + self.trigger_delay
@@ -78,11 +78,11 @@ def get_traces(self, add_trace, clock=None):
                     continue
                 else:
                     last_instruction_was_wait = False
-                    for i in range(row['reps']):
+                    for i in range(row["reps"]):
                         for j in range(1, -1, -1):
                             time.append(t)
                             states.append(j)
-                            t += row['half_period'] * clock_factor
+                            t += row["half_period"] * clock_factor
 
             clock = (np.array(time), np.array(states))
 
@@ -91,6 +91,8 @@ def get_traces(self, add_trace, clock=None):
                     # Ignore the dummy internal wait monitor clockline
                     if clock_line.parent_port.startswith("GPIO"):
                         clocklines_and_triggers[clock_line_name] = clock
-                        add_trace(clock_line_name, clock, self.name, clock_line.parent_port)
+                        add_trace(
+                            clock_line_name, clock, self.name, clock_line.parent_port
+                        )
 
         return clocklines_and_triggers