commit
216462cba5
|
@ -20,7 +20,7 @@
|
|||
########################################################################
|
||||
# Project setup
|
||||
########################################################################
|
||||
cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
|
||||
cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
|
||||
project(gr-satnogs CXX C)
|
||||
enable_testing()
|
||||
|
||||
|
@ -29,16 +29,28 @@ set (CMAKE_CXX_STANDARD 11)
|
|||
add_definitions(-std=c++11)
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra")
|
||||
|
||||
#install to PyBOMBS target prefix if defined
|
||||
if(DEFINED ENV{PYBOMBS_PREFIX})
|
||||
#IGNORE set(CMAKE_INSTALL_PREFIX $ENV{PYBOMBS_PREFIX})
|
||||
message(STATUS "PyBOMBS installed GNU Radio. Setting CMAKE_INSTALL_PREFIX to $ENV{PYBOMBS_PREFIX}")
|
||||
endif()
|
||||
|
||||
#select the release build type by default to get optimization flags
|
||||
if(NOT CMAKE_BUILD_TYPE)
|
||||
set(CMAKE_BUILD_TYPE "Release")
|
||||
#IGNORE set(CMAKE_BUILD_TYPE "Release")
|
||||
message(STATUS "Build type not specified: defaulting to release.")
|
||||
endif(NOT CMAKE_BUILD_TYPE)
|
||||
set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")
|
||||
#IGNORE set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")
|
||||
|
||||
#make sure our local CMake Modules path comes first
|
||||
list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_SOURCE_DIR}/cmake/Modules)
|
||||
|
||||
# Set the version information here
|
||||
set(VERSION_INFO_MAJOR_VERSION 1)
|
||||
set(VERSION_INFO_API_COMPAT 0)
|
||||
set(VERSION_INFO_MINOR_VERSION 1)
|
||||
set(VERSION_INFO_MAINT_VERSION git)
|
||||
|
||||
########################################################################
|
||||
# Compiler specific setup
|
||||
########################################################################
|
||||
|
@ -115,13 +127,34 @@ find_package (Threads REQUIRED)
|
|||
########################################################################
|
||||
find_package(CppUnit)
|
||||
find_package(Doxygen)
|
||||
find_package(Volk REQUIRED)
|
||||
find_package(OggVorbis REQUIRED)
|
||||
|
||||
########################################################################
|
||||
# Include or not into the module blocks for debugging
|
||||
########################################################################
|
||||
option(INCLUDE_DEBUG_BLOCKS "Enable/Disable blocks that are used for debugging purposes" ON)
|
||||
|
||||
|
||||
########################################################################
|
||||
# Find gr-satnogs external build dependencies
|
||||
########################################################################
|
||||
if(${INCLUDE_DEBUG_BLOCKS})
|
||||
find_package(Nova)
|
||||
if(NOT NOVA_FOUND)
|
||||
message(FATAL_ERROR "libnova required to compile satnogs")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Search for GNU Radio and its components and versions. Add any
|
||||
# components required to the list of GR_REQUIRED_COMPONENTS (in all
|
||||
# caps such as FILTER or FFT) and change the version to the minimum
|
||||
# API compatible version required.
|
||||
set(GR_REQUIRED_COMPONENTS RUNTIME)
|
||||
find_package(Gnuradio "3.7.2" REQUIRED)
|
||||
set(GR_REQUIRED_COMPONENTS RUNTIME FFT)
|
||||
set(GR_REQUIRED_COMPONENTS RUNTIME FILTER)
|
||||
find_package(Gnuradio "3.7.7" REQUIRED)
|
||||
list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_SOURCE_DIR}/cmake/Modules)
|
||||
include(GrVersion)
|
||||
|
||||
if(NOT CPPUNIT_FOUND)
|
||||
message(FATAL_ERROR "CppUnit required to compile satnogs")
|
||||
|
@ -147,6 +180,7 @@ include_directories(
|
|||
${Boost_INCLUDE_DIRS}
|
||||
${CPPUNIT_INCLUDE_DIRS}
|
||||
${GNURADIO_ALL_INCLUDE_DIRS}
|
||||
${NOVA_INCLUDE_DIRS}
|
||||
)
|
||||
|
||||
link_directories(
|
||||
|
|
44
README.md
44
README.md
|
@ -5,12 +5,17 @@ for decoding signals from various scientific and academic sattelites.
|
|||
## Install
|
||||
|
||||
### Requirements
|
||||
1. GNU Radio ( > 3.7.2 )
|
||||
2. CMake ( > 3.1)
|
||||
3. G++ (with C++11 support)
|
||||
4. VOLK
|
||||
5. git
|
||||
6. gr-osmocom (optional, for using the flowgraphs)
|
||||
* GNU Radio ( > 3.7.7 )
|
||||
* CMake ( > 3.1)
|
||||
* G++ (with C++11 support)
|
||||
* VOLK
|
||||
* libogg
|
||||
* libvorbis
|
||||
* git
|
||||
|
||||
**Optional**
|
||||
* gr-osmocom (for using the flowgraphs with real SDR hardware)
|
||||
* libnova (for building the debug blocks)
|
||||
|
||||
### Installation
|
||||
|
||||
|
@ -24,6 +29,33 @@ for decoding signals from various scientific and academic sattelites.
|
|||
If this is the first time you are building the gr-satnogs module run
|
||||
`sudo ldconfig`
|
||||
|
||||
#### Advanced
|
||||
By default, the **SatNOGS** module will use the default installation prefix.
|
||||
This highly depends on the Linux distribution. You can use the `CMAKE_INSTALL_PREFIX`
|
||||
variable to alter the default installation path.
|
||||
E.g:
|
||||
|
||||
`cmake -DCMAKE_INSTALL_PREFIX=/usr ..`
|
||||
|
||||
Also, by default the build system enables a set of blocks used for debugging
|
||||
during the development. The enable/disable switch is controled through the
|
||||
`INCLUDE_DEBUG_BLOCKS` boolean variable. If for example, you want to disable the
|
||||
debugging blocks, the **CMake** command would be:
|
||||
|
||||
`cmake -DINCLUDE_DEBUG_BLOCKS=OFF ..`
|
||||
|
||||
Another common control option is the library sugffix of the Linux distribution.
|
||||
There are distributions like Fedora, openSUSE, e.t.c that the their 64-bit version
|
||||
use the `lib64` folder to store the 64-bit versions of their dynamic libraries.
|
||||
On the other hand, distributions like Ubuntu do the exact opposite. They use
|
||||
`lib` directory for the libraries of the native architecture and place the 32-bit versions
|
||||
on the `lib32` directory. In any case the correct library directory suffix
|
||||
can be specified with the `LIB_SUFFIX` variable. For example:
|
||||
|
||||
`cmake -DLIB_SUFFIX=64 -DCMAKE_INSTALL_PREFIX=/usr -DINCLUDE_DEBUG_BLOCKS=OFF ..`
|
||||
|
||||
will install the libraries at the `/usr/lib64` directory.
|
||||
|
||||
## Website
|
||||
For more indormation about SatNOGS please visit our [site](https://satnogs.org/).
|
||||
|
||||
|
|
|
@ -19,8 +19,12 @@
|
|||
|
||||
include(GrPython)
|
||||
|
||||
add_subdirectory(flowgraphs/satellites)
|
||||
add_subdirectory(scripts)
|
||||
|
||||
GR_PYTHON_INSTALL(
|
||||
PROGRAMS
|
||||
flowgraphs/upsat_transceiver_cli.py
|
||||
flowgraphs/satnogs_fm_demod.py
|
||||
flowgraphs/satnogs_generic_iq_receiver.py
|
||||
DESTINATION bin
|
||||
)
|
||||
|
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,26 @@
|
|||
# Copyright 2011 Free Software Foundation, Inc.
|
||||
#
|
||||
# This file is part of GNU Radio
|
||||
#
|
||||
# GNU Radio is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 3, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# GNU Radio is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with GNU Radio; see the file COPYING. If not, write to
|
||||
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
# Boston, MA 02110-1301, USA.
|
||||
|
||||
include(GrPython)
|
||||
|
||||
GR_PYTHON_INSTALL(
|
||||
PROGRAMS
|
||||
upsat_transceiver_cli.py
|
||||
DESTINATION bin
|
||||
)
|
|
@ -1,5 +1,5 @@
|
|||
<?xml version='1.0' encoding='utf-8'?>
|
||||
<?grc format='1' created='3.7.9'?>
|
||||
<?grc format='1' created='3.7.10'?>
|
||||
<flow_graph>
|
||||
<timestamp>Fri Jul 1 17:53:00 2016</timestamp>
|
||||
<block>
|
||||
|
@ -78,7 +78,7 @@
|
|||
</param>
|
||||
<param>
|
||||
<key>title</key>
|
||||
<value></value>
|
||||
<value>UPSat Tranceiver</value>
|
||||
</param>
|
||||
</block>
|
||||
<block>
|
||||
|
@ -3676,6 +3676,10 @@ we shift the LO a little further</value>
|
|||
<key>average</key>
|
||||
<value>1.0</value>
|
||||
</param>
|
||||
<param>
|
||||
<key>axislabels</key>
|
||||
<value>True</value>
|
||||
</param>
|
||||
<param>
|
||||
<key>bw</key>
|
||||
<value>samp_rate_rx/decimation_rx</value>
|
||||
|
@ -3944,6 +3948,10 @@ we shift the LO a little further</value>
|
|||
<key>wintype</key>
|
||||
<value>firdes.WIN_BLACKMAN_hARRIS</value>
|
||||
</param>
|
||||
<param>
|
||||
<key>label</key>
|
||||
<value>Relative Gain</value>
|
||||
</param>
|
||||
<param>
|
||||
<key>ymax</key>
|
||||
<value>0</value>
|
||||
|
@ -3952,6 +3960,10 @@ we shift the LO a little further</value>
|
|||
<key>ymin</key>
|
||||
<value>-140</value>
|
||||
</param>
|
||||
<param>
|
||||
<key>units</key>
|
||||
<value>dB</value>
|
||||
</param>
|
||||
</block>
|
||||
<block>
|
||||
<key>parameter</key>
|
|
@ -2,10 +2,10 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
##################################################
|
||||
# GNU Radio Python Flow Graph
|
||||
# Title: Upsat Transceiver Cli
|
||||
# Title: UPSat Tranceiver
|
||||
# Author: Manolis Surligas (surligas@gmail.com)
|
||||
# Description: SATNOGS transceiver for UPSAT satellite
|
||||
# Generated: Sun Aug 14 22:13:27 2016
|
||||
# Generated: Wed Oct 12 20:16:02 2016
|
||||
##################################################
|
||||
|
||||
from gnuradio import analog
|
||||
|
@ -28,7 +28,7 @@ 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", wod_port=5023):
|
||||
gr.top_block.__init__(self, "Upsat Transceiver Cli")
|
||||
gr.top_block.__init__(self, "UPSat Tranceiver")
|
||||
|
||||
##################################################
|
||||
# Parameters
|
||||
|
@ -150,10 +150,10 @@ class upsat_transceiver_cli(gr.top_block):
|
|||
|
||||
def set_lo_offset(self, lo_offset):
|
||||
self.lo_offset = lo_offset
|
||||
self.analog_sig_source_x_0.set_frequency(self.lo_offset )
|
||||
self.freq_xlating_fir_filter_xxx_0.set_center_freq(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.osmosdr_sink_0.set_center_freq(self.tx_frequency - self.lo_offset, 0)
|
||||
self.freq_xlating_fir_filter_xxx_0.set_center_freq(self.lo_offset)
|
||||
self.analog_sig_source_x_0.set_frequency(self.lo_offset )
|
||||
|
||||
def get_recv_port(self):
|
||||
return self.recv_port
|
||||
|
@ -166,8 +166,8 @@ class upsat_transceiver_cli(gr.top_block):
|
|||
|
||||
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.set_samp_rate_rx(satnogs.hw_rx_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)
|
||||
|
@ -200,10 +200,10 @@ class upsat_transceiver_cli(gr.top_block):
|
|||
|
||||
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_uplink) / self.samples_per_symbol_tx)
|
||||
self.pfb_arb_resampler_xxx_0.set_rate(self.samp_rate_tx / (self.baud_rate_uplink * self.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.analog_frequency_modulator_fc_0.set_sensitivity((math.pi*self.modulation_index_uplink) / self.samples_per_symbol_tx)
|
||||
|
||||
def get_sq_wave(self):
|
||||
return self.sq_wave
|
||||
|
@ -233,8 +233,8 @@ class upsat_transceiver_cli(gr.top_block):
|
|||
|
||||
def set_deviation(self, deviation):
|
||||
self.deviation = deviation
|
||||
self.set_modulation_index_downlink(self.deviation / (self.baud_rate_downlink / 2.0))
|
||||
self.set_modulation_index_uplink(self.deviation / (self.baud_rate_uplink / 2.0))
|
||||
self.set_modulation_index_downlink(self.deviation / (self.baud_rate_downlink / 2.0))
|
||||
|
||||
def get_decimation_rx(self):
|
||||
return self.decimation_rx
|
||||
|
@ -257,8 +257,8 @@ class upsat_transceiver_cli(gr.top_block):
|
|||
def set_baud_rate_downlink(self, baud_rate_downlink):
|
||||
self.baud_rate_downlink = baud_rate_downlink
|
||||
self.set_modulation_index_downlink(self.deviation / (self.baud_rate_downlink / 2.0))
|
||||
self.analog_quadrature_demod_cf_0_0.set_gain(((self.first_stage_samp_rate_rx) / self.baud_rate_downlink)/(math.pi*self.modulation_index_downlink))
|
||||
self.digital_clock_recovery_mm_xx_0.set_omega(self.first_stage_samp_rate_rx/self.baud_rate_downlink)
|
||||
self.analog_quadrature_demod_cf_0_0.set_gain(((self.first_stage_samp_rate_rx) / self.baud_rate_downlink)/(math.pi*self.modulation_index_downlink))
|
||||
|
||||
def get_tx_frequency(self):
|
||||
return self.tx_frequency
|
||||
|
@ -279,10 +279,10 @@ class upsat_transceiver_cli(gr.top_block):
|
|||
|
||||
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_uplink * 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)
|
||||
self.pfb_arb_resampler_xxx_0.set_rate(self.samp_rate_tx / (self.baud_rate_uplink * self.samples_per_symbol_tx))
|
||||
self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate_tx)
|
||||
|
||||
def get_rx_frequency(self):
|
||||
return self.rx_frequency
|
||||
|
@ -317,12 +317,13 @@ class upsat_transceiver_cli(gr.top_block):
|
|||
|
||||
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_downlink)/(math.pi*self.modulation_index_downlink))
|
||||
self.digital_clock_recovery_mm_xx_0.set_omega(self.first_stage_samp_rate_rx/self.baud_rate_downlink)
|
||||
self.analog_quadrature_demod_cf_0_0.set_gain(((self.first_stage_samp_rate_rx) / self.baud_rate_downlink)/(math.pi*self.modulation_index_downlink))
|
||||
|
||||
|
||||
def argument_parser():
|
||||
parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
|
||||
description = 'SATNOGS transceiver for UPSAT satellite'
|
||||
parser = OptionParser(usage="%prog: [options]", option_class=eng_option, description=description)
|
||||
parser.add_option(
|
||||
"", "--bind-addr", dest="bind_addr", type="string", default="0.0.0.0",
|
||||
help="Set bind_addr [default=%default]")
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,498 @@
|
|||
#!/usr/bin/env python2
|
||||
# -*- coding: utf-8 -*-
|
||||
##################################################
|
||||
# GNU Radio Python Flow Graph
|
||||
# Title: UPSat Transceiver QT
|
||||
# Author: Manolis Surligas (surligas@gmail.com)
|
||||
# Description: SATNOGS transceiver for UPSAT satellite
|
||||
# Generated: Sun Feb 5 13:59:36 2017
|
||||
##################################################
|
||||
|
||||
if __name__ == '__main__':
|
||||
import ctypes
|
||||
import sys
|
||||
if sys.platform.startswith('linux'):
|
||||
try:
|
||||
x11 = ctypes.cdll.LoadLibrary('libX11.so')
|
||||
x11.XInitThreads()
|
||||
except:
|
||||
print "Warning: failed to XInitThreads()"
|
||||
|
||||
from PyQt4 import Qt
|
||||
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 import qtgui
|
||||
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 sip
|
||||
import sys
|
||||
import time
|
||||
|
||||
|
||||
class upsat_transceiver_qt(gr.top_block, Qt.QWidget):
|
||||
|
||||
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', wod_port=5023):
|
||||
gr.top_block.__init__(self, "UPSat Transceiver QT")
|
||||
Qt.QWidget.__init__(self)
|
||||
self.setWindowTitle("UPSat Transceiver QT")
|
||||
try:
|
||||
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
|
||||
except:
|
||||
pass
|
||||
self.top_scroll_layout = Qt.QVBoxLayout()
|
||||
self.setLayout(self.top_scroll_layout)
|
||||
self.top_scroll = Qt.QScrollArea()
|
||||
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
|
||||
self.top_scroll_layout.addWidget(self.top_scroll)
|
||||
self.top_scroll.setWidgetResizable(True)
|
||||
self.top_widget = Qt.QWidget()
|
||||
self.top_scroll.setWidget(self.top_widget)
|
||||
self.top_layout = Qt.QVBoxLayout(self.top_widget)
|
||||
self.top_grid_layout = Qt.QGridLayout()
|
||||
self.top_layout.addLayout(self.top_grid_layout)
|
||||
|
||||
self.settings = Qt.QSettings("GNU Radio", "upsat_transceiver_qt")
|
||||
self.restoreGeometry(self.settings.value("geometry").toByteArray())
|
||||
|
||||
##################################################
|
||||
# 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
|
||||
self.wod_port = wod_port
|
||||
|
||||
##################################################
|
||||
# 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_uplink = baud_rate_uplink = 1200
|
||||
self.baud_rate_downlink = baud_rate_downlink = 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_uplink = modulation_index_uplink = deviation / (baud_rate_uplink / 2.0)
|
||||
self.modulation_index_downlink = modulation_index_downlink = deviation / (baud_rate_downlink / 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, 0)
|
||||
self.satnogs_udp_msg_sink_0_0_0 = satnogs.udp_msg_sink(dest_addr, wod_port, 1500)
|
||||
self.satnogs_udp_msg_sink_0_0 = satnogs.udp_msg_sink(dest_addr, send_port, 1500)
|
||||
self.satnogs_qb50_deframer_0 = satnogs.qb50_deframer(0xe)
|
||||
self.satnogs_multi_format_msg_sink_0 = satnogs.multi_format_msg_sink(1)
|
||||
self.satnogs_ax25_decoder_bm_0 = satnogs.ax25_decoder_bm('GND', 0, False, True, 256, 3)
|
||||
self.qtgui_waterfall_sink_x_0 = qtgui.waterfall_sink_c(
|
||||
1024, #size
|
||||
firdes.WIN_BLACKMAN_hARRIS, #wintype
|
||||
0, #fc
|
||||
50e3, #bw
|
||||
"", #name
|
||||
1 #number of inputs
|
||||
)
|
||||
self.qtgui_waterfall_sink_x_0.set_update_time(0.10)
|
||||
self.qtgui_waterfall_sink_x_0.enable_grid(False)
|
||||
self.qtgui_waterfall_sink_x_0.enable_axis_labels(True)
|
||||
|
||||
if not True:
|
||||
self.qtgui_waterfall_sink_x_0.disable_legend()
|
||||
|
||||
if "complex" == "float" or "complex" == "msg_float":
|
||||
self.qtgui_waterfall_sink_x_0.set_plot_pos_half(not True)
|
||||
|
||||
labels = ['', '', '', '', '',
|
||||
'', '', '', '', '']
|
||||
colors = [0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0]
|
||||
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
|
||||
1.0, 1.0, 1.0, 1.0, 1.0]
|
||||
for i in xrange(1):
|
||||
if len(labels[i]) == 0:
|
||||
self.qtgui_waterfall_sink_x_0.set_line_label(i, "Data {0}".format(i))
|
||||
else:
|
||||
self.qtgui_waterfall_sink_x_0.set_line_label(i, labels[i])
|
||||
self.qtgui_waterfall_sink_x_0.set_color_map(i, colors[i])
|
||||
self.qtgui_waterfall_sink_x_0.set_line_alpha(i, alphas[i])
|
||||
|
||||
self.qtgui_waterfall_sink_x_0.set_intensity_range(-140, 10)
|
||||
|
||||
self._qtgui_waterfall_sink_x_0_win = sip.wrapinstance(self.qtgui_waterfall_sink_x_0.pyqwidget(), Qt.QWidget)
|
||||
self.top_layout.addWidget(self._qtgui_waterfall_sink_x_0_win)
|
||||
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
|
||||
1024, #size
|
||||
firdes.WIN_BLACKMAN_hARRIS, #wintype
|
||||
0, #fc
|
||||
samp_rate_rx/decimation_rx, #bw
|
||||
"", #name
|
||||
1 #number of inputs
|
||||
)
|
||||
self.qtgui_freq_sink_x_0.set_update_time(0.01)
|
||||
self.qtgui_freq_sink_x_0.set_y_axis(-140, 0)
|
||||
self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB')
|
||||
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
|
||||
self.qtgui_freq_sink_x_0.enable_autoscale(False)
|
||||
self.qtgui_freq_sink_x_0.enable_grid(True)
|
||||
self.qtgui_freq_sink_x_0.set_fft_average(1.0)
|
||||
self.qtgui_freq_sink_x_0.enable_axis_labels(True)
|
||||
self.qtgui_freq_sink_x_0.enable_control_panel(True)
|
||||
|
||||
if not True:
|
||||
self.qtgui_freq_sink_x_0.disable_legend()
|
||||
|
||||
if "complex" == "float" or "complex" == "msg_float":
|
||||
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
|
||||
|
||||
labels = ['', '', '', '', '',
|
||||
'', '', '', '', '']
|
||||
widths = [1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1]
|
||||
colors = ["blue", "red", "green", "black", "cyan",
|
||||
"magenta", "yellow", "dark red", "dark green", "dark blue"]
|
||||
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
|
||||
1.0, 1.0, 1.0, 1.0, 1.0]
|
||||
for i in xrange(1):
|
||||
if len(labels[i]) == 0:
|
||||
self.qtgui_freq_sink_x_0.set_line_label(i, "Data {0}".format(i))
|
||||
else:
|
||||
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
|
||||
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
|
||||
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
|
||||
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
|
||||
|
||||
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
|
||||
self.top_layout.addWidget(self._qtgui_freq_sink_x_0_win)
|
||||
self.pfb_arb_resampler_xxx_0 = pfb.arb_resampler_ccf(
|
||||
samp_rate_tx / (baud_rate_uplink * 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) + " " + satnogs.hw_rx_settings[rx_sdr_device]['dev_arg'] )
|
||||
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) + " " + satnogs.hw_tx_settings[rx_sdr_device]['dev_arg'] )
|
||||
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_downlink, 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_downlink)/(math.pi*modulation_index_downlink))
|
||||
self.analog_frequency_modulator_fc_0 = analog.frequency_modulator_fc((math.pi*modulation_index_uplink) / samples_per_symbol_tx)
|
||||
|
||||
##################################################
|
||||
# Connections
|
||||
##################################################
|
||||
self.msg_connect((self.satnogs_ax25_decoder_bm_0, 'failed_pdu'), (self.satnogs_multi_format_msg_sink_0, 'in'))
|
||||
self.msg_connect((self.satnogs_ax25_decoder_bm_0, 'pdu'), (self.satnogs_qb50_deframer_0, 'in'))
|
||||
self.msg_connect((self.satnogs_qb50_deframer_0, 'out'), (self.satnogs_udp_msg_sink_0_0, 'in'))
|
||||
self.msg_connect((self.satnogs_qb50_deframer_0, 'wod'), (self.satnogs_udp_msg_sink_0_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.freq_xlating_fir_filter_xxx_0, 0), (self.qtgui_freq_sink_x_0, 0))
|
||||
self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.qtgui_waterfall_sink_x_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 closeEvent(self, event):
|
||||
self.settings = Qt.QSettings("GNU Radio", "upsat_transceiver_qt")
|
||||
self.settings.setValue("geometry", self.saveGeometry())
|
||||
event.accept()
|
||||
|
||||
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.osmosdr_source_0.set_center_freq(self.rx_frequency - self.lo_offset, 0)
|
||||
self.osmosdr_sink_0.set_center_freq(self.tx_frequency - self.lo_offset, 0)
|
||||
self.freq_xlating_fir_filter_xxx_0.set_center_freq(self.lo_offset)
|
||||
self.analog_sig_source_x_0.set_frequency(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_tx(satnogs.hw_tx_settings[self.rx_sdr_device]['samp_rate'])
|
||||
self.set_samp_rate_rx(satnogs.hw_rx_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_wod_port(self):
|
||||
return self.wod_port
|
||||
|
||||
def set_wod_port(self, wod_port):
|
||||
self.wod_port = wod_port
|
||||
|
||||
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_sq_wave((1.0, ) * self.samples_per_symbol_tx)
|
||||
self.pfb_arb_resampler_xxx_0.set_rate(self.samp_rate_tx / (self.baud_rate_uplink * self.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.analog_frequency_modulator_fc_0.set_sensitivity((math.pi*self.modulation_index_uplink) / 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.qtgui_freq_sink_x_0.set_frequency_range(0, 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_uplink(self.deviation / (self.baud_rate_uplink / 2.0))
|
||||
self.set_modulation_index_downlink(self.deviation / (self.baud_rate_downlink / 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)
|
||||
self.qtgui_freq_sink_x_0.set_frequency_range(0, self.samp_rate_rx/self.decimation_rx)
|
||||
|
||||
def get_baud_rate_uplink(self):
|
||||
return self.baud_rate_uplink
|
||||
|
||||
def set_baud_rate_uplink(self, baud_rate_uplink):
|
||||
self.baud_rate_uplink = baud_rate_uplink
|
||||
self.set_modulation_index_uplink(self.deviation / (self.baud_rate_uplink / 2.0))
|
||||
self.pfb_arb_resampler_xxx_0.set_rate(self.samp_rate_tx / (self.baud_rate_uplink * self.samples_per_symbol_tx))
|
||||
|
||||
def get_baud_rate_downlink(self):
|
||||
return self.baud_rate_downlink
|
||||
|
||||
def set_baud_rate_downlink(self, baud_rate_downlink):
|
||||
self.baud_rate_downlink = baud_rate_downlink
|
||||
self.set_modulation_index_downlink(self.deviation / (self.baud_rate_downlink / 2.0))
|
||||
self.digital_clock_recovery_mm_xx_0.set_omega(self.first_stage_samp_rate_rx/self.baud_rate_downlink)
|
||||
self.analog_quadrature_demod_cf_0_0.set_gain(((self.first_stage_samp_rate_rx) / self.baud_rate_downlink)/(math.pi*self.modulation_index_downlink))
|
||||
|
||||
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.pfb_arb_resampler_xxx_0.set_rate(self.samp_rate_tx / (self.baud_rate_uplink * 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)
|
||||
self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate_tx)
|
||||
|
||||
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_uplink(self):
|
||||
return self.modulation_index_uplink
|
||||
|
||||
def set_modulation_index_uplink(self, modulation_index_uplink):
|
||||
self.modulation_index_uplink = modulation_index_uplink
|
||||
self.analog_frequency_modulator_fc_0.set_sensitivity((math.pi*self.modulation_index_uplink) / self.samples_per_symbol_tx)
|
||||
|
||||
def get_modulation_index_downlink(self):
|
||||
return self.modulation_index_downlink
|
||||
|
||||
def set_modulation_index_downlink(self, modulation_index_downlink):
|
||||
self.modulation_index_downlink = modulation_index_downlink
|
||||
self.analog_quadrature_demod_cf_0_0.set_gain(((self.first_stage_samp_rate_rx) / self.baud_rate_downlink)/(math.pi*self.modulation_index_downlink))
|
||||
|
||||
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.digital_clock_recovery_mm_xx_0.set_omega(self.first_stage_samp_rate_rx/self.baud_rate_downlink)
|
||||
self.analog_quadrature_demod_cf_0_0.set_gain(((self.first_stage_samp_rate_rx) / self.baud_rate_downlink)/(math.pi*self.modulation_index_downlink))
|
||||
|
||||
|
||||
def argument_parser():
|
||||
description = 'SATNOGS transceiver for UPSAT satellite'
|
||||
parser = OptionParser(usage="%prog: [options]", option_class=eng_option, description=description)
|
||||
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]")
|
||||
parser.add_option(
|
||||
"", "--wod-port", dest="wod_port", type="intx", default=5023,
|
||||
help="Set wod_port [default=%default]")
|
||||
return parser
|
||||
|
||||
|
||||
def main(top_block_cls=upsat_transceiver_qt, options=None):
|
||||
if options is None:
|
||||
options, _ = argument_parser().parse_args()
|
||||
|
||||
from distutils.version import StrictVersion
|
||||
if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"):
|
||||
style = gr.prefs().get_string('qtgui', 'style', 'raster')
|
||||
Qt.QApplication.setGraphicsSystem(style)
|
||||
qapp = Qt.QApplication(sys.argv)
|
||||
|
||||
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, wod_port=options.wod_port)
|
||||
tb.start()
|
||||
tb.show()
|
||||
|
||||
def quitting():
|
||||
tb.stop()
|
||||
tb.wait()
|
||||
qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting)
|
||||
qapp.exec_()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
|
@ -0,0 +1,242 @@
|
|||
#!/usr/bin/env python2
|
||||
# -*- coding: utf-8 -*-
|
||||
##################################################
|
||||
# GNU Radio Python Flow Graph
|
||||
# Title: FM Generic Demodulation
|
||||
# Author: Manolis Surligas (surligas@gmail.com)
|
||||
# Description: A generic FM demodulation block
|
||||
# Generated: Sun Mar 19 10:01:51 2017
|
||||
##################################################
|
||||
|
||||
from gnuradio import analog
|
||||
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 optparse import OptionParser
|
||||
import math
|
||||
import osmosdr
|
||||
import satnogs
|
||||
import time
|
||||
|
||||
|
||||
class satnogs_fm_demod(gr.top_block):
|
||||
|
||||
def __init__(self, doppler_correction_per_sec=1000, file_path='test.wav', lo_offset=100e3, ppm=0, rigctl_port=4532, rx_freq=100e6, rx_sdr_device='usrpb200', waterfall_file_path='/tmp/waterfall.dat'):
|
||||
gr.top_block.__init__(self, "FM Generic Demodulation")
|
||||
|
||||
##################################################
|
||||
# Parameters
|
||||
##################################################
|
||||
self.doppler_correction_per_sec = doppler_correction_per_sec
|
||||
self.file_path = file_path
|
||||
self.lo_offset = lo_offset
|
||||
self.ppm = ppm
|
||||
self.rigctl_port = rigctl_port
|
||||
self.rx_freq = rx_freq
|
||||
self.rx_sdr_device = rx_sdr_device
|
||||
self.waterfall_file_path = waterfall_file_path
|
||||
|
||||
##################################################
|
||||
# Variables
|
||||
##################################################
|
||||
self.samp_rate_rx = samp_rate_rx = satnogs.hw_rx_settings[rx_sdr_device]['samp_rate']
|
||||
self.xlate_filter_taps = xlate_filter_taps = firdes.low_pass(1, samp_rate_rx, 125000, 25000, firdes.WIN_HAMMING, 6.76)
|
||||
|
||||
self.taps = taps = firdes.low_pass(12.0, samp_rate_rx, 100e3, 60000, firdes.WIN_HAMMING, 6.76)
|
||||
|
||||
self.filter_rate = filter_rate = 250000
|
||||
self.deviation = deviation = 5000
|
||||
self.audio_samp_rate = audio_samp_rate = 48000
|
||||
self.audio_gain = audio_gain = satnogs.fm_demod_settings[rx_sdr_device]['audio_gain']
|
||||
|
||||
##################################################
|
||||
# Blocks
|
||||
##################################################
|
||||
self.satnogs_waterfall_sink_0 = satnogs.waterfall_sink(audio_samp_rate, 0.0, 10, 1024, waterfall_file_path, 1)
|
||||
self.satnogs_tcp_rigctl_msg_source_0 = satnogs.tcp_rigctl_msg_source("127.0.0.1", rigctl_port, False, 1000, 1500)
|
||||
self.satnogs_ogg_encoder_0 = satnogs.ogg_encoder(file_path, audio_samp_rate, 1.0)
|
||||
self.satnogs_coarse_doppler_correction_cc_0 = satnogs.coarse_doppler_correction_cc(rx_freq, samp_rate_rx)
|
||||
self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + satnogs.hw_rx_settings[rx_sdr_device]['dev_arg'] )
|
||||
self.osmosdr_source_0.set_sample_rate(samp_rate_rx)
|
||||
self.osmosdr_source_0.set_center_freq(rx_freq - lo_offset, 0)
|
||||
self.osmosdr_source_0.set_freq_corr(ppm, 0)
|
||||
self.osmosdr_source_0.set_dc_offset_mode(2, 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.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(int(samp_rate_rx/filter_rate), (xlate_filter_taps), lo_offset, samp_rate_rx)
|
||||
self.blks2_rational_resampler_xxx_1 = filter.rational_resampler_ccc(
|
||||
interpolation=24,
|
||||
decimation=125,
|
||||
taps=None,
|
||||
fractional_bw=None,
|
||||
)
|
||||
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf((2*math.pi*deviation)/audio_samp_rate)
|
||||
|
||||
##################################################
|
||||
# Connections
|
||||
##################################################
|
||||
self.msg_connect((self.satnogs_tcp_rigctl_msg_source_0, 'freq'), (self.satnogs_coarse_doppler_correction_cc_0, 'freq'))
|
||||
self.connect((self.analog_quadrature_demod_cf_0, 0), (self.satnogs_ogg_encoder_0, 0))
|
||||
self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.analog_quadrature_demod_cf_0, 0))
|
||||
self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.satnogs_waterfall_sink_0, 0))
|
||||
self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.blks2_rational_resampler_xxx_1, 0))
|
||||
self.connect((self.osmosdr_source_0, 0), (self.satnogs_coarse_doppler_correction_cc_0, 0))
|
||||
self.connect((self.satnogs_coarse_doppler_correction_cc_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0))
|
||||
|
||||
def get_doppler_correction_per_sec(self):
|
||||
return self.doppler_correction_per_sec
|
||||
|
||||
def set_doppler_correction_per_sec(self, doppler_correction_per_sec):
|
||||
self.doppler_correction_per_sec = doppler_correction_per_sec
|
||||
|
||||
def get_file_path(self):
|
||||
return self.file_path
|
||||
|
||||
def set_file_path(self, file_path):
|
||||
self.file_path = file_path
|
||||
|
||||
def get_lo_offset(self):
|
||||
return self.lo_offset
|
||||
|
||||
def set_lo_offset(self, lo_offset):
|
||||
self.lo_offset = lo_offset
|
||||
self.osmosdr_source_0.set_center_freq(self.rx_freq - self.lo_offset, 0)
|
||||
self.freq_xlating_fir_filter_xxx_0.set_center_freq(self.lo_offset)
|
||||
|
||||
def get_ppm(self):
|
||||
return self.ppm
|
||||
|
||||
def set_ppm(self, ppm):
|
||||
self.ppm = ppm
|
||||
self.osmosdr_source_0.set_freq_corr(self.ppm, 0)
|
||||
|
||||
def get_rigctl_port(self):
|
||||
return self.rigctl_port
|
||||
|
||||
def set_rigctl_port(self, rigctl_port):
|
||||
self.rigctl_port = rigctl_port
|
||||
|
||||
def get_rx_freq(self):
|
||||
return self.rx_freq
|
||||
|
||||
def set_rx_freq(self, rx_freq):
|
||||
self.rx_freq = rx_freq
|
||||
self.satnogs_coarse_doppler_correction_cc_0.set_new_freq_locked(self.rx_freq)
|
||||
self.osmosdr_source_0.set_center_freq(self.rx_freq - self.lo_offset, 0)
|
||||
|
||||
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.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)
|
||||
self.set_audio_gain(satnogs.fm_demod_settings[self.rx_sdr_device]['audio_gain'])
|
||||
|
||||
def get_waterfall_file_path(self):
|
||||
return self.waterfall_file_path
|
||||
|
||||
def set_waterfall_file_path(self, waterfall_file_path):
|
||||
self.waterfall_file_path = waterfall_file_path
|
||||
|
||||
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_xlate_filter_taps(firdes.low_pass(1, self.samp_rate_rx, 125000, 25000, firdes.WIN_HAMMING, 6.76))
|
||||
self.osmosdr_source_0.set_sample_rate(self.samp_rate_rx)
|
||||
self.osmosdr_source_0.set_bandwidth(self.samp_rate_rx, 0)
|
||||
|
||||
def get_xlate_filter_taps(self):
|
||||
return self.xlate_filter_taps
|
||||
|
||||
def set_xlate_filter_taps(self, xlate_filter_taps):
|
||||
self.xlate_filter_taps = xlate_filter_taps
|
||||
self.freq_xlating_fir_filter_xxx_0.set_taps((self.xlate_filter_taps))
|
||||
|
||||
def get_taps(self):
|
||||
return self.taps
|
||||
|
||||
def set_taps(self, taps):
|
||||
self.taps = taps
|
||||
|
||||
def get_filter_rate(self):
|
||||
return self.filter_rate
|
||||
|
||||
def set_filter_rate(self, filter_rate):
|
||||
self.filter_rate = filter_rate
|
||||
|
||||
def get_deviation(self):
|
||||
return self.deviation
|
||||
|
||||
def set_deviation(self, deviation):
|
||||
self.deviation = deviation
|
||||
self.analog_quadrature_demod_cf_0.set_gain((2*math.pi*self.deviation)/self.audio_samp_rate)
|
||||
|
||||
def get_audio_samp_rate(self):
|
||||
return self.audio_samp_rate
|
||||
|
||||
def set_audio_samp_rate(self, audio_samp_rate):
|
||||
self.audio_samp_rate = audio_samp_rate
|
||||
self.analog_quadrature_demod_cf_0.set_gain((2*math.pi*self.deviation)/self.audio_samp_rate)
|
||||
|
||||
def get_audio_gain(self):
|
||||
return self.audio_gain
|
||||
|
||||
def set_audio_gain(self, audio_gain):
|
||||
self.audio_gain = audio_gain
|
||||
|
||||
|
||||
def argument_parser():
|
||||
description = 'A generic FM demodulation block'
|
||||
parser = OptionParser(usage="%prog: [options]", option_class=eng_option, description=description)
|
||||
parser.add_option(
|
||||
"", "--doppler-correction-per-sec", dest="doppler_correction_per_sec", type="intx", default=1000,
|
||||
help="Set doppler_correction_per_sec [default=%default]")
|
||||
parser.add_option(
|
||||
"", "--file-path", dest="file_path", type="string", default='test.wav',
|
||||
help="Set file_path [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(
|
||||
"", "--ppm", dest="ppm", type="intx", default=0,
|
||||
help="Set ppm [default=%default]")
|
||||
parser.add_option(
|
||||
"", "--rigctl-port", dest="rigctl_port", type="intx", default=4532,
|
||||
help="Set rigctl_port [default=%default]")
|
||||
parser.add_option(
|
||||
"", "--rx-freq", dest="rx_freq", type="eng_float", default=eng_notation.num_to_str(100e6),
|
||||
help="Set rx_freq [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(
|
||||
"", "--waterfall-file-path", dest="waterfall_file_path", type="string", default='/tmp/waterfall.dat',
|
||||
help="Set waterfall_file_path [default=%default]")
|
||||
return parser
|
||||
|
||||
|
||||
def main(top_block_cls=satnogs_fm_demod, options=None):
|
||||
if options is None:
|
||||
options, _ = argument_parser().parse_args()
|
||||
|
||||
tb = top_block_cls(doppler_correction_per_sec=options.doppler_correction_per_sec, file_path=options.file_path, lo_offset=options.lo_offset, ppm=options.ppm, rigctl_port=options.rigctl_port, rx_freq=options.rx_freq, rx_sdr_device=options.rx_sdr_device, waterfall_file_path=options.waterfall_file_path)
|
||||
tb.start()
|
||||
tb.wait()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
|
@ -0,0 +1,211 @@
|
|||
#!/usr/bin/env python2
|
||||
# -*- coding: utf-8 -*-
|
||||
##################################################
|
||||
# GNU Radio Python Flow Graph
|
||||
# Title: Generic IQ samples receiver
|
||||
# Author: Manolis Surligas (surligas@gmail.com)
|
||||
# Description: A generic FM demodulation block
|
||||
# Generated: Mon Nov 7 19:49:15 2016
|
||||
##################################################
|
||||
|
||||
from gnuradio import blocks
|
||||
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 optparse import OptionParser
|
||||
import osmosdr
|
||||
import satnogs
|
||||
import time
|
||||
|
||||
|
||||
class satnogs_generic_iq_receiver(gr.top_block):
|
||||
|
||||
def __init__(self, doppler_correction_per_sec=1000, file_path='test.wav', lo_offset=100e3, rigctl_port=4532, rx_freq=100e6, rx_sdr_device='usrpb200'):
|
||||
gr.top_block.__init__(self, "Generic IQ samples receiver")
|
||||
|
||||
##################################################
|
||||
# Parameters
|
||||
##################################################
|
||||
self.doppler_correction_per_sec = doppler_correction_per_sec
|
||||
self.file_path = file_path
|
||||
self.lo_offset = lo_offset
|
||||
self.rigctl_port = rigctl_port
|
||||
self.rx_freq = rx_freq
|
||||
self.rx_sdr_device = rx_sdr_device
|
||||
|
||||
##################################################
|
||||
# Variables
|
||||
##################################################
|
||||
self.samp_rate_rx = samp_rate_rx = satnogs.hw_rx_settings[rx_sdr_device]['samp_rate']
|
||||
self.decimation_rx = decimation_rx = satnogs.fm_demod_settings[rx_sdr_device]['decimation_rx']
|
||||
|
||||
self.taps = taps = firdes.low_pass(12.0, samp_rate_rx, 100e3, 60000, firdes.WIN_HAMMING, 6.76)
|
||||
|
||||
self.quadrature_rate = quadrature_rate = samp_rate_rx / decimation_rx
|
||||
self.audio_samp_rate = audio_samp_rate = 44100
|
||||
self.audio_gain = audio_gain = satnogs.fm_demod_settings[rx_sdr_device]['audio_gain']
|
||||
self.audio_decimation = audio_decimation = 2
|
||||
|
||||
##################################################
|
||||
# Blocks
|
||||
##################################################
|
||||
self.satnogs_tcp_rigctl_msg_source_0 = satnogs.tcp_rigctl_msg_source("127.0.0.1", rigctl_port, False, 1000, 1500)
|
||||
self.satnogs_coarse_doppler_correction_cc_0 = satnogs.coarse_doppler_correction_cc(rx_freq, samp_rate_rx)
|
||||
self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + satnogs.hw_rx_settings[rx_sdr_device]['dev_arg'] )
|
||||
self.osmosdr_source_0.set_sample_rate(samp_rate_rx)
|
||||
self.osmosdr_source_0.set_center_freq(rx_freq - lo_offset, 0)
|
||||
self.osmosdr_source_0.set_freq_corr(0, 0)
|
||||
self.osmosdr_source_0.set_dc_offset_mode(2, 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.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(decimation_rx, (taps), lo_offset, samp_rate_rx)
|
||||
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex*1, file_path, False)
|
||||
self.blocks_file_sink_0.set_unbuffered(True)
|
||||
|
||||
##################################################
|
||||
# Connections
|
||||
##################################################
|
||||
self.msg_connect((self.satnogs_tcp_rigctl_msg_source_0, 'freq'), (self.satnogs_coarse_doppler_correction_cc_0, 'freq'))
|
||||
self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.blocks_file_sink_0, 0))
|
||||
self.connect((self.osmosdr_source_0, 0), (self.satnogs_coarse_doppler_correction_cc_0, 0))
|
||||
self.connect((self.satnogs_coarse_doppler_correction_cc_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0))
|
||||
|
||||
def get_doppler_correction_per_sec(self):
|
||||
return self.doppler_correction_per_sec
|
||||
|
||||
def set_doppler_correction_per_sec(self, doppler_correction_per_sec):
|
||||
self.doppler_correction_per_sec = doppler_correction_per_sec
|
||||
|
||||
def get_file_path(self):
|
||||
return self.file_path
|
||||
|
||||
def set_file_path(self, file_path):
|
||||
self.file_path = file_path
|
||||
self.blocks_file_sink_0.open(self.file_path)
|
||||
|
||||
def get_lo_offset(self):
|
||||
return self.lo_offset
|
||||
|
||||
def set_lo_offset(self, lo_offset):
|
||||
self.lo_offset = lo_offset
|
||||
self.osmosdr_source_0.set_center_freq(self.rx_freq - self.lo_offset, 0)
|
||||
self.freq_xlating_fir_filter_xxx_0.set_center_freq(self.lo_offset)
|
||||
|
||||
def get_rigctl_port(self):
|
||||
return self.rigctl_port
|
||||
|
||||
def set_rigctl_port(self, rigctl_port):
|
||||
self.rigctl_port = rigctl_port
|
||||
|
||||
def get_rx_freq(self):
|
||||
return self.rx_freq
|
||||
|
||||
def set_rx_freq(self, rx_freq):
|
||||
self.rx_freq = rx_freq
|
||||
self.satnogs_coarse_doppler_correction_cc_0.set_new_freq_locked(self.rx_freq)
|
||||
self.osmosdr_source_0.set_center_freq(self.rx_freq - self.lo_offset, 0)
|
||||
|
||||
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_decimation_rx(satnogs.fm_demod_settings[self.rx_sdr_device]['decimation_rx'])
|
||||
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)
|
||||
self.set_audio_gain(satnogs.fm_demod_settings[self.rx_sdr_device]['audio_gain'])
|
||||
|
||||
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_quadrature_rate(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_decimation_rx(self):
|
||||
return self.decimation_rx
|
||||
|
||||
def set_decimation_rx(self, decimation_rx):
|
||||
self.decimation_rx = decimation_rx
|
||||
self.set_quadrature_rate(self.samp_rate_rx / self.decimation_rx)
|
||||
|
||||
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_quadrature_rate(self):
|
||||
return self.quadrature_rate
|
||||
|
||||
def set_quadrature_rate(self, quadrature_rate):
|
||||
self.quadrature_rate = quadrature_rate
|
||||
|
||||
def get_audio_samp_rate(self):
|
||||
return self.audio_samp_rate
|
||||
|
||||
def set_audio_samp_rate(self, audio_samp_rate):
|
||||
self.audio_samp_rate = audio_samp_rate
|
||||
|
||||
def get_audio_gain(self):
|
||||
return self.audio_gain
|
||||
|
||||
def set_audio_gain(self, audio_gain):
|
||||
self.audio_gain = audio_gain
|
||||
|
||||
def get_audio_decimation(self):
|
||||
return self.audio_decimation
|
||||
|
||||
def set_audio_decimation(self, audio_decimation):
|
||||
self.audio_decimation = audio_decimation
|
||||
|
||||
|
||||
def argument_parser():
|
||||
description = 'A generic FM demodulation block'
|
||||
parser = OptionParser(usage="%prog: [options]", option_class=eng_option, description=description)
|
||||
parser.add_option(
|
||||
"", "--doppler-correction-per-sec", dest="doppler_correction_per_sec", type="intx", default=1000,
|
||||
help="Set doppler_correction_per_sec [default=%default]")
|
||||
parser.add_option(
|
||||
"", "--file-path", dest="file_path", type="string", default='test.wav',
|
||||
help="Set file_path [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(
|
||||
"", "--rigctl-port", dest="rigctl_port", type="intx", default=4532,
|
||||
help="Set rigctl_port [default=%default]")
|
||||
parser.add_option(
|
||||
"", "--rx-freq", dest="rx_freq", type="eng_float", default=eng_notation.num_to_str(100e6),
|
||||
help="Set rx_freq [default=%default]")
|
||||
parser.add_option(
|
||||
"", "--rx-sdr-device", dest="rx_sdr_device", type="string", default='usrpb200',
|
||||
help="Set rx_sdr_device [default=%default]")
|
||||
return parser
|
||||
|
||||
|
||||
def main(top_block_cls=satnogs_generic_iq_receiver, options=None):
|
||||
if options is None:
|
||||
options, _ = argument_parser().parse_args()
|
||||
|
||||
tb = top_block_cls(doppler_correction_per_sec=options.doppler_correction_per_sec, file_path=options.file_path, lo_offset=options.lo_offset, rigctl_port=options.rigctl_port, rx_freq=options.rx_freq, rx_sdr_device=options.rx_sdr_device)
|
||||
tb.start()
|
||||
tb.wait()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
|
@ -0,0 +1,4 @@
|
|||
INSTALL(FILES
|
||||
satnogs_waterfall.gp
|
||||
DESTINATION share/satnogs/scripts
|
||||
)
|
|
@ -0,0 +1,70 @@
|
|||
#!/usr/bin/gnuplot
|
||||
#
|
||||
# gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
#
|
||||
# Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
#
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# 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 <http://www.gnu.org/licenses/>
|
||||
|
||||
# satnogs-waterfall.gp
|
||||
# Plot a waterfall diagramm from the output of the satnogs_waterfall_sink block.
|
||||
#
|
||||
# Usage:
|
||||
# gnuplot -e "inputfile='waterfall_sink.data'" -e "outfile='waterfall.png'" /usr/local/share/satnogs/scripts/satnogs_waterfall.gp
|
||||
|
||||
reset
|
||||
if (!exists("height")) height=800
|
||||
if (!exists("width")) width=800
|
||||
if (!exists("outfile")) outfile='/tmp/waterfall.png'
|
||||
|
||||
set terminal pngcairo size width,height enhanced font 'Verdana,14'
|
||||
set output outfile
|
||||
|
||||
unset key
|
||||
set style line 11 lc rgb '#808080' lt 1
|
||||
set border 3 front ls 11
|
||||
set style line 12 lc rgb '#888888' lt 0 lw 1
|
||||
set grid front ls 12
|
||||
set tics nomirror out scale 0.75
|
||||
|
||||
set xlabel 'Frequency (kHz)'
|
||||
set ylabel 'Time'
|
||||
set cbtics scale 0
|
||||
set cbtics (-110, -105, -100, -95, -90, -85, -80, -75, -70, -65, -60, -55, -50, -55, -40)
|
||||
|
||||
# palette
|
||||
set palette defined (0 '#aa00ff',\
|
||||
1 '#6200ea',\
|
||||
2 '#2962ff',\
|
||||
3 '#00b8d4',\
|
||||
4 '#00bfa5',\
|
||||
5 '#00c853',\
|
||||
6 '#64dd17 ',\
|
||||
7 '#aeea00',\
|
||||
9 '#ffd600 ',\
|
||||
10 '#ffab00 ',\
|
||||
11 '#ff6d00',\
|
||||
12 '#d50000')
|
||||
set ylabel 'Time (seconds)'
|
||||
set cbrange [-100:-50]
|
||||
set cblabel 'Power (dB)'
|
||||
|
||||
# Get automatically the axis ranges from the file
|
||||
stats inputfile using 1 binary nooutput
|
||||
set xrange [STATS_min*1e-3:STATS_max*1e-3 + 1]
|
||||
stats inputfile using 2 binary nooutput
|
||||
set yrange [0:STATS_max + 1]
|
||||
|
||||
# Plot and scale the frequency axis to kHz for readability
|
||||
plot inputfile using ($1*1e-3):2:3 binary matrix with image
|
|
@ -0,0 +1,26 @@
|
|||
INCLUDE(FindPkgConfig)
|
||||
PKG_CHECK_MODULES(PC_NOVA Nova)
|
||||
|
||||
FIND_PATH(
|
||||
NOVA_INCLUDE_DIRS
|
||||
NAMES libnova/libnova.h
|
||||
HINTS $ENV{NOVA_DIR}/include
|
||||
${PC_NOVA_INCLUDEDIR}
|
||||
PATHS /usr/local/include
|
||||
/usr/include
|
||||
)
|
||||
|
||||
FIND_LIBRARY(
|
||||
NOVA_LIBRARIES
|
||||
NAMES nova
|
||||
HINTS $ENV{NOVA_DIR}/lib
|
||||
${PC_NOVA_LIBDIR}
|
||||
PATHS /usr/local/lib
|
||||
/usr/local/lib64
|
||||
/usr/lib
|
||||
/usr/lib64
|
||||
)
|
||||
|
||||
INCLUDE(FindPackageHandleStandardArgs)
|
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(NOVA DEFAULT_MSG NOVA_LIBRARIES NOVA_INCLUDE_DIRS)
|
||||
MARK_AS_ADVANCED(NOVA_LIBRARIES NOVA_INCLUDE_DIRS)
|
|
@ -0,0 +1,86 @@
|
|||
# - Try to find the OggVorbis libraries
|
||||
# Once done this will define
|
||||
#
|
||||
# OGGVORBIS_FOUND - system has OggVorbis
|
||||
# OGGVORBIS_VERSION - set either to 1 or 2
|
||||
# OGG_INCLUDE_DIR - the OggVorbis include directory
|
||||
# VORBIS_INCLUDE_DIR - the OggVorbis include directory
|
||||
# OGGVORBIS_LIBRARIES - The libraries needed to use OggVorbis
|
||||
# OGG_LIBRARY - The Ogg library
|
||||
# VORBIS_LIBRARY - The Vorbis library
|
||||
# VORBISFILE_LIBRARY - The VorbisFile library
|
||||
# VORBISENC_LIBRARY - The VorbisEnc library
|
||||
|
||||
# Copyright (c) 2006, Richard Laerkaeng, <richard@goteborg.utfors.se>
|
||||
#
|
||||
# Redistribution and use is allowed according to the terms of the BSD license.
|
||||
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
|
||||
|
||||
|
||||
include (CheckLibraryExists)
|
||||
|
||||
find_path(VORBIS_INCLUDE_DIR vorbis/vorbisfile.h)
|
||||
find_path(OGG_INCLUDE_DIR ogg/ogg.h)
|
||||
|
||||
find_library(OGG_LIBRARY NAMES ogg)
|
||||
find_library(VORBIS_LIBRARY NAMES vorbis)
|
||||
find_library(VORBISFILE_LIBRARY NAMES vorbisfile)
|
||||
find_library(VORBISENC_LIBRARY NAMES vorbisenc)
|
||||
|
||||
|
||||
if (VORBIS_INCLUDE_DIR AND VORBIS_LIBRARY AND VORBISFILE_LIBRARY AND VORBISENC_LIBRARY)
|
||||
set(OGGVORBIS_FOUND TRUE)
|
||||
|
||||
set(OGGVORBIS_LIBRARIES ${OGG_LIBRARY} ${VORBIS_LIBRARY} ${VORBISFILE_LIBRARY} ${VORBISENC_LIBRARY})
|
||||
|
||||
set(_CMAKE_REQUIRED_LIBRARIES_TMP ${CMAKE_REQUIRED_LIBRARIES})
|
||||
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${OGGVORBIS_LIBRARIES})
|
||||
check_library_exists(vorbis vorbis_bitrate_addblock "" HAVE_LIBVORBISENC2)
|
||||
set(CMAKE_REQUIRED_LIBRARIES ${_CMAKE_REQUIRED_LIBRARIES_TMP})
|
||||
|
||||
if (HAVE_LIBVORBISENC2)
|
||||
set (OGGVORBIS_VERSION 2)
|
||||
else (HAVE_LIBVORBISENC2)
|
||||
set (OGGVORBIS_VERSION 1)
|
||||
endif (HAVE_LIBVORBISENC2)
|
||||
|
||||
else (VORBIS_INCLUDE_DIR AND VORBIS_LIBRARY AND VORBISFILE_LIBRARY AND VORBISENC_LIBRARY)
|
||||
set (OGGVORBIS_VERSION)
|
||||
set(OGGVORBIS_FOUND FALSE)
|
||||
endif (VORBIS_INCLUDE_DIR AND VORBIS_LIBRARY AND VORBISFILE_LIBRARY AND VORBISENC_LIBRARY)
|
||||
|
||||
|
||||
if (OGGVORBIS_FOUND)
|
||||
if (NOT OggVorbis_FIND_QUIETLY)
|
||||
message(STATUS "Found OggVorbis: ${OGGVORBIS_LIBRARIES}")
|
||||
endif (NOT OggVorbis_FIND_QUIETLY)
|
||||
else (OGGVORBIS_FOUND)
|
||||
if (OggVorbis_FIND_REQUIRED)
|
||||
message(FATAL_ERROR "Could NOT find OggVorbis libraries")
|
||||
endif (OggVorbis_FIND_REQUIRED)
|
||||
if (NOT OggVorbis_FIND_QUITELY)
|
||||
message(STATUS "Could NOT find OggVorbis libraries")
|
||||
endif (NOT OggVorbis_FIND_QUITELY)
|
||||
endif (OGGVORBIS_FOUND)
|
||||
|
||||
#check_include_files(vorbis/vorbisfile.h HAVE_VORBISFILE_H)
|
||||
#check_library_exists(ogg ogg_page_version "" HAVE_LIBOGG)
|
||||
#check_library_exists(vorbis vorbis_info_init "" HAVE_LIBVORBIS)
|
||||
#check_library_exists(vorbisfile ov_open "" HAVE_LIBVORBISFILE)
|
||||
#check_library_exists(vorbisenc vorbis_info_clear "" HAVE_LIBVORBISENC)
|
||||
#check_library_exists(vorbis vorbis_bitrate_addblock "" HAVE_LIBVORBISENC2)
|
||||
|
||||
#if (HAVE_LIBOGG AND HAVE_VORBISFILE_H AND HAVE_LIBVORBIS AND HAVE_LIBVORBISFILE AND HAVE_LIBVORBISENC)
|
||||
# message(STATUS "Ogg/Vorbis found")
|
||||
# set (VORBIS_LIBS "-lvorbis -logg")
|
||||
# set (VORBISFILE_LIBS "-lvorbisfile")
|
||||
# set (VORBISENC_LIBS "-lvorbisenc")
|
||||
# set (OGGVORBIS_FOUND TRUE)
|
||||
# if (HAVE_LIBVORBISENC2)
|
||||
# set (HAVE_VORBIS 2)
|
||||
# else (HAVE_LIBVORBISENC2)
|
||||
# set (HAVE_VORBIS 1)
|
||||
# endif (HAVE_LIBVORBISENC2)
|
||||
#else (HAVE_LIBOGG AND HAVE_VORBISFILE_H AND HAVE_LIBVORBIS AND HAVE_LIBVORBISFILE AND HAVE_LIBVORBISENC)
|
||||
# message(STATUS "Ogg/Vorbis not found")
|
||||
#endif (HAVE_LIBOGG AND HAVE_VORBISFILE_H AND HAVE_LIBVORBIS AND HAVE_LIBVORBISFILE AND HAVE_LIBVORBISENC)
|
|
@ -15,28 +15,39 @@
|
|||
# You should have received a copy of the GNU General Public License
|
||||
# along with GNU Radio; see the file COPYING. If not, write to
|
||||
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
# Boston, MA 02110-1301, USA.
|
||||
install(FILES
|
||||
# Boston, MA
|
||||
|
||||
add_subdirectory(satellites)
|
||||
|
||||
list(APPEND debug_blocks
|
||||
satnogs_morse_debug_source.xml
|
||||
satnogs_debug_msg_source.xml
|
||||
satnogs_debug_msg_source_raw.xml
|
||||
satnogs_leo_channel.xml
|
||||
)
|
||||
|
||||
list(APPEND enabled_blocks
|
||||
satnogs_block_tree.xml
|
||||
satnogs_cw_matched_filter_ff.xml
|
||||
satnogs_morse_decoder.xml
|
||||
satnogs_morse_debug_source.xml
|
||||
satnogs_multi_format_msg_sink.xml
|
||||
satnogs_ogg_encoder.xml
|
||||
satnogs_cw_to_symbol.xml
|
||||
satnogs_sine_matched_filter_ff.xml
|
||||
satnogs_udp_msg_source.xml
|
||||
satnogs_debug_msg_source.xml
|
||||
satnogs_json_to_ecss_src.xml
|
||||
satnogs_tcp_rigctl_msg_source.xml
|
||||
satnogs_frame_encoder.xml
|
||||
satnogs_doppler_correction_cc.xml
|
||||
satnogs_upsat_fsk_frame_acquisition.xml
|
||||
satnogs_upsat_fsk_frame_encoder.xml
|
||||
satnogs_whitening.xml
|
||||
satnogs_udp_msg_sink.xml
|
||||
satnogs_upsat_transmitter.xml
|
||||
satnogs_coarse_doppler_correction_cc.xml
|
||||
satnogs_debug_msg_source_raw.xml
|
||||
satnogs_ax25_encoder_mb.xml
|
||||
satnogs_ax25_decoder_bm.xml
|
||||
satnogs_qb50_deframer.xml DESTINATION share/gnuradio/grc/blocks
|
||||
satnogs_waterfall_sink.xml
|
||||
)
|
||||
|
||||
if(${INCLUDE_DEBUG_BLOCKS})
|
||||
list(APPEND enabled_blocks ${debug_blocks})
|
||||
endif()
|
||||
install(FILES
|
||||
${enabled_blocks}
|
||||
satnogs_ogg_source.xml DESTINATION share/gnuradio/grc/blocks
|
||||
)
|
||||
|
|
|
@ -0,0 +1,21 @@
|
|||
# Copyright 2011 Free Software Foundation, Inc.
|
||||
#
|
||||
# This file is part of GNU Radio
|
||||
#
|
||||
# GNU Radio is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 3, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# GNU Radio is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with GNU Radio; see the file COPYING. If not, write to
|
||||
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
# Boston, MA 02110-1301, USA.
|
||||
|
||||
|
||||
add_subdirectory(upsat)
|
|
@ -0,0 +1,30 @@
|
|||
# Copyright 2011 Free Software Foundation, Inc.
|
||||
#
|
||||
# This file is part of GNU Radio
|
||||
#
|
||||
# GNU Radio is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 3, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# GNU Radio is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with GNU Radio; see the file COPYING. If not, write to
|
||||
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
# Boston, MA 02110-1301, USA.
|
||||
|
||||
list(APPEND blocks
|
||||
satnogs_qb50_deframer.xml
|
||||
satnogs_upsat_fsk_frame_acquisition.xml
|
||||
satnogs_upsat_fsk_frame_encoder.xml
|
||||
satnogs_upsat_transmitter.xml
|
||||
)
|
||||
|
||||
install(FILES
|
||||
${blocks}
|
||||
DESTINATION share/gnuradio/grc/blocks
|
||||
)
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>QB50 AX.25 Deframer</name>
|
||||
<key>satnogs_qb50_deframer</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.qb50_deframer($wod_ssid)</make>
|
||||
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>UPSAT FSK Frame Acquisition</name>
|
||||
<key>satnogs_upsat_fsk_frame_acquisition</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.upsat_fsk_frame_acquisition($preamble, $sync_word, $whitening, $manchester, $check_crc, $ax_25)</make>
|
||||
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>UPSAT FSK Frame Encoder</name>
|
||||
<key>satnogs_upsat_fsk_frame_encoder</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.upsat_fsk_frame_encoder($preamble, $sync_word, $append_crc, $whitening, $manchester, $msb_first, $ax_25, $src_addr, $src_ssid, $dest_addr, $dest_ssid, $settling_samples)</make>
|
||||
|
|
@ -1,7 +1,6 @@
|
|||
<block>
|
||||
<name>Satnogs UPSat Transmitter</name>
|
||||
<key>satnogs_upsat_transmitter</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
|
||||
<make>satnogs.satnogs_upsat_transmitter(frame_preamble=$frame_preamble,
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>AX.25 Decoder</name>
|
||||
<key>satnogs_ax25_decoder_bm</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.ax25_decoder_bm($addr, $ssid, $promisc, $descrambling, $max_frame_len, $n_sync_flags)</make>
|
||||
|
||||
|
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>AX.25 Encoder</name>
|
||||
<key>satnogs_ax25_encoder_mb</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.ax25_encoder_mb($dest_addr, $dest_ssid, $src_addr, $src_ssid, $preamble_len, $postamble_len, $scramble)</make>
|
||||
|
||||
|
|
|
@ -0,0 +1,28 @@
|
|||
<cat>
|
||||
<name>[SatNOGS]</name>
|
||||
<cat>
|
||||
<name>Satellites</name>
|
||||
<cat>
|
||||
<name>UPSat</name>
|
||||
<block>satnogs_upsat_fsk_frame_acquisition</block>
|
||||
<block>satnogs_upsat_fsk_frame_encoder</block>
|
||||
<block>satnogs_upsat_transmitter</block>
|
||||
<block>satnogs_qb50_deframer</block>
|
||||
</cat>
|
||||
</cat>
|
||||
<block>satnogs_cw_matched_filter_ff</block>
|
||||
<block>satnogs_morse_decoder</block>
|
||||
<block>satnogs_multi_format_msg_sink</block>
|
||||
<block>satnogs_ogg_encoder</block>
|
||||
<block>satnogs_ogg_source</block>
|
||||
<block>satnogs_cw_to_symbol</block>
|
||||
<block>satnogs_sine_matched_filter_ff</block>
|
||||
<block>satnogs_udp_msg_source</block>
|
||||
<block>satnogs_tcp_rigctl_msg_source</block>
|
||||
<block>satnogs_doppler_correction_cc</block>
|
||||
<block>satnogs_udp_msg_sink</block>
|
||||
<block>satnogs_coarse_doppler_correction_cc</block>
|
||||
<block>satnogs_ax25_encoder_mb</block>
|
||||
<block>satnogs_ax25_decoder_bm</block>
|
||||
<block>satnogs_waterfall_sink</block>
|
||||
</cat>
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>Coarse Doppler Correction</name>
|
||||
<key>satnogs_coarse_doppler_correction_cc</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.coarse_doppler_correction_cc($target_freq, $sampling_rate)</make>
|
||||
<callback>set_new_freq_locked($target_freq)</callback>
|
||||
|
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>CW Matched Filter</name>
|
||||
<key>satnogs_cw_matched_filter_ff</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.cw_matched_filter_ff($sampling_rate, $carrier_freq, $wpm, $energy)</make>
|
||||
<callback>set_new_freq_locked($carrier_freq)</callback>
|
||||
|
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>CW to Symbols</name>
|
||||
<key>satnogs_cw_to_symbol</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.cw_to_symbol($sampling_rate, $threshold, $conf_level, $wpm, $auto_config)</make>
|
||||
<callback>set_act_threshold($threshold)</callback>
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
<block>
|
||||
<name>Debug Message Source</name>
|
||||
<key>satnogs_debug_msg_source</key>
|
||||
<category>satnogs</category>
|
||||
<category>[SatNOGS]/Debug</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.debug_msg_source($msg, $delay, $repeat)</make>
|
||||
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
<block>
|
||||
<name>Debug Message Source Raw</name>
|
||||
<key>satnogs_debug_msg_source_raw</key>
|
||||
<category>satnogs</category>
|
||||
<category>[SatNOGS]/Debug</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.debug_msg_source_raw($msg, $delay, $repeat)</make>
|
||||
|
||||
|
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>Doppler Correction</name>
|
||||
<key>satnogs_doppler_correction_cc</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.doppler_correction_cc($target_freq, $sampling_rate, $corrections_per_sec)</make>
|
||||
|
||||
|
|
|
@ -1,38 +0,0 @@
|
|||
<?xml version="1.0"?>
|
||||
<block>
|
||||
<name>frame_encoder</name>
|
||||
<key>satnogs_frame_encoder</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.frame_encoder($append_preamble, $ecss_encap, $dest_addr, $dest_ssid, $src_addr, $src_ssid)</make>
|
||||
<!-- Make one 'param' node for every Parameter you want settable from the GUI.
|
||||
Sub-nodes:
|
||||
* name
|
||||
* key (makes the value accessible as $keyname, e.g. in the make node)
|
||||
* type -->
|
||||
<param>
|
||||
<name>...</name>
|
||||
<key>...</key>
|
||||
<type>...</type>
|
||||
</param>
|
||||
|
||||
<!-- Make one 'sink' node per input. Sub-nodes:
|
||||
* name (an identifier for the GUI)
|
||||
* type
|
||||
* vlen
|
||||
* optional (set to 1 for optional inputs) -->
|
||||
<sink>
|
||||
<name>in</name>
|
||||
<type><!-- e.g. int, float, complex, byte, short, xxx_vector, ...--></type>
|
||||
</sink>
|
||||
|
||||
<!-- Make one 'source' node per output. Sub-nodes:
|
||||
* name (an identifier for the GUI)
|
||||
* type
|
||||
* vlen
|
||||
* optional (set to 1 for optional inputs) -->
|
||||
<source>
|
||||
<name>out</name>
|
||||
<type><!-- e.g. int, float, complex, byte, short, xxx_vector, ...--></type>
|
||||
</source>
|
||||
</block>
|
|
@ -1,19 +0,0 @@
|
|||
<?xml version="1.0"?>
|
||||
<block>
|
||||
<name>JSON to ECSS</name>
|
||||
<key>satnogs_json_to_ecss_src</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.json_to_ecss_src()</make>
|
||||
|
||||
|
||||
<sink>
|
||||
<name>in</name>
|
||||
<type>message</type>
|
||||
</sink>
|
||||
|
||||
<source>
|
||||
<name>out</name>
|
||||
<type>message</type>
|
||||
</source>
|
||||
</block>
|
|
@ -1,10 +1,10 @@
|
|||
<?xml version="1.0"?>
|
||||
<block>
|
||||
<name>whitening</name>
|
||||
<key>satnogs_whitening</key>
|
||||
<category>satnogs</category>
|
||||
<name>LEO Channel</name>
|
||||
<key>satnogs_leo_channel</key>
|
||||
<category>[SatNOGS]/Debug</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.whitening($mask, $seed, $order)</make>
|
||||
<make>satnogs.leo_channel($freq, $freq_shifts_per_sec)</make>
|
||||
<!-- Make one 'param' node for every Parameter you want settable from the GUI.
|
||||
Sub-nodes:
|
||||
* name
|
|
@ -2,7 +2,7 @@
|
|||
<block>
|
||||
<name>Morse code Debug Source</name>
|
||||
<key>satnogs_morse_debug_source</key>
|
||||
<category>satnogs</category>
|
||||
<category>[SatNOGS]/Debug</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.morse_debug_source($debug_seq, $errors, $p)</make>
|
||||
|
||||
|
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>Morse Decoder</name>
|
||||
<key>satnogs_morse_decoder</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.morse_decoder($unrecognized_char)</make>
|
||||
|
||||
|
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>Multi Format Message Sink</name>
|
||||
<key>satnogs_multi_format_msg_sink</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.multi_format_msg_sink($format)</make>
|
||||
|
||||
|
|
|
@ -0,0 +1,32 @@
|
|||
<?xml version="1.0"?>
|
||||
<block>
|
||||
<name>OGG Encoder</name>
|
||||
<key>satnogs_ogg_encoder</key>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.ogg_encoder($filename, $samp_rate, $quality)</make>
|
||||
|
||||
<param>
|
||||
<name>File</name>
|
||||
<key>filename</key>
|
||||
<value></value>
|
||||
<type>file_save</type>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>Sampling rate</name>
|
||||
<key>samp_rate</key>
|
||||
<type>real</type>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>Quality</name>
|
||||
<key>quality</key>
|
||||
<value>0.8</value>
|
||||
<type>real</type>
|
||||
</param>
|
||||
|
||||
<sink>
|
||||
<name>in</name>
|
||||
<type>float</type>
|
||||
</sink>
|
||||
</block>
|
|
@ -0,0 +1,28 @@
|
|||
<?xml version="1.0"?>
|
||||
<block>
|
||||
<name>OGG File Source</name>
|
||||
<key>satnogs_ogg_source</key>
|
||||
<category>[satnogs]</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.ogg_source($filename, $channels)</make>
|
||||
|
||||
<param>
|
||||
<name>File</name>
|
||||
<key>filename</key>
|
||||
<value></value>
|
||||
<type>file_open</type>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>Channels</name>
|
||||
<key>channels</key>
|
||||
<value>1</value>
|
||||
<type>int</type>
|
||||
</param>
|
||||
|
||||
<source>
|
||||
<name>out</name>
|
||||
<type>float</type>
|
||||
<nports>$channels</nports>
|
||||
</source>
|
||||
</block>
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>Sine Matched filter</name>
|
||||
<key>satnogs_sine_matched_filter_ff</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.sine_matched_filter_ff($sampling_rate, $sine_freq, $baud, $compute_energy)</make>
|
||||
|
||||
|
|
|
@ -2,9 +2,8 @@
|
|||
<block>
|
||||
<name>TCP rigctl Message Source</name>
|
||||
<key>satnogs_tcp_rigctl_msg_source</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.tcp_rigctl_msg_source($addr, $port, $mtu)</make>
|
||||
<make>satnogs.tcp_rigctl_msg_source($addr, $port, $mode, $interval, $mtu)</make>
|
||||
|
||||
<param>
|
||||
<name>IP Address</name>
|
||||
|
@ -14,12 +13,33 @@
|
|||
</param>
|
||||
|
||||
<param>
|
||||
<name>Listen port</name>
|
||||
<name>Port</name>
|
||||
<key>port</key>
|
||||
<value>16886</value>
|
||||
<type>int</type>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>Mode</name>
|
||||
<key>mode</key>
|
||||
<type>enum</type>
|
||||
<option>
|
||||
<name>Client</name>
|
||||
<key>False</key>
|
||||
</option>
|
||||
<option>
|
||||
<name>Server</name>
|
||||
<key>True</key>
|
||||
</option>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>Update interval (ms)</name>
|
||||
<key>interval</key>
|
||||
<value>1000</value>
|
||||
<type>int</type>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>MTU</name>
|
||||
<key>mtu</key>
|
||||
|
|
|
@ -2,7 +2,6 @@
|
|||
<block>
|
||||
<name>UDP Message Sink</name>
|
||||
<key>satnogs_udp_msg_sink</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.udp_msg_sink($addr, $port, $mtu)</make>
|
||||
<param>
|
||||
|
|
|
@ -2,9 +2,8 @@
|
|||
<block>
|
||||
<name>UDP Message Source</name>
|
||||
<key>satnogs_udp_msg_source</key>
|
||||
<category>satnogs</category>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.udp_msg_source($addr, $port, $mtu)</make>
|
||||
<make>satnogs.udp_msg_source($addr, $port, $mtu, $msg_type)</make>
|
||||
|
||||
<param>
|
||||
<name>IP Address</name>
|
||||
|
@ -27,6 +26,24 @@
|
|||
<type>int</type>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>Message Type</name>
|
||||
<key>msg_type</key>
|
||||
<type>enum</type>
|
||||
<option>
|
||||
<name>Raw</name>
|
||||
<key>0</key>
|
||||
</option>
|
||||
<option>
|
||||
<name>uin32_t</name>
|
||||
<key>1</key>
|
||||
</option>
|
||||
<option>
|
||||
<name>in32_t</name>
|
||||
<key>2</key>
|
||||
</option>
|
||||
</param>
|
||||
|
||||
<source>
|
||||
<name>msg</name>
|
||||
<type>message</type>
|
||||
|
|
|
@ -0,0 +1,67 @@
|
|||
<?xml version="1.0"?>
|
||||
<block>
|
||||
<name>Waterfall Sink</name>
|
||||
<key>satnogs_waterfall_sink</key>
|
||||
<import>import satnogs</import>
|
||||
<make>satnogs.waterfall_sink($samp_rate, $center_freq, $pps, $fft_size, $filename, $mode)</make>
|
||||
|
||||
<param>
|
||||
<name>Sample Rate</name>
|
||||
<key>samp_rate</key>
|
||||
<value>samp_rate</value>
|
||||
<type>real</type>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>FFT Size</name>
|
||||
<key>fft_size</key>
|
||||
<value>1024</value>
|
||||
<type>int</type>
|
||||
</param>
|
||||
|
||||
|
||||
<param>
|
||||
<name>Pixel Rows per Second</name>
|
||||
<key>pps</key>
|
||||
<value>10</value>
|
||||
<type>int</type>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>Mode</name>
|
||||
<key>mode</key>
|
||||
<type>enum</type>
|
||||
<option>
|
||||
<name>Simple decimation</name>
|
||||
<key>0</key>
|
||||
</option>
|
||||
<option>
|
||||
<name>Max hold</name>
|
||||
<key>1</key>
|
||||
</option>
|
||||
<option>
|
||||
<name>Mean</name>
|
||||
<key>2</key>
|
||||
</option>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>Center Frequency</name>
|
||||
<key>center_freq</key>
|
||||
<value>0.0</value>
|
||||
<type>real</type>
|
||||
</param>
|
||||
|
||||
<param>
|
||||
<name>File</name>
|
||||
<key>filename</key>
|
||||
<value></value>
|
||||
<type>file_save</type>
|
||||
</param>
|
||||
|
||||
<sink>
|
||||
<name>in</name>
|
||||
<type>complex</type>
|
||||
</sink>
|
||||
|
||||
</block>
|
|
@ -20,7 +20,14 @@
|
|||
########################################################################
|
||||
# Install public header files
|
||||
########################################################################
|
||||
install(FILES
|
||||
list(APPEND DEBUG_HEADER_FILES
|
||||
morse_debug_source.h
|
||||
debug_msg_source_raw.h
|
||||
debug_msg_source.h
|
||||
leo_channel.h
|
||||
)
|
||||
|
||||
list(APPEND HEADER_FILES
|
||||
api.h
|
||||
ax25.h
|
||||
config.h
|
||||
|
@ -29,14 +36,12 @@ install(FILES
|
|||
morse_tree.h
|
||||
morse.h
|
||||
morse_decoder.h
|
||||
morse_debug_source.h
|
||||
multi_format_msg_sink.h
|
||||
ogg_encoder.h
|
||||
cw_to_symbol.h
|
||||
sine_matched_filter_ff.h
|
||||
utils.h
|
||||
udp_msg_source.h
|
||||
debug_msg_source.h
|
||||
json_to_ecss_src.h
|
||||
tcp_rigctl_msg_source.h
|
||||
frame_encoder.h
|
||||
doppler_correction_cc.h
|
||||
|
@ -47,8 +52,16 @@ install(FILES
|
|||
whitening.h
|
||||
udp_msg_sink.h
|
||||
coarse_doppler_correction_cc.h
|
||||
debug_msg_source_raw.h
|
||||
ax25_encoder_mb.h
|
||||
ax25_decoder_bm.h
|
||||
qb50_deframer.h DESTINATION include/satnogs
|
||||
qb50_deframer.h
|
||||
waterfall_sink.h
|
||||
)
|
||||
|
||||
if(${INCLUDE_DEBUG_BLOCKS})
|
||||
list(APPEND HEADER_FILES ${DEBUG_HEADER_FILES})
|
||||
endif()
|
||||
install(FILES
|
||||
${HEADER_FILES}
|
||||
ogg_source.h DESTINATION include/satnogs
|
||||
)
|
|
@ -0,0 +1,722 @@
|
|||
/* -*- c++ -*- */
|
||||
/* GNU GENERAL PUBLIC LICENSE
|
||||
* Version 3, 29 June 2007
|
||||
*
|
||||
* Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
|
||||
* Everyone is permitted to copy and distribute verbatim copies
|
||||
* of this license document, but changing it is not allowed.
|
||||
*
|
||||
* Preamble
|
||||
*
|
||||
* The GNU General Public License is a free, copyleft license for
|
||||
* software and other kinds of works.
|
||||
*
|
||||
* The licenses for most software and other practical works are designed
|
||||
* to take away your freedom to share and change the works. By contrast,
|
||||
* the GNU General Public License is intended to guarantee your freedom to
|
||||
* share and change all versions of a program--to make sure it remains free
|
||||
* software for all its users. We, the Free Software Foundation, use the
|
||||
* GNU General Public License for most of our software; it applies also to
|
||||
* any other work released this way by its authors. You can apply it to
|
||||
* your programs, too.
|
||||
*
|
||||
* When we speak of free software, we are referring to freedom, not
|
||||
* price. Our General Public Licenses are designed to make sure that you
|
||||
* have the freedom to distribute copies of free software (and charge for
|
||||
* them if you wish), that you receive source code or can get it if you
|
||||
* want it, that you can change the software or use pieces of it in new
|
||||
* free programs, and that you know you can do these things.
|
||||
*
|
||||
* To protect your rights, we need to prevent others from denying you
|
||||
* these rights or asking you to surrender the rights. Therefore, you have
|
||||
* certain responsibilities if you distribute copies of the software, or if
|
||||
* you modify it: responsibilities to respect the freedom of others.
|
||||
*
|
||||
* For example, if you distribute copies of such a program, whether
|
||||
* gratis or for a fee, you must pass on to the recipients the same
|
||||
* freedoms that you received. You must make sure that they, too, receive
|
||||
* or can get the source code. And you must show them these terms so they
|
||||
* know their rights.
|
||||
*
|
||||
* Developers that use the GNU GPL protect your rights with two steps:
|
||||
* (1) assert copyright on the software, and (2) offer you this License
|
||||
* giving you legal permission to copy, distribute and/or modify it.
|
||||
*
|
||||
* For the developers' and authors' protection, the GPL clearly explains
|
||||
* that there is no warranty for this free software. For both users' and
|
||||
* authors' sake, the GPL requires that modified versions be marked as
|
||||
* changed, so that their problems will not be attributed erroneously to
|
||||
* authors of previous versions.
|
||||
*
|
||||
* Some devices are designed to deny users access to install or run
|
||||
* modified versions of the software inside them, although the manufacturer
|
||||
* can do so. This is fundamentally incompatible with the aim of
|
||||
* protecting users' freedom to change the software. The systematic
|
||||
* pattern of such abuse occurs in the area of products for individuals to
|
||||
* use, which is precisely where it is most unacceptable. Therefore, we
|
||||
* have designed this version of the GPL to prohibit the practice for those
|
||||
* products. If such problems arise substantially in other domains, we
|
||||
* stand ready to extend this provision to those domains in future versions
|
||||
* of the GPL, as needed to protect the freedom of users.
|
||||
*
|
||||
* Finally, every program is threatened constantly by software patents.
|
||||
* States should not allow patents to restrict development and use of
|
||||
* software on general-purpose computers, but in those that do, we wish to
|
||||
* avoid the special danger that patents applied to a free program could
|
||||
* make it effectively proprietary. To prevent this, the GPL assures that
|
||||
* patents cannot be used to render the program non-free.
|
||||
*
|
||||
* The precise terms and conditions for copying, distribution and
|
||||
* modification follow.
|
||||
*
|
||||
* TERMS AND CONDITIONS
|
||||
*
|
||||
* 0. Definitions.
|
||||
*
|
||||
* "This License" refers to version 3 of the GNU General Public License.
|
||||
*
|
||||
* "Copyright" also means copyright-like laws that apply to other kinds of
|
||||
* works, such as semiconductor masks.
|
||||
*
|
||||
* "The Program" refers to any copyrightable work licensed under this
|
||||
* License. Each licensee is addressed as "you". "Licensees" and
|
||||
* "recipients" may be individuals or organizations.
|
||||
*
|
||||
* To "modify" a work means to copy from or adapt all or part of the work
|
||||
* in a fashion requiring copyright permission, other than the making of an
|
||||
* exact copy. The resulting work is called a "modified version" of the
|
||||
* earlier work or a work "based on" the earlier work.
|
||||
*
|
||||
* A "covered work" means either the unmodified Program or a work based
|
||||
* on the Program.
|
||||
*
|
||||
* To "propagate" a work means to do anything with it that, without
|
||||
* permission, would make you directly or secondarily liable for
|
||||
* infringement under applicable copyright law, except executing it on a
|
||||
* computer or modifying a private copy. Propagation includes copying,
|
||||
* distribution (with or without modification), making available to the
|
||||
* public, and in some countries other activities as well.
|
||||
*
|
||||
* To "convey" a work means any kind of propagation that enables other
|
||||
* parties to make or receive copies. Mere interaction with a user through
|
||||
* a computer network, with no transfer of a copy, is not conveying.
|
||||
*
|
||||
* An interactive user interface displays "Appropriate Legal Notices"
|
||||
* to the extent that it includes a convenient and prominently visible
|
||||
* feature that (1) displays an appropriate copyright notice, and (2)
|
||||
* tells the user that there is no warranty for the work (except to the
|
||||
* extent that warranties are provided), that licensees may convey the
|
||||
* work under this License, and how to view a copy of this License. If
|
||||
* the interface presents a list of user commands or options, such as a
|
||||
* menu, a prominent item in the list meets this criterion.
|
||||
*
|
||||
* 1. Source Code.
|
||||
*
|
||||
* The "source code" for a work means the preferred form of the work
|
||||
* for making modifications to it. "Object code" means any non-source
|
||||
* form of a work.
|
||||
*
|
||||
* A "Standard Interface" means an interface that either is an official
|
||||
* standard defined by a recognized standards body, or, in the case of
|
||||
* interfaces specified for a particular programming language, one that
|
||||
* is widely used among developers working in that language.
|
||||
*
|
||||
* The "System Libraries" of an executable work include anything, other
|
||||
* than the work as a whole, that (a) is included in the normal form of
|
||||
* packaging a Major Component, but which is not part of that Major
|
||||
* Component, and (b) serves only to enable use of the work with that
|
||||
* Major Component, or to implement a Standard Interface for which an
|
||||
* implementation is available to the public in source code form. A
|
||||
* "Major Component", in this context, means a major essential component
|
||||
* (kernel, window system, and so on) of the specific operating system
|
||||
* (if any) on which the executable work runs, or a compiler used to
|
||||
* produce the work, or an object code interpreter used to run it.
|
||||
*
|
||||
* The "Corresponding Source" for a work in object code form means all
|
||||
* the source code needed to generate, install, and (for an executable
|
||||
* work) run the object code and to modify the work, including scripts to
|
||||
* control those activities. However, it does not include the work's
|
||||
* System Libraries, or general-purpose tools or generally available free
|
||||
* programs which are used unmodified in performing those activities but
|
||||
* which are not part of the work. For example, Corresponding Source
|
||||
* includes interface definition files associated with source files for
|
||||
* the work, and the source code for shared libraries and dynamically
|
||||
* linked subprograms that the work is specifically designed to require,
|
||||
* such as by intimate data communication or control flow between those
|
||||
* subprograms and other parts of the work.
|
||||
*
|
||||
* The Corresponding Source need not include anything that users
|
||||
* can regenerate automatically from other parts of the Corresponding
|
||||
* Source.
|
||||
*
|
||||
* The Corresponding Source for a work in source code form is that
|
||||
* same work.
|
||||
*
|
||||
* 2. Basic Permissions.
|
||||
*
|
||||
* All rights granted under this License are granted for the term of
|
||||
* copyright on the Program, and are irrevocable provided the stated
|
||||
* conditions are met. This License explicitly affirms your unlimited
|
||||
* permission to run the unmodified Program. The output from running a
|
||||
* covered work is covered by this License only if the output, given its
|
||||
* content, constitutes a covered work. This License acknowledges your
|
||||
* rights of fair use or other equivalent, as provided by copyright law.
|
||||
*
|
||||
* You may make, run and propagate covered works that you do not
|
||||
* convey, without conditions so long as your license otherwise remains
|
||||
* in force. You may convey covered works to others for the sole purpose
|
||||
* of having them make modifications exclusively for you, or provide you
|
||||
* with facilities for running those works, provided that you comply with
|
||||
* the terms of this License in conveying all material for which you do
|
||||
* not control copyright. Those thus making or running the covered works
|
||||
* for you must do so exclusively on your behalf, under your direction
|
||||
* and control, on terms that prohibit them from making any copies of
|
||||
* your copyrighted material outside their relationship with you.
|
||||
*
|
||||
* Conveying under any other circumstances is permitted solely under
|
||||
* the conditions stated below. Sublicensing is not allowed; section 10
|
||||
* makes it unnecessary.
|
||||
*
|
||||
* 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
|
||||
*
|
||||
* No covered work shall be deemed part of an effective technological
|
||||
* measure under any applicable law fulfilling obligations under article
|
||||
* 11 of the WIPO copyright treaty adopted on 20 December 1996, or
|
||||
* similar laws prohibiting or restricting circumvention of such
|
||||
* measures.
|
||||
*
|
||||
* When you convey a covered work, you waive any legal power to forbid
|
||||
* circumvention of technological measures to the extent such circumvention
|
||||
* is effected by exercising rights under this License with respect to
|
||||
* the covered work, and you disclaim any intention to limit operation or
|
||||
* modification of the work as a means of enforcing, against the work's
|
||||
* users, your or third parties' legal rights to forbid circumvention of
|
||||
* technological measures.
|
||||
*
|
||||
* 4. Conveying Verbatim Copies.
|
||||
*
|
||||
* You may convey verbatim copies of the Program's source code as you
|
||||
* receive it, in any medium, provided that you conspicuously and
|
||||
* appropriately publish on each copy an appropriate copyright notice;
|
||||
* keep intact all notices stating that this License and any
|
||||
* non-permissive terms added in accord with section 7 apply to the code;
|
||||
* keep intact all notices of the absence of any warranty; and give all
|
||||
* recipients a copy of this License along with the Program.
|
||||
*
|
||||
* You may charge any price or no price for each copy that you convey,
|
||||
* and you may offer support or warranty protection for a fee.
|
||||
*
|
||||
* 5. Conveying Modified Source Versions.
|
||||
*
|
||||
* You may convey a work based on the Program, or the modifications to
|
||||
* produce it from the Program, in the form of source code under the
|
||||
* terms of section 4, provided that you also meet all of these conditions:
|
||||
*
|
||||
* a) The work must carry prominent notices stating that you modified
|
||||
* it, and giving a relevant date.
|
||||
*
|
||||
* b) The work must carry prominent notices stating that it is
|
||||
* released under this License and any conditions added under section
|
||||
* 7. This requirement modifies the requirement in section 4 to
|
||||
* "keep intact all notices".
|
||||
*
|
||||
* c) You must license the entire work, as a whole, under this
|
||||
* License to anyone who comes into possession of a copy. This
|
||||
* License will therefore apply, along with any applicable section 7
|
||||
* additional terms, to the whole of the work, and all its parts,
|
||||
* regardless of how they are packaged. This License gives no
|
||||
* permission to license the work in any other way, but it does not
|
||||
* invalidate such permission if you have separately received it.
|
||||
*
|
||||
* d) If the work has interactive user interfaces, each must display
|
||||
* Appropriate Legal Notices; however, if the Program has interactive
|
||||
* interfaces that do not display Appropriate Legal Notices, your
|
||||
* work need not make them do so.
|
||||
*
|
||||
* A compilation of a covered work with other separate and independent
|
||||
* works, which are not by their nature extensions of the covered work,
|
||||
* and which are not combined with it such as to form a larger program,
|
||||
* in or on a volume of a storage or distribution medium, is called an
|
||||
* "aggregate" if the compilation and its resulting copyright are not
|
||||
* used to limit the access or legal rights of the compilation's users
|
||||
* beyond what the individual works permit. Inclusion of a covered work
|
||||
* in an aggregate does not cause this License to apply to the other
|
||||
* parts of the aggregate.
|
||||
*
|
||||
* 6. Conveying Non-Source Forms.
|
||||
*
|
||||
* You may convey a covered work in object code form under the terms
|
||||
* of sections 4 and 5, provided that you also convey the
|
||||
* machine-readable Corresponding Source under the terms of this License,
|
||||
* in one of these ways:
|
||||
*
|
||||
* a) Convey the object code in, or embodied in, a physical product
|
||||
* (including a physical distribution medium), accompanied by the
|
||||
* Corresponding Source fixed on a durable physical medium
|
||||
* customarily used for software interchange.
|
||||
*
|
||||
* b) Convey the object code in, or embodied in, a physical product
|
||||
* (including a physical distribution medium), accompanied by a
|
||||
* written offer, valid for at least three years and valid for as
|
||||
* long as you offer spare parts or customer support for that product
|
||||
* model, to give anyone who possesses the object code either (1) a
|
||||
* copy of the Corresponding Source for all the software in the
|
||||
* product that is covered by this License, on a durable physical
|
||||
* medium customarily used for software interchange, for a price no
|
||||
* more than your reasonable cost of physically performing this
|
||||
* conveying of source, or (2) access to copy the
|
||||
* Corresponding Source from a network server at no charge.
|
||||
*
|
||||
* c) Convey individual copies of the object code with a copy of the
|
||||
* written offer to provide the Corresponding Source. This
|
||||
* alternative is allowed only occasionally and noncommercially, and
|
||||
* only if you received the object code with such an offer, in accord
|
||||
* with subsection 6b.
|
||||
*
|
||||
* d) Convey the object code by offering access from a designated
|
||||
* place (gratis or for a charge), and offer equivalent access to the
|
||||
* Corresponding Source in the same way through the same place at no
|
||||
* further charge. You need not require recipients to copy the
|
||||
* Corresponding Source along with the object code. If the place to
|
||||
* copy the object code is a network server, the Corresponding Source
|
||||
* may be on a different server (operated by you or a third party)
|
||||
* that supports equivalent copying facilities, provided you maintain
|
||||
* clear directions next to the object code saying where to find the
|
||||
* Corresponding Source. Regardless of what server hosts the
|
||||
* Corresponding Source, you remain obligated to ensure that it is
|
||||
* available for as long as needed to satisfy these requirements.
|
||||
*
|
||||
* e) Convey the object code using peer-to-peer transmission, provided
|
||||
* you inform other peers where the object code and Corresponding
|
||||
* Source of the work are being offered to the general public at no
|
||||
* charge under subsection 6d.
|
||||
*
|
||||
* A separable portion of the object code, whose source code is excluded
|
||||
* from the Corresponding Source as a System Library, need not be
|
||||
* included in conveying the object code work.
|
||||
*
|
||||
* A "User Product" is either (1) a "consumer product", which means any
|
||||
* tangible personal property which is normally used for personal, family,
|
||||
* or household purposes, or (2) anything designed or sold for incorporation
|
||||
* into a dwelling. In determining whether a product is a consumer product,
|
||||
* doubtful cases shall be resolved in favor of coverage. For a particular
|
||||
* product received by a particular user, "normally used" refers to a
|
||||
* typical or common use of that class of product, regardless of the status
|
||||
* of the particular user or of the way in which the particular user
|
||||
* actually uses, or expects or is expected to use, the product. A product
|
||||
* is a consumer product regardless of whether the product has substantial
|
||||
* commercial, industrial or non-consumer uses, unless such uses represent
|
||||
* the only significant mode of use of the product.
|
||||
*
|
||||
* "Installation Information" for a User Product means any methods,
|
||||
* procedures, authorization keys, or other information required to install
|
||||
* and execute modified versions of a covered work in that User Product from
|
||||
* a modified version of its Corresponding Source. The information must
|
||||
* suffice to ensure that the continued functioning of the modified object
|
||||
* code is in no case prevented or interfered with solely because
|
||||
* modification has been made.
|
||||
*
|
||||
* If you convey an object code work under this section in, or with, or
|
||||
* specifically for use in, a User Product, and the conveying occurs as
|
||||
* part of a transaction in which the right of possession and use of the
|
||||
* User Product is transferred to the recipient in perpetuity or for a
|
||||
* fixed term (regardless of how the transaction is characterized), the
|
||||
* Corresponding Source conveyed under this section must be accompanied
|
||||
* by the Installation Information. But this requirement does not apply
|
||||
* if neither you nor any third party retains the ability to install
|
||||
* modified object code on the User Product (for example, the work has
|
||||
* been installed in ROM).
|
||||
*
|
||||
* The requirement to provide Installation Information does not include a
|
||||
* requirement to continue to provide support service, warranty, or updates
|
||||
* for a work that has been modified or installed by the recipient, or for
|
||||
* the User Product in which it has been modified or installed. Access to a
|
||||
* network may be denied when the modification itself materially and
|
||||
* adversely affects the operation of the network or violates the rules and
|
||||
* protocols for communication across the network.
|
||||
*
|
||||
* Corresponding Source conveyed, and Installation Information provided,
|
||||
* in accord with this section must be in a format that is publicly
|
||||
* documented (and with an implementation available to the public in
|
||||
* source code form), and must require no special password or key for
|
||||
* unpacking, reading or copying.
|
||||
*
|
||||
* 7. Additional Terms.
|
||||
*
|
||||
* "Additional permissions" are terms that supplement the terms of this
|
||||
* License by making exceptions from one or more of its conditions.
|
||||
* Additional permissions that are applicable to the entire Program shall
|
||||
* be treated as though they were included in this License, to the extent
|
||||
* that they are valid under applicable law. If additional permissions
|
||||
* apply only to part of the Program, that part may be used separately
|
||||
* under those permissions, but the entire Program remains governed by
|
||||
* this License without regard to the additional permissions.
|
||||
*
|
||||
* When you convey a copy of a covered work, you may at your option
|
||||
* remove any additional permissions from that copy, or from any part of
|
||||
* it. (Additional permissions may be written to require their own
|
||||
* removal in certain cases when you modify the work.) You may place
|
||||
* additional permissions on material, added by you to a covered work,
|
||||
* for which you have or can give appropriate copyright permission.
|
||||
*
|
||||
* Notwithstanding any other provision of this License, for material you
|
||||
* add to a covered work, you may (if authorized by the copyright holders of
|
||||
* that material) supplement the terms of this License with terms:
|
||||
*
|
||||
* a) Disclaiming warranty or limiting liability differently from the
|
||||
* terms of sections 15 and 16 of this License; or
|
||||
*
|
||||
* b) Requiring preservation of specified reasonable legal notices or
|
||||
* author attributions in that material or in the Appropriate Legal
|
||||
* Notices displayed by works containing it; or
|
||||
*
|
||||
* c) Prohibiting misrepresentation of the origin of that material, or
|
||||
* requiring that modified versions of such material be marked in
|
||||
* reasonable ways as different from the original version; or
|
||||
*
|
||||
* d) Limiting the use for publicity purposes of names of licensors or
|
||||
* authors of the material; or
|
||||
*
|
||||
* e) Declining to grant rights under trademark law for use of some
|
||||
* trade names, trademarks, or service marks; or
|
||||
*
|
||||
* f) Requiring indemnification of licensors and authors of that
|
||||
* material by anyone who conveys the material (or modified versions of
|
||||
* it) with contractual assumptions of liability to the recipient, for
|
||||
* any liability that these contractual assumptions directly impose on
|
||||
* those licensors and authors.
|
||||
*
|
||||
* All other non-permissive additional terms are considered "further
|
||||
* restrictions" within the meaning of section 10. If the Program as you
|
||||
* received it, or any part of it, contains a notice stating that it is
|
||||
* governed by this License along with a term that is a further
|
||||
* restriction, you may remove that term. If a license document contains
|
||||
* a further restriction but permits relicensing or conveying under this
|
||||
* License, you may add to a covered work material governed by the terms
|
||||
* of that license document, provided that the further restriction does
|
||||
* not survive such relicensing or conveying.
|
||||
*
|
||||
* If you add terms to a covered work in accord with this section, you
|
||||
* must place, in the relevant source files, a statement of the
|
||||
* additional terms that apply to those files, or a notice indicating
|
||||
* where to find the applicable terms.
|
||||
*
|
||||
* Additional terms, permissive or non-permissive, may be stated in the
|
||||
* form of a separately written license, or stated as exceptions;
|
||||
* the above requirements apply either way.
|
||||
*
|
||||
* 8. Termination.
|
||||
*
|
||||
* You may not propagate or modify a covered work except as expressly
|
||||
* provided under this License. Any attempt otherwise to propagate or
|
||||
* modify it is void, and will automatically terminate your rights under
|
||||
* this License (including any patent licenses granted under the third
|
||||
* paragraph of section 11).
|
||||
*
|
||||
* However, if you cease all violation of this License, then your
|
||||
* license from a particular copyright holder is reinstated (a)
|
||||
* provisionally, unless and until the copyright holder explicitly and
|
||||
* finally terminates your license, and (b) permanently, if the copyright
|
||||
* holder fails to notify you of the violation by some reasonable means
|
||||
* prior to 60 days after the cessation.
|
||||
*
|
||||
* Moreover, your license from a particular copyright holder is
|
||||
* reinstated permanently if the copyright holder notifies you of the
|
||||
* violation by some reasonable means, this is the first time you have
|
||||
* received notice of violation of this License (for any work) from that
|
||||
* copyright holder, and you cure the violation prior to 30 days after
|
||||
* your receipt of the notice.
|
||||
*
|
||||
* Termination of your rights under this section does not terminate the
|
||||
* licenses of parties who have received copies or rights from you under
|
||||
* this License. If your rights have been terminated and not permanently
|
||||
* reinstated, you do not qualify to receive new licenses for the same
|
||||
* material under section 10.
|
||||
*
|
||||
* 9. Acceptance Not Required for Having Copies.
|
||||
*
|
||||
* You are not required to accept this License in order to receive or
|
||||
* run a copy of the Program. Ancillary propagation of a covered work
|
||||
* occurring solely as a consequence of using peer-to-peer transmission
|
||||
* to receive a copy likewise does not require acceptance. However,
|
||||
* nothing other than this License grants you permission to propagate or
|
||||
* modify any covered work. These actions infringe copyright if you do
|
||||
* not accept this License. Therefore, by modifying or propagating a
|
||||
* covered work, you indicate your acceptance of this License to do so.
|
||||
*
|
||||
* 10. Automatic Licensing of Downstream Recipients.
|
||||
*
|
||||
* Each time you convey a covered work, the recipient automatically
|
||||
* receives a license from the original licensors, to run, modify and
|
||||
* propagate that work, subject to this License. You are not responsible
|
||||
* for enforcing compliance by third parties with this License.
|
||||
*
|
||||
* An "entity transaction" is a transaction transferring control of an
|
||||
* organization, or substantially all assets of one, or subdividing an
|
||||
* organization, or merging organizations. If propagation of a covered
|
||||
* work results from an entity transaction, each party to that
|
||||
* transaction who receives a copy of the work also receives whatever
|
||||
* licenses to the work the party's predecessor in interest had or could
|
||||
* give under the previous paragraph, plus a right to possession of the
|
||||
* Corresponding Source of the work from the predecessor in interest, if
|
||||
* the predecessor has it or can get it with reasonable efforts.
|
||||
*
|
||||
* You may not impose any further restrictions on the exercise of the
|
||||
* rights granted or affirmed under this License. For example, you may
|
||||
* not impose a license fee, royalty, or other charge for exercise of
|
||||
* rights granted under this License, and you may not initiate litigation
|
||||
* (including a cross-claim or counterclaim in a lawsuit) alleging that
|
||||
* any patent claim is infringed by making, using, selling, offering for
|
||||
* sale, or importing the Program or any portion of it.
|
||||
*
|
||||
* 11. Patents.
|
||||
*
|
||||
* A "contributor" is a copyright holder who authorizes use under this
|
||||
* License of the Program or a work on which the Program is based. The
|
||||
* work thus licensed is called the contributor's "contributor version".
|
||||
*
|
||||
* A contributor's "essential patent claims" are all patent claims
|
||||
* owned or controlled by the contributor, whether already acquired or
|
||||
* hereafter acquired, that would be infringed by some manner, permitted
|
||||
* by this License, of making, using, or selling its contributor version,
|
||||
* but do not include claims that would be infringed only as a
|
||||
* consequence of further modification of the contributor version. For
|
||||
* purposes of this definition, "control" includes the right to grant
|
||||
* patent sublicenses in a manner consistent with the requirements of
|
||||
* this License.
|
||||
*
|
||||
* Each contributor grants you a non-exclusive, worldwide, royalty-free
|
||||
* patent license under the contributor's essential patent claims, to
|
||||
* make, use, sell, offer for sale, import and otherwise run, modify and
|
||||
* propagate the contents of its contributor version.
|
||||
*
|
||||
* In the following three paragraphs, a "patent license" is any express
|
||||
* agreement or commitment, however denominated, not to enforce a patent
|
||||
* (such as an express permission to practice a patent or covenant not to
|
||||
* sue for patent infringement). To "grant" such a patent license to a
|
||||
* party means to make such an agreement or commitment not to enforce a
|
||||
* patent against the party.
|
||||
*
|
||||
* If you convey a covered work, knowingly relying on a patent license,
|
||||
* and the Corresponding Source of the work is not available for anyone
|
||||
* to copy, free of charge and under the terms of this License, through a
|
||||
* publicly available network server or other readily accessible means,
|
||||
* then you must either (1) cause the Corresponding Source to be so
|
||||
* available, or (2) arrange to deprive yourself of the benefit of the
|
||||
* patent license for this particular work, or (3) arrange, in a manner
|
||||
* consistent with the requirements of this License, to extend the patent
|
||||
* license to downstream recipients. "Knowingly relying" means you have
|
||||
* actual knowledge that, but for the patent license, your conveying the
|
||||
* covered work in a country, or your recipient's use of the covered work
|
||||
* in a country, would infringe one or more identifiable patents in that
|
||||
* country that you have reason to believe are valid.
|
||||
*
|
||||
* If, pursuant to or in connection with a single transaction or
|
||||
* arrangement, you convey, or propagate by procuring conveyance of, a
|
||||
* covered work, and grant a patent license to some of the parties
|
||||
* receiving the covered work authorizing them to use, propagate, modify
|
||||
* or convey a specific copy of the covered work, then the patent license
|
||||
* you grant is automatically extended to all recipients of the covered
|
||||
* work and works based on it.
|
||||
*
|
||||
* A patent license is "discriminatory" if it does not include within
|
||||
* the scope of its coverage, prohibits the exercise of, or is
|
||||
* conditioned on the non-exercise of one or more of the rights that are
|
||||
* specifically granted under this License. You may not convey a covered
|
||||
* work if you are a party to an arrangement with a third party that is
|
||||
* in the business of distributing software, under which you make payment
|
||||
* to the third party based on the extent of your activity of conveying
|
||||
* the work, and under which the third party grants, to any of the
|
||||
* parties who would receive the covered work from you, a discriminatory
|
||||
* patent license (a) in connection with copies of the covered work
|
||||
* conveyed by you (or copies made from those copies), or (b) primarily
|
||||
* for and in connection with specific products or compilations that
|
||||
* contain the covered work, unless you entered into that arrangement,
|
||||
* or that patent license was granted, prior to 28 March 2007.
|
||||
*
|
||||
* Nothing in this License shall be construed as excluding or limiting
|
||||
* any implied license or other defenses to infringement that may
|
||||
* otherwise be available to you under applicable patent law.
|
||||
*
|
||||
* 12. No Surrender of Others' Freedom.
|
||||
*
|
||||
* If conditions are imposed on you (whether by court order, agreement or
|
||||
* otherwise) that contradict the conditions of this License, they do not
|
||||
* excuse you from the conditions of this License. If you cannot convey a
|
||||
* covered work so as to satisfy simultaneously your obligations under this
|
||||
* License and any other pertinent obligations, then as a consequence you may
|
||||
* not convey it at all. For example, if you agree to terms that obligate you
|
||||
* to collect a royalty for further conveying from those to whom you convey
|
||||
* the Program, the only way you could satisfy both those terms and this
|
||||
* License would be to refrain entirely from conveying the Program.
|
||||
*
|
||||
* 13. Use with the GNU Affero General Public License.
|
||||
*
|
||||
* Notwithstanding any other provision of this License, you have
|
||||
* permission to link or combine any covered work with a work licensed
|
||||
* under version 3 of the GNU Affero General Public License into a single
|
||||
* combined work, and to convey the resulting work. The terms of this
|
||||
* License will continue to apply to the part which is the covered work,
|
||||
* but the special requirements of the GNU Affero General Public License,
|
||||
* section 13, concerning interaction through a network will apply to the
|
||||
* combination as such.
|
||||
*
|
||||
* 14. Revised Versions of this License.
|
||||
*
|
||||
* The Free Software Foundation may publish revised and/or new versions of
|
||||
* the GNU General Public License from time to time. Such new versions will
|
||||
* be similar in spirit to the present version, but may differ in detail to
|
||||
* address new problems or concerns.
|
||||
*
|
||||
* Each version is given a distinguishing version number. If the
|
||||
* Program specifies that a certain numbered version of the GNU General
|
||||
* Public License "or any later version" applies to it, you have the
|
||||
* option of following the terms and conditions either of that numbered
|
||||
* version or of any later version published by the Free Software
|
||||
* Foundation. If the Program does not specify a version number of the
|
||||
* GNU General Public License, you may choose any version ever published
|
||||
* by the Free Software Foundation.
|
||||
*
|
||||
* If the Program specifies that a proxy can decide which future
|
||||
* versions of the GNU General Public License can be used, that proxy's
|
||||
* public statement of acceptance of a version permanently authorizes you
|
||||
* to choose that version for the Program.
|
||||
*
|
||||
* Later license versions may give you additional or different
|
||||
* permissions. However, no additional obligations are imposed on any
|
||||
* author or copyright holder as a result of your choosing to follow a
|
||||
* later version.
|
||||
*
|
||||
* 15. Disclaimer of Warranty.
|
||||
*
|
||||
* THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
|
||||
* APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
|
||||
* HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
|
||||
* OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
|
||||
* IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
|
||||
* ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
*
|
||||
* 16. Limitation of Liability.
|
||||
*
|
||||
* IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
* WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
|
||||
* THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
|
||||
* GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
|
||||
* USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
|
||||
* DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
|
||||
* PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
|
||||
* EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGES.
|
||||
*
|
||||
* 17. Interpretation of Sections 15 and 16.
|
||||
*
|
||||
* If the disclaimer of warranty and limitation of liability provided
|
||||
* above cannot be given local legal effect according to their terms,
|
||||
* reviewing courts shall apply local law that most closely approximates
|
||||
* an absolute waiver of all civil liability in connection with the
|
||||
* Program, unless a warranty or assumption of liability accompanies a
|
||||
* copy of the Program in return for a fee.
|
||||
*
|
||||
* END OF TERMS AND CONDITIONS
|
||||
*
|
||||
* How to Apply These Terms to Your New Programs
|
||||
*
|
||||
* If you develop a new program, and you want it to be of the greatest
|
||||
* possible use to the public, the best way to achieve this is to make it
|
||||
* free software which everyone can redistribute and change under these terms.
|
||||
*
|
||||
* To do so, attach the following notices to the program. It is safest
|
||||
* to attach them to the start of each source file to most effectively
|
||||
* state the exclusion of warranty; and each file should have at least
|
||||
* the "copyright" line and a pointer to where the full notice is found.
|
||||
*
|
||||
* {one line to give the program's name and a brief idea of what it does.}
|
||||
* Copyright (C) {year} {name of author}
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
* Also add information on how to contact you by electronic and paper mail.
|
||||
*
|
||||
* If the program does terminal interaction, make it output a short
|
||||
* notice like this when it starts in an interactive mode:
|
||||
*
|
||||
* {project} Copyright (C) {year} {fullname}
|
||||
* This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
* This is free software, and you are welcome to redistribute it
|
||||
* under certain conditions; type `show c' for details.
|
||||
*
|
||||
* The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
* parts of the General Public License. Of course, your program's commands
|
||||
* might be different; for a GUI interface, you would use an "about box".
|
||||
*
|
||||
* You should also get your employer (if you work as a programmer) or school,
|
||||
* if any, to sign a "copyright disclaimer" for the program, if necessary.
|
||||
* For more information on this, and how to apply and follow the GNU GPL, see
|
||||
* <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
* The GNU General Public License does not permit incorporating your program
|
||||
* into proprietary programs. If your program is a subroutine library, you
|
||||
* may consider it more useful to permit linking proprietary applications with
|
||||
* the library. If this is what you want to do, use the GNU Lesser General
|
||||
* Public License instead of this License. But first, please read
|
||||
* <http://www.gnu.org/philosophy/why-not-lgpl.html>.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_SATNOGS_LEO_CHANNEL_H
|
||||
#define INCLUDED_SATNOGS_LEO_CHANNEL_H
|
||||
|
||||
#include <satnogs/api.h>
|
||||
#include <gnuradio/sync_block.h>
|
||||
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
/*!
|
||||
* \brief Channel model that emulates the signal of a LEO satellite.
|
||||
* It adds the proper doppler shift and in the future will emulate also
|
||||
* the signal fading based on the sattelite position.
|
||||
*
|
||||
* \ingroup satnogs
|
||||
*
|
||||
*/
|
||||
class SATNOGS_API leo_channel : virtual public gr::sync_block
|
||||
{
|
||||
public:
|
||||
typedef boost::shared_ptr<leo_channel> sptr;
|
||||
|
||||
/*!
|
||||
* \brief Return a shared_ptr to a new instance of satnogs::leo_channel.
|
||||
*
|
||||
* To avoid accidental use of raw pointers, satnogs::leo_channel's
|
||||
* constructor is in a private implementation
|
||||
* class. satnogs::leo_channel::make is the public interface for
|
||||
* creating new instances.
|
||||
*/
|
||||
static sptr
|
||||
make (const double freq, const double samp_rate,
|
||||
const double sat_altitude,
|
||||
const double sat_inclination,
|
||||
const size_t pass_duration_sec = 420,
|
||||
const size_t freq_shifts_per_sec = 100);
|
||||
};
|
||||
|
||||
} // namespace satnogs
|
||||
} // namespace gr
|
||||
|
||||
#endif /* INCLUDED_SATNOGS_LEO_CHANNEL_H */
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_SATNOGS_OGG_ENCODER_H
|
||||
#define INCLUDED_SATNOGS_OGG_ENCODER_H
|
||||
|
||||
#include <satnogs/api.h>
|
||||
#include <gnuradio/sync_block.h>
|
||||
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
/*!
|
||||
* \brief Ogg encoder and sink block
|
||||
* \ingroup satnogs
|
||||
*
|
||||
*/
|
||||
class SATNOGS_API ogg_encoder : virtual public gr::sync_block
|
||||
{
|
||||
public:
|
||||
typedef boost::shared_ptr<ogg_encoder> sptr;
|
||||
|
||||
/*!
|
||||
* Ogg encoder and sink block.
|
||||
* @param filename filename of the output file
|
||||
* @param samp_rate the sampling rate
|
||||
* @param quality the quality of the output file. [0.1 - 1.0] (worst - best)
|
||||
*/
|
||||
static sptr
|
||||
make (char* filename, double samp_rate, float quality);
|
||||
};
|
||||
|
||||
} // namespace satnogs
|
||||
} // namespace gr
|
||||
|
||||
#endif /* INCLUDED_SATNOGS_OGG_ENCODER_H */
|
|
@ -2,7 +2,7 @@
|
|||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2016, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
* Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
|
@ -18,39 +18,42 @@
|
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_SATNOGS_JSON_TO_ECSS_SRC_H
|
||||
#define INCLUDED_SATNOGS_JSON_TO_ECSS_SRC_H
|
||||
#ifndef INCLUDED_SATNOGS_OGG_SOURCE_H
|
||||
#define INCLUDED_SATNOGS_OGG_SOURCE_H
|
||||
|
||||
#include <satnogs/api.h>
|
||||
#include <gnuradio/sync_block.h>
|
||||
|
||||
namespace gr {
|
||||
namespace satnogs {
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
/*!
|
||||
* \brief <+description of block+>
|
||||
* \brief OGG source block. Reads a file with an OGG audio and
|
||||
* convert it to float samples
|
||||
*
|
||||
* \ingroup satnogs
|
||||
*
|
||||
*/
|
||||
class SATNOGS_API json_to_ecss_src : virtual public gr::block
|
||||
class SATNOGS_API ogg_source : virtual public gr::sync_block
|
||||
{
|
||||
public:
|
||||
typedef boost::shared_ptr<json_to_ecss_src> sptr;
|
||||
public:
|
||||
typedef boost::shared_ptr<ogg_source> sptr;
|
||||
|
||||
/*!
|
||||
* \brief Return a shared_ptr to a new instance of satnogs::json_to_ecss_src.
|
||||
*
|
||||
* To avoid accidental use of raw pointers, satnogs::json_to_ecss_src's
|
||||
* constructor is in a private implementation
|
||||
* class. satnogs::json_to_ecss_src::make is the public interface for
|
||||
* creating new instances.
|
||||
* @param filename the OGG audio file path
|
||||
* @param number of channels of the OGG stream. If the actual OGG stream
|
||||
* contains a different number of channels than specified an exception
|
||||
* is raised
|
||||
*/
|
||||
static sptr make();
|
||||
|
||||
static sptr
|
||||
make (const std::string& filename, size_t channels = 1);
|
||||
};
|
||||
|
||||
} // namespace satnogs
|
||||
} // namespace gr
|
||||
|
||||
#endif /* INCLUDED_SATNOGS_JSON_TO_ECSS_SRC_H */
|
||||
#endif /* INCLUDED_SATNOGS_OGG_SOURCE_H */
|
||||
|
|
@ -44,13 +44,19 @@ namespace gr
|
|||
|
||||
/**
|
||||
* Rigctl TCP command accepter
|
||||
*
|
||||
* @param addr the address of the interface to listen at
|
||||
* @param port the TCP port to listen for TCP connections
|
||||
* @param port the TCP port to listen or connect
|
||||
* @param serve_mode If set to yes this block, act as a rigctl server.
|
||||
* Otherwise as a rigctl client
|
||||
* @param interval_ms The interval in milliseconds at which the client
|
||||
* request the frequency from the rigctl
|
||||
* @param mtu the maximum MTU
|
||||
* @return
|
||||
*/
|
||||
static sptr
|
||||
make (const std::string& addr, uint16_t port, size_t mtu = 1500);
|
||||
make (const std::string& addr, uint16_t port, bool server_mode,
|
||||
size_t interval_ms = 1000, size_t mtu = 1500);
|
||||
};
|
||||
|
||||
} // namespace satnogs
|
||||
|
|
|
@ -48,9 +48,12 @@ namespace gr
|
|||
* @param addr the address to bind the UDP socket
|
||||
* @param port the UDP port to wait for packets
|
||||
* @param mtu the maximum MTU. Used to pre-allocate a maximum packet size
|
||||
* @param type code of the data type of each message. 0 corresponds to raw
|
||||
* bytes, 1 to 32-bit signed integers and 2 to 3 bit unsigned integers.
|
||||
*/
|
||||
static sptr
|
||||
make (const std::string& addr, uint16_t port, size_t mtu = 1500);
|
||||
make (const std::string& addr, uint16_t port, size_t mtu = 1500,
|
||||
size_t type = 0);
|
||||
};
|
||||
|
||||
} // namespace satnogs
|
||||
|
|
|
@ -0,0 +1,77 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_SATNOGS_WATERFALL_SINK_H
|
||||
#define INCLUDED_SATNOGS_WATERFALL_SINK_H
|
||||
|
||||
#include <satnogs/api.h>
|
||||
#include <gnuradio/sync_block.h>
|
||||
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
/*!
|
||||
* \brief This block computes the waterfall of the incoming signal
|
||||
* and stores the result to a file.
|
||||
*
|
||||
* The file has a special header, so that the satnogs_waterfall Gnuplot
|
||||
* script to be able to plot it properly.
|
||||
*
|
||||
* \ingroup satnogs
|
||||
*
|
||||
*/
|
||||
class SATNOGS_API waterfall_sink : virtual public gr::sync_block
|
||||
{
|
||||
public:
|
||||
typedef boost::shared_ptr<waterfall_sink> sptr;
|
||||
|
||||
/**
|
||||
* This block computes the waterfall of the incoming signal
|
||||
* and stores the result to a file.
|
||||
*
|
||||
* The file has a special header, so that the satnogs_waterfall Gnuplot
|
||||
* script to be able to plot it properly.
|
||||
*
|
||||
* @param samp_rate the sampling rate
|
||||
* @param center_freq the observation center frequency. Used only for
|
||||
* plotting reasons. For a normalized frequency x-axis set it to 0.
|
||||
* @param pps pixels per second
|
||||
* @param fft_size FFT size
|
||||
* @param filename the name of the output file
|
||||
* @param mode the mode that the waterfall.
|
||||
* - 0: Simple decimation
|
||||
* - 1: Max hold
|
||||
* - 2: Mean energy
|
||||
*
|
||||
* @return shared pointer to the object
|
||||
*/
|
||||
static sptr
|
||||
make (double samp_rate, double center_freq,
|
||||
double pps, size_t fft_size,
|
||||
const std::string& filename, int mode = 0);
|
||||
};
|
||||
|
||||
} // namespace satnogs
|
||||
} // namespace gr
|
||||
|
||||
#endif /* INCLUDED_SATNOGS_WATERFALL_SINK_H */
|
||||
|
|
@ -22,20 +22,31 @@
|
|||
########################################################################
|
||||
include(GrPlatform) #define LIB_SUFFIX
|
||||
|
||||
include_directories(${Boost_INCLUDE_DIR})
|
||||
include_directories(
|
||||
${Boost_INCLUDE_DIR}
|
||||
${VOLK_INCLUDE_DIRS}
|
||||
${VORBIS_INCLUDE_DIR}
|
||||
${OGG_INCLUDE_DIR}
|
||||
)
|
||||
|
||||
link_directories(${Boost_LIBRARY_DIRS})
|
||||
|
||||
list(APPEND satnogs_debug_sources
|
||||
morse_debug_source_impl.cc
|
||||
debug_msg_source_impl.cc
|
||||
debug_msg_source_raw_impl.cc
|
||||
leo_channel_impl.cc
|
||||
)
|
||||
list(APPEND satnogs_sources
|
||||
cw_matched_filter_ff_impl.cc
|
||||
morse_tree.cc
|
||||
morse_decoder_impl.cc
|
||||
morse_debug_source_impl.cc
|
||||
multi_format_msg_sink_impl.cc
|
||||
ogg_encoder_impl.cc
|
||||
cw_to_symbol_impl.cc
|
||||
sine_matched_filter_ff_impl.cc
|
||||
udp_msg_source_impl.cc
|
||||
debug_msg_source_impl.cc
|
||||
tcp_rigctl_msg_source_impl.cc
|
||||
json_to_ecss_src_impl.cc
|
||||
doppler_correction_cc_impl.cc
|
||||
frame_encoder_impl.cc
|
||||
doppler_fit.cc
|
||||
|
@ -45,10 +56,15 @@ list(APPEND satnogs_sources
|
|||
whitening.cc
|
||||
udp_msg_sink_impl.cc
|
||||
coarse_doppler_correction_cc_impl.cc
|
||||
debug_msg_source_raw_impl.cc
|
||||
ax25_encoder_mb_impl.cc
|
||||
ax25_decoder_bm_impl.cc
|
||||
qb50_deframer_impl.cc )
|
||||
qb50_deframer_impl.cc
|
||||
waterfall_sink_impl.cc
|
||||
ogg_source_impl.cc)
|
||||
|
||||
if(${INCLUDE_DEBUG_BLOCKS})
|
||||
list(APPEND satnogs_sources ${satnogs_debug_sources})
|
||||
endif()
|
||||
|
||||
set(satnogs_sources "${satnogs_sources}" PARENT_SCOPE)
|
||||
if(NOT satnogs_sources)
|
||||
|
@ -60,7 +76,12 @@ add_library(gnuradio-satnogs SHARED ${satnogs_sources})
|
|||
target_link_libraries(gnuradio-satnogs
|
||||
${Boost_LIBRARIES}
|
||||
${GNURADIO_ALL_LIBRARIES}
|
||||
${CMAKE_THREAD_LIBS_INIT})
|
||||
gnuradio-digital
|
||||
${CMAKE_THREAD_LIBS_INIT}
|
||||
${NOVA_LIBRARIES}
|
||||
${VOLK_LIBRARIES}
|
||||
${OGGVORBIS_LIBRARIES}
|
||||
)
|
||||
|
||||
set_target_properties(gnuradio-satnogs PROPERTIES DEFINE_SYMBOL "gnuradio_satnogs_EXPORTS")
|
||||
|
||||
|
@ -73,32 +94,11 @@ endif(APPLE)
|
|||
########################################################################
|
||||
# Install built library files
|
||||
########################################################################
|
||||
install(TARGETS gnuradio-satnogs
|
||||
LIBRARY DESTINATION lib${LIB_SUFFIX} # .so/.dylib file
|
||||
ARCHIVE DESTINATION lib${LIB_SUFFIX} # .lib file
|
||||
RUNTIME DESTINATION bin # .dll file
|
||||
)
|
||||
include(GrMiscUtils)
|
||||
GR_LIBRARY_FOO(gnuradio-satnogs RUNTIME_COMPONENT "satnogs_runtime" DEVEL_COMPONENT "satnogs_devel")
|
||||
|
||||
########################################################################
|
||||
# Build and register unit test
|
||||
# Print summary
|
||||
########################################################################
|
||||
include(GrTest)
|
||||
|
||||
#include_directories(${CPPUNIT_INCLUDE_DIRS})
|
||||
|
||||
#list(APPEND test_satnogs_sources
|
||||
# ${CMAKE_CURRENT_SOURCE_DIR}/test_satnogs.cc
|
||||
# ${CMAKE_CURRENT_SOURCE_DIR}/qa_satnogs.cc
|
||||
#)
|
||||
|
||||
#add_executable(test-satnogs ${test_satnogs_sources})
|
||||
|
||||
#target_link_libraries(
|
||||
# test-satnogs
|
||||
# ${GNURADIO_RUNTIME_LIBRARIES}
|
||||
# ${Boost_LIBRARIES}
|
||||
# ${CPPUNIT_LIBRARIES}
|
||||
# gnuradio-satnogs
|
||||
#)
|
||||
|
||||
#GR_ADD_TEST(test_satnogs test-satnogs)
|
||||
message(STATUS "Using install prefix: ${CMAKE_INSTALL_PREFIX}")
|
||||
message(STATUS "Building for version: ${VERSION} / ${LIBVER}")
|
||||
|
|
|
@ -25,6 +25,7 @@
|
|||
#include <gnuradio/io_signature.h>
|
||||
#include "coarse_doppler_correction_cc_impl.h"
|
||||
#include <volk/volk.h>
|
||||
#include <satnogs/log.h>
|
||||
|
||||
namespace gr
|
||||
{
|
||||
|
@ -49,7 +50,7 @@ namespace gr
|
|||
gr::io_signature::make (1, 1, sizeof(gr_complex))),
|
||||
d_target_freq (target_freq),
|
||||
d_samp_rate (sampling_rate),
|
||||
d_buf_items (std::min (8192UL, (size_t) (d_samp_rate / 4))),
|
||||
d_buf_items (std::min ((size_t)8192UL, (size_t) (d_samp_rate / 4))),
|
||||
d_freq_diff (0),
|
||||
d_nco ()
|
||||
{
|
||||
|
@ -86,7 +87,7 @@ namespace gr
|
|||
boost::mutex::scoped_lock lock (d_mutex);
|
||||
double new_freq;
|
||||
new_freq = pmt::to_double (msg);
|
||||
d_freq_diff = d_target_freq - new_freq;
|
||||
d_freq_diff = new_freq - d_target_freq;
|
||||
d_nco.set_freq ((2 * M_PI * (-d_freq_diff)) / d_samp_rate);
|
||||
}
|
||||
|
||||
|
|
|
@ -102,7 +102,7 @@ namespace gr
|
|||
boost::mutex::scoped_lock lock (d_mutex);
|
||||
double new_freq;
|
||||
new_freq = pmt::to_double (msg);
|
||||
d_freq_diff = d_target_freq - new_freq;
|
||||
d_freq_diff = new_freq - d_target_freq;
|
||||
if (!d_have_est) {
|
||||
d_freq_est_num++;
|
||||
d_doppler_freqs.push_back (
|
||||
|
|
|
@ -1,91 +0,0 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2016, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <gnuradio/io_signature.h>
|
||||
#include "json_to_ecss_src_impl.h"
|
||||
|
||||
#include <sstream>
|
||||
#include <map>
|
||||
|
||||
#define BUFFER_SIZE 2048
|
||||
|
||||
|
||||
namespace gr {
|
||||
namespace satnogs {
|
||||
|
||||
json_to_ecss_src::sptr
|
||||
json_to_ecss_src::make()
|
||||
{
|
||||
return gnuradio::get_initial_sptr
|
||||
(new json_to_ecss_src_impl());
|
||||
}
|
||||
|
||||
/*
|
||||
* The private constructor
|
||||
*/
|
||||
json_to_ecss_src_impl::json_to_ecss_src_impl()
|
||||
: gr::block("json_to_ecss_src",
|
||||
gr::io_signature::make (0, 0, 0),
|
||||
gr::io_signature::make (0, 0, 0)),
|
||||
is_running(true),
|
||||
d_in_port(pmt::mp("in")),
|
||||
d_out_port(pmt::mp("out"))
|
||||
{
|
||||
message_port_register_out(d_out_port);
|
||||
message_port_register_in(d_in_port);
|
||||
|
||||
d_buf = (uint8_t*)malloc(BUFFER_SIZE * sizeof(uint8_t));
|
||||
|
||||
new boost::thread (
|
||||
boost::bind (&json_to_ecss_src_impl::json_accepter, this));
|
||||
}
|
||||
|
||||
/*
|
||||
* Our virtual destructor.
|
||||
*/
|
||||
json_to_ecss_src_impl::~json_to_ecss_src_impl()
|
||||
{
|
||||
is_running = false;
|
||||
}
|
||||
void
|
||||
json_to_ecss_src_impl::json_accepter(){
|
||||
pmt::pmt_t message;
|
||||
size_t length;
|
||||
|
||||
while(is_running){
|
||||
message = delete_head_blocking(d_in_port);
|
||||
length = blob_length(message);
|
||||
d_buf = (uint8_t*)blob_data(message);
|
||||
std::istringstream ss(std::string(d_buf, d_buf + length));
|
||||
ptree tree;
|
||||
read_json(ss,tree);
|
||||
BOOST_FOREACH(const ptree::value_type &v, tree) {
|
||||
std::cout<<"First = "<<v.first << "Second = "<<v.second.data()<<std::endl ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} /* namespace satnogs */
|
||||
} /* namespace gr */
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2016, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <gnuradio/io_signature.h>
|
||||
#include "leo_channel_impl.h"
|
||||
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
leo_channel::sptr
|
||||
leo_channel::make (const double freq, const double samp_rate,
|
||||
const double sat_altitude, const double sat_inclination,
|
||||
const size_t pass_duration_sec,
|
||||
const size_t freq_shifts_per_sec)
|
||||
{
|
||||
return gnuradio::get_initial_sptr (
|
||||
new leo_channel_impl (freq, freq_shifts_per_sec));
|
||||
}
|
||||
|
||||
/*
|
||||
* The private constructor
|
||||
*/
|
||||
leo_channel_impl::leo_channel_impl (const double freq,
|
||||
const size_t freq_shifts_per_sec) :
|
||||
gr::sync_block ("leo_channel",
|
||||
gr::io_signature::make (1, 1, sizeof(gr_complex)),
|
||||
gr::io_signature::make (1, 1, sizeof(gr_complex))),
|
||||
d_freq (freq),
|
||||
d_shifts_per_sec (freq_shifts_per_sec)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* Our virtual destructor.
|
||||
*/
|
||||
leo_channel_impl::~leo_channel_impl ()
|
||||
{
|
||||
}
|
||||
|
||||
int
|
||||
leo_channel_impl::work (int noutput_items,
|
||||
gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items)
|
||||
{
|
||||
const gr_complex *in = (const gr_complex *) input_items[0];
|
||||
gr_complex *out = (gr_complex *) output_items[0];
|
||||
|
||||
// Do <+signal processing+>
|
||||
|
||||
// Tell runtime system how many output items we produced.
|
||||
return noutput_items;
|
||||
}
|
||||
|
||||
} /* namespace satnogs */
|
||||
} /* namespace gr */
|
||||
|
|
@ -18,46 +18,35 @@
|
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_SATNOGS_JSON_TO_ECSS_SRC_IMPL_H
|
||||
#define INCLUDED_SATNOGS_JSON_TO_ECSS_SRC_IMPL_H
|
||||
#ifndef INCLUDED_SATNOGS_LEO_CHANNEL_IMPL_H
|
||||
#define INCLUDED_SATNOGS_LEO_CHANNEL_IMPL_H
|
||||
|
||||
#include <satnogs/json_to_ecss_src.h>
|
||||
#include <boost/property_tree/ptree.hpp>
|
||||
#include <boost/property_tree/json_parser.hpp>
|
||||
#include <satnogs/leo_channel.h>
|
||||
#include <libnova/libnova.h>
|
||||
|
||||
using boost::property_tree::ptree;
|
||||
using boost::property_tree::read_json;
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
|
||||
|
||||
namespace gr {
|
||||
namespace satnogs {
|
||||
|
||||
class json_to_ecss_src_impl : public json_to_ecss_src
|
||||
class leo_channel_impl : public leo_channel
|
||||
{
|
||||
private:
|
||||
// Nothing to declare in this block.
|
||||
bool is_running;
|
||||
pmt::pmt_t d_in_port;
|
||||
pmt::pmt_t d_out_port;
|
||||
private:
|
||||
const double d_freq;
|
||||
const size_t d_shifts_per_sec;
|
||||
|
||||
uint8_t* d_buf;
|
||||
|
||||
void json_accepter();
|
||||
|
||||
public:
|
||||
json_to_ecss_src_impl();
|
||||
~json_to_ecss_src_impl();
|
||||
public:
|
||||
leo_channel_impl (const double freq, const size_t freq_shifts_per_sec);
|
||||
~leo_channel_impl ();
|
||||
|
||||
// Where all the action really happens
|
||||
int work(int noutput_items,
|
||||
gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items);
|
||||
|
||||
int
|
||||
work (int noutput_items, gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items);
|
||||
};
|
||||
|
||||
} // namespace satnogs
|
||||
} // namespace gr
|
||||
|
||||
#endif /* INCLUDED_SATNOGS_JSON_TO_ECSS_SRC_IMPL_H */
|
||||
#endif /* INCLUDED_SATNOGS_LEO_CHANNEL_IMPL_H */
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <gnuradio/io_signature.h>
|
||||
#include "ogg_encoder_impl.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <math.h>
|
||||
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
ogg_encoder::sptr
|
||||
ogg_encoder::make (char* filename, double samp_rate, float quality)
|
||||
{
|
||||
return gnuradio::get_initial_sptr (
|
||||
new ogg_encoder_impl (filename, samp_rate, quality));
|
||||
}
|
||||
|
||||
/*
|
||||
* The private constructor
|
||||
*/
|
||||
ogg_encoder_impl::ogg_encoder_impl (char* filename, double samp_rate,
|
||||
float quality) :
|
||||
gr::sync_block ("ogg_encoder",
|
||||
gr::io_signature::make (1, 1, sizeof(float)),
|
||||
gr::io_signature::make (0, 0, 0))
|
||||
{
|
||||
d_quality = quality;
|
||||
d_out = fopen (filename, "wb");
|
||||
d_samp_rate = samp_rate;
|
||||
vorbis_info_init (&d_vi);
|
||||
int ret = vorbis_encode_init_vbr (&d_vi, 1, d_samp_rate, d_quality);
|
||||
if (ret)
|
||||
exit (1);
|
||||
|
||||
vorbis_comment_init (&d_vc);
|
||||
vorbis_comment_add_tag (&d_vc, "ENCODER", "satnogs ogg encoder");
|
||||
|
||||
vorbis_analysis_init (&d_vd, &d_vi);
|
||||
vorbis_block_init (&d_vd, &d_vb);
|
||||
|
||||
srand (time (NULL));
|
||||
ogg_stream_init (&d_os, rand ());
|
||||
|
||||
ogg_packet header;
|
||||
ogg_packet header_comm;
|
||||
ogg_packet header_code;
|
||||
|
||||
vorbis_analysis_headerout (&d_vd, &d_vc, &header, &header_comm,
|
||||
&header_code);
|
||||
ogg_stream_packetin (&d_os, &header);
|
||||
ogg_stream_packetin (&d_os, &header_comm);
|
||||
ogg_stream_packetin (&d_os, &header_code);
|
||||
int result = 1;
|
||||
while (result) {
|
||||
result = ogg_stream_flush (&d_os, &d_og);
|
||||
if (result == 0)
|
||||
break;
|
||||
fwrite (d_og.header, 1, d_og.header_len, d_out);
|
||||
fwrite (d_og.body, 1, d_og.body_len, d_out);
|
||||
}
|
||||
}
|
||||
|
||||
ogg_encoder_impl::~ogg_encoder_impl ()
|
||||
{
|
||||
vorbis_analysis_wrote (&d_vd, 0);
|
||||
ogg_stream_clear (&d_os);
|
||||
vorbis_block_clear (&d_vb);
|
||||
vorbis_dsp_clear (&d_vd);
|
||||
vorbis_comment_clear (&d_vc);
|
||||
vorbis_info_clear (&d_vi);
|
||||
fclose (d_out);
|
||||
}
|
||||
|
||||
int
|
||||
ogg_encoder_impl::work (int noutput_items,
|
||||
gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items)
|
||||
{
|
||||
const char *in = (const char *) input_items[0];
|
||||
int i;
|
||||
float **buffer = vorbis_analysis_buffer (&d_vd, noutput_items);
|
||||
memcpy(buffer[0], in, noutput_items * sizeof(float));
|
||||
|
||||
vorbis_analysis_wrote (&d_vd, noutput_items);
|
||||
|
||||
while (vorbis_analysis_blockout (&d_vd, &d_vb) == 1) {
|
||||
vorbis_analysis (&d_vb, NULL);
|
||||
vorbis_bitrate_addblock (&d_vb);
|
||||
|
||||
while (vorbis_bitrate_flushpacket (&d_vd, &d_op)) {
|
||||
|
||||
ogg_stream_packetin (&d_os, &d_op);
|
||||
int result = 1;
|
||||
while (result) {
|
||||
int result = ogg_stream_pageout (&d_os, &d_og);
|
||||
if (result == 0)
|
||||
break;
|
||||
fwrite (d_og.header, 1, d_og.header_len, d_out);
|
||||
fwrite (d_og.body, 1, d_og.body_len, d_out);
|
||||
if (ogg_page_eos (&d_og))
|
||||
result = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return noutput_items;
|
||||
}
|
||||
|
||||
} /* namespace satnogs */
|
||||
} /* namespace gr */
|
|
@ -0,0 +1,62 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_SATNOGS_OGG_ENCODER_IMPL_H
|
||||
#define INCLUDED_SATNOGS_OGG_ENCODER_IMPL_H
|
||||
|
||||
#include <satnogs/ogg_encoder.h>
|
||||
#include <vorbis/vorbisenc.h>
|
||||
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
class ogg_encoder_impl : public ogg_encoder
|
||||
{
|
||||
private:
|
||||
// Nothing to declare in this block.
|
||||
ogg_stream_state d_os;
|
||||
ogg_page d_og;
|
||||
ogg_packet d_op;
|
||||
|
||||
vorbis_info d_vi;
|
||||
vorbis_comment d_vc;
|
||||
|
||||
vorbis_dsp_state d_vd;
|
||||
vorbis_block d_vb;
|
||||
FILE* d_out;
|
||||
double d_samp_rate;
|
||||
float d_quality;
|
||||
|
||||
public:
|
||||
ogg_encoder_impl (char* filename, double samp_rate, float quality);
|
||||
~ogg_encoder_impl ();
|
||||
|
||||
// Where all the action really happens
|
||||
int
|
||||
work (int noutput_items, gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items);
|
||||
};
|
||||
|
||||
} // namespace satnogs
|
||||
} // namespace gr
|
||||
|
||||
#endif /* INCLUDED_SATNOGS_OGG_ENCODER_IMPL_H */
|
|
@ -0,0 +1,125 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <gnuradio/io_signature.h>
|
||||
#include <vorbis/codec.h>
|
||||
#include <vorbis/vorbisfile.h>
|
||||
#include <volk/volk.h>
|
||||
|
||||
#include "ogg_source_impl.h"
|
||||
|
||||
#define PCM_BUF_SIZE 4096
|
||||
|
||||
namespace gr {
|
||||
namespace satnogs {
|
||||
|
||||
ogg_source::sptr
|
||||
ogg_source::make(const std::string& filename, size_t channels)
|
||||
{
|
||||
return gnuradio::get_initial_sptr
|
||||
(new ogg_source_impl(filename, channels));
|
||||
}
|
||||
|
||||
/*
|
||||
* The private constructor
|
||||
*/
|
||||
ogg_source_impl::ogg_source_impl (const std::string& filename,
|
||||
size_t channels) :
|
||||
gr::sync_block (
|
||||
"ogg_source", gr::io_signature::make (0, 0, 0),
|
||||
gr::io_signature::make (channels, channels, sizeof(float))),
|
||||
d_channels (channels)
|
||||
{
|
||||
if (channels < 1) {
|
||||
throw std::invalid_argument ("At least one output channels should"
|
||||
" be specified");
|
||||
}
|
||||
|
||||
if (ov_fopen (filename.c_str (), &d_ogvorb_f) < 0) {
|
||||
throw std::invalid_argument ("Invalid .ogg file");
|
||||
}
|
||||
|
||||
vorbis_info *vi = ov_info(&d_ogvorb_f,-1);
|
||||
if(vi->channels != (int) channels) {
|
||||
throw std::invalid_argument (
|
||||
std::string ("Channels number specified (")
|
||||
+ std::to_string (channels)
|
||||
+ ") does not match the channels of "
|
||||
"the ogg stream (" + std::to_string (vi->channels) + ")");
|
||||
}
|
||||
|
||||
const int alignment_multiple = volk_get_alignment() / sizeof(float);
|
||||
set_alignment(std::max(1,alignment_multiple));
|
||||
set_max_noutput_items(PCM_BUF_SIZE);
|
||||
|
||||
d_in_buffer = (int16_t *)volk_malloc(PCM_BUF_SIZE * sizeof(int16_t),
|
||||
volk_get_alignment());
|
||||
d_out_buffer = (float *)volk_malloc(PCM_BUF_SIZE * sizeof(float),
|
||||
volk_get_alignment());
|
||||
}
|
||||
|
||||
/*
|
||||
* Our virtual destructor.
|
||||
*/
|
||||
ogg_source_impl::~ogg_source_impl()
|
||||
{
|
||||
ov_clear(&d_ogvorb_f);
|
||||
volk_free(d_in_buffer);
|
||||
volk_free(d_out_buffer);
|
||||
}
|
||||
|
||||
int
|
||||
ogg_source_impl::work(int noutput_items,
|
||||
gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items)
|
||||
{
|
||||
long int ret;
|
||||
int section = 0;
|
||||
int available = (noutput_items / d_channels);
|
||||
int produced = 0;
|
||||
|
||||
ret = ov_read (&d_ogvorb_f, (char *)d_in_buffer,
|
||||
available * sizeof(int16_t),
|
||||
0, sizeof(int16_t), 1, §ion);
|
||||
if(ret < sizeof(int16_t)) {
|
||||
return WORK_DONE;
|
||||
}
|
||||
|
||||
/* Convert to float the signed-short audio samples */
|
||||
volk_16i_s32f_convert_32f (d_out_buffer, d_in_buffer, 2 << 15,
|
||||
ret / sizeof(int16_t));
|
||||
|
||||
/* De-interleave the available channels */
|
||||
for(int i = 0; i < ret / sizeof(int16_t); i += d_channels, produced++) {
|
||||
for(int chan = 0; chan < d_channels; chan++){
|
||||
((float *)output_items[chan])[produced] = d_out_buffer[i * d_channels + chan];
|
||||
}
|
||||
}
|
||||
|
||||
return produced;
|
||||
}
|
||||
|
||||
} /* namespace satnogs */
|
||||
} /* namespace gr */
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_SATNOGS_OGG_SOURCE_IMPL_H
|
||||
#define INCLUDED_SATNOGS_OGG_SOURCE_IMPL_H
|
||||
|
||||
#include <satnogs/ogg_source.h>
|
||||
#include <vorbis/codec.h>
|
||||
#include <vorbis/vorbisfile.h>
|
||||
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
class ogg_source_impl : public ogg_source
|
||||
{
|
||||
private:
|
||||
const size_t d_channels;
|
||||
OggVorbis_File d_ogvorb_f;
|
||||
|
||||
int16_t *d_in_buffer;
|
||||
float *d_out_buffer;
|
||||
|
||||
public:
|
||||
ogg_source_impl (const std::string& filename, size_t channels);
|
||||
~ogg_source_impl ();
|
||||
|
||||
// Where all the action really happens
|
||||
int
|
||||
work (int noutput_items, gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items);
|
||||
};
|
||||
|
||||
} // namespace satnogs
|
||||
} // namespace gr
|
||||
|
||||
#endif /* INCLUDED_SATNOGS_OGG_SOURCE_IMPL_H */
|
||||
|
|
@ -38,7 +38,6 @@
|
|||
#include <netinet/in.h>
|
||||
#include <netinet/tcp.h>
|
||||
|
||||
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
|
@ -46,50 +45,163 @@ namespace gr
|
|||
|
||||
tcp_rigctl_msg_source::sptr
|
||||
tcp_rigctl_msg_source::make (const std::string& addr, uint16_t port,
|
||||
size_t mtu)
|
||||
bool server_mode, size_t interval_ms,
|
||||
size_t mtu)
|
||||
{
|
||||
return gnuradio::get_initial_sptr (
|
||||
new tcp_rigctl_msg_source_impl (addr, port, mtu));
|
||||
new tcp_rigctl_msg_source_impl (addr, port, server_mode, interval_ms,
|
||||
mtu));
|
||||
}
|
||||
|
||||
/*
|
||||
* The private constructor
|
||||
*/
|
||||
tcp_rigctl_msg_source_impl::tcp_rigctl_msg_source_impl (
|
||||
const std::string& addr, uint16_t port, size_t mtu) :
|
||||
gr::block ("tcp_rigctl_msg_source",
|
||||
gr::io_signature::make (0, 0, 0),
|
||||
gr::io_signature::make (0, 0, 0)),
|
||||
d_iface_addr (addr),
|
||||
d_port (port),
|
||||
d_mtu (mtu),
|
||||
d_running (true)
|
||||
const std::string& addr, uint16_t port, bool server_mode,
|
||||
size_t interval_ms, size_t mtu) :
|
||||
gr::block ("tcp_rigctl_msg_source",
|
||||
gr::io_signature::make (0, 0, 0),
|
||||
gr::io_signature::make (0, 0, 0)),
|
||||
d_ip_addr (addr),
|
||||
d_port (port),
|
||||
d_is_server (server_mode),
|
||||
d_interval_ms(interval_ms),
|
||||
d_mtu (mtu),
|
||||
d_running (true)
|
||||
{
|
||||
message_port_register_out (pmt::mp ("freq"));
|
||||
boost::shared_ptr<boost::thread> (
|
||||
new boost::thread (
|
||||
boost::bind (&tcp_rigctl_msg_source_impl::tcp_msg_accepter,
|
||||
this)));
|
||||
if(d_is_server) {
|
||||
d_thread = boost::shared_ptr<boost::thread> (
|
||||
new boost::thread (
|
||||
boost::bind (&tcp_rigctl_msg_source_impl::rigctl_server, this)));
|
||||
}
|
||||
else{
|
||||
d_thread = boost::shared_ptr<boost::thread> (
|
||||
new boost::thread (
|
||||
boost::bind (&tcp_rigctl_msg_source_impl::rigctl_client, this)));
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
send_freq(int sock, uint64_t freq)
|
||||
send_freq (int sock, uint64_t freq)
|
||||
{
|
||||
static char buf[512];
|
||||
snprintf(buf, 512, "%llu\n", freq);
|
||||
send(sock, buf, strnlen(buf, 512), 0);
|
||||
snprintf (buf, 512, "%llu\n", freq);
|
||||
send (sock, buf, strnlen (buf, 512), 0);
|
||||
}
|
||||
|
||||
static inline void
|
||||
send_report_code(int sock, int code)
|
||||
send_report_code (int sock, int code)
|
||||
{
|
||||
static char buf[512];
|
||||
snprintf(buf, 512, "RPRT %d\n", code);
|
||||
send(sock, buf, strnlen(buf, 512), 0);
|
||||
snprintf (buf, 512, "RPRT %d\n", code);
|
||||
send (sock, buf, strnlen (buf, 512), 0);
|
||||
}
|
||||
|
||||
static inline void
|
||||
request_freq_msg (int sock)
|
||||
{
|
||||
static const char *cmd = "f\n";
|
||||
send (sock, cmd, strnlen(cmd, 2), 0);
|
||||
}
|
||||
|
||||
static inline void
|
||||
send_quit(int sock)
|
||||
{
|
||||
static const char *cmd = "q\n";
|
||||
send (sock, cmd, strnlen(cmd, 2), 0);
|
||||
}
|
||||
|
||||
void
|
||||
tcp_rigctl_msg_source_impl::tcp_msg_accepter ()
|
||||
tcp_rigctl_msg_source_impl::rigctl_client ()
|
||||
{
|
||||
int sock;
|
||||
struct sockaddr_in sin;
|
||||
ssize_t ret;
|
||||
uint8_t *buf;
|
||||
double freq = 0.0;
|
||||
int optval = 1;
|
||||
struct timeval timeout;
|
||||
timeout.tv_sec = 2;
|
||||
timeout.tv_usec = 0;
|
||||
|
||||
if ((sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
|
||||
perror ("opening UDP socket");
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
memset (&sin, 0, sizeof(struct sockaddr_in));
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons (d_port);
|
||||
sin.sin_addr.s_addr = INADDR_ANY;
|
||||
|
||||
if (inet_aton (d_ip_addr.c_str (), &(sin.sin_addr)) == 0) {
|
||||
LOG_ERROR("Wrong IP address");
|
||||
close (sock);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (connect(sock, (struct sockaddr *)&sin, sizeof(struct sockaddr_in)) != 0) {
|
||||
LOG_ERROR("Could not connect at rigctl server %s", d_ip_addr.c_str());
|
||||
close (sock);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Apply the TCP_NODELAY option at the socket for a packet based
|
||||
* behavior.
|
||||
*/
|
||||
if (setsockopt (sock, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(int))
|
||||
< 0) {
|
||||
perror ("TCP setsockopt TCP_NODELAY");
|
||||
shutdown(sock, SHUT_RDWR);
|
||||
close(sock);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* Set a reasonable timeout at the response from the server */
|
||||
if (setsockopt (sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout))
|
||||
< 0) {
|
||||
perror ("TCP setsockopt SO_RCVTIMEO");
|
||||
shutdown (sock, SHUT_RDWR);
|
||||
close (sock);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* All good until now. Allocate buffer memory and proceed */
|
||||
buf = new uint8_t[d_mtu];
|
||||
sleep(2);
|
||||
while (d_running) {
|
||||
/* Request frequency from rigctl */
|
||||
request_freq_msg (sock);
|
||||
ret = recv (sock, buf, d_mtu, 0);
|
||||
if (ret > 0) {
|
||||
freq = get_freq_from_buf (buf);
|
||||
/*
|
||||
* If the frequency is different than 0, then the parsed value
|
||||
* is valid and an appropriate message can be generated
|
||||
*
|
||||
* NOTE: Comparison for equality in floats is a bit tricky.
|
||||
* But here the get_freq_from_buf() will assign a 0.0 explicitly
|
||||
* if something goes wrong. For this reason it is safe to compare
|
||||
* the in-equality against 0.0.
|
||||
*/
|
||||
if (freq != 0.0 && !std::isnan(freq)) {
|
||||
message_port_pub (pmt::mp ("freq"), pmt::from_double (freq));
|
||||
}
|
||||
}
|
||||
boost::this_thread::sleep(boost::posix_time::milliseconds(d_interval_ms));
|
||||
}
|
||||
|
||||
send_quit(sock);
|
||||
shutdown (sock, SHUT_RDWR);
|
||||
close (sock);
|
||||
delete[] buf;
|
||||
exit (EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
void
|
||||
tcp_rigctl_msg_source_impl::rigctl_server ()
|
||||
{
|
||||
int sock;
|
||||
int listen_sock;
|
||||
|
@ -104,8 +216,8 @@ namespace gr
|
|||
int optval = 1;
|
||||
|
||||
if ((listen_sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
|
||||
perror ("opening UDP socket");
|
||||
exit (EXIT_FAILURE);
|
||||
perror ("opening UDP socket");
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
memset (&client_addr, 0, sizeof(struct sockaddr));
|
||||
|
@ -114,84 +226,88 @@ namespace gr
|
|||
sin.sin_port = htons (d_port);
|
||||
sin.sin_addr.s_addr = INADDR_ANY;
|
||||
|
||||
if (inet_aton (d_iface_addr.c_str (), &(sin.sin_addr)) == 0) {
|
||||
LOG_ERROR("Wrong IP address");
|
||||
close (listen_sock);
|
||||
exit (EXIT_FAILURE);
|
||||
if (inet_aton (d_ip_addr.c_str (), &(sin.sin_addr)) == 0) {
|
||||
LOG_ERROR("Wrong IP address");
|
||||
close (listen_sock);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (bind (listen_sock, (struct sockaddr *) &sin,
|
||||
sizeof(struct sockaddr_in)) == -1) {
|
||||
perror ("TCP bind");
|
||||
close (listen_sock);
|
||||
exit (EXIT_FAILURE);
|
||||
sizeof(struct sockaddr_in)) == -1) {
|
||||
perror ("TCP bind");
|
||||
close (listen_sock);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (listen (listen_sock, 1000) == -1) {
|
||||
perror ("TCP listen");
|
||||
close (listen_sock);
|
||||
exit (EXIT_FAILURE);
|
||||
perror ("TCP listen");
|
||||
close (listen_sock);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* All good until now. Allocate buffer memory and proceed */
|
||||
buf = new uint8_t[d_mtu];
|
||||
|
||||
while (d_running) {
|
||||
sock = accept (listen_sock, &client_addr, &client_addr_len);
|
||||
if (sock <= 0) {
|
||||
perror ("TCP accept");
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
sock = accept (listen_sock, &client_addr, &client_addr_len);
|
||||
if (sock <= 0) {
|
||||
perror ("TCP accept");
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* Apply the TCP_NODELAY option at the accepted socket */
|
||||
if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(int)) < 0){
|
||||
perror ("TCP setsockopt");
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
/* Apply the TCP_NODELAY option at the accepted socket */
|
||||
if (setsockopt (sock, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(int))
|
||||
< 0) {
|
||||
perror ("TCP setsockopt");
|
||||
shutdown(sock, SHUT_RDWR);
|
||||
close(sock);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
while ((ret = recv (sock, buf, d_mtu, 0)) > 0 && d_running) {
|
||||
switch (buf[0])
|
||||
{
|
||||
case 'F':
|
||||
freq = get_freq_from_buf (buf + 2);
|
||||
/*
|
||||
* If the frequency is different than 0, then the parsed value
|
||||
* is valid and an appropriate message can be generated
|
||||
*
|
||||
* NOTE: Comparison for equality in floats is a bit tricky.
|
||||
* But here the get_freq_from_buf() will assign a 0.0 explicitly
|
||||
* if something goes wrong. For this reason it is safe to compare
|
||||
* the in-equality agains 0.0.
|
||||
*/
|
||||
if (freq != 0.0) {
|
||||
reported_freq = freq;
|
||||
message_port_pub (pmt::mp ("freq"), pmt::from_double (freq));
|
||||
error_code = 0;
|
||||
}
|
||||
else{
|
||||
error_code = -11;
|
||||
}
|
||||
/* Send the report code */
|
||||
send_report_code(sock, error_code);
|
||||
break;
|
||||
case 'f':
|
||||
send_freq(sock, reported_freq);
|
||||
break;
|
||||
/* Terminate the connection and exit */
|
||||
case 'q':
|
||||
send_report_code(sock, 0);
|
||||
d_running = false;
|
||||
break;
|
||||
default:
|
||||
LOG_WARN("Unsupported rigctl command");
|
||||
send_report_code(sock, -11);
|
||||
}
|
||||
}
|
||||
shutdown (sock, SHUT_RDWR);
|
||||
close (sock);
|
||||
while ((ret = recv (sock, buf, d_mtu, 0)) > 0 && d_running) {
|
||||
switch (buf[0])
|
||||
{
|
||||
case 'F':
|
||||
freq = get_freq_from_buf (buf + 2);
|
||||
/*
|
||||
* If the frequency is different than 0, then the parsed value
|
||||
* is valid and an appropriate message can be generated
|
||||
*
|
||||
* NOTE: Comparison for equality in floats is a bit tricky.
|
||||
* But here the get_freq_from_buf() will assign a 0.0 explicitly
|
||||
* if something goes wrong. For this reason it is safe to compare
|
||||
* the in-equality against 0.0.
|
||||
*/
|
||||
if (freq != 0.0) {
|
||||
reported_freq = freq;
|
||||
message_port_pub (pmt::mp ("freq"), pmt::from_double (freq));
|
||||
error_code = 0;
|
||||
}
|
||||
else {
|
||||
error_code = -11;
|
||||
}
|
||||
/* Send the report code */
|
||||
send_report_code (sock, error_code);
|
||||
break;
|
||||
case 'f':
|
||||
send_freq (sock, reported_freq);
|
||||
break;
|
||||
/* Terminate the connection and exit */
|
||||
case 'q':
|
||||
send_report_code (sock, 0);
|
||||
d_running = false;
|
||||
break;
|
||||
default:
|
||||
LOG_WARN("Unsupported rigctl command");
|
||||
send_report_code (sock, -11);
|
||||
}
|
||||
}
|
||||
shutdown (sock, SHUT_RDWR);
|
||||
close (sock);
|
||||
}
|
||||
shutdown (listen_sock, SHUT_RDWR);
|
||||
close (listen_sock);
|
||||
delete [] buf;
|
||||
delete[] buf;
|
||||
exit (EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
|
@ -210,14 +326,14 @@ namespace gr
|
|||
|
||||
/* Check for various possible errors */
|
||||
if ((errno == ERANGE && (f == LONG_MAX || f == LONG_MIN))
|
||||
|| (errno != 0 && f == 0)) {
|
||||
LOG_WARN("Invalid rigctl command");
|
||||
f = 0;
|
||||
|| (errno != 0 && f == 0)) {
|
||||
LOG_WARN("Invalid rigctl command");
|
||||
f = 0;
|
||||
}
|
||||
|
||||
if ((char *) buf == end) {
|
||||
LOG_WARN("Invalid rigctl command");
|
||||
f = 0;
|
||||
LOG_WARN("Invalid rigctl command");
|
||||
f = 0;
|
||||
}
|
||||
|
||||
return (double) f;
|
||||
|
|
|
@ -31,20 +31,26 @@ namespace gr
|
|||
class tcp_rigctl_msg_source_impl : public tcp_rigctl_msg_source
|
||||
{
|
||||
private:
|
||||
const std::string d_iface_addr;
|
||||
const std::string d_ip_addr;
|
||||
const uint16_t d_port;
|
||||
const bool d_is_server;
|
||||
const size_t d_interval_ms;
|
||||
const size_t d_mtu;
|
||||
bool d_running;
|
||||
boost::shared_ptr<boost::thread> d_thread;
|
||||
|
||||
void
|
||||
tcp_msg_accepter();
|
||||
rigctl_server();
|
||||
|
||||
void
|
||||
rigctl_client();
|
||||
|
||||
double
|
||||
get_freq_from_buf(const uint8_t *buf);
|
||||
|
||||
public:
|
||||
tcp_rigctl_msg_source_impl (const std::string& addr, uint16_t port,
|
||||
bool server_mode, size_t interval_ms,
|
||||
size_t mtu);
|
||||
~tcp_rigctl_msg_source_impl ();
|
||||
};
|
||||
|
|
|
@ -33,37 +33,37 @@
|
|||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
|
||||
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
udp_msg_source::sptr
|
||||
udp_msg_source::make (const std::string& addr, uint16_t port, size_t mtu)
|
||||
udp_msg_source::make (const std::string& addr, uint16_t port, size_t mtu,
|
||||
size_t type)
|
||||
{
|
||||
return gnuradio::get_initial_sptr (
|
||||
new udp_msg_source_impl (addr, port, mtu));
|
||||
new udp_msg_source_impl (addr, port, mtu, type));
|
||||
}
|
||||
|
||||
/*
|
||||
* The private constructor
|
||||
*/
|
||||
udp_msg_source_impl::udp_msg_source_impl (const std::string& addr,
|
||||
uint16_t port,
|
||||
size_t mtu) :
|
||||
gr::block ("udp_msg_source",
|
||||
gr::io_signature::make (0, 0, 0),
|
||||
gr::io_signature::make (0, 0, 0)),
|
||||
d_iface_addr (addr),
|
||||
d_udp_port (port),
|
||||
d_mtu(mtu),
|
||||
d_running (true)
|
||||
uint16_t port, size_t mtu,
|
||||
size_t type) :
|
||||
gr::block ("udp_msg_source", gr::io_signature::make (0, 0, 0),
|
||||
gr::io_signature::make (0, 0, 0)),
|
||||
d_iface_addr (addr),
|
||||
d_udp_port (port),
|
||||
d_mtu (mtu),
|
||||
d_type (type),
|
||||
d_running (true)
|
||||
{
|
||||
message_port_register_out(pmt::mp("msg"));
|
||||
message_port_register_out (pmt::mp ("msg"));
|
||||
boost::shared_ptr<boost::thread> (
|
||||
new boost::thread (
|
||||
boost::bind (&udp_msg_source_impl::udp_msg_accepter, this)));
|
||||
new boost::thread (
|
||||
boost::bind (&udp_msg_source_impl::udp_msg_accepter, this)));
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -75,10 +75,13 @@ namespace gr
|
|||
socklen_t client_addr_len;
|
||||
ssize_t ret;
|
||||
uint8_t *buf;
|
||||
uint32_t bytes_num;
|
||||
uint32_t uint_val;
|
||||
uint32_t int_val;
|
||||
|
||||
if ((sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
|
||||
perror ("opening UDP socket");
|
||||
exit (EXIT_FAILURE);
|
||||
perror ("opening UDP socket");
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
memset (&client_addr, 0, sizeof(struct sockaddr));
|
||||
|
@ -86,35 +89,61 @@ namespace gr
|
|||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons (d_udp_port);
|
||||
|
||||
if( inet_aton(d_iface_addr.c_str(), &(sin.sin_addr)) == 0){
|
||||
LOG_ERROR("Wrong IP address");
|
||||
close(sock);
|
||||
exit (EXIT_FAILURE);
|
||||
if (inet_aton (d_iface_addr.c_str (), &(sin.sin_addr)) == 0) {
|
||||
LOG_ERROR("Wrong IP address");
|
||||
close (sock);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (bind (sock, (struct sockaddr *) &sin, sizeof(struct sockaddr_in))
|
||||
== -1) {
|
||||
perror ("UDP bind");
|
||||
close(sock);
|
||||
exit (EXIT_FAILURE);
|
||||
== -1) {
|
||||
perror ("UDP bind");
|
||||
close (sock);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* All good until now. Allocate buffer memory and proceed */
|
||||
buf = new uint8_t[d_mtu];
|
||||
|
||||
while(d_running){
|
||||
ret = recvfrom(sock, buf, d_mtu, 0, &client_addr, &client_addr_len);
|
||||
if(ret > 0) {
|
||||
message_port_pub(pmt::mp("msg"), pmt::make_blob(buf, ret));
|
||||
}
|
||||
else{
|
||||
perror("UDP recvfrom");
|
||||
close(sock);
|
||||
delete[] buf;
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
while (d_running) {
|
||||
ret = recvfrom (sock, buf, d_mtu, 0, &client_addr, &client_addr_len);
|
||||
if (ret > 0) {
|
||||
bytes_num = (uint32_t) ret;
|
||||
switch(d_type){
|
||||
case 0:
|
||||
message_port_pub (pmt::mp ("msg"), pmt::make_blob (buf, bytes_num));
|
||||
break;
|
||||
case 1:
|
||||
if(bytes_num < sizeof(uint32_t)){
|
||||
continue;
|
||||
}
|
||||
memcpy(&uint_val, buf, sizeof(uint32_t));
|
||||
message_port_pub (pmt::mp ("msg"),
|
||||
pmt::from_uint64 (ntohl (uint_val)));
|
||||
break;
|
||||
case 2:
|
||||
if (bytes_num < sizeof(int32_t)) {
|
||||
continue;
|
||||
}
|
||||
memcpy(&int_val, buf, sizeof(int32_t));
|
||||
message_port_pub (pmt::mp ("msg"),
|
||||
pmt::from_long (ntohl (int_val)));
|
||||
break;
|
||||
default:
|
||||
LOG_ERROR("Unsupported message type");
|
||||
close (sock);
|
||||
delete[] buf;
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
else {
|
||||
perror ("UDP recvfrom");
|
||||
close (sock);
|
||||
delete[] buf;
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
close(sock);
|
||||
close (sock);
|
||||
delete[] buf;
|
||||
exit (EXIT_SUCCESS);
|
||||
}
|
||||
|
|
|
@ -35,6 +35,7 @@ namespace gr
|
|||
const std::string d_iface_addr;
|
||||
const uint16_t d_udp_port;
|
||||
const size_t d_mtu;
|
||||
const size_t d_type;
|
||||
bool d_running;
|
||||
boost::shared_ptr<boost::thread> d_thread;
|
||||
|
||||
|
@ -42,7 +43,8 @@ namespace gr
|
|||
udp_msg_accepter ();
|
||||
|
||||
public:
|
||||
udp_msg_source_impl (const std::string& addr, uint16_t port, size_t mtu);
|
||||
udp_msg_source_impl (const std::string& addr, uint16_t port,
|
||||
size_t mtu, size_t type);
|
||||
~udp_msg_source_impl ();
|
||||
};
|
||||
|
||||
|
|
|
@ -0,0 +1,268 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <gnuradio/io_signature.h>
|
||||
#include "waterfall_sink_impl.h"
|
||||
#include <satnogs/log.h>
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
waterfall_sink::sptr
|
||||
waterfall_sink::make (double samp_rate, double center_freq,
|
||||
double fps, size_t fft_size,
|
||||
const std::string& filename, int mode)
|
||||
{
|
||||
return gnuradio::get_initial_sptr (
|
||||
new waterfall_sink_impl (samp_rate, center_freq,
|
||||
fps, fft_size, filename, mode));
|
||||
}
|
||||
|
||||
/*
|
||||
* The private constructor
|
||||
*/
|
||||
waterfall_sink_impl::waterfall_sink_impl (double samp_rate,
|
||||
double center_freq,
|
||||
double pps,
|
||||
size_t fft_size,
|
||||
const std::string& filename,
|
||||
int mode) :
|
||||
gr::sync_block ("waterfall_sink",
|
||||
gr::io_signature::make (1, 1, sizeof(gr_complex)),
|
||||
gr::io_signature::make (0, 0, 0)),
|
||||
d_samp_rate (samp_rate),
|
||||
d_pps (pps),
|
||||
d_fft_size (fft_size),
|
||||
d_mode ((wf_mode_t)mode),
|
||||
d_refresh( (d_samp_rate / fft_size) / pps),
|
||||
d_fft_cnt(0),
|
||||
d_fft_shift((size_t)(ceil(fft_size/2.0))),
|
||||
d_samples_cnt(0),
|
||||
d_fft (fft_size)
|
||||
{
|
||||
float r = 0.0;
|
||||
const int alignment_multiple = volk_get_alignment ()
|
||||
/ (fft_size * sizeof(gr_complex));
|
||||
set_alignment (std::max (1, alignment_multiple));
|
||||
set_output_multiple (fft_size);
|
||||
|
||||
d_shift_buffer = (gr_complex *) volk_malloc (
|
||||
fft_size * sizeof(gr_complex), volk_get_alignment());
|
||||
if(!d_shift_buffer){
|
||||
LOG_ERROR("Could not allocate aligned memory");
|
||||
throw std::runtime_error("Could not allocate aligned memory");
|
||||
}
|
||||
|
||||
d_hold_buffer = (float *)volk_malloc(fft_size * sizeof(gr_complex),
|
||||
volk_get_alignment());
|
||||
if(!d_hold_buffer){
|
||||
LOG_ERROR("Could not allocate aligned memory");
|
||||
throw std::runtime_error("Could not allocate aligned memory");
|
||||
}
|
||||
memset(d_hold_buffer, 0, fft_size * sizeof(gr_complex));
|
||||
|
||||
d_tmp_buffer = (float *) volk_malloc (fft_size * sizeof(float),
|
||||
volk_get_alignment ());
|
||||
if (!d_tmp_buffer) {
|
||||
LOG_ERROR("Could not allocate aligned memory");
|
||||
throw std::runtime_error ("Could not allocate aligned memory");
|
||||
}
|
||||
|
||||
d_fos.open(filename, std::ios::binary | std::ios::trunc);
|
||||
|
||||
/* Append header for proper plotting */
|
||||
r = fft_size;
|
||||
d_fos.write((char *)&r, sizeof(float));
|
||||
for(size_t i = 0; i < fft_size; i++) {
|
||||
r = (samp_rate/fft_size * i ) - samp_rate/2.0 + center_freq;
|
||||
d_fos.write((char *)&r, sizeof(float));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Our virtual destructor.
|
||||
*/
|
||||
waterfall_sink_impl::~waterfall_sink_impl ()
|
||||
{
|
||||
d_fos.close();
|
||||
volk_free(d_shift_buffer);
|
||||
volk_free(d_hold_buffer);
|
||||
volk_free(d_tmp_buffer);
|
||||
}
|
||||
|
||||
int
|
||||
waterfall_sink_impl::work (int noutput_items,
|
||||
gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items)
|
||||
{
|
||||
const gr_complex *in = (const gr_complex *) input_items[0];
|
||||
size_t n_fft = ((size_t) noutput_items / d_fft_size);
|
||||
|
||||
switch (d_mode)
|
||||
{
|
||||
case WATERFALL_MODE_DECIMATION:
|
||||
compute_decimation (in, n_fft);
|
||||
break;
|
||||
case WATERFALL_MODE_MAX_HOLD:
|
||||
compute_max_hold (in, n_fft);
|
||||
break;
|
||||
case WATERFALL_MODE_MEAN:
|
||||
compute_mean (in, n_fft);
|
||||
break;
|
||||
default:
|
||||
LOG_ERROR("Wrong waterfall mode");
|
||||
throw std::runtime_error ("Wrong waterfall mode");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return n_fft * d_fft_size;
|
||||
}
|
||||
|
||||
void
|
||||
waterfall_sink_impl::compute_decimation (const gr_complex* in, size_t n_fft)
|
||||
{
|
||||
size_t i;
|
||||
float t;
|
||||
gr_complex *fft_in;
|
||||
for(i = 0; i < n_fft; i++){
|
||||
d_fft_cnt++;
|
||||
if(d_fft_cnt > d_refresh){
|
||||
fft_in = d_fft.get_inbuf();
|
||||
memcpy(fft_in, in + i*d_fft_size, d_fft_size*sizeof(gr_complex));
|
||||
d_fft.execute();
|
||||
/* Perform FFT shift */
|
||||
memcpy (d_shift_buffer, &d_fft.get_outbuf ()[d_fft_shift],
|
||||
sizeof(gr_complex) * (d_fft_size - d_fft_shift));
|
||||
memcpy (&d_shift_buffer[d_fft_size - d_fft_shift],
|
||||
&d_fft.get_outbuf ()[0], sizeof(gr_complex) * d_fft_shift);
|
||||
|
||||
/* Compute the energy in dB */
|
||||
volk_32fc_s32f_x2_power_spectral_density_32f (d_hold_buffer,
|
||||
d_shift_buffer,
|
||||
(float) d_fft_size, 1.0,
|
||||
d_fft_size);
|
||||
/* Write the result to the file */
|
||||
t = (float)(d_samples_cnt / d_samp_rate);
|
||||
d_fos.write((char *) &t, sizeof(float));
|
||||
d_fos.write((char *) d_hold_buffer, d_fft_size * sizeof(float));
|
||||
d_fft_cnt = 0;
|
||||
}
|
||||
d_samples_cnt += d_fft_size;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
waterfall_sink_impl::compute_max_hold (const gr_complex* in, size_t n_fft)
|
||||
{
|
||||
size_t i;
|
||||
size_t j;
|
||||
float t;
|
||||
gr_complex *fft_in;
|
||||
for(i = 0; i < n_fft; i++){
|
||||
fft_in = d_fft.get_inbuf ();
|
||||
memcpy (fft_in, in + i * d_fft_size, d_fft_size * sizeof(gr_complex));
|
||||
d_fft.execute ();
|
||||
/* Perform FFT shift */
|
||||
memcpy (d_shift_buffer, &d_fft.get_outbuf ()[d_fft_shift],
|
||||
sizeof(gr_complex) * (d_fft_size - d_fft_shift));
|
||||
memcpy (&d_shift_buffer[d_fft_size - d_fft_shift],
|
||||
&d_fft.get_outbuf ()[0], sizeof(gr_complex) * d_fft_shift);
|
||||
|
||||
/* Normalization factor */
|
||||
volk_32fc_s32fc_multiply_32fc(d_shift_buffer, d_shift_buffer,
|
||||
1.0/d_fft_size, d_fft_size);
|
||||
|
||||
/* Compute the mag^2 */
|
||||
volk_32fc_magnitude_squared_32f(d_tmp_buffer, d_shift_buffer,
|
||||
d_fft_size);
|
||||
/* Max hold */
|
||||
volk_32f_x2_max_32f (d_hold_buffer, d_hold_buffer, d_tmp_buffer,
|
||||
d_fft_size);
|
||||
d_fft_cnt++;
|
||||
if(d_fft_cnt > d_refresh) {
|
||||
/* Compute the energy in dB */
|
||||
for(j = 0; j < d_fft_size; j++){
|
||||
d_hold_buffer[j] = 10.0 * log10f(d_hold_buffer[j] + 1.0e-20);
|
||||
}
|
||||
|
||||
/* Write the result to the file */
|
||||
t = (float)(d_samples_cnt / d_samp_rate);
|
||||
d_fos.write((char *) &t, sizeof(float));
|
||||
d_fos.write((char *) d_hold_buffer, d_fft_size * sizeof(float));
|
||||
|
||||
/* Reset */
|
||||
d_fft_cnt = 0;
|
||||
memset(d_hold_buffer, 0, d_fft_size * sizeof(float));
|
||||
}
|
||||
d_samples_cnt += d_fft_size;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
waterfall_sink_impl::compute_mean (const gr_complex* in, size_t n_fft)
|
||||
{
|
||||
size_t i;
|
||||
size_t j;
|
||||
float t;
|
||||
gr_complex *fft_in;
|
||||
for(i = 0; i < n_fft; i++){
|
||||
fft_in = d_fft.get_inbuf ();
|
||||
memcpy (fft_in, in + i * d_fft_size, d_fft_size * sizeof(gr_complex));
|
||||
d_fft.execute ();
|
||||
/* Perform FFT shift */
|
||||
memcpy (d_shift_buffer, &d_fft.get_outbuf ()[d_fft_shift],
|
||||
sizeof(gr_complex) * (d_fft_size - d_fft_shift));
|
||||
memcpy (&d_shift_buffer[d_fft_size - d_fft_shift],
|
||||
&d_fft.get_outbuf ()[0], sizeof(gr_complex) * d_fft_shift);
|
||||
|
||||
/* Accumulate the complex numbers */
|
||||
volk_32f_x2_add_32f(d_hold_buffer, d_hold_buffer,
|
||||
(float *)d_shift_buffer, 2 * d_fft_size);
|
||||
d_fft_cnt++;
|
||||
if(d_fft_cnt > d_refresh) {
|
||||
/*
|
||||
* Compute the energy in dB performing the proper normalization
|
||||
* before any dB calculation, emulating the mean
|
||||
*/
|
||||
volk_32fc_s32f_x2_power_spectral_density_32f (
|
||||
d_hold_buffer, (gr_complex *)d_hold_buffer,
|
||||
(float) d_fft_cnt * d_fft_size, 1.0, d_fft_size);
|
||||
|
||||
/* Write the result to the file */
|
||||
t = (float)(d_samples_cnt / d_samp_rate);
|
||||
d_fos.write((char *) &t, sizeof(float));
|
||||
d_fos.write((char *) d_hold_buffer, d_fft_size * sizeof(float));
|
||||
|
||||
/* Reset */
|
||||
d_fft_cnt = 0;
|
||||
memset(d_hold_buffer, 0, 2 * d_fft_size * sizeof(float));
|
||||
}
|
||||
d_samples_cnt += d_fft_size;
|
||||
}
|
||||
}
|
||||
|
||||
} /* namespace satnogs */
|
||||
} /* namespace gr */
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
*
|
||||
* Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* 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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_SATNOGS_WATERFALL_SINK_IMPL_H
|
||||
#define INCLUDED_SATNOGS_WATERFALL_SINK_IMPL_H
|
||||
|
||||
#include <satnogs/waterfall_sink.h>
|
||||
#include <volk/volk.h>
|
||||
#include <gnuradio/fft/fft.h>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
|
||||
namespace gr
|
||||
{
|
||||
namespace satnogs
|
||||
{
|
||||
|
||||
class waterfall_sink_impl : public waterfall_sink
|
||||
{
|
||||
private:
|
||||
/**
|
||||
* The different types of operation of the waterfall
|
||||
*/
|
||||
typedef enum {
|
||||
WATERFALL_MODE_DECIMATION = 0,//!< WATERFALL_MODE_DECIMATION Performs just a decimation and computes the energy only
|
||||
WATERFALL_MODE_MAX_HOLD = 1, //!< WATERFALL_MODE_MAX_HOLD compute the max hold energy of all the FFT snapshots between two consecutive pixel rows
|
||||
WATERFALL_MODE_MEAN = 2 //!< WATERFALL_MODE_MEAN compute the mean energy of all the FFT snapshots between two consecutive pixel rows
|
||||
} wf_mode_t;
|
||||
|
||||
const double d_samp_rate;
|
||||
double d_pps;
|
||||
const size_t d_fft_size;
|
||||
wf_mode_t d_mode;
|
||||
size_t d_refresh;
|
||||
size_t d_fft_cnt;
|
||||
size_t d_fft_shift;
|
||||
size_t d_samples_cnt;
|
||||
fft::fft_complex d_fft;
|
||||
gr_complex *d_shift_buffer;
|
||||
float *d_hold_buffer;
|
||||
float *d_tmp_buffer;
|
||||
std::ofstream d_fos;
|
||||
|
||||
public:
|
||||
waterfall_sink_impl (double samp_rate, double center_freq,
|
||||
double pps, size_t fft_size,
|
||||
const std::string& filename, int mode);
|
||||
~waterfall_sink_impl ();
|
||||
|
||||
|
||||
int
|
||||
work (int noutput_items, gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items);
|
||||
|
||||
void
|
||||
compute_decimation(const gr_complex *in, size_t n_fft);
|
||||
|
||||
void
|
||||
compute_max_hold(const gr_complex *in, size_t n_fft);
|
||||
|
||||
void
|
||||
compute_mean(const gr_complex *in, size_t n_fft);
|
||||
};
|
||||
|
||||
} // namespace satnogs
|
||||
} // namespace gr
|
||||
|
||||
#endif /* INCLUDED_SATNOGS_WATERFALL_SINK_IMPL_H */
|
||||
|
|
@ -31,6 +31,7 @@ endif()
|
|||
GR_PYTHON_INSTALL(
|
||||
FILES
|
||||
__init__.py
|
||||
dsp_settings.py
|
||||
hw_settings.py
|
||||
satnogs_upsat_transmitter.py
|
||||
DESTINATION ${GR_PYTHON_DIR}/satnogs
|
||||
|
|
|
@ -22,15 +22,17 @@
|
|||
This is the GNU Radio SATNOGS module. Place your Python package
|
||||
description here (python/__init__.py).
|
||||
'''
|
||||
import sys
|
||||
|
||||
# import swig generated symbols into the satnogs namespace
|
||||
try:
|
||||
# this might fail if the module is python-only
|
||||
from satnogs_swig import *
|
||||
from dsp_settings import *
|
||||
from hw_settings import *
|
||||
from satnogs_upsat_transmitter import *
|
||||
except ImportError:
|
||||
except ImportError as err:
|
||||
sys.stderr.write("Failed to import SatNOGS ({})\n".format(err))
|
||||
sys.stderr.write("Consider first to run 'sudo ldconfig'\n")
|
||||
pass
|
||||
|
||||
# import any pure python here
|
||||
#
|
||||
|
|
|
@ -0,0 +1,31 @@
|
|||
#! /usr/bin/python
|
||||
#
|
||||
# gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
||||
#
|
||||
# Copyright (C) 2016, Libre Space Foundation <http://librespacefoundation.org/>
|
||||
#
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# 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 <http://www.gnu.org/licenses/>
|
||||
#
|
||||
|
||||
#===============================================================================
|
||||
# This file provides a variaty of settings for the flowgraphs
|
||||
# based on the hardware SDR device that they are using
|
||||
#===============================================================================
|
||||
|
||||
fm_demod_settings = {'usrpb200' : {'decimation_rx' : 5, 'audio_gain' : 0.9},
|
||||
'usrp2' : {'decimation_rx' : 5, 'audio_gain' : 0.9},
|
||||
'airspy' : {'decimation_rx' : 10, 'audio_gain' : 0.9},
|
||||
'hackrf' : {'decimation_rx' : 5, 'audio_gain' : 0.9},
|
||||
'rtlsdr' : {'decimation_rx' : 5, 'audio_gain' : 0.9}
|
||||
}
|
|
@ -29,19 +29,22 @@ hw_tx_settings = {'usrpb200' : {'rf_gain' : 60.0, 'if_gain' : 0.0,
|
|||
'usrp2' : {'rf_gain' : 20.0, 'samp_rate' : 2e6,
|
||||
'bb_gain' : 0.0, 'samp_rate' : 2e6,
|
||||
'antenna' : 'TX/RX', 'dev_arg': 'uhd'},
|
||||
'hackrf' : {'rf_gain' : 20.0, 'if_gain' : 8.0,
|
||||
'bb_gain' : 5.0, 'samp_rate' : 2e6,
|
||||
'hackrf' : {'rf_gain' : 0.0, 'if_gain' : 16.0,
|
||||
'bb_gain' : 20.0, 'samp_rate' : 2e6,
|
||||
'antenna' : '', 'dev_arg': 'hackrf'} }
|
||||
|
||||
hw_rx_settings = {'usrpb200' : {'rf_gain' : 20.0, 'if_gain' : 0.0,
|
||||
'bb_gain' : 0.0, 'samp_rate' : 1e6,
|
||||
hw_rx_settings = {'usrpb200' : {'rf_gain' : 50.0, 'if_gain' : 0.0,
|
||||
'bb_gain' : 0.0, 'samp_rate' : 5e5,
|
||||
'antenna' : 'RX2', 'dev_arg': 'uhd'},
|
||||
'usrp2' : {'rf_gain' : 20.0, 'if_gain' : 0.0,
|
||||
'bb_gain' : 0.0, 'samp_rate' : 2e6,
|
||||
'usrp2' : {'rf_gain' : 50.0, 'if_gain' : 0.0,
|
||||
'bb_gain' : 0.0, 'samp_rate' : 5e5,
|
||||
'antenna' : 'RX2', 'dev_arg': 'uhd'},
|
||||
'airspy' : {'rf_gain' : 16.0, 'if_gain' : 0.0,
|
||||
'bb_gain' : 0.0, 'samp_rate' : 2.5e6,
|
||||
'airspy' : {'rf_gain' : 30.0, 'if_gain' : 0.0,
|
||||
'bb_gain' : 0.0, 'samp_rate' : 10e6,
|
||||
'antenna' : '', 'dev_arg': 'airspy'},
|
||||
'hackrf' : {'rf_gain' : 20.0, 'if_gain' : 8.0,
|
||||
'bb_gain' : 5.0, 'samp_rate' : 2e6,
|
||||
'antenna' : '', 'dev_arg': 'hackrf'} }
|
||||
'hackrf' : {'rf_gain' : 14.0, 'if_gain' : 16.0,
|
||||
'bb_gain' : 20.0, 'samp_rate' : 8e6,
|
||||
'antenna' : '', 'dev_arg': 'hackrf'},
|
||||
'rtlsdr' : {'rf_gain' : 49.6, 'if_gain' : 0.0,
|
||||
'bb_gain' : 0.0, 'samp_rate' : 1.5e6,
|
||||
'antenna' : '', 'dev_arg' : 'rtl'} }
|
||||
|
|
|
@ -57,9 +57,18 @@ GR_SWIG_INSTALL(TARGETS satnogs_swig DESTINATION ${GR_PYTHON_DIR}/satnogs)
|
|||
########################################################################
|
||||
# Install swig .i files for development
|
||||
########################################################################
|
||||
list(APPEND swig_files
|
||||
satnogs_swig.i
|
||||
${CMAKE_CURRENT_BINARY_DIR}/satnogs_swig_doc.i
|
||||
)
|
||||
|
||||
if(${INCLUDE_DEBUG_BLOCKS})
|
||||
list(APPEND swig_files "satnogs_debug_swig.i")
|
||||
endif()
|
||||
|
||||
install(
|
||||
FILES
|
||||
satnogs_swig.i
|
||||
${swig_files}
|
||||
${CMAKE_CURRENT_BINARY_DIR}/satnogs_swig_doc.i
|
||||
DESTINATION ${GR_INCLUDE_DIR}/satnogs/swig
|
||||
)
|
||||
|
|
|
@ -0,0 +1,27 @@
|
|||
/* -*- c++ -*- */
|
||||
|
||||
%include <typemaps.i>
|
||||
%include "gnuradio.i" // the common stuff
|
||||
|
||||
//load generated python docstrings
|
||||
%include "satnogs_swig_doc.i"
|
||||
|
||||
%{
|
||||
#include "satnogs/morse_debug_source.h"
|
||||
#include "satnogs/debug_msg_source.h"
|
||||
#include "satnogs/debug_msg_source_raw.h"
|
||||
#include "satnogs/leo_channel.h"
|
||||
%}
|
||||
|
||||
%include "satnogs/morse_debug_source.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, morse_debug_source);
|
||||
|
||||
%include "satnogs/debug_msg_source.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, debug_msg_source);
|
||||
|
||||
%include "satnogs/debug_msg_source_raw.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, debug_msg_source_raw);
|
||||
|
||||
%include "satnogs/leo_channel.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, leo_channel);
|
||||
|
|
@ -19,7 +19,6 @@
|
|||
#include "satnogs/udp_msg_source.h"
|
||||
#include "satnogs/debug_msg_source.h"
|
||||
#include "satnogs/tcp_rigctl_msg_source.h"
|
||||
#include "satnogs/json_to_ecss_src.h"
|
||||
#include "satnogs/doppler_correction_cc.h"
|
||||
#include "satnogs/frame_encoder.h"
|
||||
#include "satnogs/upsat_fsk_frame_acquisition.h"
|
||||
|
@ -31,18 +30,26 @@
|
|||
#include "satnogs/ax25_encoder_mb.h"
|
||||
#include "satnogs/ax25_decoder_bm.h"
|
||||
#include "satnogs/qb50_deframer.h"
|
||||
#include "satnogs/waterfall_sink.h"
|
||||
#include "satnogs/ogg_encoder.h"
|
||||
#include "satnogs/ogg_source.h"
|
||||
%}
|
||||
|
||||
|
||||
%include "satnogs/cw_matched_filter_ff.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, cw_matched_filter_ff);
|
||||
|
||||
%include "satnogs/morse_tree.h"
|
||||
|
||||
%include "satnogs/morse_decoder.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, morse_decoder);
|
||||
|
||||
%include "satnogs/morse_debug_source.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, morse_debug_source);
|
||||
|
||||
%include "satnogs/multi_format_msg_sink.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, multi_format_msg_sink);
|
||||
|
||||
%include "satnogs/cw_to_symbol.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, cw_to_symbol);
|
||||
|
||||
|
@ -51,30 +58,48 @@ GR_SWIG_BLOCK_MAGIC2(satnogs, sine_matched_filter_ff);
|
|||
|
||||
%include "satnogs/udp_msg_source.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, udp_msg_source);
|
||||
|
||||
%include "satnogs/debug_msg_source.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, debug_msg_source);
|
||||
|
||||
%include "satnogs/tcp_rigctl_msg_source.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, tcp_rigctl_msg_source);
|
||||
%include "satnogs/json_to_ecss_src.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, json_to_ecss_src);
|
||||
|
||||
%include "satnogs/frame_encoder.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, frame_encoder);
|
||||
|
||||
%include "satnogs/doppler_correction_cc.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, doppler_correction_cc);
|
||||
|
||||
%include "satnogs/upsat_fsk_frame_acquisition.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, upsat_fsk_frame_acquisition);
|
||||
|
||||
%include "satnogs/upsat_fsk_frame_encoder.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, upsat_fsk_frame_encoder);
|
||||
|
||||
%include "satnogs/whitening.h"
|
||||
|
||||
%include "satnogs/udp_msg_sink.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, udp_msg_sink);
|
||||
|
||||
%include "satnogs/coarse_doppler_correction_cc.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, coarse_doppler_correction_cc);
|
||||
|
||||
%include "satnogs/debug_msg_source_raw.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, debug_msg_source_raw);
|
||||
|
||||
%include "satnogs/ax25_encoder_mb.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, ax25_encoder_mb);
|
||||
|
||||
%include "satnogs/ax25_decoder_bm.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, ax25_decoder_bm);
|
||||
|
||||
%include "satnogs/qb50_deframer.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, qb50_deframer);
|
||||
|
||||
%include "satnogs/waterfall_sink.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, waterfall_sink);
|
||||
%include "satnogs/ogg_encoder.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, ogg_encoder);
|
||||
%include "satnogs/ogg_source.h"
|
||||
GR_SWIG_BLOCK_MAGIC2(satnogs, ogg_source);
|
||||
|
|
Loading…
Reference in New Issue