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
