Beispiel #1
0
### User Entry
##########################################################
FSW_IP = '192.168.1.109'
Freq = 28e9
ChBW = 100
numMeas = 10

##########################################################
### Code Overhead: Import and create objects
##########################################################
from rssd.VSA.NR5G_K144 import VSA
from datetime import datetime
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
Beispiel #2
0
pwrArry     = range(-50,10,2)                               #Power Array
comment     = '-Autolevel'

###############################################################################
### Overhead
###############################################################################
from rssd.VSG.NR5G_K144     import VSG
from rssd.VSA.NR5G_K144     import VSA
from rssd.FileIO            import FileIO
from rssd.RSI.time          import timer

OFile = FileIO().makeFile(__file__)
TMR = timer()
SMW = VSG().jav_Open(SMW_IP,OFile)                          #Create SMW Object
SMW.debug = 0
FSW = VSA().jav_Open(FSW_IP,OFile)                          #Create FSW Object
FSW.debug = 0

class dataClass():
    def __init__(self):
#         self.Direction      = 'UL'
#         self.CellID         = 1
#         # self.FreqRng      = 'HIGH'
#         self.ChBW           = 100
#         self.TF             = 'ON'
#         self.SubSp          = 120
#         self.RB             = 60
#         self.RBO            = 0
#         self.Ch_RB          = 60
#         self.Ch_RBO         = 0
#         self.Mod            = 'QPSK'
Beispiel #3
0
class TestGeneral(unittest.TestCase):
    def setUp(self):  #run before each test
        self.FSW = VSA().jav_OpenTest(host)
        self.FSW.Init_5GNR()

    def tearDown(self):  #Run after each test
        self.assertEqual(self.FSW.jav_Error()[0], '0')
        self.FSW.jav_Close()

###############################################################################
### <Test>
###############################################################################

    def test_FSW_5GNR_Direction(self):
        self.FSW.Set_5GNR_Direction('UL')
        getVal = self.FSW.Get_5GNR_Direction()
        if self.FSW.connected: self.assertEqual(getVal, 'UL')
        self.FSW.Set_5GNR_Direction('DL')
        getVal = self.FSW.Get_5GNR_Direction()
        if self.FSW.connected: self.assertEqual(getVal, 'DL')

    def test_FSW_5GNR_Ex_Meas_Multi_CC(self):
        self.FSW.Init_5GNR_Meas('EVM')
        # Configure setup
        self.FSW.Set_5GNR_CellID(1)
        self.FSW.Set_5GNR_SubFrameCount(2)
        self.FSW.Set_5GNR_Result_View('ALL')  # Multi CC results
        self.FSW.Set_5GNR_EVMUnit('DB')
        self.FSW.Get_5GNR_Params_EVM()

    def test_FSW_5GNR_Ex_SEM(self):
        self.FSW.Init_5GNR_SEM()
        self.FSW.Set_5GNR_SEM_Freq(20e9)
        self.FSW.Set_5GNR_SEM_SubBlockNum(1)
        self.FSW.Get_5GNR_SEM()

    def test_FSW_5GNR_FreqRange(self):
        self.FSW.Set_5GNR_Direction('UL')
        self.FSW.Set_5GNR_FreqRange('LOW')
        getVal = self.FSW.Get_5GNR_FreqRange()
        if self.FSW.connected: self.assertEqual(getVal, 'LOW')

        self.FSW.Set_5GNR_FreqRange('MIDD')
        getVal = self.FSW.Get_5GNR_FreqRange()
        if self.FSW.connected: self.assertEqual(getVal, 'MIDD')

        self.FSW.Set_5GNR_FreqRange('HIGH')
        getVal = self.FSW.Get_5GNR_FreqRange()
        if self.FSW.connected: self.assertEqual(getVal, 'HIGH')

    def test_FSW_5GNR_Get_DL(self):
        self.FSW.Set_5GNR_Direction('DL')
        nullVal = self.FSW.Get_5GNR_CC_Freq()
        nullVal = self.FSW.Get_5GNR_Direction()
        nullVal = self.FSW.Get_5GNR_FreqRange()
        nullVal = self.FSW.Get_5GNR_RefA()
        nullVal = self.FSW.Get_5GNR_ChannelBW()
        nullVal = self.FSW.Get_5GNR_TransPrecoding()
        nullVal = self.FSW.Get_5GNR_PhaseCompensate()
        nullVal = self.FSW.Get_5GNR_SSB_SubSpace()
        nullVal = self.FSW.Get_5GNR_BWP_SubSpace()
        nullVal = self.FSW.Get_5GNR_BWP_Count()
        nullVal = self.FSW.Get_5GNR_BWP_ResBlock()
        nullVal = self.FSW.Get_5GNR_BWP_ResBlockOffset()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_Modulation()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_ResBlock()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_ResBlockOffset()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_SymbNum()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_SymbOff()
        if self.FSW.connected: nullVal = self.FSW.Get_5GNR_BWP_Center()
        ### "=DMRS="
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_Config()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_Mapping()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_1stDMRSSym()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_AddPosition()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_MSymbLen()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_SeqGenMeth()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_SeqGenSeed()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_RelPwr()
        ### "=PTRS=")
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_State()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_L()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_K()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_Pow()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_RE_Offset()

    def test_FSW_5GNR_Get_PTRS(self):
        self.FSW.Set_5GNR_Direction('DL')
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_State()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_L()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_K()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_Pow()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_RE_Offset()

    def test_FSW_5GNR_Get_Misc(self):
        self.FSW.Get_5GNR_ACLR()
        self.FSW.Get_5GNR_BWP_SlotNum()
        self.FSW.Get_5GNR_CC_Offset()
        self.FSW.Get_5GNR_Meas_ACLR()

    def test_FSW_5GNR_Get_UL(self):
        self.FSW.Set_5GNR_Direction('UL')
        nullVal = self.FSW.Get_5GNR_CC_Freq()
        nullVal = self.FSW.Get_5GNR_Direction()
        nullVal = self.FSW.Get_5GNR_FreqRange()
        nullVal = self.FSW.Get_5GNR_RefA()
        nullVal = self.FSW.Get_5GNR_ChannelBW()
        nullVal = self.FSW.Get_5GNR_TransPrecoding()
        nullVal = self.FSW.Get_5GNR_PhaseCompensate()
        nullVal = self.FSW.Get_5GNR_SSB_SubSpace()
        ### "=User="******"==Ch=="
        nullVal = self.FSW.Get_5GNR_BWP_Ch_Modulation()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_ResBlock()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_ResBlockOffset()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_SymbNum()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_SymbOff()
        if self.FSW.connected: nullVal = self.FSW.Get_5GNR_BWP_Center()
        ### "=DMRS="
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_Config()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_Mapping()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_1stDMRSSym()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_AddPosition()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_MSymbLen()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_SeqGenMeth()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_SeqGenSeed()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_DMRS_RelPwr()
        ### "=PTRS=")
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_State()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_L()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_K()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_Pow()
        nullVal = self.FSW.Get_5GNR_BWP_Ch_PTRS_RE_Offset()

    def test_FSW_5GNR_InstrState(self):
        self.FSW.Get_5GNR_TM_Cat()
        self.FSW.Set_5GNR_TM('NR-FR1-TM1_1__FDD_15MHz_30kHz')
        self.FSW.Set_5GNR_savesetting('test')
        self.FSW.Set_5GNR_AllocFile('test')  #mmm
        self.FSW.Set_5GNR_AllocFileSave('test')  #mmm

    def test_FSW_5GNR_Set_DL(self):
        self.FSW.Set_5GNR_Direction('DL')
        self.FSW.Set_5GNR_CC_Num(1)
        self.FSW.Set_5GNR_TransPrecoding('OFF')
        self.FSW.Set_5GNR_PhaseCompensate('ON')
        self.FSW.Set_5GNR_PhaseCompensate_Freq(1e6)
        self.FSW.Set_5GNR_FreqRange('HIGH')
        self.FSW.Set_5GNR_ChannelBW(100)
        self.FSW.Set_5GNR_BWP_SubSpace(120)
        self.FSW.Set_5GNR_BWP_ResBlock(66)
        self.FSW.Set_5GNR_BWP_ResBlockOffset(0)
        self.FSW.Set_5GNR_BWP_Ch_ResBlock(66)
        self.FSW.Set_5GNR_BWP_Corset_ResBlock(66)
        self.FSW.Set_5GNR_BWP_Ch_ResBlockOffset(0)
        self.FSW.Set_5GNR_BWP_Ch_Modulation('QPSK')
        # self.FSW.Set_5GNR_SSB()

    def test_FSW_5GNR_Set_DMRS(self):
        self.FSW.Set_5GNR_BWP_Ch_DMRS_1stDMRSSym(2)
        self.FSW.Set_5GNR_BWP_Ch_DMRS_AddPosition(0)
        self.FSW.Set_5GNR_BWP_Ch_DMRS_Config(1)
        self.FSW.Set_5GNR_BWP_Ch_DMRS_Mapping('A')
        self.FSW.Set_5GNR_BWP_Ch_DMRS_MSymbLen(1)
        self.FSW.Set_5GNR_BWP_Ch_DMRS_RelPwr(0)
        self.FSW.Set_5GNR_BWP_Ch_DMRS_SeqGenMeth('NICD')
        self.FSW.Set_5GNR_BWP_Ch_DMRS_SeqGenSeed(0)

    def test_FSW_5GNR_Set_UL(self):
        self.FSW.Set_5GNR_Direction('UL')
        self.FSW.Set_5GNR_CC_Num(1)
        self.FSW.Set_5GNR_TransPrecoding('OFF')
        self.FSW.Set_5GNR_PhaseCompensate('OFF')
        self.FSW.Set_5GNR_FreqRange('HIGH')
        self.FSW.Set_5GNR_ChannelBW(100)
        self.FSW.Set_5GNR_BWP_SubSpace(120)
        self.FSW.Set_5GNR_BWP_ResBlock(66)
        self.FSW.Set_5GNR_BWP_ResBlockOffset(0)
        self.FSW.Set_5GNR_BWP_Ch_ResBlock(66)
        self.FSW.Set_5GNR_BWP_Corset_ResBlock(66)
        self.FSW.Set_5GNR_BWP_Ch_ResBlockOffset(0)
        self.FSW.Set_5GNR_BWP_Ch_Modulation('QPSK')
Beispiel #4
0
 def setUp(self):  #run before each test
     self.FSW = VSA().jav_OpenTest(host)
     self.FSW.Init_5GNR()
Beispiel #5
0
class vari:
    def __init__(self):
        self.NR_ChBW = 0
        self.NR_SubSp = 0
        self.NR_RB = 0
        self.NR_Mod = ''
        self.NR_TF = "off"


NR5G = vari()

########################################################################
### Code Start
########################################################################
CMP = RCT()
FSW = VSA()
CMP.jav_Open(CMP_IP, OFile)
FSW.jav_Open(FSW_IP, OFile)

CMP.query('*IDN?')
FSW.write(':UNIT:EVM DB')
FSW.Set_SweepCont(0)
##########################################################
### Measure Time
##########################################################
#sDate = datetime.now().strftime("%y%m%d-%H:%M:%S.%f") #Date String
Header = 'Iter,Model,Freq,EVM,ChBW,UL-TP,SubSp,Mod,SMWPwr,Attn,Preamp,RefLvl,StepTime'
OFile.write(Header)

for i in range(numMeas):  #Loop: Repeatability
    for param in waveparam:  #Loop: Waveform Parameters
Beispiel #6
0
### User Entry
###############################################################################
instru_ip = '192.168.1.109'
centerFreq = 15e9  #GHz
SEMFreqmax = 2.345e9
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()
Beispiel #7
0
Pwr = -10
NumCC = 1
NR_Dir = 'UP'
CCSpace = 99.96e6
CCStart = (1 - NumCC) * (CCSpace / 2)

###############################################################################
### Code Overhead: Import and create objects
###############################################################################
import timeit
from rssd.VSG.NR5G_K144 import VSG  #pylint: disable=E0611,E0401
from rssd.VSA.NR5G_K144 import VSA  #pylint: disable=E0611,E0401
# from rssd.FileIO            import FileIO           #pylint: disable=E0611,E0401

if VSG_ON: SMW = VSG().jav_Open(SMW_IP)  #Create SMW Object
FSW = VSA().jav_Open(FSW_IP)  #Create FSW Object

###############################################################################
### Code Start
###############################################################################
if VSG_ON:
    SMW.Get_SysC_All()
    SMW.Set_Freq(Freq)  # SMW Freq --> BB Center
    SMW.Set_5GNR_BBState('OFF')
    SMW.Set_5GNR_Direction(NR_Dir)
    SMW.Set_5GNR_CC_Num(NumCC)
    SMW.Set_5GNR_PhaseCompensate('OFF')
    SMW.Set_RFPwr(Pwr)
    SMW.Set_RFState(1)

FSW.Init_5GNR()
Beispiel #8
0
### Author : mclim
### Date   : 2018.10.26
###
###############################################################################
### User Entry
###############################################################################
FSW_IP   = '192.168.1.109'

###############################################################################
### Code Overhead: Import and create objects
###############################################################################
from rssd.VSA.NR5G_K144     import VSA              #pylint: disable=E0611,E0401
from rssd.VSG.NR5G_K144     import VSG              #pylint: disable=E0611,E0401
# from rssd.FileIO            import FileIO           #pylint: disable=E0611,E0401

FSW = VSA().jav_Open(FSW_IP)                        #Create FSW Object
SMW = VSG().jav_Open('192.168.1.114')               #Create SMW Object

###############################################################################
### Code Start
###############################################################################
FSW.Set_5GNR_Direction('DL')
cat = SMW.Get_5GNR_TM_Cat()
print(len(cat))

FSW.Set_SweepCont(0)
for file in cat:
    print(file)
    FSW.Set_5GNR_TM(file)
    FSW.Set_5GNR_savesetting(file)
    # FSW.query(f'MMEM:STOR:DEM:CC1 "TM\{file}.allocation";*OPC?')
Beispiel #9
0
 def jav_OpenTest(self,SMW_IP,FSW_IP):
     self.SMW = VSG().jav_OpenTest(SMW_IP)  #Create SMW Object
     self.FSW = VSA().jav_OpenTest(FSW_IP)  #Create FSW Object
     return self
Beispiel #10
0
 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
Beispiel #11
0
class VST(object):
    """ Rohde & Schwarz Vector Signal Transciever 5GNR Object """
    def __init__(self):
        self.Freq      = 19e9
        self.SWM_Out   = 0
        self.NR_Dir    = 'UL'
        self.NR_Deploy = 'HIGH'     #LOW|MIDD|HIGH
        self.NR_PhaseC = 'OFF'      #ON|OFF
        self.NR_ChBW   = 100        #MHz
        self.NR_SubSp  = 120        #kHz
        self.NR_RB     = 66         #RB
        self.NR_RBO    = 0          #RB Offset
        self.NR_Mod    = 'QAM64'    #QPSK; QAM16; QAM64; QAM256; PITB
        self.NR_CC     = 1
        self.NR_TF     = 'OFF'

    def Get_5GNR_All(self):                     #pylint: disable=R0915
        DMRS = 1
        PTRS = 1
        self.SMW.cc     = self.NR_CC - 1
        self.FSW.cc     = self.NR_CC

        odata =  [[] for i in range(3)]
        odata[0].append("[[Parameter]]  ")
        odata[0].append("Center Freq    ")
        odata[0].append("Direction      ")
        odata[0].append("FreqRange      ")
        odata[0].append("RefA,MHz       ")
        odata[0].append("Ch BW          ")
        odata[0].append("TransPrecoding ")
        odata[0].append("Phase Compensat")
        odata[0].append("====SS/PBCH====")
        odata[0].append("SubSpacing     ")
        odata[0].append("===User/BWP====")
        odata[0].append("SubSpacing     ")
        odata[0].append("Num BWP        ")
        odata[0].append("BWP_RB         ")
        odata[0].append("BWP_RBoff      ")
        odata[0].append("====Channel====")
        odata[0].append("User_BWP_Mod   ")
        odata[0].append("User_BWP_RB    ")
        odata[0].append("User_BWP_RBOff ")
        odata[0].append("User_BWP_SymNum")
        odata[0].append("User_BWP_SymOff")
        odata[0].append("User_BWP_Cntr  ")
        if DMRS:
            odata[0].append("=====DMRS======")
            odata[0].append("DMRS Mapping   ")
            odata[0].append("DMRS FirstSym  ")
            odata[0].append("DMRS Config    ")
            odata[0].append("DMRS Add Positn")
            odata[0].append("DMRS Length    ")
            odata[0].append("DMRS SeqGenMeth")
            odata[0].append("DMRS SeqGenSeed")
            odata[0].append("DMRS Rel Power ")
        if PTRS:
            odata[0].append("=====PTRS======")
            odata[0].append("PTRS State     ")
            odata[0].append("Time L_PTRS    ")
            odata[0].append("Freq K_PTRS    ")
            odata[0].append("PTRS Rel Power ")
            odata[0].append("UL-PTRS-RE-offs")

        try:
            # self.SMW.Set_5GNR_Parameters(self.NR_Dir)
            odata[1].append("[-SMW-]")
            odata[1].append(self.SMW.Get_5GNR_CC_Freq())
            odata[1].append(self.SMW.Get_5GNR_Direction())
            odata[1].append(self.SMW.Get_5GNR_FreqRange())
            odata[1].append(self.SMW.Get_5GNR_RefA()/1e6)
            odata[1].append(self.SMW.Get_5GNR_ChannelBW())
            odata[1].append(self.SMW.Get_5GNR_TransPrecoding())
            odata[1].append(self.SMW.Get_5GNR_PhaseCompensate())
            odata[1].append("=SSB==")
            odata[1].append(self.SMW.Get_5GNR_SSB_SubSpace())
            odata[1].append("=User="******"==Ch==")
            odata[1].append(self.SMW.Get_5GNR_BWP_Ch_Modulation())
            odata[1].append(self.SMW.Get_5GNR_BWP_Ch_ResBlock())
            odata[1].append(self.SMW.Get_5GNR_BWP_Ch_ResBlockOffset())
            odata[1].append(self.SMW.Get_5GNR_BWP_Ch_SymbNum())
            odata[1].append(self.SMW.Get_5GNR_BWP_Ch_SymbOff())
            odata[1].append(self.SMW.Get_5GNR_BWP_Center()/1e6)
            if DMRS:
                odata[1].append("=DMRS=")
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_DMRS_Mapping())
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_DMRS_1stDMRSSym())

                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_DMRS_Config())
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_DMRS_AddPosition())
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_DMRS_MSymbLen())

                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_DMRS_SeqGenMeth())
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_DMRS_SeqGenSeed())
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_DMRS_RelPwr())
            if PTRS:
                odata[1].append("=PTRS=")
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_PTRS_State())
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_PTRS_L())
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_PTRS_K())
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_PTRS_Pow())
                odata[1].append(self.SMW.Get_5GNR_BWP_Ch_PTRS_RE_Offset())
        except:
            pass

        try:
            self.FSW.Init_5GNR()
            odata[2].append("[-FSW-]")
            odata[2].append(self.FSW.Get_5GNR_CC_Freq())
            odata[2].append(self.FSW.Get_5GNR_Direction())
            odata[2].append(self.FSW.Get_5GNR_FreqRange())
            odata[2].append(self.FSW.Get_5GNR_RefA()/1e6)
            odata[2].append(self.FSW.Get_5GNR_ChannelBW())
            odata[2].append(self.FSW.Get_5GNR_TransPrecoding())
            odata[2].append(self.FSW.Get_5GNR_PhaseCompensate())
            odata[2].append("=SSB==")
            odata[2].append(self.FSW.Get_5GNR_SSB_SubSpace())
            odata[2].append("=User="******"==Ch==")
            odata[2].append(self.FSW.Get_5GNR_BWP_Ch_Modulation())
            odata[2].append(self.FSW.Get_5GNR_BWP_Ch_ResBlock())
            odata[2].append(self.FSW.Get_5GNR_BWP_Ch_ResBlockOffset())
            odata[2].append(self.FSW.Get_5GNR_BWP_Ch_SymbNum())
            odata[2].append(self.FSW.Get_5GNR_BWP_Ch_SymbOff())
            odata[2].append(self.FSW.Get_5GNR_BWP_Center()/1e6)
            if DMRS:
                odata[2].append("=DMRS=")
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_DMRS_Mapping())
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_DMRS_1stDMRSSym())

                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_DMRS_Config())
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_DMRS_AddPosition())
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_DMRS_MSymbLen())

                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_DMRS_SeqGenMeth())
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_DMRS_SeqGenSeed())
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_DMRS_RelPwr())
            if PTRS:
                odata[2].append("=PTRS=")
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_PTRS_State())
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_PTRS_L())
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_PTRS_K())
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_PTRS_Pow())
                odata[2].append(self.FSW.Get_5GNR_BWP_Ch_PTRS_RE_Offset())
        except:
            pass
        print('SMW/FSW Values: %d %d'%(len(odata[2]),len(odata[2])))

        return odata

    def Get_5GNR_All_print(self):
        data = self.Get_5GNR_All()
        for i in range(len(data[0])):
            try:
                print(f"{data[0][i]}\t{data[1][i]}\t{data[2][i]}")
            except:
            #     try:
            #         print("%s\t%s\t%s"%(data[0][i],data[1][i],'<notRead>'))
            #     except:
            #         print("%s\t%s\t%s"%(data[0][i],'<notRead>',data[2][i]))
                pass

    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_OpenTest(self,SMW_IP,FSW_IP):
        self.SMW = VSG().jav_OpenTest(SMW_IP)  #Create SMW Object
        self.FSW = VSA().jav_OpenTest(FSW_IP)  #Create FSW Object
        return self

    def jav_Close(self):
        self.SMW.jav_Close()
        self.FSW.jav_Close()

    def jav_Clear(self):
        self.SMW.jav_Clear()
        self.FSW.jav_Clear()

    def Set_5GNR_All(self):
        try:
            ### SMW Settings
            self.SMW.cc     = self.NR_CC - 1
            self.SMW.Set_Freq(self.Freq)
            self.SMW.Set_5GNR_BBState('OFF')
            self.SMW.Set_5GNR_Direction(self.NR_Dir)
            self.SMW.Set_5GNR_TransPrecoding(self.NR_TF)
            self.SMW.Set_5GNR_PhaseCompensate(self.NR_PhaseC)
            self.SMW.Set_5GNR_FreqRange(self.NR_Deploy)
            self.SMW.Set_5GNR_ChannelBW(self.NR_ChBW)
            self.SMW.Set_5GNR_BWP_SubSpace(self.NR_SubSp)
            self.SMW.Set_5GNR_BWP_ResBlock(self.NR_RB)
            self.SMW.Set_5GNR_BWP_ResBlockOffset(self.NR_RBO)
            self.SMW.Set_5GNR_BWP_Ch_ResBlock(self.NR_RB)
            self.SMW.Set_5GNR_BWP_Corset_ResBlock(self.NR_RB)
            #self.SMW.Set_5GNR_BWP_Ch_ResBlockOffset(NR_RBO)
            self.SMW.Set_5GNR_BWP_Ch_Modulation(self.NR_Mod)
            self.SMW.Set_5GNR_SSB()
            self.SMW.Set_5GNR_BBState('ON')
            self.SMW.Set_RFState('ON')                            #Turn RF Output on
            self.SMW.Set_RFPwr(self.SWM_Out)                      #Output Power
        except:
            print("NR5G_SetSettings: SMW Error")

        try:
            ### FSW Setting
            # self.cc         = self.NR_CC
            self.FSW.Init_5GNR()
            self.FSW.Set_Freq(self.Freq)
            self.FSW.Set_5GNR_Direction(self.NR_Dir)
            self.FSW.Set_5GNR_TransPrecoding(self.NR_TF)
            self.FSW.Set_5GNR_PhaseCompensate(self.NR_PhaseC)
            self.FSW.Set_5GNR_FreqRange(self.NR_Deploy)
            self.FSW.Set_5GNR_ChannelBW(self.NR_ChBW)
            self.FSW.Set_5GNR_BWP_SubSpace(self.NR_SubSp)
            self.FSW.Set_5GNR_BWP_ResBlock(self.NR_RB)
            self.FSW.Set_5GNR_BWP_ResBlockOffset(self.NR_RBO)
            self.FSW.Set_5GNR_BWP_Ch_ResBlock(self.NR_RB)
            self.FSW.Set_5GNR_BWP_Corset_ResBlock(self.NR_RB)
            #self.FSW.Set_5GNR_BWP_Ch_ResBlockOffset(self.NR_RBO)
            self.FSW.Set_5GNR_BWP_Ch_Modulation(self.NR_Mod)
            self.FSW.Set_SweepCont(1)
            self.FSW.Set_InitImm()
        except:
            print("NR5G_SetSettings: FSW Error")
        return 0
Beispiel #12
0
###############################################################################
### Rohde & Schwarz Automation for demonstration use.
#pylint: disable=E0611,E0401
###############################################################################
FSW_IP = '192.168.58.109'

###############################################################################
### Overhead
###############################################################################
from rssd.VSA.NR5G_K144 import VSA

FSW = VSA().jav_Open(FSW_IP)  #Create FSW Object
FSW.debug = 0

###############################################################################
### Code Start
###############################################################################
FSW.Set_Freq(3.5e9)
FSW.Init_5GNR()
FSW.Set_5GNR_FrameCount('OFF')
FSW.Set_5GNR_Direction('UL')
# FSW.Set_5GNR_CellID(1024)
FSW.Set_5GNR_FreqRange('LOW')
FSW.Set_5GNR_ChannelBW(100)
FSW.write(f'CONF:NR5G:UL:CC1:FRAM1:BWP0:SLOT0:ALC 0')  # PUSCH Allocations
FSW.write(f'CONF:NR5G:UL:CC1:FRAM1:BWP0:SLOT0:UCCC 50')  # PUCCH Allocation
FSW.write(f':CONF:NR5G:UL:CC1:FRAM1:BWP0:CSL 1'
          )  # User configurable slots, rest copy

for ch in range(0, 44):
    ## Frame Configuration
Beispiel #13
0
##########################################################
### Rohde & Schwarz Automation for demonstration use.
###
### Title  : Timing SCPI Commands Example
### Author : mclim
### Date   : 2019.12.06
### Steps  : 
###
##########################################################
### User Entry
##########################################################
FSW_IP   = '192.168.1.109'
SaveName = 'test'

##########################################################
### Code Overhead: Import and create objects
##########################################################
from rssd.VSA.NR5G_K144    import VSA
FSW = VSA().jav_Open(FSW_IP)  #Create FSW Object

##########################################################
### Code Start
##########################################################
FSW.Set_5GNR_AllocFileSave(SaveName)
FSW.Set_Savestate(SaveName)

##########################################################
### Cleanup Automation
##########################################################
FSW.jav_Close()