21class Device():
 22    """
 23    a class to control the low-level API interface of Spectrum Instrumentation devices
 24
 25    For more information about what setups are available, please have a look at the user manual
 26    for your specific device.
 27
 28    Parameters
 29    ----------
 30    device_identifier
 31        the identifying string that defines the used device
 32
 33    Raises
 34    ----------
 35    SpcmException
 36    SpcmTimeout
 37    """
 38
 39    # public
 40    device_identifier : str = ""
 41
 42    # private
 43    _kwargs : Dict[str, Union[int, float, str]] = {}
 44    _last_error = None
 45    _handle = None
 46    """the handle object used for the card connection"""
 47
 48    _str_len = 256
 49    _reraise : bool = False
 50    _throw_error : bool = True
 51    _verbose : bool = False
 52    _closed : bool = False
 53    """the indicator that indicated whether a connection is opened or closed is set to open (False)"""
 54
 55
 56    def __init__(self, device_identifier : str = "", handle = False, **kwargs) -> None:
 57        """Puts the device_identifier in the class parameter self.device_parameter
 58
 59        Parameters
 60        ----------
 61        device_identifier : str = ""
 62            an identifier string to connect to a specific device, for example:
 63
 64            * Local PCIe device '/dev/spcm0'
 65            * Remote 'TCPIP::192.168.1.10::inst0::INSTR'
 66        handle = False
 67            directly supply the object with an existing handle
 68        """
 69        self.device_identifier = device_identifier
 70        self._handle = handle
 71        self._kwargs = kwargs
 72        self._throw_error = kwargs.get("throw_error", True)
 73        self._verbose = kwargs.get("verbose", False)
 74    
 75    def __del__(self) -> None:
 76        """Destructor that closes the connection associated with the handle"""
 77        if not self._closed:
 78            self.stop()
 79            self._closed = True
 80            self.close(self._handle)
 81
 82    def __enter__(self) -> object:
 83        """
 84        Constructs a handle using the parameter `device_identifier`, when using the with statement
 85        
 86        Returns
 87        -------
 88        object
 89            The active card handle
 90        
 91        Raises
 92        ------
 93        SpcmException
 94        """
 95
 96        if self.device_identifier and not self._handle:
 97            self.open(self.device_identifier)
 98            if not self._handle and self._throw_error:
 99                error = SpcmError(text="{} not found...".format(self.device_identifier))
100                raise SpcmException(error)
101        return self
102    
103    def __exit__(self, exception : SpcmException = None, error_value : str = None, trace : types.TracebackType = None) -> None:
104        """
105        Handles the exiting of the with statement, when either no code is left or an exception is thrown before
106
107        Parameters
108        ----------
109        exception : SpcmException
110            Only this parameter is used and printed 
111        error_value : str
112        trace : types.TracebackType
113
114        Raises
115        ------
116        SpcmException
117        """
118        if self._verbose and exception:
119            self._print("Error type: {}".format(exception))
120            self._print("Error value: {}".format(error_value))
121            self._print("Traceback:")
122            traceback.print_tb(trace)
123        elif exception:
124            self._print("Error: {}".format(error_value))
125        self.stop(M2CMD_DATA_STOPDMA) # stop the card and the DMA transfer
126        self._closed = True
127        self.close(self._handle)
128        self._handle = None
129        if exception and self._reraise:
130            raise exception
131    
132    def handle(self) -> object:
133        """
134        Returns the handle used by the object to connect to the active card
135    
136        Class Parameters
137        ----------
138        self._handle
139    
140        Returns
141        -------
142        drv_handle
143            The active card handle
144        """
145        
146        return self._handle
147
148    # Check if a card was found
149    def __bool__(self) -> bool:
150        """
151        Check for a connection to the active card
152    
153        Class Parameters
154        ----------
155        self._handle
156    
157        Returns
158        -------
159        bool
160            True for an active connection and false otherwise
161            
162        Examples
163        -----------
164        >>> card = spcm.Card('/dev/spcm0')
165        >>> print(bool(card))
166        <<< True # if a card was found at '/dev/spcm0'
167        """
168        
169        return bool(self._handle)
170    
171    # High-level parameter functions, that use the low-level get and set function    
172    def drv_type(self) -> int:
173        """
174        Get the driver type of the currently used driver (see register `SPC_GETDRVTYPE` in the manual)
175    
176        Returns
177        -------
178        int
179            The driver type of the currently used driver
180        """
181
182        return self.get_i(SPC_GETDRVTYPE)
183
184    def drv_version(self) -> dict:
185        """
186        Get the version of the currently used driver. (see register `SPC_GETDRVVERSION` in the manual)
187    
188        Returns
189        -------
190        dict
191            version of the currently used driver
192              * "major" - the major version number,
193              * "minor" - the minor version number,
194              * "build" - the actual build
195        """
196        version_hex = self.get_i(SPC_GETDRVVERSION)
197        major = (version_hex & 0xFF000000) >> 24
198        minor = (version_hex & 0x00FF0000) >> 16
199        build = version_hex & 0x0000FFFF
200        version_dict = {"major": major, "minor": minor, "build": build}
201        return version_dict
202    
203    def kernel_version(self) -> dict:
204        """
205        Get the version of the currently used kernel. (see register `SPC_GETKERNELVERSION` in the manual)
206    
207        Returns
208        -------
209        dict 
210            version of the currently used driver
211              * "major" - the major version number,
212              * "minor" - the minor version number,
213              * "build" - the actual build
214        """
215        version_hex = self.get_i(SPC_GETKERNELVERSION)
216        major = (version_hex & 0xFF000000) >> 24
217        minor = (version_hex & 0x00FF0000) >> 16
218        build = version_hex & 0x0000FFFF
219        version_dict = {"major": major, "minor": minor, "build": build}
220        return version_dict
221    
222    def custom_modifications(self) -> dict:
223        """
224        Get the custom modifications of the currently used device. (see register `SPCM_CUSTOMMOD` in the manual)
225    
226        Returns
227        -------
228        dict
229            The custom modifications of the currently used device
230              * "starhub" - custom modifications to the starhub,
231              * "module" -  custom modification of the front-end module(s)
232              * "base" - custom modification of the base card
233        """
234
235        custom_mode = self.get_i(SPCM_CUSTOMMOD)
236        starhub = (custom_mode & SPCM_CUSTOMMOD_STARHUB_MASK) >> 16
237        module = (custom_mode & SPCM_CUSTOMMOD_MODULE_MASK) >> 8
238        base = custom_mode & SPCM_CUSTOMMOD_BASE_MASK
239        custom_dict = {"starhub": starhub, "module": module, "base": base}
240        return custom_dict
241    
242    def log_level(self, log_level : int = None) -> int:
243        """
244        Set the logging level of the driver
245    
246        Parameters
247        ----------
248        log_level : int
249            The logging level that is set for the driver
250        
251        Returns
252        -------
253        int
254            The logging level of the driver
255        """
256
257        if log_level is not None:
258            self.set_i(SPC_LOGDLLCALLS, log_level)
259        return self.get_i(SPC_LOGDLLCALLS)
260
261    def cmd(self, *args) -> None:
262        """
263        Execute spcm commands (see register `SPC_M2CMD` in the manual)
264    
265        Parameters
266        ----------
267        *args : int
268            The different command flags to be executed.
269        """
270
271        cmd = 0
272        for arg in args:
273            cmd |= arg
274        self.set_i(SPC_M2CMD, cmd)
275    
276    #@Decorators.unitize(units.ms, "timeout", int)
277    def timeout(self, timeout : int = None, return_unit = None) -> int:
278        """
279        Sets the timeout in ms (see register `SPC_TIMEOUT` in the manual)
280        
281        Parameters
282        ----------
283        timeout : int
284            The timeout in ms
285        
286        Returns
287        -------
288        int
289            returns the current timeout in ms
290        """
291
292        if timeout is not None:
293            timeout = UnitConversion.convert(timeout, units.ms, int)
294            self.set_i(SPC_TIMEOUT, timeout)
295        return_value = self.get_i(SPC_TIMEOUT)
296        if return_unit is not None: return_value = UnitConversion.to_unit(return_value, return_unit)
297        return return_value
298    
299    def start(self, *args) -> None:
300        """
301        Starts the connected card and enables triggering on the card (see command `M2CMD_CARD_START` in the manual)
302
303        Parameters
304        ----------
305        *args : int
306            flags that are send together with the start command
307        """
308
309        self.cmd(M2CMD_CARD_START, *args)
310    
311    def stop(self, *args : int) -> None:
312        """
313        Stops the connected card (see command `M2CMD_CARD_STOP` in the manual)
314
315        Parameters
316        ----------
317        *args : int
318            flags that are send together with the stop command (e.g. M2CMD_DATA_STOPDMA)
319        """
320
321        self.cmd(M2CMD_CARD_STOP, *args)
322    
323    def reset(self) -> None:
324        """
325        Resets the connected device (see command `M2CMD_CARD_RESET` in the manual)
326        """
327
328        self.cmd(M2CMD_CARD_RESET)
329
330    def write_setup(self, *args) -> None:
331        """
332        Writes of the configuration registers previously changed to the device (see command `M2CMD_CARD_WRITESETUP` in the manual)
333
334        Parameters
335        ----------
336        *args : int
337            flags that are set with the write command
338        """
339
340        self.cmd(M2CMD_CARD_WRITESETUP, *args)
341    
342    def register_list(self, register_list : List[dict[str, Union[int, float]]]) -> None:
343        """
344        Writes a list with dictionaries, where each dictionary corresponds to a command (see the user manual of your device for all the available registers)
345    
346        Parameters
347        ----------
348        register_list : List[dict[str, Union[int, float]]]
349            The list of commands that needs to written to the specific registers of the card.
350        """
351
352        c_astParams = (ST_LIST_PARAM * 1024)()
353        astParams = ctypes.cast(c_astParams, ctypes.POINTER(ST_LIST_PARAM))
354        for i, register in enumerate(register_list):
355            astParams[i].lReg = register["lReg"]
356            astParams[i].lType = register["lType"]
357            if register["lType"] == TYPE_INT64:
358                astParams[i].Value.llValue = register["llValue"]
359            elif register["lType"] == TYPE_DOUBLE:
360                astParams[i].Value.dValue = register["dValue"]
361        self.set_ptr(SPC_REGISTER_LIST, astParams, len(register_list) * ctypes.sizeof(ST_LIST_PARAM))
362
363    # Low-level get and set functions
364    def get_i(self, register : int) -> int:
365        """
366        Get the integer value of a specific register of the card (see the user manual of your device for all the available registers)
367    
368        Parameters
369        ----------
370        register : int
371            The specific register that will be read from.
372        
373        Returns
374        -------
375        int
376            The value as stored in the specific register
377        """
378
379        self._check_closed()
380        return_value = int64(0)
381        dwErr = spcm_dwGetParam_i64(self._handle, register, byref(return_value))
382        self._check_error(dwErr)
383        return return_value.value
384    get = get_i
385    """Alias of get_i"""
386    
387    def get_d(self, register : int) -> float:
388        """
389        Get the float value of a specific register of the card (see the user manual of your device for all the available registers)
390    
391        Parameters
392        ----------
393        register : int
394            The specific register that will be read from.
395        
396        Returns
397        -------
398        float
399            The value as stored in the specific register
400        """
401
402        self._check_closed()
403        return_value = c_double(0)
404        self._check_error(spcm_dwGetParam_d64(self._handle, register, byref(return_value)))
405        return return_value.value
406    
407    def get_str(self, register : int) -> str:
408        """
409        Get the string value of a specific register of the card (see the user manual of your device for all the available registers)
410    
411        Parameters
412        ----------
413        register : int
414            The specific register that will be read from.
415        
416        Returns
417        -------
418        str
419            The value as stored in the specific register
420        """
421
422        self._check_closed()
423        return_value = create_string_buffer(self._str_len)
424        self._check_error(spcm_dwGetParam_ptr(self._handle, register, byref(return_value), self._str_len))
425        return return_value.value.decode('utf-8')
426    
427    def set_i(self, register : int, value : int) -> None:
428        """
429        Write the value of a specific register to the card (see the user manual of your device for all the available registers)
430    
431        Parameters
432        ----------
433        register : int
434            The specific register that will be written.
435        value : int
436            The value that is written to the card.
437        """
438
439        self._check_closed()
440        self._check_error(spcm_dwSetParam_i64(self._handle, register, value))
441    
442    def set_d(self, register : int, value : float) -> None:
443        """
444        Write the value of a specific register to the card (see the user manual of your device for all the available registers)
445    
446        Parameters
447        ----------
448        register : int
449            The specific register that will be written.
450        value : float
451            The value that is written to the card.
452        """
453
454        self._check_closed()
455        self._check_error(spcm_dwSetParam_d64(self._handle, register, value))
456    
457    def set_ptr(self, register : int, reference : c_void_p, size : int) -> None:
458        """
459        Use a memory segment to write to a specific register of the card (see the user manual of your device for all the available registers)
460    
461        Parameters
462        ----------
463        register : int
464            The specific register that will be read from.
465        reference : c_void_p
466            pointer to the memory segment
467        size : int
468            size of the memory segment
469        
470        Returns
471        -------
472        int
473            The value as stored in the specific register
474        """
475
476        self._check_closed()
477        self._check_error(spcm_dwSetParam_ptr(self._handle, register, reference, size))
478
479    # Error handling and exception raising
480    def _check_error(self, dwErr : int):
481        """
482        Create an SpcmError object and check for the last error (see the appendix in the user manual of your device for all the possible error codes)
483    
484        Parameters
485        ----------
486        dwErr : int
487            The error value as returned from a direct driver call
488        
489        Raises
490        ------
491        SpcmException
492        SpcmTimeout
493        """
494
495        # pass
496        if dwErr not in [ERR_OK, ERR_TIMEOUT] and self._throw_error:
497            self.get_error_info()
498            raise SpcmException(self._last_error)
499        elif dwErr == ERR_TIMEOUT:
500            raise SpcmTimeout("A card timeout occured")
501
502    def get_error_info(self) -> SpcmError:
503        """
504        Create an SpcmError object and store it in an object parameter
505    
506        Returns
507        ----------
508        SpcmError
509            the Error object containing the last error
510        """
511
512        self._last_error = SpcmError(self._handle)
513        return self._last_error
514    
515    def _check_closed(self) -> None:
516        """
517        Check if a connection to the card exists and if not throw an error
518
519        Raises
520        ------
521        SpcmException
522        """
523        if self._closed:
524            error_text = "The connection to the card has been closed. Please reopen the connection before sending commands."
525            if self._throw_error:
526                raise SpcmException(text=error_text)
527            else:
528                self._print(error_text)
529    
530    def _print(self, text : str, verbose : bool = False, **kwargs) -> None:
531        """
532        Print information
533
534        Parameters
535        ----------
536        text : str
537            The text that is printed
538        verbose : bool
539            A boolean that indicates if the text should forced to be printed
540        **kwargs
541            Additional parameters that are passed to the print function
542    
543        """
544
545        if self._verbose or verbose:
546            print(text, **kwargs)
547
548    def open(self, device_identifier : str) -> None:
549        """
550        Open a connection to the card and return the handle (see the user manual of your specific device on how to find out the device_identifier string)
551    
552        Parameters
553        ----------
554        device_identifier : str
555            The card identifier string (e.g. '/dev/spcm0' for a local device or 'TCPIP::192.168.1.10::inst0::INSTR' for a remote device)
556        """
557
558        self._handle = spcm_hOpen(create_string_buffer(bytes(device_identifier, 'utf-8')))
559        self._closed = False
560    
561    @staticmethod
562    def close(handle) -> None:
563        """
564        Close a connection to the card using a handle
565    
566        Parameters
567        ----------
568        handle
569            the handle object used for the card connection that is closed
570        """
571
572        spcm_vClose(handle)

 15class Card(Device):
 16    """
 17    a high-level class to control Spectrum Instrumentation cards
 18
 19    For more information about what setups are available, please have a look at the user manual
 20    for your specific card.
 21
 22    """
 23
 24    _std_device_identifier : str = "/dev/spcm{}"
 25    _max_cards : int = 64
 26    
 27    _function_type : int = 0
 28    _card_type : int = 0
 29    _max_sample_value : int = 0
 30
 31    def __enter__(self) -> 'Card':
 32        """
 33        Context manager entry function
 34
 35        Returns
 36        -------
 37        Card
 38            The card object
 39        
 40        Raises
 41        ------
 42        SpcmException
 43        """
 44        super().__enter__()
 45
 46        # keyword arguments
 47        card_type = self._kwargs.get("card_type", 0)
 48        serial_number = self._kwargs.get("serial_number", 0)
 49
 50        if self.device_identifier == "":
 51            # No device identifier was given, so we need to find the first card
 52            self._handle = self.find(card_type=card_type, serial_number=serial_number)
 53            if not self._handle:
 54                if card_type:
 55                    raise SpcmException(text="No card found of right type")
 56                elif serial_number:
 57                    raise SpcmException(text="No card found with serial number: {}".format(serial_number))
 58        elif self._handle:
 59            if card_type != 0 and self.function_type() != card_type:
 60                raise SpcmException(text="The card with the given device identifier is not the correct type")
 61            elif serial_number != 0 and self.sn() != serial_number:
 62                raise SpcmException(text="The card with the given device identifier does not have the correct serial number")
 63        
 64        # Check python, driver and kernel version
 65        if self._verbose:
 66            print("Python version: {} on {}".format (platform.python_version(), platform.system()))
 67            print("Driver version: {major}.{minor}.{build}".format(**self.drv_version()))
 68            print("Kernel version: {major}.{minor}.{build}".format(**self.kernel_version()))
 69            if self._handle:
 70                print("Found '{}': {} sn {:05d}".format(self.device_identifier, self.product_name(), self.sn()))
 71
 72        # Get the function type of the card
 73        self._function_type = self.get_i(SPC_FNCTYPE)
 74        self._card_type = self.get_i(SPC_PCITYP)
 75        self._features = self.get_i(SPC_PCIFEATURES)
 76        self._max_sample_value = self.get_i(SPC_MIINST_MAXADCVALUE)
 77        
 78        return self
 79    
 80    def __str__(self) -> str:
 81        """
 82        String representation of the card
 83
 84        Returns
 85        -------
 86        str
 87            String representation of the card
 88        """
 89        return "Card: {} sn {:05d}".format(self.product_name(), self.sn())
 90    __repr__ = __str__
 91    
 92    def find(self, card_type : int = 0, serial_number : int = 0) -> Union[bool, int]:
 93        """
 94        Find first card that is connected to the computer, with either the given card type or serial number
 95
 96        Parameters
 97        ----------
 98        card_type : int = 0
 99            The function type of the card that needs to be found
100        serial_number : int = 0
101            The serial number of the card that needs to be found
102
103        """
104        for nr in range(self._max_cards):
105            device_identifier = self._std_device_identifier.format(nr)
106            handle = spcm_hOpen(ctypes.create_string_buffer(bytes(device_identifier, 'utf-8')))
107            if handle:
108                self.device_identifier = device_identifier
109                return_value = ctypes.c_int64()
110                spcm_dwGetParam_i64(handle, SPC_FNCTYPE, ctypes.byref(return_value))
111                function_type = return_value.value
112                spcm_dwGetParam_i64(handle, SPC_PCISERIALNO, ctypes.byref(return_value))
113                sn = return_value.value
114                if card_type != 0 and (card_type & function_type) == function_type:
115                    return handle
116                elif sn != 0 and sn == serial_number:
117                    return handle
118                elif serial_number == 0 and card_type == 0:
119                    return handle
120                spcm_vClose(handle)
121        return False
122
123                
124    # High-level parameter functions, that use the low-level get and set function
125    def status(self) -> int:
126        """
127        Get the status of the card (see register `SPC_M2STATUS` in the manual)
128    
129        Returns
130        -------
131        int
132            The status of the card
133        """
134
135        return self.get_i(SPC_M2STATUS)
136    
137    def card_type(self) -> int:
138        """
139        Get the card type of the card (see register `SPC_PCITYP` in the manual)
140    
141        Returns
142        -------
143        int
144            The card type of the card
145        """
146
147        return self._card_type
148    
149    def series(self) -> int:
150        """
151        Get the series of the card (see register `SPC_PCITYP` and `TYP_SERIESMASK` in the manual)
152    
153        Returns
154        -------
155        int
156            The series of the card
157        """
158
159        return self.card_type() & TYP_SERIESMASK
160
161    def function_type(self) -> int:
162        """
163        Gives information about what type of card it is. (see register `SPC_FNCTYPE` in the manual)
164    
165        Returns
166        -------
167        int
168            The function type of the card
169
170            * SPCM_TYPE_AI = 1h - Analog input card (analog acquisition; the M2i.4028 and M2i.4038 also return this value)
171            * SPCM_TYPE_AO = 2h - Analog output card (arbitrary waveform generators)
172            * SPCM_TYPE_DI = 4h - Digital input card (logic analyzer card)
173            * SPCM_TYPE_DO = 8h - Digital output card (pattern generators)
174            * SPCM_TYPE_DIO = 10h - Digital I/O (input/output) card, where the direction is software selectable.
175        """
176
177        return self._function_type
178
179    def features(self) -> int:
180        """
181        Get the features of the card (see register `SPC_PCIFEATURES` in the manual)
182    
183        Returns
184        -------
185        int
186            The features of the card
187        """
188
189        return self._features
190    
191    def starhub_card(self) -> bool:
192        """
193        Check if the card is a starhub card (see register `SPC_PCIFEATURES` in the manual)
194    
195        Returns
196        -------
197        bool
198            True if the card is the card that carriers a starhub, False otherwise
199        """
200
201        return bool(self._features & SPCM_FEAT_STARHUBXX_MASK)
202    
203    def num_modules(self) -> int:
204        """
205        Get the number of modules of the card (see register `SPC_MIINST_MODULES` in the manual)
206    
207        Returns
208        -------
209        int
210            The number of modules of the card
211        """
212
213        return self.get_i(SPC_MIINST_MODULES)
214
215    def channels_per_module(self) -> int:
216        """
217        Get the number of channels per module of the card (see register `SPC_MIINST_CHPERMODULE` in the manual)
218    
219        Returns
220        -------
221        int
222            The number of channels per module of the card
223        """
224
225        return self.get_i(SPC_MIINST_CHPERMODULE)
226    
227    def num_channels(self) -> int:
228        """
229        Get the number of channels of the card (= SPC_MIINST_MODULES * SPC_MIINST_CHPERMODULE)
230    
231        Returns
232        -------
233        int
234            The number of channels of the card
235        """
236
237        return self.num_modules() * self.channels_per_module()
238
239    def card_mode(self, card_mode : int = None) -> int:
240        """
241        Set the card mode of the connected card (see register `SPC_CARDMODE` in the manual)
242        
243        Parameters
244        ----------
245        card_mode : int
246            the mode that the card needs to operate in
247
248        Returns
249        -------
250        int
251            the mode that the card operates in
252        """
253        
254        if card_mode is not None:
255            self.set_i(SPC_CARDMODE, card_mode)
256        return self.get_i(SPC_CARDMODE)
257
258    def product_name(self) -> str:
259        """
260        Get the product name of the card (see register `SPC_PCITYP` in the manual)
261    
262        Returns
263        -------
264        str
265            The product name of the connected card (e.g. M4i.6631-x8)
266        """
267
268        return self.get_str(SPC_PCITYP)
269    
270    def sn(self) -> int:
271        """
272        Get the serial number of a product (see register `SPC_PCISERIALNO` in the manual)
273    
274        Returns
275        -------
276        int
277            The serial number of the connected card (e.g. 12345)
278        """
279
280        return self.get_i(SPC_PCISERIALNO)
281
282    def active_channels(self) -> int:
283        """
284        Get the number of channels of the card (see register `SPC_CHCOUNT` in the manual)
285    
286        Returns
287        -------
288        int
289            The number of channels of the card
290        """
291
292        return self.get_i(SPC_CHCOUNT)
293
294    def bits_per_sample(self) -> int:
295        """
296        Get the number of bits per sample of the card (see register `SPC_MIINST_BITSPERSAMPLE` in the manual)
297    
298        Returns
299        -------
300        int
301            The number of bits per sample of the card
302        """
303
304        return self.get_i(SPC_MIINST_BITSPERSAMPLE)
305    
306    def bytes_per_sample(self) -> int:
307        """
308        Get the number of bytes per sample
309
310        Returns
311        -------
312        int
313            number of bytes per sample
314        """
315        return self.get_i(SPC_MIINST_BYTESPERSAMPLE)
316    
317    def max_sample_value(self) -> int:
318        """
319        Get the maximum ADC value of the card (see register `SPC_MIINST_MAXADCVALUE` in the manual)
320
321        Returns
322        -------
323        int
324            The maximum ADC value of the card
325        """
326
327        return self._max_sample_value
328    
329    def loops(self, loops : int = None) -> int:
330        """
331        Set the number of times the memory is replayed. If set to zero the generation will run continuously until it is 
332        stopped by the user.  (see register `SPC_LOOPS` in the manual)
333        
334        Parameters
335        ----------
336        loops : int
337            the number of loops that the card should perform
338        """
339
340        if loops is not None:
341            self.set_i(SPC_LOOPS, loops)
342        return self.get_i(SPC_LOOPS)