sebastian
/
gr-satnogs
mirror of https://gitlab.com/LongHairedHacker/gr-satnogs.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Remove obsolete blocks 

* Blocks removed are now covered from decoders available supporting the
new decoder architecture
* The quadrature demodulation filter block, had as primary goal to
reduce the false alarms and the performance of the DUV decoder. Now the
new DUV decoder, uses a shift register approach, likewise the AX.25
decoder, therefore it is not needed anymore.
This commit is contained in:
Manolis Surligas 2019-09-03 14:31:31 +03:00
parent c9f685d1c1
commit 14382ddc4f
25 changed files with 0 additions and 2312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
grc/CMakeLists.txt
View File

@ -30,12 +30,8 @@ list(APPEND debug_blocks
list(APPEND enabled_blocks
satnogs_block_tree.xml
satnogs_amsat_duv_decoder.xml
satnogs_ax25_decoder_bm.xml
satnogs_ax25_encoder_mb.xml
satnogs_ax25_decoder.xml
satnogs_ccsds_rs_decoder_mm.xml
satnogs_decoder_8b10b.xml
satnogs_fox_telem_mm.xml
satnogs_frame_decoder.xml
satnogs_frame_file_sink.xml
satnogs_iq_sink.xml
@ -52,7 +48,6 @@ list(APPEND enabled_blocks
satnogs_udp_msg_sink.xml
satnogs_coarse_doppler_correction_cc.xml
satnogs_waterfall_sink.xml
satnogs_quad_demod_filter_ff.xml
satnogs_ogg_source.xml
satnogs_noaa_apt_sink.xml
satnogs_whitening.xml

74
grc/satnogs_ax25_decoder_bm.xml
View File

@ -1,74 +0,0 @@
<?xml version="1.0"?>
<block>
<name>AX.25 Decoder</name>
<key>satnogs_ax25_decoder_bm</key>
<import>import satnogs</import>
<make>satnogs.ax25_decoder_bm($addr, $ssid, $promisc, $descrambling, $max_frame_len)</make>
<param>
<name>Receiver Callsign</name>
<key>addr</key>
<value>'GND'</value>
<type>string</type>
</param>
<param>
<name>Receiver SSID</name>
<key>ssid</key>
<value>0</value>
<type>int</type>
</param>
<param>
<name>Promiscuous mode</name>
<key>promisc</key>
<type>enum</type>
<option>
<name>No</name>
<key>False</key>
</option>
<option>
<name>Yes</name>
<key>True</key>
</option>
</param>
<param>
<name>G3RUH descrambling</name>
<key>descrambling</key>
<type>enum</type>
<option>
<name>Yes</name>
<key>True</key>
</option>
<option>
<name>No</name>
<key>False</key>
</option>
</param>
<param>
<name>Maximum frame length</name>
<key>max_frame_len</key>
<value>256</value>
<type>int</type>
</param>
<sink>
<name>in</name>
<type>byte</type>
</sink>
<source>
<name>pdu</name>
<type>message</type>
</source>
<source>
<name>failed_pdu</name>
<type>message</type>
<optional>1</optional>
</source>
</block>

8
grc/satnogs_block_tree.xml
View File

@ -18,10 +18,6 @@
<block>satnogs_upsat_transmitter</block>
<block>satnogs_qb50_deframer</block>
</cat>
<cat>
<name>AMSAT FOX</name>
<block>satnogs_fox_telem_mm</block>
</cat>
<cat>
<name>METOP</name>
<block>satnogs_lrpt_sync</block>
@ -42,11 +38,7 @@
<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>
<block>satnogs_quad_demod_filter_ff</block>
<block>satnogs_ccsds_rs_decoder_mm</block>
<block>satnogs_decoder_8b10b</block>
<block>variable_whitening</block>
<block>satnogs_frame_acquisition</block>
<block>satnogs_frame_decoder</block>

17
grc/satnogs_ccsds_rs_decoder_mm.xml
View File

@ -1,17 +0,0 @@
<?xml version="1.0"?>
<block>
<name>CCSDS (255,223) RS Decoder</name>
<key>satnogs_ccsds_rs_decoder_mm</key>
<import>import satnogs</import>
<make>satnogs.ccsds_rs_decoder_mm()</make>
<sink>
<name>in</name>
<type>message</type>
</sink>
<source>
<name>pdu</name>
<type>message</type>
</source>
</block>

33
grc/satnogs_decoder_8b10b.xml
View File

@ -1,33 +0,0 @@
<?xml version="1.0"?>
<block>
<name>8b10b Decoder</name>
<key>satnogs_decoder_8b10b</key>
<import>import satnogs</import>
<make>satnogs.decoder_8b10b($control_symbol, $max_frame_len)
</make>
<param>
<name>Control symbols</name>
<key>control_symbol</key>
<value>0011111010</value>
<type>string</type>
</param>
<param>
<name>Maximum frame length</name>
<key>max_frame_len</key>
<value>960</value>
<type>int</type>
</param>
<sink>
<name>in</name>
<type>byte</type>
</sink>
<source>
<name>pdu</name>
<type>message</type>
</source>
</block>

17
grc/satnogs_fox_telem_mm.xml
View File

@ -1,17 +0,0 @@
<?xml version="1.0"?>
<block>
<name>FOX telemetry processor</name>
<key>satnogs_fox_telem_mm</key>
<import>import satnogs</import>
<make>satnogs.fox_telem_mm()</make>
<sink>
<name>in</name>
<type>message</type>
</sink>
<source>
<name>raw</name>
<type>message</type>
</source>
</block>

41
grc/satnogs_quad_demod_filter_ff.xml
View File

@ -1,41 +0,0 @@
<?xml version="1.0"?>
<block>
<name>Quadrature Demod Filter</name>
<key>satnogs_quad_demod_filter_ff</key>
<import>import satnogs</import>
<make>satnogs.quad_demod_filter_ff($gain)</make>
<param>
<name>Gain</name>
<key>gain</key>
<value>1.0</value>
<type>real</type>
</param>
<param>
<name>Window Size</name>
<key>win</key>
<value>80</value>
<type>int</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>float</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>float</type>
</source>
</block>

5
include/satnogs/CMakeLists.txt
View File

@ -57,17 +57,12 @@ list(APPEND HEADER_FILES
udp_msg_sink.h
coarse_doppler_correction_cc.h
ax25_encoder_mb.h
ax25_decoder_bm.h
qb50_deframer.h
waterfall_sink.h
ogg_source.h
noaa_apt_sink.h
frame_file_sink.h
iq_sink.h
quad_demod_filter_ff.h
decoder_8b10b.h
ccsds_rs_decoder_mm.h
fox_telem_mm.h
lrpt_sync.h
lrpt_decoder.h
frame_acquisition.h

89
include/satnogs/ax25_decoder_bm.h
View File

@ -1,89 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2016, 2017, 2018
* 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_AX25_DECODER_BM_H
#define INCLUDED_SATNOGS_AX25_DECODER_BM_H
#include <satnogs/api.h>
#include <gnuradio/sync_block.h>
namespace gr
{
namespace satnogs
{
/*!
* \brief AX.25 decoder that supports the legacy hardware radios.
*
* This block takes as input a quadrature demodulated bit stream.
* Each byte should contains only one bit of information at the LSB.
*
* The block will try to find an AX.25 frame. If the frame pass the
* CRC check then a blob PMT message is produced at the message output
* indicated with name 'out'. Otherwise if the frame did not pass the
* CRC check or the size was invalid, a blob PMT message is generated at
* the output port with the name 'fail'. This will help to recover at least
* some bytes from a corrupted message.
*
* The block also supports destination callsign check. Only frames with
* the right destination Callsign will be accepted. This feature can be
* disabled using the promisc parameter.
*
* \ingroup satnogs
*
*/
class SATNOGS_API ax25_decoder_bm : virtual public gr::sync_block
{
public:
typedef boost::shared_ptr<ax25_decoder_bm> sptr;
/**
* This block takes as input a quadrature demodulated bit stream.
* Each byte should contains only one bit of information at the LSB.
*
* The block will try to find an AX.25 frame. If the frame pass the
* CRC check then a blob PMT message is produced at the message output
* indicated with name 'pdu'. Otherwise if the frame did not pass the
* CRC check or the size was invalid, a blob PMT message is generated at
* the output port with the name 'failed_pdu'.
* This will help to recover at least some bytes from a corrupted message.
*
* The block also supports destination callsign check. Only frames with
* the right destination Callsign will be accepted. This feature can be
* disabled using the promisc parameter.
* @param addr the Callsign of the receiver
* @param ssid the SSID of the receiver
* @param promisc if set to yes, the Callsign check is disabled
* @param descramble if set to yes, the data will be descrambled prior
* decoding using the G3RUH self-synchronizing descrambler.
* @param max_frame_len the maximum allowed frame length
* @return
*/
static sptr
make (const std::string& addr, uint8_t ssid, bool promisc = false,
bool descramble = true, size_t max_frame_len = 512);
};
} // namespace satnogs
} // namespace gr
#endif /* INCLUDED_SATNOGS_AX25_DECODER_BM_H */

56
include/satnogs/ccsds_rs_decoder_mm.h
View File

@ -1,56 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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_CCSDS_RS_DECODER_MM_H
#define INCLUDED_SATNOGS_CCSDS_RS_DECODER_MM_H
#include <satnogs/api.h>
#include <gnuradio/block.h>
namespace gr {
namespace satnogs {
/*!
* \brief <+description of block+>
* \ingroup satnogs
*
*/
class SATNOGS_API ccsds_rs_decoder_mm : virtual public gr::block
{
public:
typedef boost::shared_ptr<ccsds_rs_decoder_mm> sptr;
/*!
* \brief Return a shared_ptr to a new instance of satnogs::ccsds_rs_decoder_mm.
*
* To avoid accidental use of raw pointers, satnogs::ccsds_rs_decoder_mm's
* constructor is in a private implementation
* class. satnogs::ccsds_rs_decoder_mm::make is the public interface for
* creating new instances.
*/
static sptr make();
};
} // namespace satnogs
} // namespace gr
#endif /* INCLUDED_SATNOGS_CCSDS_RS_DECODER_MM_H */

58
include/satnogs/decoder_8b10b.h
View File

@ -1,58 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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_DECODER_8B10B_H
#define INCLUDED_SATNOGS_DECODER_8B10B_H
#include <satnogs/api.h>
#include <gnuradio/sync_block.h>
namespace gr
{
namespace satnogs
{
/*!
* \brief <+description of block+>
* \ingroup satnogs
*
*/
class SATNOGS_API decoder_8b10b : virtual public gr::sync_block
{
public:
typedef boost::shared_ptr<decoder_8b10b> sptr;
/*!
* \brief Return a shared_ptr to a new instance of satnogs::decoder_8b10b.
*
* To avoid accidental use of raw pointers, satnogs::decoder_8b10b's
* constructor is in a private implementation
* class. satnogs::decoder_8b10b::make is the public interface for
* creating new instances.
*/
static sptr make(const std::string& control_symbol,size_t max_frame_len);
};
}
// namespace satnogs
}// namespace gr
#endif /* INCLUDED_SATNOGS_DECODER_8B10B_H */

57
include/satnogs/fox_telem_mm.h
View File

@ -1,57 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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_FOX_TELEM_MM_H
#define INCLUDED_SATNOGS_FOX_TELEM_MM_H
#include <satnogs/api.h>
#include <gnuradio/block.h>
namespace gr
{
namespace satnogs
{
/*!
* \brief This block takes a AMSAT FOX telemetry frame from the CCSDS
* RS decoder, discards the pad bytes, checks if the frame is originating
* from a valid spacecraft and outputs the data to another message port.
* \ingroup satnogs
*
*/
class SATNOGS_API fox_telem_mm : virtual public gr::block
{
public:
typedef boost::shared_ptr<fox_telem_mm> sptr;
/*!
* \brief This block takes a AMSAT FOX telemetry frame from the CCSDS
* RS decoder, discards the pad bytes, checks if the frame is originating
* from a valid spacecraft and outputs the data to another message port.
*/
static sptr
make ();
};
} // namespace satnogs
} // namespace gr
#endif /* INCLUDED_SATNOGS_FOX_TELEM_MM_H */

82
include/satnogs/quad_demod_filter_ff.h
View File

@ -1,82 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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_QUAD_DEMOD_FILTER_FF_H
#define INCLUDED_SATNOGS_QUAD_DEMOD_FILTER_FF_H
#include <satnogs/api.h>
#include <gnuradio/sync_block.h>
namespace gr {
namespace satnogs {
/*!
* \brief The goal of this block is to act as a valve for a signal
* commonly originating from a clock recovered quadrature demodulated stream.
*
* A very common problem in such cases, is that after the quadrature
* demodulation the signal is on the phase domain and the detection
* of signal presence or absence cannot be performed with energy detection.
* Why do we need to identify signal presence? Most of the amateur satellites
* uses quite poor and short training sequences, especially in the AX.25
* AFSK1200 mode. Thus, the decoders have too many false alarms and due to
* this, they miss frames.
*
* Some may argue that you can perform energy detection before the quadrature
* demodulation, but this implies a 'magic' threshold should be set.
* In the SatNOGS case, this is not possible. Every ground station is unique
* in terms of performance and RF characteristics. On the other hand the
* phase domain has the nice property that the signal level is known. This
* level can be +-pi. This block tries to find an SNR-like metric based
* on the variance and the mean of the signal.
* \ingroup satnogs
*
*/
class SATNOGS_API quad_demod_filter_ff : virtual public gr::sync_block
{
public:
typedef boost::shared_ptr<quad_demod_filter_ff> sptr;
/**
* Creates a Quadrature Demodulate filter. The block will output samples
* only in signal presence acting as a "valve" to reduce false alarms of
* the FSK decoders. In case of no signal, zero samples are produced.
*
* @param gain this MUST be the gain set on the quadrature demodulate
* gain or an appropriate value if the amplitude of the quadrature
* demodulated signal somehow is scaled. By default if the signal is
* on the +-pi region, the gain should be one. If it is on the +-2pi, the
* gain should be set to 2.0 etc.
*
* @param window the window size to calculate the moving average and
* variance.
*
* @return shared pointer of the block
*/
static sptr make(float gain, int window = 80);
};
} // namespace satnogs
} // namespace gr
#endif /* INCLUDED_SATNOGS_QUAD_DEMOD_FILTER_FF_H */

5
lib/CMakeLists.txt
View File

@ -63,17 +63,12 @@ list(APPEND satnogs_sources
udp_msg_sink_impl.cc
coarse_doppler_correction_cc_impl.cc
ax25_encoder_mb_impl.cc
ax25_decoder_bm_impl.cc
qb50_deframer_impl.cc
waterfall_sink_impl.cc
ogg_source_impl.cc
noaa_apt_sink_impl.cc
frame_file_sink_impl.cc
iq_sink_impl.cc
quad_demod_filter_ff_impl.cc
decoder_8b10b_impl.cc
ccsds_rs_decoder_mm_impl.cc
fox_telem_mm_impl.cc
lrpt_sync_impl.cc
convolutional_deinterleaver.cc
lrpt_decoder_impl.cc

328
lib/ax25_decoder_bm_impl.cc
View File

@ -1,328 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2016-2019
* 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 <satnogs/log.h>
#include <satnogs/ax25.h>
#include "ax25_decoder_bm_impl.h"
namespace gr
{
namespace satnogs
{
ax25_decoder_bm::sptr
ax25_decoder_bm::make (const std::string &addr, uint8_t ssid, bool promisc,
bool descramble, size_t max_frame_len)
{
return gnuradio::get_initial_sptr (
new ax25_decoder_bm_impl (addr, ssid, promisc, descramble, max_frame_len));
}
/*
* The private constructor
*/
ax25_decoder_bm_impl::ax25_decoder_bm_impl (const std::string &addr,
uint8_t ssid, bool promisc,
bool descramble,
size_t max_frame_len) :
gr::sync_block ("ax25_decoder_bm",
gr::io_signature::make (1, 1, sizeof(uint8_t)),
gr::io_signature::make (0, 0, 0)),
d_promisc (promisc),
d_descramble (descramble),
d_max_frame_len (max_frame_len),
d_state (NO_SYNC),
d_shift_reg (0x0),
d_dec_b (0x0),
d_prev_bit_nrzi (0),
d_received_bytes (0),
d_decoded_bits (0),
d_lfsr (0x21, 0x0, 16),
d_frame_buffer (
new uint8_t[max_frame_len + AX25_MAX_ADDR_LEN + AX25_MAX_CTRL_LEN
+ sizeof(uint16_t)]),
d_start_idx(0)
{
/* Valid PDUs output message port */
message_port_register_out (pmt::mp ("pdu"));
/*
* Valid invalid (wrong CRC, different destination Callsign/SSID,
* wrong frame size)PDUs output message port
*/
message_port_register_out (pmt::mp ("failed_pdu"));
}
void
ax25_decoder_bm_impl::decode ()
{
while (1) {
bool cont = false;
switch (d_state)
{
case NO_SYNC:
for (size_t i = 0; i < d_bitstream.size (); i++) {
decode_1b (d_bitstream[i]);
if (d_shift_reg == AX25_SYNC_FLAG) {
d_bitstream.erase (d_bitstream.begin (),
d_bitstream.begin () + i + 1);
enter_sync_state ();
d_start_idx = 0;
cont = true;
break;
}
}
if(cont) {
continue;
}
d_bitstream.clear ();
return;
case IN_SYNC:
/*
* Most of the transmitters repeat several times the AX.25 SYNC
* In case of G3RUH this is mandatory to allow the self synchronizing
* scrambler to settle
*/
for (size_t i = d_start_idx; i < d_bitstream.size (); i++) {
decode_1b (d_bitstream[i]);
d_decoded_bits++;
if (d_decoded_bits == 8) {
/* Perhaps we are in frame! */
if (d_shift_reg != AX25_SYNC_FLAG) {
d_start_idx = i + 1;
enter_decoding_state ();
cont = true;
break;
}
d_decoded_bits = 0;
}
}
if(cont) {
continue;
}
d_start_idx = d_bitstream.size ();
return;
case DECODING:
for (size_t i = d_start_idx; i < d_bitstream.size (); i++) {
decode_1b (d_bitstream[i]);
if (d_shift_reg == AX25_SYNC_FLAG) {
LOG_DEBUG("Found frame end");
if (enter_frame_end ()) {
d_bitstream.erase (d_bitstream.begin (),
d_bitstream.begin () + i + 1);
}
cont = true;
break;
}
else if ((d_shift_reg & 0xfc) == 0x7c) {
/*This was a stuffed bit */
d_dec_b <<= 1;
}
else if ((d_shift_reg & 0xfe) == 0xfe) {
LOG_DEBUG("Invalid shift register value %u", d_received_bytes);
reset_state ();
cont = true;
break;
}
else {
d_decoded_bits++;
if (d_decoded_bits == 8) {
d_frame_buffer[d_received_bytes++] = d_dec_b;
d_decoded_bits = 0;
/*Check if the frame limit was reached */
if (d_received_bytes >= d_max_frame_len) {
LOG_DEBUG("Wrong size");
reset_state ();
cont = true;
break;
}
}
}
}
if(cont) {
continue;
}
d_start_idx = d_bitstream.size ();
return;
default:
LOG_ERROR("Invalid decoding state");
reset_state ();
return;
}
}
}
/*
* Our virtual destructor.
*/
ax25_decoder_bm_impl::~ax25_decoder_bm_impl ()
{
delete[] d_frame_buffer;
LOG_DEBUG("Left over: %lu", d_bitstream.size());
}
void
ax25_decoder_bm_impl::reset_state ()
{
d_state = NO_SYNC;
d_dec_b = 0x0;
d_shift_reg = 0x0;
d_decoded_bits = 0;
d_received_bytes = 0;
}
void
ax25_decoder_bm_impl::enter_sync_state ()
{
d_state = IN_SYNC;
d_dec_b = 0x0;
d_shift_reg = 0x0;
d_decoded_bits = 0;
d_received_bytes = 0;
}
void
ax25_decoder_bm_impl::enter_decoding_state ()
{
uint8_t tmp;
d_state = DECODING;
d_decoded_bits = 0;
d_received_bytes = 0;
/*
* Due to the possibility of bit stuffing on the first byte some special
* handling is necessary
*/
if ((d_shift_reg & 0xfc) == 0x7c) {
/*This was a stuffed bit */
d_dec_b <<= 1;
d_decoded_bits = 7;
}
else {
d_frame_buffer[0] = d_dec_b;
d_decoded_bits = 0;
d_received_bytes = 1;
}
}
bool
ax25_decoder_bm_impl::enter_frame_end ()
{
uint16_t fcs;
uint16_t recv_fcs = 0x0;
/* First check if the size of the frame is valid */
if (d_received_bytes < AX25_MIN_ADDR_LEN + sizeof(uint16_t)) {
reset_state ();
return false;
}
/*
* Check if the frame is correct using the FCS field
* Using this field also try to correct up to 2 error bits
*/
if (frame_check ()) {
message_port_pub (
pmt::mp ("pdu"),
pmt::make_blob (d_frame_buffer, d_received_bytes - sizeof(uint16_t)));
reset_state ();
return true;
}
else {
message_port_pub (
pmt::mp ("failed_pdu"),
pmt::make_blob (d_frame_buffer, d_received_bytes - sizeof(uint16_t)));
LOG_DEBUG("Wrong crc");
reset_state ();
return false;
}
}
inline void
ax25_decoder_bm_impl::decode_1b (uint8_t in)
{
/* In AX.25 the LS bit is sent first */
d_shift_reg = (d_shift_reg >> 1) | (in << 7);
d_dec_b = (d_dec_b >> 1) | (in << 7);
}
bool
ax25_decoder_bm_impl::frame_check ()
{
uint16_t fcs;
uint16_t recv_fcs = 0x0;
uint8_t orig_byte;
/* Check if the frame is correct using the FCS field */
fcs = ax25_fcs (d_frame_buffer, d_received_bytes - sizeof(uint16_t));
recv_fcs = (((uint16_t) d_frame_buffer[d_received_bytes - 1]) << 8)
| d_frame_buffer[d_received_bytes - 2];
if (fcs == recv_fcs) {
return true;
}
return false;
}
int
ax25_decoder_bm_impl::work (int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
int ret;
const uint8_t *in = (const uint8_t*) input_items[0];
if (noutput_items < 1) {
return noutput_items;
}
if (d_descramble) {
for (int i = 0; i < noutput_items; i++) {
/* Perform NRZI decoding */
uint8_t b = (~((in[i] - d_prev_bit_nrzi) % 2)) & 0x1;
d_prev_bit_nrzi = in[i];
b = d_lfsr.next_bit_descramble (b);
d_bitstream.push_back (b);
}
}
else {
for (int i = 0; i < noutput_items; i++) {
/* Perform NRZI decoding */
uint8_t b = (~((in[i] - d_prev_bit_nrzi) % 2)) & 0x1;
d_prev_bit_nrzi = in[i];
d_bitstream.push_back (b);
}
}
decode();
return noutput_items;
}
} /* namespace satnogs */
} /* namespace gr */

93
lib/ax25_decoder_bm_impl.h
View File

@ -1,93 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2016,2018
* 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_AX25_DECODER_BM_IMPL_H
#define INCLUDED_SATNOGS_AX25_DECODER_BM_IMPL_H
#include <satnogs/ax25_decoder_bm.h>
#include <gnuradio/digital/lfsr.h>
#include <deque>
namespace gr
{
namespace satnogs
{
class ax25_decoder_bm_impl : public ax25_decoder_bm
{
private:
typedef enum
{
NO_SYNC, IN_SYNC, DECODING
} decoding_state_t;
/**
* If this flag is set, the decoder operates in promiscuous mode and
* forwards all successfully decoded frames
*/
const bool d_promisc;
const bool d_descramble;
const size_t d_max_frame_len;
decoding_state_t d_state;
uint8_t d_shift_reg;
uint8_t d_dec_b;
uint8_t d_prev_bit_nrzi;
size_t d_received_bytes;
size_t d_decoded_bits;
digital::lfsr d_lfsr;
uint8_t *d_frame_buffer;
std::deque<uint8_t> d_bitstream;
size_t d_start_idx;
void
reset_state ();
void
enter_sync_state ();
void
enter_decoding_state ();
bool
enter_frame_end ();
void
decode ();
inline void
decode_1b (uint8_t in);
bool
frame_check();
public:
ax25_decoder_bm_impl (const std::string& addr, uint8_t ssid, bool promisc,
bool descramble, size_t max_frame_len);
~ax25_decoder_bm_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_AX25_DECODER_BM_IMPL_H */

107
lib/ccsds_rs_decoder_mm_impl.cc
View File

@ -1,107 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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 "ccsds_rs_decoder_mm_impl.h"
#include <satnogs/log.h>
extern "C" {
#include <fec.h>
}
namespace gr {
namespace satnogs {
ccsds_rs_decoder_mm::sptr
ccsds_rs_decoder_mm::make()
{
return gnuradio::get_initial_sptr
(new ccsds_rs_decoder_mm_impl());
}
/*
* The private constructor
*/
ccsds_rs_decoder_mm_impl::ccsds_rs_decoder_mm_impl()
: gr::block("ccsds_rs_decoder_mm",
gr::io_signature::make(0, 0, 0),
gr::io_signature::make(0, 0, 0))
{
message_port_register_in(pmt::mp("in"));
message_port_register_out(pmt::mp("pdu"));
set_msg_handler (
pmt::mp ("in"),
boost::bind (&ccsds_rs_decoder_mm_impl::message_handler, this, _1));
}
void
ccsds_rs_decoder_mm_impl::message_handler (pmt::pmt_t m)
{
int ret;
uint8_t data[255];
int erasures[255];
const uint8_t *data_ref;
size_t data_len;
const int *erasures_ref;
size_t erasures_len;
pmt::pmt_t pmt_data = pmt::dict_ref(m, pmt::intern("data"), pmt::PMT_NIL);
pmt::pmt_t pmt_erasures = pmt::dict_ref(m, pmt::intern("erasures"),
pmt::PMT_NIL);
/* Check if the message contains erasure info. Otherwise handle it as
* a blob
*/
if (pmt::equal (pmt::PMT_NIL, pmt_data)) {
pmt_data = m;
}
data_ref = pmt::u8vector_elements(pmt_data, data_len);
memcpy(data, data_ref, data_len);
if( pmt::equal (pmt::PMT_NIL, pmt_erasures)) {
ret = decode_rs_8(data, NULL, 0, (int)(255 - data_len));
}
else {
erasures_len = pmt::blob_length(pmt_erasures);
erasures_ref = pmt::s32vector_elements(pmt_erasures, erasures_len);
memcpy(erasures, erasures_ref, erasures_len * sizeof(int));
ret = decode_rs_8 (data, erasures, (int) erasures_len,
(int) (255 - data_len));
}
if(ret > -1) {
message_port_pub(pmt::mp("pdu"), pmt::make_blob(data, 223));
}
}
/*
* Our virtual destructor.
*/
ccsds_rs_decoder_mm_impl::~ccsds_rs_decoder_mm_impl()
{
}
} /* namespace satnogs */
} /* namespace gr */

47
lib/ccsds_rs_decoder_mm_impl.h
View File

@ -1,47 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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_CCSDS_RS_DECODER_MM_IMPL_H
#define INCLUDED_SATNOGS_CCSDS_RS_DECODER_MM_IMPL_H
#include <satnogs/ccsds_rs_decoder_mm.h>
namespace gr
{
namespace satnogs
{
class ccsds_rs_decoder_mm_impl : public ccsds_rs_decoder_mm
{
private:
void
message_handler(pmt::pmt_t m);
public:
ccsds_rs_decoder_mm_impl ();
~ccsds_rs_decoder_mm_impl ();
};
} // namespace satnogs
} // namespace gr
#endif /* INCLUDED_SATNOGS_CCSDS_RS_DECODER_MM_IMPL_H */

224
lib/decoder_8b10b_impl.cc
View File

@ -1,224 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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 "decoder_8b10b_impl.h"
#include <satnogs/log.h>
#include <gnuradio/blocks/count_bits.h>
namespace gr
{
namespace satnogs
{
decoder_8b10b::sptr
decoder_8b10b::make (const std::string& control_symbol,
size_t max_frame_len)
{
return gnuradio::get_initial_sptr (
new decoder_8b10b_impl (control_symbol, max_frame_len));
}
/*
* The private constructor
*/
decoder_8b10b_impl::decoder_8b10b_impl (const std::string& control_symbol,
size_t max_frame_len) :
gr::sync_block ("decoder_8b10b",
gr::io_signature::make (1, 1, sizeof(char)),
gr::io_signature::make (0, 0, 0)),
d_max_frame_len (max_frame_len),
d_erasure_cnt (0),
d_control_symbol_pos (0),
d_control_symbol_neg (0),
d_data_reg (0),
d_wrong_bits (0),
d_wrong_bits_neg (0),
d_nwrong (0),
d_nwrong_neg (0),
d_word_cnt (0),
d_state (IN_SYNC)
{
message_port_register_out (pmt::mp ("pdu"));
set_output_multiple(10);
if (!set_access_code (control_symbol)) {
throw std::out_of_range ("control_symbol is not 10 bits");
}
d_8b_words = new uint8_t [d_max_frame_len / 10];
d_erasures_indexes = new int [d_max_frame_len / 10];
}
/*
* Our virtual destructor.
*/
decoder_8b10b_impl::~decoder_8b10b_impl ()
{
delete [] d_8b_words;
delete [] d_erasures_indexes;
}
bool
decoder_8b10b_impl::set_access_code (const std::string &control_symbol)
{
unsigned len = control_symbol.length (); // # of bytes in string
/* if the control sequence is not 10-bit then throw exception */
if (len != 10) {
return false;
}
for (size_t i = 0; i < len; i++) {
d_control_symbol_pos = (d_control_symbol_pos << 1)
| (control_symbol[i] & 0x1);
}
d_control_symbol_neg = (~d_control_symbol_pos) & 0x3FF;
return true;
}
void
decoder_8b10b_impl::process_10b (uint16_t word, int write_pos)
{
uint16_t diff_bits = 0;
uint8_t min_pos = 0;
uint8_t min_dist = 11;
uint8_t curr_dist = 0;
size_t i = 0;
/* Check for the disparity -1 */
while ((i < 256) && (min_dist > 0)) {
diff_bits = (word ^ (d_lookup_8b10b[0][i])) & 0x3FF;
curr_dist = gr::blocks::count_bits16 (diff_bits);
if (curr_dist < min_dist) {
min_dist = curr_dist;
min_pos = i;
}
i++;
}
/* Check for the disparity +1 */
i = 0;
while ((i < 256) && (min_dist > 0)) {
diff_bits = (word ^ (d_lookup_8b10b[1][i])) & 0x3FF;
curr_dist = gr::blocks::count_bits16 (diff_bits);
if (curr_dist < min_dist) {
min_dist = curr_dist;
min_pos = i;
}
i++;
}
/* report that there is erasure to this 10 bits */
d_8b_words[write_pos] = min_pos;
/* If we did not found a perfect match, mark this index as erasure */
if(min_dist != 0) {
d_erasures_indexes[d_erasure_cnt++] = write_pos;
}
}
static inline uint16_t
pack_10b_word(const uint8_t *in)
{
return (((uint16_t)in[0] & 0x1) << 9) | (((uint16_t)in[1] & 0x1) << 8)
| (((uint16_t)in[2] & 0x1) << 7) | (((uint16_t)in[3] & 0x1) << 6)
| (((uint16_t)in[4] & 0x1) << 5) | (((uint16_t)in[5] & 0x1) << 4)
| (((uint16_t)in[6] & 0x1) << 3) | (((uint16_t)in[7] & 0x1) << 2)
| (((uint16_t)in[8] & 0x1) << 1) | (in[9] & 0x1);
}
int
decoder_8b10b_impl::work (int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
int i;
uint16_t word;
const uint8_t *in = (const uint8_t *) input_items[0];
/* Search for the Comma symbol */
if(d_state == IN_SYNC) {
for (i = 0; i < noutput_items; i++) {
d_data_reg = (d_data_reg << 1) | (in[i] & 0x1);
d_wrong_bits = (d_data_reg ^ d_control_symbol_pos) & 0x3FF;
d_wrong_bits_neg = (d_data_reg ^ d_control_symbol_neg) & 0x3FF;
d_nwrong = gr::blocks::count_bits16 (d_wrong_bits);
d_nwrong_neg = gr::blocks::count_bits16 (d_wrong_bits_neg);
/* we found the controls symbol */
if ((d_nwrong == 0) || (d_nwrong_neg == 0)) {
d_erasure_cnt = 0;
d_word_cnt = 0;
d_state = DECODING;
return i + 1;
}
}
return noutput_items;
}
/*
* From now one, we have a SYNC so we process the data
* in chunks of 10 bits
*/
for(i = 0; i < noutput_items / 10; i++) {
word = pack_10b_word(&in[i * 10]);
/* Revert 10b to 8b and accumulate! */
process_10b (word, d_word_cnt);
d_word_cnt++;
if(d_word_cnt == d_max_frame_len / 10) {
d_state = IN_SYNC;
pmt::pmt_t data = pmt::init_u8vector (d_max_frame_len / 10,
d_8b_words);
pmt::pmt_t out = pmt::make_dict();
if (d_erasure_cnt > 0) {
pmt::pmt_t erasures = pmt::init_s32vector (d_erasure_cnt,
d_erasures_indexes);
out = pmt::dict_add (out, pmt::intern ("erasures"), erasures);
}
out = pmt::dict_add(out, pmt::intern("data"), data);
message_port_pub (pmt::mp ("pdu"), out);
return (i+1) * 10;
}
}
return noutput_items;
}
}
/* namespace satnogs */
} /* namespace gr */

595
lib/decoder_8b10b_impl.h
View File

@ -1,595 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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_DECODER_8B10B_IMPL_H
#define INCLUDED_SATNOGS_DECODER_8B10B_IMPL_H
#include <satnogs/decoder_8b10b.h>
namespace gr
{
namespace satnogs
{
class decoder_8b10b_impl : public decoder_8b10b
{
private:
const size_t d_max_frame_len;
size_t d_erasure_cnt;
uint16_t d_control_symbol_pos;
uint16_t d_control_symbol_neg;
uint16_t d_data_reg;
uint16_t d_wrong_bits;
uint16_t d_wrong_bits_neg;
uint8_t d_nwrong;
uint8_t d_nwrong_neg;
size_t d_word_cnt;
uint8_t *d_8b_words;
int *d_erasures_indexes;
int d_lookup_8b10b[2][256] =
{
// RD = -1 cases
{
/* 00 */0x274,
/* 01 */0x1d4,
/* 02 */0x2d4,
/* 03 */0x71b,
/* 04 */0x354,
/* 05 */0x69b,
/* 06 */0x59b,
/* 07 */0x78b,
/* 08 */0x394,
/* 09 */0x65b,
/* 0a */0x55b,
/* 0b */0x74b,
/* 0c */0x4db,
/* 0d */0x6cb,
/* 0e */0x5cb,
/* 0f */0x174,
/* 10 */0x1b4,
/* 11 */0x63b,
/* 12 */0x53b,
/* 13 */0x72b,
/* 14 */0x4bb,
/* 15 */0x6ab,
/* 16 */0x5ab,
/* 17 */0x3a4,
/* 18 */0x334,
/* 19 */0x66b,
/* 1a */0x56b,
/* 1b */0x364,
/* 1c */0x4eb,
/* 1d */0x2e4,
/* 1e */0x1e4,
/* 1f */0x2b4,
/* 20 */0x679,
/* 21 */0x5d9,
/* 22 */0x6d9,
/* 23 */0x319,
/* 24 */0x759,
/* 25 */0x299,
/* 26 */0x199,
/* 27 */0x389,
/* 28 */0x799,
/* 29 */0x259,
/* 2a */0x159,
/* 2b */0x349,
/* 2c */0x0d9,
/* 2d */0x2c9,
/* 2e */0x1c9,
/* 2f */0x579,
/* 30 */0x5b9,
/* 31 */0x239,
/* 32 */0x139,
/* 33 */0x329,
/* 34 */0x0b9,
/* 35 */0x2a9,
/* 36 */0x1a9,
/* 37 */0x7a9,
/* 38 */0x739,
/* 39 */0x269,
/* 3a */0x169,
/* 3b */0x769,
/* 3c */0x0e9,
/* 3d */0x6e9,
/* 3e */0x5e9,
/* 3f */0x6b9,
/* 40 */0x675,
/* 41 */0x5d5,
/* 42 */0x6d5,
/* 43 */0x315,
/* 44 */0x755,
/* 45 */0x295,
/* 46 */0x195,
/* 47 */0x385,
/* 48 */0x795,
/* 49 */0x255,
/* 4a */0x155,
/* 4b */0x345,
/* 4c */0x0d5,
/* 4d */0x2c5,
/* 4e */0x1c5,
/* 4f */0x575,
/* 50 */0x5b5,
/* 51 */0x235,
/* 52 */0x135,
/* 53 */0x325,
/* 54 */0x0b5,
/* 55 */0x2a5,
/* 56 */0x1a5,
/* 57 */0x7a5,
/* 58 */0x735,
/* 59 */0x265,
/* 5a */0x165,
/* 5b */0x765,
/* 5c */0x0e5,
/* 5d */0x6e5,
/* 5e */0x5e5,
/* 5f */0x6b5,
/* 60 */0x673,
/* 61 */0x5d3,
/* 62 */0x6d3,
/* 63 */0x31c,
/* 64 */0x753,
/* 65 */0x29c,
/* 66 */0x19c,
/* 67 */0x38c,
/* 68 */0x793,
/* 69 */0x25c,
/* 6a */0x15c,
/* 6b */0x34c,
/* 6c */0x0dc,
/* 6d */0x2cc,
/* 6e */0x1cc,
/* 6f */0x573,
/* 70 */0x5b3,
/* 71 */0x23c,
/* 72 */0x13c,
/* 73 */0x32c,
/* 74 */0x0bc,
/* 75 */0x2ac,
/* 76 */0x1ac,
/* 77 */0x7a3,
/* 78 */0x733,
/* 79 */0x26c,
/* 7a */0x16c,
/* 7b */0x763,
/* 7c */0x0ec,
/* 7d */0x6e3,
/* 7e */0x5e3,
/* 7f */0x6b3,
/* 80 */0x272,
/* 81 */0x1d2,
/* 82 */0x2d2,
/* 83 */0x71d,
/* 84 */0x352,
/* 85 */0x69d,
/* 86 */0x59d,
/* 87 */0x78d,
/* 88 */0x392,
/* 89 */0x65d,
/* 8a */0x55d,
/* 8b */0x74d,
/* 8c */0x4dd,
/* 8d */0x6cd,
/* 8e */0x5cd,
/* 8f */0x172,
/* 90 */0x1b2,
/* 91 */0x63d,
/* 92 */0x53d,
/* 93 */0x72d,
/* 94 */0x4bd,
/* 95 */0x6ad,
/* 96 */0x5ad,
/* 97 */0x3a2,
/* 98 */0x332,
/* 99 */0x66d,
/* 9a */0x56d,
/* 9b */0x362,
/* 9c */0x4ed,
/* 9d */0x2e2,
/* 9e */0x1e2,
/* 9f */0x2b2,
/* a0 */0x67a,
/* a1 */0x5da,
/* a2 */0x6da,
/* a3 */0x31a,
/* a4 */0x75a,
/* a5 */0x29a,
/* a6 */0x19a,
/* a7 */0x38a,
/* a8 */0x79a,
/* a9 */0x25a,
/* aa */0x15a,
/* ab */0x34a,
/* ac */0x0da,
/* ad */0x2ca,
/* ae */0x1ca,
/* af */0x57a,
/* b0 */0x5ba,
/* b1 */0x23a,
/* b2 */0x13a,
/* b3 */0x32a,
/* b4 */0x0ba,
/* b5 */0x2aa,
/* b6 */0x1aa,
/* b7 */0x7aa,
/* b8 */0x73a,
/* b9 */0x26a,
/* ba */0x16a,
/* bb */0x76a,
/* bc */0x0ea,
/* bd */0x6ea,
/* be */0x5ea,
/* bf */0x6ba,
/* c0 */0x676,
/* c1 */0x5d6,
/* c2 */0x6d6,
/* c3 */0x316,
/* c4 */0x756,
/* c5 */0x296,
/* c6 */0x196,
/* c7 */0x386,
/* c8 */0x796,
/* c9 */0x256,
/* ca */0x156,
/* cb */0x346,
/* cc */0x0d6,
/* cd */0x2c6,
/* ce */0x1c6,
/* cf */0x576,
/* d0 */0x5b6,
/* d1 */0x236,
/* d2 */0x136,
/* d3 */0x326,
/* d4 */0x0b6,
/* d5 */0x2a6,
/* d6 */0x1a6,
/* d7 */0x7a6,
/* d8 */0x736,
/* d9 */0x266,
/* da */0x166,
/* db */0x766,
/* dc */0x0e6,
/* dd */0x6e6,
/* de */0x5e6,
/* df */0x6b6,
/* e0 */0x271,
/* e1 */0x1d1,
/* e2 */0x2d1,
/* e3 */0x71e,
/* e4 */0x351,
/* e5 */0x69e,
/* e6 */0x59e,
/* e7 */0x78e,
/* e8 */0x391,
/* e9 */0x65e,
/* ea */0x55e,
/* eb */0x74e,
/* ec */0x4de,
/* ed */0x6ce,
/* ee */0x5ce,
/* ef */0x171,
/* f0 */0x1b1,
/* f1 */0x637,
/* f2 */0x537,
/* f3 */0x72e,
/* f4 */0x4b7,
/* f5 */0x6ae,
/* f6 */0x5ae,
/* f7 */0x3a1,
/* f8 */0x331,
/* f9 */0x66e,
/* fa */0x56e,
/* fb */0x361,
/* fc */0x4ee,
/* fd */0x2e1,
/* fe */0x1e1,
/* ff */0x2b1, }, // RD = +1 cases
{
/* 00 */0x58b,
/* 01 */0x62b,
/* 02 */0x52b,
/* 03 */0x314,
/* 04 */0x4ab,
/* 05 */0x294,
/* 06 */0x194,
/* 07 */0x074,
/* 08 */0x46b,
/* 09 */0x254,
/* 0a */0x154,
/* 0b */0x344,
/* 0c */0x0d4,
/* 0d */0x2c4,
/* 0e */0x1c4,
/* 0f */0x68b,
/* 10 */0x64b,
/* 11 */0x234,
/* 12 */0x134,
/* 13 */0x324,
/* 14 */0x0b4,
/* 15 */0x2a4,
/* 16 */0x1a4,
/* 17 */0x45b,
/* 18 */0x4cb,
/* 19 */0x264,
/* 1a */0x164,
/* 1b */0x49b,
/* 1c */0x0e4,
/* 1d */0x51b,
/* 1e */0x61b,
/* 1f */0x54b,
/* 20 */0x189,
/* 21 */0x229,
/* 22 */0x129,
/* 23 */0x719,
/* 24 */0x0a9,
/* 25 */0x699,
/* 26 */0x599,
/* 27 */0x479,
/* 28 */0x069,
/* 29 */0x659,
/* 2a */0x559,
/* 2b */0x749,
/* 2c */0x4d9,
/* 2d */0x6c9,
/* 2e */0x5c9,
/* 2f */0x289,
/* 30 */0x249,
/* 31 */0x639,
/* 32 */0x539,
/* 33 */0x729,
/* 34 */0x4b9,
/* 35 */0x6a9,
/* 36 */0x5a9,
/* 37 */0x059,
/* 38 */0x0c9,
/* 39 */0x669,
/* 3a */0x569,
/* 3b */0x099,
/* 3c */0x4e9,
/* 3d */0x119,
/* 3e */0x219,
/* 3f */0x149,
/* 40 */0x185,
/* 41 */0x225,
/* 42 */0x125,
/* 43 */0x715,
/* 44 */0x0a5,
/* 45 */0x695,
/* 46 */0x595,
/* 47 */0x475,
/* 48 */0x065,
/* 49 */0x655,
/* 4a */0x555,
/* 4b */0x745,
/* 4c */0x4d5,
/* 4d */0x6c5,
/* 4e */0x5c5,
/* 4f */0x285,
/* 50 */0x245,
/* 51 */0x635,
/* 52 */0x535,
/* 53 */0x725,
/* 54 */0x4b5,
/* 55 */0x6a5,
/* 56 */0x5a5,
/* 57 */0x055,
/* 58 */0x0c5,
/* 59 */0x665,
/* 5a */0x565,
/* 5b */0x095,
/* 5c */0x4e5,
/* 5d */0x115,
/* 5e */0x215,
/* 5f */0x145,
/* 60 */0x18c,
/* 61 */0x22c,
/* 62 */0x12c,
/* 63 */0x713,
/* 64 */0x0ac,
/* 65 */0x693,
/* 66 */0x593,
/* 67 */0x473,
/* 68 */0x06c,
/* 69 */0x653,
/* 6a */0x553,
/* 6b */0x743,
/* 6c */0x4d3,
/* 6d */0x6c3,
/* 6e */0x5c3,
/* 6f */0x28c,
/* 70 */0x24c,
/* 71 */0x633,
/* 72 */0x533,
/* 73 */0x723,
/* 74 */0x4b3,
/* 75 */0x6a3,
/* 76 */0x5a3,
/* 77 */0x05c,
/* 78 */0x0cc,
/* 79 */0x663,
/* 7a */0x563,
/* 7b */0x09c,
/* 7c */0x4e3,
/* 7d */0x11c,
/* 7e */0x21c,
/* 7f */0x14c,
/* 80 */0x58d,
/* 81 */0x62d,
/* 82 */0x52d,
/* 83 */0x312,
/* 84 */0x4ad,
/* 85 */0x292,
/* 86 */0x192,
/* 87 */0x072,
/* 88 */0x46d,
/* 89 */0x252,
/* 8a */0x152,
/* 8b */0x342,
/* 8c */0x0d2,
/* 8d */0x2c2,
/* 8e */0x1c2,
/* 8f */0x68d,
/* 90 */0x64d,
/* 91 */0x232,
/* 92 */0x132,
/* 93 */0x322,
/* 94 */0x0b2,
/* 95 */0x2a2,
/* 96 */0x1a2,
/* 97 */0x45d,
/* 98 */0x4cd,
/* 99 */0x262,
/* 9a */0x162,
/* 9b */0x49d,
/* 9c */0x0e2,
/* 9d */0x51d,
/* 9e */0x61d,
/* 9f */0x54d,
/* a0 */0x18a,
/* a1 */0x22a,
/* a2 */0x12a,
/* a3 */0x71a,
/* a4 */0x0aa,
/* a5 */0x69a,
/* a6 */0x59a,
/* a7 */0x47a,
/* a8 */0x06a,
/* a9 */0x65a,
/* aa */0x55a,
/* ab */0x74a,
/* ac */0x4da,
/* ad */0x6ca,
/* ae */0x5ca,
/* af */0x28a,
/* b0 */0x24a,
/* b1 */0x63a,
/* b2 */0x53a,
/* b3 */0x72a,
/* b4 */0x4ba,
/* b5 */0x6aa,
/* b6 */0x5aa,
/* b7 */0x05a,
/* b8 */0x0ca,
/* b9 */0x66a,
/* ba */0x56a,
/* bb */0x09a,
/* bc */0x4ea,
/* bd */0x11a,
/* be */0x21a,
/* bf */0x14a,
/* c0 */0x186,
/* c1 */0x226,
/* c2 */0x126,
/* c3 */0x716,
/* c4 */0x0a6,
/* c5 */0x696,
/* c6 */0x596,
/* c7 */0x476,
/* c8 */0x066,
/* c9 */0x656,
/* ca */0x556,
/* cb */0x746,
/* cc */0x4d6,
/* cd */0x6c6,
/* ce */0x5c6,
/* cf */0x286,
/* d0 */0x246,
/* d1 */0x636,
/* d2 */0x536,
/* d3 */0x726,
/* d4 */0x4b6,
/* d5 */0x6a6,
/* d6 */0x5a6,
/* d7 */0x056,
/* d8 */0x0c6,
/* d9 */0x666,
/* da */0x566,
/* db */0x096,
/* dc */0x4e6,
/* dd */0x116,
/* de */0x216,
/* df */0x146,
/* e0 */0x58e,
/* e1 */0x62e,
/* e2 */0x52e,
/* e3 */0x311,
/* e4 */0x4ae,
/* e5 */0x291,
/* e6 */0x191,
/* e7 */0x071,
/* e8 */0x46e,
/* e9 */0x251,
/* ea */0x151,
/* eb */0x348,
/* ec */0x0d1,
/* ed */0x2c8,
/* ee */0x1c8,
/* ef */0x68e,
/* f0 */0x64e,
/* f1 */0x231,
/* f2 */0x131,
/* f3 */0x321,
/* f4 */0x0b1,
/* f5 */0x2a1,
/* f6 */0x1a1,
/* f7 */0x45e,
/* f8 */0x4ce,
/* f9 */0x261,
/* fa */0x161,
/* fb */0x49e,
/* fc */0x0e1,
/* fd */0x51e,
/* fe */0x61e,
/* ff */0x54e, } };
typedef enum
{
IN_SYNC, DECODING
} d_state_t;
d_state_t d_state;
public:
decoder_8b10b_impl (const std::string& control_symbol,
size_t max_frame_len);
~decoder_8b10b_impl ();
bool
set_access_code (const std::string &access_code);
void
process_10b (uint16_t word, int write_pos);
// 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_DECODER_8B10B_IMPL_H */

110
lib/fox_telem_mm_impl.cc
View File

@ -1,110 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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 "fox_telem_mm_impl.h"
#include <satnogs/log.h>
namespace gr {
namespace satnogs {
/**
* AMSAT FOX spacecraft IDs
*/
const uint8_t fox_telem_mm_impl::fox_id[] =
{
0x1 /* FOX-1A */,
0x2 /* FOX-1B */,
0x3 /* FOX-1C */,
0x4 /* FOX-1D */,
0x5 /* FOX-1E */
};
fox_telem_mm::sptr
fox_telem_mm::make()
{
return gnuradio::get_initial_sptr
(new fox_telem_mm_impl());
}
/*
* The private constructor
*/
fox_telem_mm_impl::fox_telem_mm_impl()
: gr::block("fox_telem_mm",
gr::io_signature::make(0, 0, 0),
gr::io_signature::make(0, 0, 0)),
/* 6 header, 58 payload */
d_frame_size (6 + 58)
{
message_port_register_in (pmt::mp ("in"));
message_port_register_out (pmt::mp ("raw"));
set_msg_handler (
pmt::mp ("in"),
boost::bind (&fox_telem_mm_impl::process_frame, this, _1));
}
static inline bool
is_spacecraft_valid(uint8_t id)
{
for (size_t i = 0; i < sizeof(fox_telem_mm_impl::fox_id); i++) {
if (fox_telem_mm_impl::fox_id[i] == id) {
return true;
}
}
return false;
}
void
fox_telem_mm_impl::process_frame (pmt::pmt_t msg)
{
uint8_t fox_id;
const uint8_t *data = (const uint8_t *) pmt::blob_data(msg);
size_t data_len = pmt::blob_length(msg);
if(data_len != 223) {
LOG_ERROR("Invalid message");
}
/* Check the spacecraft ID */
fox_id = data[0] & 0x7;
if(!is_spacecraft_valid(fox_id)) {
return;
}
message_port_pub(pmt::mp("raw"), pmt::make_blob(data, d_frame_size));
}
/*
* Our virtual destructor.
*/
fox_telem_mm_impl::~fox_telem_mm_impl()
{
}
} /* namespace satnogs */
} /* namespace gr */

50
lib/fox_telem_mm_impl.h
View File

@ -1,50 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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_FOX_TELEM_MM_IMPL_H
#define INCLUDED_SATNOGS_FOX_TELEM_MM_IMPL_H
#include <satnogs/fox_telem_mm.h>
namespace gr
{
namespace satnogs
{
class fox_telem_mm_impl : public fox_telem_mm
{
private:
const size_t d_frame_size;
void
process_frame (pmt::pmt_t msg);
public:
static const uint8_t fox_id[];
fox_telem_mm_impl ();
~fox_telem_mm_impl ();
};
} // namespace satnogs
} // namespace gr
#endif /* INCLUDED_SATNOGS_FOX_TELEM_MM_IMPL_H */

139
lib/quad_demod_filter_ff_impl.cc
View File

@ -1,139 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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 "quad_demod_filter_ff_impl.h"
namespace gr {
namespace satnogs {
quad_demod_filter_ff::sptr
quad_demod_filter_ff::make(float gain, int window)
{
return gnuradio::get_initial_sptr
(new quad_demod_filter_ff_impl(gain, window));
}
/*
* The private constructor
*/
quad_demod_filter_ff_impl::quad_demod_filter_ff_impl (float gain,
int window) :
gr::sync_block ("quad_demod_filter_ff",
gr::io_signature::make (1, 1, sizeof(float)),
gr::io_signature::make (1, 1, sizeof(float))),
d_gain (gain),
d_norm (1.0f / window),
d_win (window),
d_sum (0.0f),
d_sum_sq (0.0f),
d_remaining (0)
{
if(window < 1) {
throw std::invalid_argument ("Window must be a positive");
}
set_history (window);
}
/*
* Our virtual destructor.
*/
quad_demod_filter_ff_impl::~quad_demod_filter_ff_impl()
{
}
/**
* Fast approximation of the inverse of the square root.
* Thank you OpenArena!
* @param number the number to be computed
* @return the inverse of the square root of the number
*/
static inline float
inv_sqrt (float number)
{
long i;
float x2, y;
const float threehalfs = 1.5f;
x2 = number * 0.5f;
y = number;
i = *(long *) &y;
i = 0x5f3759df - (i >> 1); /* what the fuck? */
y = *(float *) &i;
y = y * (threehalfs - (x2 * y * y));
return y;
}
int
quad_demod_filter_ff_impl::work (int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
const float *in = (const float *) input_items[0];
float *out = (float *) output_items[0];
float m;
float m_sq;
float snr;
float in_old;
float in_new;
float diff;
for (int i = 0; i < noutput_items; i++) {
in_old = std::abs (in[i]);
in_new = std::abs (in[i + d_win - 1]);
d_sum -= in_old;
d_sum += in_new;
d_sum_sq -= (in_old * in_old);
d_sum_sq += (in_new * in_new);
m = (d_sum * d_norm);
m_sq = (d_sum_sq * d_norm);
snr = m * inv_sqrt (m_sq - m * m);
/*
* If the SNR is high enough start passing the data to the output.
* In order not to loose any samples due to the settling period, start
* from the buffered and let a window of samples to pass after the
* trigger is off
*/
if (snr > d_gain * 1.8) {
d_remaining = 2 * d_win;
}
if (d_remaining) {
out[i] = in[i];
d_remaining--;
}
else {
out[i] = 0.0f;
}
}
// Tell runtime system how many output items we produced.
return noutput_items;
}
} /* namespace satnogs */
} /* namespace gr */

52
lib/quad_demod_filter_ff_impl.h
View File

@ -1,52 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2018, 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_QUAD_DEMOD_FILTER_FF_IMPL_H
#define INCLUDED_SATNOGS_QUAD_DEMOD_FILTER_FF_IMPL_H
#include <satnogs/quad_demod_filter_ff.h>
namespace gr {
namespace satnogs {
class quad_demod_filter_ff_impl : public quad_demod_filter_ff
{
private:
const float d_gain;
const float d_norm;
const int d_win;
float d_sum;
float d_sum_sq;
int d_remaining;
public:
quad_demod_filter_ff_impl(float gain, int window);
~quad_demod_filter_ff_impl();
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_QUAD_DEMOD_FILTER_FF_IMPL_H */

20
swig/satnogs_swig0.i
View File

@ -32,7 +32,6 @@
#include "satnogs/udp_msg_sink.h"
#include "satnogs/coarse_doppler_correction_cc.h"
#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"
@ -41,10 +40,6 @@
#include "satnogs/frame_file_sink.h"
#include "satnogs/iq_sink.h"
#include "satnogs/json_converter.h"
#include "satnogs/quad_demod_filter_ff.h"
#include "satnogs/decoder_8b10b.h"
#include "satnogs/ccsds_rs_decoder_mm.h"
#include "satnogs/fox_telem_mm.h"
#include "satnogs/lrpt_decoder.h"
#include "satnogs/lrpt_sync.h"
#include "satnogs/frame_acquisition.h"
@ -99,9 +94,6 @@ GR_SWIG_BLOCK_MAGIC2(satnogs, coarse_doppler_correction_cc);
%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);
@ -126,18 +118,6 @@ GR_SWIG_BLOCK_MAGIC2(satnogs, iq_sink);
%include "satnogs/json_converter.h"
GR_SWIG_BLOCK_MAGIC2(satnogs, json_converter);
%include "satnogs/quad_demod_filter_ff.h"
GR_SWIG_BLOCK_MAGIC2(satnogs, quad_demod_filter_ff);
%include "satnogs/decoder_8b10b.h"
GR_SWIG_BLOCK_MAGIC2(satnogs, decoder_8b10b);
%include "satnogs/ccsds_rs_decoder_mm.h"
GR_SWIG_BLOCK_MAGIC2(satnogs, ccsds_rs_decoder_mm);
%include "satnogs/fox_telem_mm.h"
GR_SWIG_BLOCK_MAGIC2(satnogs, fox_telem_mm);
%include "satnogs/lrpt_sync.h"
GR_SWIG_BLOCK_MAGIC2(satnogs, lrpt_sync);