from .......Internal.Core import Core
from .......Internal.CommandsGroup import CommandsGroup
from .......Internal import Conversions
from .......Internal.StructBase import StructBase
from .......Internal.ArgStruct import ArgStruct
from ....... import enums
# noinspection PyPep8Naming,PyAttributeOutsideInit,SpellCheckingInspection
class PconfigurationCls:
"""
| Commands in total: 123
| Subgroups: 13
| Direct child commands: 86
"""
def __init__(self, core: Core, parent):
self._core = core
self._cmd_group = CommandsGroup("pconfiguration", core, parent)
@property
def acad(self):
"""
| Commands in total: 3
| Subgroups: 0
| Direct child commands: 3
"""
if not hasattr(self, '_acad'):
from .Acad import AcadCls
self._acad = AcadCls(self._core, self._cmd_group)
return self._acad
@property
def data(self):
"""
| Commands in total: 3
| Subgroups: 0
| Direct child commands: 3
"""
if not hasattr(self, '_data'):
from .Data import DataCls
self._data = DataCls(self._core, self._cmd_group)
return self._data
@property
def dcmTable(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_dcmTable'):
from .DcmTable import DcmTableCls
self._dcmTable = DcmTableCls(self._core, self._cmd_group)
return self._dcmTable
@property
def eheader(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_eheader'):
from .Eheader import EheaderCls
self._eheader = EheaderCls(self._core, self._cmd_group)
return self._eheader
@property
def ehFlags(self):
"""
| Commands in total: 7
| Subgroups: 7
| Direct child commands: 0
"""
if not hasattr(self, '_ehFlags'):
from .EhFlags import EhFlagsCls
self._ehFlags = EhFlagsCls(self._core, self._cmd_group)
return self._ehFlags
@property
def fsbit(self):
"""
| Commands in total: 1
| Subgroups: 1
| Direct child commands: 0
"""
if not hasattr(self, '_fsbit'):
from .Fsbit import FsbitCls
self._fsbit = FsbitCls(self._core, self._cmd_group)
return self._fsbit
@property
def mtsphy(self):
"""
| Commands in total: 3
| Subgroups: 3
| Direct child commands: 0
"""
if not hasattr(self, '_mtsphy'):
from .Mtsphy import MtsphyCls
self._mtsphy = MtsphyCls(self._core, self._cmd_group)
return self._mtsphy
@property
def offset(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_offset'):
from .Offset import OffsetCls
self._offset = OffsetCls(self._core, self._cmd_group)
return self._offset
@property
def phy(self):
"""
| Commands in total: 3
| Subgroups: 3
| Direct child commands: 0
"""
if not hasattr(self, '_phy'):
from .Phy import PhyCls
self._phy = PhyCls(self._core, self._cmd_group)
return self._phy
@property
def phys(self):
"""
| Commands in total: 3
| Subgroups: 3
| Direct child commands: 0
"""
if not hasattr(self, '_phys'):
from .Phys import PhysCls
self._phys = PhysCls(self._core, self._cmd_group)
return self._phys
@property
def rphys(self):
"""
| Commands in total: 3
| Subgroups: 3
| Direct child commands: 0
"""
if not hasattr(self, '_rphys'):
from .Rphys import RphysCls
self._rphys = RphysCls(self._core, self._cmd_group)
return self._rphys
@property
def stmPhy(self):
"""
| Commands in total: 3
| Subgroups: 3
| Direct child commands: 0
"""
if not hasattr(self, '_stmPhy'):
from .StmPhy import StmPhyCls
self._stmPhy = StmPhyCls(self._core, self._cmd_group)
return self._stmPhy
@property
def tphys(self):
"""
| Commands in total: 3
| Subgroups: 3
| Direct child commands: 0
"""
if not hasattr(self, '_tphys'):
from .Tphys import TphysCls
self._tphys = TphysCls(self._core, self._cmd_group)
return self._tphys
# noinspection PyTypeChecker
[docs]
class AaddressStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Aaddress: str: numeric
- Bitcount: int: integer Range: 32 to 32
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Aaddress'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Aaddress: str=None
self.Bitcount: int=None
[docs]
def get_aaddress(self) -> AaddressStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:AADDress`` \n
Snippet: ``value: AaddressStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_aaddress()`` \n
Sets the access address of the link layer connection (32-bit string) .
:return: structure: for return value, see the help for AaddressStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:AADDress?', self.__class__.AaddressStruct())
# noinspection PyTypeChecker
[docs]
class AcAssignedStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Ac_Assigned: str: No parameter help available
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Ac_Assigned'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Ac_Assigned: str=None
self.Bitcount: int=None
[docs]
def get_ac_assigned(self) -> AcAssignedStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ACASsigned`` \n
Snippet: ``value: AcAssignedStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_ac_assigned()`` \n
Sets the advertiser's device address. For advertising channel packets, the format of the device address differs,
depending on the selected address type.
Selects the clock source: \n
- 'Public Address Types' The public address is given from the registration authority IEEE and is composed of:
\n
- LSB: 24 bits = company_assigned
- MSB: 24 bits = company_id
- 'Random Address Type' is a 48-bits random static device address.
- 'Private Address Type' A private address is optional and composed of:
\n
- LSB: 24 bits = hash
- MSB: 24 bits = random
:return: structure: for return value, see the help for AcAssignedStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ACASsigned?', self.__class__.AcAssignedStruct())
# noinspection PyTypeChecker
[docs]
class AcidStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Acid: str: No parameter help available
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Acid'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Acid: str=None
self.Bitcount: int=None
[docs]
def get_acid(self) -> AcidStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ACID`` \n
Snippet: ``value: AcidStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_acid()`` \n
Sets the advertiser's device address. For advertising channel packets, the format of the device address differs,
depending on the selected address type.
Selects the clock source: \n
- 'Public Address Types' The public address is given from the registration authority IEEE and is composed of:
\n
- LSB: 24 bits = company_assigned
- MSB: 24 bits = company_id
- 'Random Address Type' is a 48-bits random static device address.
- 'Private Address Type' A private address is optional and composed of:
\n
- LSB: 24 bits = hash
- MSB: 24 bits = random
:return: structure: for return value, see the help for AcidStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ACID?', self.__class__.AcidStruct())
# noinspection PyTypeChecker
[docs]
class AdidStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Adid: str: numeric
- Bitcount: int: integer Range: 12 to 12
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Adid'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Adid: str=None
self.Bitcount: int=None
[docs]
def get_adid(self) -> AdidStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ADID`` \n
Snippet: ``value: AdidStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_adid()`` \n
Specifies 'Advertising Data ID' in hexadecimal format to be signaled within an extended header.
:return: structure: for return value, see the help for AdidStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ADID?', self.__class__.AdidStruct())
# noinspection PyTypeChecker
[docs]
class AlapStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Lap: str: numeric
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Lap'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Lap: str=None
self.Bitcount: int=None
[docs]
def get_alap(self) -> AlapStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ALAP`` \n
Snippet: ``value: AlapStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_alap()`` \n
Sets the lower address part (LAP) of Bluetooth device address. Commands for the advertising ..:ALAP, initiating ..:ILAP,
scanning ..:SLAP PDUs of advertising channel type are provided. In addition, a command is provided for scanner's or
initiator's target device address to which the advertisement is directed ..:TLAP.
:return: structure: for return value, see the help for AlapStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ALAP?', self.__class__.AlapStruct())
[docs]
def get_alength(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ALENgth`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_alength()`` \n
Specifies the length of ACAD data pattern.
:return: length: integer Range: 0 to 62
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ALENgth?')
return Conversions.str_to_int(response)
# noinspection PyTypeChecker
[docs]
def get_amode(self) -> enums.BtoAdvMode:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:AMODe`` \n
Snippet: ``value: enums.BtoAdvMode = driver.source.bb.btooth.econfiguration.pconfiguration.get_amode()`` \n
Indicates the mode of the advertisement.
:return: amode: NCNS | CNS | NCS NCNS: Non-connectable, non-scannable CNS: Connectable, non-scannable NCS: Non-connectable, non-scannable
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:AMODe?')
return Conversions.str_to_scalar_enum(response, enums.BtoAdvMode)
# noinspection PyTypeChecker
[docs]
class AnuapStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Nap_Uap: str: numeric
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Nap_Uap'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Nap_Uap: str=None
self.Bitcount: int=None
[docs]
def get_anuap(self) -> AnuapStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ANUap`` \n
Snippet: ``value: AnuapStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_anuap()`` \n
Sets the non-significant address part (NAP) and upper address part (UAP) of Bluetooth device address. Commands for the
advertising ..:ANUap, initiating ..:INUap, and scanning ..:SNUap PDUs of advertising channel type are provided.
In addition, a command is provided for scanner's or initiator's target device address to which the advertisement is
directed ..:TNUap.
:return: structure: for return value, see the help for AnuapStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ANUap?', self.__class__.AnuapStruct())
[docs]
def get_aoffset(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:AOFFset`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_aoffset()`` \n
Specifies the time from the start of the packet containing the AuxPtr field to the approximate start of the auxiliary
packet. The offset is determined by multiplying the value by the unit,
see method ``RsSmw.source.bb.btooth.econfiguration.pconfiguration.ao_units()``
:return: aoffset: float Range: 0 to 245.7 or 246 to 2457 depending on offset unit
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:AOFFset?')
return Conversions.str_to_float(response)
# noinspection PyTypeChecker
[docs]
def get_ao_units(self) -> enums.BtoOffsUnit:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:AOUNits`` \n
Snippet: ``value: enums.BtoOffsUnit = driver.source.bb.btooth.econfiguration.pconfiguration.get_ao_units()`` \n
Indicates the units used by the 'Aux Offset' parameter,
see method ``RsSmw.source.bb.btooth.econfiguration.pconfiguration.aoffset()``
:return: unit: U30 | U300 U30: 30 us U300: 300 us
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:AOUNits?')
return Conversions.str_to_scalar_enum(response, enums.BtoOffsUnit)
# noinspection PyTypeChecker
[docs]
def get_aphy(self) -> enums.BtoPackFormat:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:APHY`` \n
Snippet: ``value: enums.BtoPackFormat = driver.source.bb.btooth.econfiguration.pconfiguration.get_aphy()`` \n
Sets the physical layer (PHY) to transmit the auxiliary packet.
:return: aphy: L1M | L2M | LCOD | L2M2B For a description, see method ``RsSmw.source.bb.btooth.pformat()`` .
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:APHY?')
return Conversions.str_to_scalar_enum(response, enums.BtoPackFormat)
# noinspection PyTypeChecker
[docs]
class AsidStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Asid: str: numeric
- Bitcount: int: integer Range: 4 to 4
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Asid'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Asid: str=None
self.Bitcount: int=None
[docs]
def get_asid(self) -> AsidStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ASID`` \n
Snippet: ``value: AsidStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_asid()`` \n
Specifies the 'Advertising Set ID' in hexadecimal format to be signaled within an extended header.
:return: structure: for return value, see the help for AsidStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ASID?', self.__class__.AsidStruct())
# noinspection PyTypeChecker
[docs]
def get_atype(self) -> enums.BtoUlpAddrType:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ATYPe`` \n
Snippet: ``value: enums.BtoUlpAddrType = driver.source.bb.btooth.econfiguration.pconfiguration.get_atype()`` \n
Sets the address type in the payload of Bluetooth LE LL_PERIODIC_SYNC_IND packets.
:return: atype: PUBLic | RANDom
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ATYPe?')
return Conversions.str_to_scalar_enum(response, enums.BtoUlpAddrType)
# noinspection PyTypeChecker
[docs]
def get_caccuracy(self) -> enums.BtoClkAcc:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CACCuracy`` \n
Snippet: ``value: enums.BtoClkAcc = driver.source.bb.btooth.econfiguration.pconfiguration.get_caccuracy()`` \n
Specifies the clock accuracy of the advertiser used between the packet containing this data and the auxiliary packet.
:return: caccuracy: T500 | T50 T500: 51 ppm to 500 ppm T50: 0 ppm to 50 ppm
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CACCuracy?')
return Conversions.str_to_scalar_enum(response, enums.BtoClkAcc)
[docs]
def get_ce_count(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CECount`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_ce_count()`` \n
Specifies the connection event count in the CtrData field of the LL_PERIODIC_SYNC_IND control data PDU.
:return: ce_count: integer Range: 0 to 65535
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CECount?')
return Conversions.str_to_int(response)
# noinspection PyTypeChecker
[docs]
class CidStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Cid: str: numeric
- Bitcount: int: integer Range: 16 to 16
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Cid'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Cid: str=None
self.Bitcount: int=None
[docs]
def get_cid(self) -> CidStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CID`` \n
Snippet: ``value: CidStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_cid()`` \n
Sets the company identifier of the manufacturer of the Bluetooth Controller. A 16 bit value is set. Note: This parameter
is relevant for data frame configuration and for the packet type LL_VERSION_IND.
:return: structure: for return value, see the help for CidStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CID?', self.__class__.CidStruct())
[docs]
def get_cinstant(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CINStant`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_cinstant()`` \n
Sets a connection instant for indicating the connection event at which the new connection parameters are taken in use.
:return: cinstant: integer Range: 1 to depends on sequence length
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CINStant?')
return Conversions.str_to_int(response)
[docs]
def get_cinterval(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CINTerval`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_cinterval()`` \n
Sets the time interval between the start points of two consecutive connection events for the packet type DATA and all
CONTROL_DATA packet types. Command sets the values in ms. Query returns values in s.
:return: cinterval: float Range: 7.5E-3 s to depends on oversampling , Unit: ms
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CINTerval?')
return Conversions.str_to_float(response)
# noinspection PyTypeChecker
[docs]
class CiValueStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Ci_Value: str: numeric
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Ci_Value'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Ci_Value: str=None
self.Bitcount: int=None
[docs]
def get_ci_value(self) -> CiValueStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CIValue`` \n
Snippet: ``value: CiValueStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_ci_value()`` \n
Sets the initialization value for the CRC (Cyclic Redundancy Check, 24 bits) calculation. A packet has been received
correctly, when it has passed the CRC check.
:return: structure: for return value, see the help for CiValueStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CIValue?', self.__class__.CiValueStruct())
[docs]
def get_cpresent(self) -> bool:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CPResent`` \n
Snippet: ``value: bool = driver.source.bb.btooth.econfiguration.pconfiguration.get_cpresent()`` \n
Activates the CTEInfo field in the header of Bluetooth LE data packets in the LE uncoded PHY.
:return: state: 1 | ON | 0| OFF
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CPResent?')
return Conversions.str_to_bool(response)
# noinspection PyTypeChecker
[docs]
def get_cselection(self) -> enums.BtoChSel:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CSELection`` \n
Snippet: ``value: enums.BtoChSel = driver.source.bb.btooth.econfiguration.pconfiguration.get_cselection()`` \n
Specifies the algorithm of channel selection.
:return: cselection: CS1 | CS2 Algorithm #1 or algorithm #2
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CSELection?')
return Conversions.str_to_scalar_enum(response, enums.BtoChSel)
[docs]
def get_ctime(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CTIMe`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_ctime()`` \n
Sets the CTETime comprising the length of constant tone extension field of the Bluetooth LE PDU.
:return: ctime: float Range: 16E-6 to 160E-6
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CTIMe?')
return Conversions.str_to_float(response)
# noinspection PyTypeChecker
[docs]
def get_ct_req(self) -> enums.BtoCteType:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CTReq`` \n
Snippet: ``value: enums.BtoCteType = driver.source.bb.btooth.econfiguration.pconfiguration.get_ct_req()`` \n
Sets the CTE type in the CTETypeReq field of the CtrData field of the LL_CTE_REQ PDU.
:return: ct_req: AOD1 | AOA | AOD2 AOA AoA Constant Tone Extension AOD1 AoD Constant Tone Extension with 1 us time slots AOD2 AoD Constant Tone Extension with 2 us time slots
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CTReq?')
return Conversions.str_to_scalar_enum(response, enums.BtoCteType)
# noinspection PyTypeChecker
[docs]
def get_ctype(self) -> enums.BtoCteType:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:CTYPe`` \n
Snippet: ``value: enums.BtoCteType = driver.source.bb.btooth.econfiguration.pconfiguration.get_ctype()`` \n
Sets the type of constant tone extension. The type specifies the CTE AoA/AoD method and for AoD the length of the
switching and I/Q sampling slots.
:return: ctype: AOD1 | AOA | AOD2 AOA AoA Constant Tone Extension AOD1 AoD Constant Tone Extension with 1 us time slots AOD2 AoD Constant Tone Extension with 2 us time slots
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:CTYPe?')
return Conversions.str_to_scalar_enum(response, enums.BtoCteType)
[docs]
def get_dlength(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:DLENgth`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_dlength()`` \n
Sets the payload data length in bytes.
:return: dlength: integer Range: 0 to 255 (advertiser) or 251 (data)
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:DLENgth?')
return Conversions.str_to_int(response)
[docs]
def get_dwhitening(self) -> bool:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:DWHitening`` \n
Snippet: ``value: bool = driver.source.bb.btooth.econfiguration.pconfiguration.get_dwhitening()`` \n
Activates or deactivates the Data Whitening. Evenly distributed white noise is ideal for the transmission and real data
can be forced to look similar to white noise with different methods called Data Whitening. Applied to the PDU and CRC
fields of all packet types, whitening is used to avoid long equal seqeunces in the data bit stream.
:return: dwhitening: 1 | ON | 0| OFF
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:DWHitening?')
return Conversions.str_to_bool(response)
# noinspection PyTypeChecker
[docs]
class EcodeStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Ecode: str: numeric
- Bitcount: int: integer Range: 8 to 8
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Ecode'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Ecode: str=None
self.Bitcount: int=None
[docs]
def get_ecode(self) -> EcodeStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ECODe`` \n
Snippet: ``value: EcodeStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_ecode()`` \n
Sets the error code value to inform the remote device why the connection is about to be terminated in case of
LL_TERMINATE_IND packet. On the other hand, this parameter for LL_REJECT_IND packet is used for the reason a request was
rejected. A 8 bit value is set. Note: This parameter is relevant for data frame configuration and the packet type:
Selects the clock source: \n
- LL_TERMINATE_IND
- LL_REJECT_IND
:return: structure: for return value, see the help for EcodeStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ECODe?', self.__class__.EcodeStruct())
[docs]
def get_ecounter(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ECOunter`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_ecounter()`` \n
Counts the AUX_SYNC_IND packets that the SyncInfo field describes.
:return: ecounter: integer Range: 0 to 65535
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ECOunter?')
return Conversions.str_to_int(response)
# noinspection PyTypeChecker
[docs]
class EdiversifierStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Ediversifier: str: numeric
- Bitcount: int: integer Range: 16 to 16
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Ediversifier'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Ediversifier: str=None
self.Bitcount: int=None
[docs]
def get_ediversifier(self) -> EdiversifierStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:EDIVersifier`` \n
Snippet: ``value: EdiversifierStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_ediversifier()`` \n
Sets the encrypted diversifier of the Central for device identification. The parameter is an initialization vector
provided by the host in the HCI_ULP_Start_Encryption command.
:return: structure: for return value, see the help for EdiversifierStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:EDIVersifier?', self.__class__.EdiversifierStruct())
[docs]
def get_fs_length(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:FSLength`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_fs_length()`` \n
Enables that the feature set length is indicated.
:return: fs_length: integer Range: 1 to 26
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:FSLength?')
return Conversions.str_to_int(response)
[docs]
def get_hlength(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:HLENgth`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_hlength()`` \n
Requires data event and advertising frame configuration with the packet type CONNECT_IND. Sets the difference from the
current channel to the next channel. The Central and Peripherals determine the data channel in use for every connection
event from the channel map. Hop_length is set for the LL connection and communicated in the CONNECT_IND and
LL_CHANNEL_MAP_IND packets.
:return: hlength: integer Range: 5 to 16
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:HLENgth?')
return Conversions.str_to_int(response)
# noinspection PyTypeChecker
[docs]
class IcAssignedStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Ic_Assigned: str: No parameter help available
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Ic_Assigned'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Ic_Assigned: str=None
self.Bitcount: int=None
[docs]
def get_ic_assigned(self) -> IcAssignedStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ICASsigned`` \n
Snippet: ``value: IcAssignedStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_ic_assigned()`` \n
Sets the advertiser's device address. For advertising channel packets, the format of the device address differs,
depending on the selected address type.
Selects the clock source: \n
- 'Public Address Types' The public address is given from the registration authority IEEE and is composed of:
\n
- LSB: 24 bits = company_assigned
- MSB: 24 bits = company_id
- 'Random Address Type' is a 48-bits random static device address.
- 'Private Address Type' A private address is optional and composed of:
\n
- LSB: 24 bits = hash
- MSB: 24 bits = random
:return: structure: for return value, see the help for IcAssignedStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ICASsigned?', self.__class__.IcAssignedStruct())
# noinspection PyTypeChecker
[docs]
class IcidStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Icid: str: numeric
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Icid'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Icid: str=None
self.Bitcount: int=None
[docs]
def get_icid(self) -> IcidStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ICID`` \n
Snippet: ``value: IcidStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_icid()`` \n
Sets the advertiser's device address. For advertising channel packets, the format of the device address differs,
depending on the selected address type.
Selects the clock source: \n
- 'Public Address Types' The public address is given from the registration authority IEEE and is composed of:
\n
- LSB: 24 bits = company_assigned
- MSB: 24 bits = company_id
- 'Random Address Type' is a 48-bits random static device address.
- 'Private Address Type' A private address is optional and composed of:
\n
- LSB: 24 bits = hash
- MSB: 24 bits = random
:return: structure: for return value, see the help for IcidStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ICID?', self.__class__.IcidStruct())
# noinspection PyTypeChecker
[docs]
class IdStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Idn: str: numeric
- Bitcount: int: integer Range: 16 to 16
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Idn'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Idn: str=None
self.Bitcount: int=None
[docs]
def get_id(self) -> IdStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ID`` \n
Snippet: ``value: IdStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_id()`` \n
Specifies the ID in the CtrData field of the LL_PERIODIC_SYNC_IND PDU.
:return: structure: for return value, see the help for IdStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ID?', self.__class__.IdStruct())
# noinspection PyTypeChecker
[docs]
class IlapStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Lap: str: numeric
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Lap'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Lap: str=None
self.Bitcount: int=None
[docs]
def get_ilap(self) -> IlapStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ILAP`` \n
Snippet: ``value: IlapStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_ilap()`` \n
Sets the lower address part (LAP) of Bluetooth device address. Commands for the advertising ..:ALAP, initiating ..:ILAP,
scanning ..:SLAP PDUs of advertising channel type are provided. In addition, a command is provided for scanner's or
initiator's target device address to which the advertisement is directed ..:TLAP.
:return: structure: for return value, see the help for IlapStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ILAP?', self.__class__.IlapStruct())
# noinspection PyTypeChecker
[docs]
class InuapStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Nap_Uap: str: numeric
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Nap_Uap'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Nap_Uap: str=None
self.Bitcount: int=None
[docs]
def get_inuap(self) -> InuapStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:INUap`` \n
Snippet: ``value: InuapStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_inuap()`` \n
Sets the non-significant address part (NAP) and upper address part (UAP) of Bluetooth device address. Commands for the
advertising ..:ANUap, initiating ..:INUap, and scanning ..:SNUap PDUs of advertising channel type are provided.
In addition, a command is provided for scanner's or initiator's target device address to which the advertisement is
directed ..:TNUap.
:return: structure: for return value, see the help for InuapStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:INUap?', self.__class__.InuapStruct())
[docs]
def get_lc_timeout(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:LCTimeout`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_lc_timeout()`` \n
Defines the maximum time between two correctly received Bluetooth LE packets in the LL connection before the connection
is considered lost for the packet type CONNECT_IND. Command sets the values in ms. Query returns values in s.
:return: lc_timeout: float Range: 100E-3 s to 32000E-3 s , Unit: ms
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:LCTimeout?')
return Conversions.str_to_float(response)
[docs]
def get_lpe_counter(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:LPECounter`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_lpe_counter()`` \n
Specifies the lastPaEventCounter field in the CtrData field of the LL_PERIODIC_SYNC_IND PDU.
:return: lpe_counter: integer Range: 0 to 65535
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:LPECounter?')
return Conversions.str_to_int(response)
[docs]
def get_mcl_req(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:MCLReq`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_mcl_req()`` \n
Specifies the minimum CTE length in the CtrData field of the LL_CTE_Req PDU.
:return: mcl_req: float Range: 16E-6 to 160E-6
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:MCLReq?')
return Conversions.str_to_float(response)
# noinspection PyTypeChecker
[docs]
class MiVectorStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Mi_Vector: str: No parameter help available
- Bitcount: int: integer Range: 32 to 32
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Mi_Vector'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Mi_Vector: str=None
self.Bitcount: int=None
[docs]
def get_mi_vector(self) -> MiVectorStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:MIVector`` \n
Snippet: ``value: MiVectorStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_mi_vector()`` \n
Sets the portion of Central or the portion of the Peripheral of the initialization vector (IVm/IVs) .
:return: structure: for return value, see the help for MiVectorStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:MIVector?', self.__class__.MiVectorStruct())
[docs]
def get_mn_interval(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:MNINterval`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_mn_interval()`` \n
Specifies the minimum allowed connection interval. Command sets the values in ms. Query returns values in s.
:return: mn_interval: float Range: 7.5E-3 s to depending on Max. Interval
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:MNINterval?')
return Conversions.str_to_float(response)
[docs]
def get_mr_octets(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:MROCtets`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_mr_octets()`` \n
Specifies the maximum allowed payload length of a packet to be received (..:MROCtets) or transmitted (..:MTOCtets) .
Information is signaled via LL_LENGTH_REQ and LL_LENGTH_RSP.
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:MROCtets?')
return Conversions.str_to_int(response)
[docs]
def get_mr_time(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:MRTime`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_mr_time()`` \n
Specifies the maximum allowed time to receive (..:MRTime) or transmit (..:MTTime) a packet. Information is signaled via
LL_LENGTH_REQ and LL_LENGTH_RSP.
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:MRTime?')
return Conversions.str_to_float(response)
# noinspection PyTypeChecker
[docs]
class MskdStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Mskd: str: No parameter help available
- Bitcount: int: integer Range: 64 to 64
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Mskd'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Mskd: str=None
self.Bitcount: int=None
[docs]
def get_mskd(self) -> MskdStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:MSKD`` \n
Snippet: ``value: MskdStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_mskd()`` \n
Sets the portion of Central or the portion of the Peripheral of the session key diversifier (SKDm/SKDs) .
:return: structure: for return value, see the help for MskdStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:MSKD?', self.__class__.MskdStruct())
[docs]
def get_mt_octets(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:MTOCtets`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_mt_octets()`` \n
Specifies the maximum allowed payload length of a packet to be received (..:MROCtets) or transmitted (..:MTOCtets) .
Information is signaled via LL_LENGTH_REQ and LL_LENGTH_RSP.
:return: mt_octets: integer Range: 27 to 251
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:MTOCtets?')
return Conversions.str_to_int(response)
[docs]
def get_mt_time(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:MTTime`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_mt_time()`` \n
Specifies the maximum allowed time to receive (..:MRTime) or transmit (..:MTTime) a packet. Information is signaled via
LL_LENGTH_REQ and LL_LENGTH_RSP.
:return: mt_time: float Range: 0.328E-3 to 17.04E-3
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:MTTime?')
return Conversions.str_to_float(response)
[docs]
def get_mu_channels(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:MUCHannels`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_mu_channels()`` \n
Specifies the minimum number of channels to be used on the specified PHYs,
see method ``RsSmw.source.bb.btooth.econfiguration.pconfiguration.phys.l1M.state.get()`` etc.
:return: mu_channels: integer Range: 2 to 37
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:MUCHannels?')
return Conversions.str_to_int(response)
[docs]
def get_mx_interval(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:MXINterval`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_mx_interval()`` \n
Specifies the maximum allowed connection interval. Command sets the values in ms. Query returns values in s.
:return: minterval: float Range: 7.5E-3 s to 4000E-3 s
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:MXINterval?')
return Conversions.str_to_float(response)
[docs]
def get_nc_interval(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:NCINterval`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_nc_interval()`` \n
Sets the time interval new connection events for the packet types CONNECT_IND and LL_CONNECTION_UPDATE_IND. Command sets
the values in ms. Query returns values in s.
:return: nc_interval: float Range: 7.5E-3 s to depends on oversampling , Unit: ms
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:NCINterval?')
return Conversions.str_to_float(response)
[docs]
def get_nlc_timeout(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:NLCTimeout`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_nlc_timeout()`` \n
Defines the maximum time between two correctly received Bluetooth LE packets in the LL connection before the connection
is considered lost only for the packet type LL_CONNECTION_UPDATE_IND. Command sets the values in ms. Query returns values
in s.
:return: nlc_timeout: float Range: 100E-3 s to 32000E-3 s , Unit: ms
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:NLCTimeout?')
return Conversions.str_to_float(response)
[docs]
def get_ns_latency(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:NSLatency`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_ns_latency()`` \n
Requires a data event and advertising frame configuration with the packet type LL_CONNECTION_UPDATE_IND. Sets the number
of consecutive connection events the Peripheral can ignore for asymmetric link layer connections.
:return: ns_latency: integer Range: 0 to depends on LL connection timeout and connection event interval
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:NSLatency?')
return Conversions.str_to_int(response)
[docs]
def get_ns_value(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:NSValue`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_ns_value()`` \n
Sets the start value of the next expected packet from the same device in the LL connection ('N'ext'E'xpected
'S'equence'N'umber) . This parameter can be set in the first event. From the second event this field is not indicated.
:return: ns_value: integer Range: 0 to 1
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:NSValue?')
return Conversions.str_to_int(response)
[docs]
def get_nw_offset(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:NWOFfset`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_nw_offset()`` \n
Sets the start point of the transmit window for data event and advertising frame configuration with the packet type
LL_CONNECTION_UPDATE_IND. Command sets the values in ms. Query returns values in s.
:return: nw_offset: float Range: 0 s to depends on connection event interval , Unit: ms
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:NWOFfset?')
return Conversions.str_to_float(response)
[docs]
def get_nw_size(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:NWSize`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_nw_size()`` \n
Sets the size of the transmit window, regarding to the start point for data event and advertising frame configuration
with the packet type LL_CONNECTION_UPDATE_IND.
:return: nw_size: float Range: 1.25E-3 to depends on connection event interval
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:NWSize?')
return Conversions.str_to_float(response)
[docs]
def get_oadjust(self) -> bool:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:OADJust`` \n
Snippet: ``value: bool = driver.source.bb.btooth.econfiguration.pconfiguration.get_oadjust()`` \n
Adjusts the 'Sync Packet Offset' automatically to the next value, which is a multiple of the ''Offset Units'.
:return: state: 1 | ON | 0| OFF
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:OADJust?')
return Conversions.str_to_bool(response)
[docs]
def get_pa_interval(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:PAINterval`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_pa_interval()`` \n
Sets the time interval between the start of two AUX_SYNC_IND PDUs from the same advertising set. Command sets the values
in ms. Query returns values in s.
:return: interval: float Range: 7.5E-3 s to depending on oversampling , Unit: ms
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:PAINterval?')
return Conversions.str_to_float(response)
[docs]
def get_pperiodicity(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:PPERiodicity`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_pperiodicity()`` \n
Specifies a value the connection interval is preferred to be a multiple of.
:return: pperiodicity: float Range: 0 to depends on Max. Interval
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:PPERiodicity?')
return Conversions.str_to_float(response)
# noinspection PyTypeChecker
[docs]
def get_ra_type(self) -> enums.BtoUlpAddrType:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:RATYpe`` \n
Snippet: ``value: enums.BtoUlpAddrType = driver.source.bb.btooth.econfiguration.pconfiguration.get_ra_type()`` \n
Selects the address type of the controller device. Depending on the Bluetooth controller role either Tx or Rx or both
address types are assigned. Subdivided into private and random, a Bluetooth LE device address consits of 48 bits.
The format of the device address differs depending on the selected address type.
:return: ra_type: PUBLic | RANDom PUBlic Allocates a unique 48 bit address to each Bluetooth LE device. The public address is given from the registration authority IEEE. RANDom Allocates a 48-bit address to each Bluetooth LE device. A random address is optional.
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:RATYpe?')
return Conversions.str_to_scalar_enum(response, enums.BtoUlpAddrType)
[docs]
def get_rce_count(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:RCECount`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_rce_count()`` \n
Specifies the ReferenceConnEventCount field of LL_CONNECTION_PARAM_REQ.
:return: rce_count: integer Range: 0 to 65535
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:RCECount?')
return Conversions.str_to_int(response)
# noinspection PyTypeChecker
[docs]
class RopCodeStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Rop_Code: str: numeric
- Bitcount: int: integer Range: 8 to 8
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Rop_Code'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Rop_Code: str=None
self.Bitcount: int=None
[docs]
def get_rop_code(self) -> RopCodeStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:ROPCode`` \n
Snippet: ``value: RopCodeStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_rop_code()`` \n
Specifies the Opcode of rejected LL control PDU. information is signaled via LL_REJECT_EXT_IND.
:return: structure: for return value, see the help for RopCodeStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:ROPCode?', self.__class__.RopCodeStruct())
# noinspection PyTypeChecker
[docs]
class RvectorStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Rvector: str: numeric
- Bitcount: int: integer Range: 64 to 64
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Rvector'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Rvector: str=None
self.Bitcount: int=None
[docs]
def get_rvector(self) -> RvectorStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:RVECtor`` \n
Snippet: ``value: RvectorStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_rvector()`` \n
Sets the random vector of the Central for device identification. The parameter is an initialization vector provided by
the Host in the HCI_ULP_Start_Encryption command.
:return: structure: for return value, see the help for RvectorStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:RVECtor?', self.__class__.RvectorStruct())
# noinspection PyTypeChecker
[docs]
def get_sc_accuracy(self) -> enums.BtoSlpClckAccrcy:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SCACcuracy`` \n
Snippet: ``value: enums.BtoSlpClckAccrcy = driver.source.bb.btooth.econfiguration.pconfiguration.get_sc_accuracy()`` \n
Defines the clock accuracy of the Central with specified encoding. This parameter is used by the Peripheral to determine
required listening windows in the LL connection. It is a controller design parameter known by the bluetooth controller.
:return: sc_accuracy: SCA0 | SCA1 | SCA2 | SCA3 | SCA4 | SCA5 | SCA6 | SCA7
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SCACcuracy?')
return Conversions.str_to_scalar_enum(response, enums.BtoSlpClckAccrcy)
# noinspection PyTypeChecker
[docs]
class ScAssignedStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Sc_Assigned: str: No parameter help available
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Sc_Assigned'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Sc_Assigned: str=None
self.Bitcount: int=None
[docs]
def get_sc_assigned(self) -> ScAssignedStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SCASsigned`` \n
Snippet: ``value: ScAssignedStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_sc_assigned()`` \n
Sets the advertiser's device address. For advertising channel packets, the format of the device address differs,
depending on the selected address type.
Selects the clock source: \n
- 'Public Address Types' The public address is given from the registration authority IEEE and is composed of:
\n
- LSB: 24 bits = company_assigned
- MSB: 24 bits = company_id
- 'Random Address Type' is a 48-bits random static device address.
- 'Private Address Type' A private address is optional and composed of:
\n
- LSB: 24 bits = hash
- MSB: 24 bits = random
:return: structure: for return value, see the help for ScAssignedStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SCASsigned?', self.__class__.ScAssignedStruct())
[docs]
def get_sce_counter(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SCECounter`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_sce_counter()`` \n
No help available
:return: sce_counter: integer Range: 0 to 65535
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SCECounter?')
return Conversions.str_to_int(response)
# noinspection PyTypeChecker
[docs]
class ScidStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Scid: str: No parameter help available
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Scid'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Scid: str=None
self.Bitcount: int=None
[docs]
def get_scid(self) -> ScidStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SCID`` \n
Snippet: ``value: ScidStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_scid()`` \n
Sets the advertiser's device address. For advertising channel packets, the format of the device address differs,
depending on the selected address type.
Selects the clock source: \n
- 'Public Address Types' The public address is given from the registration authority IEEE and is composed of:
\n
- LSB: 24 bits = company_assigned
- MSB: 24 bits = company_id
- 'Random Address Type' is a 48-bits random static device address.
- 'Private Address Type' A private address is optional and composed of:
\n
- LSB: 24 bits = hash
- MSB: 24 bits = random
:return: structure: for return value, see the help for ScidStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SCID?', self.__class__.ScidStruct())
# noinspection PyTypeChecker
[docs]
class SidStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Sid: str: numeric
- Bitcount: int: integer Range: 4 to 4
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Sid'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Sid: str=None
self.Bitcount: int=None
[docs]
def get_sid(self) -> SidStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SID`` \n
Snippet: ``value: SidStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_sid()`` \n
Specifies the SID in the CtrData field of the LL_PERIODIC_SYNC_IND.
:return: structure: for return value, see the help for SidStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SID?', self.__class__.SidStruct())
# noinspection PyTypeChecker
[docs]
class SiVectorStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Si_Vector: str: numeric
- Bitcount: int: integer Range: 32 to 32
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Si_Vector'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Si_Vector: str=None
self.Bitcount: int=None
[docs]
def get_si_vector(self) -> SiVectorStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SIVector`` \n
Snippet: ``value: SiVectorStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_si_vector()`` \n
Sets the portion of Central or the portion of the Peripheral of the initialization vector (IVm/IVs) .
:return: structure: for return value, see the help for SiVectorStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SIVector?', self.__class__.SiVectorStruct())
# noinspection PyTypeChecker
[docs]
class SlapStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Lap: str: numeric
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Lap'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Lap: str=None
self.Bitcount: int=None
[docs]
def get_slap(self) -> SlapStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SLAP`` \n
Snippet: ``value: SlapStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_slap()`` \n
Sets the lower address part (LAP) of Bluetooth device address. Commands for the advertising ..:ALAP, initiating ..:ILAP,
scanning ..:SLAP PDUs of advertising channel type are provided. In addition, a command is provided for scanner's or
initiator's target device address to which the advertisement is directed ..:TLAP.
:return: structure: for return value, see the help for SlapStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SLAP?', self.__class__.SlapStruct())
[docs]
def get_slatency(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SLATency`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_slatency()`` \n
Requires data event and advertising frame configuration with the packet type CONNECT_IND. Sets the number of consecutive
connection events the Peripheral can ignore for asymmetric link layer connections.
:return: slatency: integer Range: 0 to depends on LL connection timeout and connection event interval
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SLATency?')
return Conversions.str_to_int(response)
# noinspection PyTypeChecker
[docs]
class SnuapStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Nap_Uap: str: numeric
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Nap_Uap'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Nap_Uap: str=None
self.Bitcount: int=None
[docs]
def get_snuap(self) -> SnuapStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SNUap`` \n
Snippet: ``value: SnuapStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_snuap()`` \n
Sets the non-significant address part (NAP) and upper address part (UAP) of Bluetooth device address. Commands for the
advertising ..:ANUap, initiating ..:INUap, and scanning ..:SNUap PDUs of advertising channel type are provided.
In addition, a command is provided for scanner's or initiator's target device address to which the advertisement is
directed ..:TNUap.
:return: structure: for return value, see the help for SnuapStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SNUap?', self.__class__.SnuapStruct())
# noinspection PyTypeChecker
[docs]
def get_sounits(self) -> enums.BtoOffsUnit:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SOUNits`` \n
Snippet: ``value: enums.BtoOffsUnit = driver.source.bb.btooth.econfiguration.pconfiguration.get_sounits()`` \n
Indicates the units used by the 'Sync Packet Offset' parameter,
see method ``RsSmw.source.bb.btooth.econfiguration.pconfiguration.sp_offset()``
:return: unit: U30 | U300 U30 30 us U300 300 us
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SOUNits?')
return Conversions.str_to_scalar_enum(response, enums.BtoOffsUnit)
# noinspection PyTypeChecker
[docs]
def get_spbit(self) -> enums.BtoSymPerBit:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SPBit`` \n
Snippet: ``value: enums.BtoSymPerBit = driver.source.bb.btooth.econfiguration.pconfiguration.get_spbit()`` \n
Specifies a coding for LE coded packets. The specification for Bluetooth wireless technology defines two values S for
forward error correction: S = 2 symbol/bit and S = 8 symbol/bit.
:return: spb: TWO | EIGHt
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SPBit?')
return Conversions.str_to_scalar_enum(response, enums.BtoSymPerBit)
[docs]
def get_sp_offset(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SPOFfset`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_sp_offset()`` \n
Specifies the time from the start of the AUX_ADV_IND packet containing the SyncInfo field to the start of the
AUX_SYNC_IND packet. The offset is determined by multiplying the value by the unit,
see method ``RsSmw.source.bb.btooth.econfiguration.pconfiguration.sounits()``
:return: sp_offset: float Range: 0 to 245.7 or 246 to 2457 depending on offset unit
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SPOFfset?')
return Conversions.str_to_float(response)
# noinspection PyTypeChecker
[docs]
class SskdStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Sskd: str: numeric
- Bitcount: int: integer Range: 64 to 64
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Sskd'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Sskd: str=None
self.Bitcount: int=None
[docs]
def get_sskd(self) -> SskdStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SSKD`` \n
Snippet: ``value: SskdStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_sskd()`` \n
Sets the portion of Central or the portion of the Peripheral of the session key diversifier (SKDm/SKDs) .
:return: structure: for return value, see the help for SskdStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SSKD?', self.__class__.SskdStruct())
[docs]
def get_ss_value(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SSValue`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_ss_value()`` \n
Sets the sequence number of the packet. This parameter can be set in the first event. From the second event, this field
is not indicated.
:return: ss_value: integer Range: 0 to 1
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SSValue?')
return Conversions.str_to_int(response)
# noinspection PyTypeChecker
[docs]
class SvNumberStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Sv_Number: str: numeric
- Bitcount: int: integer Range: 16 to 16
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Sv_Number'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Sv_Number: str=None
self.Bitcount: int=None
[docs]
def get_sv_number(self) -> SvNumberStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SVNumber`` \n
Snippet: ``value: SvNumberStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_sv_number()`` \n
Sets a unique value for each implementation or revision of an implementation of the Bluetooth Controller. A 16-bit value
is set. Note: This parameter is relevant for data frame configuration and for the packet type: LL_VERSION_IND.
:return: structure: for return value, see the help for SvNumberStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SVNumber?', self.__class__.SvNumberStruct())
# noinspection PyTypeChecker
[docs]
def get_sync_word(self) -> enums.BtoSyncWord:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:SYNCword`` \n
Snippet: ``value: enums.BtoSyncWord = driver.source.bb.btooth.econfiguration.pconfiguration.get_sync_word()`` \n
Sets the 32-bit Sync Word in the packet header field in hexadecimal representation.
:return: sync_word: SW | UPAT SW Fixed value of 0x94826E8E. UPAT User-defined pattern allowing 8-digit hexadecimal input via the following command: method ``RsSmw.source.bb.btooth.econfiguration.pconfiguration.user_patt()``
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:SYNCword?')
return Conversions.str_to_scalar_enum(response, enums.BtoSyncWord)
# noinspection PyTypeChecker
[docs]
def get_ta_type(self) -> enums.BtoUlpAddrType:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:TATYpe`` \n
Snippet: ``value: enums.BtoUlpAddrType = driver.source.bb.btooth.econfiguration.pconfiguration.get_ta_type()`` \n
Selects the address type of the controller device. Depending on the Bluetooth controller role either Tx or Rx or both
address types are assigned. Subdivided into private and random, a Bluetooth LE device address consits of 48 bits.
The format of the device address differs depending on the selected address type.
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:TATYpe?')
return Conversions.str_to_scalar_enum(response, enums.BtoUlpAddrType)
# noinspection PyTypeChecker
[docs]
class TlapStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Lap: str: numeric
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Lap'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Lap: str=None
self.Bitcount: int=None
[docs]
def get_tlap(self) -> TlapStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:TLAP`` \n
Snippet: ``value: TlapStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_tlap()`` \n
Sets the lower address part (LAP) of Bluetooth device address. Commands for the advertising ..:ALAP, initiating ..:ILAP,
scanning ..:SLAP PDUs of advertising channel type are provided. In addition, a command is provided for scanner's or
initiator's target device address to which the advertisement is directed ..:TLAP.
:return: structure: for return value, see the help for TlapStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:TLAP?', self.__class__.TlapStruct())
# noinspection PyTypeChecker
[docs]
class TnuapStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Nap_Uap: str: numeric
- Bitcount: int: integer Range: 24 to 24
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Nap_Uap'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Nap_Uap: str=None
self.Bitcount: int=None
[docs]
def get_tnuap(self) -> TnuapStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:TNUap`` \n
Snippet: ``value: TnuapStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_tnuap()`` \n
Sets the non-significant address part (NAP) and upper address part (UAP) of Bluetooth device address. Commands for the
advertising ..:ANUap, initiating ..:INUap, and scanning ..:SNUap PDUs of advertising channel type are provided.
In addition, a command is provided for scanner's or initiator's target device address to which the advertisement is
directed ..:TNUap.
:return: structure: for return value, see the help for TnuapStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:TNUap?', self.__class__.TnuapStruct())
[docs]
def get_tpower(self) -> int:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:TPOWer`` \n
Snippet: ``value: int = driver.source.bb.btooth.econfiguration.pconfiguration.get_tpower()`` \n
Sets the required transmit power to be signaled within an extended header.
:return: tpower: integer Range: -127 to 126
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:TPOWer?')
return Conversions.str_to_int(response)
# noinspection PyTypeChecker
[docs]
class UserPattStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- User_Patt: str: numeric
- Bitcount: int: integer Range: 1 to 32
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('User_Patt'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.User_Patt: str=None
self.Bitcount: int=None
[docs]
def get_user_patt(self) -> UserPattStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:USERpatt`` \n
Snippet: ``value: UserPattStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_user_patt()`` \n
Sets a user-defined pattern of the 32-bit Sync Word. Using this Sync Word requires the following setting:
SOURce1:BB:BTOoth:ECONfiguration:PCONfiguration:SYNCword UPAT
:return: structure: for return value, see the help for UserPattStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:USERpatt?', self.__class__.UserPattStruct())
# noinspection PyTypeChecker
[docs]
class UtypeStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Utype: str: numeric
- Bitcount: int: integer Range: 8 to 8
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Utype'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Utype: str=None
self.Bitcount: int=None
[docs]
def get_utype(self) -> UtypeStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:UTYPe`` \n
Snippet: ``value: UtypeStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_utype()`` \n
Enables that an invalid control packet is indicated. The CtrType field indicates the value of the LL control packet that
caused the transmission of this packet.
:return: structure: for return value, see the help for UtypeStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:UTYPe?', self.__class__.UtypeStruct())
# noinspection PyTypeChecker
[docs]
class VnumberStruct(StructBase):
"""
Structure for reading output parameters. Fields: \n
- Vnumber: str: numeric
- Bitcount: int: integer Range: 8 to 8
"""
__meta_args_list = [
ArgStruct.scalar_raw_str('Vnumber'),
ArgStruct.scalar_int('Bitcount')]
def __init__(self):
StructBase.__init__(self, self)
self.Vnumber: str=None
self.Bitcount: int=None
[docs]
def get_vnumber(self) -> VnumberStruct:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:VNUMber`` \n
Snippet: ``value: VnumberStruct = driver.source.bb.btooth.econfiguration.pconfiguration.get_vnumber()`` \n
Sets the company identifier of the manufacturer of the Bluetooth controller. An 8-bit value is set. Note: This parameter
is relevant for data frame configuration and for the packet type LL_VERSION_IND.
:return: structure: for return value, see the help for VnumberStruct structure arguments.
"""
return self._core.io.query_struct('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:VNUMber?', self.__class__.VnumberStruct())
[docs]
def get_woffset(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:WOFFset`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_woffset()`` \n
Sets the start point of the window transmit for data event and advertising frame configuration with the packet type
CONNECT_IND. Command sets the values in ms. Query returns values in s.
:return: woffset: float Range: 0 s to depending on connection event interval , Unit: ms
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:WOFFset?')
return Conversions.str_to_float(response)
[docs]
def get_wsize(self) -> float:
"""
``[SOURce<HW>]:BB:BTOoth:ECONfiguration:PCONfiguration:WSIZe`` \n
Snippet: ``value: float = driver.source.bb.btooth.econfiguration.pconfiguration.get_wsize()`` \n
Sets the size of the transmit window, regarding to the start point for data event and advertising frame configuration
with the packet type CONNECT_IND.
:return: wsize: float Range: 1.25E-3 to depends on connection event interval
"""
response = self._core.io.query_str('SOURce<HwInstance>:BB:BTOoth:ECONfiguration:PCONfiguration:WSIZe?')
return Conversions.str_to_float(response)
def clone(self) -> 'PconfigurationCls':
"""
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 = PconfigurationCls(self._core, self._cmd_group.parent)
self._cmd_group.synchronize_repcaps(new_group)
return new_group