def export_pcap( self, source_file, dest_file , format = FILE_DEFAULT_FORMAT, frames_to_export = -1):
frames_range = ''
if not(os.path.exists(source_file)):
globals.Error("File not exists")
if type(frames_to_export) == int:
if frames_to_export == '-1':
frame_range = ""
elif frames_to_export > 0:
frames_range = '-R frame.number == %d' % frames_to_export
elif type(frams_to_export) == string:
if len(frames_to_export.split('-'))>1:
frames_range = "-R \"frame.number>=%s && frame.number<=%s\"" % ( frames_to_export.split('-')[0].strip(), frames_to_export.split('-')[1].strip() )
else:
Error("frames_to_export value is mismatch, either number or range etc: 1 or 1-5")
file_args = ' -r %s -T %s %s >%s' % ( source_file, format, frames_range, dest_file )
cmd = "\"" + self.tsharks_file + "\"" + file_args
try:
data = subprocess.check_output(cmd, shell = True)
except WindowsError as e:
raise globals.Error("FAILED : Please make sure the path are correct")
except subprocess.CalledProcessError as e:
raise globals.Error("FAILD : Process failed with return value diffrent from 0")
return globals.EXIT_OK
def __init__(self):
# Store handler for function
self.pckt_handler = None
self.num_packets = 0
# Set Max recursion limit for parse_file
# sys.setrecursionlimit(10)
# Process os
if 'win32' in sys.platform:
import win32process
if win32process.IsWow64Process () == True:
self.capinfos_file = 'c:\\Program Files (x86)\\Wireshark\\capinfos.exe'
self.tsharks_file = 'c:\\Program Files (x86)\\Wireshark\\tshark.exe'
else:
self.capinfos_file = 'c:\\Program Files\\Wireshark\\capinfos.exe'
self.tsharks_file = 'c:\\Program Files\\Wireshark\\tshark.exe'
elif 'linux' in sys.platform:
self.capinfos_file = "./capinfos"
self.tsharks_file = "./tshark"
else:
raise globals.Error("Unknown os type, where is capinfos.exe")
if not( os.path.exists(self.capinfos_file) or os.path.exists(self.tsharks_file) ):
raise globals.Error("Tshark or capinfos file not found, please make sure you have a full WireShark full installtion")
def initialization(self):
self.status_tx_power = False
self.status_tx_evm = False
self.status_tx_iq_ampl_imbalance = False
self.status_tx_iq_phase_imbalance = False
self.status_dc_lo_leakage = False
self.status_freq_error = False
self.status_sym_clock_error = False
# Verify uut idx exits
try:
self.uut = globals.setup.units.unit(self._uut_id[0])
self.uut.create_fw_cli() # create cli connection for (23,1123,terminal)
self.fw_cli = self.uut.fw_cli('23') # get cli from telnet port 23
self.uboot = self.uut.fw_cli('terminal').u_boot
self.consts = setup_consts.CONSTS[globals.setup.station_parameters.station_name]
except KeyError as e:
raise globals.Error("uut index and interface input is missing or currpted, usage : uut_id=(0,1)")
# Get RF switch handle from setup
log.info("RF switch configuration")
if globals.setup.instruments.rf_switch_box is None:
raise globals.Error("RF switch is not initilized, please check your configuration")
# Get pointer to object
self.rf_switch_box = globals.setup.instruments.rf_switch_box
# VSA select switch
self.rf_switch_box.set_switch('A',self.param['rf_if']+1) # setup RF Switch A to com 1/2 (com1 selection for chA,com2 selection for chB)
self.rf_switch_box.set_switch('B',1) # Switch B to com 1
# Set frequency
self.uut.managment.set_rf_frequency( self.param['ch_freq'], self.rf_if )
# Set rate
self.uut.managment.set_rf_rate( self.param['snmp_rate'], self.rf_if )
# Compensator connected/disconnected
self.uut.managment.set_rf_frontend_enable( self.param['rf_front_end_compensator'], self.rf_if )
# Set tx power
self.uut.managment.set_tx_power( self.param['tx_power'], self.rf_if ) #Set tx power to 20dBm
# Set RF OFDM channel bandwidth
self.uut.managment.set_rf_ofdm_chan_bandwidth( self.param["bandwidth"], self.rf_if )
# Get Signal tester VSG/MXG handle from setup
log.info("Signal tester VSA/VSG/MXG configuration")
if globals.setup.instruments.rf_vector_signal is None:
raise globals.Error("Signal tester is not initilized, please check your configuration")
self.vsa = globals.setup.instruments.rf_vector_signal['vsa']
# VSA settings
port = 2 # left port VSA mode
atten = self.consts.common[ 'TX_PATH_SETUP_ATTENUATION_DB' + "_" + str( self.rf_if ) + "_" + self.param['board_type'] ]
self.vsa.vsa_settings(self.param['ch_freq'], self.consts.common['VSA_MAX_SIGNAL_LEVEL_DBM'], port, atten, self.consts.common['VSA_TRIGGER_LEVEL_DB'], self.consts.common['VSA_CAPTURE_WINDOW'] )
time.sleep(0.5)
def unit_configuration(self):
super(TC_CAN_LOAD_2DEVICES, self).unit_configuration()
self.uut_can_if.append(self.uut.can_interfaces[self.uut_id[2]])
if not self.uut_can_if[1].active:
raise globals.Error("CAN device {} is not active.".format(
self.uut_can_if[1].device_id))
self.can_cli2 = self.uut.create_qa_cli("can_cli2",
target_cpu=self.target_cpu)
ret = self.can_cli2.can.socket_create(self.uut_can_if[1].device_id, {})
if "ERROR :" in ret:
raise globals.Error(
"Can socket create received error {}".format(ret))
self.can_cli2.can.reset_counters()
self.can_cli_rx2 = self.uut.create_qa_cli("can_cli_rx2",
target_cpu=self.target_cpu)
ret = self.can_cli_rx2.can.socket_create(self.uut_can_if[1].device_id,
{})
if "ERROR :" in ret:
raise globals.Error(
"Can socket create received error {}".format(ret))
self.can_cli_rx2.can.reset_counters()
def test_initilization(self):
# Get sniffer handle from setup
log.info("Getting Sniffer info")
if globals.setup.instruments.sniffer is None:
raise globals.Error("Sniffer is not initilize or define in setup, please check your configuration")
else:
# Get pointer to object
sniffer = globals.setup.instruments.sniffer
# initlize sniffer
sniffer.initialize()
log.info("Getting GPS simulator in config")
if globals.setup.instruments.gps_simulator is None:
raise globals.Error("gps simulator is not initilize, please check your configuration")
else:
# Get pointer to object
gps_sim = globals.setup.instruments.gps_simulator
# set general tx power
gps_sim.tx_power( self._gps_tx_power )
#load scenario
gps_sim.load( self._gps_scenario )
dir_name = tempfile.gettempdir()
timestr = time.strftime("%Y%m%d-%H%M%S")
self.test_file_name = 'tc_bsm_hardbake_rec'
self.gps_file = os.path.join( tempfile.gettempdir(), self.test_file_name + "_" + time.strftime("%Y%m%d-%H%M%S") + "." + 'txt')
self.sniffer_file = os.path.join( common.SNIFFER_DRIVE , self.test_file_name + "_" + time.strftime("%Y%m%d-%H%M%S") + "." + 'pcap')
def unit_configuration(self):
self.uut_index = self.uut_id[0]
# Verify uut idx exits
try:
self.uut = globals.setup.units.unit(self.uut_index)
except KeyError as e:
raise globals.Error(
"uut index and interface input is missing or corrupted, usage : uut_id=(0,1)"
)
self.uut_can_if.append(self.uut.can_interfaces[self.uut_id[1]])
if not self.uut_can_if[0].active:
raise globals.Error("CAN device {} is not active.".format(
self.uut_can_if[0].device_id))
# Open new v2x-cli
self.can_cli = self.uut.create_qa_cli("can_cli",
target_cpu=self.target_cpu)
self.can_cli.can.service_create()
ret = self.can_cli.can.socket_create(self.uut_can_if[0].device_id, {})
if "ERROR :" in ret:
raise globals.Error(
"Can socket create received error {}".format(ret))
self.can_cli.can.reset_counters()
def test_nav_api(self):
""" Test nav api correctness
@fn test_nav_api_1
@brief Verify nav api data and accurecy correctness
@details Test ID : TC_SDK2.1_NAV_01\n
Test Name : NAV API\n
Objective : Validate correct positioning data reported by NAV API\n
Reference : REQ_SDK2.1_NAVAPI_01\n
@see Test Plan : \\fs01\docs\system\Integration\Test_Plans\SW_Releases\SDK2.1\SDK2_1_Test_Plan_v2.docx\n
"""
# unit configuration
print >> self.result._original_stdout, "Starting : {}".format(
self._testMethodName)
#Test scenario shall include the following driving segments (derived from SafetyPilot test scenario), played by GNSS simulator:
#Each test case should be executed at least 5 minutes.
#Segment Detail
#Straight line Straight line, driving speed 50kph ? 100kph.
#Elliptic track course 50, 100,150 kph driving speed
#Figure ? 8 50, 100,150 kph driving speed
#Additional scenario details:
#HDOP < 5
#Get position data that described in table below via NAV API.
self.get_test_parameters()
# Verify uut input exists and active
self._uut_id = self.param.get('uut_id', None)
if self._uut_id is None:
raise globals.Error(
"uut index and interface input is missing or currpted, usage : uut_id=(0,1)"
)
# Verify uut idx exits
try:
self.uut = globals.setup.units.unit(self._uut_id[0])
except KeyError as e:
raise globals.Error(
"uut index and interface input is missing or currpted, usage : uut_id=(0,1)"
)
self.uut_channel = self._uut_id[1]
# self.debug_override()
self.instruments_initilization()
rv = self.unit_configuration()
# Check if unit is locked
if rv == True:
self.main()
self.analyze_results()
self.print_results()
print >> self.result._original_stdout, "test, {} completed".format(
self._testMethodName)
def initialization(self):
# Verify uut idx exits
try:
self.uut = globals.setup.units.unit(self._uut_id[0])
self.uut.create_fw_cli(
) # create cli connection for (23,1123,terminal)
self.fw_cli = self.uut.fw_cli('23') # get cli from telnet port 23
self.uboot = self.uut.fw_cli('terminal').u_boot
self.consts = setup_consts.CONSTS[
globals.setup.station_parameters.station_name]
except KeyError as e:
raise globals.Error(
"uut index and interface input is missing or currpted, usage : uut_id=(0,1)"
)
# Get Signal tester VSG/MXG handle from setup
log.info("Signal tester VSA/VSG/MXG configuration")
if globals.setup.instruments.rf_vector_signal is None:
raise globals.Error(
"Signal tester is not initilized, please check your configuration"
)
self.vsg = globals.setup.instruments.rf_vector_signal['vsg']
# Get RF switch handle from setup
log.info("RF switch configuration")
if globals.setup.instruments.rf_switch_box is None:
raise globals.Error(
"RF switch is not initilized, please check your configuration")
# Get pointer to object
self.rf_switch_box = globals.setup.instruments.rf_switch_box
# MXG/VSG select switch
self.rf_switch_box.set_switch(
'A', self.param['rf_if'] + 1
) # setup RF Switch A to com 1/2 (com1 selection for chA,com2 selection for chB)
self.rf_switch_box.set_switch('B', 2) # Switch B to com 2
if globals.setup.instruments.power_control is None:
raise globals.Error(
"Power control is not initilized, please check your configuration"
)
self.power_control = globals.setup.instruments.power_control
# Set frequency
self.uut.managment.set_rf_frequency(self.param['ch_freq'], self.rf_if)
# Compensator connected/disconnected
self.uut.managment.set_rf_frontend_enable(
self.param['rf_front_end_compensator'], self.rf_if)
print >> self.result._original_stdout, "\nWaiting for loading file to vsg.. "
self.vsg.load_file(self.param['test_data_dir'],
self.param['data_waveform'],
self.param['bandwidth'])
self.vsg.rf_enable(True)
def test_initilization(self):
# Get sniffer handle from setup
log.info("Getting Sniffer info")
if globals.setup.instruments.sniffer is None:
raise globals.Error(
"Sniffer is not initilize or define in setup, please check your configuration"
)
else:
# Get pointer to object
sniffer = globals.setup.instruments.sniffer
# initlize sniffer
sniffer.initialize()
log.info("Getting GPS simulator in config")
if globals.setup.instruments.gps_simulator is None:
#raise globals.Error("gps simulator is not initilize, please check your configuration")
gps_sim = None
else:
# Get pointer to object
gps_sim = globals.setup.instruments.gps_simulator
if globals.setup.instruments.can_bus is None:
raise globals.Error(
"Can bus server is not initilize, please check your configuration"
)
else:
# Get pointer to object
self._can_bus_sim = globals.setup.instruments.can_bus
#self._komodo = Komodo.Komodo()
self._can_bus_sim.configure_port(self._can_inferface)
self._can_bus_sim.power_up(self._can_inferface)
#self._can_bus_sim.power_down(self._can_inferface)
#self._komodo.power_down(self._komodo_interface)
self.gm_can_msgs = gm_can_definitions.GmCanMessages(
self._can_bus_sim, self._can_inferface)
# set general tx power
if not gps_sim is None:
gps_sim.tx_power(self._gps_tx_power)
#load scenario
if not gps_sim is None:
gps_sim.load(self._gps_scenario)
dir_name = tempfile.gettempdir()
timestr = time.strftime("%Y%m%d-%H%M%S")
self.test_file_name = 'tc_can_2_bsm_rec'
self.gps_file = os.path.join(
tempfile.gettempdir(), self.test_file_name + "_" +
time.strftime("%Y%m%d-%H%M%S") + "." + 'txt')
self.sniffer_file = os.path.join(
common.SNIFFER_DRIVE, self.test_file_name + "_" +
time.strftime("%Y%m%d-%H%M%S") + "." + 'pcap')
def verify_ack(self, timout_sec=2):
data = self.clean_ansi_escape(
self._if.read_until(self._prompt, timout_sec))
if 'OK' in data:
return True
elif 'ERR' in data:
raise globals.Error("Error in Command")
else:
raise globals.Error("No ack")
def get_value(json_data, key_name):
""" Get value from json ctype configuration file """
try:
return json_data[key_name]
except KeyError:
raise globals.Error(
'File corrupt, file should contain `%s\' attribute' % (key_name))
else:
raise globals.Error(
"Unknow error getting value from configuration file. key : `%s\'" %
(key_name))
def _check_connection(self):
self._if.write("\n", False)
str = self.clean_ansi_escape(self._if.read_until(self._prompt, 2))
if self._prompt in str:
return True
if 'Connection is already in use by' in str:
raise globals.Error(
"Unable to connect to LABSAT, connection is busy")
raise globals.Error("Unable to connect to LABSAT, unknown reason")
def _read_until(self, data, timeout):
""" Read data until prompt """
try:
data = self._host.read_until(data, timeout)
except EOFError as e:
raise globals.Error(
'ERROR : EOF rasied, no data to read from server')
except Exception as e:
raise globals.Error(
'ERROR : Error reading from unit, {}'.format(e))
return data
def test_vca_1(self):
# Parse test parameters
# params = [ tParam( tx = (0,1), rx = (1,1), proto_id = 0, frames = 1000, frame_rate_hz = 50, tx_data_len = 100, tx_data_val = 'ab', tx_power = -5 ) ]
self._test_params = self.param.get('params', None)
if self._test_params is None:
raise globals.Error(
"uut index and interface input is missing or currpted, usage : params = tParam( tx = (0,1), rx = (1,1), proto_id = 0, frames = 1000, frame_rate_hz = 50, tx_data_len = 100, tx_data_val = 'ab', tx_power = -5 )"
)
# Get & parse test parameters
self.get_test_parameters()
# Verify uut input exists and active
self.rf_if_tx_params_list = []
self.rf_if_rx_params_list = []
for t_params in self._test_params:
self.rf_if_rx_params_list.append(
self.Rf_if_basic_params(t_params.rx[0], t_params.rx[1]))
if t_params.tx_power == None or t_params.frame_rate_hz == None:
raise globals.Error(
"Missing tx_power or frame_rate_hz from input params")
self.rf_if_tx_params_list.append(
self.Rf_if_tx_params(t_params.tx[0], t_params.tx[1],
t_params.tx_power,
t_params.frame_rate_hz))
self.uuts = []
for rf_if in self.rf_if_tx_params_list + self.rf_if_rx_params_list:
self.uuts.append(globals.setup.units.unit(rf_if.uut_idx))
self.uuts = set(self.uuts)
#self._clean_logs()
self.log = logging.getLogger(__name__)
self.stats = self.Statistics()
self.initilization()
# Set Rf Frequenct & tx_power
for rf_if_params in self.rf_if_tx_params_list:
rf_if_params.uut.managment.set_rf_frequency(
rf_if_params.freq, rf_if_params.rf_if)
rf_if_params.uut.managment.set_tx_power(rf_if_params.tx_power,
rf_if_params.rf_if)
for rf_if_params in self.rf_if_rx_params_list:
rf_if_params.uut.managment.set_rf_frequency(
rf_if_params.freq, rf_if_params.rf_if)
(tx_vca_cnt, rx_vca_cnt, tx_hw_cnt, rx_hw_cnt) = self.main_test()
self.print_report(tx_vca_cnt, rx_vca_cnt, tx_hw_cnt, rx_hw_cnt)
def setUp(self):
# Verify uut input exists and active
self._uut_id = self.param.get('uut_id', None )
if self._uut_id is None:
raise globals.Error("uut index and interface input is missing or currpted, usage : uut_id=(0,1)")
# Verify uut idx exits
try:
self.uut = globals.setup.units.unit(self._uut_id[0])
self.uut.create_fw_cli() # create cli connection for (23,1123,terminal)
self.fw_cli = self.uut.fw_cli('23') # get cli from telnet port 23
self.consts = setup_consts.CONSTS[globals.setup.station_parameters.station_name]
except KeyError as e:
raise globals.Error("uut index and interface input is missing or currpted, usage : uut_id=(0,1)")
def get_num_packets(self, pcap_file):
"""
TBD : consider use of pypcapfile lbrary for this actions
"""
try:
data = subprocess.check_output([self.capinfos_file,self.pcap_file])
except WindowsError as e:
raise globals.Error("FAILED : Please make sure the path are correct")
except subprocess.CalledProcessError as e:
raise globals.Error("FAILD : Process failed with return value diffrent from 0")
data = data.split('\r\n')
# Get numner of packet in file
self.num_packets = int(data[4].split(':')[1].strip())
return self.num_packets
def instruments_initilization(self):
# Initilize GPS
self.gps_init(self._gps_scenario, self._gps_tx_power)
# Get sniffer handle from setup
self.sniffer = globals.setup.instruments.sniffer
if self.sniffer is None:
raise globals.Error(
"Sniffer is not initilize or define in setup, please check your configuration"
)
# initlize sniffer
self.sniffer.initialize()
self.sniffer.set_interface([0, 1])
# tshark app used for capturing frames must verify license of sirit and it take time ~ 15 seconds
time.sleep(20)
if self.sniffer.type == 'sirit':
self.sniffer.configure_dsrc_tool()
self.can_bus = globals.setup.instruments.can_bus
if self.can_bus == None:
raise Exception(
"CAN BUS simulator is missing in current configuration")
# create capture files for gps and sniffer
self.gps_file = os.path.join(
tempfile.gettempdir(), self._testMethodName + "_" +
time.strftime("%Y%m%d-%H%M%S") + "." + 'txt')
self.sniffer_file = os.path.join(
common.SNIFFER_DRIVE, self._testMethodName + "_" +
time.strftime("%Y%m%d-%H%M%S") + "." + 'pcap')
def disconnect(self):
if self._host is None:
raise globals.Error('ERROR : system is not connected to any host')
try:
self.send_command("exit", False)
except Exception:
pass
def instruments_initilization(self):
# Initilize GPS
self.gps_init(self._gps_scenario, self._gps_tx_power)
# Get sniffer handle from setup
self.log.info("Getting Sniffer info")
if globals.setup.instruments.sniffer is None:
raise globals.Error(
"Sniffer is not initilize or define in setup, please check your configuration"
)
else:
# Get pointer to object
self.sniffer = globals.setup.instruments.sniffer
# initlize sniffer
self.sniffer.initialize()
self.sniffer.set_interface([0, 1])
# tshark app used for capturing frames must verify license of sirit and it take time ~ 15 seconds
time.sleep(20)
# create capture files for gps and sniffer
self.gps_file = os.path.join(
tempfile.gettempdir(), self._testMethodName + "_" +
time.strftime("%Y%m%d-%H%M%S") + "." + 'txt')
self.sniffer_file = os.path.join(
common.SNIFFER_DRIVE, self._testMethodName + "_" +
time.strftime("%Y%m%d-%H%M%S") + "." + 'pcap')
def setUp(self):
# Verify uut input exists and active
self._uut_id = self.param.get('uut_id', None)
if self._uut_id is None:
raise globals.Error(
"uut index and interface input is missing or currpted, usage : uut_id=(0,1)"
)
def initilization(self):
# Get sniffer handle from setup
log.info("Getting Sniffer info")
if globals.setup.instruments.sniffer is None:
raise globals.Error(
"Sniffer is not initilize or define in setup, please check your configuration"
)
else:
# Get pointer to object
self.sniffer = globals.setup.instruments.sniffer
# initlize sniffer
self.sniffer.initialize()
self.sniffer.set_interface([0, 1])
# Initilize GPS
self.gps_sim = self.gps_init(self._gps_scenario, self._gps_tx_power)
self.gps_file = os.path.join(
tempfile.gettempdir(), self._testMethodName + "_" +
time.strftime("%Y%m%d-%H%M%S") + "." + 'txt')
self.sniffer_file = os.path.join(
common.SNIFFER_DRIVE, self._testMethodName + "_" +
time.strftime("%Y%m%d-%H%M%S") + "." + 'pcap')
def get_test_parameters(self):
# Set Some test defaults
self._gps_scenario = self.param.get('gps_scenario', "")
self._gps_tx_power = self.param.get('gps_tx_power', -68.0)
self._gps_lock_timeout_sec = self.param.get('gps_lock_timeout_sec',
600)
self._capture_frames = self.param.get('capture_frames', 0)
self._sniffer_test = self.param.get('sniffer_test', 0)
self._testParams = self.param.get('params', None)
if self._testParams is None:
raise globals.Error(
"uut index and interface input is missing or currpted, usage : params = tParam( tx = (0,1), rx = (1,1), proto_id = 0, frames = 1000, frame_rate_hz = 50, tx_data_len = 100, tx_data_val = 'ab', tx_power = -5 )"
)
g = list()
i = 0
for t_param in self._testParams:
print "Tparam {} : {}".format(i, t_param.__dict__)
if 'tx' in vars(t_param):
g.append(t_param.tx[0])
if 'rx' in vars(t_param):
g.append(t_param.rx[0])
i += 1
self._uut_list = set(g)
self._uut = {}
def start_dut_sniffer(self, cli_interface, idx, type):
self.dut_host_sniffer = traffic_generator.TGHostSniffer(idx)
if self.dut_embd_sniffer is None :
self.dut_embd_sniffer = traffic_generator.Panagea4SnifferLinkEmbedded(cli_interface)
#add to sniffer list
sniffer_port = BASE_HOST_PORT + ( (idx - 1) * 10 )
#save for sniffer close...
self.sniffers_ports.append(sniffer_port)
self.sniffer_file.append(os.path.join( common.SNIFFER_DRIVE , self._testMethodName + "_" + "dut" + str(idx) + "_" + type + "_" + time.strftime("%Y%m%d-%H%M%S") + "." + 'pcap'))
try:
time.sleep(2)
#use the last appended sniffer file...
self.dut_host_sniffer.start( if_idx = idx , port = sniffer_port, capture_file = self.sniffer_file[len(self.sniffer_file) - 1] )
time.sleep(1)
if bool(self.v2x_cli_sniffer_if0):
self.dut_embd_sniffer.start( if_idx = idx -1 , server_ip = self.sniffer_agent_ip_addr , server_port = sniffer_port, sniffer_type = type)
time.sleep(1)
if bool(self.v2x_cli_sniffer_if1):
self.dut_embd_sniffer.start( if_idx = idx , server_ip = self.sniffer_agent_ip_addr , server_port = sniffer_port, sniffer_type = type)
except Exception as e:
raise globals.Error("sniffer start error")
pass
def test_start(self):
self.log = logging.getLogger(__name__)
# unit configuration
print >> self.result._original_stdout, "Starting : {}".format( self._testMethodName )
# Get position data that described in table below via NAV API.
self.get_test_parameters()
# Verify uut input exists and active
self._uut_id = self.param.get('uut_id', None )
if self._uut_id is None:
raise globals.Error("uut index and interface input is missing or currpted, usage : uut_id=(0,1)")
# Verify uut idx exits
try:
self.uut = globals.setup.units.unit(self._uut_id[0])
except KeyError as e:
raise globals.Error("uut index and interface input is missing or currpted, usage : uut_id=(0,1)")
self.uut_channel = self._uut_id[1]
self._tg_id = self.param.get('tg_id', None)
if self._tg_id is None:
raise globals.Error("uut index and interface input is missing or currpted, usage : tg_id=(0,1)")
# Verify uut idx exits
try:
self.tg = globals.setup.units.unit(self._tg_id[0])
except KeyError as e:
raise globals.Error("uut index and interface input is missing or currpted, usage : tg_id=(0,1)")
self.instruments_initilization()
self.unit_configuration()
self.main()
#self.debug_override()
if len(self._cpu_load_info):
for uut_id in self._cpu_load_info:
self.uut.set_cpu_load( 0 )
self.analyze_results()
self.print_results()
print >> self.result._original_stdout, "test, {} completed".format( self._testMethodName )
def frequency_set(self, rf_if=None, freq=None):
cmd = "%s freq set" % self._name
cmd += (" -rf_if %s" % rf_if) if not rf_if is None else ""
cmd += (" -freq %s" % freq) if not freq is None else ""
self._if.send_command(cmd)
data = self._if.read_until_prompt(timeout=3)
if 'ERROR' in data:
raise globals.Error("ERROR in frequency set")
def set_output(self, type, destination):
""" Sets output direction """
self.type = type
if type == 'file':
self.output = open(destination, 'w')
elif type == "handler":
self.output = destination
elif type == 'stdout':
self.output = sys.stdout
else:
raise globals.Error("Type is not known")
def cpu_load(self, uut_idx, cpu_load_level=50, timeout=-1):
try:
cpu_uut = globals.setup.units.unit(uut_idx)
except KeyError as e:
raise globals.Error(
"uut index and interface input is missing or currpted, usage : _uut_id_tx=(0,1)"
)
cli_name = 'cpu_load'
cpu_uut.create_qa_cli(cli_name)
# Open general session
cpu_uut.qa_cli(cli_name).cpu_load(cpu_load_level, timeout)
def unit_configuration(self):
super(TC_CAN_LOAD, self).unit_configuration()
self.can_cli_rx = self.uut.create_qa_cli("can_cli_rx",
target_cpu=self.target_cpu)
ret = self.can_cli_rx.can.socket_create(self.uut_can_if[0].device_id,
{})
if "ERROR :" in ret:
raise globals.Error(
"Can socket create received error {}".format(ret))
self.can_cli_rx.can.reset_counters()
def initilization(self):
# Initilize GPS
self.gps_sim = None
if self._gps_scenario == None:
globals.Error(
"Gps scenario not exists, please make sure to pass parameters")
self.log.info("Getting GPS simulator in config")
if globals.setup.instruments.gps_simulator is None:
raise globals.Error(
"GPS simulator is not initilize, please check your configuration"
)
#pass
else:
# Get pointer to object
self.gps_sim = globals.setup.instruments.gps_simulator
# set general tx power
self.gps_sim.tx_power(self._gps_tx_power)
#load scenario
self.gps_sim.load(self._gps_scenario)
def parse_file( self, pdml_file_name, pckt_handler ):
# pdml_filename = self.pcap_file.split('.')[0] + '.' + FILE_DEFAULT_FORMAT
if not(os.path.exists(pdml_file_name)):
raise globals.Error("File not exists")
file_hwd = open(pdml_file_name, "r")
i = 0;
#while file_hwd.readline() != '<?xml version="1.0"?>\n':
while ('xml version' not in file_hwd.readline()) and (i < 20):
i += 1
if ( i >= 20 ):
raise globals.Error("Start of PDML file not found")
if ( i == 0 ): file_hwd.seek(0)
self.pckt_handler = pckt_handler
wiresharkXML.parse_fh(file_hwd, self._packet_analyzer)
