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        return_value = UnitConversion.to_unit(return_value * units.ms, 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        Returns
131        -------
132        Union[bool, int]
133            False if no card is found, otherwise the handle of the card
134
135        """
136        for nr in range(self._max_cards):
137            device_identifier = self._std_device_identifier.format(nr)
138            handle = spcm_hOpen(ctypes.create_string_buffer(bytes(device_identifier, 'utf-8')))
139            if handle:
140                self.device_identifier = device_identifier
141                return_value = ctypes.c_int64()
142                spcm_dwGetParam_i64(handle, SPC_FNCTYPE, ctypes.byref(return_value))
143                function_type = return_value.value
144                spcm_dwGetParam_i64(handle, SPC_PCISERIALNO, ctypes.byref(return_value))
145                sn = return_value.value
146                if card_type != 0 and (card_type & function_type) == function_type:
147                    return handle
148                elif sn != 0 and sn == serial_number:
149                    return handle
150                elif serial_number == 0 and card_type == 0:
151                    return handle
152                spcm_vClose(handle)
153        return False
154
155                
156    # High-level parameter functions, that use the low-level get and set function
157    def status(self) -> int:
158        """
159        Get the status of the card (see register `SPC_M2STATUS` in the manual)
160    
161        Returns
162        -------
163        int
164            The status of the card
165        """
166
167        return self.get_i(SPC_M2STATUS)
168    
169    def card_type(self) -> int:
170        """
171        Get the card type of the card (see register `SPC_PCITYP` in the manual)
172    
173        Returns
174        -------
175        int
176            The card type of the card
177        """
178
179        return self._card_type
180    
181    def series(self) -> int:
182        """
183        Get the series of the card (see register `SPC_PCITYP` and `TYP_SERIESMASK` in the manual)
184    
185        Returns
186        -------
187        int
188            The series of the card
189        """
190
191        return self.card_type() & TYP_SERIESMASK
192
193    def function_type(self) -> int:
194        """
195        Gives information about what type of card it is. (see register `SPC_FNCTYPE` in the manual)
196    
197        Returns
198        -------
199        int
200            The function type of the card
201
202            * SPCM_TYPE_AI = 1h - Analog input card (analog acquisition; the M2i.4028 and M2i.4038 also return this value)
203            * SPCM_TYPE_AO = 2h - Analog output card (arbitrary waveform generators)
204            * SPCM_TYPE_DI = 4h - Digital input card (logic analyzer card)
205            * SPCM_TYPE_DO = 8h - Digital output card (pattern generators)
206            * SPCM_TYPE_DIO = 10h - Digital I/O (input/output) card, where the direction is software selectable.
207        """
208
209        return self._function_type
210
211    def features(self) -> int:
212        """
213        Get the features of the card (see register `SPC_PCIFEATURES` in the manual)
214    
215        Returns
216        -------
217        int
218            The features of the card
219        """
220
221        return self._features
222    
223    def ext_features(self) -> int:
224        """
225        Get the extended features of the card (see register `SPC_PCIEXTFEATURES` in the manual)
226    
227        Returns
228        -------
229        int
230            The extended features of the card
231        """
232
233        return self._ext_features
234    
235    def starhub_card(self) -> bool:
236        """
237        Check if the card is a starhub card (see register `SPC_PCIFEATURES` in the manual)
238    
239        Returns
240        -------
241        bool
242            True if the card is the card that carriers a starhub, False otherwise
243        """
244
245        return bool(self._features & SPCM_FEAT_STARHUBXX_MASK)
246    
247    def num_modules(self) -> int:
248        """
249        Get the number of modules of the card (see register `SPC_MIINST_MODULES` in the manual)
250    
251        Returns
252        -------
253        int
254            The number of modules of the card
255        """
256
257        return self.get_i(SPC_MIINST_MODULES)
258
259    def channels_per_module(self) -> int:
260        """
261        Get the number of channels per module of the card (see register `SPC_MIINST_CHPERMODULE` in the manual)
262    
263        Returns
264        -------
265        int
266            The number of channels per module of the card
267        """
268
269        return self.get_i(SPC_MIINST_CHPERMODULE)
270    
271    def num_channels(self) -> int:
272        """
273        Get the number of channels of the card (= SPC_MIINST_MODULES * SPC_MIINST_CHPERMODULE)
274    
275        Returns
276        -------
277        int
278            The number of channels of the card
279        """
280
281        return self.num_modules() * self.channels_per_module()
282
283    def card_mode(self, card_mode : int = None) -> int:
284        """
285        Set the card mode of the connected card (see register `SPC_CARDMODE` in the manual)
286        
287        Parameters
288        ----------
289        card_mode : int
290            the mode that the card needs to operate in
291
292        Returns
293        -------
294        int
295            the mode that the card operates in
296        """
297        
298        if card_mode is not None:
299            self.set_i(SPC_CARDMODE, card_mode)
300        return self.get_i(SPC_CARDMODE)
301
302    def product_name(self) -> str:
303        """
304        Get the product name of the card (see register `SPC_PCITYP` in the manual)
305    
306        Returns
307        -------
308        str
309            The product name of the connected card (e.g. M4i.6631-x8)
310        """
311
312        return self.get_str(SPC_PCITYP)
313    
314    def sn(self) -> int:
315        """
316        Get the serial number of a product (see register `SPC_PCISERIALNO` in the manual)
317    
318        Returns
319        -------
320        int
321            The serial number of the connected card (e.g. 12345)
322        """
323
324        return self.get_i(SPC_PCISERIALNO)
325
326    def active_channels(self) -> int:
327        """
328        Get the number of channels of the card (see register `SPC_CHCOUNT` in the manual)
329    
330        Returns
331        -------
332        int
333            The number of channels of the card
334        """
335
336        return self.get_i(SPC_CHCOUNT)
337
338    def bits_per_sample(self) -> int:
339        """
340        Get the number of bits per sample of the card (see register `SPC_MIINST_BITSPERSAMPLE` in the manual)
341    
342        Returns
343        -------
344        int
345            The number of bits per sample of the card
346        """
347
348        return self.get_i(SPC_MIINST_BITSPERSAMPLE)
349    
350    def bytes_per_sample(self) -> int:
351        """
352        Get the number of bytes per sample
353
354        Returns
355        -------
356        int
357            number of bytes per sample
358        """
359        return self.get_i(SPC_MIINST_BYTESPERSAMPLE)
360    
361    def max_sample_value(self) -> int:
362        """
363        Get the maximum ADC value of the card (see register `SPC_MIINST_MAXADCVALUE` in the manual)
364
365        Returns
366        -------
367        int
368            The maximum ADC value of the card
369        """
370
371        return self._max_sample_value
372    
373    def loops(self, loops : int = None) -> int:
374        """
375        Set the number of times the memory is replayed. If set to zero the generation will run continuously until it is 
376        stopped by the user.  (see register `SPC_LOOPS` in the manual)
377        
378        Parameters
379        ----------
380        loops : int
381            the number of loops that the card should perform
382        """
383
384        if loops is not None:
385            self.set_i(SPC_LOOPS, loops)
386        return self.get_i(SPC_LOOPS)