def main(): print("you are using", platform.system(), platform.release(), os.name) # creating the central shared dgsn-node-data for all programs on the nodes ####################################### pathname = os.path.abspath(os.path.dirname(sys.argv[0])) pathname_all = "" for i in range(len(pathname.split(path_separator))-2): # creating the folders two folder levels above pathname_all = pathname_all + pathname.split(path_separator)[i] + path_separator pathname_save = pathname_all + "dgsn-node-data" pathname_config = pathname_all + "dgsn-hub-ops" # creating the dump folder for files and the needed data folders ####################################### if not os.path.exists(pathname_save): os.makedirs(pathname_save) folder = pathname_save + path_separator + "rec" subfolders = ["iq", "sdr", "gapped", "coded", "monitor"] if not os.path.exists(folder): os.makedirs(folder) if os.path.exists(folder): for i in range(len(subfolders)): if not os.path.exists(folder + path_separator + subfolders[i]): os.makedirs(folder + path_separator + subfolders[i]) if not os.path.exists(pathname_config): os.makedirs(pathname_config) pathname_config = pathname_config + path_separator + "io-radio" if not os.path.exists(pathname_config): os.makedirs(pathname_config) # setting the rtlsdr before the gain finding ##################################### # getting one file to each node very simple via github, or via a local file copy data = loading_config_file(pathname_config) # getting the specific settings for the node itself. perhaps it cannot be as fast as others with open(pathname + path_separator +'node-config.json') as data_file: data_node = json.load(data_file) device_number = data["device_number"] center_frequency = data["center_frequency"] samplerate = data["samplerate"] # this will be necessary in case a full fledged pc is a node or in case a micro pc is used with less RAM secondsofrecording = min(data["secondsofrecording"], data_node["secondsofrecording_maximum"]) print("record seconds commanded", data["secondsofrecording"], "record seconds maximum", data_node["secondsofrecording_maximum"], "and it is", secondsofrecording) nsamples = secondsofrecording * samplerate freq_correction = data["freq_correction"] user_hash = get_groundstationid() dt = datetime.datetime(data["recording_start"]["year"], data["recording_start"]["month"], data["recording_start"]["day"], data["recording_start"]["hour"], data["recording_start"]["minute"], data["recording_start"]["second"]) recording_start = time.mktime(dt.timetuple()) dt = datetime.datetime(data["recording_end"]["year"], data["recording_end"]["month"], data["recording_end"]["day"], data["recording_end"]["hour"], data["recording_end"]["minute"], data["recording_end"]["second"]) recording_stop = time.mktime(dt.timetuple()) # getting the data for calibration calibration_start = data["calibration_start"] gain_start = data["gain_start"] gain_end = data["gain_end"] gain_step = data["gain_step"] signal_threshold = data["signal_threshold"] print("gg", gain_start, gain_end) ################################## print("starting the fun...") if platform.system() == "Windows": print("detecting a windows") ############## device_count = librtlsdr.rtlsdr_get_device_count() print("number of rtl-sdr devices:", device_count) if device_count > 0: lock = Lock() jobs = [] gain = 0 calibration_finished = 0 # 1 means calibration is done while time.mktime(time.gmtime()) <= recording_start or calibration_finished == 0: # waiting for the time to be right :) time.sleep(10) print("still to wait", recording_start - time.mktime(time.gmtime()), "to record and", recording_start - time.mktime(time.gmtime())- calibration_start, "to calibration") if time.mktime(time.gmtime()) > recording_start - calibration_start and calibration_finished == 0: sdr = RtlSdr(device_index=device_number) sdr.center_freq = center_frequency sdr.sample_rate = samplerate # sdr.freq_correction = 1 # PPM # calibrating the dongle if gain_start >= gain_end or gain_start >= 49.0: print("fixed gain") if gain_start==0 or gain_start > 49.0: print("autogain") gain = 'auto' else: gain = gain_start else: print("calibrated gain") gain = calibrating_gain_with_windows(sdr, samplerate, gain_step, gain_start, gain_end, signal_threshold) print("used gain", gain) sdr.gain = gain sdr.close() calibration_finished = 1 utctime = time.mktime(time.gmtime()) if utctime >= recording_start and utctime <= recording_stop: print("recording starts now...") for recs in range(2): p = Process(target=storing_stream_with_windows, args=(lock, device_number, folder, subfolders, center_frequency, samplerate, gain, nsamples, freq_correction, user_hash)) jobs.append(p) p.start() print("end") while time.mktime(time.gmtime()) <= recording_stop: time.sleep(2) for n, p in enumerate(jobs): if not p.is_alive() and time.mktime(time.gmtime()) <= recording_stop: jobs.pop(n) recs += 1 p = Process(target=storing_stream_with_windows, args=(lock, device_number, folder, subfolders, center_frequency, samplerate, gain, nsamples, freq_correction, user_hash)) jobs.append(p) p.start() print("rec number", recs, 'added') for job in jobs: job.join() elif platform.system() == "Linux" or platform.system() == "Linux2": print("detecting a linux") # getNumber_of_rtlsdrs_with_linux() gain = 0 calibration_finished = 0 while time.mktime(time.gmtime()) <= recording_start or calibration_finished == 0: # waiting for the time to be right :) time.sleep(10) print("still to wait", recording_start - time.mktime(time.gmtime()), "to record and", recording_start - time.mktime(time.gmtime())- calibration_start, "to calibration") if time.mktime(time.gmtime()) > recording_start - calibration_start and calibration_finished == 0: if gain_start >= gain_end or gain_start >= 49.0: print("fixed gain") if gain_start==0 or gain_start > 49.0: print("autogain") gain = 0 else: gain = gain_start else: print("calibrated gain") gain = calibrating_gain_with_linux(device_number, center_frequency, samplerate, gain_step, gain_start, gain_end, signal_threshold) print("used gain", gain) calibration_finished = 1 utctime = time.mktime(time.gmtime()) if utctime >= recording_start and utctime <= recording_stop: print("recording starts now...") rtl_sdr_exe = "rtl_sdr" sdr = Popen([rtl_sdr_exe, "-d", str(device_number), "-f", str(center_frequency), "-s", str(samplerate), "-g", str(gain), "-p", str(freq_correction), "-"], stdout=PIPE, stderr=None) while time.mktime(time.gmtime()) <= recording_stop: stream_data = sdr.stdout.read(nsamples*2) storing_stream_with_linux(stream_data, device_number, folder, subfolders, center_frequency, samplerate, gain, nsamples, freq_correction, user_hash) sdr.kill() print("it's done. thank you, please come back again!")