def setUp(self): #run before each test
self.SMW = VSG()
try:
self.SMW.jav_Open(host)
self.SMW.jav_Reset()
self.SMW.jav_ClrErr()
self.SMW.dLastErr = ""
except:
self.assertTrue(1)
class VST(object):
def __init__(self):
self.Freq = 19e9
def jav_Open(self, SMW_IP, FSW_IP, OFile=''):
self.SMW = VSG().jav_Open(SMW_IP, OFile) #Create SMW Object
self.FSW = VSA().jav_Open(FSW_IP, OFile) #Create FSW Object
return self
def jav_Close(self):
self.SMW.jav_Close()
self.FSW.jav_Close()
def jav_ClrErr(self):
self.SMW.jav_ClrErr()
self.FSW.jav_ClrErr()
def Set_Freq(self, freq):
self.SMW.Set_Freq(freq)
self.FSW.Set_Freq(freq)
class VST(object):
""" Rohde & Schwarz Vector Signal Transceiver Object """
def __init__(self):
self.Freq = 19e9
def jav_Open(self,SMW_IP,FSW_IP,OFile=''):
self.SMW = VSG().jav_Open(SMW_IP,OFile) #Create SMW Object
self.FSW = VSA().jav_Open(FSW_IP,OFile) #Create FSW Object
return self
def jav_Close(self):
self.SMW.jav_Close()
self.FSW.jav_Close()
def jav_ClrErr(self):
self.SMW.jav_ClrErr()
self.FSW.jav_ClrErr()
def Set_Freq(self,freq):
self.SMW.Set_Freq(freq)
self.FSW.Set_Freq(freq)
class TestGeneral(unittest.TestCase):
def setUp(self): #run before each test
self.SMW = VSG()
try:
self.SMW.jav_Open(host)
self.SMW.jav_Reset()
self.SMW.jav_ClrErr()
self.SMW.dLastErr = ""
except:
self.assertTrue(1)
def test_SMW_Connect(self):
self.assertEqual(self.SMW.jav_Error()[0],'0')
def test_SMW_Common(self):
self.SMW.Set_Freq(1e6)
self.SMW.Set_Power(10)
self.SMW.Get_Freq()
self.SMW.Get_Level()
self.assertEqual(self.SMW.jav_Error()[0],'0')
### Date : 2018.10.26
###
##########################################################
### User Entry
##########################################################
SMW_IP = '192.168.1.114'
Freq = 28e9
ChBW = 100
##########################################################
### Code Overhead: Import and create objects
##########################################################
from rssd.SMW_Common import VSG
from rssd.FileIO import FileIO
SMW = VSG().jav_Open(SMW_IP, OFile) #Create SMW Object
##########################################################
### Code Start
##########################################################
# parts
#scpi = "MMEM:DATA '/var/user/test.txt',#15hallo"
#scpi = 'BB:ARB:WAV:DATA "test.wv",#14' #bytes = 2(I)+2(Q)= 4bytes = 1IQ sample
scpi = ':MMEM:DATA:UNPR "NVWFM://var//user//wave.wv",#14'
bits = b'\x00\x01\x02\x03'
cmd = bytes(scpi, 'utf-8') + bits
print(bytes(cmd))
SMW.K2.write_raw(cmd)
SMW.write('SOUR1:BB:ARB:WAV:CLOC "/var/user/wave.wv",1.1E6')
#SMW.write(':MMEM:DATA:UNPR "NVMKR:/var/user/wave.wv",#185*7uuf5*')
SMW.write('BB:ARB:WAV:SEL "/var/user/wave.wv"')
##########################################################
### Rohde & Schwarz Automation for demonstration use.
###
### Purpose: Load arb file on SMW
### Author: mclim
### Date: 2018.05.17
##########################################################
### User Entry
##########################################################
host = '192.168.1.114' #Get local machine name
##########################################################
### Code Start
##########################################################
from rssd.SMW_Common import VSG
SMW = VSG().jav_Open(host)
#SMW.jav_logSCPI() #Log SCPI commands
SMW.Set_Freq(10e9) #Set 10GHz
SMW.Set_RFPwr(-30) #Output -30dBm
SMW.Set_RFState('ON') #Turn RF Output on
SMW.Set_ArbWv('composer.wv') #Load file
SMW.Set_ArbState('ON') #Turn on Arb & IQ Mod
SMW.jav_ClrErr() #Clear Errors
#self.write(':SOUR1:BB:NR5G:NODE:CELL0:OFFS POIN')
self.write(':SOUR1:BB:NR5G:NODE:CELL0:NSSP 1')
def Set_5GNR_TransPrecoding(self, sState):
# SC-FDMA or DFT-S-OFDM
# 5GNR--> User/BWP --> UL BWP Config --> PUSCH --> TP
if sState == 'ON':
# self.write(':SOUR1:BB:NR5G:SCH:CELL0:SUBF0:USER0:BWP0:ALL0:TPST ON') #4.30SP2?
self.write(
':SOUR1:BB:NR5G:UBWP:USER0:CELL0:UL:BWP0:PUSC:TPST ON') #4.50
else:
# self.write(':SOUR1:BB:NR5G:SCH:CELL0:SUBF0:USER0:BWP0:ALL0:TPST OFF') #4.30SP2?
self.write(
':SOUR1:BB:NR5G:UBWP:USER0:CELL0:UL:BWP0:PUSC:TPST OFF') #4.50
def Set_5GNR_savesetting(self, sName):
self.query(f':SOUR:BB:NR5G:SETT:STOR "/var/user/{sName}";*OPC?')
self.query(f':SOUR:BB:NR5G:WAV:CRE "/var/user/{sName}";*OPC?')
self.delay(10)
#####################################################################
### Run if Main
#####################################################################
if __name__ == "__main__":
# this won't be run when imported
SMW = VSG()
SMW.jav_Open("192.168.1.114")
SMW.Set_5GNR_savesetting('asdfasdf')
SMW.jav_Close()
if (iRange==0) or (iRange == 'LOW'):
self.write(':SOUR1:BB:NR5G:NODE:CELL0:CARD LT3')
elif (iRange==1) or (iRange == 'MIDD'):
self.write(':SOUR1:BB:NR5G:NODE:CELL0:CARD BT36')
elif (iRange==2) or (iRange == 'HIGH'):
self.write(':SOUR1:BB:NR5G:NODE:CELL0:CARD GT6')
def Set_5GNR_Parameters(self,sDir):
self.Set_5GNR_Direction(sDir)
def Set_5GNR_SSB(self):
#self.write(':SOUR1:BB:NR5G:NODE:CELL0:OFFS POIN')
self.write(':SOUR1:BB:NR5G:NODE:CELL0:NSSP 1')
def Set_5GNR_TransPrecoding(self, sState):
#SC-FDMA or DFT-S-OFDM
if sState == 'ON':
self.write(':SOUR1:BB:NR5G:SCH:CELL0:SUBF0:USER0:BWP0:ALL0:TPST ON')
else:
self.write(':SOUR1:BB:NR5G:SCH:CELL0:SUBF0:USER0:BWP0:ALL0:TPST OFF')
#####################################################################
### Run if Main
#####################################################################
if __name__ == "__main__":
# this won't be run when imported
SMW = VSG()
SMW.jav_Open("192.168.1.114")
SMW.Get_5GNR_RBMax()
SMW.jav_Close()
FSW_IP = '192.168.1.109'
VSE_IP = '127.0.0.1' #Get local machine name
Fs = 1200e6 #Sampling Rate
MeasTim = 500e-6
##########################################################
### Code Overhead: Import and create objects
##########################################################
from rssd.FSW_Common import VSA
from rssd.SMW_Common import VSG
from rssd.VSE_K96 import VSE
from rssd.FileIO import FileIO
from datetime import datetime
OFile = FileIO().makeFile(__file__)
SMW = VSG().jav_Open(SMW_IP, OFile) #Create SMW Object
FSW = VSA().jav_Open(FSW_IP, OFile) #Create FSW Object
VSE = VSE().jav_Open(VSE_IP, OFile) #Create FSW Object
##########################################################
### Code Start
##########################################################
FSW.jav_Reset()
FSW.Init_IQ() #FSW IQ Channel
FSW.Set_DisplayUpdate("OFF")
FSW.Set_SweepTime(MeasTim)
FSW.Set_IQ_SamplingRate(Fs)
##########################################################
### Measure Time
##########################################################
FreqStep = int(1e9)
fSpan = 100e6
SWM_Out = -20
Mixer = 0
##########################################################
### Code Start
##########################################################
from rssd.FSW_Common import VSA #pylint:disable=
from rssd.SMW_Common import VSG
from rssd.FileIO import FileIO
import time
OFileCSV = FileIO().makeFile(__file__+'csv')
OFileXML = FileIO().makeFile(__file__+'xml')
SMW = VSG().jav_Open(SMW_IP,OFileCSV) #Create SMW Object
FSW = VSA().jav_Open(FSW_IP,OFileCSV) #Create FSW Object
##########################################################
### Instrument Settings
##########################################################
SMW.Set_RFPwr(SWM_Out) #Output Power
SMW.Set_RFState('ON') #Turn RF Output on
FSW.Set_SweepCont(0)
#FSW.Set_SweepTime(200e-3)
FSW.Set_Span(fSpan)
if Mixer: #Mixer
FSW.write('SENS:MIX:STAT ON')
FSW.write('SENS:MIX:HARM:BAND V')
##########################################################
# Bench Settings
##########################################################
FSW_IP = '192.168.1.109'
SMW_IP = '192.168.1.114'
##########################################################
### Code Overhead: Import and create objects
##########################################################
from rssd.FSW_ADemod_K7 import VSA
from rssd.SMW_Common import VSG
from rssd.FileIO import FileIO
import time
OFile = FileIO().makeFile(__file__)
SMW = VSG().jav_Open(SMW_IP, OFile) #Create SMW Object
FSW = VSA().jav_Open(FSW_IP, OFile) #Create FSW Object
##########################################################
### Function Definition
##########################################################
def MeasRelPhase(FSW, SMW, x):
count = 0
leaveLoop = 0
while True:
SMW.Set_PhaseDelta((x - 1) * 10) #Initial Phase Shift
time.sleep(Delay / 1000) #Wait for phase settling
FSW.write('INIT:IMM') #Initiate Sweep
time.sleep(Delay / 1000) #Wait
for i in range(NumMkrs + 2):
##########################################################
### Code Overhead: Import and create objects
##########################################################
from datetime import datetime #pylint: disable=E0611,E0401
from rssd.FileIO import FileIO #pylint: disable=E0611,E0401
from rssd.SMW_Common import VSG #pylint: disable=E0611,E0401
from rssd.PNA_Common import PNA #pylint: disable=E0611,E0401
import time
OFile = FileIO().makeFile(__file__)
##########################################################
### Code Start
##########################################################
SMW = VSG().jav_Open(SMW_IP, OFile)
FSWP = PNA().jav_Open(FSWP_IP, OFile)
##########################################################
### Measure Time
##########################################################
Header = 'Iter,SetFreq,SMFPwr,FSWPFreq,FSWPPwr,LockStatus'
OFile.write(Header)
FSWP.Set_SweepCont(0)
SMW.Set_RFPwr(-50)
SMW.Set_RFState(1)
for i in range(numMeas): #Loop: Measurements
for freq in FreqArry: #Loop: Frequency
SMW.Set_Freq(freq)
CC_Size = 100e6 #Component Carrier Size
Fs = 115.2e6 #Sampling Rate
MeasTim = 500e-6
##########################################################
### Code Overhead
##########################################################
# import time
from rssd.SMW_Common import VSG
from rssd.FSW_Common import VSA
from rssd.VSE.K96 import VSE
import rssd.FileIO
f = rssd.FileIO.FileIO()
DataFile = f.Init(OutFile)
SMW = VSG().jav_Open(SMW_IP, f.sFName) #Connect to SMW
FSW = VSA().jav_Open(FSW_IP, f.sFName) #Connect to FSW
VSE = VSE().jav_Open(VSE_IP, f.sFName) #Connect to VSE
##########################################################
### Setup Instruments
##########################################################
VSE.jav_Reset()
#time.sleep(6)
VSE.Init_K96() #Change Channel
VSE.Set_DisplayUpdate("ON") #Display On
VSE.Set_SweepCont(0) #Continuous Sweep Off
VSE.Set_IQ_SamplingRate(Fs) #Sampling Rate
VSE.Set_File_InputIQW(Fs, IQFile) #VSE Input File
VSE.Set_K96_File_Config(OFDMCfg) #K96 Demod File
VSE.Set_K96_BurstSearch("OFF") #Burst Search off
##########################################################
### Rohde & Schwarz Automation for demonstration use.
### Purpose: VSG List Mode
### Author: mclim
### Date: 2019.06.13
##########################################################
### User Entry
##########################################################
host = '192.168.1.114' #Get local machine name
##########################################################
### Code Start
##########################################################
from rssd.SMW_Common import VSG
SMW = VSG().jav_Open(host)
#SMW.jav_logSCPI() # Log SCPI commands
SMW.Set_Freq(10e9) # Set 10GHz
SMW.Set_RFPwr(-30) # Output -30dBm
SMW.Set_ListMode_File('list1.lsw') # Select List File
SMW.Set_ListMode_TrigSource('SING') # Single run
SMW.Set_ListMode_RMode('LIVE')
SMW.Set_ListMode_Dwell(1) # Dwell time
SMW.Set_RFState(1) # RF Output on.
SMW.Set_ListMode('LIST') # Turn on listmode
SMW.Set_ListMode_TrigExecute() # Execute single trigger
SMW.Set_ListMode_TrigWait() # Wait for single trigger
SMW.Set_RFState('OFF') # RF Output off
SMW.jav_ClrErr() # Clear Errors
FreqStop = int(75e9)
FreqStep = int(1e9)
fSpan = 100e6
SWM_Out = -20
Mixer = 1
##########################################################
### Code Start
##########################################################
from rssd.SMW_Common import VSG
from rssd.FileIO import FileIO
import time
f = FileIO()
DataFile = f.Init(OutFile)
SMW = VSG()
SMW.jav_Open(SMW_IP, f.sFName)
##########################################################
### Instrument Settings
##########################################################
SMW.Set_RFPwr(SWM_Out) #Output Power
SMW.Set_RFState('ON') #Turn RF Output on
f.write(SMW.query('FREQ:MULT:EXT:TYPE?')) #SMZ #
f.write(SMW.query('FREQ:MULT:EXT:SNUM?')) #Serial Num
f.write(SMW.query('FREQ:MULT:EXT:LOAD:VERS?'))
f.write(SMW.query('FREQ:MULT:EXT:FMAX?'))
f.write(SMW.query('FREQ:MULT:EXT:FMIN?'))
f.write(SMW.query('FREQ:MULT:EXT:REV?')) #Revision
def Set_WLAN_Standard(self, sStd):
#WLAN-->Frame Blocks-->TxMode
sStd.upper()
if sStd == 'B':
self.write(f':SOUR:BB:WLNN:FBL1:PMOD LEG') #Set Physical Mode
self.write(f':SOUR:BB:WLNN:FBL1:TMOD CCK')
elif sStd == 'G' or sStd == 'A':
self.write(f':SOUR:BB:WLNN:FBL1:PMOD LEG') #Set Physical Mode
self.write(f':SOUR:BB:WLNN:FBL1:TMOD L{self.WLAN_ChBW}')
elif sStd == 'N':
self.write(f':SOUR:BB:WLNN:FBL1:PMOD MIX') #Set Physical Mode
self.write(f':SOUR:BB:WLNN:FBL1:TMOD HT{self.WLAN_ChBW}')
elif sStd == 'AC':
self.write(f':SOUR:BB:WLNN:FBL1:PMOD MIX') #Set Physical Mode
self.write(f':SOUR:BB:WLNN:FBL1:TMOD V{self.WLAN_ChBW}')
elif sStd == 'AX':
self.write(f':SOUR:BB:WLNN:FBL1:PMOD MIX') #Set Physical Mode
self.write(f':SOUR:BB:WLNN:FBL1:TMOD HE{self.WLAN_ChBW}')
else:
print(f'Set_WLAN_Standard: {sStd} not supported')
#####################################################################
### Run if Main
#####################################################################
if __name__ == "__main__":
### this won't be run when imported
WLAN = VSG()
WLAN.jav_Open("192.168.1.114")
print(WLAN.Get_WLAN_Standard())
WLAN.jav_Close()
def jav_Open(self,SMW_IP,FSW_IP,OFile=''):
self.SMW = VSG().jav_Open(SMW_IP,OFile) #Create SMW Object
self.FSW = VSA().jav_Open(FSW_IP,OFile) #Create FSW Object
return self
CC_Size = 100e6 #Component Carrier Size
Fs = 115.2e6 #Sampling Rate
MeasTim = 500e-6
##########################################################
### Code Overhead
##########################################################
from rssd.SMW_Common import VSG
from rssd.FSW_Common import VSA
from rssd.VSE.K96 import VSE
import rssd.FileIO
import time
f = rssd.FileIO.FileIO()
DataFile = f.Init(OutFile)
SMW = VSG() #Create SMW Object
SMW.jav_Open(SMW_IP, f.sFName) #Connect to SMW
FSW = VSA() #Create FSW Object
FSW.jav_Open(FSW_IP, f.sFName) #Connect to FSW
VSE = VSE() #Create VSE Object
VSE.jav_Open(VSE_IP, f.sFName) #Connect to VSE
if 0:
SMW.jav_logSCPI()
FSW.jav_logSCPI()
VSE.jav_logSCPI()
##########################################################
### Setup Instruments
##########################################################
VSE.jav_Reset()
#time.sleep(6)
class TestGeneral(unittest.TestCase):
def setUp(self): #run before each test
self.SMW = VSG()
try:
self.SMW.jav_Open(host, prnt=0)
self.SMW.jav_Reset()
self.SMW.jav_ClrErr()
self.SMW.dLastErr = ""
except:
self.assertTrue(1)
def tearDown(self): #Run after each test
self.SMW.jav_Close()
###############################################################################
### <Test>
###############################################################################
def test_SMW_Connect(self):
self.SMW.jav_IDN(prnt=0)
self.assertEqual(self.SMW.Make, "Rohde&Schwarz")
def test_SMW_Freq(self):
frq = 1e6
self.SMW.Set_Freq(frq)
rdFrq = self.SMW.Get_Freq()
self.assertEqual(self.SMW.jav_Error()[0], '0')
self.assertEqual(frq, rdFrq)
def test_SMW_Pwr(self):
pwr = -10
self.SMW.Set_RFPwr(pwr)
rdPwr = self.SMW.Get_PowerRMS()
self.assertEqual(self.SMW.jav_Error()[0], '0')
self.assertEqual(pwr, rdPwr)