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 = True
 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 and self._handle:
 78            self.stop()
 79            self.close(self._handle)
 80        self._closed = True
 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        return self.open()
 96
 97    def open(self, device_identifier : str = None) -> object:
 98        """
 99        Opens a connection to the card and creates a handle, when no with statement is used
100
101        Parameters
102        ----------
103        device_identifier : str
104            The card identifier string (e.g. '/dev/spcm0' for a local device
105            NOTE: this is to keep the API consistent with a previous version. The original open()
106            method is now in _open()
107
108        Returns
109        -------
110        object
111            This Card object
112        """
113            
114        if device_identifier: # this is to keep the API consistent
115            return self._open(device_identifier)
116        # This used to be in enter. It is now split up to allow for the open method
117        # to be used when no with statement is used
118        if self.device_identifier and not self._handle:
119            self._open(self.device_identifier)
120            if not self._handle and self._throw_error:
121                error = SpcmError(text="{} not found...".format(self.device_identifier))
122                raise SpcmDeviceNotFound(error)
123            if self._handle:
124                self._closed = False
125        return self
126    
127    def __exit__(self, exception : SpcmException = None, error_value : str = None, trace : types.TracebackType = None) -> None:
128        """
129        Handles the exiting of the with statement, when either no code is left or an exception is thrown before
130
131        Parameters
132        ----------
133        exception : SpcmException
134            Only this parameter is used and printed 
135        error_value : str
136        trace : types.TracebackType
137
138        Raises
139        ------
140        SpcmException
141        """
142        if self._verbose and exception:
143            self._print("Error type: {}".format(exception))
144            self._print("Error value: {}".format(error_value))
145            self._print("Traceback:")
146            traceback.print_tb(trace)
147        elif exception:
148            self._print("Error: {}".format(error_value))
149        self.stop(M2CMD_DATA_STOPDMA) # stop the card and the DMA transfer
150        self._closed = True
151        self.close(self._handle)
152        self._handle = None
153        if exception and self._reraise:
154            raise exception
155    
156    def handle(self) -> object:
157        """
158        Returns the handle used by the object to connect to the active card
159    
160        Class Parameters
161        ----------
162        self._handle
163    
164        Returns
165        -------
166        drv_handle
167            The active card handle
168        """
169        
170        return self._handle
171
172    # Check if a card was found
173    def __bool__(self) -> bool:
174        """
175        Check for a connection to the active card
176    
177        Class Parameters
178        ----------
179        self._handle
180    
181        Returns
182        -------
183        bool
184            True for an active connection and false otherwise
185            
186        Examples
187        -----------
188        >>> card = spcm.Card('/dev/spcm0')
189        >>> print(bool(card))
190        <<< True # if a card was found at '/dev/spcm0'
191        """
192        
193        return bool(self._handle)
194    
195    # High-level parameter functions, that use the low-level get and set function    
196    def drv_type(self) -> int:
197        """
198        Get the driver type of the currently used driver (see register `SPC_GETDRVTYPE` in the manual)
199    
200        Returns
201        -------
202        int
203            The driver type of the currently used driver
204        """
205
206        return self.get_i(SPC_GETDRVTYPE)
207
208    def drv_version(self) -> dict:
209        """
210        Get the version of the currently used driver. (see register `SPC_GETDRVVERSION` in the manual)
211    
212        Returns
213        -------
214        dict
215            version of the currently used driver
216              * "major" - the major version number,
217              * "minor" - the minor version number,
218              * "build" - the actual build
219        """
220        version_hex = self.get_i(SPC_GETDRVVERSION)
221        major = (version_hex & 0xFF000000) >> 24
222        minor = (version_hex & 0x00FF0000) >> 16
223        build = version_hex & 0x0000FFFF
224        version_dict = {"major": major, "minor": minor, "build": build}
225        return version_dict
226    
227    def kernel_version(self) -> dict:
228        """
229        Get the version of the currently used kernel. (see register `SPC_GETKERNELVERSION` in the manual)
230    
231        Returns
232        -------
233        dict 
234            version of the currently used driver
235              * "major" - the major version number,
236              * "minor" - the minor version number,
237              * "build" - the actual build
238        """
239        version_hex = self.get_i(SPC_GETKERNELVERSION)
240        major = (version_hex & 0xFF000000) >> 24
241        minor = (version_hex & 0x00FF0000) >> 16
242        build = version_hex & 0x0000FFFF
243        version_dict = {"major": major, "minor": minor, "build": build}
244        return version_dict
245    
246    def custom_modifications(self) -> dict:
247        """
248        Get the custom modifications of the currently used device. (see register `SPCM_CUSTOMMOD` in the manual)
249    
250        Returns
251        -------
252        dict
253            The custom modifications of the currently used device
254              * "starhub" - custom modifications to the starhub,
255              * "module" -  custom modification of the front-end module(s)
256              * "base" - custom modification of the base card
257        """
258
259        custom_mode = self.get_i(SPCM_CUSTOMMOD)
260        starhub = (custom_mode & SPCM_CUSTOMMOD_STARHUB_MASK) >> 16
261        module = (custom_mode & SPCM_CUSTOMMOD_MODULE_MASK) >> 8
262        base = custom_mode & SPCM_CUSTOMMOD_BASE_MASK
263        custom_dict = {"starhub": starhub, "module": module, "base": base}
264        return custom_dict
265    
266    def log_level(self, log_level : int = None) -> int:
267        """
268        Set the logging level of the driver
269    
270        Parameters
271        ----------
272        log_level : int
273            The logging level that is set for the driver
274        
275        Returns
276        -------
277        int
278            The logging level of the driver
279        """
280
281        if log_level is not None:
282            self.set_i(SPC_LOGDLLCALLS, log_level)
283        return self.get_i(SPC_LOGDLLCALLS)
284
285    def cmd(self, *args) -> None:
286        """
287        Execute spcm commands (see register `SPC_M2CMD` in the manual)
288    
289        Parameters
290        ----------
291        *args : int
292            The different command flags to be executed.
293        """
294
295        cmd = 0
296        for arg in args:
297            cmd |= arg
298        self.set_i(SPC_M2CMD, cmd)
299    
300    #@Decorators.unitize(units.ms, "timeout", int)
301    def timeout(self, timeout : int = None, return_unit = None) -> int:
302        """
303        Sets the timeout in ms (see register `SPC_TIMEOUT` in the manual)
304        
305        Parameters
306        ----------
307        timeout : int
308            The timeout in ms
309        
310        Returns
311        -------
312        int
313            returns the current timeout in ms
314        """
315
316        if timeout is not None:
317            timeout = UnitConversion.convert(timeout, units.ms, int)
318            self.set_i(SPC_TIMEOUT, timeout)
319        return_value = self.get_i(SPC_TIMEOUT)
320        if return_unit is not None: return_value = UnitConversion.to_unit(return_value, return_unit)
321        return return_value
322    
323    def start(self, *args) -> None:
324        """
325        Starts the connected card and enables triggering on the card (see command `M2CMD_CARD_START` in the manual)
326
327        Parameters
328        ----------
329        *args : int
330            flags that are send together with the start command
331        """
332
333        self.cmd(M2CMD_CARD_START, *args)
334    
335    def stop(self, *args : int) -> None:
336        """
337        Stops the connected card (see command `M2CMD_CARD_STOP` in the manual)
338
339        Parameters
340        ----------
341        *args : int
342            flags that are send together with the stop command (e.g. M2CMD_DATA_STOPDMA)
343        """
344
345        self.cmd(M2CMD_CARD_STOP, *args)
346    
347    def reset(self) -> None:
348        """
349        Resets the connected device (see command `M2CMD_CARD_RESET` in the manual)
350        """
351
352        self.cmd(M2CMD_CARD_RESET)
353
354    def write_setup(self, *args) -> None:
355        """
356        Writes of the configuration registers previously changed to the device (see command `M2CMD_CARD_WRITESETUP` in the manual)
357
358        Parameters
359        ----------
360        *args : int
361            flags that are set with the write command
362        """
363
364        self.cmd(M2CMD_CARD_WRITESETUP, *args)
365    
366    def register_list(self, register_list : List[dict[str, Union[int, float]]]) -> None:
367        """
368        Writes a list with dictionaries, where each dictionary corresponds to a command (see the user manual of your device for all the available registers)
369    
370        Parameters
371        ----------
372        register_list : List[dict[str, Union[int, float]]]
373            The list of commands that needs to written to the specific registers of the card.
374        """
375
376        c_astParams = (ST_LIST_PARAM * 1024)()
377        astParams = ctypes.cast(c_astParams, ctypes.POINTER(ST_LIST_PARAM))
378        for i, register in enumerate(register_list):
379            astParams[i].lReg = register["lReg"]
380            astParams[i].lType = register["lType"]
381            if register["lType"] == TYPE_INT64:
382                astParams[i].Value.llValue = register["llValue"]
383            elif register["lType"] == TYPE_DOUBLE:
384                astParams[i].Value.dValue = register["dValue"]
385        self.set_ptr(SPC_REGISTER_LIST, astParams, len(register_list) * ctypes.sizeof(ST_LIST_PARAM))
386
387    # Low-level get and set functions
388    def get_i(self, register : int) -> int:
389        """
390        Get the integer value of a specific register of the card (see the user manual of your device for all the available registers)
391    
392        Parameters
393        ----------
394        register : int
395            The specific register that will be read from.
396        
397        Returns
398        -------
399        int
400            The value as stored in the specific register
401        """
402
403        self._check_closed()
404        return_value = int64(0)
405        dwErr = spcm_dwGetParam_i64(self._handle, register, byref(return_value))
406        self._check_error(dwErr)
407        return return_value.value
408    get = get_i
409    """Alias of get_i"""
410    
411    def get_d(self, register : int) -> float:
412        """
413        Get the float value of a specific register of the card (see the user manual of your device for all the available registers)
414    
415        Parameters
416        ----------
417        register : int
418            The specific register that will be read from.
419        
420        Returns
421        -------
422        float
423            The value as stored in the specific register
424        """
425
426        self._check_closed()
427        return_value = c_double(0)
428        self._check_error(spcm_dwGetParam_d64(self._handle, register, byref(return_value)))
429        return return_value.value
430    
431    def get_str(self, register : int) -> str:
432        """
433        Get the string value of a specific register of the card (see the user manual of your device for all the available registers)
434    
435        Parameters
436        ----------
437        register : int
438            The specific register that will be read from.
439        
440        Returns
441        -------
442        str
443            The value as stored in the specific register
444        """
445
446        self._check_closed()
447        return_value = create_string_buffer(self._str_len)
448        self._check_error(spcm_dwGetParam_ptr(self._handle, register, byref(return_value), self._str_len))
449        return return_value.value.decode('utf-8')
450    
451    def set_i(self, register : int, value : int) -> None:
452        """
453        Write the value of a specific register to the card (see the user manual of your device for all the available registers)
454    
455        Parameters
456        ----------
457        register : int
458            The specific register that will be written.
459        value : int
460            The value that is written to the card.
461        """
462
463        self._check_closed()
464        self._check_error(spcm_dwSetParam_i64(self._handle, register, value))
465    
466    def set_d(self, register : int, value : float) -> None:
467        """
468        Write the value of a specific register to the card (see the user manual of your device for all the available registers)
469    
470        Parameters
471        ----------
472        register : int
473            The specific register that will be written.
474        value : float
475            The value that is written to the card.
476        """
477
478        self._check_closed()
479        self._check_error(spcm_dwSetParam_d64(self._handle, register, value))
480    
481    def set_ptr(self, register : int, reference : c_void_p, size : int) -> None:
482        """
483        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)
484    
485        Parameters
486        ----------
487        register : int
488            The specific register that will be read from.
489        reference : c_void_p
490            pointer to the memory segment
491        size : int
492            size of the memory segment
493        
494        Returns
495        -------
496        int
497            The value as stored in the specific register
498        """
499
500        self._check_closed()
501        self._check_error(spcm_dwSetParam_ptr(self._handle, register, reference, size))
502
503    # Error handling and exception raising
504    def _check_error(self, dwErr : int):
505        """
506        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)
507    
508        Parameters
509        ----------
510        dwErr : int
511            The error value as returned from a direct driver call
512        
513        Raises
514        ------
515        SpcmException
516        SpcmTimeout
517        """
518
519        # pass
520        if dwErr not in [ERR_OK, ERR_TIMEOUT] and self._throw_error:
521            self.get_error_info()
522            raise SpcmException(self._last_error)
523        elif dwErr == ERR_TIMEOUT:
524            raise SpcmTimeout("A card timeout occured")
525
526    def get_error_info(self) -> SpcmError:
527        """
528        Create an SpcmError object and store it in an object parameter
529    
530        Returns
531        ----------
532        SpcmError
533            the Error object containing the last error
534        """
535
536        self._last_error = SpcmError(self._handle)
537        return self._last_error
538    
539    def _check_closed(self) -> None:
540        """
541        Check if a connection to the card exists and if not throw an error
542
543        Raises
544        ------
545        SpcmException
546        """
547        if self._closed:
548            error_text = "The connection to the card has been closed. Please reopen the connection before sending commands."
549            if self._throw_error:
550                raise SpcmException(text=error_text)
551            else:
552                self._print(error_text)
553    
554    def _print(self, text : str, verbose : bool = False, **kwargs) -> None:
555        """
556        Print information
557
558        Parameters
559        ----------
560        text : str
561            The text that is printed
562        verbose : bool
563            A boolean that indicates if the text should forced to be printed
564        **kwargs
565            Additional parameters that are passed to the print function
566    
567        """
568
569        if self._verbose or verbose:
570            print(text, **kwargs)
571
572    def _open(self, device_identifier : str) -> None:
573        """
574        Open a connection to the card and create a handle (see the user manual of your specific device on how to find out the device_identifier string)
575    
576        Parameters
577        ----------
578        device_identifier : str
579            The card identifier string (e.g. '/dev/spcm0' for a local device or 'TCPIP::192.168.1.10::inst0::INSTR' for a remote device)
580        """
581
582        self._handle = spcm_hOpen(create_string_buffer(bytes(device_identifier, 'utf-8')))
583        self._closed = False
584    
585    @staticmethod
586    def close(handle) -> None:
587        """
588        Close a connection to the card using a handle
589    
590        Parameters
591        ----------
592        handle
593            the handle object used for the card connection that is closed
594        """
595
596        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        return super().__enter__()
 45
 46    def open(self, device_identifier : str = None) -> 'Card':
 47        """
 48        Open a connection to the card
 49
 50        Parameters
 51        ----------
 52        device_identifier : str = ""
 53            The device identifier of the card that needs to be opened
 54
 55        Returns
 56        -------
 57        Card
 58            The card object
 59
 60        Raises
 61        ------
 62        SpcmException
 63        """
 64
 65        if device_identifier is not None:
 66            return super().open(device_identifier=device_identifier)
 67        
 68        super().open()
 69
 70        # keyword arguments
 71        card_type = self._kwargs.get("card_type", 0)
 72        serial_number = self._kwargs.get("serial_number", 0)
 73
 74        if self.device_identifier == "":
 75            # No device identifier was given, so we need to find the first card
 76            self._handle = self.find(card_type=card_type, serial_number=serial_number)
 77            if not self._handle:
 78                if card_type:
 79                    raise SpcmException(text="No card found of right type")
 80                elif serial_number:
 81                    raise SpcmException(text="No card found with serial number: {}".format(serial_number))
 82            else:
 83                self._closed = False
 84        elif self._handle:
 85            if card_type != 0 and self.function_type() != card_type:
 86                raise SpcmException(text="The card with the given device identifier is not the correct type")
 87            elif serial_number != 0 and self.sn() != serial_number:
 88                raise SpcmException(text="The card with the given device identifier does not have the correct serial number")
 89        
 90        # Check python, driver and kernel version
 91        if self._verbose:
 92            print("Python version: {} on {}".format (platform.python_version(), platform.system()))
 93            print("Driver version: {major}.{minor}.{build}".format(**self.drv_version()))
 94            print("Kernel version: {major}.{minor}.{build}".format(**self.kernel_version()))
 95            if self._handle:
 96                print("Found '{}': {} sn {:05d}".format(self.device_identifier, self.product_name(), self.sn()))
 97
 98        # Get the function type of the card
 99        self._function_type = self.get_i(SPC_FNCTYPE)
100        self._card_type = self.get_i(SPC_PCITYP)
101        self._features = self.get_i(SPC_PCIFEATURES)
102        self._ext_features = self.get_i(SPC_PCIEXTFEATURES)
103        self._max_sample_value = self.get_i(SPC_MIINST_MAXADCVALUE)
104        
105        return self
106    
107    def __str__(self) -> str:
108        """
109        String representation of the card
110
111        Returns
112        -------
113        str
114            String representation of the card
115        """
116        return "Card: {} sn {:05d}".format(self.product_name(), self.sn())
117    __repr__ = __str__
118    
119    def find(self, card_type : int = 0, serial_number : int = 0) -> Union[bool, int]:
120        """
121        Find first card that is connected to the computer, with either the given card type or serial number
122
123        Parameters
124        ----------
125        card_type : int = 0
126            The function type of the card that needs to be found
127        serial_number : int = 0
128            The serial number of the card that needs to be found
129
130        """
131        for nr in range(self._max_cards):
132            device_identifier = self._std_device_identifier.format(nr)
133            handle = spcm_hOpen(ctypes.create_string_buffer(bytes(device_identifier, 'utf-8')))
134            if handle:
135                self.device_identifier = device_identifier
136                return_value = ctypes.c_int64()
137                spcm_dwGetParam_i64(handle, SPC_FNCTYPE, ctypes.byref(return_value))
138                function_type = return_value.value
139                spcm_dwGetParam_i64(handle, SPC_PCISERIALNO, ctypes.byref(return_value))
140                sn = return_value.value
141                if card_type != 0 and (card_type & function_type) == function_type:
142                    return handle
143                elif sn != 0 and sn == serial_number:
144                    return handle
145                elif serial_number == 0 and card_type == 0:
146                    return handle
147                spcm_vClose(handle)
148        return False
149
150                
151    # High-level parameter functions, that use the low-level get and set function
152    def status(self) -> int:
153        """
154        Get the status of the card (see register `SPC_M2STATUS` in the manual)
155    
156        Returns
157        -------
158        int
159            The status of the card
160        """
161
162        return self.get_i(SPC_M2STATUS)
163    
164    def card_type(self) -> int:
165        """
166        Get the card type of the card (see register `SPC_PCITYP` in the manual)
167    
168        Returns
169        -------
170        int
171            The card type of the card
172        """
173
174        return self._card_type
175    
176    def series(self) -> int:
177        """
178        Get the series of the card (see register `SPC_PCITYP` and `TYP_SERIESMASK` in the manual)
179    
180        Returns
181        -------
182        int
183            The series of the card
184        """
185
186        return self.card_type() & TYP_SERIESMASK
187
188    def function_type(self) -> int:
189        """
190        Gives information about what type of card it is. (see register `SPC_FNCTYPE` in the manual)
191    
192        Returns
193        -------
194        int
195            The function type of the card
196
197            * SPCM_TYPE_AI = 1h - Analog input card (analog acquisition; the M2i.4028 and M2i.4038 also return this value)
198            * SPCM_TYPE_AO = 2h - Analog output card (arbitrary waveform generators)
199            * SPCM_TYPE_DI = 4h - Digital input card (logic analyzer card)
200            * SPCM_TYPE_DO = 8h - Digital output card (pattern generators)
201            * SPCM_TYPE_DIO = 10h - Digital I/O (input/output) card, where the direction is software selectable.
202        """
203
204        return self._function_type
205
206    def features(self) -> int:
207        """
208        Get the features of the card (see register `SPC_PCIFEATURES` in the manual)
209    
210        Returns
211        -------
212        int
213            The features of the card
214        """
215
216        return self._features
217    
218    def ext_features(self) -> int:
219        """
220        Get the extended features of the card (see register `SPC_PCIEXTFEATURES` in the manual)
221    
222        Returns
223        -------
224        int
225            The extended features of the card
226        """
227
228        return self._ext_features
229    
230    def starhub_card(self) -> bool:
231        """
232        Check if the card is a starhub card (see register `SPC_PCIFEATURES` in the manual)
233    
234        Returns
235        -------
236        bool
237            True if the card is the card that carriers a starhub, False otherwise
238        """
239
240        return bool(self._features & SPCM_FEAT_STARHUBXX_MASK)
241    
242    def num_modules(self) -> int:
243        """
244        Get the number of modules of the card (see register `SPC_MIINST_MODULES` in the manual)
245    
246        Returns
247        -------
248        int
249            The number of modules of the card
250        """
251
252        return self.get_i(SPC_MIINST_MODULES)
253
254    def channels_per_module(self) -> int:
255        """
256        Get the number of channels per module of the card (see register `SPC_MIINST_CHPERMODULE` in the manual)
257    
258        Returns
259        -------
260        int
261            The number of channels per module of the card
262        """
263
264        return self.get_i(SPC_MIINST_CHPERMODULE)
265    
266    def num_channels(self) -> int:
267        """
268        Get the number of channels of the card (= SPC_MIINST_MODULES * SPC_MIINST_CHPERMODULE)
269    
270        Returns
271        -------
272        int
273            The number of channels of the card
274        """
275
276        return self.num_modules() * self.channels_per_module()
277
278    def card_mode(self, card_mode : int = None) -> int:
279        """
280        Set the card mode of the connected card (see register `SPC_CARDMODE` in the manual)
281        
282        Parameters
283        ----------
284        card_mode : int
285            the mode that the card needs to operate in
286
287        Returns
288        -------
289        int
290            the mode that the card operates in
291        """
292        
293        if card_mode is not None:
294            self.set_i(SPC_CARDMODE, card_mode)
295        return self.get_i(SPC_CARDMODE)
296
297    def product_name(self) -> str:
298        """
299        Get the product name of the card (see register `SPC_PCITYP` in the manual)
300    
301        Returns
302        -------
303        str
304            The product name of the connected card (e.g. M4i.6631-x8)
305        """
306
307        return self.get_str(SPC_PCITYP)
308    
309    def sn(self) -> int:
310        """
311        Get the serial number of a product (see register `SPC_PCISERIALNO` in the manual)
312    
313        Returns
314        -------
315        int
316            The serial number of the connected card (e.g. 12345)
317        """
318
319        return self.get_i(SPC_PCISERIALNO)
320
321    def active_channels(self) -> int:
322        """
323        Get the number of channels of the card (see register `SPC_CHCOUNT` in the manual)
324    
325        Returns
326        -------
327        int
328            The number of channels of the card
329        """
330
331        return self.get_i(SPC_CHCOUNT)
332
333    def bits_per_sample(self) -> int:
334        """
335        Get the number of bits per sample of the card (see register `SPC_MIINST_BITSPERSAMPLE` in the manual)
336    
337        Returns
338        -------
339        int
340            The number of bits per sample of the card
341        """
342
343        return self.get_i(SPC_MIINST_BITSPERSAMPLE)
344    
345    def bytes_per_sample(self) -> int:
346        """
347        Get the number of bytes per sample
348
349        Returns
350        -------
351        int
352            number of bytes per sample
353        """
354        return self.get_i(SPC_MIINST_BYTESPERSAMPLE)
355    
356    def max_sample_value(self) -> int:
357        """
358        Get the maximum ADC value of the card (see register `SPC_MIINST_MAXADCVALUE` in the manual)
359
360        Returns
361        -------
362        int
363            The maximum ADC value of the card
364        """
365
366        return self._max_sample_value
367    
368    def loops(self, loops : int = None) -> int:
369        """
370        Set the number of times the memory is replayed. If set to zero the generation will run continuously until it is 
371        stopped by the user.  (see register `SPC_LOOPS` in the manual)
372        
373        Parameters
374        ----------
375        loops : int
376            the number of loops that the card should perform
377        """
378
379        if loops is not None:
380            self.set_i(SPC_LOOPS, loops)
381        return self.get_i(SPC_LOOPS)