def test_request_live_bytes():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
line = tester.send_request_live_bytes()
if line:
print("request live bytes successful")
print("live bytes are " + str(line))
def test_specific_daq(daq):
tester = instruction_manager.instruction_manager('COM6')
line = tester.send_request_data(daq)
print("recieved line " + str(line))
# if __name__ == "__main__":
# test_request_status()
# test_specific_daq(1)
# test_listen()
# test_send()
# test_send_byte()
# test_compare_byte()
# -----------------------------------------------------
# test_send_configuration()
# test_request_configuration()
# test_request_start()
# test_request_number_of_modules_connected()
# test_request_live_bytes()
# test_send_cancel()
# test_request_all_data()
# test_listen()
# test_gps_data_request()
# test_sync_gps_request()
# test_diagnose_request()
# test_request_status()
# test_request_configuration_validity()
# test_wrong_instruction_acknowledge()
def test_request_status():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
line = tester.send_request_status()
if line:
print("request status successful")
print("microntroller output is: " + str(line))
def test_diagnose_request():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
line = tester.send_diagnose_request()
if line:
print("request diagnode successful")
print("microntroller output is: " + str(line))
def test_gps_data_request():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
line = tester.send_gps_data_request()
if line:
print("request gps data successful")
print("microntroller output is: " + str(line))
def test_request_number_of_modules_connected():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
line = tester.send_request_number_of_mods_connected()
print("type of them are" + str(type(line[0])))
if line:
print("request number of modules successful")
print("modules connected: " + str(line))
def test_request_configuration_validity():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
line = tester.send_request_configuration_validity()
if line:
print("request configuration validity successful")
print("microntroller output is: " + str(line))
"""
def test_request_configuration():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
line = tester.send_request_configuration()
#print("line is " + str(line))
if line:
print("request configuration succesful")
print("microntroller output is: " + str(line))
else:
print("test failed")
def sync_gps(): # TODO TEST IN ENVIRONMENT WHERE IT DOES SYNC.
"""
Calls Control Module for GPS nada.
"""
# Show Progress Dialog.
global stop_break_loop
stop_break_loop = True
prog_dlg = ProgressDialog()
prog_dlg.acquire_dialog('GPS Signal')
prog_dlg.progress_bar.setMaximum(100)
prog_dlg.progress_bar.setValue(0)
app.processEvents()
try:
ins = ins_man.instruction_manager(ins_port)
ins.send_gps_sync_request()
timeout = 0
sleep_value = 0.1 # Wait for half a second before asking again.
max_timeout = 30 # desired timeout in seconds
synced = True # Used to not request data if synched==False.
while (ins.send_request_status()[2] !=
1) and stop_break_loop: # Status[2] --> gps_synched
print('GPS Waiting....')
sleep(sleep_value)
timeout += 1
prog_dlg.progress_bar.setValue(
(timeout / (max_timeout * (1 / sleep_value))) * 100)
app.processEvents()
if timeout == max_timeout * (
1 / sleep_value
) + 1: # = [desired timeout in seconds] * [1/(sleep value)] + begin at 1%.
prog_dlg.progress_bar.setValue(100)
base_window.display_error('GPS Failed to Synchronize.')
prog_dlg.close()
synced = False
break
if synced and stop_break_loop:
prog_dlg.progress_bar.setValue(100)
ins.send_gps_data_request()
main_window.set_GPS_into_gui()
if not stop_break_loop:
ins.send_cancel_request()
prog_dlg.close()
del ins
except serial.SerialException:
prog_dlg.close()
base_window.not_connected_error()
def open(self):
"""
Opens Module Selection Window. [Does not create a new instance]
Done before Channel Selection.
"""
# Disable not connected modules.
try:
im = ins_man.instruction_manager(GUI_Handler.ins_port)
connected_modules = im.send_request_number_of_mods_connected()
self.disable_buttons(connected_modules)
self.module_selection_win.show()
except SerialException:
GUI_Handler.base_window.not_connected_error()
def test_send_cancel():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
bool = tester.send_cancel_request()
if bool:
print("cancel request successful")
def test_send_live_stream_request():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
tester.send_live_stream_request(1, 1, 2)
def test_request_start():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
bool = tester.send_request_start()
if bool:
print("request start succesful")
def test_sync_gps_request():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
bool = tester.send_gps_sync_request()
if bool:
print("request gps sync succesful")
def action_begin_recording(sel_matrix: SensorSelectionMatrix,
start_diagnose: int):
"""
Prepares GUI and sends request to control module for begin recording data.
:param sel_matrix: SensorSelectionMatrix Window instance that called this function (signaled to this slot)
:param start_diagnose: Integer to know if user wants to begin recording or run a diagnostic test.
"""
# Send Setting Information to Control Module.
try:
configuration = setting_data_manager.settings_to_string()
sens_selected, mods_selected = sensor_matrix.get_modules_and_sensors_selected(
)
sel_matrix.close()
ins = ins_man.instruction_manager(ins_port)
# SendRecording Parameters & Begin Recording FLAG to Control Module.
if start_diagnose == START_TEST:
if configuration:
# ins = ins_man.instruction_manager(ins_port)
# ins.send_set_configuration(configuration)
params_sent = ins.send_recording_parameters(
sfrequency=daq_config.sampling_rate_index,
cutoff=daq_config.cutoff_freq_index,
gain=daq_config.gain_index,
duration=daq_config.recording_configs["test_duration"],
start_delay=daq_config.
recording_configs["test_start_delay"],
store_data_sd=daq_config.data_handling_configs["store"],
sensor_enable=sens_selected,
name="Not Used",
location="Not Used")
print("sent was " + str(params_sent))
sleep(0.5)
ins.send_request_start()
# Send Run Diagnostic FLAG to Control Module.
elif start_diagnose == DIAGNOSE:
if configuration:
# ins = ins_man.instruction_manager(ins_port)
# ins.send_set_configuration(configuration)
ins.send_diagnose_request()
sleep(0.3)
params_sent = ins.send_recording_parameters(
sfrequency=daq_config.sampling_rate_index,
cutoff=daq_config.cutoff_freq_index,
gain=daq_config.gain_index,
duration=daq_config.recording_configs["test_duration"],
start_delay=daq_config.
recording_configs["test_start_delay"],
store_data_sd=daq_config.data_handling_configs["store"],
sensor_enable=sens_selected,
name="Not Used",
location="Not Used")
print("sent was " + str(params_sent))
sleep(0.5)
ins.send_request_start()
# Close Window
sensor_matrix.close()
check_status_during_test(ins, mods_selected)
except serial.SerialException:
base_window.not_connected_error()
def enable_connected_sensors(self):
"""
Enables CheckBoxes on window after asking Control Module for connected modules.
This Method ASUMES device connection is made and/or handled before calling enable_connected_sensors.
:return: False if there are no sensors connected.
"""
continuar = False
# Get Connected Modules
# connected_module_list = [1, 0, 0, 0, 0, 0, 0, 0]
ins = ins_man.instruction_manager(GUI_Handler.ins_port)
connected_module_list = ins.send_request_number_of_mods_connected()
if log:
print("entered enable start, array is " +
str(connected_module_list))
if connected_module_list[0]:
self.win_sens_1.setEnabled(True)
self.win_sens_2.setEnabled(True)
self.win_sens_3.setEnabled(True)
self.win_sens_4.setEnabled(True)
continuar = True
if connected_module_list[1]:
self.win_sens_5.setEnabled(True)
self.win_sens_6.setEnabled(True)
self.win_sens_7.setEnabled(True)
self.win_sens_8.setEnabled(True)
continuar = True
if connected_module_list[2]:
self.win_sens_9.setEnabled(True)
self.win_sens_10.setEnabled(True)
self.win_sens_11.setEnabled(True)
self.win_sens_12.setEnabled(True)
continuar = True
if connected_module_list[3]:
self.win_sens_13.setEnabled(True)
self.win_sens_14.setEnabled(True)
self.win_sens_15.setEnabled(True)
self.win_sens_16.setEnabled(True)
continuar = True
if connected_module_list[4]:
self.win_sens_17.setEnabled(True)
self.win_sens_18.setEnabled(True)
self.win_sens_19.setEnabled(True)
self.win_sens_20.setEnabled(True)
continuar = True
if connected_module_list[5]:
self.win_sens_21.setEnabled(True)
self.win_sens_22.setEnabled(True)
self.win_sens_23.setEnabled(True)
self.win_sens_24.setEnabled(True)
continuar = True
if connected_module_list[6]:
self.win_sens_25.setEnabled(True)
self.win_sens_26.setEnabled(True)
self.win_sens_27.setEnabled(True)
self.win_sens_28.setEnabled(True)
continuar = True
if connected_module_list[7]:
self.win_sens_29.setEnabled(True)
self.win_sens_30.setEnabled(True)
self.win_sens_31.setEnabled(True)
self.win_sens_32.setEnabled(True)
continuar = True
if log: print("got out of enable start connected sensors")
# If not Connected to not continue.
return continuar, connected_module_list
def test_send_configuration():
tester = instruction_manager.instruction_manager('COM6')
# tester.init(1)
bool = tester.send_set_configuration("set dmmy configuration text")
if bool:
print("send configuration test sucessful")
