Add interface to use atsaverage auto rearm

qupulse/hardware/dacs/alazar.py

@@ -14,12 +14,16 @@
 from qupulse.hardware.dacs.dac_base import DAC
 
 
+logger = logging.getLogger(__name__)
+
+
 class AlazarProgram:
     def __init__(self):
         self._sample_factor = None
         self._masks = {}
         self.operations = []
         self._total_length = None
+        self._auto_rearm_count = 1
 
     def masks(self, mask_maker: Callable[[str, np.ndarray, np.ndarray], Mask]) -> List[Mask]:
         return [mask_maker(mask_name, *data) for mask_name, data in self._masks.items()]
@@ -39,6 +43,21 @@ def total_length(self) -> int:
     def total_length(self, val: int):
         self._total_length = val
 
+    @property
+    def auto_rearm_count(self) -> int:
+        """This is passed to AlazarCard.startAcquisition. The card will (re-)arm automatically for this many times."""
+        return self._auto_rearm_count
+
+    @auto_rearm_count.setter
+    def auto_rearm_count(self, value: int):
+        trigger_count = int(value)
+        if trigger_count == 0:
+            raise ValueError("Trigger count of 0 is not supported in qupulse (yet) because tracking the number of "
+                             "remaining triggers is too hard in case of infinity :(")
+        if not 0 < trigger_count < 2**64:
+            raise ValueError("Trigger count has to be in the interval [0, 2**64-1]")
+        self._auto_rearm_count = trigger_count
+
     def clear_masks(self):
         self._masks.clear()
 
@@ -192,6 +211,8 @@ def __init__(self, card, config: Optional[ScanlineConfiguration]=None):
         # defaults to self.__card.minimum_record_size
         self._buffer_strategy = None
 
+        self._remaining_auto_triggers = 0
+
         self._mask_prototypes = dict()  # type: Dict
 
         self._registered_programs = defaultdict(AlazarProgram)  # type: Dict[str, AlazarProgram]
@@ -248,8 +269,13 @@ def register_operations(self, program_name: str, operations) -> None:
         self._registered_programs[program_name].operations = operations
 
     def arm_program(self, program_name: str) -> None:
+        logger.debug("Arming program %s on %r", program_name, self.__card)
+
         to_arm = self._registered_programs[program_name]
         if self.update_settings or self.__armed_program is not to_arm:
+            logger.info("Arming %r by calling applyConfiguration. Update settings flag: %r",
+                        self.__card, self.update_settings)
+
             config = self.config
             config.masks, config.operations, total_record_size = self._registered_programs[program_name].iter(
                 self._make_mask)
@@ -287,7 +313,15 @@ def arm_program(self, program_name: str) -> None:
 
             self.update_settings = False
             self.__armed_program = to_arm
-        self.__card.startAcquisition(1)
+
+        elif self.__armed_program is to_arm and self._remaining_auto_triggers > 0:
+            self._remaining_auto_triggers -= 1
+            logger.info("Relying on atsaverage auto-arm with %d auto triggers remaining after this one",
+                        self._remaining_auto_triggers)
+            return
+
+        self.__card.startAcquisition(to_arm.auto_rearm_count)
+        self._remaining_auto_triggers = to_arm.auto_rearm_count - 1
 
     def delete_program(self, program_name: str) -> None:
         self._registered_programs.pop(program_name)