from typing import List
from ...Internal.Core import Core
from ...Internal.CommandsGroup import CommandsGroup
from ...Internal import Conversions
from ...Internal.Utilities import trim_str_response
from ... import enums
# noinspection PyPep8Naming,PyAttributeOutsideInit,SpellCheckingInspection
class SystemCls:
"""
| Commands in total: 207
| Subgroups: 37
| Direct child commands: 28
"""
def __init__(self, core: Core, parent):
self._core = core
self._cmd_group = CommandsGroup("system", core, parent)
@property
def beeper(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_beeper'):
from .Beeper import BeeperCls
self._beeper = BeeperCls(self._core, self._cmd_group)
return self._beeper
@property
def bios(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_bios'):
from .Bios import BiosCls
self._bios = BiosCls(self._core, self._cmd_group)
return self._bios
@property
def communicate(self):
"""
| Commands in total: 49
| Subgroups: 8
| Direct child commands: 0
"""
if not hasattr(self, '_communicate'):
from .Communicate import CommunicateCls
self._communicate = CommunicateCls(self._core, self._cmd_group)
return self._communicate
@property
def date(self):
"""
| Commands in total: 3
| Subgroups: 0
| Direct child commands: 3
"""
if not hasattr(self, '_date'):
from .Date import DateCls
self._date = DateCls(self._core, self._cmd_group)
return self._date
@property
def device(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_device'):
from .Device import DeviceCls
self._device = DeviceCls(self._core, self._cmd_group)
return self._device
@property
def dexchange(self):
"""
| Commands in total: 12
| Subgroups: 3
| Direct child commands: 5
"""
if not hasattr(self, '_dexchange'):
from .Dexchange import DexchangeCls
self._dexchange = DexchangeCls(self._core, self._cmd_group)
return self._dexchange
@property
def deviceFootprint(self):
"""
| Commands in total: 3
| Subgroups: 1
| Direct child commands: 1
"""
if not hasattr(self, '_deviceFootprint'):
from .DeviceFootprint import DeviceFootprintCls
self._deviceFootprint = DeviceFootprintCls(self._core, self._cmd_group)
return self._deviceFootprint
@property
def error(self):
"""
| Commands in total: 7
| Subgroups: 2
| Direct child commands: 3
"""
if not hasattr(self, '_error'):
from .Error import ErrorCls
self._error = ErrorCls(self._core, self._cmd_group)
return self._error
@property
def files(self):
"""
| Commands in total: 1
| Subgroups: 1
| Direct child commands: 0
"""
if not hasattr(self, '_files'):
from .Files import FilesCls
self._files = FilesCls(self._core, self._cmd_group)
return self._files
@property
def fpFpga(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_fpFpga'):
from .FpFpga import FpFpgaCls
self._fpFpga = FpFpgaCls(self._core, self._cmd_group)
return self._fpFpga
@property
def fpreset(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_fpreset'):
from .Fpreset import FpresetCls
self._fpreset = FpresetCls(self._core, self._cmd_group)
return self._fpreset
@property
def generic(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_generic'):
from .Generic import GenericCls
self._generic = GenericCls(self._core, self._cmd_group)
return self._generic
@property
def help(self):
"""
| Commands in total: 4
| Subgroups: 1
| Direct child commands: 2
"""
if not hasattr(self, '_help'):
from .Help import HelpCls
self._help = HelpCls(self._core, self._cmd_group)
return self._help
@property
def identification(self):
"""
| Commands in total: 2
| Subgroups: 0
| Direct child commands: 2
"""
if not hasattr(self, '_identification'):
from .Identification import IdentificationCls
self._identification = IdentificationCls(self._core, self._cmd_group)
return self._identification
@property
def information(self):
"""
| Commands in total: 4
| Subgroups: 1
| Direct child commands: 2
"""
if not hasattr(self, '_information'):
from .Information import InformationCls
self._information = InformationCls(self._core, self._cmd_group)
return self._information
@property
def linux(self):
"""
| Commands in total: 1
| Subgroups: 1
| Direct child commands: 0
"""
if not hasattr(self, '_linux'):
from .Linux import LinuxCls
self._linux = LinuxCls(self._core, self._cmd_group)
return self._linux
@property
def lock(self):
"""
| Commands in total: 10
| Subgroups: 5
| Direct child commands: 1
"""
if not hasattr(self, '_lock'):
from .Lock import LockCls
self._lock = LockCls(self._core, self._cmd_group)
return self._lock
@property
def massMemory(self):
"""
| Commands in total: 2
| Subgroups: 1
| Direct child commands: 0
"""
if not hasattr(self, '_massMemory'):
from .MassMemory import MassMemoryCls
self._massMemory = MassMemoryCls(self._core, self._cmd_group)
return self._massMemory
@property
def ntp(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_ntp'):
from .Ntp import NtpCls
self._ntp = NtpCls(self._core, self._cmd_group)
return self._ntp
@property
def option(self):
"""
| Commands in total: 2
| Subgroups: 1
| Direct child commands: 0
"""
if not hasattr(self, '_option'):
from .Option import OptionCls
self._option = OptionCls(self._core, self._cmd_group)
return self._option
@property
def package(self):
"""
| Commands in total: 3
| Subgroups: 3
| Direct child commands: 0
"""
if not hasattr(self, '_package'):
from .Package import PackageCls
self._package = PackageCls(self._core, self._cmd_group)
return self._package
@property
def pciFpga(self):
"""
| Commands in total: 2
| Subgroups: 1
| Direct child commands: 0
"""
if not hasattr(self, '_pciFpga'):
from .PciFpga import PciFpgaCls
self._pciFpga = PciFpgaCls(self._core, self._cmd_group)
return self._pciFpga
@property
def profiling(self):
"""
| Commands in total: 11
| Subgroups: 5
| Direct child commands: 1
"""
if not hasattr(self, '_profiling'):
from .Profiling import ProfilingCls
self._profiling = ProfilingCls(self._core, self._cmd_group)
return self._profiling
@property
def protect(self):
"""
| Commands in total: 1
| Subgroups: 1
| Direct child commands: 0
"""
if not hasattr(self, '_protect'):
from .Protect import ProtectCls
self._protect = ProtectCls(self._core, self._cmd_group)
return self._protect
@property
def reboot(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_reboot'):
from .Reboot import RebootCls
self._reboot = RebootCls(self._core, self._cmd_group)
return self._reboot
@property
def restart(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_restart'):
from .Restart import RestartCls
self._restart = RestartCls(self._core, self._cmd_group)
return self._restart
@property
def scrpt(self):
"""
| Commands in total: 5
| Subgroups: 1
| Direct child commands: 4
"""
if not hasattr(self, '_scrpt'):
from .Scrpt import ScrptCls
self._scrpt = ScrptCls(self._core, self._cmd_group)
return self._scrpt
@property
def security(self):
"""
| Commands in total: 18
| Subgroups: 6
| Direct child commands: 1
"""
if not hasattr(self, '_security'):
from .Security import SecurityCls
self._security = SecurityCls(self._core, self._cmd_group)
return self._security
@property
def shutdown(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_shutdown'):
from .Shutdown import ShutdownCls
self._shutdown = ShutdownCls(self._core, self._cmd_group)
return self._shutdown
@property
def specification(self):
"""
| Commands in total: 5
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_specification'):
from .Specification import SpecificationCls
self._specification = SpecificationCls(self._core, self._cmd_group)
return self._specification
@property
def srData(self):
"""
| Commands in total: 2
| Subgroups: 0
| Direct child commands: 2
"""
if not hasattr(self, '_srData'):
from .SrData import SrDataCls
self._srData = SrDataCls(self._core, self._cmd_group)
return self._srData
@property
def srexec(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_srexec'):
from .Srexec import SrexecCls
self._srexec = SrexecCls(self._core, self._cmd_group)
return self._srexec
@property
def srtime(self):
"""
| Commands in total: 2
| Subgroups: 1
| Direct child commands: 1
"""
if not hasattr(self, '_srtime'):
from .Srtime import SrtimeCls
self._srtime = SrtimeCls(self._core, self._cmd_group)
return self._srtime
@property
def startup(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_startup'):
from .Startup import StartupCls
self._startup = StartupCls(self._core, self._cmd_group)
return self._startup
@property
def time(self):
"""
| Commands in total: 12
| Subgroups: 3
| Direct child commands: 4
"""
if not hasattr(self, '_time'):
from .Time import TimeCls
self._time = TimeCls(self._core, self._cmd_group)
return self._time
@property
def ulock(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_ulock'):
from .Ulock import UlockCls
self._ulock = UlockCls(self._core, self._cmd_group)
return self._ulock
@property
def undo(self):
"""
| Commands in total: 5
| Subgroups: 3
| Direct child commands: 1
"""
if not hasattr(self, '_undo'):
from .Undo import UndoCls
self._undo = UndoCls(self._core, self._cmd_group)
return self._undo
[docs]
def set_crash(self, test_scpi_generic: float) -> None:
"""
``SYSTem:CRASh`` \n
Snippet: ``driver.system.set_crash(test_scpi_generic = 1.0)`` \n
No help available
"""
param = Conversions.decimal_value_to_str(test_scpi_generic)
self._core.io.write(f'SYSTem:CRASh {param}')
[docs]
def get_did(self) -> str:
"""
``SYSTem:DID`` \n
Snippet: ``value: str = driver.system.get_did()`` \n
No help available
"""
response = self._core.io.query_str('SYSTem:DID?')
return trim_str_response(response)
[docs]
def get_dlock(self) -> bool:
"""
``SYSTem:DLOCk`` \n
Snippet: ``value: bool = driver.system.get_dlock()`` \n
Disables the manual operation over the display, including the front panel keyboard of the instrument.
:return: disp_lock_stat: 1 | ON | 0| OFF
"""
response = self._core.io.query_str('SYSTem:DLOCk?')
return Conversions.str_to_bool(response)
[docs]
def set_dlock(self, disp_lock_stat: bool) -> None:
"""
``SYSTem:DLOCk`` \n
Snippet: ``driver.system.set_dlock(disp_lock_stat = False)`` \n
Disables the manual operation over the display, including the front panel keyboard of the instrument.
:param disp_lock_stat: 1 | ON | 0| OFF
"""
param = Conversions.bool_to_str(disp_lock_stat)
self._core.io.write(f'SYSTem:DLOCk {param}')
[docs]
def set_import_py(self, filename: str) -> None:
"""
``SYSTem:IMPort`` \n
Snippet: ``driver.system.set_import_py(filename = 'abc')`` \n
No help available
"""
param = Conversions.value_to_quoted_str(filename)
self._core.io.write(f'SYSTem:IMPort {param}')
[docs]
def get_iresponse(self) -> str:
"""
``SYSTem:IRESponse`` \n
Snippet: ``value: str = driver.system.get_iresponse()`` \n
Defines the user defined identification string for ``*IDN``. Note: While working in an emulation mode, the instrument's
specific command set is disabled, i.e. the SCPI command method ``RsSmw.system.iresponse()`` is discarded.
:return: idn_response: string
"""
response = self._core.io.query_str('SYSTem:IRESponse?')
return trim_str_response(response)
[docs]
def set_iresponse(self, idn_response: str) -> None:
"""
``SYSTem:IRESponse`` \n
Snippet: ``driver.system.set_iresponse(idn_response = 'abc')`` \n
Defines the user defined identification string for ``*IDN``. Note: While working in an emulation mode, the instrument's
specific command set is disabled, i.e. the SCPI command method ``RsSmw.system.iresponse()`` is discarded.
:param idn_response: string
"""
param = Conversions.value_to_quoted_str(idn_response)
self._core.io.write(f'SYSTem:IRESponse {param}')
[docs]
def get_klock(self) -> bool:
"""
``SYSTem:KLOCk`` \n
Snippet: ``value: bool = driver.system.get_klock()`` \n
Disables the front panel keyboard of the instrument.
:return: state: 1 | ON | 0| OFF
"""
response = self._core.io.query_str('SYSTem:KLOCk?')
return Conversions.str_to_bool(response)
[docs]
def set_klock(self, state: bool) -> None:
"""
``SYSTem:KLOCk`` \n
Snippet: ``driver.system.set_klock(state = False)`` \n
Disables the front panel keyboard of the instrument.
:param state: 1 | ON | 0| OFF
"""
param = Conversions.bool_to_str(state)
self._core.io.write(f'SYSTem:KLOCk {param}')
[docs]
def get_language(self) -> str:
"""
``SYSTem:LANGuage`` \n
Snippet: ``value: str = driver.system.get_language()`` \n
Sets the remote control command set.
:return: language: string
"""
response = self._core.io.query_str('SYSTem:LANGuage?')
return trim_str_response(response)
[docs]
def set_language(self, language: str) -> None:
"""
``SYSTem:LANGuage`` \n
Snippet: ``driver.system.set_language(language = 'abc')`` \n
Sets the remote control command set.
:param language: string
"""
param = Conversions.value_to_quoted_str(language)
self._core.io.write(f'SYSTem:LANGuage {param}')
[docs]
def get_oresponse(self) -> str:
"""
``SYSTem:ORESponse`` \n
Snippet: ``value: str = driver.system.get_oresponse()`` \n
Defines the user defined response string for ``*OPT``. Note: While working in an emulation mode, the instrument's
specific command set is disabled, i.e. the SCPI command method ``RsSmw.system.oresponse()`` is discarded.
:return: oresponse: string
"""
response = self._core.io.query_str('SYSTem:ORESponse?')
return trim_str_response(response)
[docs]
def set_oresponse(self, oresponse: str) -> None:
"""
``SYSTem:ORESponse`` \n
Snippet: ``driver.system.set_oresponse(oresponse = 'abc')`` \n
Defines the user defined response string for ``*OPT``. Note: While working in an emulation mode, the instrument's
specific command set is disabled, i.e. the SCPI command method ``RsSmw.system.oresponse()`` is discarded.
:param oresponse: string
"""
param = Conversions.value_to_quoted_str(oresponse)
self._core.io.write(f'SYSTem:ORESponse {param}')
[docs]
def get_osystem(self) -> str:
"""
``SYSTem:OSYStem`` \n
Snippet: ``value: str = driver.system.get_osystem()`` \n
Queries the operating system of the instrument.
:return: oper_system: string
"""
response = self._core.io.query_str('SYSTem:OSYStem?')
return trim_str_response(response)
[docs]
def preset(self, pseudo_string: str) -> None:
"""
``SYSTem:PRESet`` \n
Snippet: ``driver.system.preset(pseudo_string = 'abc')`` \n
Triggers an instrument reset. This command has the same effect as: \n
- The [PRESET] key. However, the command does not close open GUI dialogs like the key does.
- The ``*RST`` command
For an overview of the settings affected by the preset function, see Table 'Key parameters affected by preset and
factory preset'
"""
param = Conversions.value_to_quoted_str(pseudo_string)
self._core.io.write(f'SYSTem:PRESet {param}')
[docs]
def preset_all(self, pseudo_string: str) -> None:
"""
``SYSTem:PRESet:ALL`` \n
Snippet: ``driver.system.preset_all(pseudo_string = 'abc')`` \n
No help available
"""
param = Conversions.value_to_quoted_str(pseudo_string)
self._core.io.write(f'SYSTem:PRESet:ALL {param}')
[docs]
def preset_base(self, pseudo_string: str) -> None:
"""
``SYSTem:PRESet:BASE`` \n
Snippet: ``driver.system.preset_base(pseudo_string = 'abc')`` \n
No help available
"""
param = Conversions.value_to_quoted_str(pseudo_string)
self._core.io.write(f'SYSTem:PRESet:BASE {param}')
[docs]
def recall(self, path_name: str) -> None:
"""
``SYSTem:RCL`` \n
Snippet: ``driver.system.recall(path_name = 'abc')`` \n
Selects and uploads a savrcltxt file with previously saved R&S SMW200A settings from the default or a specified directory.
:param path_name: string
"""
param = Conversions.value_to_quoted_str(path_name)
self._core.io.write(f'SYSTem:RCL {param}')
[docs]
def reset(self, pseudo_string: str) -> None:
"""
``SYSTem:RESet`` \n
Snippet: ``driver.system.reset(pseudo_string = 'abc')`` \n
No help available
"""
param = Conversions.value_to_quoted_str(pseudo_string)
self._core.io.write(f'SYSTem:RESet {param}')
[docs]
def reset_all(self, pseudo_string: str) -> None:
"""
``SYSTem:RESet:ALL`` \n
Snippet: ``driver.system.reset_all(pseudo_string = 'abc')`` \n
No help available
"""
param = Conversions.value_to_quoted_str(pseudo_string)
self._core.io.write(f'SYSTem:RESet:ALL {param}')
[docs]
def reset_base(self, pseudo_string: str) -> None:
"""
``SYSTem:RESet:BASE`` \n
Snippet: ``driver.system.reset_base(pseudo_string = 'abc')`` \n
No help available
"""
param = Conversions.value_to_quoted_str(pseudo_string)
self._core.io.write(f'SYSTem:RESet:BASE {param}')
[docs]
def save(self, path_name: str) -> None:
"""
``SYSTem:SAV`` \n
Snippet: ``driver.system.save(path_name = 'abc')`` \n
Saves the current R&S SMW200A settings in a file. To deteremine the file name and storage location, enter the directory
and file name with the command. According to the file type, the R&S SMW200A assigns the extension (savrcltxt)
automatically.
:param path_name: string
"""
param = Conversions.value_to_quoted_str(path_name)
self._core.io.write(f'SYSTem:SAV {param}')
[docs]
def get_simulation(self) -> bool:
"""
``SYSTem:SIMulation`` \n
Snippet: ``value: bool = driver.system.get_simulation()`` \n
No help available
"""
response = self._core.io.query_str('SYSTem:SIMulation?')
return Conversions.str_to_bool(response)
[docs]
def get_sr_cat(self) -> List[str]:
"""
``SYSTem:SRCat`` \n
Snippet: ``value: List[str] = driver.system.get_sr_cat()`` \n
No help available
"""
response = self._core.io.query_str('SYSTem:SRCat?')
return Conversions.str_to_str_list(response)
[docs]
def set_srestore(self, data_set: int) -> None:
"""
``SYSTem:SREStore`` \n
Snippet: ``driver.system.set_srestore(data_set = 1)`` \n
No help available
"""
param = Conversions.decimal_value_to_str(data_set)
self._core.io.write(f'SYSTem:SREStore {param}')
# noinspection PyTypeChecker
[docs]
def get_sr_mode(self) -> enums.RecScpiCmdMode:
"""
``SYSTem:SRMode`` \n
Snippet: ``value: enums.RecScpiCmdMode = driver.system.get_sr_mode()`` \n
No help available
"""
response = self._core.io.query_str('SYSTem:SRMode?')
return Conversions.str_to_scalar_enum(response, enums.RecScpiCmdMode)
[docs]
def set_sr_mode(self, mode: enums.RecScpiCmdMode) -> None:
"""
``SYSTem:SRMode`` \n
Snippet: ``driver.system.set_sr_mode(mode = enums.RecScpiCmdMode.AUTO)`` \n
No help available
"""
param = Conversions.enum_scalar_to_str(mode, enums.RecScpiCmdMode)
self._core.io.write(f'SYSTem:SRMode {param}')
[docs]
def get_sr_sel(self) -> str:
"""
``SYSTem:SRSel`` \n
Snippet: ``value: str = driver.system.get_sr_sel()`` \n
No help available
"""
response = self._core.io.query_str('SYSTem:SRSel?')
return trim_str_response(response)
[docs]
def set_sr_sel(self, filename: str) -> None:
"""
``SYSTem:SRSel`` \n
Snippet: ``driver.system.set_sr_sel(filename = 'abc')`` \n
No help available
"""
param = Conversions.value_to_quoted_str(filename)
self._core.io.write(f'SYSTem:SRSel {param}')
[docs]
def set_ssave(self, data_set: int) -> None:
"""
``SYSTem:SSAVe`` \n
Snippet: ``driver.system.set_ssave(data_set = 1)`` \n
No help available
"""
param = Conversions.decimal_value_to_str(data_set)
self._core.io.write(f'SYSTem:SSAVe {param}')
[docs]
def get_tzone(self) -> str:
"""
``SYSTem:TZONe`` \n
Snippet: ``value: str = driver.system.get_tzone()`` \n
No help available
"""
response = self._core.io.query_str('SYSTem:TZONe?')
return trim_str_response(response)
[docs]
def set_tzone(self, pseudo_string: str) -> None:
"""
``SYSTem:TZONe`` \n
Snippet: ``driver.system.set_tzone(pseudo_string = 'abc')`` \n
No help available
"""
param = Conversions.value_to_quoted_str(pseudo_string)
self._core.io.write(f'SYSTem:TZONe {param}')
[docs]
def get_up_time(self) -> str:
"""
``SYSTem:UPTime`` \n
Snippet: ``value: str = driver.system.get_up_time()`` \n
Queries the up time of the operating system.
:return: up_time: 'ddd.hh:mm:ss'
"""
response = self._core.io.query_str('SYSTem:UPTime?')
return trim_str_response(response)
[docs]
def get_version(self) -> str:
"""
``SYSTem:VERSion`` \n
Snippet: ``value: str = driver.system.get_version()`` \n
Queries the SCPI version the instrument's command set complies with.
:return: version: string
"""
response = self._core.io.query_str('SYSTem:VERSion?')
return trim_str_response(response)
[docs]
def set_wait(self, time_ms: int) -> None:
"""
``SYSTem:WAIT`` \n
Snippet: ``driver.system.set_wait(time_ms = 1)`` \n
Delays the execution of the subsequent remote command by the specified time. This function is useful, for example to
execute an SCPI sequence automatically but with a defined time delay between some commands. See 'How to assign actions to
the [USER] key'.
:param time_ms: integer Wait time in ms Range: 0 to 10000
"""
param = Conversions.decimal_value_to_str(time_ms)
self._core.io.write(f'SYSTem:WAIT {param}')
def clone(self) -> 'SystemCls':
"""
Clones the group by creating new object from it and its whole existing subgroups.
Also copies all the existing default Repeated Capabilities setting,
which you can change independently without affecting the original group.
"""
new_group = SystemCls(self._core, self._cmd_group.parent)
self._cmd_group.synchronize_repcaps(new_group)
return new_group