From 6a063956b45736e73efa083c888881133a9d6cb0 Mon Sep 17 00:00:00 2001 From: Manolis Surligas Date: Sun, 24 Jul 2016 21:51:36 +0300 Subject: [PATCH] Add CLI UPSAT transceiver flowgraph --- apps/CMakeLists.txt | 1 + apps/flowgraphs/upsat_transceiver_cli.grc | 4441 +++++++++++++++++++++ apps/flowgraphs/upsat_transceiver_cli.py | 338 ++ examples/morse_decoding_flowgraph.grc | 70 +- python/hw_settings.py | 25 +- 5 files changed, 4834 insertions(+), 41 deletions(-) create mode 100644 apps/flowgraphs/upsat_transceiver_cli.grc create mode 100755 apps/flowgraphs/upsat_transceiver_cli.py diff --git a/apps/CMakeLists.txt b/apps/CMakeLists.txt index c837d77..26a9f2c 100644 --- a/apps/CMakeLists.txt +++ b/apps/CMakeLists.txt @@ -21,5 +21,6 @@ include(GrPython) GR_PYTHON_INSTALL( PROGRAMS + flowgraphs/upsat_transceiver_cli.py DESTINATION bin ) diff --git a/apps/flowgraphs/upsat_transceiver_cli.grc b/apps/flowgraphs/upsat_transceiver_cli.grc new file mode 100644 index 0000000..1e23a31 --- /dev/null +++ b/apps/flowgraphs/upsat_transceiver_cli.grc @@ -0,0 +1,4441 @@ + + + + Fri Jul 1 17:53:00 2016 + + options + + author + Manolis Surligas (surligas@gmail.com) + + + window_size + 1768,1080 + + + category + Custom + + + comment + + + + description + SATNOGS transceiver for UPSAT satellite + + + _enabled + True + + + _coordinate + (8, 8) + + + _rotation + 0 + + + generate_options + no_gui + + + hier_block_src_path + .: + + + id + upsat_transceiver_cli + + + max_nouts + 0 + + + qt_qss_theme + + + + realtime_scheduling + + + + run_command + {python} -u {filename} + + + run_options + prompt + + + run + True + + + thread_safe_setters + + + + title + + + + + variable + + comment + FSK baud rate + + + _enabled + True + + + _coordinate + (1048, 13) + + + _rotation + 0 + + + id + baud_rate + + + value + 9600 + + + + variable + + comment + Decimation factor +for the RX after the +SDR received samples + + + _enabled + True + + + _coordinate + (752, 13) + + + _rotation + 0 + + + id + decimation_rx + + + value + 20 + + + + variable + + comment + The FSK frequency deviation + + + _enabled + True + + + _coordinate + (888, 13) + + + _rotation + 0 + + + id + deviation + + + value + 3.9973e3 + + + + variable + + comment + + + + _enabled + True + + + _coordinate + (168, 925) + + + _rotation + 0 + + + id + first_stage_samp_rate_rx + + + value + samp_rate_rx / decimation_rx + + + + variable + + comment + + + + _enabled + True + + + _coordinate + (16, 901) + + + _rotation + 0 + + + id + gaussian_taps + + + value + filter.firdes.gaussian(1.0, samples_per_symbol_tx, 1.0, 4*samples_per_symbol_tx) + + + + variable + + comment + + + + _enabled + 1 + + + _coordinate + (168, 981) + + + _rotation + 0 + + + id + interp_taps + + + value + numpy.convolve(numpy.array(gaussian_taps), numpy.array(sq_wave)) + + + + variable + + comment + + + + _enabled + True + + + _coordinate + (416, 13) + + + _rotation + 0 + + + id + modulation_index + + + value + deviation / (baud_rate / 2.0) + + + + variable + + comment + The RX center frequency + of the system + + + _enabled + True + + + _coordinate + (1296, 13) + + + _rotation + 0 + + + id + rx_frequency + + + value + 435.765e6 + + + + variable + + comment + SDR device +TX sampling rate + + + _enabled + True + + + _coordinate + (672, 917) + + + _rotation + 0 + + + id + samp_rate_rx + + + value + satnogs.hw_rx_settings[rx_sdr_device]['samp_rate'] + + + + variable + + comment + SDR device +TX sampling rate + + + _enabled + True + + + _coordinate + (672, 805) + + + _rotation + 0 + + + id + samp_rate_tx + + + value + satnogs.hw_tx_settings[rx_sdr_device]['samp_rate'] + + + + variable + + comment + Samples per FSK symbol. +Should be changed only for better +spectrum mask, or if the resampling +is too great and becomes a bottlneck. + + + _enabled + True + + + _coordinate + (536, 13) + + + _rotation + 0 + + + id + samples_per_symbol_tx + + + value + 4*8 + + + + variable + + comment + + + + _enabled + 1 + + + _coordinate + (16, 981) + + + _rotation + 0 + + + id + sq_wave + + + value + (1.0, ) * samples_per_symbol_tx + + + + variable_low_pass_filter_taps + + beta + 6.76 + + + comment + + + + cutoff_freq + 20000 + + + _enabled + 1 + + + _coordinate + (16, 762) + + + _rotation + 0 + + + gain + 1.0 + + + id + taps + + + samp_rate + samp_rate_rx + + + width + 60000 + + + win + firdes.WIN_HAMMING + + + + variable + + comment + The TX center frequency + of the system + + + _enabled + True + + + _coordinate + (1144, 13) + + + _rotation + 0 + + + id + tx_frequency + + + value + 145.835e6 + + + + analog_frequency_modulator_fc + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (792, 228) + + + _rotation + 0 + + + id + analog_frequency_modulator_fc_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + sensitivity + (math.pi*modulation_index) / samples_per_symbol_tx + + + + analog_quadrature_demod_cf + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (552, 524) + + + _rotation + 0 + + + gain + ((first_stage_samp_rate_rx) / baud_rate)/(math.pi*modulation_index) + + + id + analog_quadrature_demod_cf_0_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + + analog_sig_source_x + + amp + 1 + + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + freq + lo_offset + + + _coordinate + (952, 272) + + + _rotation + 180 + + + id + analog_sig_source_x_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + offset + 0 + + + type + complex + + + samp_rate + samp_rate_tx + + + waveform + analog.GR_COS_WAVE + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (248, 774) + + + _rotation + 0 + + + id + bind_addr + + + label + + + + short_id + + + + type + string + + + value + 0.0.0.0 + + + + blocks_multiply_xx + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (832, 352) + + + _rotation + 180 + + + id + blocks_multiply_xx_0 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + num_inputs + 2 + + + vlen + 1 + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (248, 846) + + + _rotation + 0 + + + id + dest_addr + + + label + + + + short_id + + + + type + string + + + value + 127.0.0.1 + + + + digital_binary_slicer_fb + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (944, 528) + + + _rotation + 0 + + + id + digital_binary_slicer_fb_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + + digital_clock_recovery_mm_xx + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (736, 496) + + + _rotation + 0 + + + gain_mu + 0.175 + + + gain_omega + 0.25*0.175*0.175 + + + id + digital_clock_recovery_mm_xx_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + mu + 0.5 + + + omega_relative_limit + 0.005 + + + omega + first_stage_samp_rate_rx/baud_rate + + + type + float + + + + freq_xlating_fir_filter_xxx + + alias + + + + center_freq + lo_offset + + + comment + + + + affinity + + + + decim + decimation_rx + + + _enabled + 1 + + + _coordinate + (304, 503) + + + _rotation + 0 + + + id + freq_xlating_fir_filter_xxx_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + samp_rate + samp_rate_rx + + + taps + taps + + + type + ccc + + + + import + + alias + + + + comment + + + + _enabled + 1 + + + _coordinate + (184, 60) + + + _rotation + 0 + + + id + import_0 + + + import + import numpy + + + + import + + alias + + + + comment + + + + _enabled + 1 + + + _coordinate + (184, 12) + + + _rotation + 0 + + + id + import_0_0 + + + import + import math + + + + import + + alias + + + + comment + + + + _enabled + 1 + + + _coordinate + (184, 108) + + + _rotation + 0 + + + id + import_0_1 + + + import + from gnuradio import filter + + + + interp_fir_filter_xxx + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (592, 221) + + + _rotation + 0 + + + id + interp_fir_filter_xxx_0 + + + interp + samples_per_symbol_tx + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + samp_delay + 0 + + + taps + interp_taps + + + type + fff + + + + parameter + + alias + + + + comment + To avoid the SDR carrier at the DC +we shift the LO a little further + + + _enabled + True + + + _coordinate + (360, 774) + + + _rotation + 0 + + + id + lo_offset + + + label + + + + short_id + + + + type + eng_float + + + value + 100e3 + + + + osmosdr_sink + + alias + + + + ant0 + satnogs.hw_tx_settings[tx_sdr_device]['antenna'] + + + bb_gain0 + satnogs.hw_tx_settings[tx_sdr_device]['bb_gain'] + + + bw0 + samp_rate_tx + + + corr0 + 0 + + + freq0 + tx_frequency - lo_offset + + + if_gain0 + satnogs.hw_tx_settings[tx_sdr_device]['if_gain'] + + + gain0 + satnogs.hw_tx_settings[tx_sdr_device]['rf_gain'] + + + ant10 + + + + bb_gain10 + 20 + + + bw10 + 0 + + + corr10 + 0 + + + freq10 + 100e6 + + + if_gain10 + 20 + + + gain10 + 10 + + + ant11 + + + + bb_gain11 + 20 + + + bw11 + 0 + + + corr11 + 0 + + + freq11 + 100e6 + + + if_gain11 + 20 + + + gain11 + 10 + + + ant12 + + + + bb_gain12 + 20 + + + bw12 + 0 + + + corr12 + 0 + + + freq12 + 100e6 + + + if_gain12 + 20 + + + gain12 + 10 + + + ant13 + + + + bb_gain13 + 20 + + + bw13 + 0 + + + corr13 + 0 + + + freq13 + 100e6 + + + if_gain13 + 20 + + + gain13 + 10 + + + ant14 + + + + bb_gain14 + 20 + + + bw14 + 0 + + + corr14 + 0 + + + freq14 + 100e6 + + + if_gain14 + 20 + + + gain14 + 10 + + + ant15 + + + + bb_gain15 + 20 + + + bw15 + 0 + + + corr15 + 0 + + + freq15 + 100e6 + + + if_gain15 + 20 + + + gain15 + 10 + + + ant16 + + + + bb_gain16 + 20 + + + bw16 + 0 + + + corr16 + 0 + + + freq16 + 100e6 + + + if_gain16 + 20 + + + gain16 + 10 + + + ant17 + + + + bb_gain17 + 20 + + + bw17 + 0 + + + corr17 + 0 + + + freq17 + 100e6 + + + if_gain17 + 20 + + + gain17 + 10 + + + ant18 + + + + bb_gain18 + 20 + + + bw18 + 0 + + + corr18 + 0 + + + freq18 + 100e6 + + + if_gain18 + 20 + + + gain18 + 10 + + + ant19 + + + + bb_gain19 + 20 + + + bw19 + 0 + + + corr19 + 0 + + + freq19 + 100e6 + + + if_gain19 + 20 + + + gain19 + 10 + + + ant1 + + + + bb_gain1 + 20 + + + bw1 + 0 + + + corr1 + 0 + + + freq1 + 100e6 + + + if_gain1 + 20 + + + gain1 + 10 + + + ant20 + + + + bb_gain20 + 20 + + + bw20 + 0 + + + corr20 + 0 + + + freq20 + 100e6 + + + if_gain20 + 20 + + + gain20 + 10 + + + ant21 + + + + bb_gain21 + 20 + + + bw21 + 0 + + + corr21 + 0 + + + freq21 + 100e6 + + + if_gain21 + 20 + + + gain21 + 10 + + + ant22 + + + + bb_gain22 + 20 + + + bw22 + 0 + + + corr22 + 0 + + + freq22 + 100e6 + + + if_gain22 + 20 + + + gain22 + 10 + + + ant23 + + + + bb_gain23 + 20 + + + bw23 + 0 + + + corr23 + 0 + + + freq23 + 100e6 + + + if_gain23 + 20 + + + gain23 + 10 + + + ant24 + + + + bb_gain24 + 20 + + + bw24 + 0 + + + corr24 + 0 + + + freq24 + 100e6 + + + if_gain24 + 20 + + + gain24 + 10 + + + ant25 + + + + bb_gain25 + 20 + + + bw25 + 0 + + + corr25 + 0 + + + freq25 + 100e6 + + + if_gain25 + 20 + + + gain25 + 10 + + + ant26 + + + + bb_gain26 + 20 + + + bw26 + 0 + + + corr26 + 0 + + + freq26 + 100e6 + + + if_gain26 + 20 + + + gain26 + 10 + + + ant27 + + + + bb_gain27 + 20 + + + bw27 + 0 + + + corr27 + 0 + + + freq27 + 100e6 + + + if_gain27 + 20 + + + gain27 + 10 + + + ant28 + + + + bb_gain28 + 20 + + + bw28 + 0 + + + corr28 + 0 + + + freq28 + 100e6 + + + if_gain28 + 20 + + + gain28 + 10 + + + ant29 + + + + bb_gain29 + 20 + + + bw29 + 0 + + + corr29 + 0 + + + freq29 + 100e6 + + + if_gain29 + 20 + + + gain29 + 10 + + + ant2 + + + + bb_gain2 + 20 + + + bw2 + 0 + + + corr2 + 0 + + + freq2 + 100e6 + + + if_gain2 + 20 + + + gain2 + 10 + + + ant30 + + + + bb_gain30 + 20 + + + bw30 + 0 + + + corr30 + 0 + + + freq30 + 100e6 + + + if_gain30 + 20 + + + gain30 + 10 + + + ant31 + + + + bb_gain31 + 20 + + + bw31 + 0 + + + corr31 + 0 + + + freq31 + 100e6 + + + if_gain31 + 20 + + + gain31 + 10 + + + ant3 + + + + bb_gain3 + 20 + + + bw3 + 0 + + + corr3 + 0 + + + freq3 + 100e6 + + + if_gain3 + 20 + + + gain3 + 10 + + + ant4 + + + + bb_gain4 + 20 + + + bw4 + 0 + + + corr4 + 0 + + + freq4 + 100e6 + + + if_gain4 + 20 + + + gain4 + 10 + + + ant5 + + + + bb_gain5 + 20 + + + bw5 + 0 + + + corr5 + 0 + + + freq5 + 100e6 + + + if_gain5 + 20 + + + gain5 + 10 + + + ant6 + + + + bb_gain6 + 20 + + + bw6 + 0 + + + corr6 + 0 + + + freq6 + 100e6 + + + if_gain6 + 20 + + + gain6 + 10 + + + ant7 + + + + bb_gain7 + 20 + + + bw7 + 0 + + + corr7 + 0 + + + freq7 + 100e6 + + + if_gain7 + 20 + + + gain7 + 10 + + + ant8 + + + + bb_gain8 + 20 + + + bw8 + 0 + + + corr8 + 0 + + + freq8 + 100e6 + + + if_gain8 + 20 + + + gain8 + 10 + + + ant9 + + + + bb_gain9 + 20 + + + bw9 + 0 + + + corr9 + 0 + + + freq9 + 100e6 + + + if_gain9 + 20 + + + gain9 + 10 + + + comment + + + + affinity + + + + args + + + + _enabled + 1 + + + _coordinate + (544, 315) + + + _rotation + 180 + + + id + osmosdr_sink_0 + + + type + fc32 + + + clock_source0 + + + + time_source0 + + + + clock_source1 + + + + time_source1 + + + + clock_source2 + + + + time_source2 + + + + clock_source3 + + + + time_source3 + + + + clock_source4 + + + + time_source4 + + + + clock_source5 + + + + time_source5 + + + + clock_source6 + + + + time_source6 + + + + clock_source7 + + + + time_source7 + + + + nchan + 1 + + + num_mboards + 1 + + + sample_rate + samp_rate_tx + + + sync + + + + + osmosdr_source + + alias + + + + ant0 + satnogs.hw_rx_settings[rx_sdr_device]['antenna'] + + + bb_gain0 + satnogs.hw_rx_settings[rx_sdr_device]['bb_gain'] + + + bw0 + samp_rate_rx + + + dc_offset_mode0 + 0 + + + corr0 + 0 + + + freq0 + rx_frequency - lo_offset + + + gain_mode0 + False + + + if_gain0 + satnogs.hw_rx_settings[rx_sdr_device]['if_gain'] + + + iq_balance_mode0 + 0 + + + gain0 + satnogs.hw_rx_settings[rx_sdr_device]['rf_gain'] + + + ant10 + + + + bb_gain10 + 20 + + + bw10 + 0 + + + dc_offset_mode10 + 0 + + + corr10 + 0 + + + freq10 + 100e6 + + + gain_mode10 + False + + + if_gain10 + 20 + + + iq_balance_mode10 + 0 + + + gain10 + 10 + + + ant11 + + + + bb_gain11 + 20 + + + bw11 + 0 + + + dc_offset_mode11 + 0 + + + corr11 + 0 + + + freq11 + 100e6 + + + gain_mode11 + False + + + if_gain11 + 20 + + + iq_balance_mode11 + 0 + + + gain11 + 10 + + + ant12 + + + + bb_gain12 + 20 + + + bw12 + 0 + + + dc_offset_mode12 + 0 + + + corr12 + 0 + + + freq12 + 100e6 + + + gain_mode12 + False + + + if_gain12 + 20 + + + iq_balance_mode12 + 0 + + + gain12 + 10 + + + ant13 + + + + bb_gain13 + 20 + + + bw13 + 0 + + + dc_offset_mode13 + 0 + + + corr13 + 0 + + + freq13 + 100e6 + + + gain_mode13 + False + + + if_gain13 + 20 + + + iq_balance_mode13 + 0 + + + gain13 + 10 + + + ant14 + + + + bb_gain14 + 20 + + + bw14 + 0 + + + dc_offset_mode14 + 0 + + + corr14 + 0 + + + freq14 + 100e6 + + + gain_mode14 + False + + + if_gain14 + 20 + + + iq_balance_mode14 + 0 + + + gain14 + 10 + + + ant15 + + + + bb_gain15 + 20 + + + bw15 + 0 + + + dc_offset_mode15 + 0 + + + corr15 + 0 + + + freq15 + 100e6 + + + gain_mode15 + False + + + if_gain15 + 20 + + + iq_balance_mode15 + 0 + + + gain15 + 10 + + + ant16 + + + + bb_gain16 + 20 + + + bw16 + 0 + + + dc_offset_mode16 + 0 + + + corr16 + 0 + + + freq16 + 100e6 + + + gain_mode16 + False + + + if_gain16 + 20 + + + iq_balance_mode16 + 0 + + + gain16 + 10 + + + ant17 + + + + bb_gain17 + 20 + + + bw17 + 0 + + + dc_offset_mode17 + 0 + + + corr17 + 0 + + + freq17 + 100e6 + + + gain_mode17 + False + + + if_gain17 + 20 + + + iq_balance_mode17 + 0 + + + gain17 + 10 + + + ant18 + + + + bb_gain18 + 20 + + + bw18 + 0 + + + dc_offset_mode18 + 0 + + + corr18 + 0 + + + freq18 + 100e6 + + + gain_mode18 + False + + + if_gain18 + 20 + + + iq_balance_mode18 + 0 + + + gain18 + 10 + + + ant19 + + + + bb_gain19 + 20 + + + bw19 + 0 + + + dc_offset_mode19 + 0 + + + corr19 + 0 + + + freq19 + 100e6 + + + gain_mode19 + False + + + if_gain19 + 20 + + + iq_balance_mode19 + 0 + + + gain19 + 10 + + + ant1 + + + + bb_gain1 + 20 + + + bw1 + 0 + + + dc_offset_mode1 + 0 + + + corr1 + 0 + + + freq1 + 100e6 + + + gain_mode1 + False + + + if_gain1 + 20 + + + iq_balance_mode1 + 0 + + + gain1 + 10 + + + ant20 + + + + bb_gain20 + 20 + + + bw20 + 0 + + + dc_offset_mode20 + 0 + + + corr20 + 0 + + + freq20 + 100e6 + + + gain_mode20 + False + + + if_gain20 + 20 + + + iq_balance_mode20 + 0 + + + gain20 + 10 + + + ant21 + + + + bb_gain21 + 20 + + + bw21 + 0 + + + dc_offset_mode21 + 0 + + + corr21 + 0 + + + freq21 + 100e6 + + + gain_mode21 + False + + + if_gain21 + 20 + + + iq_balance_mode21 + 0 + + + gain21 + 10 + + + ant22 + + + + bb_gain22 + 20 + + + bw22 + 0 + + + dc_offset_mode22 + 0 + + + corr22 + 0 + + + freq22 + 100e6 + + + gain_mode22 + False + + + if_gain22 + 20 + + + iq_balance_mode22 + 0 + + + gain22 + 10 + + + ant23 + + + + bb_gain23 + 20 + + + bw23 + 0 + + + dc_offset_mode23 + 0 + + + corr23 + 0 + + + freq23 + 100e6 + + + gain_mode23 + False + + + if_gain23 + 20 + + + iq_balance_mode23 + 0 + + + gain23 + 10 + + + ant24 + + + + bb_gain24 + 20 + + + bw24 + 0 + + + dc_offset_mode24 + 0 + + + corr24 + 0 + + + freq24 + 100e6 + + + gain_mode24 + False + + + if_gain24 + 20 + + + iq_balance_mode24 + 0 + + + gain24 + 10 + + + ant25 + + + + bb_gain25 + 20 + + + bw25 + 0 + + + dc_offset_mode25 + 0 + + + corr25 + 0 + + + freq25 + 100e6 + + + gain_mode25 + False + + + if_gain25 + 20 + + + iq_balance_mode25 + 0 + + + gain25 + 10 + + + ant26 + + + + bb_gain26 + 20 + + + bw26 + 0 + + + dc_offset_mode26 + 0 + + + corr26 + 0 + + + freq26 + 100e6 + + + gain_mode26 + False + + + if_gain26 + 20 + + + iq_balance_mode26 + 0 + + + gain26 + 10 + + + ant27 + + + + bb_gain27 + 20 + + + bw27 + 0 + + + dc_offset_mode27 + 0 + + + corr27 + 0 + + + freq27 + 100e6 + + + gain_mode27 + False + + + if_gain27 + 20 + + + iq_balance_mode27 + 0 + + + gain27 + 10 + + + ant28 + + + + bb_gain28 + 20 + + + bw28 + 0 + + + dc_offset_mode28 + 0 + + + corr28 + 0 + + + freq28 + 100e6 + + + gain_mode28 + False + + + if_gain28 + 20 + + + iq_balance_mode28 + 0 + + + gain28 + 10 + + + ant29 + + + + bb_gain29 + 20 + + + bw29 + 0 + + + dc_offset_mode29 + 0 + + + corr29 + 0 + + + freq29 + 100e6 + + + gain_mode29 + False + + + if_gain29 + 20 + + + iq_balance_mode29 + 0 + + + gain29 + 10 + + + ant2 + + + + bb_gain2 + 20 + + + bw2 + 0 + + + dc_offset_mode2 + 0 + + + corr2 + 0 + + + freq2 + 100e6 + + + gain_mode2 + False + + + if_gain2 + 20 + + + iq_balance_mode2 + 0 + + + gain2 + 10 + + + ant30 + + + + bb_gain30 + 20 + + + bw30 + 0 + + + dc_offset_mode30 + 0 + + + corr30 + 0 + + + freq30 + 100e6 + + + gain_mode30 + False + + + if_gain30 + 20 + + + iq_balance_mode30 + 0 + + + gain30 + 10 + + + ant31 + + + + bb_gain31 + 20 + + + bw31 + 0 + + + dc_offset_mode31 + 0 + + + corr31 + 0 + + + freq31 + 100e6 + + + gain_mode31 + False + + + if_gain31 + 20 + + + iq_balance_mode31 + 0 + + + gain31 + 10 + + + ant3 + + + + bb_gain3 + 20 + + + bw3 + 0 + + + dc_offset_mode3 + 0 + + + corr3 + 0 + + + freq3 + 100e6 + + + gain_mode3 + False + + + if_gain3 + 20 + + + iq_balance_mode3 + 0 + + + gain3 + 10 + + + ant4 + + + + bb_gain4 + 20 + + + bw4 + 0 + + + dc_offset_mode4 + 0 + + + corr4 + 0 + + + freq4 + 100e6 + + + gain_mode4 + False + + + if_gain4 + 20 + + + iq_balance_mode4 + 0 + + + gain4 + 10 + + + ant5 + + + + bb_gain5 + 20 + + + bw5 + 0 + + + dc_offset_mode5 + 0 + + + corr5 + 0 + + + freq5 + 100e6 + + + gain_mode5 + False + + + if_gain5 + 20 + + + iq_balance_mode5 + 0 + + + gain5 + 10 + + + ant6 + + + + bb_gain6 + 20 + + + bw6 + 0 + + + dc_offset_mode6 + 0 + + + corr6 + 0 + + + freq6 + 100e6 + + + gain_mode6 + False + + + if_gain6 + 20 + + + iq_balance_mode6 + 0 + + + gain6 + 10 + + + ant7 + + + + bb_gain7 + 20 + + + bw7 + 0 + + + dc_offset_mode7 + 0 + + + corr7 + 0 + + + freq7 + 100e6 + + + gain_mode7 + False + + + if_gain7 + 20 + + + iq_balance_mode7 + 0 + + + gain7 + 10 + + + ant8 + + + + bb_gain8 + 20 + + + bw8 + 0 + + + dc_offset_mode8 + 0 + + + corr8 + 0 + + + freq8 + 100e6 + + + gain_mode8 + False + + + if_gain8 + 20 + + + iq_balance_mode8 + 0 + + + gain8 + 10 + + + ant9 + + + + bb_gain9 + 20 + + + bw9 + 0 + + + dc_offset_mode9 + 0 + + + corr9 + 0 + + + freq9 + 100e6 + + + gain_mode9 + False + + + if_gain9 + 20 + + + iq_balance_mode9 + 0 + + + gain9 + 10 + + + comment + + + + affinity + + + + args + + + + _enabled + 1 + + + _coordinate + (64, 438) + + + _rotation + 0 + + + id + osmosdr_source_0 + + + maxoutbuf + 0 + + + clock_source0 + + + + time_source0 + + + + clock_source1 + + + + time_source1 + + + + clock_source2 + + + + time_source2 + + + + clock_source3 + + + + time_source3 + + + + clock_source4 + + + + time_source4 + + + + clock_source5 + + + + time_source5 + + + + clock_source6 + + + + time_source6 + + + + clock_source7 + + + + time_source7 + + + + minoutbuf + 0 + + + nchan + 1 + + + num_mboards + 1 + + + type + fc32 + + + sample_rate + samp_rate_rx + + + sync + + + + + pfb_arb_resampler_xxx + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (1080, 359) + + + _rotation + 180 + + + id + pfb_arb_resampler_xxx_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + nfilts + 32 + + + rrate + samp_rate_tx / (baud_rate * samples_per_symbol_tx) + + + samp_delay + 0 + + + atten + 60 + + + taps + firdes.low_pass_2(32, 32, 0.8, 0.1, 60) + + + type + ccf + + + + qtgui_freq_sink_x + + autoscale + False + + + average + 1.0 + + + bw + samp_rate_rx/decimation_rx + + + alias + + + + fc + 0 + + + comment + + + + ctrlpanel + True + + + affinity + + + + _enabled + 0 + + + fftsize + 1024 + + + _coordinate + (312, 406) + + + gui_hint + + + + _rotation + 180 + + + grid + True + + + id + qtgui_freq_sink_x_0 + + + legend + True + + + alpha1 + 1.0 + + + color1 + "blue" + + + label1 + + + + width1 + 1 + + + alpha10 + 1.0 + + + color10 + "dark blue" + + + label10 + + + + width10 + 1 + + + alpha2 + 1.0 + + + color2 + "red" + + + label2 + + + + width2 + 1 + + + alpha3 + 1.0 + + + color3 + "green" + + + label3 + + + + width3 + 1 + + + alpha4 + 1.0 + + + color4 + "black" + + + label4 + + + + width4 + 1 + + + alpha5 + 1.0 + + + color5 + "cyan" + + + label5 + + + + width5 + 1 + + + alpha6 + 1.0 + + + color6 + "magenta" + + + label6 + + + + width6 + 1 + + + alpha7 + 1.0 + + + color7 + "yellow" + + + label7 + + + + width7 + 1 + + + alpha8 + 1.0 + + + color8 + "dark red" + + + label8 + + + + width8 + 1 + + + alpha9 + 1.0 + + + color9 + "dark green" + + + label9 + + + + width9 + 1 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + name + "" + + + nconnections + 1 + + + showports + True + + + freqhalf + True + + + tr_chan + 0 + + + tr_level + 0.0 + + + tr_mode + qtgui.TRIG_MODE_FREE + + + tr_tag + "" + + + type + complex + + + update_time + 0.01 + + + wintype + firdes.WIN_BLACKMAN_hARRIS + + + ymax + 0 + + + ymin + -140 + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (160, 774) + + + _rotation + 0 + + + id + recv_port + + + label + + + + short_id + + + + type + intx + + + value + 16886 + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (560, 902) + + + _rotation + 0 + + + id + rx_sdr_device + + + label + + + + short_id + + + + type + string + + + value + usrpb200 + + + + satnogs_ax25_decoder_bm + + alias + + + + comment + + + + affinity + + + + _enabled + True + + + descrambling + True + + + _coordinate + (1176, 568) + + + _rotation + 180 + + + id + satnogs_ax25_decoder_bm_0 + + + maxoutbuf + 0 + + + max_frame_len + 256 + + + minoutbuf + 0 + + + promisc + False + + + addr + 'GND' + + + ssid + 0 + + + + satnogs_multi_format_msg_sink + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (920, 684) + + + _rotation + 180 + + + id + satnogs_multi_format_msg_sink_0_0 + + + format + 1 + + + + satnogs_udp_msg_sink + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (936, 598) + + + _rotation + 180 + + + id + satnogs_udp_msg_sink_0_0 + + + addr + dest_addr + + + mtu + 1500 + + + port + send_port + + + + satnogs_udp_msg_source + + alias + + + + comment + The transmitter can also receive payloads +from a UDP source. Use netcat or something +similar to produce dynamic payloads. + + + affinity + + + + _enabled + 1 + + + _coordinate + (0, 214) + + + _rotation + 0 + + + id + satnogs_udp_msg_source_0 + + + addr + bind_addr + + + mtu + 1500 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + port + recv_port + + + + satnogs_upsat_fsk_frame_encoder + + append_crc + False + + + alias + + + + comment + + + + affinity + + + + dest_addr + ON02GR + + + dest_ssid + 0 + + + _enabled + 1 + + + preamble + [0x33]*8 + + + _coordinate + (304, 151) + + + _rotation + 0 + + + id + satnogs_upsat_fsk_frame_encoder_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + settling_samples + 64 + + + msb_first + True + + + src_addr + ABCD + + + src_ssid + 0 + + + sync_word + [0x7A, 0x0E] + + + ax_25 + True + + + manchester + False + + + whitening + False + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (160, 846) + + + _rotation + 0 + + + id + send_port + + + label + + + + short_id + + + + type + intx + + + value + 5022 + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (560, 806) + + + _rotation + 0 + + + id + tx_sdr_device + + + label + + + + short_id + + + + type + string + + + value + usrpb200 + + + + analog_frequency_modulator_fc_0 + pfb_arb_resampler_xxx_0 + 0 + 0 + + + analog_quadrature_demod_cf_0_0 + digital_clock_recovery_mm_xx_0 + 0 + 0 + + + analog_sig_source_x_0 + blocks_multiply_xx_0 + 0 + 1 + + + blocks_multiply_xx_0 + osmosdr_sink_0 + 0 + 0 + + + digital_binary_slicer_fb_0 + satnogs_ax25_decoder_bm_0 + 0 + 0 + + + digital_clock_recovery_mm_xx_0 + digital_binary_slicer_fb_0 + 0 + 0 + + + freq_xlating_fir_filter_xxx_0 + analog_quadrature_demod_cf_0_0 + 0 + 0 + + + freq_xlating_fir_filter_xxx_0 + qtgui_freq_sink_x_0 + 0 + 0 + + + interp_fir_filter_xxx_0 + analog_frequency_modulator_fc_0 + 0 + 0 + + + osmosdr_source_0 + freq_xlating_fir_filter_xxx_0 + 0 + 0 + + + pfb_arb_resampler_xxx_0 + blocks_multiply_xx_0 + 0 + 0 + + + satnogs_ax25_decoder_bm_0 + satnogs_multi_format_msg_sink_0_0 + pdu + in + + + satnogs_ax25_decoder_bm_0 + satnogs_udp_msg_sink_0_0 + pdu + in + + + satnogs_udp_msg_source_0 + satnogs_upsat_fsk_frame_encoder_0 + msg + pdu + + + satnogs_upsat_fsk_frame_encoder_0 + interp_fir_filter_xxx_0 + 0 + 0 + + diff --git a/apps/flowgraphs/upsat_transceiver_cli.py b/apps/flowgraphs/upsat_transceiver_cli.py new file mode 100755 index 0000000..c2d74b5 --- /dev/null +++ b/apps/flowgraphs/upsat_transceiver_cli.py @@ -0,0 +1,338 @@ +#!/usr/bin/env python2 +# -*- coding: utf-8 -*- +################################################## +# GNU Radio Python Flow Graph +# Title: Upsat Transceiver Cli +# Author: Manolis Surligas (surligas@gmail.com) +# Description: SATNOGS transceiver for UPSAT satellite +# Generated: Sun Jul 24 21:44:09 2016 +################################################## + +from gnuradio import analog +from gnuradio import blocks +from gnuradio import digital +from gnuradio import eng_notation +from gnuradio import filter +from gnuradio import gr +from gnuradio.eng_option import eng_option +from gnuradio.filter import firdes +from gnuradio.filter import pfb +from optparse import OptionParser +import math +import numpy +import osmosdr +import satnogs +import time + + +class upsat_transceiver_cli(gr.top_block): + + def __init__(self, bind_addr="0.0.0.0", dest_addr="127.0.0.1", lo_offset=100e3, recv_port=16886, rx_sdr_device="usrpb200", send_port=5022, tx_sdr_device="usrpb200"): + gr.top_block.__init__(self, "Upsat Transceiver Cli") + + ################################################## + # Parameters + ################################################## + self.bind_addr = bind_addr + self.dest_addr = dest_addr + self.lo_offset = lo_offset + self.recv_port = recv_port + self.rx_sdr_device = rx_sdr_device + self.send_port = send_port + self.tx_sdr_device = tx_sdr_device + + ################################################## + # Variables + ################################################## + self.samples_per_symbol_tx = samples_per_symbol_tx = 4*8 + self.sq_wave = sq_wave = (1.0, ) * samples_per_symbol_tx + self.samp_rate_rx = samp_rate_rx = satnogs.hw_rx_settings[rx_sdr_device]['samp_rate'] + self.gaussian_taps = gaussian_taps = filter.firdes.gaussian(1.0, samples_per_symbol_tx, 1.0, 4*samples_per_symbol_tx) + self.deviation = deviation = 3.9973e3 + self.decimation_rx = decimation_rx = 20 + self.baud_rate = baud_rate = 9600 + self.tx_frequency = tx_frequency = 145.835e6 + + self.taps = taps = firdes.low_pass(1.0, samp_rate_rx, 20000, 60000, firdes.WIN_HAMMING, 6.76) + + self.samp_rate_tx = samp_rate_tx = satnogs.hw_tx_settings[rx_sdr_device]['samp_rate'] + self.rx_frequency = rx_frequency = 435.765e6 + self.modulation_index = modulation_index = deviation / (baud_rate / 2.0) + self.interp_taps = interp_taps = numpy.convolve(numpy.array(gaussian_taps), numpy.array(sq_wave)) + self.first_stage_samp_rate_rx = first_stage_samp_rate_rx = samp_rate_rx / decimation_rx + + ################################################## + # Blocks + ################################################## + self.satnogs_upsat_fsk_frame_encoder_0 = satnogs.upsat_fsk_frame_encoder([0x33]*8 , [0x7A, 0x0E], False, False, False, True, True, "ABCD", 0, "ON02GR", 0, 64) + self.satnogs_udp_msg_source_0 = satnogs.udp_msg_source(bind_addr, recv_port, 1500) + self.satnogs_udp_msg_sink_0_0 = satnogs.udp_msg_sink(dest_addr, send_port, 1500) + self.satnogs_multi_format_msg_sink_0_0 = satnogs.multi_format_msg_sink(1) + self.satnogs_ax25_decoder_bm_0 = satnogs.ax25_decoder_bm('GND', 0, False, True, 256) + self.pfb_arb_resampler_xxx_0 = pfb.arb_resampler_ccf( + samp_rate_tx / (baud_rate * samples_per_symbol_tx), + taps=(firdes.low_pass_2(32, 32, 0.8, 0.1, 60)), + flt_size=32) + self.pfb_arb_resampler_xxx_0.declare_sample_delay(0) + + self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "" ) + self.osmosdr_source_0.set_sample_rate(samp_rate_rx) + self.osmosdr_source_0.set_center_freq(rx_frequency - lo_offset, 0) + self.osmosdr_source_0.set_freq_corr(0, 0) + self.osmosdr_source_0.set_dc_offset_mode(0, 0) + self.osmosdr_source_0.set_iq_balance_mode(0, 0) + self.osmosdr_source_0.set_gain_mode(False, 0) + self.osmosdr_source_0.set_gain(satnogs.hw_rx_settings[rx_sdr_device]['rf_gain'], 0) + self.osmosdr_source_0.set_if_gain(satnogs.hw_rx_settings[rx_sdr_device]['if_gain'], 0) + self.osmosdr_source_0.set_bb_gain(satnogs.hw_rx_settings[rx_sdr_device]['bb_gain'], 0) + self.osmosdr_source_0.set_antenna(satnogs.hw_rx_settings[rx_sdr_device]['antenna'], 0) + self.osmosdr_source_0.set_bandwidth(samp_rate_rx, 0) + + self.osmosdr_sink_0 = osmosdr.sink( args="numchan=" + str(1) + " " + "" ) + self.osmosdr_sink_0.set_sample_rate(samp_rate_tx) + self.osmosdr_sink_0.set_center_freq(tx_frequency - lo_offset, 0) + self.osmosdr_sink_0.set_freq_corr(0, 0) + self.osmosdr_sink_0.set_gain(satnogs.hw_tx_settings[tx_sdr_device]['rf_gain'], 0) + self.osmosdr_sink_0.set_if_gain(satnogs.hw_tx_settings[tx_sdr_device]['if_gain'], 0) + self.osmosdr_sink_0.set_bb_gain(satnogs.hw_tx_settings[tx_sdr_device]['bb_gain'], 0) + self.osmosdr_sink_0.set_antenna(satnogs.hw_tx_settings[tx_sdr_device]['antenna'], 0) + self.osmosdr_sink_0.set_bandwidth(samp_rate_tx, 0) + + self.interp_fir_filter_xxx_0 = filter.interp_fir_filter_fff(samples_per_symbol_tx, (interp_taps)) + self.interp_fir_filter_xxx_0.declare_sample_delay(0) + self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(decimation_rx, (taps), lo_offset, samp_rate_rx) + self.digital_clock_recovery_mm_xx_0 = digital.clock_recovery_mm_ff(first_stage_samp_rate_rx/baud_rate, 0.25*0.175*0.175, 0.5, 0.175, 0.005) + self.digital_binary_slicer_fb_0 = digital.binary_slicer_fb() + self.blocks_multiply_xx_0 = blocks.multiply_vcc(1) + self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate_tx, analog.GR_COS_WAVE, lo_offset , 1, 0) + self.analog_quadrature_demod_cf_0_0 = analog.quadrature_demod_cf(((first_stage_samp_rate_rx) / baud_rate)/(math.pi*modulation_index)) + self.analog_frequency_modulator_fc_0 = analog.frequency_modulator_fc((math.pi*modulation_index) / samples_per_symbol_tx) + + ################################################## + # Connections + ################################################## + self.msg_connect((self.satnogs_ax25_decoder_bm_0, 'pdu'), (self.satnogs_multi_format_msg_sink_0_0, 'in')) + self.msg_connect((self.satnogs_ax25_decoder_bm_0, 'pdu'), (self.satnogs_udp_msg_sink_0_0, 'in')) + self.msg_connect((self.satnogs_udp_msg_source_0, 'msg'), (self.satnogs_upsat_fsk_frame_encoder_0, 'pdu')) + self.connect((self.analog_frequency_modulator_fc_0, 0), (self.pfb_arb_resampler_xxx_0, 0)) + self.connect((self.analog_quadrature_demod_cf_0_0, 0), (self.digital_clock_recovery_mm_xx_0, 0)) + self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1)) + self.connect((self.blocks_multiply_xx_0, 0), (self.osmosdr_sink_0, 0)) + self.connect((self.digital_binary_slicer_fb_0, 0), (self.satnogs_ax25_decoder_bm_0, 0)) + self.connect((self.digital_clock_recovery_mm_xx_0, 0), (self.digital_binary_slicer_fb_0, 0)) + self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.analog_quadrature_demod_cf_0_0, 0)) + self.connect((self.interp_fir_filter_xxx_0, 0), (self.analog_frequency_modulator_fc_0, 0)) + self.connect((self.osmosdr_source_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0)) + self.connect((self.pfb_arb_resampler_xxx_0, 0), (self.blocks_multiply_xx_0, 0)) + self.connect((self.satnogs_upsat_fsk_frame_encoder_0, 0), (self.interp_fir_filter_xxx_0, 0)) + + def get_bind_addr(self): + return self.bind_addr + + def set_bind_addr(self, bind_addr): + self.bind_addr = bind_addr + + def get_dest_addr(self): + return self.dest_addr + + def set_dest_addr(self, dest_addr): + self.dest_addr = dest_addr + + def get_lo_offset(self): + return self.lo_offset + + def set_lo_offset(self, lo_offset): + self.lo_offset = lo_offset + self.analog_sig_source_x_0.set_frequency(self.lo_offset ) + self.osmosdr_sink_0.set_center_freq(self.tx_frequency - self.lo_offset, 0) + self.osmosdr_source_0.set_center_freq(self.rx_frequency - self.lo_offset, 0) + self.freq_xlating_fir_filter_xxx_0.set_center_freq(self.lo_offset) + + def get_recv_port(self): + return self.recv_port + + def set_recv_port(self, recv_port): + self.recv_port = recv_port + + def get_rx_sdr_device(self): + return self.rx_sdr_device + + def set_rx_sdr_device(self, rx_sdr_device): + self.rx_sdr_device = rx_sdr_device + self.set_samp_rate_rx(satnogs.hw_rx_settings[self.rx_sdr_device]['samp_rate']) + self.set_samp_rate_tx(satnogs.hw_tx_settings[self.rx_sdr_device]['samp_rate']) + self.osmosdr_source_0.set_gain(satnogs.hw_rx_settings[self.rx_sdr_device]['rf_gain'], 0) + self.osmosdr_source_0.set_if_gain(satnogs.hw_rx_settings[self.rx_sdr_device]['if_gain'], 0) + self.osmosdr_source_0.set_bb_gain(satnogs.hw_rx_settings[self.rx_sdr_device]['bb_gain'], 0) + self.osmosdr_source_0.set_antenna(satnogs.hw_rx_settings[self.rx_sdr_device]['antenna'], 0) + + def get_send_port(self): + return self.send_port + + def set_send_port(self, send_port): + self.send_port = send_port + + def get_tx_sdr_device(self): + return self.tx_sdr_device + + def set_tx_sdr_device(self, tx_sdr_device): + self.tx_sdr_device = tx_sdr_device + self.osmosdr_sink_0.set_gain(satnogs.hw_tx_settings[self.tx_sdr_device]['rf_gain'], 0) + self.osmosdr_sink_0.set_if_gain(satnogs.hw_tx_settings[self.tx_sdr_device]['if_gain'], 0) + self.osmosdr_sink_0.set_bb_gain(satnogs.hw_tx_settings[self.tx_sdr_device]['bb_gain'], 0) + self.osmosdr_sink_0.set_antenna(satnogs.hw_tx_settings[self.tx_sdr_device]['antenna'], 0) + + def get_samples_per_symbol_tx(self): + return self.samples_per_symbol_tx + + def set_samples_per_symbol_tx(self, samples_per_symbol_tx): + self.samples_per_symbol_tx = samples_per_symbol_tx + self.set_gaussian_taps(filter.firdes.gaussian(1.0, self.samples_per_symbol_tx, 1.0, 4*self.samples_per_symbol_tx)) + self.set_sq_wave((1.0, ) * self.samples_per_symbol_tx) + self.analog_frequency_modulator_fc_0.set_sensitivity((math.pi*self.modulation_index) / self.samples_per_symbol_tx) + self.pfb_arb_resampler_xxx_0.set_rate(self.samp_rate_tx / (self.baud_rate * self.samples_per_symbol_tx)) + + def get_sq_wave(self): + return self.sq_wave + + def set_sq_wave(self, sq_wave): + self.sq_wave = sq_wave + self.set_interp_taps(numpy.convolve(numpy.array(self.gaussian_taps), numpy.array(self.sq_wave))) + + def get_samp_rate_rx(self): + return self.samp_rate_rx + + def set_samp_rate_rx(self, samp_rate_rx): + self.samp_rate_rx = samp_rate_rx + self.set_first_stage_samp_rate_rx(self.samp_rate_rx / self.decimation_rx) + self.osmosdr_source_0.set_sample_rate(self.samp_rate_rx) + self.osmosdr_source_0.set_bandwidth(self.samp_rate_rx, 0) + + def get_gaussian_taps(self): + return self.gaussian_taps + + def set_gaussian_taps(self, gaussian_taps): + self.gaussian_taps = gaussian_taps + self.set_interp_taps(numpy.convolve(numpy.array(self.gaussian_taps), numpy.array(self.sq_wave))) + + def get_deviation(self): + return self.deviation + + def set_deviation(self, deviation): + self.deviation = deviation + self.set_modulation_index(self.deviation / (self.baud_rate / 2.0)) + + def get_decimation_rx(self): + return self.decimation_rx + + def set_decimation_rx(self, decimation_rx): + self.decimation_rx = decimation_rx + self.set_first_stage_samp_rate_rx(self.samp_rate_rx / self.decimation_rx) + + def get_baud_rate(self): + return self.baud_rate + + def set_baud_rate(self, baud_rate): + self.baud_rate = baud_rate + self.set_modulation_index(self.deviation / (self.baud_rate / 2.0)) + self.pfb_arb_resampler_xxx_0.set_rate(self.samp_rate_tx / (self.baud_rate * self.samples_per_symbol_tx)) + self.analog_quadrature_demod_cf_0_0.set_gain(((self.first_stage_samp_rate_rx) / self.baud_rate)/(math.pi*self.modulation_index)) + self.digital_clock_recovery_mm_xx_0.set_omega(self.first_stage_samp_rate_rx/self.baud_rate) + + def get_tx_frequency(self): + return self.tx_frequency + + def set_tx_frequency(self, tx_frequency): + self.tx_frequency = tx_frequency + self.osmosdr_sink_0.set_center_freq(self.tx_frequency - self.lo_offset, 0) + + def get_taps(self): + return self.taps + + def set_taps(self, taps): + self.taps = taps + self.freq_xlating_fir_filter_xxx_0.set_taps((self.taps)) + + def get_samp_rate_tx(self): + return self.samp_rate_tx + + def set_samp_rate_tx(self, samp_rate_tx): + self.samp_rate_tx = samp_rate_tx + self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate_tx) + self.pfb_arb_resampler_xxx_0.set_rate(self.samp_rate_tx / (self.baud_rate * self.samples_per_symbol_tx)) + self.osmosdr_sink_0.set_sample_rate(self.samp_rate_tx) + self.osmosdr_sink_0.set_bandwidth(self.samp_rate_tx, 0) + + def get_rx_frequency(self): + return self.rx_frequency + + def set_rx_frequency(self, rx_frequency): + self.rx_frequency = rx_frequency + self.osmosdr_source_0.set_center_freq(self.rx_frequency - self.lo_offset, 0) + + def get_modulation_index(self): + return self.modulation_index + + def set_modulation_index(self, modulation_index): + self.modulation_index = modulation_index + self.analog_frequency_modulator_fc_0.set_sensitivity((math.pi*self.modulation_index) / self.samples_per_symbol_tx) + self.analog_quadrature_demod_cf_0_0.set_gain(((self.first_stage_samp_rate_rx) / self.baud_rate)/(math.pi*self.modulation_index)) + + def get_interp_taps(self): + return self.interp_taps + + def set_interp_taps(self, interp_taps): + self.interp_taps = interp_taps + self.interp_fir_filter_xxx_0.set_taps((self.interp_taps)) + + def get_first_stage_samp_rate_rx(self): + return self.first_stage_samp_rate_rx + + def set_first_stage_samp_rate_rx(self, first_stage_samp_rate_rx): + self.first_stage_samp_rate_rx = first_stage_samp_rate_rx + self.analog_quadrature_demod_cf_0_0.set_gain(((self.first_stage_samp_rate_rx) / self.baud_rate)/(math.pi*self.modulation_index)) + self.digital_clock_recovery_mm_xx_0.set_omega(self.first_stage_samp_rate_rx/self.baud_rate) + + +def argument_parser(): + parser = OptionParser(option_class=eng_option, usage="%prog: [options]") + parser.add_option( + "", "--bind-addr", dest="bind_addr", type="string", default="0.0.0.0", + help="Set bind_addr [default=%default]") + parser.add_option( + "", "--dest-addr", dest="dest_addr", type="string", default="127.0.0.1", + help="Set dest_addr [default=%default]") + parser.add_option( + "", "--lo-offset", dest="lo_offset", type="eng_float", default=eng_notation.num_to_str(100e3), + help="Set lo_offset [default=%default]") + parser.add_option( + "", "--recv-port", dest="recv_port", type="intx", default=16886, + help="Set recv_port [default=%default]") + parser.add_option( + "", "--rx-sdr-device", dest="rx_sdr_device", type="string", default="usrpb200", + help="Set rx_sdr_device [default=%default]") + parser.add_option( + "", "--send-port", dest="send_port", type="intx", default=5022, + help="Set send_port [default=%default]") + parser.add_option( + "", "--tx-sdr-device", dest="tx_sdr_device", type="string", default="usrpb200", + help="Set tx_sdr_device [default=%default]") + return parser + + +def main(top_block_cls=upsat_transceiver_cli, options=None): + if options is None: + options, _ = argument_parser().parse_args() + + tb = top_block_cls(bind_addr=options.bind_addr, dest_addr=options.dest_addr, lo_offset=options.lo_offset, recv_port=options.recv_port, rx_sdr_device=options.rx_sdr_device, send_port=options.send_port, tx_sdr_device=options.tx_sdr_device) + tb.start() + try: + raw_input('Press Enter to quit: ') + except EOFError: + pass + tb.stop() + tb.wait() + + +if __name__ == '__main__': + main() diff --git a/examples/morse_decoding_flowgraph.grc b/examples/morse_decoding_flowgraph.grc index 00e9f67..407d419 100644 --- a/examples/morse_decoding_flowgraph.grc +++ b/examples/morse_decoding_flowgraph.grc @@ -1,5 +1,5 @@ - + Sun Jan 17 23:03:00 2016 @@ -1548,37 +1548,6 @@ of a full period of the CW signal with frequency freq. -10 - - satnogs_clear_text_msg_sink - - alias - - - - comment - - - - affinity - - - - _enabled - True - - - _coordinate - (928, 584) - - - _rotation - 0 - - - id - satnogs_clear_text_msg_sink_0 - - satnogs_cw_matched_filter_ff @@ -1736,6 +1705,41 @@ of a full period of the CW signal with frequency freq. ord('#') + + satnogs_multi_format_msg_sink + + alias + + + + comment + + + + affinity + + + + _enabled + True + + + _coordinate + (864, 580) + + + _rotation + 0 + + + id + satnogs_multi_format_msg_sink_0 + + + format + 0 + + analog_agc2_xx_0_0 qtgui_time_sink_x_0_0 @@ -1828,7 +1832,7 @@ of a full period of the CW signal with frequency freq. satnogs_morse_decoder_0 - satnogs_clear_text_msg_sink_0 + satnogs_multi_format_msg_sink_0 out in diff --git a/python/hw_settings.py b/python/hw_settings.py index 5c21ce0..7717e3c 100644 --- a/python/hw_settings.py +++ b/python/hw_settings.py @@ -15,7 +15,7 @@ # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License -# * along with this program. If not, see +# along with this program. If not, see # #=============================================================================== @@ -23,16 +23,25 @@ # different SDR hardware. Feel free, to provide additional hardware # configurations #=============================================================================== -hw_tx_settings = {'usrpb200' : {'rf_gain' : 60.0, 'samp_rate' : 2e6}, - 'usrp2' : {'rf_gain' : 20.0, 'samp_rate' : 2e6}, +hw_tx_settings = {'usrpb200' : {'rf_gain' : 60.0, 'if_gain' : 0.0, + 'bb_gain' : 0.0, 'samp_rate' : 2e6, + 'antenna' : 'TX/RX'}, + 'usrp2' : {'rf_gain' : 20.0, 'samp_rate' : 2e6, + 'bb_gain' : 0.0, 'samp_rate' : 2e6, + 'antenna' : 'TX/RX'}, 'hackrf' : {'rf_gain' : 20.0, 'if_gain' : 8.0, - 'bb_gain' : 5.0, 'samp_rate' : 2e6} } + 'bb_gain' : 5.0, 'samp_rate' : 2e6, + 'antenna' : ''} } hw_rx_settings = {'usrpb200' : {'rf_gain' : 20.0, 'if_gain' : 0.0, - 'bb_gain' : 0.0, 'samp_rate' : 2e6}, + 'bb_gain' : 0.0, 'samp_rate' : 1e6, + 'antenna' : 'RX2'}, 'usrp2' : {'rf_gain' : 20.0, 'if_gain' : 0.0, - 'bb_gain' : 0.0, 'samp_rate' : 2e6}, + 'bb_gain' : 0.0, 'samp_rate' : 2e6, + 'antenna' : 'RX2'}, 'airspy' : {'rf_gain' : 20.0, 'if_gain' : 0.0, - 'bb_gain' : 0.0, 'samp_rate' : 2.5e6}, + 'bb_gain' : 0.0, 'samp_rate' : 2.5e6, + 'antenna' : ''}, 'hackrf' : {'rf_gain' : 20.0, 'if_gain' : 8.0, - 'bb_gain' : 5.0, 'samp_rate' : 2e6} } + 'bb_gain' : 5.0, 'samp_rate' : 2e6, + 'antenna' : ''} }