scottk/OpenCellular
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenCellular.git synced 2025-12-25 01:07:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #189 from Telecominfraproject/octal_subbranch_cavium

Browse Source 
Adding baseline Cavium scripts
This commit is contained in:
dsaha26
2018-11-07 10:14:06 -08:00
committed by GitHub
parent 152843a420 70b63fddca
commit 87e21bb346
146 changed files with 9700 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
octal/cavium_env/rf_card_cal_tip/._cal_instructions_v10.docx Normal file
View File

Binary file not shown.

4
octal/cavium_env/rf_card_cal_tip/.idea/misc.xml generated Normal file
View File

@@ -0,0 +1,4 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectRootManager" version="2" project-jdk-name="Python 2.7" project-jdk-type="Python SDK" />
</project>

8
octal/cavium_env/rf_card_cal_tip/.idea/modules.xml generated Normal file
View File

@@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/rf_card_cal_tip.iml" filepath="$PROJECT_DIR$/.idea/rf_card_cal_tip.iml" />
</modules>
</component>
</project>

11
octal/cavium_env/rf_card_cal_tip/.idea/rf_card_cal_tip.iml generated Normal file
View File

@@ -0,0 +1,11 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="PYTHON_MODULE" version="4">
<component name="NewModuleRootManager">
<content url="file://$MODULE_DIR$" />
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
<component name="TestRunnerService">
<option name="PROJECT_TEST_RUNNER" value="Unittests" />
</component>
</module>

213
octal/cavium_env/rf_card_cal_tip/.idea/workspace.xml generated Normal file
View File

@@ -0,0 +1,213 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ChangeListManager">
<list default="true" id="f1eaeb0a-de90-4189-a620-a276a80d83d2" name="Default Changelist" comment="" />
<option name="EXCLUDED_CONVERTED_TO_IGNORED" value="true" />
<option name="SHOW_DIALOG" value="false" />
<option name="HIGHLIGHT_CONFLICTS" value="true" />
<option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
<option name="LAST_RESOLUTION" value="IGNORE" />
</component>
<component name="FUSProjectUsageTrigger">
<session id="-1060803192">
<usages-collector id="statistics.lifecycle.project">
<counts>
<entry key="project.open.time.0" value="1" />
<entry key="project.opened" value="1" />
</counts>
</usages-collector>
<usages-collector id="statistics.file.extensions.open">
<counts>
<entry key="py" value="4" />
<entry key="txt" value="1" />
</counts>
</usages-collector>
<usages-collector id="statistics.file.types.open">
<counts>
<entry key="PLAIN_TEXT" value="1" />
<entry key="Python" value="4" />
</counts>
</usages-collector>
</session>
</component>
<component name="FileEditorManager">
<leaf>
<file pinned="false" current-in-tab="false">
<entry file="file://$PROJECT_DIR$/main.py">
<provider selected="true" editor-type-id="text-editor">
<state relative-caret-position="-1880">
<caret line="627" column="48" lean-forward="true" selection-start-line="627" selection-start-column="48" selection-end-line="627" selection-end-column="48" />
</state>
</provider>
</entry>
</file>
<file pinned="false" current-in-tab="true">
<entry file="file://$PROJECT_DIR$/test_config.txt">
<provider selected="true" editor-type-id="text-editor">
<state relative-caret-position="357">
<caret line="21" column="49" lean-forward="true" selection-start-line="21" selection-start-column="49" selection-end-line="21" selection-end-column="49" />
</state>
</provider>
</entry>
</file>
<file pinned="false" current-in-tab="false">
<entry file="file://$PROJECT_DIR$/cal_tx_pwr.py">
<provider selected="true" editor-type-id="text-editor">
<state relative-caret-position="-3553">
<caret line="26" column="8" selection-start-line="26" selection-start-column="8" selection-end-line="26" selection-end-column="52" />
</state>
</provider>
</entry>
</file>
<file pinned="false" current-in-tab="false">
<entry file="file://$PROJECT_DIR$/cal_ref_clk_dac.py">
<provider selected="true" editor-type-id="text-editor">
<state relative-caret-position="36">
<caret line="90" column="17" lean-forward="true" selection-start-line="90" selection-start-column="17" selection-end-line="90" selection-end-column="17" />
</state>
</provider>
</entry>
</file>
<file pinned="false" current-in-tab="false">
<entry file="file://$PROJECT_DIR$/bb_eeprom.py">
<provider selected="true" editor-type-id="text-editor">
<state relative-caret-position="365">
<caret line="195" column="73" lean-forward="true" selection-start-line="195" selection-start-column="73" selection-end-line="195" selection-end-column="73" />
</state>
</provider>
</entry>
</file>
</leaf>
</component>
<component name="FindInProjectRecents">
<findStrings>
<find>write_bb_eeprom</find>
<find>cal_ref_clk_dac</find>
<find>CalRefClk</find>
<find>do_tx</find>
</findStrings>
</component>
<component name="IdeDocumentHistory">
<option name="CHANGED_PATHS">
<list>
<option value="$PROJECT_DIR$/main.py" />
</list>
</option>
</component>
<component name="ProjectFrameBounds" extendedState="1">
<option name="x" value="85" />
<option name="y" value="114" />
<option name="width" value="1842" />
<option name="height" value="900" />
</component>
<component name="ProjectView">
<navigator proportions="" version="1">
<foldersAlwaysOnTop value="true" />
</navigator>
<panes>
<pane id="ProjectPane">
<subPane>
<expand>
<path>
<item name="rf_card_cal_tip" type="b2602c69:ProjectViewProjectNode" />
<item name="rf_card_cal_tip" type="462c0819:PsiDirectoryNode" />
</path>
</expand>
<select />
</subPane>
</pane>
<pane id="Scope" />
</panes>
</component>
<component name="PropertiesComponent">
<property name="last_opened_file_path" value="$PROJECT_DIR$/../../cavium_env_5calib" />
</component>
<component name="RunDashboard">
<option name="ruleStates">
<list>
<RuleState>
<option name="name" value="ConfigurationTypeDashboardGroupingRule" />
</RuleState>
<RuleState>
<option name="name" value="StatusDashboardGroupingRule" />
</RuleState>
</list>
</option>
</component>
<component name="SvnConfiguration">
<configuration />
</component>
<component name="TaskManager">
<task active="true" id="Default" summary="Default task">
<changelist id="f1eaeb0a-de90-4189-a620-a276a80d83d2" name="Default Changelist" comment="" />
<created>1540235473732</created>
<option name="number" value="Default" />
<option name="presentableId" value="Default" />
<updated>1540235473732</updated>
</task>
<servers />
</component>
<component name="ToolWindowManager">
<frame x="85" y="114" width="1842" height="900" extended-state="1" />
<editor active="true" />
<layout>
<window_info id="Favorites" side_tool="true" />
<window_info active="true" content_ui="combo" id="Project" order="0" visible="true" weight="0.25" />
<window_info id="Structure" order="1" side_tool="true" weight="0.25" />
<window_info anchor="bottom" id="Version Control" show_stripe_button="false" />
<window_info anchor="bottom" id="Python Console" />
<window_info anchor="bottom" id="Terminal" />
<window_info anchor="bottom" id="Event Log" side_tool="true" />
<window_info anchor="bottom" id="Message" order="0" />
<window_info anchor="bottom" id="Find" order="1" />
<window_info anchor="bottom" id="Run" order="2" />
<window_info anchor="bottom" id="Debug" order="3" weight="0.4" />
<window_info anchor="bottom" id="Cvs" order="4" weight="0.25" />
<window_info anchor="bottom" id="Inspection" order="5" weight="0.4" />
<window_info anchor="bottom" id="TODO" order="6" />
<window_info anchor="right" id="Commander" internal_type="SLIDING" order="0" type="SLIDING" weight="0.4" />
<window_info anchor="right" id="Ant Build" order="1" weight="0.25" />
<window_info anchor="right" content_ui="combo" id="Hierarchy" order="2" weight="0.25" />
</layout>
</component>
<component name="VcsContentAnnotationSettings">
<option name="myLimit" value="2678400000" />
</component>
<component name="editorHistoryManager">
<entry file="file://$PROJECT_DIR$/cal_ref_clk_dac.py">
<provider selected="true" editor-type-id="text-editor">
<state relative-caret-position="36">
<caret line="90" column="17" lean-forward="true" selection-start-line="90" selection-start-column="17" selection-end-line="90" selection-end-column="17" />
</state>
</provider>
</entry>
<entry file="file://$PROJECT_DIR$/bb_eeprom.py">
<provider selected="true" editor-type-id="text-editor">
<state relative-caret-position="365">
<caret line="195" column="73" lean-forward="true" selection-start-line="195" selection-start-column="73" selection-end-line="195" selection-end-column="73" />
</state>
</provider>
</entry>
<entry file="file://$PROJECT_DIR$/main.py">
<provider selected="true" editor-type-id="text-editor">
<state relative-caret-position="-1880">
<caret line="627" column="48" lean-forward="true" selection-start-line="627" selection-start-column="48" selection-end-line="627" selection-end-column="48" />
</state>
</provider>
</entry>
<entry file="file://$PROJECT_DIR$/cal_tx_pwr.py">
<provider selected="true" editor-type-id="text-editor">
<state relative-caret-position="-3553">
<caret line="26" column="8" selection-start-line="26" selection-start-column="8" selection-end-line="26" selection-end-column="52" />
</state>
</provider>
</entry>
<entry file="file://$PROJECT_DIR$/test_config.txt">
<provider selected="true" editor-type-id="text-editor">
<state relative-caret-position="357">
<caret line="21" column="49" lean-forward="true" selection-start-line="21" selection-start-column="49" selection-end-line="21" selection-end-column="49" />
</state>
</provider>
</entry>
</component>
</project>

225
octal/cavium_env/rf_card_cal_tip/bb_eeprom.py Normal file
View File

@@ -0,0 +1,225 @@
#!/usr/bin/python
import sys
import os.path
import test_config
from time import sleep
from im_calibration import Calibration
class BBEepromAccess(Calibration):
def __init__(self):
self.cfg = test_config.EnbConfig()
self.cfg_file = 'bb_eeprom.txt'
self.SerialNum = '12345678' # 12 bytes
self.boardname = 'zen' # ('refkit1', 'zen') default 'zen'
self.boardversion = 7 # (1 to 254)
self.NumETHPort = 1 # (1 or 2) default 1
self.ExtPTPHWPresent = 1 # (0 not present, 1 present)
self.ExtPTPHWUARTPort = 'ttyS1' # (port name) default 'ttyS1'
self.ExtPTPHWUARTBaud = 6 # (1: 4800 2: 9600 3: 19200 4: 38400 5: 57600
# 6: 115200 7: 230400); default 6
self.ExtPTPHWUARTEcho = 0 # (0 disable, 1 enable) default 0
self.ExtGPSHWPresent = 0 # (0 not present, 1 present)
self.ExtGPSHWUARTPort = 'ttyS1' # (port name) default 'ttyS1'
self.ExtGPSHWUARTBaud = 6 # (1: 4800 2: 9600 3: 19200 4: 38400 5: 57600
# 6: 115200 7: 230400); default 6
self.ExtGPSHWUARTEcho = 0 # (0 disable, 1 enable) default 0
self.SimCardPresent = 0 # (0 not present, 1 present)
self.SDCardPresent = 0 # (0 not present, 1 present)
self.USBPortPresent = 0 # (0 not present, 1 present)
self.PCIEPresent = 0 # (0 not present, 1 present)
self.EthSwitchPresent = 0 # (0 not present, 1 present)
self.PtpVcoDriftPresent = 0 # (0 not present, 1 present)
self.PtpVcoDriftValue = 0 # signed integer
self.read_bb_config_file()
def start_enodeb(self):
type(self).enb.enb_login()
type(self).enb.enb_cd_usr_bin()
#type(self).enb.enb_load_rf_driver()
def read_line(self, strline):
param = ""
value = ""
sn = strline
if ((sn[0] != '#') and (sn[0] != ' ') and
(sn[0] != '\n') and (sn[0] != '\r') and
(sn[0] != '\t')):
result = sn.split('=')
param = result[0]
value = result[1]
for i in range(len(value)):
if ((value[i] == '\n') or (value[i] == '\r')):
value = value[:i]
break
elif ((value[i] == " ") or (value[i] == "#") or (value[i] == '\t')):
value = value[:i]
break
value = value.strip("\'")
#print("read_line(): param=%s, value=%s" % (param, value))
return param, value
def read_bb_config_file(self):
#if not os.path.isfile(self.cfg_file):
# print 'error, bb_eeprom.txt not exists'
# exit(-1)
cfgfile = open(self.cfg_file, 'r')
cfgln = cfgfile.readlines()
cfgfile.close()
for cl in cfgln:
par, val = self.read_line(cl)
if (par == 'SerialNum'):
self.SerialNum = val
elif (par == 'boardname'):
self.boardname = val
elif (par == 'boardversion'):
self.boardversion = int(val)
elif (par == 'NumETHPort'):
self.NumETHPort = int(val)
elif (par == 'ExtPTPHWUARTPort'):
self.ExtPTPHWUARTPort = val
elif (par == 'ExtGPSHWUARTPort'):
self.ExtGPSHWUARTPort = val
elif (par == 'ExtPTPHWPresent'):
self.ExtPTPHWPresent = int(val)
elif (par == 'ExtPTPHWUARTBaud'):
self.ExtPTPHWUARTBaud = int(val)
elif (par == 'ExtPTPHWUARTEcho'):
self.ExtPTPHWUARTEcho = int(val)
elif (par == 'ExtGPSHWPresent'):
self.ExtGPSHWPresent = int(val)
elif (par == 'ExtGPSHWUARTBaud'):
self.ExtGPSHWUARTBaud = int(val)
elif (par == 'ExtGPSHWUARTEcho'):
self.ExtGPSHWUARTEcho = int(val)
elif (par == 'SimCardPresent'):
self.SimCardPresent = int(val)
elif (par == 'SDCardPresent'):
self.SDCardPresent = int(val)
elif (par == 'USBPortPresent'):
self.USBPortPresent = int(val)
elif (par == 'PCIEPresent'):
self.PCIEPresent = int(val)
elif (par == 'EthSwitchPresent'):
self.EthSwitchPresent = int(val)
elif (par == 'PtpVcoDriftPresent'):
self.PtpVcoDriftPresent = int(val)
elif (par == 'PtpVcoDriftValue'):
self.PtpVcoDriftValue = int(val)
elif (par == ''):
continue
else:
pass
def read_bb_eeprom(self):
_ = self.enb.tn.read_until('login'.encode("ascii"), 5)
print ''
print 'Serial Number: ' + self.do_driver_reading('rsn')
print 'Board Name: ' + self.do_driver_reading('rbn')
print 'Board Version: ' + self.do_driver_reading('rbv')
print 'Number ETH Port: ' + self.do_driver_reading('rne')
print 'EXT PTP Present: ' + self.do_driver_reading('rpp')
print 'EXT PTP UART Port: ' + self.do_driver_reading('rpo')
print 'EXT PTP UART Baud: ' + self.do_driver_reading('rpb')
print 'EXT PTP UART Echo: ' + self.do_driver_reading('rpe')
print 'EXT GPS Present: ' + self.do_driver_reading('rgp')
print 'EXT GPS UART Port: ' + self.do_driver_reading('rgo')
print 'EXT GPS UART Baud: ' + self.do_driver_reading('rgb')
print 'EXT GPS UART Echo: ' + self.do_driver_reading('rge')
print 'SimCard Present: ' + self.do_driver_reading('rsp')
print 'SD Card Present: ' + self.do_driver_reading('rdp')
print 'USB Port Present: ' + self.do_driver_reading('rup')
print 'PCIE Present: ' + self.do_driver_reading('rcp')
print 'ETH Switch Present: ' + self.do_driver_reading('rwp')
print 'PTP VCO Drift Present: ' + self.do_driver_reading('rvp')
print 'PTP VCO Drift Value: ' + self.do_driver_reading('rvv')
print ''
def convert_baud_rate(self, baudNum):
res = 0
if baudNum == 1:
res = 4800
elif baudNum == 2:
res = 9600
elif baudNum == 3:
res = 19200
elif baudNum == 4:
res = 38400
elif baudNum == 5:
res = 57600
elif baudNum == 6:
res = 115200
elif baudNum == 7:
res = 230400
else:
res = -1
return str(res).encode('ascii')
def do_driver_reading(self, cmd):
self.enb.tn_write('Option', "oncpu 0 /usr/bin/" + self.cfg.rf_driver)
self.enb.tn_write('option', "be")
self.enb.tn_write(':', cmd)
res = self.enb.tn.read_until('*'.encode("ascii"), 5)
self.enb.tn_write('/usr/bin', "q")
#print 'get:' + res + ':got'
start = 0
start = res.find("= ".encode("ascii"), start)
start += len("= ")
data = res[start:res.find('*'.encode("ascii"), start)].strip()
return data
def write_bb_serial_number(self, serialNum):
self.enb.enb_bb_eeprom_edit_record('wsn', serialNum)
def write_bb_eeprom(self):
#self.enb.enb_bb_eeprom_edit_record('wsn', self.SerialNum)
self.enb.enb_bb_eeprom_edit_record('wbn', self.boardname)
self.enb.enb_bb_eeprom_edit_record('wbv', str(self.boardversion))
self.enb.enb_bb_eeprom_edit_record('wne', str(self.NumETHPort))
self.enb.enb_bb_eeprom_edit_record('wpp', str(self.ExtPTPHWPresent))
self.enb.enb_bb_eeprom_edit_record('wpo', self.ExtPTPHWUARTPort)
self.enb.enb_bb_eeprom_edit_record('wpb', str(self.ExtPTPHWUARTBaud))
self.enb.enb_bb_eeprom_edit_record('wpe', str(self.ExtPTPHWUARTEcho))
self.enb.enb_bb_eeprom_edit_record('wgp', str(self.ExtGPSHWPresent))
self.enb.enb_bb_eeprom_edit_record('wgo', self.ExtGPSHWUARTPort)
self.enb.enb_bb_eeprom_edit_record('wgb', str(self.ExtGPSHWUARTBaud))
self.enb.enb_bb_eeprom_edit_record('wge', str(self.ExtGPSHWUARTEcho))
self.enb.enb_bb_eeprom_edit_record('wsp', str(self.SimCardPresent))
self.enb.enb_bb_eeprom_edit_record('wdp', str(self.SDCardPresent))
self.enb.enb_bb_eeprom_edit_record('wup', str(self.USBPortPresent))
self.enb.enb_bb_eeprom_edit_record('wcp', str(self.PCIEPresent))
self.enb.enb_bb_eeprom_edit_record('wwp', str(self.EthSwitchPresent))
self.enb.enb_bb_eeprom_edit_record('wvp', str(self.PtpVcoDriftPresent))
self.enb.enb_bb_eeprom_edit_record('wvv', str(self.PtpVcoDriftValue))
def erase_bb_eeprom(self):
answer = raw_input("Are you sure erase EEPROM?(y or n):")
if (answer == 'y') or (answer == 'Y'):
print 'earsing baseboard EEPROM...'
self.enb.tn_write('Option', "oncpu 0 /usr/bin/" + self.cfg.rf_driver)
self.enb.tn_write('option', "be")
self.enb.tn_write(':', 'eei')
self.enb.tn_write('option', 'y', 60)
self.enb.tn_write('/usr/bin', "q", 3)
print 'erase done'

BIN
octal/cavium_env/rf_card_cal_tip/bb_eeprom.pyc Normal file
View File

Binary file not shown.

23
octal/cavium_env/rf_card_cal_tip/bb_eeprom.txt Normal file
View File

@@ -0,0 +1,23 @@
# Baseboard EEPROM Data
boardname='zen' # ('refkit1', 'zen') default 'zen'
boardversion=10 # (1 to 254)
NumETHPort=1 # (1 or 2) default 1
ExtPTPHWPresent=1 # (0 not present, 1 present)
ExtPTPHWUARTPort='ttyS1' # (port name) default 'ttyS1'
ExtPTPHWUARTBaud=6 # (1: 4800 2: 9600 3: 19200 4: 38400 5: 57600
# 6: 115200 7: 230400); default 6
ExtPTPHWUARTEcho=0 # (0 disable, 1 enable) default 0
ExtGPSHWPresent=1 # (0 not present, 1 present)
ExtGPSHWUARTPort='ttyS1' # (port name) default 'ttyS1'
ExtGPSHWUARTBaud=6 # (1: 4800 2: 9600 3: 19200 4: 38400 5: 57600
# 6: 115200 7: 230400); default 6
ExtGPSHWUARTEcho=0 # (0 disable, 1 enable) default 0
SimCardPresent=0 # (0 not present, 1 present)
SDCardPresent=0 # (0 not present, 1 present)
USBPortPresent=0 # (0 not present, 1 present)
PCIEPresent=0 # (0 not present, 1 present)
EthSwitchPresent=0 # (0 not present, 1 present)
PTPVcoDriftPresent=0 # (0 not present, 1 present)
PTPVcoDriftValue=0 # signed integer

492
octal/cavium_env/rf_card_cal_tip/bb_testterm.py Normal file
View File

@@ -0,0 +1,492 @@
#!/usr/bin/python
# Very simple serial terminal
# (C)2002-2004 Chris Liechti <cliecht@gmx.net>
import test_config
#weison import sys, os, serial, threading, getopt
import sys, os, threading, getopt
#weison import enhancedserial
from time import sleep
from im_calibration import Calibration
EXITCHARCTER = '\x04' #ctrl+D
FUNCCHARCTER = '\x01' #ctrl+A
CONVERT_CRLF = 2
CONVERT_CR = 1
CONVERT_LF = 0
if os.name == 'nt':
print "OS = Windows"
import msvcrt
elif os.name == 'posix':
print "OS = Linux"
import termios
else:
raise "Sorry no implementation for your platform (%s) available." % sys.platform
class TestTerm(Calibration):
def __init__(self, osname):
#initialize with defaults
#self.port = 'COM11' #'/dev/ttyUSB0'
#self.baudrate = 115200
#self.pingip = '10.18.104.189' #'192.168.166.202' #'10.102.81.5'
self.port = type(self).cfg.bb_port
self.baudrate = type(self).cfg.bb_baudrate
self.pingip = type(self).cfg.bb_pingip
self.echo = 0
self.convert_outgoing = CONVERT_CR
self.newline = '';
self.rtscts = 0
self.xonxoff = 0
self.repr_mode = 0
self.os_name = osname
def getkey(self):
return raw_input()
def getkey_org(self):
if self.os_name == 'nt':
while True:
if self.echo:
z = msvcrt.getche()
else:
z = msvcrt.getch()
if z == '\0' or z == '\xe0': #functions keys
msvcrt.getch()
else:
if z == '\r':
return '\n'
return z
elif self.os_name == 'posix':
fd = sys.stdin.fileno()
old = termios.tcgetattr(fd)
new = termios.tcgetattr(fd)
new[3] = new[3] & ~termios.ICANON & ~termios.ECHO
new[6][termios.VMIN] = 1
new[6][termios.VTIME] = 0
termios.tcsetattr(fd, termios.TCSANOW, new)
self.ts = '' # We'll save the characters typed and add them to the pool.
def clenaup_console():
if self.os_name == 'posix':
termios.tcsetattr(fd, termios.TCSAFLUSH, old)
def reader(self):
"""loop forever and copy serial->console"""
while 1:
try:
data = self.ts.read()
except:
e = sys.exc_info()[0]
print "--- Exception ignored: ", sys.exc_info()[0]
if self.repr_mode:
sys.stdout.write(repr(data)[1:-1])
else:
sys.stdout.write(data)
sys.stdout.flush()
def writer(self):
"""loop and copy console->serial until EOF character is found"""
c = FUNCCHARCTER
while True:
if c == EXITCHARCTER:
break #exit app
elif c == FUNCCHARCTER:
self.menu()
return
elif c == '\n':
self.ts.write(self.newline)
else:
self.ts.write(c) #send character
c = self.getkey()
#print(":".join(a.encode('hex') for a in c))
def menu(self):
ret=' ';
while True:
print("--- Starting a new test...")
print("--- Reset Zen to initial test procedure...")
self.ts.wait_until("Clearing DRAM......", timeout=0);
self.ts.write(self.newline + self.newline);
self.ts.wait_until("Octeon zen=>","Octeon titan_cnf7130=>", timeout=0);
ret = self.uboot_menu(ret)
if 1 == ret: return;
self.ts.wait_until("LSM login:", timeout=0);
self.ts.write('root' + self.newline);
ret = self.kernel_menu(ret)
if 1 == ret: return;
def kernel_menu(self, batch_cmd = ' '):
sleep(0.1)
bac=batch_cmd;
while 1:
print("\n")
print("--- 1. Network: Ping "+self.pingip)
print("--- 2. GPIO LED: blink(GPIO 0, 6, 7)")
print("--- 3. Flash write/read test(/dev/mtdblock7)")
#print("--- 4. SD/MMC write/read test(/dev/mmcblk0)")
print("--- 4. GPS query test")
print("--- r. Restart test")
print("--- q. Quit")
print("--- Please select function:")
if len(bac) > 1:
c = bac[0]
bac = bac[1:]
else:
c = self.getkey()
#c = self.getkey()
if c == '1' :
print("\n--- Starting Ping test...")
self.ts.write(self.newline+'ping -c3 -q '+self.pingip+self.newline);
ret=self.ts.wait_until("0 received","1 received","2 received","3 received",timeout=5);
sleep(0.1)
if ret > 0 :
print("\n\n--- RESULT : Ping test PASSED\n")
else:
print("\n\n--- RESULT : Ping test FAILED!!\n")
bac=' '
elif c == '2':
for a in [0,6,7]:
print("\n--- GPIO LED %d blink test..."%a)
self.ts.write(self.newline+'toggle 1 %d '%a+self.newline);
sleep(0.1)
print("--- Please check if GPIO %d LED are blinking..."%a)
print("--- Press Y/y if the LED is blinking, others mean failed...")
c = self.getkey()
if c == 'y' or c == 'Y':
print("\n\n--- RESULT: LED %d test PASSED"%a)
else:
print("\n\n--- RESULT: LED %d test FAILED"%a)
self.ts.write('\x03');
elif c == '3':
print("\n--- Starting flash test...")
self.ts.write(self.newline +
'DEV=/dev/mtdblock7; dd if=/dev/urandom of=test bs=1M count=1; \
dd if=test of=$DEV bs=1M count=1; dd if=$DEV of=test1 bs=1M count=1;\
cmp test test1 && echo Files are the same!!;' + self.newline);
ret = self.ts.wait_until("Files are the same!!","differ:",timeout=30);
sleep(0.1)
if ret == 0:
print ("\n\n--- RESULT : flash test PASSED\n")
else:
print("\n\n--- RESULT : flash test FAILED\n")
bac=' '
elif c == '4':
print("\n--- Starting GPS query test...")
self.ts.write(self.newline+' cat > /gps_test.sh << EOF'+self.newline+
'#!/bin/sh'+self.newline+
'i=0'+self.newline+
'cat /dev/ttyS1 |grep -a -m 1 "GP" > /tmp/gps_result &'+self.newline+
'while true'+self.newline+
'do'+self.newline+
' sleep 1'+self.newline+
' result=\`cat /tmp/gps_result\`'+self.newline+
' if [ -z "\$result" ]; then '+self.newline+
' if [ "\$i" -ge "5" ];then echo "gps module test is failed!!"; break; fi '+self.newline+
' '+self.newline+
' else'+self.newline+
' echo "gps module test is passed!!";'+self.newline+
' break;'+self.newline+
' fi'+self.newline+
' true \$(( i++ ))'+self.newline+
'done'+self.newline+
'exit 0'+self.newline+
'EOF'+self.newline);
ret=self.ts.wait_until("EOF");
ret=self.ts.wait_until("EOF");
self.ts.write('sh /gps_test.sh'+self.newline);
ret=self.ts.wait_until("gps module test is failed","gps module test is passed");
sleep(0.1)
if ret == 1: print ("\n\n--- RESULT : GPS query test PASSED!\n")
elif ret == 0: print("\n\n--- RESULT : GPS query test FAILED\n")
else:
print("\n\n--- RESULT : GPS query test FAILED (timeout) \n")
bac=' '
elif c == 'r' or c == 'R':
print("--- Restarting test!!")
return ' '
elif c == 'q' or c == 'Q':
print("--- Quit test mode!!")
return 1
else:
print("--- Error: unknown function!!")
return ' '
def uboot_menu(self, batch_cmd = ' '):
sleep(0.1)
bac = batch_cmd;
while 1:
print("\n\n")
print("--- 1. Run all the tests")
print("--- 2. Reset button")
print("--- 3. Memory: u-boot mtest")
print("--- 4. BB/RF Temperature sensor test")
print("--- 5. BB EEPROM test")
print("--- 6. RF EEPROM test")
print("--- 7. DSP test")
print("--- k. Boot to kernel")
print("--- r. Reset u-boot environment variables")
print("--- q. Quit")
print("--- Please select function:")
if len(bac) > 1:
c = bac[0]
bac = bac[1:]
else:
c = self.getkey()
print "selection = " + c
if c == '1' :
print("\n--- Run all the tests")
#bac='234567k1234r '
bac='234567k1234 '
elif c == '2':
print("\n--- Starting Reset button test...\n")
print("Please press reset button in 10 seconds...\n")
ret=self.ts.wait_until("Clearing DRAM......",timeout=20);
if ret>=0 :
self.ts.write(self.newline+self.newline);
ret=self.ts.wait_until("Octeon zen=>","Octeon titan_cnf7130=>", timeout=10);
if ret<0 : print("\n\n--- RESULT : Reset button test FAILED (for wait timeout)\n")
else : print("\n\n--- RESULT : Reset button test PASSED\n")
elif c == '3':
print("\n--- Starting memroy test...")
self.ts.write('echo '+self.newline+'mtest 80100000 80ffffff 5a5aa5a5 a'+self.newline);
ret=self.ts.wait_until("0 errors","errors",timeout=15);
sleep(0.1)
if ret==0 : print("\n\n--- RESULT : Memory test PASSED\n")
elif ret==1 : print("\n\n--- RESULT : Memory test FAILED\n")
elif ret<0 : print("\n\n--- RESULT : Memory test FAILED (for wait timeout)\n")
elif c == '4':
print("\n--- Starting BB/RF Temperature sensor test...\n")
self.ts.write('echo '+self.newline+'dtt'+self.newline);
ret=self.ts.wait_until("DTT0: Failed init!", "DTT1: Failed init!", "C")
sleep(0.5)
if ret==2 : print("\n\n--- RESULT : BB/RF Temperature sensor test PASSED\n")
elif ret>=0 : print("\n\n--- RESULT : BB/RF Temperature sensor test FAILED\n")
else : print("\n\n--- RESULT : BB/RF Temperature sensor test FAILED (for wait timeout)\n")
elif c == '5':
print("\n--- Starting BB EEPROM test...\n")
self.ts.write('echo '+self.newline+'i2c md 50 0.2 0x100'+self.newline);
ret=self.ts.wait_until("00f0:","Error");
sleep(0.1)
if ret==0 : print("\n\n--- RESULT : BB EEPROM test PASSED\n")
elif ret==1 : print("\n\n--- RESULT : BB EEPROM test FAILED\n")
elif ret<0 : print("\n\n--- RESULT : BB EEPROM test FAILED (for wait timeout)\n")
elif c == '6':
print("\n--- Starting RF EEPROM test...\n")
self.ts.write('echo '+self.newline+'i2c md 51 0.2 0x100'+self.newline);
ret=self.ts.wait_until("00f0:","Error");
sleep(0.1)
if ret==0 : print("\n\n--- RESULT : RF EEPROM test PASSED\n")
elif ret==1 : print("\n\n--- RESULT : RF EEPROM test FAILED\n")
elif ret<0 : print("\n\n--- RESULT : RF EEPROM test FAILED (for wait timeout)\n")
elif c == '7':
print("\n--- Starting DSP query test...\n")
self.ts.write('echo '+self.newline+'echo CVMX_EOI_CTL_STA; md64 0x0001180013000000 1;'+self.newline);
ret=self.ts.wait_until("8001180013000000:");
if ret < 0 :
print("\n\n--- RESULT : DSP query test for reading CVMX_EOI_CTL_STA FAILED (for wait timeout)\n")
break
sleep(0.1)
self.ts.write('echo '+self.newline+'mw64 0x0001180013000000 0x800 1;echo CVMX_EOI_CTL_STA; md64 0x0001180013000000 1;'+self.newline);
ret=self.ts.wait_until("8001180013000000: 0000000000000800");
if ret < 0 :
print("\n\n--- RESULT : DSP query test for writing CVMX_EOI_CTL_STA FAILED 1 (for wait timeout)\n")
break
sleep(0.1)
self.ts.write('echo '+self.newline+'mw64 0x0001180013000000 0x802 1;echo CVMX_EOI_CTL_STA; md64 0x0001180013000000 1;'+self.newline);
ret=self.ts.wait_until("8001180013000000: 0000000000000802");
if ret < 0 :
print("\n\n--- RESULT : DSP query test for writing CVMX_EOI_CTL_STA FAILED 2 (for wait timeout)\n")
break
sleep(0.1)
self.ts.write('echo '+self.newline+'echo BBP_RSTCLK_CLKENB1_STATE 0x00010F0000844430; read64l 0x00010F0000844430;'+self.newline);
ret=self.ts.wait_until("0x80010f0000844430:");
if ret < 0 :
print("\n\n--- RESULT : DSP query test for reading BBP_RSTCLK_CLKENB1_STATE FAILED (for wait timeout)\n")
break
sleep(0.1)
self.ts.write('echo '+self.newline+'write64l 0x00010F0000844438 0xff; echo BBP_RSTCLK_CLKENB1_STATE 0x00010F0000844430; read64l 0x00010F0000844430;'+self.newline);
ret=self.ts.wait_until("0x80010f0000844430: 0x0");
if ret < 0 :
print("\n\n--- RESULT : DSP query test for clearing BBP_RSTCLK_CLKENB1_STATE FAILED (for wait timeout)\n")
break
sleep(0.1)
self.ts.write('echo '+self.newline+'write64l 0x00010F0000844434 0xff; echo BBP_RSTCLK_CLKENB1_STATE 0x00010F0000844430; read64l 0x00010F0000844430;'+self.newline);
ret=self.ts.wait_until("0x80010f0000844430: 0xff");
if ret < 0 :
print("\n\n--- RESULT : DSP query test for setting BBP_RSTCLK_CLKENB1_STATE FAILED (for wait timeout)\n")
break
sleep(0.1)
print("\n\n--- RESULT : DSP query test PASSED\n")
elif c == 'k':
print("\n--- Running bootcmd...\n")
self.ts.write('echo '+self.newline+'run bootcmd'+self.newline);
return bac;
elif c == 'r':
print("\n--- Resetting u-boot environment variables...")
self.ts.write('echo '+self.newline+'setenv blabla xxx; savenv'+self.newline);
elif c == 'q' or c == 'Q':
print("--- Quit test mode!!")
return 1
else:
print("--- Error: unknown function!!")
return 0
#print a short help message
def usage(self):
sys.stderr.write("""USAGE: %s [options]
Miniterm - A simple terminal program for the serial port.
options:
-p, --port=PORT: port, a number, default = 0 or a device name
-b, --baud=BAUD: baudrate, default 9600
-r, --rtscts: enable RTS/CTS flow control (default off)
-x, --xonxoff: enable software flow control (default off)
-e, --echo: enable local echo (default off)
-c, --cr: do not send CR+LF, send CR only
-n, --newline: do not send CR+LF, send LF only
-D, --debug: debug received data (escape nonprintable chars)
""" % (sys.argv[0], ))
def run(self):
#parse command line options
try:
opts, args = getopt.getopt(sys.argv[1:],
"hp:b:rxecnD",
["help", "port=", "baud=", "rtscts", "xonxoff", "echo",
"cr", "newline", "debug"]
)
except getopt.GetoptError:
# print help information and exit:
self.usage()
sys.exit(2)
for o, a in opts:
if o in ("-h", "--help"): #help text
self.usage()
sys.exit()
elif o in ("-p", "--port"): #specified port
try:
self.port = int(a)
except ValueError:
self.port = a
elif o in ("-b", "--baud"): #specified baudrate
try:
self.baudrate = int(a)
except ValueError:
raise ValueError, "Baudrate must be a integer number, not %r" % a
elif o in ("-r", "--rtscts"):
self.rtscts = 1
elif o in ("-x", "--xonxoff"):
self.xonxoff = 1
elif o in ("-e", "--echo"):
self.echo = 1
elif o in ("-c", "--cr"):
self.convert_outgoing = CONVERT_CR
elif o in ("-n", "--newline"):
self.convert_outgoing = CONVERT_LF
elif o in ("-D", "--debug"):
self.repr_mode = 1
if self.convert_outgoing == CONVERT_CRLF:
self.newline = '\r\n' #make it a CR+LF
elif self.convert_outgoing == CONVERT_CR:
self.newline = '\r' #make it a CR
elif self.convert_outgoing == CONVERT_LF:
self.newline = '\n' #make it a LF
#open the port
try:
self.ts = enhancedserial.EnhancedSerial(self.port, self.baudrate,
rtscts=self.rtscts, xonxoff=self.xonxoff)
except:
sys.stderr.write("Could not open port %s \n"%self.port)
sys.exit(1)
#sys.stderr.write("--- type Ctrl-D or Ctrl-C to quit\n")
#sys.stderr.write("--- type Ctrl-A to enter test mode\n")
#start serial->console thread
r = threading.Thread(target=self.reader)
r.setDaemon(True)
r.start()
#and enter console->serial loop
self.writer()
r.join(0)
#sys.stderr.write("\n--- exit ---\n")
def main():
tt = TestTerm(os.name)
tt.run()
if __name__ == '__main__':
main()

BIN
octal/cavium_env/rf_card_cal_tip/bb_testterm.pyc Normal file
View File

Binary file not shown.

240
octal/cavium_env/rf_card_cal_tip/cal_freq_err_pwm.py Normal file
View File

@@ -0,0 +1,240 @@
#!/usr/bin/python
"""
Setup:
1. Agilent MXA, connect cable to one of the antenna port of enodeB
2. Set TFTP server, address and port as test_config
"""
import test_config
import im_calibration
from time import sleep
from im_calibration import Calibration
class CalFreqErr(Calibration):
def __init__(self, rpt_hndl, rec_num):
self.rpt = rpt_hndl
self.rn = rec_num
self.dif_freq = 0
self.pwm_ini = 0x5000
self.pwm_cur = 0x5000
self.pwm_val = 0x5000
self.pwm_lo_val = 0x9200
self.limit_cal = 10
self.dif_factor = 1
self.got_ref = False
self.narrow_span = False
self.ref_freq = test_config.dl_freq * 1000000
self.input_power = 0 # input power in dBm
self.signal_bw = 10 # input signal bandwidth
def mxa_setup(self):
type(self).mxa.send_msg_to_server('*RST')
type(self).mxa.send_msg_to_server('*IDN?')
in_msg = type(self).mxa.recv_msg_frm_server()
print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + in_msg)
type(self).mxa.send_msg_to_server(':INIT:CONT ON')
type(self).mxa.send_msg_to_server(':INST:SEL SA')
type(self).mxa.send_msg_to_server(':CONF:SAN:NDEF')
type(self).mxa.send_msg_to_server(':FREQ:CENT ' + str(self.ref_freq) + ' Hz')
type(self).mxa.send_msg_to_server(':FREQ:SPAN 50 KHz')
#type(self).mxa.send_msg_to_server(':BAND 100 Hz')
type(self).mxa.send_msg_to_server(':DISP:WIND:TRAC:Y:RLEV 10 dBm')
type(self).mxa.send_msg_to_server(':POW:ATT 20')
def mt8870a_setup(self, freq_center):
print 'Start VSA...'
type(self).mt8870a.send_msg_to_server(':BATC:BAND:FREQ:CENT ' + str(freq_center) + 'MHZ')
type(self).mt8870a.send_msg_to_server(':BATC:BAND:POW:RANG:ILEV ' + str(self.input_power))
type(self).mt8870a.send_msg_to_server(':BATC:CC:RAD:CBAN ' + str(self.signal_bw))
type(self).mt8870a.send_msg_to_server(':BATC:CC:RAD:TMOD TM1_1')
type(self).mt8870a.send_msg_to_server(':TRIG:STAT OFF')
type(self).mt8870a.send_msg_to_server(':TRIG:SOUR IMM')
type(self).mt8870a.send_msg_to_server(':BATC:CAPT:TIME:STAR 0')
type(self).mt8870a.send_msg_to_server(':BATC:CAPT:TIME:LENG 1')
type(self).mt8870a.send_msg_to_server(':BATC:CAPT:TIME:UWEM:STAR 0')
type(self).mt8870a.send_msg_to_server(':BATC:CAPT:TIME:UWEM:LENG 140')
type(self).mt8870a.send_msg_to_server(':BATC:CC:PDCC:SYMB:NUMB 2')
type(self).mt8870a.send_msg_to_server(':BATC:EVM ON')
type(self).mt8870a.send_msg_to_server('*WAI')
def cmw500_setup(self, freq_center):
print 'Start VSA...'
#if test_config.band > 32:
# type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:DMOD TDD")
#else:
# type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:DMOD FDD")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:DMOD FDD")
type(self).cmw500.send_msg_to_server("ROUTe:LTE:MEAS:ENB:SCENario:SALone RFAC, RX1")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:RFS:FREQ " + str(freq_center) + " MHz")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:RFS:ENP 35")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:RFS:UMAR 0")
if (self.signal_bw == 5):
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:CBAN B050")
elif (self.signal_bw == 10):
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:CBAN B100")
elif (self.signal_bw == 15):
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:CBAN B150")
elif (self.signal_bw == 20):
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:CBAN B200")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:RES:ALL ON,OFF,OFF,OFF,OFF,OFF,ON,OFF,OFF")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:SCO:MOD 10")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:MOEX ON")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:REP SING")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:ETES ETM11")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:PLC 1")
type(self).cmw500.send_msg_to_server("TRIG:LTE:MEAS:ENB:MEV:SOUR 'Free Run (Fast Sync)'")
def start_enodeb(self):
type(self).enb.enb_login()
type(self).enb.enb_cd_usr_bin()
# default is PWM control in booting
if (type(self).cfg.tcxo_ctrl == "dax"):
print("load ext dac clock control")
type(self).enb.enb_load_dax() # do ext DAC control
if test_config.band > 32:
type(self).enb.enb_set_zen_tdd_tx()
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_run_dsp_app_dl()
def do_refclk_cal(self):
type(self).enb.enb_pwm_ctrl_call_cmd('l ' + str(self.pwm_lo_val) +
' h ' + str(self.pwm_ini) + ' e q')
for rn in range(50):
print("\ncalibration round: " + str(rn+1))
self.check_freq_err()
if rn > 30:
self.limit_cal = 50;
if (abs(self.dif_freq) >= self.limit_cal):
self.calc_pwm_value()
else:
self.got_ref = True
print("\nGot target reference frequency,")
print(" PWM_high value= " + str(self.pwm_val))
print(" PWM_low value= " + str(self.pwm_lo_val))
if (type(self).cfg.test_report == True) and (im_calibration.is_test_all == True):
self.rpt.write('\nReference Clock Calibration:\n')
self.rpt.write('Frequency = ' + str(self.ref_freq) + '\n')
self.rpt.write('PWM_high value = ' + str(self.pwm_val) + '\n')
self.rpt.write('PWM_low value = ' + str(self.pwm_lo_val) + '\n')
break
type(self).enb.enb_pwm_ctrl_call_cmd('h ' + str(self.pwm_val) + ' q')
sleep(3)
if (not self.got_ref):
print("Reference clock calibration failed")
else:
# pwmreg0 for high pwm, pwmreg1 for low pwm
if test_config.wr_var_to_uboot == True:
print("fsetenv pwm_offset " + str(self.pwm_val))
type(self).enb.tn_write(im_calibration.pp_base, \
"fsetenv pwmreglow " + str(self.pwm_lo_val), 3)
type(self).enb.tn_write(im_calibration.pp_base, \
"fsetenv pwmreghigh " + str(self.pwm_val), 3)
if (type(self).cfg.en_eeprom_write == True):
if (im_calibration.is_test_all == True):
self.write_pwmclk_to_eeprom()
else:
se = raw_input("Write result to EEPROM?(y/n):")
if (se == 'y') or (se == 'Y'):
self.write_pwmclk_to_eeprom()
se = raw_input("Write result to uboot?(y/n):")
if (se == 'y') or (se == 'Y'):
print("fsetenv pwm_offset " + str(self.pwm_val))
type(self).enb.tn_write(im_calibration.pp_base, \
"fsetenv pwmreglow " \
+ str(self.pwm_lo_val), 3)
type(self).enb.tn_write(im_calibration.pp_base, \
"fsetenv pwmreghigh " \
+ str(self.pwm_val), 3)
def write_pwmclk_to_eeprom(self):
type(self).enb.enb_cd_usr_bin()
print "edit EEPROM record"
type(self).enb.enb_eeprom_edit_record('wrh', self.rn, str(self.pwm_val))
type(self).enb.enb_eeprom_edit_record('wrl', self.rn, str(self.pwm_lo_val))
sleep(0.5) # wait EEPROM data wrote
def check_freq_err(self):
if (type(self).cfg.test_set == 'anritsu'):
type(self).mt8870a.send_msg_to_server(':INIT:MODE:SING')
type(self).mt8870a.send_msg_to_server('*WAI')
type(self).mt8870a.send_msg_to_server(':FETC:BATC1?')
type(self).mt8870a.send_msg_to_server('*WAI')
#sleep(3)
in_msg = type(self).mt8870a.recv_msg_frm_server()
#print in_msg
line = in_msg.split(',')
self.dif_freq = int(float(line[1]))
print "frequency error = " + str(self.dif_freq) + " Hz"
elif (type(self).cfg.test_set == 'rs'):
type(self).cmw500.send_msg_to_server('INIT:LTE:MEAS:ENB:MEV')
type(self).cmw500.send_msg_to_server('*WAI')
type(self).cmw500.send_msg_to_server('FETC:LTE:MEAS:ENB:MEV:MOD:AVER?')
in_msg = type(self).cmw500.recv_msg_frm_server()
line = in_msg.split(',')
if (int(line[0]) != 0):
print in_msg
self.dif_freq = int(float(line[15]))
print "frequency error = " + str(self.dif_freq) + " Hz"
def calc_pwm_value(self):
if (abs(self.dif_freq) > 10000):
self.pwm_val = self.pwm_cur + 1000
print("pwm_val=" + str(self.pwm_cur) + " diff=" + str(self.dif_freq)
+ " new_val=" + str(self.pwm_val))
else:
self.pwm_val = self.pwm_cur - self.dif_freq * self.dif_factor
print("pwm_val=" + str(self.pwm_cur) + " diff=" + str(self.dif_freq)
+ " new_val=" + str(self.pwm_val))
self.pwm_cur = self.pwm_val
def run(self):
self.start_enodeb()
sleep(3) # wait spectrum comes out
if (type(self).cfg.test_set == 'agilent'):
self.mxa_setup()
elif (type(self).cfg.test_set == 'anritsu'):
self.mt8870a_setup(test_config.dl_freq)
elif (type(self).cfg.test_set == 'rs'):
self.cmw500_setup(test_config.dl_freq)
self.do_refclk_cal()

BIN
octal/cavium_env/rf_card_cal_tip/cal_freq_err_pwm.pyc Normal file
View File

Binary file not shown.

BIN
octal/cavium_env/rf_card_cal_tip/cal_instructions_v10.docx Normal file
View File

Binary file not shown.

264
octal/cavium_env/rf_card_cal_tip/cal_iq_offset.py Normal file
View File

@@ -0,0 +1,264 @@
#!/usr/bin/python
"""
Setup:
1. Agilent MXA, connect to primary antenna port of enodeB
2. Set TFTP server, address and port as test_config
"""
import operator
import test_config
import im_calibration
from time import sleep
from im_calibration import Calibration
class CalIQOffset(Calibration):
def __init__(self, rpt_hndl, rec_num):
self.rpt = rpt_hndl
self.rn = rec_num
self.iq_step = 5 #3
self.local_freq_tolerance = 50000 # tolerance of local frequency deviation
self.offs_low = 0xF0 # IQ offset lower limit #0xC0
self.offs_up = 0xFF # IQ offset upper limit
self.reg_tx1_i = 0x92
self.reg_tx1_q = 0x93
self.reg_tx2_i = 0x94
self.reg_tx2_q = 0x95
self.reg_en_offset = 0x9F #0x9A
self.results = {}
self.offsets = []
def mxa_setup(self):
type(self).mxa.send_msg_to_server('*RST')
#type(self).mxa.send_msg_to_server('*IDN?')
#in_msg = type(self).mxa.recv_msg_frm_server()
#print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + in_msg)
type(self).mxa.send_msg_to_server(':INIT:CONT ON')
type(self).mxa.send_msg_to_server(':INST:SEL SA')
type(self).mxa.send_msg_to_server(':FREQ:CENT ' + str(test_config.dl_freq) + ' MHz')
type(self).mxa.send_msg_to_server(':FREQ:SPAN 300 kHz')
type(self).mxa.send_msg_to_server(':BAND 100 Hz')
type(self).mxa.send_msg_to_server(':POW:ATT 38')
type(self).mxa.send_msg_to_server(':DISP:WIND:TRAC:Y:RLEV 20 dBm')
def start_enodeb_tx(self):
type(self).enb.enb_login()
# default is PWM control in booting
if (type(self).cfg.tcxo_ctrl == "dax"):
print("load ext dac clock control")
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_load_dax() # do ext DAC control
if test_config.band > 32:
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_set_zen_tdd_tx()
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_run_dsp_app_dl()
def do_iq_offset_cal(self):
self.reg_tx_i = self.reg_tx1_i
self.reg_tx_q = self.reg_tx1_q
type(self).enb.enb_cd_usr_bin()
if (type(self).cfg.cal_bandwidth >= 15):
cmd = "w 0x02 0x4e q"
else:
cmd = "w 0x02 0x5e q"
type(self).enb.enb_rf_drv_call_cmd(cmd)
sleep(2)
type(self).enb.enb_adi_write_reg(str(hex(self.reg_en_offset)), str(hex(0x0C)))
try:
for ant in range(2):
print('')
print("Testing antenna port " + str(ant+1))
if (ant == 1):
self.reg_tx_i = self.reg_tx2_i
self.reg_tx_q = self.reg_tx2_q
type(self).enb.enb_disable_TX1()
else:
type(self).enb.enb_disable_TX2()
# 1. fix Q offset to zero
print("\n1. fix Q offset to initial value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_q)), str(hex(0xC0)))
# 2. optimize I offset
print("\n2. optimize I offset")
self.results = {}
for offs in xrange(self.offs_low, self.offs_up + 1, self.iq_step):
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(hex(offs)))
#sleep(self.delay) # wait for average
lopwr = self.get_local_leakage_power()
if (lopwr == 0):
print 'IQ offset test error'
return -1
self.results[str(hex(offs))] = lopwr
print('I offset ' + str(hex(offs)) + ' power ' + str(lopwr) + ' dBm')
sort_res = sorted(self.results.iteritems(), key=operator.itemgetter(1))
try:
self.offsets.append(sort_res[0][0])
except:
print("error")
# 3. fix I offset to new value
print("\n3. fix I offset to new value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(sort_res[0][0]))
# 4. optimize Q offset
print("\n4. optimize Q offset")
self.results = {}
for offs in xrange(self.offs_low, self.offs_up + 1, self.iq_step):
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_q)), str(hex(offs)))
#sleep(self.delay) # wait for average
lopwr = self.get_local_leakage_power()
self.results[str(hex(offs))] = lopwr
print('Q offset ' + str(hex(offs)) + ' power ' + str(lopwr) + ' dBm')
sort_res = sorted(self.results.iteritems(), key=operator.itemgetter(1))
self.offsets.append(sort_res[0][0])
# 5. fix Q offset to new value
print("\n5. fix Q offset to new value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_q)), str(sort_res[0][0]))
# 6. optimize I offset
print("\n6. optimize I offset")
self.results = {}
for offs in xrange(self.offs_low, self.offs_up + 1, self.iq_step):
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(hex(offs)))
#sleep(self.delay) # wait for average
lopwr = self.get_local_leakage_power()
self.results[str(hex(offs))] = lopwr
print('I offset ' + str(hex(offs)) + ' power ' + str(lopwr) + ' dBm')
sort_res = sorted(self.results.iteritems(), key=operator.itemgetter(1))
self.offsets.append(sort_res[0][0])
# 7. fix I offset to new value
print("\n7. fix I offset to new value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(sort_res[0][0]))
except:
#print Exception, e
print("\n8. save dummy offset results")
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
else:
# 8. save offset results
print('\nIQ Offset Calibration Results:\n')
print('tx1_i_offset = ' + str(self.offsets[2]))
print('tx1_q_offset = ' + str(self.offsets[1]))
print('tx2_i_offset = ' + str(self.offsets[5]))
print('tx2_q_offset = ' + str(self.offsets[4]))
print("\n8. save offset results")
if test_config.wr_var_to_uboot == True:
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx1_q_offset " \
+ str(self.offsets[1]), 3)
print("fsetenv TX1_Q_OFFSET " + str(self.offsets[1]))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx1_i_offset " \
+ str(self.offsets[2]), 3)
print("fsetenv TX1_I_OFFSET " + str(self.offsets[2]))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx2_q_offset " \
+ str(self.offsets[4]), 3)
print("fsetenv TX2_Q_OFFSET " + str(self.offsets[4]))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx2_i_offset " \
+ str(self.offsets[5]), 3)
print("fsetenv TX2_I_OFFSET " + str(self.offsets[5]))
if (type(self).cfg.test_report == True) and (im_calibration.is_test_all == True):
self.rpt.write('\nIQ Offset Calibration:\n')
self.rpt.write('tx1_i_offset = ' + str(self.offsets[2]) + '\n')
self.rpt.write('tx1_q_offset = ' + str(self.offsets[1]) + '\n')
self.rpt.write('tx2_i_offset = ' + str(self.offsets[5]) + '\n')
self.rpt.write('tx2_q_offset = ' + str(self.offsets[4]) + '\n')
if (type(self).cfg.en_eeprom_write == True):
self.enb.editUbootenv('TX1_I_OFFSET', str(self.offsets[2]))
self.enb.editUbootenv('TX1_Q_OFFSET', str(self.offsets[1]))
self.enb.editUbootenv('TX2_I_OFFSET', str(self.offsets[5]))
self.enb.editUbootenv('TX2_Q_OFFSET', str(self.offsets[4]))
if (im_calibration.is_test_all == True):
self.write_iqoffset_to_eeprom()
else:
se = raw_input("Write result to EEPROM?(y/n):")
if (se == 'y') or (se == 'Y'):
self.write_iqoffset_to_eeprom()
# stop transmit
#type(self).enb.enb_cd_tmpfs()
#type(self).enb.enb_stop_transmit()
return 0
def write_iqoffset_to_eeprom(self):
type(self).enb.enb_cd_usr_bin()
print "edit EEPROM record"
type(self).enb.enb_eeprom_edit_record('wiop', self.rn, str(self.offsets[2]))
type(self).enb.enb_eeprom_edit_record('wqop', self.rn, str(self.offsets[1]))
type(self).enb.enb_eeprom_edit_record('wios', self.rn, str(self.offsets[5]))
type(self).enb.enb_eeprom_edit_record('wqos', self.rn, str(self.offsets[4]))
sleep(0.5) # wait EEPROM data wrote
def get_local_leakage_power(self):
type(self).mxa.send_msg_to_server(':FREQ:CENT ' + str(test_config.dl_freq) + ' MHz')
type(self).mxa.send_msg_to_server(':CALC:MARK1:CPS ON') # mark peak
if (self.is_peak_at_local() == False):
print "local leakage not detected"
return 0
type(self).mxa.send_msg_to_server(':CALC:MARK1:Y?') # get power
in_msg = type(self).mxa.recv_msg_frm_server()
cur_pwr = round(float(in_msg), 2)
#print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + in_msg)
return cur_pwr
def is_peak_at_local(self):
type(self).mxa.send_msg_to_server(':CALC:MARK1:X?') # get mark frequency
in_msg = type(self).mxa.recv_msg_frm_server()
fpeak = float(in_msg)
#print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + in_msg)
diff = abs(test_config.dl_freq*1000000 - fpeak)
if (diff < self.local_freq_tolerance):
return True
else:
return False
def run(self):
self.mxa_setup()
self.start_enodeb_tx()
sleep(8) # wait for leakage appears
res = self.do_iq_offset_cal()
return res

BIN
octal/cavium_env/rf_card_cal_tip/cal_iq_offset.pyc Normal file
View File

Binary file not shown.

260
octal/cavium_env/rf_card_cal_tip/cal_iq_offset_cmw500.py Normal file
View File

@@ -0,0 +1,260 @@
#!/usr/bin/python
"""
Setup:
1. RS CMW500, connect to primary antenna port of enodeB
2. Set TFTP server, address and port as test_config
"""
import operator
import test_config
import im_calibration
from time import sleep
from im_calibration import Calibration
class CalIQOffsetCMW500(Calibration):
def __init__(self, rpt_hndl, rec_num):
self.rpt = rpt_hndl
self.rn = rec_num
self.iq_step = 3
self.local_freq_tolerance = 10000 # tolerance of local frequency deviation
self.offs_low = 0xF0 # IQ offset lower limit
self.offs_up = 0xFF # IQ offset upper limit
self.reg_tx1_i = 0x92
self.reg_tx1_q = 0x93
self.reg_tx2_i = 0x94
self.reg_tx2_q = 0x95
self.reg_en_offset = 0x9F #0x9A
self.results = {}
self.offsets = []
def cmw500_setup(self):
type(self).cmw500.send_msg_to_server("CONF:GPRF:MEAS:SPEC:FREQ:CENT " + str(test_config.dl_freq*1000000))
type(self).cmw500.send_msg_to_server("CONF:GPRF:MEAS:SPEC:FREQ:SPAN 300000")
type(self).cmw500.send_msg_to_server("CONF:GPRF:MEAS:SPEC:REP SING")
type(self).cmw500.send_msg_to_server("CONF:GPRF:MEAS:SPEC:SCO 10")
type(self).cmw500.send_msg_to_server('CONF:GPRF:MEAS:RFS:ENP 30')
type(self).cmw500.send_msg_to_server('CONF:GPRF:MEAS:RFS:UMAR 0')
def start_enodeb_tx(self):
type(self).enb.enb_login()
# default is PWM control in booting
if (type(self).cfg.tcxo_ctrl == "dax"):
print("load ext dac clock control")
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_load_dax() # do ext DAC control
if test_config.band > 32:
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_set_zen_tdd_tx()
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_run_dsp_app_dl()
def do_iq_offset_cal(self):
self.reg_tx_i = self.reg_tx1_i
self.reg_tx_q = self.reg_tx1_q
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_adi_write_reg(str(hex(self.reg_en_offset)), str(hex(0x0C)))
try:
for ant in range(2):
print('')
print("Testing antenna port " + str(ant+1))
if (ant == 1):
self.reg_tx_i = self.reg_tx2_i
self.reg_tx_q = self.reg_tx2_q
type(self).enb.enb_disable_TX1()
if (type(self).cfg.test_set == 'rs'):
type(self).cmw500.send_msg_to_server("ROUTe:GPRF:MEASurement:SCENario:SALone RFBC, RX1")
else:
type(self).enb.enb_disable_TX2()
if (type(self).cfg.test_set == 'rs'):
type(self).cmw500.send_msg_to_server("ROUTe:GPRF:MEASurement:SCENario:SALone RFAC, RX1")
# 1. fix Q offset to zero
print("\n1. fix Q offset to initial value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_q)), str(hex(0xC0)))
# 2. optimize I offset
print("\n2. optimize I offset")
self.results = {}
for offs in xrange(self.offs_low, self.offs_up + 1, self.iq_step):
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(hex(offs)))
#sleep(self.delay) # wait for average
lopwr = self.get_local_leakage_power()
if (lopwr == 0):
print 'IQ offset test error'
return -1
self.results[str(hex(offs))] = lopwr
print('I offset ' + str(hex(offs)) + ' power ' + str(lopwr) + ' dBm')
sort_res = sorted(self.results.iteritems(), key=operator.itemgetter(1))
try:
self.offsets.append(sort_res[0][0])
except:
print("error")
# 3. fix I offset to new value
print("\n3. fix I offset to new value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(sort_res[0][0]))
# 4. optimize Q offset
print("\n4. optimize Q offset")
self.results = {}
for offs in xrange(self.offs_low, self.offs_up + 1, self.iq_step):
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_q)), str(hex(offs)))
#sleep(self.delay) # wait for average
lopwr = self.get_local_leakage_power()
self.results[str(hex(offs))] = lopwr
print('Q offset ' + str(hex(offs)) + ' power ' + str(lopwr) + ' dBm')
sort_res = sorted(self.results.iteritems(), key=operator.itemgetter(1))
self.offsets.append(sort_res[0][0])
# 5. fix Q offset to new value
print("\n5. fix Q offset to new value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_q)), str(sort_res[0][0]))
# 6. optimize I offset
print("\n6. optimize I offset")
self.results = {}
for offs in xrange(self.offs_low, self.offs_up + 1, self.iq_step):
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(hex(offs)))
#sleep(self.delay) # wait for average
lopwr = self.get_local_leakage_power()
self.results[str(hex(offs))] = lopwr
print('I offset ' + str(hex(offs)) + ' power ' + str(lopwr) + ' dBm')
sort_res = sorted(self.results.iteritems(), key=operator.itemgetter(1))
self.offsets.append(sort_res[0][0])
# 7. fix I offset to new value
print("\n7. fix I offset to new value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(sort_res[0][0]))
except:
#print Exception, e
print("\n8. save dummy offset results")
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
else:
# 8. save offset results
print('\nIQ Offset Calibration Results:\n')
print('tx1_i_offset = ' + str(self.offsets[2]))
print('tx1_q_offset = ' + str(self.offsets[1]))
print('tx2_i_offset = ' + str(self.offsets[5]))
print('tx2_q_offset = ' + str(self.offsets[4]))
print("\n8. save offset results")
if test_config.wr_var_to_uboot == True:
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx1_q_offset " \
+ str(self.offsets[1]), 3)
print("fsetenv TX1_Q_OFFSET " + str(self.offsets[1]))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx1_i_offset " \
+ str(self.offsets[2]), 3)
print("fsetenv TX1_I_OFFSET " + str(self.offsets[2]))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx2_q_offset " \
+ str(self.offsets[4]), 3)
print("fsetenv TX2_Q_OFFSET " + str(self.offsets[4]))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx2_i_offset " \
+ str(self.offsets[5]), 3)
print("fsetenv TX2_I_OFFSET " + str(self.offsets[5]))
if (type(self).cfg.test_report == True) and (im_calibration.is_test_all == True):
self.rpt.write('\nIQ Offset Calibration:\n')
self.rpt.write('tx1_i_offset = ' + str(self.offsets[2]) + '\n')
self.rpt.write('tx1_q_offset = ' + str(self.offsets[1]) + '\n')
self.rpt.write('tx2_i_offset = ' + str(self.offsets[5]) + '\n')
self.rpt.write('tx2_q_offset = ' + str(self.offsets[4]) + '\n')
if (type(self).cfg.en_eeprom_write == True):
self.enb.editUbootenv('TX1_I_OFFSET', str(self.offsets[2]))
self.enb.editUbootenv('TX1_Q_OFFSET', str(self.offsets[1]))
self.enb.editUbootenv('TX2_I_OFFSET', str(self.offsets[5]))
self.enb.editUbootenv('TX2_Q_OFFSET', str(self.offsets[4]))
if (im_calibration.is_test_all == True):
self.write_iqoffset_to_eeprom()
else:
se = raw_input("Write result to EEPROM?(y/n):")
if (se == 'y') or (se == 'Y'):
self.write_iqoffset_to_eeprom()
# stop transmit
#type(self).enb.enb_cd_tmpfs()
#type(self).enb.enb_stop_transmit()
return 0
def write_iqoffset_to_eeprom(self):
type(self).enb.enb_cd_usr_bin()
print "edit EEPROM record"
type(self).enb.enb_eeprom_edit_record('wiop', self.rn, str(self.offsets[2]))
type(self).enb.enb_eeprom_edit_record('wqop', self.rn, str(self.offsets[1]))
type(self).enb.enb_eeprom_edit_record('wios', self.rn, str(self.offsets[5]))
type(self).enb.enb_eeprom_edit_record('wqos', self.rn, str(self.offsets[4]))
sleep(0.5) # wait EEPROM data wrote
def get_local_leakage_power(self):
type(self).cmw500.send_msg_to_server("INIT:GPRF:MEAS:SPEC")
type(self).cmw500.send_msg_to_server("*WAI")
#sleep(1)
if (self.is_peak_at_local() == False):
print "local leakage not detected"
return 0
type(self).cmw500.send_msg_to_server("FETC:GPRF:MEAS:SPEC:REFM:SPE? AVER,CURR") # get power
in_msg = type(self).cmw500.recv_msg_frm_server()
line = in_msg.split(',')
if (int(line[0]) != 0):
print in_msg
cur_pwr = round(float(line[2]), 2)
#print('recv ' + type(self).cfg.cmw500_ipaddr + '= ' + in_msg)
return cur_pwr
def is_peak_at_local(self):
type(self).cmw500.send_msg_to_server("FETC:GPRF:MEAS:SPEC:REFM:SPE? AVER,CURR") # get mark frequency
in_msg = type(self).cmw500.recv_msg_frm_server()
line = in_msg.split(',')
if (int(line[0]) != 0):
print in_msg
fpeak = float(line[1])
#print('recv ' + type(self).cfg.cmw500_ipaddr + '= ' + in_msg)
diff = abs(test_config.dl_freq*1000000 - fpeak)
if (diff < self.local_freq_tolerance):
return True
else:
return False
def run(self):
self.start_enodeb_tx()
self.cmw500_setup()
sleep(2) # wait for leakage appears
res = self.do_iq_offset_cal()
return res

BIN
octal/cavium_env/rf_card_cal_tip/cal_iq_offset_cmw500.pyc Normal file
View File

Binary file not shown.

254
octal/cavium_env/rf_card_cal_tip/cal_iq_offset_ms8870a.py Normal file
View File

@@ -0,0 +1,254 @@
#!/usr/bin/python
"""
Setup:
1. Agilent mt8870a, connect to primary antenna port of enodeB
2. Set TFTP server, address and port as test_config
"""
import operator
import test_config
import im_calibration
from time import sleep
from im_calibration import Calibration
class CalIQOffsetMT8870A(Calibration):
def __init__(self, rpt_hndl, rec_num):
self.rpt = rpt_hndl
self.rn = rec_num
self.iq_step = 3
self.local_freq_tolerance = 10000 # tolerance of local frequency deviation
self.offs_low = 0xF0 # IQ offset lower limit
self.offs_up = 0xFF # IQ offset upper limit
self.reg_tx1_i = 0x92
self.reg_tx1_q = 0x93
self.reg_tx2_i = 0x94
self.reg_tx2_q = 0x95
self.reg_en_offset = 0x9F #0x9A
self.results = {}
self.offsets = []
def mt8870a_setup(self):
type(self).mt8870a.send_msg_to_server('*RST')
type(self).mt8870a.send_msg_to_server('*IDN?')
in_msg = type(self).mt8870a.recv_msg_frm_server()
print('recv ' + type(self).cfg.mt8870a_ipaddr + '= ' + in_msg)
#type(self).mt8870a.send_msg_to_server('SYST:LANG SCPI')
#type(self).mt8870a.send_msg_to_server('ROUT:PORT:CONN:DIR PORT1,PORT3')
type(self).mt8870a.send_msg_to_server('INST CELLULAR')
type(self).mt8870a.send_msg_to_server('CONF:CELL:MEAS:STAN COMMON')
type(self).mt8870a.send_msg_to_server('CONF:CELL:MEAS:SEL SPMON')
type(self).mt8870a.send_msg_to_server('CONF:CELL:MEAS:RFS:FREQ ' + str(test_config.dl_freq*1000000))
type(self).mt8870a.send_msg_to_server('CONF:CELL:COMM:SPM:SPAN 1MHZ')
type(self).mt8870a.send_msg_to_server('CONF:CELL:COMM:SPM:RBW 100HZ')
type(self).mt8870a.send_msg_to_server('CONF:CELL:COMM:SPM:MARK:PEAK:RANG 0.002')
type(self).mt8870a.send_msg_to_server('CONF:CELL:MEAS:RFS:LEV 10')
def start_enodeb_tx(self):
type(self).enb.enb_login()
# default is PWM control in booting
if (type(self).cfg.tcxo_ctrl == "dax"):
print("load ext dac clock control")
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_load_dax() # do ext DAC control
if test_config.band > 32:
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_set_zen_tdd_tx()
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_run_dsp_app_dl()
def do_iq_offset_cal(self):
self.reg_tx_i = self.reg_tx1_i
self.reg_tx_q = self.reg_tx1_q
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_adi_write_reg(str(hex(self.reg_en_offset)), str(hex(0x0C)))
try:
for ant in range(2):
print('')
print("Testing antenna port " + str(ant+1))
if (ant == 1):
self.reg_tx_i = self.reg_tx2_i
self.reg_tx_q = self.reg_tx2_q
type(self).enb.enb_disable_TX1()
else:
type(self).enb.enb_disable_TX2()
# 1. fix Q offset to zero
print("\n1. fix Q offset to initial value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_q)), str(hex(0xC0)))
# 2. optimize I offset
print("\n2. optimize I offset")
self.results = {}
for offs in xrange(self.offs_low, self.offs_up + 1, self.iq_step):
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(hex(offs)))
#sleep(self.delay) # wait for average
lopwr = self.get_local_leakage_power()
self.results[str(hex(offs))] = lopwr
print('I offset ' + str(hex(offs)) + ' power ' + str(lopwr) + ' dBm')
sort_res = sorted(self.results.iteritems(), key=operator.itemgetter(1))
try:
self.offsets.append(sort_res[0][0])
except:
print("error")
# 3. fix I offset to new value
print("\n3. fix I offset to new value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(sort_res[0][0]))
# 4. optimize Q offset
print("\n4. optimize Q offset")
self.results = {}
for offs in xrange(self.offs_low, self.offs_up + 1, self.iq_step):
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_q)), str(hex(offs)))
#sleep(self.delay) # wait for average
lopwr = self.get_local_leakage_power()
self.results[str(hex(offs))] = lopwr
print('Q offset ' + str(hex(offs)) + ' power ' + str(lopwr) + ' dBm')
sort_res = sorted(self.results.iteritems(), key=operator.itemgetter(1))
self.offsets.append(sort_res[0][0])
# 5. fix Q offset to new value
print("\n5. fix Q offset to new value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_q)), str(sort_res[0][0]))
# 6. optimize I offset
print("\n6. optimize I offset")
self.results = {}
for offs in xrange(self.offs_low, self.offs_up + 1, self.iq_step):
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(hex(offs)))
#sleep(self.delay) # wait for average
lopwr = self.get_local_leakage_power()
self.results[str(hex(offs))] = lopwr
print('I offset ' + str(hex(offs)) + ' power ' + str(lopwr) + ' dBm')
sort_res = sorted(self.results.iteritems(), key=operator.itemgetter(1))
self.offsets.append(sort_res[0][0])
# 7. fix I offset to new value
print("\n7. fix I offset to new value")
type(self).enb.enb_adi_write_reg(str(hex(self.reg_tx_i)), str(sort_res[0][0]))
except:
#print Exception, e
print("\n8. save dummy offset results")
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
self.offsets.append(hex(255))
else:
# 8. save offset results
print('\nIQ Offset Calibration Results:\n')
print('tx1_i_offset = ' + str(self.offsets[2]))
print('tx1_q_offset = ' + str(self.offsets[1]))
print('tx2_i_offset = ' + str(self.offsets[5]))
print('tx2_q_offset = ' + str(self.offsets[4]))
print("\n8. save offset results")
if test_config.wr_var_to_uboot == True:
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx1_q_offset " \
+ str(self.offsets[1]), 3)
print("fsetenv TX1_Q_OFFSET " + str(self.offsets[1]))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx1_i_offset " \
+ str(self.offsets[2]), 3)
print("fsetenv TX1_I_OFFSET " + str(self.offsets[2]))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx2_q_offset " \
+ str(self.offsets[4]), 3)
print("fsetenv TX2_Q_OFFSET " + str(self.offsets[4]))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx2_i_offset " \
+ str(self.offsets[5]), 3)
print("fsetenv TX2_I_OFFSET " + str(self.offsets[5]))
if (type(self).cfg.test_report == True) and (im_calibration.is_test_all == True):
self.rpt.write('\nIQ Offset Calibration:\n')
self.rpt.write('tx1_i_offset = ' + str(self.offsets[2]) + '\n')
self.rpt.write('tx1_q_offset = ' + str(self.offsets[1]) + '\n')
self.rpt.write('tx2_i_offset = ' + str(self.offsets[5]) + '\n')
self.rpt.write('tx2_q_offset = ' + str(self.offsets[4]) + '\n')
if (type(self).cfg.en_eeprom_write == True):
self.enb.editUbootenv('TX1_I_OFFSET', str(self.offsets[2]))
self.enb.editUbootenv('TX1_Q_OFFSET', str(self.offsets[1]))
self.enb.editUbootenv('TX2_I_OFFSET', str(self.offsets[5]))
self.enb.editUbootenv('TX2_Q_OFFSET', str(self.offsets[4]))
if (im_calibration.is_test_all == True):
self.write_iqoffset_to_eeprom()
else:
se = raw_input("Write result to EEPROM?(y/n):")
if (se == 'y') or (se == 'Y'):
self.write_iqoffset_to_eeprom()
# stop transmit
#type(self).enb.enb_cd_tmpfs()
#type(self).enb.enb_stop_transmit()
return 0
def write_iqoffset_to_eeprom(self):
type(self).enb.enb_cd_usr_bin()
print "edit EEPROM record"
type(self).enb.enb_eeprom_edit_record('wiop', self.rn, str(self.offsets[2]))
type(self).enb.enb_eeprom_edit_record('wqop', self.rn, str(self.offsets[1]))
type(self).enb.enb_eeprom_edit_record('wios', self.rn, str(self.offsets[5]))
type(self).enb.enb_eeprom_edit_record('wqos', self.rn, str(self.offsets[4]))
sleep(0.5) # wait EEPROM data wrote
def get_local_leakage_power(self):
type(self).mt8870a.send_msg_to_server('CONF:CELL:MEAS:RFS:FREQ ' + str(test_config.dl_freq*1000000))
type(self).mt8870a.send_msg_to_server('INIT:CELL:MEAS:SING') # mark peak
type(self).mt8870a.send_msg_to_server('*WAI')
if (self.is_peak_at_local() == False):
print "local leakage not detected"
return 0
type(self).mt8870a.send_msg_to_server('FETC:CELL:COMM:SPM:MARK:LEV?') # get power
in_msg = type(self).mt8870a.recv_msg_frm_server()
cur_pwr = round(float(in_msg), 2)
#print('recv ' + type(self).cfg.mt8870a_ipaddr + '= ' + in_msg)
return cur_pwr
def is_peak_at_local(self):
type(self).mt8870a.send_msg_to_server('FETC:CELL:COMM:SPM:MARK:FREQ?') # get mark frequency
in_msg = type(self).mt8870a.recv_msg_frm_server()
fpeak = float(in_msg)
#print('recv ' + type(self).cfg.mt8870a_ipaddr + '= ' + in_msg)
diff = abs(test_config.dl_freq*1000000 - fpeak)
if (diff < self.local_freq_tolerance):
return True
else:
return False
def run(self):
self.start_enodeb_tx()
self.mt8870a_setup()
sleep(2) # wait for leakage appears
res = self.do_iq_offset_cal()
return res

BIN
octal/cavium_env/rf_card_cal_tip/cal_iq_offset_ms8870a.pyc Normal file
View File

Binary file not shown.

155
octal/cavium_env/rf_card_cal_tip/cal_ref_clk_dac.py Normal file
View File

@@ -0,0 +1,155 @@
#!/usr/bin/python
"""
Setup:
1. Agilent MXA, connect cable to one of the antenna port of enodeB
2. Set TFTP server, address and port as test_config
"""
import test_config
import im_calibration
from time import sleep
from im_calibration import Calibration
class CalRefClk(Calibration):
def __init__(self, rpt_hndl, rec_num):
self.rpt = rpt_hndl
self.rn = rec_num
self.cur_freq = 0.0
self.ref_freq = 30720000
self.dif_freq = 0
self.dac_cur = 0x0
self.dac_val = 0x0
self.limit_cal = 1
self.got_ref = False
self.narrow_span = False
def mxa_setup(self):
type(self).mxa.send_msg_to_server('*RST')
type(self).mxa.send_msg_to_server('*IDN?')
in_msg = type(self).mxa.recv_msg_frm_server()
print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + in_msg)
type(self).mxa.send_msg_to_server(':INIT:CONT ON')
type(self).mxa.send_msg_to_server(':INST:SEL SA')
type(self).mxa.send_msg_to_server(':CONF:SAN:NDEF')
type(self).mxa.send_msg_to_server(':FREQ:CENT ' + str(self.ref_freq) + ' Hz')
type(self).mxa.send_msg_to_server(':FREQ:SPAN 1 KHz')
type(self).mxa.send_msg_to_server(':DISP:WIND:TRAC:Y:RLEV -50 dBm')
type(self).mxa.send_msg_to_server(':POW:ATT 10')
def start_enodeb(self):
type(self).enb.enb_login()
print 'enb get mac address'
type(self).enb.get_macaddr()
print 'enb set 1pps'
type(self).enb.enb_set_1pps('tx')
print 'enb cd usr bin'
type(self).enb.enb_cd_usr_bin()
print 'enb load rf drv'
type(self).enb.enb_load_rf_drv()
print 'env load rf init'
type(self).enb.enb_load_rf_init()
type(self).enb.enb_set_rf_drv_rf_card()
if test_config.band > 32:
type(self).enb.enb_set_zen_tdd_tx()
if im_calibration.is_dsp_running:
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_stop_transmit()
def do_refclk_cal_dac(self):
type(self).enb.enb_rf_drv_call()
type(self).enb.tn_write("Value", "C") # select clock cal
type(self).enb.tn_write("clock", str(self.dac_val))
type(self).mxa.send_msg_to_server(':CALC:MARK1:CPS ON') # mark peak
sleep(3) # wait for frequency stable
for rn in range(50):
print("\ncalibration round: " + str(rn+1))
self.check_curr_freq()
self.dif_freq = int(round(self.ref_freq - self.cur_freq))
if rn > 30:
self.limit_cal = 5;
if (abs(self.dif_freq) < 10) and (not self.narrow_span):
type(self).mxa.send_msg_to_server(':FREQ:SPAN 100 Hz')
self.narrow_span = True
sleep(3)
continue
elif (abs(self.dif_freq) >= self.limit_cal):
self.calc_dac_value()
else:
self.got_ref = True
tmp = hex(self.dac_val)
self.dac_val = tmp
print("Got target reference frequency, DAC value= " + str(self.dac_val))
if (type(self).cfg.test_report == True) and (im_calibration.is_test_all == True):
self.rpt.write('\nReference Clock Calibration:\n')
self.rpt.write('Frequency = ' + str(self.ref_freq) + '\n')
self.rpt.write('dac_offset = ' + str(self.dac_val) + '\n')
break
type(self).enb.tn_write("Value", "n")
type(self).enb.tn_write("clock", str(hex(self.dac_val)))
if self.narrow_span:
sleep(2)
else:
sleep(1)
if (self.got_ref):
type(self).enb.tn_write("calibration", "y")
#type(self).enb.tn_write("Option", "y") # y, fsetenv dac_offset
type(self).enb.tn.write("q\n".encode("ascii"))
else:
print("Reference clock calibration failed")
if test_config.wr_var_to_uboot == True:
print("fsetenv dac_offset " + str(self.dac_val))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv dac_offset " \
+ str(self.dac_val), 3)
def check_curr_freq(self):
type(self).mxa.send_msg_to_server(':CALC:MARK1:X?')
in_msg = type(self).mxa.recv_msg_frm_server()
self.cur_freq = float(in_msg)
print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + in_msg)
def calc_dac_value(self):
self.dac_val = self.dac_cur + self.dif_freq*2
print("cur_val=" + str(hex(self.dac_cur)) + " diff=" + str(self.dif_freq)
+ " dac_val=" + str(hex(self.dac_val)))
self.dac_cur = self.dac_val
def write_cal_temp_to_eeprom(self, cal_temp):
cal_temp = type(self).enb.enb_get_temperature()
type(self).enb.enb_cd_usr_bin()
num_rec = type(self).enb.enb_eeprom_get_record_num()
print "record calibration temperature in EEPROM"
type(self).enb.enb_eeprom_edit_record('wct', num_rec, hex(cal_temp))
def run(self):
self.mxa_setup()
self.start_enodeb()
self.do_refclk_cal_dac()
#if (type(self).cfg.eeprom_new_rec == True):
# self.write_cal_temp_to_eeprom()

BIN
octal/cavium_env/rf_card_cal_tip/cal_ref_clk_dac.pyc Normal file
View File

Binary file not shown.

159
octal/cavium_env/rf_card_cal_tip/cal_ref_clk_dax.py Normal file
View File

@@ -0,0 +1,159 @@
#!/usr/bin/python
"""
Setup:
1. Agilent MXA, connect cable to one of the antenna port of enodeB
2. Set TFTP server, address and port as test_config
"""
import test_config
import im_calibration
from time import sleep
from im_calibration import Calibration
class CalRefClkDax(Calibration):
def __init__(self, rpt_hndl, rec_num):
self.rpt = rpt_hndl
self.rn = rec_num
self.cur_freq = 0.0
self.dif_freq = 0
self.dax_cur = 0x4000
self.dax_val = 0x4000
self.dax_lo_val = 0x9200
self.limit_cal = 3
self.dif_factor = 1
self.got_ref = False
self.narrow_span = False
self.ref_freq = test_config.dl_freq * 1000000
def mxa_setup(self):
type(self).mxa.send_msg_to_server('*RST')
type(self).mxa.send_msg_to_server('*IDN?')
in_msg = type(self).mxa.recv_msg_frm_server()
print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + in_msg)
type(self).mxa.send_msg_to_server(':INIT:CONT ON')
type(self).mxa.send_msg_to_server(':INST:SEL SA')
type(self).mxa.send_msg_to_server(':CONF:SAN:NDEF')
type(self).mxa.send_msg_to_server(':FREQ:CENT ' + str(self.ref_freq) + ' Hz')
type(self).mxa.send_msg_to_server(':FREQ:SPAN 50 KHz')
#type(self).mxa.send_msg_to_server(':BAND 100 Hz')
type(self).mxa.send_msg_to_server(':DISP:WIND:TRAC:Y:RLEV 10 dBm')
type(self).mxa.send_msg_to_server(':POW:ATT 20')
def start_enodeb(self):
type(self).enb.enb_login()
#type(self).enb.get_macaddr()
type(self).enb.enb_set_1pps('tx')
type(self).enb.enb_cd_usr_bin()
print 'enb load rf drv'
type(self).enb.enb_load_rf_drv()
print 'enb load rf init'
type(self).enb.enb_load_rf_init()
type(self).enb.enb_set_rf_drv_rf_card()
if test_config.band > 32:
type(self).enb.enb_set_zen_tdd_tx()
if im_calibration.is_dsp_running:
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_stop_transmit()
def do_refclk_cal(self):
type(self).enb.enb_dax_ctrl_call_cmd('0x3000 q')
type(self).mxa.send_msg_to_server(':CALC:MARK1:CPS ON') # mark peak
sleep(3) # wait for frequency stable
for rn in range(50):
print("\ncalibration round: " + str(rn+1))
self.check_curr_freq()
self.dif_freq = int(round(self.ref_freq - self.cur_freq))
if rn > 30:
self.limit_cal = 10;
if (abs(self.dif_freq) < 50) and (not self.narrow_span):
type(self).mxa.send_msg_to_server(':FREQ:SPAN 1000 Hz')
#type(self).mxa.send_msg_to_server(':BAND 1 Hz')
self.narrow_span = True
sleep(3)
continue
elif (abs(self.dif_freq) >= self.limit_cal):
self.calc_dax_value()
else:
self.got_ref = True
print("Got target reference frequency,")
print(" PWM_high value= " + str(self.dax_val))
print(" PWM_low value= " + str(self.dax_lo_val))
if (type(self).cfg.test_report == True) and (im_calibration.is_test_all == True):
self.rpt.write('\nReference Clock Calibration:\n')
self.rpt.write('Frequency = ' + str(self.ref_freq) + '\n')
self.rpt.write('PWM_high value = ' + str(self.dax_val) + '\n')
self.rpt.write('PWM_low value = ' + str(self.dax_lo_val) + '\n')
break
type(self).enb.enb_dax_ctrl_call_cmd(str(self.dax_val) + ' q')
sleep(2)
if (not self.got_ref):
print("Reference clock calibration failed")
else:
# pwmreg0 for dax
if test_config.wr_var_to_uboot == True:
print("fsetenv dax_offset " + str(self.dax_val))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv pwmreglow " \
+ str(self.dax_lo_val), 3)
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv pwmreghigh " \
+ str(self.dax_val), 3)
if (type(self).cfg.en_eeprom_write == True):
if (im_calibration.is_test_all == True):
self.enb.editUbootenv('PWMREGHIGH', str(self.dax_val))
self.enb.editUbootenv('PWMREGLOW', str(self.dax_lo_val))
self.write_daxclk_to_eeprom()
else:
se = raw_input("Write result to EEPROM?(y/n):")
if (se == 'y') or (se == 'Y'):
self.enb.editUbootenv('PWMREGHIGH', str(self.dax_val))
self.enb.editUbootenv('PWMREGLOW', str(self.dax_lo_val))
self.write_daxclk_to_eeprom()
def write_daxclk_to_eeprom(self):
type(self).enb.enb_cd_usr_bin()
print "edit EEPROM record"
type(self).enb.enb_eeprom_edit_record('wrh', self.rn, str(self.dax_val))
type(self).enb.enb_eeprom_edit_record('wrl', self.rn, str(self.dax_lo_val))
sleep(0.5) # wait EEPROM data wrote
def check_curr_freq(self):
type(self).mxa.send_msg_to_server(':CALC:MARK1:X?')
in_msg = type(self).mxa.recv_msg_frm_server()
self.cur_freq = float(in_msg)
print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + in_msg)
def calc_dax_value(self):
self.dax_val = self.dax_cur + self.dif_freq * self.dif_factor
print("dax_val=" + str(self.dax_cur) + " diff=" + str(self.dif_freq)
+ " new_val=" + str(self.dax_val))
self.dax_cur = self.dax_val
def run(self):
self.mxa_setup()
self.start_enodeb()
self.do_refclk_cal()

BIN
octal/cavium_env/rf_card_cal_tip/cal_ref_clk_dax.pyc Normal file
View File

Binary file not shown.

166
octal/cavium_env/rf_card_cal_tip/cal_ref_clk_pwm.py Normal file
View File

@@ -0,0 +1,166 @@
#!/usr/bin/python
"""
Setup:
1. Agilent MXA, connect cable to one of the antenna port of enodeB
2. Set TFTP server, address and port as test_config
"""
import test_config
import im_calibration
from time import sleep
from im_calibration import Calibration
from cmd import PROMPT
class CalRefClk(Calibration):
def __init__(self, rpt_hndl, rec_num):
self.rpt = rpt_hndl
self.rn = rec_num
self.cur_freq = 0.0
self.dif_freq = 0
self.pwm_cur = 0x6F50
self.pwm_val = 0x6F50
self.pwm_lo_val = 0x9200
self.limit_cal = 10 #3 #frequency offset limit
self.dif_factor = 1
self.got_ref = False
self.narrow_span = False
self.ref_freq = test_config.dl_freq * 1000000
def mxa_setup(self):
type(self).mxa.send_msg_to_server('*RST')
type(self).mxa.send_msg_to_server('*IDN?')
in_msg = type(self).mxa.recv_msg_frm_server()
print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + in_msg)
type(self).mxa.send_msg_to_server(':INIT:CONT ON')
type(self).mxa.send_msg_to_server(':INST:SEL SA')
type(self).mxa.send_msg_to_server(':CONF:SAN:NDEF')
type(self).mxa.send_msg_to_server(':FREQ:CENT ' + str(self.ref_freq) + ' Hz')
type(self).mxa.send_msg_to_server(':FREQ:SPAN 50 KHz')
#type(self).mxa.send_msg_to_server(':BAND 100 Hz')
type(self).mxa.send_msg_to_server(':DISP:WIND:TRAC:Y:RLEV 10 dBm')
type(self).mxa.send_msg_to_server(':POW:ATT 20')
def start_enodeb(self):
type(self).enb.enb_login()
type(self).enb.enb_cd_usr_bin()
# default is PWM control in booting
if (type(self).cfg.tcxo_ctrl == "dax"):
print("load ext dac clock control")
type(self).enb.enb_load_dax() # do ext DAC control
if test_config.band > 32:
type(self).enb.enb_set_zen_tdd_tx()
"""
if im_calibration.is_dsp_running:
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_stop_transmit()
"""
def do_refclk_cal(self):
# set initial local frequency
type(self).enb.enb_pwm_ctrl_call_cmd('l ' + str(self.pwm_lo_val) +
' h ' + str(self.pwm_val) + ' e q')
type(self).mxa.send_msg_to_server(':CALC:MARK1:CPS ON') # mark peak
sleep(3) # wait for frequency stable
for rn in range(80):
print("\ncalibration round: " + str(rn+1))
self.check_curr_freq()
self.dif_freq = int(round(self.ref_freq - self.cur_freq))
if rn > 30:
self.limit_cal = 20 #20;
if (abs(self.dif_freq) < 60) and (not self.narrow_span):
type(self).mxa.send_msg_to_server(':FREQ:SPAN 1000 Hz')
#type(self).mxa.send_msg_to_server(':BAND 1 Hz')
self.narrow_span = True
sleep(1) #(3)
continue
elif (abs(self.dif_freq) >= self.limit_cal):
self.calc_pwm_value()
else:
#print "freq_diff=" + str(abs(self.dif_freq)) + ", limit_cal=" + str(self.limit_cal)
self.got_ref = True
print("Got target reference frequency,")
print(" PWM_high value= " + str(self.pwm_val))
print(" PWM_low value= " + str(self.pwm_lo_val))
if (type(self).cfg.test_report == True) and (im_calibration.is_test_all == True):
self.rpt.write('\nReference Clock Calibration:\n')
self.rpt.write('Frequency = ' + str(self.ref_freq) + '\n')
self.rpt.write('PWM_high value = ' + str(self.pwm_val) + '\n')
self.rpt.write('PWM_low value = ' + str(self.pwm_lo_val) + '\n')
break
type(self).enb.enb_pwm_ctrl_call_cmd('h ' + str(self.pwm_val) + ' q')
sleep(1) #(2)
if (not self.got_ref):
print("Reference clock calibration failed")
else:
# pwmreg0 for high pwm, pwmreg1 for low pwm
if test_config.wr_var_to_uboot == True:
#print("fsetenv pwm_offset " + str(self.pwm_val))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv pwmreglow " \
+ str(self.pwm_lo_val), 3)
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv pwmreghigh " \
+ str(self.pwm_val), 3)
if (type(self).cfg.en_eeprom_write == True):
self.enb.editUbootenv('PWMREGHIGH', str(self.pwm_val))
self.enb.editUbootenv('PWMREGLOW', str(self.pwm_lo_val))
if (im_calibration.is_test_all == True):
self.write_pwmclk_to_eeprom()
else:
se = raw_input("Write result to EEPROM?(y/n):")
if (se == 'y') or (se == 'Y'):
print("fsetenv pwm_offset " + str(self.pwm_val))
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv pwmreglow " \
+ str(self.pwm_lo_val), 3)
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv pwmreghigh " \
+ str(self.pwm_val), 3)
self.write_pwmclk_to_eeprom()
def write_pwmclk_to_eeprom(self):
type(self).enb.enb_cd_usr_bin()
print "edit EEPROM record"
type(self).enb.enb_eeprom_edit_record('wrh', self.rn, str(self.pwm_val))
type(self).enb.enb_eeprom_edit_record('wrl', self.rn, str(self.pwm_lo_val))
sleep(0.5) # wait EEPROM data wrote
def check_curr_freq(self):
type(self).mxa.send_msg_to_server(':CALC:MARK1:X?')
in_msg = type(self).mxa.recv_msg_frm_server()
self.cur_freq = float(in_msg)
print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + in_msg)
def calc_pwm_value(self):
self.pwm_val = self.pwm_cur + self.dif_freq * self.dif_factor
print("pwm_val=" + str(self.pwm_cur) + " diff=" + str(self.dif_freq)
+ " new_val=" + str(self.pwm_val))
self.pwm_cur = self.pwm_val
def run(self):
self.mxa_setup()
self.start_enodeb()
self.do_refclk_cal()

BIN
octal/cavium_env/rf_card_cal_tip/cal_ref_clk_pwm.pyc Normal file
View File

Binary file not shown.

261
octal/cavium_env/rf_card_cal_tip/cal_rx_rssi.py Normal file
View File

@@ -0,0 +1,261 @@
#!/usr/bin/python
"""
Setup:
1. Agilent EXG, connect to primary antenna port of enodeB
2. Set TFTP server, address and port as test_config
"""
import sys
import test_config
import im_calibration
from time import sleep
from im_calibration import Calibration
#from win32con import RES_CURSOR
class CalRxRssi(Calibration):
def __init__(self, rpt_hndl, rec_num):
self.rpt = rpt_hndl
self.rn = rec_num
self.slope_1 = ''
self.offset_1 = ''
self.slope_2 = ''
self.offset_2 = ''
self.init_pow = -30
def exg_setup(self):
type(self).exg.send_msg_to_server(':RAD:ARB ON')
type(self).exg.send_msg_to_server(':RAD:ARB:WAV ' + type(self).cfg.exg_waveform)
#type(self).exg.send_msg_to_server(':MMEM:DATA ' + type(self).cfg.exg_waveform)
print("EXG waveform is " + type(self).cfg.exg_waveform)
type(self).exg.send_msg_to_server(':FREQ ' + str(test_config.ul_freq) + ' MHz')
type(self).exg.send_msg_to_server(':POW ' + str(self.init_pow) + ' dBm')
type(self).exg.send_msg_to_server(':OUTP:MOD ON')
type(self).exg.send_msg_to_server(':OUTP ON')
def mt8870a_setup(self, freq_center):
Waveform = "'E-TM_1-1_10M'"
print 'VSG Setup...'
type(self).mt8870a.send_msg_to_server('SOUR:GPRF:GEN:MODE NORMAL\n')
type(self).mt8870a.send_msg_to_server('SOUR:GPRF:GEN:BBM ARB \n')
type(self).mt8870a.send_msg_to_server(':SOUR:GPRF:GEN:ARB:FILE:LOAD ' + Waveform)
type(self).mt8870a.send_msg_to_server('*WAI\n')
type(self).mt8870a.send_msg_to_server('*WAI\n')
type(self).mt8870a.send_msg_to_server(':SOUR:GPRF:GEN:RFS:LEV -100\n')
print 'Loading waveform...'
type(self).mt8870a.send_msg_to_server('SOUR:GPRF:GEN:ARB:WAV:PATT:SEL ' + Waveform + ',1,1\n')
type(self).mt8870a.send_msg_to_server('*WAI\n')
print 'Start VSG...'
type(self).mt8870a.send_msg_to_server('SOUR:GPRF:GEN:RFS:FREQ ' + str(freq_center * 1000000) + '\n')
type(self).mt8870a.send_msg_to_server('SOUR:GPRF:GEN:RFS:LEV ' + str(self.init_pow) + '\n')
type(self).mt8870a.send_msg_to_server('SOUR:GPRF:GEN:STAT ON\n')
def cmw500_setup(self, freq_center):
if self.cfg.cal_bandwidth == 20:
sync_delay = "0"
Waveform = "'D:\Rohde-Schwarz\CMW\Data\Waveform\CaviumFRC_20MHz.wv'"
elif self.cfg.cal_bandwidth == 15:
sync_delay = "0"
Waveform = "'D:\Rohde-Schwarz\CMW\Data\Waveform\CaviumFRC_15MHz.wv'"
elif self.cfg.cal_bandwidth == 10:
sync_delay = "0"
Waveform = "'D:\Rohde-Schwarz\CMW\Data\Waveform\CaviumFRC_10MHz.wv'"
elif self.cfg.cal_bandwidth == 5:
sync_delay = "0"
Waveform = "'D:\Rohde-Schwarz\CMW\Data\Waveform\CaviumFRC_5MHz.wv'"
print "VSG Setup..."
type(self).cmw500.send_msg_to_server("SOUR:GPRF:GEN:BBM ARB")
type(self).cmw500.send_msg_to_server("SOUR:GPRF:GEN:ARB:FILE " + Waveform)
type(self).cmw500.send_msg_to_server("SOUR:GPRF:GEN:ARB:REP CONT")
type(self).cmw500.send_msg_to_server("SOUR:GPRF:GEN:LIST OFF")
type(self).cmw500.send_msg_to_server("TRIG:GPRF:GEN:ARB:SOUR 'Manual'")
type(self).cmw500.send_msg_to_server("TRIG:GPRF:GEN:ARB:RETR ON")
type(self).cmw500.send_msg_to_server("TRIG:GPRF:GEN:ARB:AUT ON")
print "Start VSG..."
type(self).cmw500.send_msg_to_server("SOUR:GPRF:GEN:RFS:FREQ " + str(freq_center * 1000000))
type(self).cmw500.send_msg_to_server("SOUR:GPRF:GEN:RFS:LEV " + str(self.init_pow))
type(self).cmw500.send_msg_to_server("SOUR:GPRF:GEN:STAT ON")
type(self).cmw500.send_msg_to_server("*WAI")
type(self).cmw500.send_msg_to_server("SOURce:GPRF:GEN:STATe?")
in_msg = type(self).cmw500.recv_msg_frm_server()
line = in_msg.split('\n')
if (line[0] == "ON"):
print "VSG turn on"
else:
print "VSG can not turn on"
sys.exit()
def start_enodb(self):
type(self).enb.enb_login()
type(self).enb.enb_cd_usr_bin()
# default is PWM control in booting
if (type(self).cfg.tcxo_ctrl == "dax"):
print("load ext dac clock control")
type(self).enb.enb_load_dax() # do ext DAC control
if test_config.band > 32:
type(self).enb.enb_set_zen_tdd_rx()
"""
if im_calibration.is_dsp_running:
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_stop_transmit()
"""
def do_rssi_cal(self):
#type(self).enb.enb_disable_all_TX()
type(self).enb.enb_rf_drv_call()
type(self).enb.tn_write("loss", "S") # select rssi cal
type(self).enb.tn_write("antenna", str(type(self).cfg.rssi_cable_loss)) # cable loss
for ant in range(2):
print('')
print("Testing antenna port " + str(ant+1))
type(self).enb.tn.write("\n") # connect ant
if (ant == 0):
if (type(self).cfg.test_set == 'rs'):
type(self).cmw500.send_msg_to_server("ROUTe:GPRF:GENerator:SCENario:SALone RFAC, TX1")
else:
if (type(self).cfg.test_set == 'rs'):
type(self).cmw500.send_msg_to_server("ROUTe:GPRF:GENerator:SCENario:SALone RFBC, TX1")
sleep(1)
for cnt in range(0,4):
type(self).enb.tn.read_until("press Enter")
power = self.init_pow - 10*cnt
print("EXG power = " + str(power) + ' dBm')
if (type(self).cfg.test_set == 'agilent'):
type(self).exg.send_msg_to_server(':POW ' + str(power) + ' dBm')
elif (type(self).cfg.test_set == 'anritsu'):
type(self).mt8870a.send_msg_to_server('SOUR:GPRF:GEN:RFS:LEV ' + str(power) + '\n')
elif (type(self).cfg.test_set == 'rs'):
type(self).cmw500.send_msg_to_server('SOUR:GPRF:GEN:RFS:LEV ' + str(power))
sleep(0.5) # wait RF power stable
type(self).enb.tn.write("\n")
try:
res = type(self).enb.tn.read_until("calibration".encode("ascii"), 5)
type(self).enb.tn_write("Option:", "n")
type(self).enb.tn.write("q\n".encode("ascii"))
start = 0
while True:
start = res.find("slope_1=".encode("ascii"), start)
if (start == -1): break
start += len("slope_1=")
self.slope_1 = res[start:res.find(", ".encode("ascii"), start)]
start = res.find("offset_1=".encode("ascii"), start)
if (start == -1): break
start += len("offset_1=")
self.offset_1 = res[start:res.find('\n'.encode("ascii"), start)]
start = res.find("slope_2=".encode("ascii"), start)
if (start == -1): break
start += len("slope_2=")
self.slope_2 = res[start:res.find(", ".encode("ascii"), start)]
start = res.find("offset_2=".encode("ascii"), start)
if (start == -1): break
start += len("offset_2=")
self.offset_2 = res[start:res.find('\n'.encode("ascii"), start)]
print("slope_1=" + self.slope_1 + ", offset_1=" + self.offset_1)
print("slope_2=" + self.slope_2 + ", offset_2=" + self.offset_2)
if (type(self).cfg.test_report == True) and (im_calibration.is_test_all == True):
self.rpt.write('\nRSSI Calibration:\n')
self.rpt.write("slope_1=" + self.slope_1 + ", offset_1=" + self.offset_1 + '\n')
self.rpt.write("slope_2=" + self.slope_2 + ", offset_2=" + self.offset_2 + '\n')
break
if (test_config.wr_var_to_uboot == True):
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv rssi_slope_prim " \
+ str(self.slope_1), 3)
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv rssi_offset_prim " \
+ str(self.offset_1), 3)
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv rssi_slope_sec " \
+ str(self.slope_2), 3)
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv rssi_offset_sec " \
+ str(self.offset_2), 3)
if (type(self).cfg.en_eeprom_write == True):
self.enb.editUbootenv('RSSI_SLOPE_PRIM', str(self.slope_1))
self.enb.editUbootenv('RSSI_OFFSET_PRIM', str(self.offset_1))
self.enb.editUbootenv('RSSI_SLOPE_SEC', str(self.slope_2))
self.enb.editUbootenv('RSSI_OFFSET_SEC', str(self.offset_2))
if (im_calibration.is_test_all == True):
self.write_rssi_to_eeprom()
else:
se = raw_input("Write result to EEPROM?(y/n):")
if (se == 'y') or (se == 'Y'):
self.write_rssi_to_eeprom()
except:
print "Unexpected error:", sys.exc_info()[0]
def write_rssi_to_eeprom(self):
type(self).enb.enb_cd_usr_bin()
print "edit EEPROM record"
type(self).enb.enb_eeprom_edit_record('wrsp', self.rn, self.slope_1)
type(self).enb.enb_eeprom_edit_record('wrop', self.rn, self.offset_1)
type(self).enb.enb_eeprom_edit_record('wrss', self.rn, self.slope_2)
type(self).enb.enb_eeprom_edit_record('wros', self.rn, self.offset_2)
sleep(0.5) # wait EEPROM data wrote
def exg_turn_off(self):
type(self).exg.send_msg_to_server(':OUTP OFF')
type(self).exg.send_msg_to_server(':OUTP:MOD OFF')
def mt8870a_turn_off(self):
type(self).mt8870a.send_msg_to_server('SOUR:GPRF:GEN:STAT OFF\n')
def cmw500_turn_off(self):
type(self).cmw500.send_msg_to_server('SOUR:GPRF:GEN:STAT OFF')
def run(self):
if (type(self).cfg.test_set == 'agilent'):
self.exg_setup()
elif (type(self).cfg.test_set == 'anritsu'):
self.mt8870a_setup(test_config.ul_freq)
elif (type(self).cfg.test_set == 'rs'):
self.cmw500_setup(test_config.ul_freq)
self.start_enodb()
print("**** enb started")
self.do_rssi_cal()
print("**** rssi measure done")
if (type(self).cfg.test_set == 'agilent'):
self.exg_turn_off()
elif (type(self).cfg.test_set == 'anritsu'):
self.mt8870a_turn_off()
elif (type(self).cfg.test_set == 'rs'):
self.cmw500_turn_off()
print ""

BIN
octal/cavium_env/rf_card_cal_tip/cal_rx_rssi.pyc Normal file
View File

Binary file not shown.

391
octal/cavium_env/rf_card_cal_tip/cal_tx_pwr.py Normal file
View File

@@ -0,0 +1,391 @@
#!/usr/bin/python
"""
Setup:
1. Agilent MXA / Angritsu MT8870A, connect to primary antenna port of enodeB
2. Set TFTP server, address and port as test_config
"""
import sys
import test_config
import im_calibration
from time import sleep
from im_calibration import Calibration
#import common
class CalTxPwr(Calibration):
def __init__(self, rpt_hndl, rec_num):
self.rpt = rpt_hndl
self.rn = rec_num
self.slope_1 = ''
self.offset_1 = ''
self.slope_2 = ''
self.offset_2 = ''
self.attn_gain_val = []
self.input_power = -20 # input power in dBm
self.signal_bw = type(self).cfg.cal_bandwidth
if (self.cfg.cal_bandwidth == 5):
self.intbw = '4.5'
self.spabw = '10'
elif (self.cfg.cal_bandwidth == 10):
self.intbw = '9'
self.spabw = '20'
elif (self.cfg.cal_bandwidth == 15):
self.intbw = '13.5'
self.spabw = '25'
elif (self.cfg.cal_bandwidth == 20):
self.intbw = '18'
self.spabw = '30'
def mxa_setup(self):
type(self).mxa.send_msg_to_server(':INIT:CONT ON')
type(self).mxa.send_msg_to_server(':INST:SEL SA')
type(self).mxa.send_msg_to_server(':FREQ:CENT ' + str(test_config.dl_freq) + ' MHz')
type(self).mxa.send_msg_to_server(':CONF:CHP')
type(self).mxa.send_msg_to_server(':POW:ATT 30')
type(self).mxa.send_msg_to_server(':DISP:CHP:VIEW:WIND:TRAC:Y:RLEV 20 dBm')
type(self).mxa.send_msg_to_server(':CHP:BAND:INT ' + self.intbw + ' MHz')
type(self).mxa.send_msg_to_server(':CHP:FREQ:SPAN ' + self.spabw + ' MHz')
type(self).mxa.send_msg_to_server(':CHP:AVER:COUN 25')
type(self).mxa.send_msg_to_server(':CHP:AVER ON')
def mt8870a_setup(self, freq_center):
print 'Start VSA...'
type(self).mt8870a.send_msg_to_server('*RST')
type(self).mt8870a.send_msg_to_server('*IDN?')
in_msg = type(self).mt8870a.recv_msg_frm_server()
print('recv ' + type(self).cfg.mt8870a_ipaddr + '= ' + in_msg)
type(self).mt8870a.send_msg_to_server('INST SMALLCELL')
type(self).mt8870a.send_msg_to_server('INST:SYST 3GLTE_DL,ACT')
type(self).mt8870a.send_msg_to_server(':ROUT:PORT:CONN:DIR PORT3,PORT4')
type(self).mt8870a.send_msg_to_server(':BATC:BAND:FREQ:CENT ' + str(freq_center) + 'MHZ')
type(self).mt8870a.send_msg_to_server(':BATC:BAND:POW:RANG:ILEV ' + str(self.input_power))
type(self).mt8870a.send_msg_to_server(':BATC:CC:RAD:CBAN ' + str(self.signal_bw))
type(self).mt8870a.send_msg_to_server(':BATC:CC:RAD:TMOD TM1_1')
type(self).mt8870a.send_msg_to_server(':TRIG:STAT OFF')
type(self).mt8870a.send_msg_to_server(':TRIG:SOUR IMM')
type(self).mt8870a.send_msg_to_server(':BATC:CAPT:TIME:STAR 0')
type(self).mt8870a.send_msg_to_server(':BATC:CAPT:TIME:LENG 1')
type(self).mt8870a.send_msg_to_server(':BATC:CAPT:TIME:UWEM:STAR 0')
type(self).mt8870a.send_msg_to_server(':BATC:CAPT:TIME:UWEM:LENG 140')
type(self).mt8870a.send_msg_to_server(':BATC:CC:PDCC:SYMB:NUMB 2')
type(self).mt8870a.send_msg_to_server(':BATC:EVM ON')
type(self).mt8870a.send_msg_to_server('*WAI')
def cmw500_setup(self, freq_center):
print 'Start VSA...'
#if test_config.band > 32:
# type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:DMOD TDD")
#else:
# type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:DMOD FDD")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:DMOD FDD")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:RFS:FREQ " + str(freq_center) + " MHz")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:RFS:ENP 35")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:RFS:UMAR 0")
if (self.cfg.cal_bandwidth == 5):
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:CBAN B050")
elif (self.cfg.cal_bandwidth == 10):
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:CBAN B100")
elif (self.cfg.cal_bandwidth == 15):
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:CBAN B150")
elif (self.cfg.cal_bandwidth == 20):
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:CBAN B200")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:RES:ALL ON,OFF,OFF,OFF,OFF,OFF,ON,OFF,OFF")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:SCO:MOD 10")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:MOEX ON")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:REP SING")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:ETES ETM11")
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:MEV:PLC 1")
type(self).cmw500.send_msg_to_server("TRIG:LTE:MEAS:ENB:MEV:SOUR 'Free Run (Fast Sync)'")
def start_enodeb_tx(self):
type(self).enb.enb_login()
# default is PWM control in booting
if (type(self).cfg.tcxo_ctrl == "dax"):
print("load ext dac clock control")
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_load_dax() # do ext DAC control
if test_config.band > 32:
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_set_zen_tdd_tx()
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_run_dsp_app_dl()
def do_txpwr_cal(self):
type(self).enb.enb_cd_usr_bin()
#cmd = "a 1 " + str(type(self).cfg.attn1) + " q"
#type(self).enb.enb_rf_drv_call_cmd(cmd)
#sleep(2)
type(self).enb.enb_rf_drv_call()
type(self).enb.tn_write("loss", "T") # select tx cal
type(self).enb.tn_write("antenna", str(type(self).cfg.txpwr_cable_loss))
sleep(2)
if (type(self).cfg.test_report == True) and (im_calibration.is_test_all == True):
self.rpt.write('\nTX Power Calibration:\n')
for ant in range(2):
# the RF driver already switch the TX ports
print('')
print("Testing antenna port " + str(ant+1))
type(self).enb.tn.write("\n") # connect ant
sleep(2) # wait for second round stable
if (ant == 0):
if (type(self).cfg.test_set == 'rs'):
type(self).cmw500.send_msg_to_server("ROUTe:LTE:MEAS:ENB:SCENario:SALone RFAC, RX1")
else:
if (type(self).cfg.test_set == 'rs'):
type(self).cmw500.send_msg_to_server("ROUTe:LTE:MEAS:ENB:SCENario:SALone RFBC, RX1")
for st in range(0,3):
res = type(self).enb.tn.read_until(" ".encode("ascii"))
# measure channel power
if (type(self).cfg.test_set == 'agilent'):
sleep(1) #(5) # wait for average
type(self).mxa.send_msg_to_server(':FETC:CHP:CHP?')
in_msg = type(self).mxa.recv_msg_frm_server()
chpwr = str(round(float(in_msg), 2))
print('recv ' + type(self).cfg.mxa_ipaddr + '= ' + chpwr)
elif (type(self).cfg.test_set == 'anritsu'):
sleep(3) # wait for average
self.input_power = self.input_power + 10*st
type(self).mt8870a.send_msg_to_server(':BATC:BAND:POW:RANG:ILEV ' + str(self.input_power))
type(self).mt8870a.send_msg_to_server(':INIT:MODE:SING')
type(self).mt8870a.send_msg_to_server('*WAI')
type(self).mt8870a.send_msg_to_server(':FETC:BATC1?')
type(self).mt8870a.send_msg_to_server('*WAI')
in_msg = type(self).mt8870a.recv_msg_frm_server()
#print in_msg
line = in_msg.split(',')
chpwr = str(round(float(line[5]), 2))
print "Tx Power (Average) = " + chpwr + " dBm"
elif (type(self).cfg.test_set == 'rs'):
if (st == 0):
self.input_power = 5
self.input_power = self.input_power + 10
type(self).cmw500.send_msg_to_server("CONF:LTE:MEAS:ENB:RFS:ENP " + str(self.input_power))
type(self).cmw500.send_msg_to_server("INIT:LTE:MEAS:ENB:MEV")
type(self).cmw500.send_msg_to_server("*WAI")
type(self).cmw500.send_msg_to_server("FETC:LTE:MEAS:ENB:MEV:MOD:AVER?")
in_msg = type(self).cmw500.recv_msg_frm_server()
line = in_msg.split(',')
if (int(line[0]) != 0):
print in_msg
chpwr = str(round(float(line[17]), 2))
print "Tx Power (Average) = " + chpwr + " dBm"
type(self).enb.tn.write((chpwr+'\n').encode("ascii"))
sleep(3) # wait for second round stable
try:
res = type(self).enb.tn.read_until("calibration", 5)
#type(self).enb.tn_write("Option:", "y") # fsetenv variables
type(self).enb.tn.write("q\n".encode("ascii"))
start = 0
while (True):
start = res.find("slope_1=".encode("ascii"), start)
if (start == -1): break
start += len("slope_1=")
self.slope_1 = res[start:res.find(", ".encode("ascii"), start)]
start = res.find("offset_1=".encode("ascii"), start)
if (start == -1): break
start += len("offset_1=")
self.offset_1 = res[start:res.find('\n'.encode("ascii"), start)]
start = res.find("slope_2=".encode("ascii"), start)
if (start == -1): break
start += len("slope_2=")
self.slope_2 = res[start:res.find(", ".encode("ascii"), start)]
start = res.find("offset_2=".encode("ascii"), start)
if (start == -1): break
start += len("offset_2=")
self.offset_2 = res[start:res.find('\n'.encode("ascii"), start)]
print ""
print("slope_1=" + self.slope_1 + ", offset_1=" + self.offset_1)
print("slope_2=" + self.slope_2 + ", offset_2=" + self.offset_2)
print ""
if (type(self).cfg.test_report == True) and (im_calibration.is_test_all == True):
self.rpt.write("slope_1=" + self.slope_1 + ", offset_1=" + self.offset_1 + '\n')
self.rpt.write("slope_2=" + self.slope_2 + ", offset_2=" + self.offset_2 + '\n')
break
if test_config.wr_var_to_uboot == True:
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx_slope_prim " \
+ str(self.slope_1), 3)
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx_offset_prim " \
+ str(self.offset_1), 3)
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx_slope_sec " \
+ str(self.slope_2), 3)
type(self).enb.tn_write(im_calibration.pp_base, "fsetenv tx_offset_sec " \
+ str(self.offset_2), 3)
if (type(self).cfg.en_eeprom_write == True):
self.enb.editUbootenv('TX_SLOPE_PRIM', str(self.slope_1))
self.enb.editUbootenv('TX_OFFSET_PRIM', str(self.offset_1))
self.enb.editUbootenv('TX_SLOPE_SEC', str(self.slope_2))
self.enb.editUbootenv('TX_OFFSET_SEC', str(self.offset_2))
if (im_calibration.is_test_all == True):
sleep(2)
self.write_txpwr_to_eeprom()
else:
se = raw_input("Write result to EEPROM?(y/n):")
if (se == 'y') or (se == 'Y'):
self.write_txpwr_to_eeprom()
except:
print "Unexpected error:", sys.exc_info()[0]
# stop transmit
#type(self).enb.enb_cd_tmpfs()
#type(self).enb.enb_stop_transmit()
def write_txpwr_to_eeprom(self):
type(self).enb.enb_cd_usr_bin()
print "edit EEPROM record"
type(self).enb.enb_eeprom_edit_record('wtsp', self.rn, self.slope_1)
type(self).enb.enb_eeprom_edit_record('wtop', self.rn, self.offset_1)
type(self).enb.enb_eeprom_edit_record('wtss', self.rn, self.slope_2)
type(self).enb.enb_eeprom_edit_record('wtos', self.rn, self.offset_2)
sleep(0.5) # wait EEPROM data wrote
def run(self):
if (type(self).cfg.test_set == 'agilent'):
self.mxa_setup()
elif (type(self).cfg.test_set == 'anritsu'):
self.mt8870a_setup(test_config.dl_freq)
elif (type(self).cfg.test_set == 'rs'):
self.cmw500_setup(test_config.dl_freq)
self.start_enodeb_tx()
sleep(3) # wait spectrum comes out
self.do_txpwr_cal()
def get_attenuation_gain_value(self):
self.attn_gain_val = []
type(self).enb.enb_cd_usr_bin()
type(self).enb.tn.write("oncpu 0 /usr/bin/" + self.cfg.rf_driver + '\n')
_ = type(self).enb.tn.read_until("Option:".encode("ascii"), 5)
sleep(2) # prevent the rag command send too fast
type(self).enb.tn.write("rag\n".encode("ascii"))
res = type(self).enb.tn.read_until("gain1".encode("ascii"), 5)
type(self).enb.tn.write("q\n".encode("ascii"))
self.attn_gain_val.append(self.parse_attn_gain(res, 'attn1 '))
self.attn_gain_val.append(self.parse_attn_gain(res, 'attn2 '))
def parse_attn_gain(self, message, headstr):
start = 0
while (True):
start = message.find(headstr, start)
if (start == -1): break
start += len(headstr)
res = message[start:message.find(" dB".encode("ascii"), start)]
return int(res)
def set_attenuation(self, ch):
self.get_attenuation_gain_value()
if (ch == 1):
if (len(self.attn_gain_val) == 2):
print "Current primary attenuation = " + \
str(self.attn_gain_val[0])
self.att = raw_input("TX1 power attenuation(5-45 dB): ")
cmd = "a 1 " + str(self.att) + " q"
type(self).enb.enb_rf_drv_call_cmd(cmd)
else:
if (len(self.attn_gain_val) == 2):
print "Current secondary attenuation = " + \
str(self.attn_gain_val[1])
self.att = raw_input("TX2 power attenuation(5-45 dB): ")
cmd = " a 2 " + str(self.att) + " q"
type(self).enb.enb_rf_drv_call_cmd(cmd)
def tx_test(self):
self.start_enodeb_tx()
sleep(3) # wait spectrum comes out
if (type(self).cfg.test_set == 'agilent'):
self.mxa_setup()
elif (type(self).cfg.test_set == 'anritsu'):
self.mt8870a_setup(test_config.dl_freq)
elif (type(self).cfg.test_set == 'rs'):
self.cmw500_setup(test_config.dl_freq)
while (True):
print("(1) Primary port only")
print("(2) Second port only")
print("(3) All ports turn on")
print("(q) Quit")
self.mod = raw_input("Select: ")
if (self.mod == '1'):
type(self).enb.enb_disable_TX2()
self.set_attenuation(1)
elif (self.mod == '2'):
type(self).enb.enb_disable_TX1()
self.set_attenuation(2)
elif (self.mod == '3'):
type(self).enb.enb_enable_all_TX()
self.set_attenuation(1)
self.set_attenuation(2)
elif (self.mod == 'q') or (self.mod == 'Q'):
break
else:
print "unknown option"
continue
type(self).enb.enb_stop_transmit()

BIN
octal/cavium_env/rf_card_cal_tip/cal_tx_pwr.pyc Normal file
View File

Binary file not shown.

BIN
octal/cavium_env/rf_card_cal_tip/cavium_rftest_band3_zen.docx Normal file
View File

Binary file not shown.

12
octal/cavium_env/rf_card_cal_tip/common.py Normal file
View File

@@ -0,0 +1,12 @@
def hit_continue(Prompt = 'Hit Enter key to continue'):
raw_input(Prompt)
def disp_test_title(title):
length = len(title)
print ""
print "*" * (length + 4)
print "* " + title + " *"
print "*" * (length + 4)
print ""

BIN
octal/cavium_env/rf_card_cal_tip/common.pyc Normal file
View File

Binary file not shown.

95
octal/cavium_env/rf_card_cal_tip/enhancedserial.py Normal file
View File

@@ -0,0 +1,95 @@
#!/usr/bin/env python
"""Enhanced Serial Port class
part of pyserial (http://pyserial.sf.net) (C)2002 cliechti@gmx.net
another implementation of the readline and readlines method.
this one should be more efficient because a bunch of characters are read
on each access, but the drawback is that a timeout must be specified to
make it work (enforced by the class __init__).
this class could be enhanced with a read_until() method and more
like found in the telnetlib.
"""
from serial import Serial
from time import sleep
class EnhancedSerial(Serial):
def __init__(self, *args, **kwargs):
#ensure that a reasonable timeout is set
timeout = kwargs.get('timeout',0.01)
if timeout < 0.01: timeout = 0.01
kwargs['timeout'] = timeout
Serial.__init__(self, *args, **kwargs)
self.buf = ''
self.last = ''
def read(self, *args, **kwargs):
ret = Serial.read(self, *args, **kwargs)
#TODO: only store when there's someone called wait_until?
self.last += ret
return ret
def wait_until(self, *args, **kwargs):
timeout = kwargs.get('timeout',10)
tries=0
while 1:
if (timeout > 0) and (tries*self.timeout > timeout):
return -1
i = 0
for s in args:
if isinstance(s, str):
pos = self.last.find(s)
if pos >= 0:
self.last = self.last[pos+1:]
#print("matched"+ str(len(self.last)))
return i
else: break
i+=1
#if pattern not found, remove the found part in lines
pos = self.last.rfind('\n')
if pos >= 0 :
self.last = self.last[pos+1:]
sleep(self.timeout)
tries += 1
def readline(self, maxsize=None, timeout=1):
"""maxsize is ignored, timeout in seconds is the max time that is way for a complete line"""
tries = 0
while 1:
self.buf += self.read(512)
pos = self.buf.find('\n')
if pos >= 0:
line, self.buf = self.buf[:pos+1], self.buf[pos+1:]
return line
tries += 1
if tries * self.timeout > timeout:
break
line, self.buf = self.buf, ''
return line
def readlines(self, sizehint=None, timeout=1):
"""read all lines that are available. abort after timout when no more data arrives."""
lines = []
while 1:
line = self.readline(timeout=timeout)
if line:
lines.append(line)
if not line or line[-1:] != '\n':
break
return lines
if __name__=='__main__':
#do some simple tests with a Loopback HW (see test.py for details)
PORT = 0
#test, only with Loopback HW (shortcut RX/TX pins (3+4 on DSUB 9 and 25) )
s = EnhancedSerial(PORT)
#write out some test data lines
s.write('\n'.join("hello how are you".split()))
#and read them back
print s.readlines()
#this one should print an empty list
print s.readlines(timeout=0.4)

1173
octal/cavium_env/rf_card_cal_tip/enodeb_ctrl.py Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
octal/cavium_env/rf_card_cal_tip/enodeb_ctrl.pyc Normal file
View File

Binary file not shown.

169
octal/cavium_env/rf_card_cal_tip/eutra_bands.py Normal file
View File

@@ -0,0 +1,169 @@
#!/usr/bin/env python
from types import TypeType
class Band(object):
@staticmethod
def containsBand(eutra_band):
return 0
def dl_freq(self):
return (0, 0, 0) # (low, middle, high)
def ul_freq(self):
return (0, 0, 0)
class Band_1(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band1", 1]
def dl_freq(self):
return (2110, 2140, 2170)
def ul_freq(self):
return (1920, 1950, 1980)
class Band_3(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band3", 3]
def dl_freq(self):
return (1805, 1842.5, 1880) # 1850, 1755
def ul_freq(self):
return (1710, 1747.5, 1785)
class Band_4(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band4", 4]
def dl_freq(self):
return (2110, 2132.5, 2155)
def ul_freq(self):
return (1710, 1732.5, 1755)
class Band_7(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band7", 7]
def dl_freq(self):
return (2620, 2655, 2690)
def ul_freq(self):
return (2500, 2535, 2570)
class Band_8(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band8", 8]
def dl_freq(self):
return (925, 942.5, 960)
def ul_freq(self):
return (880, 897.5, 915)
class Band_13(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band13", 13]
def dl_freq(self):
return (746, 751, 756)
def ul_freq(self):
return (777, 782, 787)
class Band_14(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band14", 14]
def dl_freq(self):
return (758, 763, 768)
def ul_freq(self):
return (788, 793, 798)
class Band_17(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band17", 17]
def dl_freq(self):
return (734, 740, 746)
def ul_freq(self):
return (704, 710, 716)
class Band_25(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band25", 25]
def dl_freq(self):
return (1930, 1962, 1995)
def ul_freq(self):
return (1850, 1882, 1915)
class Band_28(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band28", 28]
def dl_freq(self):
return (758, 780.5, 803)
def ul_freq(self):
return (703, 725.5, 748)
class Band_38(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band38", 38]
def dl_freq(self):
return (2570, 2595, 2620) #2583, 2609, 2595
def ul_freq(self):
return (2570, 2595, 2620)
class Band_40(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band40", 40]
def dl_freq(self):
return (2300, 2350, 2400)
def ul_freq(self):
return (2300, 2350, 2400)
class Band_41(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band41", 41]
def dl_freq(self):
return (2496, 2593, 2690)
def ul_freq(self):
return (2496, 2593, 2690)
class Band_42(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band42", 42]
def dl_freq(self):
return (3400, 3500, 3600)
def ul_freq(self):
return (3400, 3500, 3600)
class Band_43(Band):
@staticmethod
def containsBand(eutra_band):
return eutra_band in ["band43", 43]
def dl_freq(self):
return (3600, 3650, 3800)
def ul_freq(self):
return (3600, 3650, 3800)
class BandFactory(object):
@staticmethod
def newBand(eutra_band):
# walk through all Band classes
bandClasses = [j for (i, j) in globals().iteritems() if isinstance(j, TypeType) and issubclass(j, Band)]
for bandClass in bandClasses :
if bandClass.containsBand(eutra_band):
return bandClass()
#if research was unsuccessful, raise an error
raise ValueError('No E-UTRA band containing "%s".' % eutra_band)
def main():
band = 4
mb = BandFactory().newBand(band)
dl_freq = mb.dl_freq()
ul_freq = mb.ul_freq()
print("Band=" + str(band) + " downlink=" + str(dl_freq[1]) + " uplink=" + str(ul_freq[1]))
if __name__ == "__main__":
main()

BIN
octal/cavium_env/rf_card_cal_tip/eutra_bands.pyc Normal file
View File

Binary file not shown.

163
octal/cavium_env/rf_card_cal_tip/eutra_earfcn.py Normal file
View File

@@ -0,0 +1,163 @@
#!/usr/bin/python
"""
Fdownlink = FDL_Low + 0.1 (NDL - NDL_Offset)
Fuplink = FUL_Low + 0.1 (NUL - NUL_Offset)
where:
NDL is downlink EARFCN
NUL is uplink EARFCN
NDL_Offset is offset used to calculate downlink EARFCN
NUL_Offset is offset used to calculate uplink EARFCN
"""
class EutraEarfcn():
def __init__(self):
self.eutra_arr = {1:[2110, 2140, 2170, 0, 1920, 1950, 1980, 18000],
2:[1930, 1960, 1990, 600, 1850, 1880, 1910, 18600],
3:[1805, 1842.5, 1880, 1200, 1710, 1747.5, 1785, 19200],
4:[2110, 2132.5, 2155, 1950, 1710, 1732.5, 1755, 19950],
5:[869, 881.5, 894, 2400, 824, 836.5, 849, 20400],
6:[875, 880, 885, 2650, 830, 835, 840, 20650],
7:[2620, 2655, 2690, 2750, 2500, 2535, 2570, 20750],
8:[925, 942.5, 960, 3450, 880, 897.5, 915, 21450],
9:[1844.9, 1862.4, 1879.9, 3800, 1749.9, 1767.4, 1784.9, 21800],
10:[2110, 2140, 2170, 4150, 1710, 1740, 1770, 22150],
11:[1475.9, 1485.9, 1495.9, 4750, 1427.9, 1437.9, 1447.9, 22750],
12:[729, 737.5, 746, 5010, 699, 707.5, 716, 23010],
13:[746, 751, 756, 5180, 777, 782, 787, 23180],
14:[758, 763, 768, 5280, 788, 793, 798, 23280],
17:[734, 740, 746, 5730, 704, 710, 716, 23730],
18:[860, 867.5, 875, 5850, 815, 822.5, 830, 23850],
19:[875, 882.5, 890, 6000, 830, 837.5, 845, 24000],
20:[791, 806, 821, 6150, 832, 847, 862, 24150],
21:[1495.9, 1503.4, 1510.9, 6450, 1447.9, 1455.4, 1462.9, 24450],
22:[3510, 3550, 3590, 6600, 3410, 3450, 3490, 24600],
23:[2180, 2190, 2200, 7500, 2000, 2010, 2020, 25500],
24:[1525, 1542, 1559, 7700, 1626.5, 1643.5, 1660,5, 25700],
25:[1930, 1962.5, 1995, 8040, 1850, 1882.5, 1915, 26040],
26:[859, 876.5, 894, 8690, 814, 831.5, 849, 26690],
27:[852, 860.5, 869, 9040, 807, 815.5, 824, 27040],
28:[758, 780.5, 803, 9210, 703, 725.5, 748, 27210],
30:[2350, 2355, 2360, 9770, 2305, 2310, 2315, 27660],
31:[462.5, 465, 467.5, 9870, 452.5, 455, 457.5, 27760],
33:[1900, 1910, 1920, 36000, 1900, 1910, 1920, 36000],
34:[2010, 2017.5, 2025, 36200, 2010, 2017.5, 2025, 36200],
35:[1850, 1880, 1910, 36350, 1850, 1880, 1910, 36350],
36:[1930, 1960, 1990, 36950, 1930, 1960, 1990, 36950],
37:[1910, 1920, 1930, 37550, 1910, 1920, 1930, 37550],
38:[2570, 2595, 2620, 37750, 2570, 2595, 2620, 37750],
39:[1880, 1900, 1920, 38250, 1880, 1900, 1920, 38250],
40:[2300, 2350, 2400, 38650, 2300, 2350, 2400, 38650],
41:[2496, 2593, 2690, 39650, 2496, 2593, 2690, 39650],
42:[3400, 3500, 3600, 41590, 3400, 3500, 3600, 41590],
43:[3600, 3700, 3800, 43590, 3600, 3700, 3800, 43590],
44:[703, 753, 803, 45590, 703, 753, 803, 45590]}
def dl_freq2earfcn(self, band, freq):
earfcn = -1
binf = self.eutra_arr[int(band)]
fmin = binf[0]
fmax = binf[2]
if (float(freq) < fmin) or (float(freq) > fmax):
print "frequency not in this band"
#print "band=" + str(band) + " fmin=" + str(fmin) + " fmax=" + str(fmax)
else:
earfcn = int(10*(float(freq) - binf[0]) + binf[3])
return earfcn
def ul_freq2earfcn(self, band, freq):
earfcn = -1
binf = self.eutra_arr.get(int(band))
fmin = binf[4]
fmax = binf[6]
if (float(freq) < fmin) or (float(freq) > fmax):
print "frequency not in this band"
else:
earfcn = int(10*(float(freq) - binf[4]) + binf[7])
return earfcn
def dl_earfcn2freq(self, earfcn):
freq = 0
for _, elem in self.eutra_arr.items():
emin = elem[3]
emax = elem[3] + 10*(elem[2] - elem[0]) - 1
if (int(earfcn) > emin) and (int(earfcn) < emax):
freq = elem[0] + 0.1*(int(earfcn) - elem[3])
return freq
def ul_earfcn2freq(self, earfcn):
freq = 0
for _, elem in self.eutra_arr.items():
emin = elem[7]
emax = elem[7] + 10*(elem[6] - elem[4]) - 1
if (int(earfcn) > emin) and (int(earfcn) < emax):
freq = elem[4] + 0.1*(int(earfcn) - elem[7])
return freq
def get_middle_dl_earfcn(self, band):
binf = self.eutra_arr[int(band)]
earfcn = 5*(binf[2] - binf[0]) + binf[3]
return earfcn
def get_middle_ul_earfcn(self, band):
binf = self.eutra_arr[int(band)]
earfcn = 5*(binf[6] - binf[4]) + binf[7]
return earfcn
def main():
en = EutraEarfcn()
while (True):
print "1. DL freq to earfcn"
print "2. UL freq to earfcn"
print "3. DL earfcn to freq"
print "4. UL earfcn to freq"
print "q. Quit"
op = raw_input("Select Calibration Option:")
if (op == '1'):
band = raw_input("band:")
freq = raw_input("freq:")
print str(en.dl_freq2earfcn(band, freq))
elif (op == '2'):
band = raw_input("band:")
freq = raw_input("freq:")
print str(en.ul_freq2earfcn(band, freq))
elif (op == '3'):
earfcn = raw_input("earfcn:")
print str(en.dl_earfcn2freq(earfcn))
elif (op == '4'):
earfcn = raw_input("earfcn:")
print str(en.ul_earfcn2freq(earfcn))
elif (op == 'q'):
break
else:
break
print "bye bye"
if __name__ == "__main__":
main()

BIN
octal/cavium_env/rf_card_cal_tip/eutra_earfcn.pyc Normal file
View File

Binary file not shown.

183
octal/cavium_env/rf_card_cal_tip/im_calibration.py Normal file
View File

@@ -0,0 +1,183 @@
#!/usr/bin/python
import tcp_client
import enodeb_ctrl
import test_config
from time import sleep
# global variable
is_dsp_running = False # DSP running indicator
is_test_all = False # test all items
pp_base = '>' # prompt base for tn_write
class Calibration(object):
cfg = test_config.EnbConfig()
enb = enodeb_ctrl.enodeB_Ctrl()
if (cfg.test_set == 'agilent'):
mxa = tcp_client.TcpClient(cfg.mxa_ipaddr, cfg.mxa_tcp_port)
exg = tcp_client.TcpClient(cfg.exg_ipaddr, cfg.exg_tcp_port)
elif (cfg.test_set == 'anritsu'):
mt8870a = tcp_client.TcpClient(cfg.mt8870a_ipaddr, cfg.mt8870a_tcp_port)
elif (cfg.test_set == 'rs'):
cmw500 = tcp_client.TcpClient(cfg.cmw500_ipaddr, cfg.cmw500_tcp_port)
dl_freq = test_config.dl_freq
ul_freq = test_config.ul_freq
def __init__(self, rpt_hndl, rec_num):
self.rpt = rpt_hndl
self.rn = rec_num
def exg_connect(self):
type(self).exg.tcp_connect()
sleep(1)
def exg_init(self):
type(self).exg.send_msg_to_server('*IDN?')
in_msg = type(self).exg.recv_msg_frm_server()
print('recv ' + type(self).cfg.exg_ipaddr + '= ' + in_msg)
def exg_setup(self):
pass
def mxa_connect(self):
type(self).mxa.tcp_connect()
sleep(1)
def mxa_init(self):
if (type(self).cfg.instr_disp == True):
type(self).mxa.send_msg_to_server(":DISPlay:ENABle ON")
else:
type(self).mxa.send_msg_to_server(":DISPlay:ENABle OFF")
type(self).mxa.send_msg_to_server('*RST')
type(self).mxa.send_msg_to_server('*IDN?')
in_msg = type(self).mxa.recv_msg_frm_server()
print('Instrument ID: ' + in_msg)
def mxa_pre_setup(self):
pass
def mxa_setup(self, freq_center):
type(self).mxa.send_msg_to_server(':INIT:CONT ON')
type(self).mxa.send_msg_to_server(':INST:SEL SA')
type(self).mxa.send_msg_to_server(':FREQ:CENT ' +
str(freq_center) + ' MHz')
type(self).mxa.send_msg_to_server(':FREQ:SPAN ' +
str(type(self).cfg.cal_bandwidth+10) + ' MHz')
type(self).mxa.send_msg_to_server(':POW:ATT 30')
def mt8870a_connect(self):
type(self).mt8870a.tcp_connect()
sleep(1)
def mt8870a_init(self):
type(self).mt8870a.send_msg_to_server('*IDN?')
in_msg = type(self).mt8870a.recv_msg_frm_server()
print('Instrument ID: ' + in_msg)
print 'Instrument Setup...\n'
type(self).mt8870a.send_msg_to_server('SYST:LANG SCPI')
type(self).mt8870a.send_msg_to_server('INST SMALLCELL')
type(self).mt8870a.send_msg_to_server('INST:SYST 3GLTE_DL,ACT')
type(self).mt8870a.send_msg_to_server(':ROUT:PORT:CONN:DIR PORT3,PORT4')
def mt8870a_pre_setup(self):
pass
def mt8870a_setup(self, freq_center):
pass
def cmw500_connect(self):
type(self).cmw500.tcp_connect()
sleep(1)
def cmw500_init(self):
type(self).cmw500.send_msg_to_server("*RST")
type(self).cmw500.send_msg_to_server("*IDN?")
in_msg = type(self).cmw500.recv_msg_frm_server()
print('Instrument ID: ' + in_msg)
print 'Instrument Setup...\n'
if (type(self).cfg.instr_disp == True):
type(self).cmw500.send_msg_to_server("SYSTem:DISPlay:UPDate ON")
type(self).cmw500.send_msg_to_server("*GTL")
else:
type(self).cmw500.send_msg_to_server("SYSTem:DISPlay:UPDate OFF")
type(self).cmw500.send_msg_to_server("*GTL")
type(self).cmw500.send_msg_to_server("ROUTe:GPRF:GENerator:SCENario:SALone RFAC, TX1")
type(self).cmw500.send_msg_to_server("ROUTe:GPRF:MEASurement:SCENario:SALone RFAC, RX1")
type(self).cmw500.send_msg_to_server("ROUTe:LTE:MEAS:ENB:SCENario:SALone RFAC, RX1")
def cmw500_pre_setup(self):
pass
def cmw500_setup(self, freq_center):
pass
def start_enodeb_tx(self):
# start enodeB
type(self).enb.start_telnet_session()
type(self).enb.enb_login()
type(self).enb.get_macaddr()
type(self).enb.enb_set_1pps()
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_load_rf_drv()
type(self).enb.enb_load_rf_init()
type(self).enb.enb_set_rf_drv_rf_card(test_config.dl_freq[0], test_config.ul_freq[0])
if (type(self).cfg.board_typ == "zen_ad"):
print "load pwm clock control"
type(self).enb.enb_load_pwm()
else:
print "load dac clock control"
type(self).enb.enb_load_dac() # do DAC control
if test_config.band > 32:
type(self).enb.enb_set_zen_tdd_tx()
type(self).enb.enb_cd_etc()
type(self).enb.enb_load_cazac()
type(self).enb.enb_load_calgrant()
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_load_LSM_X_L1_0_July10()
type(self).enb.enb_load_dsp_app_dl()
type(self).enb.enb_set_dsp_app_dl()
type(self).enb.enb_set_7ffeff00()
type(self).enb.enb_cleanup_tmpfs_partition()
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_load_dsp_app_dl()
type(self).enb.enb_load_LSM_X_TV_0_wk21_00_ETM()
type(self).enb.enb_run_dsp_app_etm1p1()
def end_sys(self):
print("")
#type(self).mxa.send_msg_to_server(":DISPlay:ENABle ON") # turn on display
if (self.cfg.test_set == 'agilent'):
type(self).exg.tcp_close()
type(self).mxa.tcp_close()
elif (self.cfg.test_set == 'anritsu'):
type(self).mt8870a.tcp_close()
elif (self.cfg.test_set == 'rs'):
type(self).cmw500.tcp_close()
#type(self).enb.end_telnet_session()

BIN
octal/cavium_env/rf_card_cal_tip/im_calibration.pyc Normal file
View File

Binary file not shown.

1086
octal/cavium_env/rf_card_cal_tip/main.py Normal file
View File

File diff suppressed because it is too large Load Diff

86
octal/cavium_env/rf_card_cal_tip/tcp_client.py Normal file
View File

@@ -0,0 +1,86 @@
#!/usr/bin/env python
import sys
import socket
from time import sleep
class TcpClient():
def __init__(self, host_ip, host_port):
self.host_ip = host_ip
self.host_port = host_port
self.in_msg = ""
self.out_msg = ""
self.sock = None
self.recv_buf_size = 2048
try:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.settimeout(10)
print("tcp socket ok")
except socket.error, msg:
sys.stderr.write("[ERROR] %s\n" % msg[1])
raise
def tcp_connect(self):
if (self.sock != None):
try:
self.sock.connect((self.host_ip, self.host_port))
print("tcp connect ok")
except socket.error, msg:
sys.stderr.write("[ERROR] %s\n" % msg[1])
raise
else:
print(self.host_ip + ": " + "skip tcp connect")
def send_msg_to_server(self, message):
self.out_msg = message
nsend = self.sock.send(self.out_msg + '\n')
if (nsend > 0):
#print('sent '+ self.host_ip + '= ' + self.out_msg)
pass
def recv_msg_frm_server(self):
self.in_msg = ""
self.in_msg = self.sock.recv(self.recv_buf_size)
return self.in_msg
def tcp_close(self):
self.sock.close()
print(self.host_ip + " close tcp socket")
def main():
# test exg
HOST = '192.168.51.204'
PORT = 5025
MSG1 = '*IDN?'
MSG2 = ':FREQ:CENT 2125 MHz'
MSG3A = ':POW -'
MSG3B = ' dBm'
tcpc = TcpClient(HOST, PORT)
tcpc.tcp_connect()
sleep(1)
tcpc.send_msg_to_server(MSG1)
in_msg = tcpc.recv_msg_frm_server()
print('recv ' + tcpc.host_ip + '= ' + in_msg)
tcpc.send_msg_to_server(MSG2)
for cnt in range(5):
tcpc.send_msg_to_server(MSG3A + str(cnt*10 + 20) + MSG3B)
sleep(2)
tcpc.tcp_close()
print("\nend of tcp_client")
return 0
if (__name__ == "__main__"):
main()

BIN
octal/cavium_env/rf_card_cal_tip/tcp_client.pyc Normal file
View File

Binary file not shown.

371
octal/cavium_env/rf_card_cal_tip/test_config.py Normal file
View File

@@ -0,0 +1,371 @@
#!/usr/bin/env python
"""
description: test configuration
"""
import os
import sys
# band, frequency setting:
# keep zero if select band later and use middle channel to test
# fill target band and frequency for custom setting
band = 0 # DUT band
dl_freq = 0 # current downlink frequency
ul_freq = 0 # current uplink frequency
wr_var_to_uboot = False # T: write variable to uboot; F: don't write
class EnbConfig():
def __init__(self):
self.num_cal_channel = 0 # number of calibration channels
self.dl_freq_arr = [] # list of downlink frequencies
self.ul_freq_arr = [] # list of uplink frequencies
self.cal_freq_arr = [] # list of calibration freq pair
self.cfg_file = 'test_config.txt'
self.board_typ = 'zen_ad' # board type [refkit1, zen_ad, zen_ak]
self.cal_bandwidth = 20 # calibration bandwidth in mhz [10, 20]
self.tcxo_ctrl = 'pwm' # tcxo control type [pwm, dac, dax]
self.attn1 = 13 # port 1 attenuation
self.attn2 = 13 # port 2 attenuation
self.gain1 = 35 # port 1 gain [dB]
self.gain2 = 35 # port 2 gain [dB]
self.login_pwd = '' # root login password
self.enb_ipaddr = '10.18.104.61' #'192.168.166.61' # enodeB IP address
self.enb_tn_port = 23 # enodeB telnet port
self.tftp_server_ip = '10.18.104.240' #'192.168.166.202' # tftp server IP address
self.rssi_cable_loss = 5 # cable loss for RSSI test
self.txpwr_cable_loss = 5 # cable loss for TX test
self.manual_switch_instr = True # enable/disable wait for switch cable
self.test_set='rs' # test set type [agilent, anritsu, rs]
# agilent test set
self.exg_ipaddr = '192.168.166.201' # EXG IP address
self.exg_tcp_port = 5025 # EXG TCP port
self.mxa_ipaddr = '192.168.166.203' # MXA IP address
self.mxa_tcp_port = 5025 # MXA TCP port
# anritsu test set
self.mt8870a_ipaddr = '192.168.166.201'
self.mt8870a_tcp_port = 56001
# r&s test set
self.cmw500_ipaddr = '192.168.166.69'
self.cmw500_tcp_port = 5025
# test files
self.rf_driver = 'cn_rfdriver'
self.rf_drv_init = 'rf_init.txt'
self.dsp_app_dl = 'pltD-dl'
self.dl_etm_test_vector = 'CAL_ETM_TV_20Mhz.tgz'
self.exg_waveform = '"ESG_TC0301_10M_LOW.DAT"'
# test criteria
self.max_atten = 25 # make the lowest TX power to start TX power test; 5 ~ 45
self.cr_txpwr_min = 11 # minimum TX output power limit
self.cr_txpwr_max = 22 # maximum TX output power limit
self.cr_txevm_max = 3.5 # maximum TX EVM limit
# system variables
self.en_eeprom_write = True # disable when refkit1
self.eeprom_record_ver = 1 # EEPROM record version
self.test_report = True # T: enable test report; F: disable
self.instr_disp = True # T: enable instrument screen display
self.eeprom_board_type = 1
self.eeprom_rfic_type = 1
self.eeprom_tcxo_ctrl = 1 # tcxo control type
# RX sensitivity test
self.do_sens_test_in_opt1 = True # do test in option 1 calibration
self.my_udp_ipaddr = '10.102.81.151' # UDP IP address for sensitivity test
self.my_udp_port = 9991 # UDP port for sensitivity test
self.rx_test_vector = 'TV_Low_120627.tgz' # for old DSP
self.rx_patch_vector = 'tc0301_low.tgz' # for old DSP
self.tcid = '901' # RX test case ID
self.rx_gain = 60 # RX gain for sensitivity test
self.bler_limit = 5 # percentage of BLER pass criteria
self.sens_pass_limit = -96 # sensitivity pass limit
# Baseboard test variables
self.bb_port = 'COM11' #'/dev/ttyUSB0'
self.bb_baudrate = 115200
self.bb_pingip = '10.18.104.240'
if self.check_cfg_file() < 0: sys.exit()
if self.read_cal_channel() < 0: sys.exit()
self.read_config()
self.select_rf_drv_init()
self.select_dl_etm_test_vector()
self.select_ul_exg_waveform()
def check_cfg_file(self):
cfgfile = open(self.cfg_file, "r")
if (os.path.isfile(self.cfg_file) == False):
print self.cfg_file + " file doesn't exist"
return -1
else:
self.cfgln = cfgfile.readlines()
cfgfile.close()
return 0
def read_cal_channel(self):
for cl in self.cfgln:
par, val = self.read_line(cl)
if (par == "band"):
global band
band = int(val)
elif (par == "num_cal_channel"):
self.num_cal_channel = int(val)
elif (par == "dl_freq"):
self.dl_freq_arr.append(float(val))
elif (par == "ul_freq"):
self.ul_freq_arr.append(float(val))
if (len(self.dl_freq_arr) != len(self.ul_freq_arr)):
print "number of downlink and uplink frequencies mismatch"
return -1
if (len(self.dl_freq_arr) != self.num_cal_channel):
print "num_cal_channel value mismatch with DL/UL frequencies"
return -1
for i in range(self.num_cal_channel):
self.cal_freq_arr.append([self.dl_freq_arr[i], self.ul_freq_arr[i]])
#print "dl_freq_arr " + str(self.dl_freq_arr[i]) + " ul_freq_arr " + str(self.ul_freq_arr[i])
return 0
def get_cal_freq_arr(self):
return self.cal_freq_arr
def select_dl_etm_test_vector(self):
if (self.cal_bandwidth == 5):
self.dl_etm_test_vector = 'CAL_ETM_TV_5Mhz.tgz'
elif (self.cal_bandwidth == 10):
self.dl_etm_test_vector = 'CAL_ETM_TV_10Mhz.tgz'
elif (self.cal_bandwidth == 15):
self.dl_etm_test_vector = 'CAL_ETM_TV_15Mhz.tgz'
elif (self.cal_bandwidth == 20):
self.dl_etm_test_vector = 'CAL_ETM_TV_20Mhz.tgz'
else:
self.dl_etm_test_vector = 'CAL_ETM_TV_20Mhz.tgz'
def select_ul_exg_waveform(self):
if (self.cal_bandwidth == 5):
if (self.tcid == '901'):
self.exg_waveform = '"5MHz_FRCA13_RO_0"'
elif (self.tcid == '307'):
self.exg_waveform = '"5mhz__pusch_15rb_frca3_4_tc0307.wfm"'
elif (self.tcid == '308'):
self.exg_waveform = '"5mhz__pusch_25rb_frca4_5_tc0308.wfm"'
elif (self.tcid == '309'):
self.exg_waveform = '"5mhz__pusch_25rb_frca5_4_tc0309.wfm"'
else:
self.exg_waveform = '"5mhz__pusch_15rb_frca1_2_tc0306.wfm"'
elif (self.cal_bandwidth == 10):
if (self.tcid == '901'):
#self.exg_waveform = '"10mhz__pusch_25rb_frca1_3_tc0901.wfm"'
self.exg_waveform = '"10MHz_FRCA13_RO_0"'
elif (self.tcid == '902'):
self.exg_waveform = '"10mhz__pusch_50rb_frca3_5_tc0902.wfm"'
elif (self.tcid == '903'):
self.exg_waveform = '"10mhz__pusch_50rb_frca4_6_tc0903.wfm"'
elif (self.tcid == '904'):
self.exg_waveform = '"10mhz__pusch_50rb_frca5_5_tc0904.wfm"'
else:
self.exg_waveform = '"10mhz__pusch_25rb_frca1_3_tc0901.wfm"'
elif (self.cal_bandwidth == 15):
if (self.tcid == '901'):
self.exg_waveform = '"15MHZ_FRCA13_RO_0"'
elif (self.cal_bandwidth == 20):
if (self.tcid == '901'):
#self.exg_waveform = '"20mhz__pusch_25rb_frca1_3_tc0901.wfm"'
self.exg_waveform = '"20MHz_FRCA13_RO_0"'
elif (self.tcid == '902'):
self.exg_waveform = '"20mhz__pusch_100rb_frca3_7_tc0902.wfm"'
elif (self.tcid == '903'):
self.exg_waveform = '"20mhz__pusch_100rb_frca4_8_tc0903.wfm"'
elif (self.tcid == '904'):
self.exg_waveform = '"20mhz__pusch_100rb_frca5_7_tc0904.wfm"'
else:
self.exg_waveform = '"20mhz__pusch_25rb_frca1_3_tc0901.wfm"'
else:
self.exg_waveform = '"10mhz__pusch_25rb_frca1_3_tc0901.wfm"'
def select_rf_drv_init(self):
if (self.cal_bandwidth == 5):
self.rf_drv_init = 'ad9362_init_zen5Mhz.txt'
elif (self.cal_bandwidth == 10):
self.rf_drv_init = 'ad9362_init_zen10Mhz.txt'
elif (self.cal_bandwidth == 15):
self.rf_drv_init = 'ad9362_init_zen15Mhz.txt'
elif (self.cal_bandwidth == 20):
self.rf_drv_init = 'ad9362_init_zen20Mhz.txt'
else:
self.rf_drv_init = 'ad9362_init_zen20Mhz.txt'
def read_config(self):
cfgfile = open(self.cfg_file, "r")
cfgln = cfgfile.readlines()
cfgfile.close()
for cl in cfgln:
par, val = self.read_line(cl)
if (par == "board_typ"):
self.board_typ = val
elif (par == "cal_bandwidth"):
self.cal_bandwidth = int(val)
elif (par == "tcxo_ctrl"):
self.tcxo_ctrl = val
elif (par == "test_set"):
self.test_set = val
elif (par == "attn1"):
self.attn1 = val
elif (par == "attn2"):
self.attn2 = val
elif (par == "gain1"):
self.gain1 = val
elif (par == "gain2"):
self.gain2 = val
elif (par == "login_pwd"):
self.login_pwd = val
elif (par == "enb_ipaddr"):
self.enb_ipaddr = val
elif (par == "enb_tn_port"):
self.enb_tn_port = int(val)
elif (par == "tftp_server_ip"):
self.tftp_server_ip = val
elif (par == "exg_ipaddr"):
self.exg_ipaddr = val
elif (par == "exg_tcp_port"):
self.exg_tcp_port = int(val)
elif (par == "mxa_ipaddr"):
self.mxa_ipaddr = val
elif (par == "mxa_tcp_port"):
self.mxa_tcp_port = int(val)
elif (par == "mt8870a_ipaddr"):
self.mt8870a_ipaddr = val
elif (par == "mt8870a_tcp_port"):
self.mt8870a_tcp_port = int(val)
elif (par == "cmw500_ipaddr"):
self.cmw500_ipaddr = val
elif (par == "cmw500_tcp_port"):
self.cmw500_tcp_port = int(val)
elif (par == "rssi_cable_loss"):
self.rssi_cable_loss = float(val)
elif (par == "txpwr_cable_loss"):
self.txpwr_cable_loss = float(val)
elif (par == "manual_switch_instr"):
self.manual_switch_instr = self.str2bool(val)
elif (par == "rf_driver"):
self.rf_driver = val
#elif (par == "rf_drv_init"):
# self.rf_drv_init = val
elif (par == "dsp_app_dl"):
self.dsp_app_dl = val
#elif (par == "dl_etm_test_vector"):
# self.dl_etm_test_vector = val
#elif (par == "exg_waveform"):
# self.exg_waveform = val
elif (par == "max_atten"):
self.max_atten = int(val)
elif (par == "cr_txpwr_min"):
self.cr_txpwr_min = int(val)
elif (par == "cr_txpwr_max"):
self.cr_txpwr_max = int(val)
elif (par == "cr_txevm_max"):
self.cr_txevm_max = float(val)
elif (par == "en_eeprom_write"):
self.en_eeprom_write = self.str2bool(val)
elif (par == "eeprom_record_ver"):
self.eeprom_record_ver = val
#elif (par == "eeprom_new_rec"):
# self.eeprom_new_rec = self.str2bool(val)
elif (par == "test_report"):
self.test_report = self.str2bool(val)
elif (par == "instr_disp"):
self.instr_disp = self.str2bool(val)
elif (par == "do_sens_test_in_opt1"):
self.do_sens_test_in_opt1 = self.str2bool(val)
elif (par == "my_udp_ipaddr"):
self.my_udp_ipaddr = val
elif (par == "my_udp_port"):
self.my_udp_port = int(val)
#elif (par == "rx_test_vector"):
# self.rx_test_vector = val
#elif (par == "rx_patch_vector"):
# self.rx_patch_vector = val
elif (par == "tcid"):
self.tcid = val
elif (par == "rx_gain"):
self.rx_gain = val
elif (par == "bler_limit"):
self.bler_limit = int(val)
elif (par == "sens_pass_limit"):
self.sens_pass_limit = int(val)
elif (par == "bb_port"):
self.bb_port = val
elif (par == "bb_baudrate"):
self.bb_baudrate = val
elif (par == "bb_pingip"):
self.bb_pingip = val
elif (par == ""):
continue
else:
pass
#print("unknown parameter!")
def read_line(self, strline):
param = ""
value = ""
sn = strline
if ((sn[0] != '#') and (sn[0] != ' ') and
(sn[0] != '\n') and (sn[0] != '\r') and
(sn[0] != '\t')):
result = sn.split('=')
param = result[0]
value = result[1]
for i in range(len(value)):
if ((value[i] == '\n') or (value[i] == '\r')):
value = value[:i]
break
elif ((value[i] == " ") or (value[i] == "#") or (value[i] == '\t')):
value = value[:i]
break
value = value.strip("\'")
#print("read_line(): param=%s, value=%s" % (param, value))
return param, value
def str2bool(self, vs):
return vs.lower() in ("yes", "true", "t", "1")
def main():
ec = EnbConfig()
ec.read_config()
if (__name__ == "__main__"):
main()

BIN
octal/cavium_env/rf_card_cal_tip/test_config.pyc Normal file
View File

Binary file not shown.

76
octal/cavium_env/rf_card_cal_tip/test_config.txt Normal file
View File

@@ -0,0 +1,76 @@
# calibration channel frequency select
# 1. the 1st dl_freq & ul_freq calibration results will write into u-boot environment variables
# 2. leave the 1st dl_freq & ul_freq to zero for default(center) frequencies
num_cal_channel=1 # number of calibration channels
band=3 # enodeB band
dl_freq=1840 # downlink frequency
ul_freq=1745 # uplink frequency
# environment setting
board_typ='zen_ad' # board type [zen_ad]
cal_bandwidth=10 # calibration bandwidth in mhz [5, 10, 15, 20]
tcxo_ctrl='pwm' # tcxo control type [pwm, dac, dax]; dax - DAC8571
attn1=18 # port 1 attenuation
attn2=18 # port 2 attenuation
gain1=38 # port 1 gain [dB]
gain2=38 # port 2 gain [dB]
login_pwd='cavium.lte' # 'admin.udcell'
enb_ipaddr='10.102.81.61' # enodeB IP address
enb_tn_port=23 # enodeB telnet port
tftp_server_ip='10.102.81.50' # tftp server IP address
rssi_cable_loss=9 # cable loss for RSSI test
txpwr_cable_loss=9 # cable loss for TX test
manual_switch_instr=False # T: pause for manual switching; F: continuous
test_set='agilent' # test set type [agilent, anritsu, rs]
# agilent test set
exg_ipaddr='10.115.115.38' # EXG IP address
exg_tcp_port=5025 # EXG TCP port
mxa_ipaddr='10.102.81.200' # MXA IP address
mxa_tcp_port=5025 # MXA TCP port
# anritsu test set
mt8870a_ipaddr='192.168.166.68' # '192.168.1.1'
mt8870a_tcp_port=56001
# r&s test set
cmw500_ipaddr='10.115.115.40'
cmw500_tcp_port=5025
# test files
rf_driver='cn_rfdriver' # 'oct_fusion_rfic_drv-E2E'
dsp_app_dl='pltD' #'pltD.gz'
dl_etm_test_vector='LSM_X_TV_0_wk21_00_ETM_10Mhz.tgz'
# test criteria
max_atten=5 #28 # make the lowest TX power to start TX power test; 5 ~ 45
cr_txpwr_min=-10 # minimum TX output power limit
cr_txpwr_max=22 # maximum TX output power limit
cr_txevm_max=5.0 # maximum TX EVM limit
# system variables
en_eeprom_write=True # T: write EEPROM
eeprom_record_ver=1 # EEPROM record version
test_report=True # T: enable test report; F: disable
instr_disp=True # T: enable instrument screen display
# RX sensitivity test
do_sens_test_in_opt1=True # do test in option 1 calibration
my_udp_ipaddr='192.168.166.27' # UDP IP address for sensitivity test
my_udp_port=9991 # UDP port for sensitivity test
tcid='901' # RX test case ID
rx_gain=60 # RX gain for sensitivity test
bler_limit=4 # percentage of BLER pass criteria
sens_pass_limit=-96 # sensitivity pass limit
# Baseboard test variables
bb_port='COM88' #'/dev/ttyUSB0'
bb_baudrate=115200
bb_pingip='192.168.166.27'

160
octal/cavium_env/rf_card_cal_tip/test_flatness.py Normal file
View File

@@ -0,0 +1,160 @@
#!/usr/bin/python
#import common
import test_config
from time import sleep
from im_calibration import Calibration
class TestFlatness(Calibration):
def __init__(self, rpt_hndl, bandwidth, dl_freq):
self.rpt = rpt_hndl
self.input_power = -20 # input power in dBm
self.test_bw = bandwidth
self.dl_freq = dl_freq
self.curr_obw = 0.0
self.ripple_data = []
self.curr_freq_start = 0.0
self.curr_freq_stop = 0.0
self.sample_freq_step = 100 # kHz
self.max_ripple_less_than_3mhz = 8
self.max_ripple_greater_than_3mhz = 4
if (self.test_bw == 5):
self.intbw = '4.5'
self.spabw = '10'
self.obw_std = 'B5M'
elif (self.test_bw == 10):
self.intbw = '9'
self.spabw = '20'
self.obw_std = 'B10M'
elif (self.test_bw == 20):
self.intbw = '18'
self.spabw = '30'
self.obw_std = 'B20M'
else:
print "bandwidth is not in configuration"
exit(1)
def mxa_flatness_setup(self):
type(self).mxa.send_msg_to_server(':INIT:CONT ON')
type(self).mxa.send_msg_to_server(':INST:SEL SA')
#type(self).mxa.send_msg_to_server(':FREQ:CENT ' + str(self.dl_freq) + ' MHz')
#type(self).mxa.send_msg_to_server(':FREQ:SPAN ' + self.curr_obw + ' MHz')
type(self).mxa.send_msg_to_server(':FREQ:START ' + str(self.curr_freq_start - 1) + ' MHz')
type(self).mxa.send_msg_to_server(':FREQ:STOP ' + str(self.curr_freq_stop + 1) + ' MHz')
#type(self).mxa.send_msg_to_server(':BAND:RES 1 kHz')
type(self).mxa.send_msg_to_server(':BAND:VID 1 kHz')
type(self).mxa.send_msg_to_server(':POW:ATT 38')
type(self).mxa.send_msg_to_server(':DISP:WIND:TRAC:Y:RLEV 20 dBm')
type(self).mxa.send_msg_to_server(':AVER:COUN 10')
def mxa_obw_setup(self):
type(self).mxa.send_msg_to_server('*PSC')
type(self).mxa.send_msg_to_server(':INIT:CONT ON')
type(self).mxa.send_msg_to_server(':INST LTE')
type(self).mxa.send_msg_to_server(':POW:ATT 30') # attenuation
type(self).mxa.send_msg_to_server(':FREQ:CENT ' + str(self.dl_freq) + ' MHz')
type(self).mxa.send_msg_to_server(':RAD:STAN:PRES ' + self.obw_std) # LTE preset
type(self).mxa.send_msg_to_server(':CONF:OBW ' + str(self.test_bw) + ' MHz')
type(self).mxa.send_msg_to_server(':INIT:OBW')
def start_enodeb_tx(self):
type(self).enb.enb_login()
# default is PWM control in booting
if (type(self).cfg.tcxo_ctrl == "dax"):
print("load ext dac clock control")
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_load_dax() # do ext DAC control
if test_config.band > 32:
type(self).enb.enb_cd_usr_bin()
type(self).enb.enb_set_zen_tdd_tx()
type(self).enb.enb_cd_tmpfs()
type(self).enb.enb_run_dsp_app_dl()
def collect_ripple_data(self):
self.ripple_data = []
mark_freq = self.curr_freq_start
type(self).mxa.send_msg_to_server(':CALC:MARK1:MODE POS')
while (mark_freq <= self.curr_freq_stop):
type(self).mxa.send_msg_to_server(':CALC:MARK1:X ' + str(mark_freq) + ' MHz')
sleep(0.5)
type(self).mxa.send_msg_to_server(':CALC:MARK1:Y?') # get power
in_msg = type(self).mxa.recv_msg_frm_server()
cur_pwr = round(float(in_msg), 2)
#self.ripple_data.append([mark_freq, cur_pwr])
self.ripple_data.append(cur_pwr)
self.rpt.write('\t' + str(mark_freq) + ' MHz\t\t' + str(cur_pwr) + ' dBm\n')
mark_freq = mark_freq + float(self.sample_freq_step)/1000.0
print str(mark_freq) + ' MHz ' + str(cur_pwr) + ' dBm'
type(self).mxa.send_msg_to_server(':CALC:MARK1:MODE OFF')
def calcFlatness(self):
data = sorted(self.ripple_data)
flatness = abs(round(float(data[-1] - data[0]), 2))
self.rpt.write('max = ' + str(round(float(data[-1]), 2)) + ' dBm\n')
self.rpt.write('min = ' + str(round(float(data[0]), 2)) + ' dBm\n')
self.rpt.write('flatness = ' + str(flatness) + ' dBm\n\n')
self.rpt.flush()
print ''
print 'max = ' + str(round(float(data[-1]), 2)) + ' dBm'
print 'min = ' + str(round(float(data[0]), 2)) + ' dBm'
print 'flatness = ' + str(flatness) + ' dBm'
print ''
def do_flatness_measurement(self):
# measure OBW
obw_loop = 6
self.mxa_obw_setup()
for cnt in range(0, obw_loop): # prevent get carrier only
sleep(5) # wait for spectrum stable
type(self).mxa.send_msg_to_server(':FETC:OBW?')
in_msg = type(self).mxa.recv_msg_frm_server()
line = in_msg.split(',')
self.curr_obw = round(float(line[0])/1000000, 6)
if (self.curr_obw > 3.0):
break
elif (cnt == (obw_loop - 1)):
print 'transmit signal error, obw measure failed'
exit(1)
print('OBW = ' + str(self.curr_obw) + ' MHz')
self.rpt.write('OBW = ' + str(self.curr_obw) + ' MHz\n')
# set MXA in new span
obw_offset = round(float(self.curr_obw/2), 6)
self.curr_freq_start = self.dl_freq - obw_offset
self.curr_freq_stop = self.dl_freq + obw_offset
self.rpt.write('frequency start = ' + str(self.curr_freq_start) + ' MHz\n')
self.rpt.write('frequency stop = ' + str(self.curr_freq_stop) + ' MHz\n\n')
self.mxa_flatness_setup()
sleep(3)
# collect frequency vs power list [freq, pow]
self.collect_ripple_data()
# analysis data
self.calcFlatness()
def run(self):
self.start_enodeb_tx()
sleep(3) # wait spectrum comes out
self.do_flatness_measurement()

BIN
octal/cavium_env/rf_card_cal_tip/test_flatness.pyc Normal file
View File

Binary file not shown.

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180427_114150.txt Normal file
View File

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180427_115347.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180427_115347.txt
27/04/2018 11:53:47

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180427_115502.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180427_115502.txt
27/04/2018 11:55:02

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180427_145042.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180427_145042.txt
27/04/2018 14:50:42

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180427_150844.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180427_150844.txt
27/04/2018 15:08:44

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180427_155911.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180427_155911.txt
27/04/2018 15:59:11

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180427_161032.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180427_161032.txt
27/04/2018 16:10:32

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180427_162857.txt Normal file
View File

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180427_164025.txt Normal file
View File

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180430_120144.txt Normal file
View File

7
octal/cavium_env/rf_card_cal_tip/test_report/test_20180430_120516.txt Normal file
View File

@@ -0,0 +1,7 @@
./test_report/test_20180430_120516.txt
30/04/2018 12:05:16
*** Calibration #1 ***
DL Freq.1825.0 MHz
UL Freq.1730.0 MHz

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180430_121054.txt Normal file
View File

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_102412.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_102412.txt
01/05/2018 10:24:12

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_112411.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_112411.txt
01/05/2018 11:24:11

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_112740.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_112740.txt
01/05/2018 11:27:40

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_132532.txt Normal file
View File

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_135105.txt Normal file
View File

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_135947.txt Normal file
View File

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_140511.txt Normal file
View File

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_141102.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_141102.txt
01/05/2018 14:11:02

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_141712.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_141712.txt
01/05/2018 14:17:12

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_142344.txt Normal file
View File

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_143315.txt Normal file
View File

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_143812.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_143812.txt
01/05/2018 14:38:12

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_144317.txt Normal file
View File

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_144643.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_144643.txt
01/05/2018 14:46:43

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_145822.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_145822.txt
01/05/2018 14:58:22

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_150822.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_150822.txt
01/05/2018 15:08:22

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_152014.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_152014.txt
01/05/2018 15:20:14

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180501_153652.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180501_153652.txt
01/05/2018 15:36:52

11
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_093449.txt Normal file
View File

@@ -0,0 +1,11 @@
./test_report/test_20180502_093449.txt
02/05/2018 09:34:49
*** Calibration #1 ***
DL Freq.1840.0 MHz
UL Freq.1715.0 MHz
RSSI Calibration:
slope_1=nan, offset_1=nan
slope_2=nan, offset_2=nan

28
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_095221.txt Normal file
View File

@@ -0,0 +1,28 @@
./test_report/test_20180502_095221.txt
02/05/2018 09:52:21
*** Calibration #1 ***
DL Freq.1840.0 MHz
UL Freq.1715.0 MHz
RSSI Calibration:
slope_1=nan, offset_1=nan
slope_2=nan, offset_2=nan
Reference Clock Calibration:
Frequency = 1840000000.0
PWM_high value = 22857
PWM_low value = 37376
IQ Offset Calibration:
tx1_i_offset = 0xff
tx1_q_offset = 0xff
tx2_i_offset = 0xff
tx2_q_offset = 0xfa
TX Power Calibration:
slope_1=-1.025787, offset_1=4.017246
slope_2=-7.884413, offset_2=-372.513807
TX Max Available Power:

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_095917.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180502_095917.txt
02/05/2018 09:59:17

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_100307.txt Normal file
View File

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_101718.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180502_101718.txt
02/05/2018 10:17:18

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_102327.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180502_102327.txt
02/05/2018 10:23:27

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_104011.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180502_104011.txt
02/05/2018 10:40:11

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_111044.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180502_111044.txt
02/05/2018 11:10:44

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_112908.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180502_112908.txt
02/05/2018 11:29:08

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_113244.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180502_113244.txt
02/05/2018 11:32:44

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_113449.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180502_113449.txt
02/05/2018 11:34:49

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_113804.txt Normal file
View File

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_114507.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180502_114507.txt
02/05/2018 11:45:07

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_114726.txt Normal file
View File

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_114901.txt Normal file
View File

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_115153.txt Normal file
View File

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_115311.txt Normal file
View File

0
octal/cavium_env/rf_card_cal_tip/test_report/test_20180502_142005.txt Normal file
View File

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180503_092809.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180503_092809.txt
03/05/2018 09:28:09

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180510_150438.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180510_150438.txt
10/05/2018 15:04:38

2
octal/cavium_env/rf_card_cal_tip/test_report/test_20180514_103814.txt Normal file
View File

@@ -0,0 +1,2 @@
./test_report/test_20180514_103814.txt
14/05/2018 10:38:14

Some files were not shown because too many files have changed in this diff Show More