def f_synchronize_adr(serversocket, receiver_ip, time_server): ''' Function reads a message from ADR radio astronomy receiver ntp server must be installed on server PC (sudo apt install ntp) to start ntp-server on server pc use "sudo /etc/init.d/ntp start" or/and "sudo systemctl restart ntp" Input parameters: serversocket - handle of socket to send and receive messages from server receiver_ip - IP address of receiver_ip to connect for sntp synchro from server time_server - IP address of the ntp time server (probably PC where the script runs) Output parameters: ''' # Update synchronization of PC and ADR print('\n * ADR synchronization with Server and ADR PC') receiver_file = open('service_data/receiver.txt', 'r') rec_user = receiver_file.readline()[:-1] password = receiver_file.readline()[:-1] receiver_file.close() # SSH connection to ADR receiver to send sntp command to synchronize with server s = pxssh.pxssh() if not s.login(receiver_ip, rec_user, password): print('\n ERROR! SSH session failed on login!') print(str(s)) else: print('\n SSH session login successful') s.sendline('sntp -P no -r ' + time_server) s.prompt() # match the prompt print('\n Answer: ', s.before) # print everything before the prompt. s.logout() time.sleep(1) # now = datetime.now() serversocket.send(b'set prc/dsp/ctl/clc 0 1\0') data_0 = f_read_adr_meassage(serversocket, 0) serversocket.send(b'set prc/srv/ctl/adr 6 1\0') data_1 = f_read_adr_meassage(serversocket, 0) if data_0.startswith('SUCCESS') and data_1.startswith('SUCCESS'): print('\n UTC absolute second set') else: print('\n ERROR! UTC absolute second was not set!') time.sleep(3) serversocket.send(b'set prc/dsp/ctl/clc 0 0\0') # tune second data_0 = f_read_adr_meassage(serversocket, 0) serversocket.send(b'set prc/dsp/ctl/clc 1 0\0') # tune second data_1 = f_read_adr_meassage(serversocket, 0) serversocket.send(b'set prc/srv/ctl/adr 6 1\0') data_2 = f_read_adr_meassage(serversocket, 0) if data_0.startswith('SUCCESS') and data_1.startswith( 'SUCCESS') and data_2.startswith('SUCCESS'): print('\n UTC absolute second tuned')
def f_connect_to_adr_receiver(host, port, control, delay): """ Function connects to the ADR receiver via specified socket Input parameters: host - IP address to connect port - port to connect control - to control (1) or to view (0) possibility delay - delay in seconds to wait after connection Output parameters: serversocket - handle of socket to send and receive messages from server input_parameters_s - long string with all receiver parameters at the moment of connection """ serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) serversocket.connect((host, port)) serversocket.send('ADRSCTRL'.encode()) register_cc_msg = bytearray([108, 0, 0, 0]) register_cc_msg.extend( b'YeS\0 ' ) # Name 64 bytes register_cc_msg.extend( b'adrs\0 ') # Password 32 bytes register_cc_msg.extend([0, 0, 0, control]) # Priv 4 bytes register_cc_msg.extend([0, 0, 0, control]) # CTRL 4 bytes register_cc_msg = bytes(register_cc_msg) # print('\n Length: ', len(register_cc_msg)) # print('\n Sent message: ', register_cc_msg) serversocket.send(register_cc_msg) data = f_read_adr_meassage(serversocket, 0) data = serversocket.recv(108) if data[-1] == 1: print('\n * Connected to host: ', host, ' port: ', port, ' Control accepted') else: print('\n * Connected to host: ', host, ' port: ', port, ' (!) View only') # Reading all parameters valid now input_parameters_str = '' for i in range(23): input_parameters_str += f_read_adr_meassage(serversocket, 0) # Making pause to read the printed data time.sleep(delay) return serversocket, input_parameters_str
def f_get_adr_parameters(serversocket, print_or_not): """ Function requests ADR receiver parameters via specified socket and prints them Input parameters: serversocket - handle of socket to send and receive messages from server print_or_not - to print the parameters to console (1) or not (0) Output parameters: parameters_dict - dictionary with current parameters of ADR receiver """ parameters_dict = {} serversocket.send( (b'get prc/srv/ctl/pth\0')) # read directory where data are stored data = f_read_adr_meassage(serversocket, 0) parameters_dict["save_data_path"] = find_between(data, 'SUCCESS\n', '\n') serversocket.send( (b'get prc/srv/ctl/sys\0')) # read directory where data are stored data = f_read_adr_meassage(serversocket, 0) parameters_dict["receiver_name"] = find_between(data, 'SUCCESS\n', '\n') serversocket.send( (b'get prc/srv/ctl/plc\0')) # read directory where data are stored data = f_read_adr_meassage(serversocket, 0) parameters_dict["observation_place"] = find_between( data, 'SUCCESS\n', '\n') serversocket.send( (b'get prc/srv/ctl/dsc\0')) # read directory where data are stored data = f_read_adr_meassage(serversocket, 0) parameters_dict["file_description"] = find_between(data, 'SUCCESS\n', '\n') serversocket.send((b'get prc/dsp/ctl/opt\0')) # data = f_read_adr_meassage(serversocket, 0) parameters_dict["synchro_start"] = find_between(data, 'SyncStart: ', '\n') parameters_dict["external_clock"] = find_between(data, 'Ext.CLC: ', '\n') parameters_dict["fft_window"] = find_between(data, 'FFT_Window: ', '\n') parameters_dict["sum_diff_mode"] = find_between(data, 'A+B/A-B: ', '\n') serversocket.send((b'get prc/dsp/ctl/mdo\0')) # data = f_read_adr_meassage(serversocket, 0) parameters_dict["operation_mode_num"] = int( find_between(data, 'SUCCESS\n', ' - Mode')) if parameters_dict["operation_mode_num"] == 0: parameters_dict["operation_mode_str"] = 'Waveform ch. A' elif parameters_dict["operation_mode_num"] == 1: parameters_dict["operation_mode_str"] = 'Waveform ch. B' elif parameters_dict["operation_mode_num"] == 2: parameters_dict["operation_mode_str"] = 'Waveform ch. A and B' elif parameters_dict["operation_mode_num"] == 3: parameters_dict["operation_mode_str"] = 'Spectra ch. A' elif parameters_dict["operation_mode_num"] == 4: parameters_dict["operation_mode_str"] = 'Spectra ch. B' elif parameters_dict["operation_mode_num"] == 5: parameters_dict["operation_mode_str"] = 'Spectra ch. A and B' elif parameters_dict["operation_mode_num"] == 6: parameters_dict["operation_mode_str"] = 'Correlation ch. A and B' else: parameters_dict["operation_mode_str"] = 'Unknown mode' parameters_dict["FFT_size_samples"] = int( find_between(data, 'Mode (index)\n', ' - FFT Size')) parameters_dict["spectra_averaging"] = int( find_between(data, 'FFT Size (samples)\n', ' - Averaging')) parameters_dict["start_line_freq"] = int( find_between(data, 'Averaging (Spectra count)\n', ' - Start line')) parameters_dict["width_line_freq"] = int( find_between(data, 'Start line (count)\n', ' - Width')) parameters_dict["clock_frequency"] = int( find_between(data, 'Width (count)\n', ' - ADC CLOCK')) serversocket.send((b'get prc/srv/ctl/srd\0')) # data = f_read_adr_meassage(serversocket, 0) parameters_dict["data_recording"] = int( find_between(data, 'SUCCESS\n', ' - Save on/off')) parameters_dict["files_autocreation"] = int( find_between(data, 'on/off (On/Off)\n', ' - Autocreation')) parameters_dict["size_of_file"] = int( find_between(data, 'Autocreation (On/Off)\n', ' - Size restriction')) parameters_dict["time_of_file"] = int( find_between(data, 'restriction (MB)\n', ' - Time restriction')) # Calculation of frequency and time parameters parameters_dict["time_resolution"] = parameters_dict["spectra_averaging"] * \ (parameters_dict["FFT_size_samples"] / float(parameters_dict["clock_frequency"])) parameters_dict["frequency_resolution"] = \ float(parameters_dict["clock_frequency"]) / parameters_dict["FFT_size_samples"] parameters_dict["number_of_channels"] = int( parameters_dict["width_line_freq"] * 1024) parameters_dict["lowest_frequency"] = \ parameters_dict["start_line_freq"] * 1024 * parameters_dict["frequency_resolution"] parameters_dict["highest_frequency"] = ( parameters_dict["lowest_frequency"] + parameters_dict["number_of_channels"] * parameters_dict["frequency_resolution"]) # Printing the parameters to console if print_or_not > 0: print('\n * Current ADR parameters:') print('\n File description: \n\n ', parameters_dict["file_description"], '\n') print(' Path to save data: ', parameters_dict["save_data_path"]) print(' Observation place: ', parameters_dict["observation_place"]) print(' Receiver name: ', parameters_dict["receiver_name"]) print('\n Time resolution: ', round(parameters_dict["time_resolution"], 3), ' s.') print(' Frequency resolution: ', round(parameters_dict["frequency_resolution"] / 1000, 3), ' kHz.') print(' Frequency range: ', round(parameters_dict["lowest_frequency"] / 1000000, 3), ' - ', round(parameters_dict["highest_frequency"] / 1000000, 3), ' MHz') print('\n ADR operation mode: ', parameters_dict["operation_mode_str"]) if parameters_dict["external_clock"] == 'OFF': print(' External 160 MHz clock: (!)', parameters_dict["external_clock"]) else: print(' External 160 MHz clock: ', parameters_dict["external_clock"]) print( ' Sampling frequency: ', format(parameters_dict["clock_frequency"], ',').replace(',', ' ').replace('.', ','), ' Hz') print(' FFT samples number: ', parameters_dict["FFT_size_samples"]) print(' Number of frequency channels: ', parameters_dict["number_of_channels"]) if parameters_dict["sum_diff_mode"] == 'ON': print(' Sum/diff mode: (!)', parameters_dict["sum_diff_mode"]) else: print(' Sum/diff mode: ', parameters_dict["sum_diff_mode"]) if parameters_dict["files_autocreation"] == 1: print(' Files autocreation: ON') else: print(' Files autocreation: (!) OFF') return parameters_dict
def f_set_adr_parameters(serversocket, print_or_not, pause=0.5): ''' Function sets ADR receiver parameters Input parameters: serversocket - handle of socket to send and receive messages from server print_or_not - to print the parameters to console (1) or not (0) Output parameters: ''' # MDO parameters serversocket.send((b"set prc/dsp/ctl/mdo 0 6\0" )) # Set operation mode 0-6 (6 - correlation) data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send((b"set prc/dsp/ctl/mdo 1 16384\0" )) # Set FFT size 2048,4096,8192,16384,32768 data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/dsp/ctl/mdo 2 2000\0" )) # Set number of averaged spectra in range [16 … 32768] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/dsp/ctl/mdo 3 0\0") ) # Start frequency line of the band in 1024-steps. SLINE range [0 … (SFFT-1024)/1024] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/dsp/ctl/mdo 4 8\0") ) # Width of frequency band in 1024-steps. WIDTH range [1 … (SFFT-SLINE*1024)/1024] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/srv/ctl/adr 3 1\0" )) # To apply the ADR DSP parameters (which is set in the [mdo] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) # OPT parameters serversocket.send( (b"set prc/dsp/ctl/opt 0 0\0") ) # On/Off the synchro start of ADR data processing by front of the PPS signal. data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send(( b"set prc/dsp/ctl/opt 1 0\0")) # On/Off the external source of ADC CLC data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/dsp/ctl/opt 2 1\0")) # On/Off the FFT Hanning window data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/dsp/ctl/opt 3 0\0")) # On/Off the “sum-difference” mode A±B data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/srv/ctl/adr 6 1\0" )) # To apply the ADR DSP options, which are defined in [opt] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) # SET parameters serversocket.send( (b"set prc/dsp/ctl/set 5 0\0") ) # Differential delay (DDEL) between CH-A and CH-B ADC sampling (CLC front) in picoseconds data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/srv/ctl/adr 5 1\0" )) # To apply the ADR DSP settings, which are defined in [set] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) ''' # Apply MDO parameters serversocket.send((b"set prc/srv/ctl/adr 3 1\0")) # To apply the ADR DSP parameters (which is set in the [mdo] data = f_read_adr_meassage(serversocket, print_or_not) serversocket.send((b"set prc/srv/ctl/adr 5 1\0")) # To apply the ADR DSP settings, which are defined in [set] data = f_read_adr_meassage(serversocket, print_or_not) serversocket.send((b"set prc/srv/ctl/adr 6 1\0")) # To apply the ADR DSP options, which are defined in [opt] data = f_read_adr_meassage(serversocket, print_or_not) ''' return
def f_wait_predefined_time_connected(time_to_start, serversocket, synchro = 0, host = '192.168.1.171', time_server = '192.168.1.150'): # ''' Function waits the predefined time and once a minute reads something from ADR receiver to save connection to ADR server Input parameters: time_to_start - datetime variable with time to continue the script serversocket - socket handle to keep the connection alive synchro - to synchronize the receiver before timer end (1 - yes, 0 - no) Output parameter: result - boolean variable (1) if time was chosen correctly (0) if not ''' #''' # Keeping connection active serversocket.send(('get prc/srv/ctl/pth\0').encode()) # serversocket.send(('get prc/srv/ctl/adr\0').encode()) a = f_read_adr_meassage(serversocket, 0) # print(a) #''' now = datetime.datetime.now() diff = int((time_to_start - now).total_seconds()) if diff > 0: result = True diff_hours = int(diff / 3600) diff_min = int((diff - diff_hours*3600) / 60) diff_sec = diff % 60 print("\n {:02d}:{:02d}:{:02d} Wait for: {:02d} hr {:02d} min {:02d} sec...".format(now.hour, now.minute, now.second, diff_hours, diff_min, diff_sec)) # Wait minutes if int(diff / 60) > 0: while True: time.sleep(60) #''' # Keeping connection active serversocket.send(('get prc/srv/ctl/pth\0').encode()) # serversocket.send(('get prc/srv/ctl/adr\0').encode()) data = f_read_adr_meassage(serversocket, 0) # print(data) #if (data.startswith('SUCCESS')): # pass #else: # pass # Can send some message if the receiver does not respond. Figure out how to make this. #''' now = datetime.datetime.now() diff = int((time_to_start - now).total_seconds()) if int(diff / 60) <= 1: break if synchro > 0: # Update synchronization of PC and ADR f_synchronize_adr(serversocket, host, time_server) print('') # To make empty line after synchro info now = datetime.datetime.now() diff = int((time_to_start - now).total_seconds()) print(" {:02d}:{:02d}:{:02d} Wait for: {} min {:02d} sec...".format(now.hour, now.minute, now.second, int(diff / 60), diff % 60)) # Wait seconds while True: time.sleep(1) now = datetime.datetime.now() diff = int((time_to_start - now).total_seconds()) if diff < 1: print(" {:02d}:{:02d}:{:02d} It's time!".format(now.hour, now.minute, now.second)) break else: print('\n ERROR! Time has passed!') result = False return result
startTime = time.time() currentTime = time.strftime("%H:%M:%S") currentDate = time.strftime("%d.%m.%Y") print(' Today is ', currentDate, ' time is ', currentTime, '\n') # process only copied from receiver data if process_data > 0: copy_data = 1 parameters_file = 'service_data/' + parameters_file # Connect to the ADR receiver via socket serversocket, input_parameters_str = f_connect_to_adr_receiver( receiver_ip, port, 1, 0.1) # 1 - control, 1 - delay in sec # Check if the receiver is initialized, if it is not - initialize it serversocket.send((b"set prc/srv/ctl/adr 3 1\0")) data = f_read_adr_meassage(serversocket, 0) if ('Failed!' in data or 'Stopped' in data): # Initialize ADR and set ADR parameters f_initialize_adr(serversocket, receiver_ip, 0) # Set initial ADR parameters #f_set_adr_parameters(serversocket, 0) parameters_dict = f_read_adr_parameters_from_txt_file(parameters_file) parameters_dict = f_check_adr_parameters_correctness(parameters_dict) f_set_adr_parameters(serversocket, parameters_dict, 0, 0.5) # Update synchronization of PC and ADR f_synchronize_adr(serversocket, receiver_ip, time_server)
def main_observation_control(receiver_ip, port, schedule_txt_file, dir_data_on_server, telegram_chat_id, Software_version, Software_name, MaxNim, RFImeanConst, Vmin, Vmax, VminNorm, VmaxNorm, VminCorrMag, VmaxCorrMag, customDPI, colormap, CorrelationProcess, DynSpecSaveInitial, DynSpecSaveCleaned, CorrSpecSaveInitial, CorrSpecSaveCleaned, SpecterFileSaveSwitch, ImmediateSpNo, averOrMin, VminMan, VmaxMan, VminNormMan, VmaxNormMan, AmplitudeReIm): # ******************************************************************************* # M A I N P R O G R A M * # ******************************************************************************* print('\n\n\n\n\n\n\n\n *********************************************************************') print(' * ', Software_name, ' v.', Software_version,' * (c) YeS 2020') print(' ********************************************************************* \n\n\n') currentTime = time.strftime("%H:%M:%S") currentDate = time.strftime("%d.%m.%Y") print(' Today is ', currentDate, ' time is ', currentTime, '\n') # Read schedule schedule = f_read_schedule_txt_for_adr(schedule_txt_file) # Check correctness of parameters in txt files for obs_no in range(len(schedule)): parameters_file = 'service_data/' + schedule[obs_no][10] parameters_dict = f_read_adr_parameters_from_txt_file(parameters_file) parameters_dict = f_check_adr_parameters_correctness(parameters_dict) del parameters_dict, parameters_file print('\n Parameters of all observations have been checked, they seem OK.') # Make or open Log file obs_log_file = open(obs_log_file_name, "a") obs_log_file.write('\n ' + currentDate + ' ' + currentTime + ' New schedule loaded: \n') # Printing overall schedule print('\n *********************** OBSERVATIONS SCHEDULE ***********************') for obs_no in range(len(schedule)): line = ' ' + schedule[obs_no][0] + ' - ' + schedule[obs_no][1] + ' DIR: ' + schedule[obs_no][6] print(' ' + line) obs_log_file.write(line + '\n') print(' *********************************************************************') # Close Log file obs_log_file.write('\n') obs_log_file.close() # Connect to the ADR receiver via socket serversocket, input_parameters_str = f_connect_to_adr_receiver(receiver_ip, port, 1, 1) # 1 - control, 1 - delay in sec # Check if the receiver is initialized, if it is not - initialize it serversocket.send(b"set prc/srv/ctl/adr 3 1\0") data = f_read_adr_meassage(serversocket, 0) if 'Failed!' in data or 'Stopped' in data: # Initialize ADR and set ADR parameters f_initialize_adr(serversocket, receiver_ip, 0) # Update synchronization of PC and ADR f_synchronize_adr(serversocket, receiver_ip, time_server) # Making separated IDs for each observation processing process p_processing = [None] * len(schedule) # Preparing and starting observations for obs_no in range(len(schedule)): print('\n *********************************************************************\n Observation # ', obs_no + 1, ' of ', len(schedule), ' ', schedule[obs_no][6], '\n *********************************************************************') # Construct datetime variables to start and stop observations dt_time = schedule[obs_no][0] dt_time_to_start_record = datetime(int(dt_time[0:4]), int(dt_time[5:7]), int(dt_time[8:10]), int(dt_time[11:13]), int(dt_time[14:16]), int(dt_time[17:19]), 0) dt_time = schedule[obs_no][1] dt_time_to_stop_record = datetime(int(dt_time[0:4]), int(dt_time[5:7]), int(dt_time[8:10]), int(dt_time[11:13]), int(dt_time[14:16]), int(dt_time[17:19]), 0) # Check the correctness of start and stop time if (dt_time_to_start_record < dt_time_to_stop_record) and (dt_time_to_start_record > datetime.now()): print(' Recording start time: ', schedule[obs_no][0]) print(' Recording stop time: ', schedule[obs_no][1], '\n *********************************************************************') else: sys.exit('\n\n * ERROR! Time limits are wrong!!! \n\n') # Prepare directory for data recording dt_time = schedule[obs_no][0] # Taking date from schedule start time data_directory_name = dt_time[0:10].replace('-', '.') + '_GURT_' + schedule[obs_no][6] serversocket.send(('set prc/srv/ctl/pth ' + data_directory_name + '\0').encode()) # set directory to store data data = f_read_adr_meassage(serversocket, 0) # if data.startswith('SUCCESS'): # print ('\n * Directory name changed to: ', data_directory_name) # Set observation description: serversocket.send(('set prc/srv/ctl/dsc ' + schedule[obs_no][7] + '\0').encode()) data = f_read_adr_meassage(serversocket, 0) # Apply other receiver parameters set in schedule (parameters file) parameters_file = 'service_data/' + schedule[obs_no][10] parameters_dict = f_read_adr_parameters_from_txt_file(parameters_file) f_set_adr_parameters(serversocket, parameters_dict, 0, 0.5) # Requesting and printing current ADR parameters parameters_dict = f_get_adr_parameters(serversocket, 1) if obs_no+1 == len(schedule): message = 'Last observation in schedule on receiver: ' + parameters_dict["receiver_name"].replace('_', ' ') + \ ' (IP: ' + receiver_ip + ') was set. It will end on: ' + schedule[obs_no][1] + \ '. Please, consider adding of a new schedule!' try: test = telegram_bot_sendtext(telegram_chat_id, message) except: pass # Waiting time to start record print('\n * Waiting time to synchronize and start recording...') ok = f_wait_predefined_time_connected(dt_time_to_start_record, serversocket, 1, receiver_ip, time_server) # Start record serversocket.send('set prc/srv/ctl/srd 0 1\0'.encode()) # start data recording data = f_read_adr_meassage(serversocket, 0) if data.startswith('SUCCESS'): print('\n * Recording started') message = 'GURT ' + data_directory_name.replace('_', ' ') + \ ' observations started successfully!\nStart time: ' + \ schedule[obs_no][0] + '\nStop time: ' + schedule[obs_no][1] + \ '\nReceiver: ' + parameters_dict["receiver_name"].replace('_', ' ') + \ '\nReceiver IP: ' + receiver_ip + \ '\nDescription: ' + parameters_dict["file_description"].replace('_', ' ') + \ '\nMode: ' + parameters_dict["operation_mode_str"] + \ '\nTime resolution: ' + str(round(parameters_dict["time_resolution"], 3)) + ' s.' + \ '\nFrequency resolution: ' + str(round(parameters_dict["frequency_resolution"] / 1000, 3)) + \ ' kHz.' + '\nFrequency range: ' + str(round(parameters_dict["lowest_frequency"] / 1000000, 3)) + \ ' - ' + str(round(parameters_dict["highest_frequency"] / 1000000, 3)) + ' MHz' try: test = telegram_bot_sendtext(telegram_chat_id, message) except: pass # Waiting time to stop record ok = f_wait_predefined_time_connected(dt_time_to_stop_record, serversocket, 0, receiver_ip, time_server) # Stop record serversocket.send('set prc/srv/ctl/srd 0 0\0'.encode()) # stop data recording data = f_read_adr_meassage(serversocket, 0) if data.startswith('SUCCESS'): print('\n * Recording stopped') # Sending message to Telegram message = 'GURT ' + data_directory_name.replace('_', ' ') + ' observations completed!\nStart time: ' \ + schedule[obs_no][0] + '\nStop time: ' + schedule[obs_no][1] + \ '\nReceiver: ' + parameters_dict["receiver_name"].replace('_', ' ') + \ '\nReceiver IP: ' + receiver_ip + \ '\nDescription: ' + parameters_dict["file_description"].replace('_', ' ') + \ '\nMode: ' + parameters_dict["operation_mode_str"] + \ '\nTime resolution: ' + str(round(parameters_dict["time_resolution"], 3)) + ' s.' + \ '\nFrequency resolution: ' + str(round(parameters_dict["frequency_resolution"] / 1000, 3)) + ' kHz.' + \ '\nFrequency range: ' + str(round(parameters_dict["lowest_frequency"] / 1000000, 3)) + ' - ' + \ str(round(parameters_dict["highest_frequency"] / 1000000, 3)) + ' MHz' if schedule[obs_no][8] > 0 and schedule[obs_no][9] == 0: message = message + '\nData will be copied to GURT server.' if schedule[obs_no][9] > 0: message = message + '\nData will be copied to GURT server and processed.' # Open Log file and write the data message there obs_log_file = open(obs_log_file_name, "a") obs_log_file.write(message + '\n\n') obs_log_file.close() if obs_no + 1 == len(schedule): message = message + '\n\nIt was the last observation in schedule. Please, consider adding of a new schedule!' try: test = telegram_bot_sendtext(telegram_chat_id, message) except: pass # Data copying processing if schedule[obs_no][8] > 0 or schedule[obs_no][9] > 0: p_processing[obs_no] = Process(target=copy_and_process_adr, args=(schedule[obs_no][8], schedule[obs_no][9], dir_data_on_server, data_directory_name, parameters_dict, telegram_chat_id, receiver_ip, MaxNim, RFImeanConst, Vmin, Vmax, VminNorm, VmaxNorm, VminCorrMag, VmaxCorrMag, customDPI, colormap, CorrelationProcess, DynSpecSaveInitial, DynSpecSaveCleaned, CorrSpecSaveInitial, CorrSpecSaveCleaned, SpecterFileSaveSwitch, ImmediateSpNo, averOrMin, VminMan, VmaxMan, VminNormMan, VmaxNormMan, AmplitudeReIm)) p_processing[obs_no].start() # If it was the last observation, set the default parameters of the receiver if obs_no+1 == len(schedule): # Apply other receiver parameters set in schedule (parameters file) parameters_file = 'service_data/' + default_parameters_file parameters_dict = f_read_adr_parameters_from_txt_file(parameters_file) parameters_dict = f_check_adr_parameters_correctness(parameters_dict) f_set_adr_parameters(serversocket, parameters_dict, 0, 0.5) for obs_no in range(len(schedule)): if schedule[obs_no][8] > 0 or schedule[obs_no][9] > 0: p_processing[obs_no].join() print('\n\n *** Program ', Software_name, ' has finished! *** \n\n\n')
def f_set_adr_parameters(serversocket, parameters_dict, print_or_not, pause=0.5): """ Function sets ADR receiver parameters Input parameters: serversocket - handle of socket to send and receive messages from server print_or_not - to print the parameters to console (1) or not (0) Output parameters: """ # MDO parameters serversocket.send( ('set prc/dsp/ctl/mdo 0 ' + str(parameters_dict["operation_mode_num"]) + '\0').encode()) # Set operation mode 0-6 (6 - correlation) data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( ('set prc/dsp/ctl/mdo 1 ' + str(parameters_dict["FFT_size_samples"]) + '\0').encode()) # Set FFT size 2048,4096,8192,16384,32768 data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send(( 'set prc/dsp/ctl/mdo 2 ' + str(parameters_dict["spectra_averaging"]) + '\0').encode()) # Set number of averaged spectra in range [16 … 32768] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( ('set prc/dsp/ctl/mdo 3 ' + str(parameters_dict["start_line_freq"]) + '\0').encode() ) # Start frequency line of the band in 1024-steps. SLINE range [0 … (SFFT-1024)/1024] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( ('set prc/dsp/ctl/mdo 4 ' + str(parameters_dict["width_line_freq"]) + '\0').encode() ) # Width of frequency band in 1024-steps. WIDTH range [1 … (SFFT-SLINE*1024)/1024] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/srv/ctl/adr 3 1\0" )) # To apply the ADR DSP parameters (which is set in the [mdo] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) # OPT parameters serversocket.send( (b"set prc/dsp/ctl/opt 0 0\0") ) # On/Off the synchro start of ADR data processing by front of the PPS signal. data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( ('set prc/dsp/ctl/opt 1 ' + str(parameters_dict["clock_source"]) + '\0').encode()) # On/Off the external source of ADC CLC data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/dsp/ctl/opt 2 1\0")) # On/Off the FFT Hanning window data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( ('set prc/dsp/ctl/opt 3 ' + str(parameters_dict["sum_diff_mode_num"]) + '\0').encode()) # On/Off the “sum-difference” mode A±B data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/srv/ctl/adr 6 1\0" )) # To apply the ADR DSP options, which are defined in [opt] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) # SET parameters serversocket.send( ('set prc/dsp/ctl/set 5 ' + str(parameters_dict["chan_diff_delay"]) + '\0').encode() ) # Differential delay (DDEL) between CH-A and CH-B ADC sampling (CLC front) in picoseconds data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) serversocket.send( (b"set prc/srv/ctl/adr 5 1\0" )) # To apply the ADR DSP settings, which are defined in [set] data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) # DATA SAVING parameters # serversocket.send((b"set prc/srv/ctl/srd 2 2048\0")) # Data file size 2048 MB serversocket.send(('set prc/srv/ctl/srd 2 ' + str(parameters_dict["data_file_size"]) + '\0').encode()) data = f_read_adr_meassage(serversocket, print_or_not) time.sleep(pause) return