class TestGeneral(unittest.TestCase):
def setUp(self): #run before each test
self.FileIO = FileIO()
self.FileIO.Init("FileIO.csv")
def test_write(self):
self.FileIO.write("Hello World Test_FileIO.py")
self.FileIO.write_raw("Hello World Test_FileIO.py Raw")
def test_readcsv(self):
data = self.FileIO.readcsv()
for i, line in enumerate(data):
print("%d:%s" % (i, ",".join(data[i])))
self.assertEqual("as" + "df", "asdf")
def test_read(self):
data = self.FileIO.read()
for i, line in enumerate(data):
print("%d:%s" % (i, ",".join(line)))
self.assertTrue('FOO'.isupper())
self.assertFalse('Foo'.isupper())
def tearDown(self):
pass
class TestGeneral(unittest.TestCase):
def setUp(self): #Run before each test
self.FileIO = FileIO()
self.FileIO.Init("FileIO.csv")
self.FileIO.debug = 0
def tearDown(self): #Run after each test
self.FileIO.Outfile.close()
###############################################################################
### </Test>
###############################################################################
def test_write(self):
try:
self.FileIO.write("test_write,write") #Append Date
self.FileIO.write_raw("test_write,write_raw") #No Date
except:
self.assertTrue(1) #FAIL
def test_readcsv(self):
self.FileIO.write('testreadcsv,spam,ham,eggs')
data = self.FileIO.readcsv() #Read as 2D Table
size = len(data)
self.assertEqual(data[size-1][3],'ham')
def test_read(self):
self.FileIO.write_raw('testread,spam,ham,eggs')
data = self.FileIO.read() #Read entire file
size = len(data)
self.assertEqual(data[size-1].strip(),'testread,spam,ham,eggs')
class TestGeneral(unittest.TestCase):
def setUp(self): #Run before each test
self.FileIO = FileIO()
self.FileIO.init("FileIO.csv")
self.FileIO.debug = 0
def tearDown(self): #Run after each test
self.FileIO.Outfile.close()
###############################################################################
### </Test>
###############################################################################
def test_setFilename(self):
self.FileIO.set_filename(".system")
def test_makeFile(self):
newName = 'makeFile'
self.FileIO.makeFile(newName)
self.assertNotEqual(self.FileIO.sFName.find(newName),-1)
def test_readcsv(self):
self.FileIO.write('testreadcsv,spam,ham,eggs')
data = self.FileIO.readcsv() #Read as 2D Table
size = len(data)
self.assertEqual(data[size-1][3],'ham')
def test_read(self):
self.FileIO.write_raw('testread,spam,ham,eggs')
data = self.FileIO.read() #Read entire file
size = len(data)
self.assertEqual(data[size-1].strip(),'testread,spam,ham,eggs')
# self.assertTrue('FOO'.isupper())
# self.assertFalse('Foo'.isupper())
def test_readdict(self):
BaseDir = os.path.dirname(os.path.realpath(__file__))
self.FileIO.set_filename(os.path.join(BaseDir,'.system'))
rdDict = self.FileIO.readdict()
rdDict['VSG'] #pylint: disable=W0104
def test_write(self):
self.FileIO.write("test_write,write") #Append Date
self.FileIO.write_raw("test_write,write_raw") #No Date
def run(root):
Instr = VST().jav_Open(root.entryCol.entry0.get(),
root.entryCol.entry1.get()) #pylint:disable=E1101
OFileCSV = FileIO().makeFile(root.entryCol.entry7.get() + 'csv')
OFileXML = FileIO().makeFile(root.entryCol.entry7.get() + 'xml')
root.toppWind.writeN('Sweep Begin')
root.toppWind.writeN(
f'-{Instr.SMW.Model} {Instr.SMW.Device} {Instr.SMW.Version} ')
root.toppWind.writeN(
f'-{Instr.FSW.Model} {Instr.FSW.Device} {Instr.FSW.Version} ')
##########################################################
### Instrument Settings
##########################################################
FreqStart = int(float(root.entryCol.entry2.get()))
FreqStop = int(float(root.entryCol.entry3.get()))
FreqStep = int(float(root.entryCol.entry4.get()))
fSpan = float(root.entryCol.entry5.get())
SWM_Out = float(root.entryCol.entry6.get())
Instr.SMW.Set_RFPwr(SWM_Out) #Output Power
Instr.SMW.Set_IQMod('OFF') #Modulation Off
Instr.SMW.Set_RFState('ON') #Turn RF Output on
Instr.FSW.Set_Channel("Spectrum")
Instr.FSW.Set_SweepCont(0)
Instr.FSW.Set_Span(fSpan)
for freq in range(FreqStart, FreqStop, FreqStep):
Instr.Set_Freq(freq)
time.sleep(0.01)
Instr.FSW.Set_InitImm()
Instr.FSW.Set_Mkr_Peak()
Mkr = Instr.FSW.Get_Mkr_XY()
OFileCSV.write(f'{freq},{Mkr[0]},{Mkr[1]}')
OFileXML.write(f' <Point x="{Mkr[0]}" y="{Mkr[1]}"/>')
Instr.jav_Close()
root.toppWind.writeN("Sweep Complete")
if leaveLoop: break
return AvgAvg
def rad2deg(radian):
""" PI() * Radian = 180 Degree"""
degree = radian * 180 / 3.14159
return degree
def deg2rad(degree):
radian = degree * 3.14159 / 180
return radian
###############################################################################
### Code Start
###############################################################################
OFile.write('DemodBW,Phase,Mkr1,Mkr2,Mkr3,Mkr4,Meas,MeasAvg\n')
FSW.write('SYST:DISP:UPD ON')
###############################################################################
### SMW-Setup 1 Radian = 180/Pi()
###############################################################################
SMW.Set_Freq(28e9)
SMW.Set_BBState(0) # Arb Off
SMW.Set_IQMod(0) # IQ Mod Off
SMW.Set_Ref_Source('EXT') # ExtReference
SMW.Set_Ref_Freq('10MHZ')
SMW.Set_Ref_SyncBW('WIDE') # Oscilator locking BW
SMW.Set_RFState('ON')
###############################################################################
##########################################################
### Code Start
##########################################################
NR5G = VST().jav_Open(SMW_IP,FSW_IP,OFile)
NR5G.NR_TF = DFT_S_OFDM
NR5G.NR_Dir = NR_Dir
NR5G.NR_ChBW = NR_ChBW
NR5G.NR_RB = NR_RB
NR5G.Freq = FreqArry[0]
##########################################################
### Measure Time
##########################################################
#sDate = datetime.now().strftime("%y%m%d-%H:%M:%S.%f") #Date String
OFile.write('Iter,Freq,AutoLvl,ALTime,Crest,Pwr,EVM,ChBW,Waveform,SubSp,Mod,Pwr,SubFram,Attn,Preamp,RefLvl,CrestF,P10_00,P01_00,P00_10,P00_01,CmdTime')
NR5G.FSW.Init_5GNR()
NR5G.FSW.Set_5GNR_EVMUnit('DB')
NR5G.FSW.Set_Trig1_Source('EXT')
NR5G.FSW.Set_SweepCont(0)
NR5G.FSW.Init_CCDF()
NR5G.FSW.Set_YIG(0)
NR5G.FSW.Set_CCDF_BW(120e6)
NR5G.FSW.Set_CCDF_Samples(2e6)
NR5G.FSW.Set_Trig1_Source('IMM')
NR5G.FSW.Set_SweepCont(0)
for mod in modArry: #Loop: Modulation
for subC in subCarr: #Loop: Subcarrier
NR5G.NR_SubSp = subC
SEMFreqmin = 2.900e9
###############################################################################
### Code Overhead: Import and create objects
###############################################################################
# import timeit
from rssd.VSA.NR5G_K144 import VSA
from rssd.FileIO import FileIO
OFile = FileIO().makeFile(__file__)
FSW = VSA().jav_Open(instru_ip, OFile) #Create Object
###############################################################################
### Code Start
###############################################################################
OFile.write('EVM,FreqError,ChPwr,Adj-,Adj+,SEM') #Data Header
FSW.Set_Freq(centerFreq)
FSW.Set_SweepCont(0)
###########################
### EVM
###########################
FSW.Init_5GNR()
FSW.Init_5GNR_Meas('EVM')
FSW.Set_InitImm()
EVM = FSW.query(':FETC:CC1:ISRC:FRAM:SUMM:EVM:ALL:AVER?')
EVM = EVM + ',' + FSW.query(':FETC:CC1:ISRC:FRAM:SUMM:FERR:AVER?')
###########################
### ACLR
instru_ip = '192.168.1.107'
###############################################################################
### Code Overhead: Import and create objects
###############################################################################
from rssd.yaVISA_socket import jaVisa
from rssd.FileIO import FileIO
import timeit
OFile = FileIO().makeFile(__file__)
instr = jaVisa().jav_Open(instru_ip,OFile) #Create Object
###############################################################################
### Code Start
###############################################################################
OFile.write('Iter,CmdTime,Response')
ALTime = []
for i in range(10):
rdStr = ''
tick = timeit.default_timer()
### <\thing we are timing>
if 1:
instr.query('INIT:IMM;*OPC?')
# instr.write(':INST:COUP:RLEV ON')
# rdStr = instr.query('FETC:SUMM:EVM:ALL?')
### <\thing we are timing>
ALTime.append(timeit.default_timer() - tick)
OutStr = f'{i},{ALTime[i]:.6f},{rdStr}'
OFile.write (OutStr)
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')
for freq in range(FreqStart,FreqStop,FreqStep):
SMW.Set_Freq(freq)
time.sleep(0.01)
FSW.Set_Freq(freq)
FSW.Set_InitImm()
FSW.Set_Mkr_Peak()
Mkr = FSW.Get_Mkr_XY()
OFileCSV.write(f'{freq},{Mkr[0]},{Mkr[1]}')
OFileXML.write(f' <Point x="{Mkr[0]}" y="{Mkr[1]}"/>')
SMW.jav_ClrErr() #Clear Errors
FSW.jav_ClrErr() #Clear Errors
instru_ip = '192.168.1.108'
###############################################################################
### Code Overhead: Import and create objects
###############################################################################
from rssd.FSW_Common import VSA
from rssd.FileIO import FileIO
import timeit
OFile = FileIO().makeFile(__file__)
FSVA = VSA().jav_Open(instru_ip, OFile) #Create Object
###############################################################################
### Code Start
###############################################################################
OFile.write('Freq,LNA,NoiseCorr,MkrFreq,Noise,dBmHz')
FSVA.Set_SweepCont(0)
#FSVA.Set_SweepTime(100e-3)
FSVA.Set_Span(1e6)
FSVA.Set_RefLevel(-100)
FSVA.Set_Trace_Detector('RMS')
FSVA.Set_Trace_Avg('POW')
FSVA.Set_Trace_AvgCount(30)
FSVA.Set_AttnMech(0)
FSVA.Set_ResBW(100)
for freq in (1, 3.6, 6):
FSVA.Set_Freq(freq * 1e9)
for preamp in ('NoPA', 'LNA'):
if 'LNA' in preamp:
FSVA.write(':INP:GAIN:STAT ON')
VSA.Set_IQ_ACLR(ChBW, ChSpace)
#VSA.Set_DisplayUpdate("OFF")
VSA.Set_Param_Couple_All()
VSA.Set_SweepTime(MeasTim)
VSA.Set_Trace_Avg('LIN')
VSA.Set_Trace_AvgCount(Avg)
VSA.Set_YIG('OFF')
if 0:
VSA.Set_Trig1_Source('Ext')
###############################################################################
### Measure Time
###############################################################################
#sDate = datetime.now().strftime("%y%m%d-%H:%M:%S.%f") #Date String
OFile.write('Model ,Iter,Freq,RBW,SwpTime,SMWPwr,ALType,ALTime,TotTime,Attn,PreAmp,RefLvl,SwpTime,SwpPts,SwpType,SwpOpt,TxPwr,Adj-,Adj+,Alt-,Alt+,ChSpace')
for i in range(Repeat):
for autoMeth in range(len(meth)):
for pwr in range(PwrSweep):
### <\thing we are timing>
VSG.write(f':POW:AMPL {-50 + pwr}dbm') ### VSG Power
tick = datetime.now()
### <AUTOLEVEL> ###
eval(meth[autoMeth]) # Dynamically call
tockA = datetime.now()
### <AUTOLEVEL> ###
VSA.write(':INIT:CONT OFF') # Single Sweep
VSA.query(':INIT:IMM;*OPC?') # Take Sweep
ACLR = VSA.Get_Mkr_BandACLR()
VSA.Set_SweepTime(MeasTim)
VSA.Set_Trace_Avg('LIN')
VSA.Set_Trace_AvgCount(Avg)
VSA.Set_Trace_Detector('RMS')
VSA.Set_SweepOpt(SweMode)
VSA.Set_SweepType(SweType)
VSA.Set_YIG('OFF')
if 0:
VSA.Set_Trig1_Source('Ext')
##########################################################
### Measure Time
##########################################################
#sDate = datetime.now().strftime("%y%m%d-%H:%M:%S.%f") #Date String
OFile.write(
'Instr,Iter,RBW,SwpTime,SMWPwr,ALType,AL Time,TotalTime,Attn,PreAmp,RefLvl,SwpTime,SwpPts,SwpType,SwpOpt,TxPwr,Adj-,Adj+,Alt-,Alt+,Freq,ChBw'
)
for i in range(Repeat):
for autoMeth in range(len(meth)):
for pwr in range(PwrSweep):
### <\thing we are timing>
VSG.query(f':POW:AMPL {-50 + pwr}dbm;*OPC?') # VSG Power
tick = datetime.now()
### <AUTOLEVEL> ###
eval(meth[autoMeth]) # Dynamically call
### <AUTOLEVEL> ###
tockA = datetime.now()
VSA.write(':INIT:CONT OFF') # Single Sweep
VSA.query(':INIT:IMM;*OPC?') # Take Sweep
from datetime import datetime #pylint: disable=E0611,E0401
from rssd.FileIO import FileIO #pylint: disable=E0611,E0401
from rssd.VST_WLAN import VST #pylint: disable=E0611,E0401
OFile = FileIO().makeFile(__file__)
##########################################################
### Code Start
##########################################################
WLAN = VST().jav_Open(SMW_IP, FSW_IP, OFile)
##########################################################
### Measure Time
##########################################################
#sDate = datetime.now().strftime("%y%m%d-%H:%M:%S.%f") #Date String
OFile.write(
'Freq,SMWPwr,ALTime,Std,ChBW,MCS,Attn,Preamp,RefLvl,MeasPwr,EVM,SEM,TxCh,Adj-,Adj+,Alt1-,Alt1+,Alt2-,Alt2+,CmdTime'
) # All
WLAN.FSW.jav_Reset()
WLAN.FSW.Init_WLAN()
WLAN.FSW.Set_Trig1_Source('EXT')
WLAN.FSW.Set_SweepCont(0)
for std in StdArry: #Loop: Standard
for chbw in CHBWArry: #Loop: Ch Bandwidth
for MCS in MCSArry: #Loop: Modulation
WLAN.WLAN_Std = std
WLAN.WLAN_MCS = MCS
WLAN.WLAN_ChBW = chbw
WLAN.Set_WLAN_All() ### Make Waveform ###
print(f'802.11{std} RFBW:{WLAN.WLAN_ChBW} MCS:{MCS}')
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
f.write("Power")
f.write(SMW.query('FREQ:MULT:EXT:PMAX?')) #Revision
f.write(SMW.query('FREQ:MULT:EXT:PMIN?')) #Revision
f.write(SMW.query('FREQ:MULT:EXT:STAT?'))
SMW.write("MMEM:CDIR '/smz/firmware/'")
f.write(SMW.query("FREQ:MULT:EXT:FIRM:CAT?"))
f.write(SMW.query("FREQ:MULT:EXT:CORR:POW:POIN?"))
SMW.jav_ClrErr() #Clear Errors
instru_ip = '192.168.1.109'
freq = 1.950 #GHz
###############################################################################
### Code Overhead: Import and create objects
###############################################################################
from rssd.VSA.Common import VSA
from rssd.FileIO import FileIO
import timeit
OFile = FileIO().makeFile(__file__)
FSW = VSA().jav_Open(instru_ip, OFile) #Create Object
###############################################################################
### Code Start
###############################################################################
OFile.write('Freq,ChPwr-dBm,2nd-dbc,3rd-dbc')
FSW.Init_Harm()
FSW.Set_Freq(freq * 1e9)
FSW.Set_Harm_num(3)
FSW.Set_Trace_Detector('RMS')
FSW.Set_Harm_adjust()
# FSW.Set_RefLevel(-100)
# FSW.Set_ResBW(100)
data = FSW.Get_Harm()
OutStr = f'{freq},{data[0]},{data[1]},{data[2]}'
OFile.write(OutStr)
###############################################################################
### Cleanup Automation
###############################################################################
##########################################################
### Code Start
##########################################################
FSW.jav_Reset()
FSW.Set_Freq(Freq)
FSW.Init_CCDF() #FSW CCDF Channel
FSW.Set_CCDF_BW(RFBW)
FSW.Set_CCDF_Samples(NumIQ)
FSW.Set_SweepCont(0)
##########################################################
### Measure Time
##########################################################
#sDate = datetime.now().strftime("%y%m%d-%H:%M:%S.%f") #Date String
OFile.write('Iter,CrestF,P10_00,P01_00,P00_10,P00_01,CmdTime')
sumTime = 0
for i in range(NumMeas):
tick = datetime.now()
FSW.Set_InitImm()
ccdf = FSW.Get_CCDF()
d = datetime.now() - tick
sumTime += d.microseconds
OutStr = f'{i},{ccdf},{d.seconds}.{d.microseconds}'
OFile.write(OutStr)
##########################################################
### Cleanup Automation
##########################################################
FSW.jav_Close()
FSW = VSA().jav_Open(FSW_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_SweepCont(0)
################################################################################
### Measure Time
################################################################################
#sDate = datetime.now().strftime("%y%m%d-%H:%M:%S.%f") #Date String
OFile.write('Fs,CapTime,Iter,CmdTime')
for Fs in FsArry:
print("Starting Fs: %f" % Fs)
FSW.Set_IQ_SamplingRate(Fs)
for i in range(numRepeat):
tick = datetime.now()
FSW.Set_InitImm()
FSW.Get_IQ_Data()
data = FSW.Get_IQ_Data_Ascii2().split(',')[0:2]
d = datetime.now() - tick
OutStr = f'{Fs/1e6},{MeasTim},{i:2d},{d.seconds:03d}.{d.microseconds:06d}, {data}'
OFile.write(OutStr)
################################################################################
### Cleanup Automation
################################################################################
from datetime import datetime #pylint: disable=E0611,E0401
from rssd.FileIO import FileIO #pylint: disable=E0611,E0401
from rssd.VST_WLAN import VST #pylint: disable=E0611,E0401
import time
OFile = FileIO().makeFile(__file__)
##########################################################
### Code Start
##########################################################
WLAN = VST().jav_Open(SMW_IP,FSW_IP,OFile)
##########################################################
### Measure Time
##########################################################
#sDate = datetime.now().strftime("%y%m%d-%H:%M:%S.%f") #Date String
OFile.write('Freq,Pwr,ALTime,Std,ChBW,MCS,Pwr,Attn,Preamp,RefLvl,EVM,CmdTime')
WLAN.FSW.Init_WLAN()
WLAN.FSW.Set_Trig1_Source('EXT')
WLAN.FSW.Set_SweepCont(0)
for std in StdArry: #Loop: Standard
for chbw in CHBWArry: #Loop: Ch Bandwidth
for MCS in MCSArry: #Loop: Modulation
WLAN.WLAN_Std = std
WLAN.WLAN_MCS = MCS
WLAN.WLAN_ChBW = chbw
WLAN.Set_WLAN_All() ### Make Waveform ###
print(f'802.11{std} RFBW:{WLAN.WLAN_ChBW} MCS:{MCS}')
WLAN.FSW.Set_SweepTime(SweepTime)
WLAN.FSW.write(':TRAC:IQ:SRAT 160e6')
FSW.Set_Trace_Mode('WRIT')
FSW.Set_Trace_Detector('RMS')
FSW.Set_Span(Span)
FSW.Set_Mkr_Freq(Freq)
FSW.Set_Mkr_Band(100e6)
FSW.Set_YIG('OFF')
FSW.Set_SweepCont(0)
FSW.Set_Autolevel()
# FSW.Set_Trig1_Source('Ext')
################################################################################
### Measure Time
################################################################################
#sDate = timeit.default_timer().strftime("%y%m%d-%H:%M:%S.%f") #Date String
LoopParam = 'Iter,RBW,SwpTime'
OFile.write(f'{LoopParam},{FSW.Get_Params(1,1,1,1,1)},{FSW.Get_Params_MkrBand(1)},{TMR.Get_Params_Time(1)}')
for i in range(Repeat):
for SwpTime in swpTimeArry:
for rbw in rbwArry:
TMR.start() # <thing we are timing>
FSW.Set_Channel('Spectrum')
FSW.Set_ResBW(rbw)
FSW.Set_SweepTime(0)
FSW.Set_InitImm() # Take Sweep
MeasData = FSW.Get_Params_MkrBand()
TMR.tick() # <\thing we are timing>
LoopParam = f'{i},{rbw:8.0f},{SwpTime:5.3f}'
TotTime = TMR.Get_Params_Time()
OutStr = f'{LoopParam},{FSW.Get_Params(1,1,1,1,0)},{MeasData},{TotTime}'
OFile.write (OutStr)
##########################################################
from rssd.VSA.OptX import VSA
from rssd.FileIO import FileIO
OFile = FileIO().makeFile(__file__)
FSW = VSA().jav_Open(FSW_IP, OFile) #Create FSW Object
##########################################################
### Code Start
##########################################################
#FSW.jav_Reset()
FSW.Init_5GNR_SEM() #FSW 5G NR Channel
FSW.Set_Freq(Freq)
FSW.Set_5GNR_Direction('DL') #UL or DL
FSW.Set_5GNR_SEM_SubBlockNum(3)
FSW.Set_5GNR_FreqRange('HIGH') #LOW:<3GHz MIDD:3-6GHz HIGH:>6GHz
FSW.Set_5GNR_ChannelBW(ChBW) #MHz
##########################################################
### Measure Time
##########################################################
#sDate = datetime.now().strftime("%y%m%d-%H:%M:%S.%f") #Date String
OFile.write('asdf')
FSW.Set_SweepCont(0)
##########################################################
### Cleanup Automation
##########################################################
FSW.jav_Close()
CMP.write('CONF:NRMM:MEAS:MEV:RES:ALL ON,ON,ON,ON,ON,ON,ON,ON,ON,ON,ON,ON')
CMP.write('CONF:NRMM:MEAS:MEV:REP SING')
CMP.write('CONF:NRMM:MEAS:MEV:SCON NONE')
CMP.write('CONF:NRMM:MEAS:MEV:MMOD NORM')
CMP.write('CONF:NRMM:MEAS:MEV:MOEX OFF')
CMP.write('CONF:NRMM:MEAS:MEV:SCO:POW 1')
CMP.write('CONF:NRMM:MEAS:MEV:SCO:MOD 1')
CMP.write('CONF:NRMM:MEAS:MEV:SCO:SPEC:SEM 1')
CMP.write('CONF:NRMM:MEAS:MEV:SCO:SPEC:ACLR 1')
##########################################################
### Measure Time
##########################################################
#sDate = datetime.now().strftime("%y%m%d-%H:%M:%S.%f") #Date String
Header = 'Iter,Model,Freq,EVM,TxPwr,PeakPwr,FreqErr,EVMdB,ChBW,UL-TP,SubSp,Mod,SMWPwr,ExpPwr,UserMargin,ExtAttn,MixerLevel,StepTime'
OFile.write(Header)
for i in range(numMeas): #Loop: Repeatability
for param in waveparam: #Loop: Waveform Parameters
NR5G.NR_ChBW = param[0]
NR5G.NR_SubSp = param[1]
NR5G.NR_RB = param[2]
NR5G.NR_Mod = param[3]
CMP.Init_5GNR()
for freq in FreqArry: #Loop: Frequency
print(
f'Freq:{freq:.0f} RFBW:{NR5G.NR_ChBW} SubC:{NR5G.NR_SubSp} Mod:{NR5G.NR_Mod}'
)
SMW.Set_Freq(freq)
CMP.Set_5GNR_Freq(freq / 1e6)
print(Header)
"""RSSD Frequency Sweep VSA & VSG"""
from rssd.VSA import VSA
from rssd.VSG import VSG
from rssd.FileIO import FileIO
freqOffset = 60e6
smwPwr = -10
OFile = FileIO().makeFile(__file__) # Create Output File
SMW = VSG().jav_Open('192.168.58.114',OFile) # Create Generator Object
FSW = VSA().jav_Open('192.168.58.109',OFile) # Create Analyzer Object
OFile.write('SMWFreq,FreqOffset,SMWPwr,MkrBand,MkrCenter,MkrOffset,MkrDelta,SMWOff')
Freqs = range(int(7e9), int(9e9), int(100e6)) # Frequency List
SMW.Set_RFPwr(smwPwr)
SMW.Set_IQMod(0)
FSW.Set_Span(200e6)
FSW.Set_SweepTime(0.500)
FSW.Set_Trace_Detector('RMS')
FSW.Set_Mkr_Band(100e6)
for frq in Freqs:
## SMW Power ON
SMW.Set_RFState(1)
SMW.Set_Freq(frq)
FSW.Set_SweepCont(0)
FSW.Set_Freq(frq)
FSW.Set_Autolevel()
FSW.Set_InitImm()
FSW.Set_Mkr_Freq(frq)
MkrCenter = FSW.Get_Mkr_Y()
MkrBandPr = FSW.Get_Mkr_Band()
FSW.Set_Mkr_Freq(frq + freqOffset)
###############################################################################
### Rohde & Schwarz Automation for demonstration use.
###############################################################################
SMW_IP = '192.168.1.114'
SMW_IP = '10.0.0.10'
FreqArry = [24e9, 28e9, 39e9]
PwrArry = range(-50, 0, 2)
###############################################################################
from rssd.VSG.Common import VSG
from rssd.FileIO import FileIO
FIL = FileIO().makeFile(__file__)
SMW = VSG().jav_Open(SMW_IP, FIL) #Create SMW Object
###############################################################################
### Code Start
###############################################################################
SMW.Set_IQMod('OFF')
for frq in FreqArry:
SMW.Set_Freq(frq)
# SMW.Set_NRP_Freq(frq)
for pwr in PwrArry:
SMW.Set_RFPwr(pwr)
SMW.Set_RFState(1)
rdStr = SMW.Get_NRPPower()
FIL.write(f'{frq},{pwr},{rdStr}')
################################################################################
### Rohde & Schwarz Automation for demonstration use.
###
### Title : Digital Storage Oscilloscope Example
### Author : mclim
### Date : 2020.03.24
###
################################################################################
### User Entry
################################################################################
RTO_IP = '192.168.1.33'
################################################################################
### Code Overhead
################################################################################
from rssd.FileIO import FileIO #pylint: disable=E0611,E0401
from rssd.DSO.Common import DSO
OFile = FileIO().makeFile(__file__) # Open Log file
RTO = DSO().jav_Open(RTO_IP, OFile) # Create RTO object & log IDN
################################################################################
### Code Start
################################################################################
rdStr = RTO.query('*IDN?')
RTO.Set_TimeScale(1e-8)
rdStr = RTO.Get_TimeScale()
RTO.Set_TimeScale(2e-8)
rdStr = RTO.Get_TimeScale()
OFile.write(rdStr)
VSA.Set_In_YIG('OFF')
# VSA.Set_Trig1_Source('Ext')
################################################################################
### Measure Time
################################################################################
#sDate = timeit.default_timer().strftime("%y%m%d-%H:%M:%S.%f") #Date String
LoopParam = 'Iter,Pwr'
TimeParam = 'AlTime,MeasTime,TotalTIme'
SwpParam = VSA.Get_Params_Sweep(1)
AmpParam = VSA.Get_Params_Amp(1)
TrcParam = VSA.Get_Params_Trace(1)
SysParam = VSA.Get_Params_System(1)
MeasData = 'TxPwr,Adj-,Adj+,Alt-,Alt+'
OFile.write(
f'{LoopParam},{TimeParam},{AmpParam},{SwpParam},{TrcParam},{SysParam},{MeasData}'
)
# table = VSAL.ReadLevellingTables(Freq)
tick0 = timeit.default_timer()
for i in range(Repeat):
for VSApwr in range(PwrSweep):
tick = timeit.default_timer()
### <\thing we are timing>
VSG.write(f':POW:AMPL {VSApwr - DUTGain}dbm') # VSG Power
#################
### AUTOLEVEL ###
#################
VSA.Set_SweepCont(0) # Sweep Continuous
VSA.Set_Autolevel()
