def test_script(self):
try:
res = self.obc.list_files_with_sizes('/')
self.result = TestCompare.assert_equal(True, True)
self.data = ResultData(pprint.pformat(res), None, None)
self.log.debug("OBC response: {}".format(res))
except:
self.result = TestCompare.assert_equal(False, True)
self.data = ResultData(None, None, None)
self.log.debug("Exception!")
def test_script(self):
self.result = {}
self.data = {}
ret = self.obc.enable_lcl(7)
self.log.debug("OBC response LCL enable: {}".format(ret))
time.sleep(5)
test_result = self.obc.perform_self_test(0)
self.log.debug("OBC response: {}".format(test_result))
ret = self.obc.disable_lcl(7)
self.log.debug("OBC response LCL disable: {}".format(ret))
self.result['INIT'] = TestCompare.assert_equal(test_result[0][0], 0)
self.result['+X'] = TestCompare.assert_equal(test_result[1][0], 0)
self.result['-X'] = TestCompare.assert_equal(test_result[2][0], 0)
self.result['+Y'] = TestCompare.assert_equal(test_result[3][0], 0)
self.result['-Y'] = TestCompare.assert_equal(test_result[4][0], 0)
self.result['+Z'] = TestCompare.assert_equal(test_result[5][0], 0)
self.result['-Z'] = TestCompare.assert_equal(test_result[6][0], 0)
self.result['FINA'] = TestCompare.assert_equal(test_result[7][0], 0)
self.data['INIT'] = ResultData(test_result[0], None, None)
self.data['+X'] = ResultData(test_result[1], None, None)
self.data['-X'] = ResultData(test_result[2], None, None)
self.data['+Y'] = ResultData(test_result[3], None, None)
self.data['-Y'] = ResultData(test_result[4], None, None)
self.data['+Z'] = ResultData(test_result[5], None, None)
self.data['-Z'] = ResultData(test_result[6], None, None)
self.data['FINA'] = ResultData(test_result[7], None, None)
def test_script(self):
self.data = []
axis = raw_input("Type name of the axis: ")
print("Press Ctrl-C to finish")
res = self.obc.enable_lcl(5)
time.sleep(3)
self.log.debug("OBC response: PLD LCL on {}".format(res))
try:
format_string = "{0:<5} [V] | {1:<5} [A] | {2:<5} [A] || {3:<5} [V] | {4:<5} [A] | {5:<5} [A] || {6:<5} [V] | {7:<5} [A] | {8:<5} [A] || {9:<5} [V] | {10:<5} [A] | {11:<5} [A]".format(
"PV Xp", "PV Xp", "Ph Xp", "PV Xn", "PV Xn", "Ph Xn", "PV Yp",
"PV Yp", "Ph Yp", "PV Yn", "PV Yn", "Ph Yn")
self.log.debug(format_string)
self.data.append(("", ResultData(format_string, "", None)))
while True:
self.obc.jump_to_time(0)
payload_response_data = self.obc.payload_photodiodes()
eps_response_data = ControllerA.to_dict(
self.obc.read_housekeeping_a())
converted_eps_data = ConvertDict.convert(
eps_response_data, eps_a_telemetry_conversion)
format_string = "{0:<9} | {1:<9} | {2:<9} || {3:<9} | {4:<9} | {5:<9} || {6:<9} | {7:<9} | {8:<9} || {9:<9} | {10:<9} | {11:<9}".format(
converted_eps_data['MPPT_X.SOL_VOLT'].converted,
converted_eps_data['MPPT_X.SOL_CURR'].converted,
payload_response_data['Xn'],
converted_eps_data['MPPT_X.SOL_VOLT'].converted,
converted_eps_data['MPPT_X.SOL_CURR'].converted,
payload_response_data['Xp'],
converted_eps_data['MPPT_Y_PLUS.SOL_VOLT'].converted,
converted_eps_data['MPPT_Y_PLUS.SOL_CURR'].converted,
payload_response_data['Yn'],
converted_eps_data['MPPT_Y_MINUS.SOL_VOLT'].converted,
converted_eps_data['MPPT_Y_MINUS.SOL_CURR'].converted,
payload_response_data['Yp'])
self.log.debug(format_string)
self.data.append(
(time.time(), ResultData(format_string, "", None)))
time.sleep(0.5)
except:
res = self.obc.disable_lcl(5)
self.log.debug("OBC response: PLD LCL off {}".format(res))
self.log.debug("Finished")
while True:
result = raw_input("Result of the test - type pass or fail: ")
if result == 'pass' or result == 'fail':
self.result = [(axis,
TestCompare.assert_equal(result, 'pass'))]
break
def test_script(self):
result = self.obc.rtc_info()
self.log.debug("RTC response: {}".format(result))
parsed_rtc_info = self._parse_rtc_info(result)
self.log.debug("Parsed response: {}".format(parsed_rtc_info))
self.result = TestCompare.assert_less(int(parsed_rtc_info[1]),
self.kwargs['max_time'])
self.data = ResultData(result.strip(), parsed_rtc_info[1], None)
def test_script(self):
result = self.obc.compile_info()
self.log.debug("OBC response: {}".format(result))
self.result = TestCompare.assert_equal(
result,
'Release Build from \'07208653\' branch: master\nMCU: FlightModel\nPayload: FlightModel\nMachine: FP-PC3266\nBuilt in C:/Jenkins/jobs/OBC/branches/master/workspace/build\nGCC:5.4.1 20160919 (release) [ARM/embedded-5-branch revision 240496] '
)
self.data = ResultData(result, None, None)
def test_script(self):
result_converted = self.obc.mcu_temp()
result_raw = self.obc.mcu_temp_raw()
self.log.debug("OBC response: raw {}; converted {}".format(
result_raw, result_converted))
self.result = TestCompare.assert_between_closed_interval(
14, result_converted['Temp'], 30)
self.data = ResultData(result_raw['Temperature RAW'],
result_converted['Temp'], "C")
def test_script(self):
self.result = {}
self.data = {}
ret = self.obc.enable_lcl(2)
self.log.debug("OBC response LCL enable: {}".format(ret))
time.sleep(5)
test_result = self.obc.measure_suns(0, 100)
self.log.debug("OBC response: {}".format(test_result))
ret = self.obc.disable_lcl(2)
self.log.debug("OBC response LCL disable: {}".format(ret))
self.result['ALS ACK'] = TestCompare.assert_equal(test_result[0], 0)
self.result['ALS presence'] = TestCompare.assert_equal(test_result[1], 4095)
self.result['ALS adc_valid'] = TestCompare.assert_equal(test_result[2], 4095)
self.data['ALS ACK'] = ResultData(test_result[0], None, None)
self.data['ALS presence'] = ResultData(test_result[1], None, None)
self.data['ALS adc_valid'] = ResultData(test_result[2], None, None)
def test_script(self):
self.result = {}
self.data = {}
res_lcl = self.obc.enable_lcl(6)
self.log.debug("OBC response: LCL enable {}".format(res_lcl))
time.sleep(5)
res = self.obc.antenna_get_telemetry()
res_lcl = self.obc.disable_lcl(6)
self.log.debug("OBC response: LCL disable {}".format(res_lcl))
self.result['ActivationCount'] = TestCompare.assert_equal(
res.ActivationCount, [0, 0, 0, 0, 0, 0, 0, 0])
self.result['ActivationTime'] = TestCompare.assert_equal(
res.ActivationTime, [0, 0, 0, 0, 0, 0, 0, 0])
self.data['ActivationCount'] = ResultData(res.ActivationCount, None,
None)
self.data['ActivationTime'] = ResultData(res.ActivationTime, None,
None)
self.log.debug(
"OBC response: ActivationCount {}; ActivationTime {}".format(
res.ActivationCount, res.ActivationTime))
def test_script(self):
self.data = {}
self.result = {}
timer1 = Timer(datetime.timedelta(seconds=5))
timer2 = Timer(datetime.timedelta(seconds=5))
timer1.start()
t_start_1 = self.obc.rtc_duration()
self.log.debug("RTC response t_start_1: {}".format(t_start_1))
self.log.debug("Waiting 1 minute")
time.sleep(60)
t_stop_1 = self.obc.rtc_duration()
timer1.stop()
self.log.debug("RTC response t_stop_1: {}".format(t_stop_1))
timedelta_1 = t_stop_1 - t_start_1
self.log.debug("RTC timedelta: {}".format(timedelta_1))
timer2.start()
t_start_2 = self.obc.current_time()
self.log.debug("OBC time response t_start_2: {}".format(t_start_2))
self.log.debug("Waiting 1 minute")
time.sleep(60)
t_stop_2 = self.obc.current_time()
timer2.stop()
self.log.debug("OBC time response t_stop_2: {}".format(t_stop_2))
timedelta_2 = (t_stop_2 - t_start_2).total_seconds()
self.log.debug("OBC timedelta: {}".format(timedelta_2))
self.result[
'RTC duration'] = TestCompare.assert_between_closed_interval(
55, timedelta_1, 65)
self.result[
'OBC duration'] = TestCompare.assert_between_closed_interval(
55, timedelta_2, 65)
self.data['RTC duration'] = ResultData(timedelta_1, timedelta_1, 's')
self.data['OBC duration'] = ResultData(timedelta_2, timedelta_1, 's')
def test_script(self):
self.result = {}
self.data = {}
test_result = self.obc.gyro_init()
self.log.debug("OBC response: {}".format(test_result))
self.result['Init'] = TestCompare.assert_equal(test_result, '')
response = self.obc.gyro_read()
dict_response = Gyro.to_dict(response)
self.data = ConvertDict.convert(dict_response, gyro_conversion)
self.result.update(
TestCompare.assert_within_closed_interval_dict_converted(
self.data, self.kwargs['ranges']))
self.data.update({'Init': ResultData(test_result, test_result, None)})
def test_script(self):
self.result = {}
self.data = {}
timer = Timer(datetime.timedelta(seconds=5))
step_no = 1
# step 1 -- schedule photo
self.log.debug("Schedule photo")
timer.start()
try:
command_result = self.obc.photo()
except:
self.log.error("exception in photo")
timer.stop()
timer.stop()
self.log.debug("OBC response - photo: {}".format(command_result))
self.result['Schedule and take'] = TestCompare.assert_equal(
command_result, 'Scheduling....Scheduled...Finished')
self.data['Schedule and take'] = ResultData(command_result,
command_result, None)
# step 2 -- get list
self.log.debug("Get file list")
command_result = self.obc.list_files_with_sizes('/')
self.log.debug("OBC response - file list: {}".format(command_result))
names = [
'p_wing128', 'p_nadir128', 'p_wing240', 'p_nadir240', 'p_wing480',
'p_nadir480'
]
# step 3 -- look for files that should be present
for name in names:
self.result['File exist: {}'.format(
name)] = TestCompare.assert_equal(
self._find_in_file_list(command_result, name), True)
# step 4 -- check files size
for name in names:
self.result['File size: {}'.format(
name)] = TestCompare.assert_greater(
self._get_file_size(command_result, name), 7)
# step 5 -- download files
for name in names:
self.log.debug("Downloading {}".format(name))
self._download_photo(self.kwargs['path'], name)
def test_script(self):
self.result = {}
self.data = {}
ret = self.obc.enable_lcl(2)
self.log.debug("OBC response LCL enable: {}".format(ret))
time.sleep(5)
dark = self.obc.measure_suns(0, 100)
#dark = [0, 4095, 4095, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 475, 534, 534, 534, 532, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.log.debug("OBC response: {}".format(dark))
self.log.debug("Waiting for user keystroke")
while True:
self.obc.jump_to_time(0)
time.sleep(2)
if raw_input("Direct a beam of light towards the sensor and press l...") == 'l':
break
light = self.obc.measure_suns(0, 100)
#light = [0, 4095, 4095, 6396, 6218, 6742, 6580, 6371, 6290, 6458, 6538, 6446, 6317, 6397, 6583, 474, 534, 534, 534, 533, 0, 10, 9433, 8729, 9823, 9285, 9049, 8769, 9641, 9222, 9033, 8907, 9291, 9227]
self.log.debug("OBC response: {}".format(light))
ret = self.obc.disable_lcl(2)
self.log.debug("OBC response LCL disable: {}".format(ret))
self.result['STRUCT TEMP'] = TestCompare.assert_between_closed_interval(18, self._lm60_to_centigrades(light[15]), 25)
self.result['TEMP A'] = TestCompare.assert_between_closed_interval(18, self._rtd_to_centigrades(light[16]), 25)
self.result['TEMP B'] = TestCompare.assert_between_closed_interval(18, self._rtd_to_centigrades(light[17]), 25)
self.result['TEMP C'] = TestCompare.assert_between_closed_interval(18, self._rtd_to_centigrades(light[18]), 25)
self.result['TEMP D'] = TestCompare.assert_between_closed_interval(18, self._rtd_to_centigrades(light[19]), 25)
self.data['STRUCT TEMP'] = ResultData(light[15], self._lm60_to_centigrades(light[15]), 'C')
self.data['TEMP A'] = ResultData(light[16], self._rtd_to_centigrades(light[16]), 'C')
self.data['TEMP B'] = ResultData(light[17], self._rtd_to_centigrades(light[17]), 'C')
self.data['TEMP C'] = ResultData(light[18], self._rtd_to_centigrades(light[18]), 'C')
self.data['TEMP D'] = ResultData(light[19], self._rtd_to_centigrades(light[19]), 'C')
difference = [light - dark for light, dark in zip(light, dark)]
self.log.debug("SunS difference: {}".format(difference))
for i in range(0, 12):
self.result['delta ALS VL {}'.format(i)] = TestCompare.assert_greater(difference[3:15][i], 100)
self.result['delta ALS IR {}'.format(i)] = TestCompare.assert_greater(difference[22:34][i], 100)
self.data['delta ALS VL {}'.format(i)] = ResultData(difference[3:15][i], None, None)
self.data['delta ALS IR {}'.format(i)] = ResultData(difference[22:34][i], None, None)
def test_script(self):
self.result = {}
self.data = {}
res_lcl = self.obc.enable_lcl(6)
self.log.debug("OBC response: LCL enable {}".format(res_lcl))
time.sleep(5)
res = self.obc.antenna_get_status("backup")
res_lcl = self.obc.disable_lcl(6)
self.log.debug("OBC response: LCL disable {}".format(res_lcl))
self.result['DeploymentInProgress'] = TestCompare.assert_equal(
res.DeploymentInProgress, [0, 0, 0, 0])
self.result['DeploymentState'] = TestCompare.assert_equal(
res.DeploymentState, [0, 0, 0, 0])
self.result['DeploymentTimeReached'] = TestCompare.assert_equal(
res.DeploymentTimeReached, [0, 0, 0, 0])
self.result['IgnoringSwitches'] = TestCompare.assert_equal(
res.IgnoringSwitches, 0)
self.result['IndependentBurn'] = TestCompare.assert_equal(
res.IndependentBurn, 0)
self.result['Status'] = TestCompare.assert_equal(res.Status, True)
self.result['SystemArmed'] = TestCompare.assert_equal(
res.SystemArmed, 0)
self.data['DeploymentInProgress'] = ResultData(
res.DeploymentInProgress, None, None)
self.data['DeploymentState'] = ResultData(res.DeploymentState, None,
None)
self.data['DeploymentTimeReached'] = ResultData(
res.DeploymentTimeReached, None, None)
self.data['IgnoringSwitches'] = ResultData(res.IgnoringSwitches, None,
None)
self.data['IndependentBurn'] = ResultData(res.IndependentBurn, None,
None)
self.data['Status'] = ResultData(res.Status, None, None)
self.data['SystemArmed'] = ResultData(res.SystemArmed, None, None)
def test_script(self):
result = self.obc.ping()
self.log.debug("OBC response: {}".format(result))
self.result = TestCompare.assert_equal(result, 'pong')
self.data = ResultData(result, result, None)
def test_script(self):
result = self.obc.current_time()
self.log.debug("OBC response: {}".format(result))
self.result = TestCompare.assert_less(result, self.kwargs['time'])
self.data = ResultData(result, result, None)
def test_script(self):
self.result = {}
self.data = {}
ret = self.obc.enable_lcl(5)
self.log.debug("OBC response LCL enable: {}".format(ret))
time.sleep(2)
res = self.obc.payload_whoami()
self.log.debug("OBC response - payload_whoami: {}".format(res))
self.result['Who Am I'] = TestCompare.assert_equal(res['Who Am I'], 83)
self.data['Who Am I'] = ResultData(res['Who Am I'], None, None)
res = self.obc.payload_housekeeping()
self.log.debug("OBC response - payload_housekeeping: {}".format(res))
self.result[
'HK INT 3V3D'] = TestCompare.assert_between_closed_interval(
3.2, self._hk_voltage(res['INT 3V3D']), 3.4)
self.data['HK INT 3V3D'] = ResultData(
res['INT 3V3D'], self._hk_voltage(res['INT 3V3D']), 'V')
self.result[
'HK OBC 3V3D'] = TestCompare.assert_between_closed_interval(
3.2, self._hk_voltage(res['OBC 3V3D']), 3.4)
self.data['HK OBC 3V3D'] = ResultData(
res['OBC 3V3D'], self._hk_voltage(res['OBC 3V3D']), 'V')
res = self.obc.payload_temps()
self.log.debug("OBC response - payload_temps: {}".format(res))
self.result[
'TEMP CAM Nadir'] = TestCompare.assert_between_closed_interval(
15, self._rtd_to_centigrades(res['CAM Nadir']), 30)
self.data['TEMP CAM Nadir'] = ResultData(
res['CAM Nadir'], self._rtd_to_centigrades(res['CAM Nadir']), 'C')
self.result[
'TEMP CAM Wing'] = TestCompare.assert_between_closed_interval(
15, self._rtd_to_centigrades(res['CAM Wing']), 30)
self.data['TEMP CAM Wing'] = ResultData(
res['CAM Wing'], self._rtd_to_centigrades(res['CAM Wing']), 'C')
self.result['TEMP SADS'] = TestCompare.assert_between_closed_interval(
15, self._rtd_to_centigrades(res['SADS']), 25)
self.data['TEMP SADS'] = ResultData(
res['SADS'], self._rtd_to_centigrades(res['SADS']), 'C')
self.result['TEMP Sail'] = TestCompare.assert_between_closed_interval(
15, self._rtd_to_centigrades(res['Sail']), 25)
self.data['TEMP Sail'] = ResultData(
res['Sail'], self._rtd_to_centigrades(res['Sail']), 'C')
self.result['TEMP Xn'] = TestCompare.assert_between_closed_interval(
15, self._rtd_to_centigrades(res['Xn']), 25)
self.data['TEMP Xn'] = ResultData(res['Xn'],
self._rtd_to_centigrades(res['Xn']),
'C')
self.result['TEMP Xp'] = TestCompare.assert_between_closed_interval(
15, self._rtd_to_centigrades(res['Xp']), 25)
self.data['TEMP Xp'] = ResultData(res['Xp'],
self._rtd_to_centigrades(res['Xp']),
'C')
self.result['TEMP Yn'] = TestCompare.assert_between_closed_interval(
15, self._rtd_to_centigrades(res['Yn']), 25)
self.data['TEMP Yn'] = ResultData(res['Yn'],
self._rtd_to_centigrades(res['Yn']),
'C')
self.result['TEMP Yp'] = TestCompare.assert_between_closed_interval(
15, self._rtd_to_centigrades(res['Yp']), 25)
self.data['TEMP Yp'] = ResultData(res['Yp'],
self._rtd_to_centigrades(res['Yp']),
'C')
self.result[
'TEMP Supply'] = TestCompare.assert_between_closed_interval(
15, self._lmt87_to_centigrades(res['Supply']), 25)
self.data['TEMP Supply'] = ResultData(
res['Supply'], self._lmt87_to_centigrades(res['Supply']), 'C')
res = self.obc.payload_photodiodes()
self.log.debug("OBC response - payload_photodiodes: {}".format(res))
self.result['Phd Xn'] = TestCompare.assert_between_closed_interval(
80, res['Xn'], 500)
self.data['Phd Xn'] = ResultData(res['Xn'], None, None)
self.result['Phd Xp'] = TestCompare.assert_between_closed_interval(
80, res['Xp'], 500)
self.data['Phd Xp'] = ResultData(res['Xp'], None, None)
self.result['Phd Yn'] = TestCompare.assert_between_closed_interval(
80, res['Yn'], 500)
self.data['Phd Yn'] = ResultData(res['Yn'], None, None)
self.result['Phd Yp'] = TestCompare.assert_between_closed_interval(
80, res['Yp'], 500)
self.data['Phd Yp'] = ResultData(res['Yp'], None, None)
res = self.obc.payload_suns()
self.log.debug("OBC response - payload_suns: {}".format(res))
self.result['SunS V1'] = TestCompare.assert_between_closed_interval(
2400, res['V1'], 2900)
self.data['SunS V1'] = ResultData(res['V1'], None, None)
self.result['SunS V2'] = TestCompare.assert_between_closed_interval(
2400, res['V2'], 2900)
self.data['SunS V2'] = ResultData(res['V2'], None, None)
self.result['SunS V3'] = TestCompare.assert_between_closed_interval(
2400, res['V3'], 2900)
self.data['SunS V3'] = ResultData(res['V3'], None, None)
self.result['SunS V4'] = TestCompare.assert_between_closed_interval(
2400, res['V4'], 2900)
self.data['SunS V4'] = ResultData(res['V4'], None, None)
self.result['SunS V5'] = TestCompare.assert_between_closed_interval(
2600, res['V5'], 2900)
self.data['SunS V5'] = ResultData(res['V5'], None, None)
res = self.obc.payload_radfet_on()
self.log.debug("OBC response - payload_radfet_on: {}".format(res))
self.result['Radfet On Status'] = TestCompare.assert_equal(
res['Status'], 255)
self.data['Radfet On Status'] = ResultData(res['Status'], None, None)
res = self.obc.payload_radfet_read()
self.log.debug("OBC response - payload_radfet_read: {}".format(res))
self.result[
'Radfet Temperature'] = TestCompare.assert_between_closed_interval(
0.55, self._radfet_diode_voltage(res['Temperature']), 0.65)
self.data['Radfet Temperature'] = ResultData(
res['Temperature'], self._radfet_diode_voltage(res['Temperature']),
'V')
self.result[
'Radfet Vth0'] = TestCompare.assert_between_closed_interval(
2.0, self._radfet_mos_voltage(res['Vth0']), 2.3)
self.data['Radfet Vth0'] = ResultData(
res['Vth0'], self._radfet_mos_voltage(res['Vth0']), 'V')
self.result[
'Radfet Vth1'] = TestCompare.assert_between_closed_interval(
2.0, self._radfet_mos_voltage(res['Vth1']), 2.3)
self.data['Radfet Vth1'] = ResultData(
res['Vth1'], self._radfet_mos_voltage(res['Vth1']), 'V')
self.result[
'Radfet Vth2'] = TestCompare.assert_between_closed_interval(
2.0, self._radfet_mos_voltage(res['Vth2']), 2.3)
self.data['Radfet Vth2'] = ResultData(
res['Vth2'], self._radfet_mos_voltage(res['Vth2']), 'V')
res = self.obc.payload_radfet_off()
self.log.debug("OBC response - payload_radfet_off: {}".format(res))
self.result['Radfet Off Status'] = TestCompare.assert_equal(
res['Status'], 32)
self.data['Radfet Off Status'] = ResultData(res['Status'], None, None)
self.obc.disable_lcl(5)