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

Continue with the transition to the new decoder API 

* Removed obsolete blocks
* Created a new CRC class with static methods. This will make easier the
integration of new CRC schemes. The old way was rather too C-styled
This commit is contained in:
Manolis Surligas 2019-09-12 01:41:57 +03:00
parent 17f91dbb27
commit 7b7fb82adc
28 changed files with 519 additions and 1406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
grc/CMakeLists.txt
View File

@ -23,7 +23,6 @@ list(APPEND debug_blocks
satnogs_morse_debug_source.xml
satnogs_debug_msg_source.xml
satnogs_debug_msg_source_raw.xml
satnogs_leo_channel.xml
satnogs_cw_encoder.xml
)
@ -51,7 +50,6 @@ list(APPEND enabled_blocks
satnogs_ogg_source.xml
satnogs_noaa_apt_sink.xml
satnogs_whitening.xml
satnogs_frame_acquisition.xml
)
if(${INCLUDE_DEBUG_BLOCKS})

2
grc/satellites/CMakeLists.txt
View File

@ -18,4 +18,4 @@
# Boston, MA 02110-1301, USA.
add_subdirectory(upsat)

30
grc/satellites/upsat/CMakeLists.txt
View File

@ -1,30 +0,0 @@
# 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
)

30
grc/satellites/upsat/satnogs_qb50_deframer.xml
View File

@ -1,30 +0,0 @@
<?xml version="1.0"?>
<block>
<name>QB50 AX.25 Deframer</name>
<key>satnogs_qb50_deframer</key>
<import>import satnogs</import>
<make>satnogs.qb50_deframer($wod_ssid)</make>
<param>
<name>WOD SSID</name>
<key>wod_ssid</key>
<value>0xe</value>
<type>int</type>
</param>
<sink>
<name>in</name>
<type>message</type>
</sink>
<source>
<name>out</name>
<type>message</type>
</source>
<source>
<name>wod</name>
<type>message</type>
</source>
</block>

113
grc/satellites/upsat/satnogs_upsat_fsk_frame_acquisition.xml
View File

@ -1,113 +0,0 @@
<?xml version="1.0"?>
<block>
<name>UPSAT FSK Frame Acquisition</name>
<key>satnogs_upsat_fsk_frame_acquisition</key>
<import>import satnogs</import>
<make>satnogs.upsat_fsk_frame_acquisition($preamble, $sync_word, $whitening, $manchester, $check_crc, $ax_25, $whitening_mask, $whitening_seed, $whitening_order, $packet_len)</make>
<param>
<name>Frame Preamble</name>
<key>preamble</key>
<type>raw</type>
</param>
<param>
<name>Synchronization Word</name>
<key>sync_word</key>
<type>raw</type>
</param>
<param>
<name>Whitening</name>
<key>whitening</key>
<type>enum</type>
<option>
<name>No</name>
<key>False</key>
</option>
<option>
<name>Yes</name>
<key>True</key>
</option>
</param>
<param>
<name>Use Manchester Coding</name>
<key>manchester</key>
<type>enum</type>
<option>
<name>No</name>
<key>False</key>
</option>
<option>
<name>Yes</name>
<key>True</key>
</option>
</param>
<param>
<name>Check CRC</name>
<key>check_crc</key>
<type>enum</type>
<option>
<name>Yes</name>
<key>True</key>
</option>
<option>
<name>No</name>
<key>False</key>
</option>
</param>
<param>
<name>Use AX.25 encapsulation</name>
<key>ax_25</key>
<type>enum</type>
<option>
<name>No</name>
<key>False</key>
</option>
<option>
<name>Yes</name>
<key>True</key>
</option>
</param>
<param>
<name>Whitening mask</name>
<key>whitening_mask</key>
<value>0x1001</value>
<type>int</type>
</param>
<param>
<name>Whitening seed</name>
<key>whitening_seed</key>
<value>0x1FF</value>
<type>int</type>
</param>
<param>
<name>Whitening order</name>
<key>whitening_order</key>
<value>17</value>
<type>int</type>
</param>
<param>
<name>Packet length</name>
<key>packet_len</key>
<value>0</value>
<type>int</type>
</param>
<sink>
<name>in</name>
<type>float</type>
</sink>
<source>
<name>pdu</name>
<type>message</type>
</source>
</block>

130
grc/satellites/upsat/satnogs_upsat_fsk_frame_encoder.xml
View File

@ -1,130 +0,0 @@
<?xml version="1.0"?>
<block>
<name>UPSAT FSK Frame Encoder</name>
<key>satnogs_upsat_fsk_frame_encoder</key>
<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>
<param>
<name>Frame Preamble</name>
<key>preamble</key>
<type>raw</type>
</param>
<param>
<name>Synchronization Word</name>
<key>sync_word</key>
<type>raw</type>
</param>
<param>
<name>Append CRC</name>
<key>append_crc</key>
<type>enum</type>
<option>
<name>Yes</name>
<key>True</key>
</option>
<option>
<name>No</name>
<key>False</key>
</option>
</param>
<param>
<name>Whitening</name>
<key>whitening</key>
<type>enum</type>
<option>
<name>No</name>
<key>False</key>
</option>
<option>
<name>Yes</name>
<key>True</key>
</option>
</param>
<param>
<name>Use Manchester Coding</name>
<key>manchester</key>
<type>enum</type>
<option>
<name>No</name>
<key>False</key>
</option>
<option>
<name>Yes</name>
<key>True</key>
</option>
</param>
<param>
<name>Send MS bit first</name>
<key>msb_first</key>
<type>enum</type>
<option>
<name>Yes</name>
<key>True</key>
</option>
<option>
<name>No</name>
<key>False</key>
</option>
</param>
<param>
<name>Use AX.25 encapsulation</name>
<key>ax_25</key>
<type>enum</type>
<option>
<name>No</name>
<key>False</key>
</option>
<option>
<name>Yes</name>
<key>True</key>
</option>
</param>
<param>
<name>Destination Callsign</name>
<key>dest_addr</key>
<type>string</type>
</param>
<param>
<name>Destination SSID</name>
<key>dest_ssid</key>
<type>int</type>
</param>
<param>
<name>Source Callsign</name>
<key>src_addr</key>
<type>string</type>
</param>
<param>
<name>Source SSID</name>
<key>src_ssid</key>
<type>int</type>
</param>
<param>
<name>Number of zero settling samples</name>
<key>settling_samples</key>
<value>64</value>
<type>int</type>
</param>
<sink>
<name>pdu</name>
<type>message</type>
</sink>
<source>
<name>out</name>
<type>float</type>
</source>
</block>

180
grc/satellites/upsat/satnogs_upsat_transmitter.xml
View File

@ -1,180 +0,0 @@
<block>
<name>Satnogs UPSat Transmitter</name>
<key>satnogs_upsat_transmitter</key>
<import>import satnogs</import>
<make>satnogs.satnogs_upsat_transmitter(frame_preamble=$frame_preamble,
sync_word=$sync_word,
append_crc=$append_crc,
whitening=$whitening,
manchester=$manchester,
msb_first=$msb_first,
ax25_format=$ax25_format,
dest_addr=$dest_addr,
dest_ssid=$dest_ssid,
src_addr=$src_addr,
src_ssid=$src_ssid,
settling_samples=$settling_samples,
samps_per_symbol=$interp,
interpolation_taps=$taps,
samp_rate=$samp_rate,
lo_offset=$lo_offset,
deviation=$deviation,
baud_rate=$baud_rate)</make>
<param>
<name>Frame Preamble</name>
<key>frame_preamble</key>
<type>raw</type>
</param>
<param>
<name>Synchronization Word</name>
<key>sync_word</key>
<type>raw</type>
</param>
<param>
<name>Append CRC</name>
<key>append_crc</key>
<type>enum</type>
<option>
<name>Yes</name>
<key>True</key>
</option>
<option>
<name>No</name>
<key>False</key>
</option>
</param>
<param>
<name>Whitening</name>
<key>whitening</key>
<type>enum</type>
<option>
<name>No</name>
<key>False</key>
</option>
<option>
<name>Yes</name>
<key>True</key>
</option>
</param>
<param>
<name>Use Manchester Coding</name>
<key>manchester</key>
<type>enum</type>
<option>
<name>No</name>
<key>False</key>
</option>
<option>
<name>Yes</name>
<key>True</key>
</option>
</param>
<param>
<name>Send MS bit first</name>
<key>msb_first</key>
<type>enum</type>
<option>
<name>Yes</name>
<key>True</key>
</option>
<option>
<name>No</name>
<key>False</key>
</option>
</param>
<param>
<name>Use AX.25 encapsulation</name>
<key>ax25_format</key>
<type>enum</type>
<option>
<name>No</name>
<key>False</key>
</option>
<option>
<name>Yes</name>
<key>True</key>
</option>
</param>
<param>
<name>Destination Callsign</name>
<key>dest_addr</key>
<type>string</type>
</param>
<param>
<name>Destination SSID</name>
<key>dest_ssid</key>
<type>int</type>
</param>
<param>
<name>Source Callsign</name>
<key>src_addr</key>
<type>string</type>
</param>
<param>
<name>Source SSID</name>
<key>src_ssid</key>
<type>int</type>
</param>
<param>
<name>Number of zero settling samples</name>
<key>settling_samples</key>
<value>64</value>
<type>int</type>
</param>
<param>
<name>FIR filter Interpolation</name>
<key>interp</key>
<value>1</value>
<type>int</type>
</param>
<param>
<name>Interpolation Taps</name>
<key>taps</key>
<type>real_vector</type>
</param>
<param>
<name>Sampling rate</name>
<key>samp_rate</key>
<type>real</type>
</param>
<param>
<name>LO offset</name>
<key>lo_offset</key>
<type>real</type>
</param>
<param>
<name>baud rate</name>
<key>baud_rate</key>
<type>real</type>
</param>
<param>
<name>Deviation</name>
<key>deviation</key>
<type>real</type>
</param>
<sink>
<name>in</name>
<type>message</type>
</sink>
<source>
<name>out</name>
<type>complex</type>
</source>
</block>

2
grc/satnogs_block_tree.xml
View File

@ -13,7 +13,6 @@
</cat>
<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>
@ -40,6 +39,5 @@
<block>satnogs_ax25_encoder_mb</block>
<block>satnogs_waterfall_sink</block>
<block>variable_whitening</block>
<block>satnogs_frame_acquisition</block>
<block>satnogs_frame_decoder</block>
</cat>

119
grc/satnogs_frame_acquisition.xml
View File

@ -1,119 +0,0 @@
<?xml version="1.0"?>
<block>
<name>Generic Frame Acquisition</name>
<key>satnogs_frame_acquisition</key>
<import>import satnogs</import>
<make>satnogs.frame_acquisition($variant, $preamble, $preamble_thrsh, $sync_word, $sync_thrsh, $frame_size_field_len, $frame_len, $crc, $whitening, $max_frame_len)</make>
<param>
<name>Variant</name>
<key>variant</key>
<type>enum</type>
<option>
<name>TI, Constant Frame Length</name>
<key>0</key>
</option>
<option>
<name>TI, Variable Frame Length</name>
<key>1</key>
</option>
<option>
<name>Golay24 coded Frame Length</name>
<key>2</key>
</option>
</param>
<param>
<name>Frame Preamble</name>
<key>preamble</key>
<value>[0x55, 0x55, 0x55, 0x55, 0x55]</value>
<type>raw</type>
</param>
<param>
<name>Preamble Threshold</name>
<key>preamble_thrsh</key>
<value>5</value>
<type>int</type>
</param>
<param>
<name>Synchronization Word</name>
<key>sync_word</key>
<value>[0x31, 0xe5]</value>
<type>raw</type>
</param>
<param>
<name>Synchronization Word Threshold</name>
<key>sync_thrsh</key>
<value>3</value>
<type>int</type>
</param>
<param>
<name>Frame Size Field Length</name>
<key>frame_size_field_len</key>
<value>1</value>
<type>int</type>
<hide>>#if $variant() == 1 then 'none' else 'all'#</hide>
</param>
<param>
<name>Frame Length</name>
<key>frame_len</key>
<value>128</value>
<type>int</type>
<hide>>#if $variant() == 0 then 'none' else 'all'#</hide>
</param>
<param>
<name>Maximum Frame Length</name>
<key>max_frame_len</key>
<value>2048</value>
<type>int</type>
</param>
<param>
<name>Whitening</name>
<key>whitening</key>
<value>None</value>
<type>raw</type>
</param>
<param>
<name>CRC</name>
<key>crc</key>
<type>enum</type>
<option>
<name>None</name>
<key>0</key>
</option>
<option>
<name>CRC16_CCITT</name>
<key>1</key>
</option>
<option>
<name>CRC16_CCITT_REVERSED</name>
<key>2</key>
</option>
<option>
<name>CRC16_IBM</name>
<key>3</key>
</option>
<option>
<name>CRC32_CCITT</name>
<key>4</key>
</option>
</param>
<sink>
<name>in</name>
<type>byte</type>
</sink>
<source>
<name>out</name>
<type>message</type>
</source>
</block>

38
grc/satnogs_leo_channel.xml
View File

@ -1,38 +0,0 @@
<?xml version="1.0"?>
<block>
<name>LEO Channel</name>
<key>satnogs_leo_channel</key>
<category>[SatNOGS]/Debug</category>
<import>import satnogs</import>
<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
* 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>

4
include/satnogs/CMakeLists.txt
View File

@ -51,7 +51,6 @@ list(APPEND HEADER_FILES
doppler_correction_cc.h
doppler_fit.h
freq_drift.h
upsat_fsk_frame_acquisition.h
upsat_fsk_frame_encoder.h
whitening.h
udp_msg_sink.h
@ -65,11 +64,12 @@ list(APPEND HEADER_FILES
iq_sink.h
lrpt_sync.h
lrpt_decoder.h
frame_acquisition.h
shift_reg.h
golay24.h
ax25_decoder.h
json_converter.h
ieee802_15_4_variant_decoder.h
crc.h
)
if(${INCLUDE_DEBUG_BLOCKS})

8
include/satnogs/ax25.h
View File

@ -21,7 +21,7 @@
#ifndef INCLUDE_SATNOGS_AX25_H_
#define INCLUDE_SATNOGS_AX25_H_
#include <satnogs/utils.h>
#include <satnogs/crc.h>
#include <satnogs/log.h>
#include <limits.h>
#include <stdint.h>
@ -85,11 +85,7 @@ namespace gr
static inline uint16_t
ax25_fcs (uint8_t *buffer, size_t len)
{
uint16_t fcs = 0xFFFF;
while (len--) {
fcs = (fcs >> 8) ^ crc16_ccitt_table_reverse[(fcs ^ *buffer++) & 0xFF];
}
return fcs ^ 0xFFFF;
return crc::crc16_ax25(buffer, len);
}
/**

71
include/satnogs/crc.h Normal file
View File

@ -0,0 +1,71 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2019, Libre Space Foundation <http://libre.space>
*
* 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_CRC_H
#define INCLUDED_SATNOGS_CRC_H
#include <satnogs/api.h>
namespace gr
{
namespace satnogs
{
/*!
* CRC class providing a range of different CRC calculation static methods
*
*/
class SATNOGS_API crc
{
public:
typedef enum crc_type {
PDU = 0,
CRC_VALID,
FREQ_OFFSET,
CORRECTED_BITS,
TIME,
SAMPLE_START,
SAMPLE_CNT,
SYMBOL_ERASURES,
KEYS_NUM
} crc_t;
static uint16_t
crc16_ccitt_reversed(const uint8_t *data, size_t len);
static uint16_t
crc16_ccitt(const uint8_t *data, size_t len);
static uint16_t
crc16_ax25(const uint8_t *data, size_t len);
static uint16_t
crc16_ibm(const uint8_t *data, size_t len);
private:
static const uint16_t crc16_ccitt_table_reverse[256];
static const uint16_t crc16_ccitt_table[256];
};
} // namespace satnogs
} // namespace gr
#endif /* INCLUDED_SATNOGS_CRC_H */

59
include/satnogs/ieee802_15_4_variant_decoder.h Normal file
View File

@ -0,0 +1,59 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2019, Libre Space Foundation <http://libre.space>
*
* 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_IEEE802_15_4_VARIANT_DECODER_H
#define INCLUDED_SATNOGS_IEEE802_15_4_VARIANT_DECODER_H
#include <satnogs/api.h>
#include <satnogs/whitening.h>
#include <satnogs/crc.h>
namespace gr
{
namespace satnogs
{
/*!
* \brief A IEEE 802.15.4 like decoder
*
* The IEEE 802.15.4 uses the well known preamble + sync word synchronization
* scheme. Many popular on Cubesats ICs like the Texas Instruments CC1xxx family
* or the AXxxxx of On Semiconductors follow this scheme. This decoder
* class provides a generic way to decode signals following this framing
* scheme.
*
*/
class SATNOGS_API ieee802_15_4_variant_decoder
{
public:
ieee802_15_4_variant_decoder (const std::vector<uint8_t> &preamble,
size_t preamble_threshold,
const std::vector<uint8_t> &sync,
crc::crc_t crc,
whitening::whitening_sptr descrambler);
~ieee802_15_4_variant_decoder ();
private:
};
} // namespace satnogs
} // namespace gr
#endif /* INCLUDED_SATNOGS_IEEE802_15_4_VARIANT_DECODER_H */

91
include/satnogs/upsat_fsk_frame_acquisition.h
View File

@ -1,91 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2016,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_UPSAT_FSK_FRAME_ACQUISITION_H
#define INCLUDED_SATNOGS_UPSAT_FSK_FRAME_ACQUISITION_H
#include <satnogs/api.h>
#include <gnuradio/sync_block.h>
namespace gr
{
namespace satnogs
{
/*!
* \brief This block takes samples after the Clock Recovery block
* and tries to extract frames. This is performed by searching for a
* known preamble. For the byte synchronization the block tries to
* search for the specified synchronization word that should be present
* before the start of the payload.
*
* \ingroup satnogs
*
*/
class SATNOGS_API upsat_fsk_frame_acquisition : virtual public gr::sync_block
{
public:
typedef boost::shared_ptr<upsat_fsk_frame_acquisition> sptr;
/*!
* Creates the FSK frame acquisition block for the UPSAT satellite.
* @param preamble the bytes that consist the preamble of the frame
*
* @param sync_word the byte synchronization word
*
* @param whitening true if the transmitted data have been processed by
* the whitening algorithm of the CC1120 chip. False otherwise.
*
* @param manchester true if the transmitted data have been processed by
* the Manchester algorithm of the CC1120 chip. False otherwise.
*
* @param check_crc if set to true the decoder will push frames only if
* their CRC field in correct.
*
* @param ax25_format if set to true the frame contains an AX.25
* encoded payload. Prior producing the payload, AX.25 decoding
* will be performed. If set to false, the payload will be pushed
* as it is.
*
* @param whitening_mask the polynomial of the scrambler
* @param whitening_seed the initial seed of the scrambler
* @param whitening_order the size of the scrambler's LFSR
* @param packet_len if set to 0 the decoder enters the variable
* packet length mode, where the packet length is indicated from the
* first byte after the SYNC word. Otherwise this field specifies the
* payload length in bytes.
*/
static sptr
make (const std::vector<uint8_t> &preamble,
const std::vector<uint8_t> &sync_word, bool whitening = false,
bool manchester = false, bool check_crc = true,
bool ax25_format = false,
uint32_t whitening_mask = 0x1001,
uint32_t whitening_seed = 0x1FF,
uint32_t whitening_order = 17,
size_t packet_len = 0);
};
} // namespace satnogs
} // namespace gr
#endif /* INCLUDED_SATNOGS_UPSAT_FSK_FRAME_ACQUISITION_H */

130
include/satnogs/utils.h
View File

@ -2,7 +2,7 @@
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2016,2018 Libre Space Foundation <http://librespacefoundation.org/>
* Copyright (C) 2016,2018,2019 Libre Space Foundation <http://libre.space>
*
* 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
@ -45,134 +45,6 @@ mape (double ref, double estimation)
return std::abs (ref - estimation) / ref;
}
/**
* Lookup table for the CCITT CRC16
*/
static const uint16_t crc16_ccitt_table_reverse[256] =
{ 0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF, 0x8C48,
0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7, 0x1081,
0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E, 0x9CC9,
0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876, 0x2102,
0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD, 0xAD4A,
0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5, 0x3183,
0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C, 0xBDCB,
0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974, 0x4204,
0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB, 0xCE4C,
0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3, 0x5285,
0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A, 0xDECD,
0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72, 0x6306,
0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9, 0xEF4E,
0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1, 0x7387,
0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738, 0xFFCF,
0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70, 0x8408,
0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7, 0x0840,
0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF, 0x9489,
0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036, 0x18C1,
0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E, 0xA50A,
0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5, 0x2942,
0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD, 0xB58B,
0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134, 0x39C3,
0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C, 0xC60C,
0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3, 0x4A44,
0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB, 0xD68D,
0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232, 0x5AC5,
0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A, 0xE70E,
0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1, 0x6B46,
0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9, 0xF78F,
0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330, 0x7BC7,
0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78 };
static const uint16_t crc16_ccitt_table[256] =
{ 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108,
0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231,
0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339,
0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462,
0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A,
0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 0x3653,
0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 0xB75B,
0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 0x48C4,
0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 0xC9CC,
0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5,
0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD,
0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6,
0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE,
0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97,
0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 0xFF9F,
0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 0x9188,
0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 0x1080,
0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83B9,
0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1,
0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA,
0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2,
0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB,
0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3,
0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 0xD94C,
0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 0x5844,
0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 0xCB7D,
0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 0x4A75,
0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E,
0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26,
0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F,
0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17,
0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 };
static inline uint16_t
update_crc16_ccitt_reversed (uint16_t crc, const uint8_t *data, size_t len)
{
register size_t i;
for (i = 0; i < len; i++) {
crc = (crc >> 8) ^ crc16_ccitt_table_reverse[(crc ^ data[i]) & 0xff];
}
return crc;
}
static inline uint16_t
crc16_ccitt_reversed (const uint8_t *data, size_t len)
{
return update_crc16_ccitt_reversed (0xFFFF, data, len) ^ 0xFFFF;
}
static uint16_t
update_crc16_ccitt (uint16_t crc, const uint8_t *buf, size_t len)
{
while (len-- != 0) {
crc = crc16_ccitt_table[((crc >> 8) ^ *buf++) & 0xff] ^ (crc << 8);
}
return crc;
}
static inline uint16_t
crc16_ccitt (const uint8_t *data, size_t len)
{
return update_crc16_ccitt (0x0000, data, len);
}
static uint16_t
update_crc16_ibm (uint8_t crc, uint16_t reg)
{
const uint16_t crc_poly = 0x8005;
for (size_t i = 0; i < 8; i++) {
if (((reg & 0x8000) >> 8) ^ (crc & 0x80)) {
reg = (reg << 1) ^ crc_poly;
}
else {
reg = (reg << 1);
}
crc <<= 1;
}
return reg;
}
static uint16_t
crc16_ibm (uint8_t *buf, size_t len)
{
uint16_t crc = 0xFFFF;
for (size_t i = 0; i < len; i++)
crc = update_crc16_ibm (buf[i], crc);
return crc;
}
/**
* Counts the number of active bits in x
*/

8
lib/CMakeLists.txt
View File

@ -57,7 +57,6 @@ list(APPEND satnogs_sources
frame_encoder_impl.cc
doppler_fit.cc
freq_drift.cc
upsat_fsk_frame_acquisition_impl.cc
upsat_fsk_frame_encoder_impl.cc
whitening.cc
udp_msg_sink_impl.cc
@ -72,11 +71,12 @@ list(APPEND satnogs_sources
lrpt_sync_impl.cc
convolutional_deinterleaver.cc
lrpt_decoder_impl.cc
frame_acquisition_impl.cc
shift_reg.cc
golay24.cc
ax25_decoder.cc
json_converter_impl.cc)
json_converter_impl.cc
ieee802_15_4_variant_decoder.cc
crc.cc)
if(${INCLUDE_DEBUG_BLOCKS})
list(APPEND satnogs_sources ${satnogs_debug_sources})
@ -129,6 +129,8 @@ list(APPEND test_satnogs_sources
${CMAKE_CURRENT_SOURCE_DIR}/qa_golay24.cc
${CMAKE_CURRENT_SOURCE_DIR}/test_satnogs.cc
${CMAKE_CURRENT_SOURCE_DIR}/qa_satnogs.cc
${CMAKE_CURRENT_SOURCE_DIR}/qa_crc.cc
${CMAKE_CURRENT_SOURCE_DIR}/qa_ieee802_15_4_variant_decoder.cc
${CMAKE_CURRENT_SOURCE_DIR}/qa_json_converter.cc
${CMAKE_CURRENT_SOURCE_DIR}/qa_ax25_decoder.cc
)

153
lib/crc.cc Normal file
View File

@ -0,0 +1,153 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2019, Libre Space Foundation <http://libre.space>
*
* 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/crc.h>
namespace gr
{
namespace satnogs
{
const uint16_t crc::crc16_ccitt_table_reverse[256] =
{ 0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF, 0x8C48,
0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7, 0x1081, 0x0108,
0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E, 0x9CC9, 0x8D40, 0xBFDB,
0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876, 0x2102, 0x308B, 0x0210, 0x1399,
0x6726, 0x76AF, 0x4434, 0x55BD, 0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E,
0xFAE7, 0xC87C, 0xD9F5, 0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E,
0x54B5, 0x453C, 0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD,
0xC974, 0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB,
0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3, 0x5285,
0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A, 0xDECD, 0xCF44,
0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72, 0x6306, 0x728F, 0x4014,
0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9, 0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5,
0xA96A, 0xB8E3, 0x8A78, 0x9BF1, 0x7387, 0x620E, 0x5095, 0x411C, 0x35A3,
0x242A, 0x16B1, 0x0738, 0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862,
0x9AF9, 0x8B70, 0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E,
0xF0B7, 0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF,
0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036, 0x18C1,
0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E, 0xA50A, 0xB483,
0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5, 0x2942, 0x38CB, 0x0A50,
0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD, 0xB58B, 0xA402, 0x9699, 0x8710,
0xF3AF, 0xE226, 0xD0BD, 0xC134, 0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7,
0x6E6E, 0x5CF5, 0x4D7C, 0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1,
0xA33A, 0xB2B3, 0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72,
0x3EFB, 0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232,
0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A, 0xE70E,
0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1, 0x6B46, 0x7ACF,
0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9, 0xF78F, 0xE606, 0xD49D,
0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330, 0x7BC7, 0x6A4E, 0x58D5, 0x495C,
0x3DE3, 0x2C6A, 0x1EF1, 0x0F78 };
const uint16_t crc::crc16_ccitt_table[256] =
{ 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108,
0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210,
0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B,
0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401,
0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE,
0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6,
0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D,
0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5,
0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC,
0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4,
0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD,
0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13,
0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A,
0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E,
0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1,
0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB,
0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0,
0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8,
0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657,
0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9,
0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882,
0x28A3, 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E,
0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07,
0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D,
0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74,
0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 };
uint16_t
crc::crc16_ccitt_reversed(const uint8_t *data, size_t len)
{
uint16_t crc = 0xFFFF;
for (size_t i = 0; i < len; i++) {
crc = (crc >> 8) ^ crc16_ccitt_table_reverse[(crc ^ data[i]) & 0xff];
}
return crc ^ 0xFFFF;
}
uint16_t
crc::crc16_ccitt (const uint8_t *data, size_t len)
{
uint16_t crc = 0;
while (len-- != 0) {
crc = crc16_ccitt_table[((crc >> 8) ^ *data++) & 0xff] ^ (crc << 8);
}
return crc;
}
uint16_t
crc::crc16_ax25(const uint8_t *data, size_t len)
{
uint16_t fcs = 0xFFFF;
while (len--) {
fcs = (fcs >> 8) ^ crc16_ccitt_table_reverse[(fcs ^ *data++) & 0xFF];
}
return fcs ^ 0xFFFF;
}
static uint16_t
update_crc16_ibm (uint8_t crc, uint16_t reg)
{
const uint16_t crc_poly = 0x8005;
for (size_t i = 0; i < 8; i++) {
if (((reg & 0x8000) >> 8) ^ (crc & 0x80)) {
reg = (reg << 1) ^ crc_poly;
}
else {
reg = (reg << 1);
}
crc <<= 1;
}
return reg;
}
uint16_t
crc::crc16_ibm(const uint8_t *data, size_t len)
{
uint16_t crc = 0xFFFF;
for (size_t i = 0; i < len; i++)
crc = update_crc16_ibm (data[i], crc);
return crc;
}
} /* namespace satnogs */
} /* namespace gr */

47
lib/ieee802_15_4_variant_decoder.cc Normal file
View File

@ -0,0 +1,47 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2019, Libre Space Foundation <http://libre.space>
*
* 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/ieee802_15_4_variant_decoder.h>
namespace gr
{
namespace satnogs
{
ieee802_15_4_variant_decoder::ieee802_15_4_variant_decoder (
const std::vector<uint8_t> &preamble, size_t preamble_threshold,
const std::vector<uint8_t> &sync, crc::crc_t crc,
whitening::whitening_sptr descrambler)
{
}
ieee802_15_4_variant_decoder::~ieee802_15_4_variant_decoder ()
{
}
} /* namespace satnogs */
} /* namespace gr */

39
lib/qa_crc.cc Normal file
View File

@ -0,0 +1,39 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2019, Libre Space Foundation <http://libre.space>
*
* 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/>.
*/
#include <gnuradio/attributes.h>
#include <cppunit/TestAssert.h>
#include "qa_crc.h"
#include <satnogs/crc.h>
namespace gr
{
namespace satnogs
{
void
qa_crc::t1 ()
{
// Put test here
}
} /* namespace satnogs */
} /* namespace gr */

45
lib/qa_crc.h Normal file
View File

@ -0,0 +1,45 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2019, Libre Space Foundation <http://libre.space>
*
* 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 _QA_CRC_H_
#define _QA_CRC_H_
#include <cppunit/extensions/HelperMacros.h>
#include <cppunit/TestCase.h>
namespace gr {
namespace satnogs {
class qa_crc : public CppUnit::TestCase
{
public:
CPPUNIT_TEST_SUITE(qa_crc);
CPPUNIT_TEST(t1);
CPPUNIT_TEST_SUITE_END();
private:
void t1();
};
} /* namespace satnogs */
} /* namespace gr */
#endif /* _QA_CRC_H_ */

39
lib/qa_ieee802_15_4_variant_decoder.cc Normal file
View File

@ -0,0 +1,39 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2019, Libre Space Foundation <http://libre.space>
*
* 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/>.
*/
#include <gnuradio/attributes.h>
#include <cppunit/TestAssert.h>
#include "qa_ieee802_15_4_variant_decoder.h"
#include <satnogs/ieee802_15_4_variant_decoder.h>
namespace gr
{
namespace satnogs
{
void
qa_ieee802_15_4_variant_decoder::t1 ()
{
// Put test here
}
} /* namespace satnogs */
} /* namespace gr */

45
lib/qa_ieee802_15_4_variant_decoder.h Normal file
View File

@ -0,0 +1,45 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2019, Libre Space Foundation <http://libre.space>
*
* 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 _QA_IEEE802_15_4_VARIANT_DECODER_H_
#define _QA_IEEE802_15_4_VARIANT_DECODER_H_
#include <cppunit/extensions/HelperMacros.h>
#include <cppunit/TestCase.h>
namespace gr {
namespace satnogs {
class qa_ieee802_15_4_variant_decoder : public CppUnit::TestCase
{
public:
CPPUNIT_TEST_SUITE(qa_ieee802_15_4_variant_decoder);
CPPUNIT_TEST(t1);
CPPUNIT_TEST_SUITE_END();
private:
void t1();
};
} /* namespace satnogs */
} /* namespace gr */
#endif /* _QA_IEEE802_15_4_VARIANT_DECODER_H_ */

4
lib/qa_satnogs.cc
View File

@ -22,6 +22,8 @@
#include "qa_golay24.h"
#include "qa_ax25_decoder.h"
#include "qa_json_converter.h"
#include "qa_ieee802_15_4_variant_decoder.h"
#include "qa_crc.h"
CppUnit::TestSuite *
qa_satnogs::suite()
@ -30,5 +32,7 @@ qa_satnogs::suite()
s->addTest(gr::satnogs::qa_golay24::suite());
s->addTest(gr::satnogs::qa_ax25_decoder::suite());
s->addTest(gr::satnogs::qa_json_converter::suite());
s->addTest(gr::satnogs::qa_ieee802_15_4_variant_decoder::suite());
s->addTest(gr::satnogs::qa_crc::suite());
return s;
}

410
lib/upsat_fsk_frame_acquisition_impl.cc
View File

@ -1,410 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2016,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 "upsat_fsk_frame_acquisition_impl.h"
#include <satnogs/log.h>
#include <satnogs/ax25.h>
#include <satnogs/utils.h>
#include <arpa/inet.h>
namespace gr
{
namespace satnogs
{
upsat_fsk_frame_acquisition::sptr
upsat_fsk_frame_acquisition::make (const std::vector<uint8_t> &preamble,
const std::vector<uint8_t> &sync_word,
bool whitening, bool manchester,
bool check_crc, bool ax25_format,
uint32_t whitening_mask,
uint32_t whitening_seed,
uint32_t whitening_order,
size_t packet_len)
{
return gnuradio::get_initial_sptr (
new upsat_fsk_frame_acquisition_impl (preamble, sync_word, whitening,
manchester, check_crc,
ax25_format, whitening_mask,
whitening_seed,
whitening_order,
packet_len));
}
/*
* The private constructor
*/
upsat_fsk_frame_acquisition_impl::upsat_fsk_frame_acquisition_impl (
const std::vector<uint8_t> &preamble,
const std::vector<uint8_t> &sync_word, bool whitening, bool manchester,
bool check_crc, bool ax25_format, uint32_t whitening_mask,
uint32_t whitening_seed, uint32_t whitening_order,
size_t packet_len) :
gr::sync_block ("upsat_fsk_frame_acquisition",
gr::io_signature::make (1, 1, sizeof(float)),
gr::io_signature::make (0, 0, 0)),
d_preamble (preamble),
d_preamble_len (preamble.size ()),
d_sync_word (sync_word),
d_sync_word_len (sync_word.size ()),
/*
* Preamble is used only for AGC. The true synchronization is
* performed using the SYNC word. For this reason if some preamble
* symbols are retrieved, the algorithm should immediately start
* searching for the SYNC word.
*/
d_search_for_sync_thrhld (d_preamble_len / 3),
d_whitening (whitening),
d_manchester (manchester),
d_check_crc (check_crc),
d_is_ax25 (ax25_format),
d_var_packet_len(packet_len == 0),
d_state (SEARCHING),
d_shifting_byte (0x0),
d_decoded_bytes (0),
d_decoded_bits (0),
d_frame_len (0),
d_descrambler (whitening_mask, whitening_seed, whitening_order)
{
size_t i;
message_port_register_out (pmt::mp ("pdu"));
if (d_preamble_len < 3) {
throw std::invalid_argument ("Preamble must be at least 2 bytes long");
}
if (d_sync_word_len < 1) {
throw std::invalid_argument (
"Synchronization word must be at least 1 byte long");
}
for (i = 1; i < d_preamble_len; i++) {
if (d_preamble[i] != d_preamble[0]) {
throw std::invalid_argument (
"The preamble should contain the same bytes");
}
}
d_pdu = new uint8_t[UPSAT_MAX_FRAME_LEN];
d_ax25_tmp_buf = new uint8_t[2 * UPSAT_MAX_FRAME_LEN * 8];
d_ax25_buf = new uint8_t[2 * UPSAT_MAX_FRAME_LEN];
/* If the fixed packet length is set, store the expected frame size */
d_frame_len = packet_len;
}
/*
* Our virtual destructor.
*/
upsat_fsk_frame_acquisition_impl::~upsat_fsk_frame_acquisition_impl ()
{
delete[] d_pdu;
delete[] d_ax25_tmp_buf;
delete[] d_ax25_buf;
}
inline void
upsat_fsk_frame_acquisition_impl::slice_and_shift (float in)
{
uint8_t tmp;
/* Slice the input into 0 and 1 bits */
tmp = in > 0 ? 1 : 0;
d_shifting_byte = d_shifting_byte << 1;
d_shifting_byte |= tmp;
}
inline void
upsat_fsk_frame_acquisition_impl::reset_state ()
{
LOG_DEBUG("Enter reset");
d_state = SEARCHING;
d_decoded_bytes = 0;
d_decoded_bits = 0;
d_shifting_byte = 0;
}
inline void
upsat_fsk_frame_acquisition_impl::have_preamble ()
{
LOG_DEBUG("Enter have preamble");
d_state = HAVE_PREAMBLE;
d_decoded_bytes = 1;
}
inline void
upsat_fsk_frame_acquisition_impl::searching_sync_word ()
{
LOG_DEBUG("Enter searching sync");
d_state = SEARCHING_SYNC_WORD;
d_decoded_bytes = 0;
d_decoded_bits = 0;
}
inline void
upsat_fsk_frame_acquisition_impl::have_sync ()
{
LOG_DEBUG("Enter have sync");
d_state = HAVE_SYNC_WORD;
/* The first SYNC byte have already been found */
d_decoded_bytes = 1;
d_decoded_bits = 0;
}
inline void
upsat_fsk_frame_acquisition_impl::have_frame_len ()
{
LOG_DEBUG("Enter frame len");
d_descrambler.reset ();
d_state = HAVE_FRAME_LEN;
d_decoded_bytes = 0;
d_decoded_bits = 0;
}
inline void
upsat_fsk_frame_acquisition_impl::have_payload ()
{
LOG_DEBUG("Enter have payload");
d_state = HAVE_PAYLOAD;
if(d_var_packet_len) {
d_decoded_bytes = 1;
}
else {
d_decoded_bytes = 0;
}
d_decoded_bits = 0;
}
inline void
upsat_fsk_frame_acquisition_impl::unpack_ax25_bytes (size_t len_bytes)
{
size_t i;
uint8_t *in = d_pdu + 1;
for (i = 0; i < len_bytes; i++) {
d_ax25_tmp_buf[8 * i] = (in[i] >> 7) & 0x1;
d_ax25_tmp_buf[8 * i + 1] = (in[i] >> 6) & 0x1;
d_ax25_tmp_buf[8 * i + 2] = (in[i] >> 5) & 0x1;
d_ax25_tmp_buf[8 * i + 3] = (in[i] >> 4) & 0x1;
d_ax25_tmp_buf[8 * i + 4] = (in[i] >> 3) & 0x1;
d_ax25_tmp_buf[8 * i + 5] = (in[i] >> 2) & 0x1;
d_ax25_tmp_buf[8 * i + 6] = (in[i] >> 1) & 0x1;
d_ax25_tmp_buf[8 * i + 7] = in[i] & 0x1;
}
/* De-white the data if necessary */
if (d_whitening) {
d_descrambler.descramble_one_bit_per_byte (d_ax25_tmp_buf,
d_ax25_tmp_buf,
len_bytes * 8);
}
}
int
upsat_fsk_frame_acquisition_impl::work (
int noutput_items, gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
int i;
uint16_t crc_received;
uint16_t crc_calc;
size_t ax25_frame_len = 0;
ax25_decode_status_t status;
size_t payload_len;
uint8_t *payload;
const float *in = (const float *) input_items[0];
for (i = 0; i < noutput_items; i++) {
slice_and_shift (in[i]);
switch (d_state)
{
case SEARCHING:
if (d_shifting_byte == d_preamble[0]) {
have_preamble ();
}
break;
case HAVE_PREAMBLE:
d_decoded_bits++;
if (d_decoded_bits == 8) {
d_decoded_bits = 0;
if (d_shifting_byte == d_preamble[d_decoded_bytes]) {
d_decoded_bytes++;
if (d_decoded_bytes >= d_search_for_sync_thrhld) {
/* End of the preamble. It's time for the sync word */
searching_sync_word ();
}
}
else {
/* Reset the preamble detection */
reset_state ();
}
}
break;
case SEARCHING_SYNC_WORD:
d_decoded_bits++;
if (d_shifting_byte == d_sync_word[0]) {
have_sync ();
break;
}
if (d_decoded_bits == 8) {
d_decoded_bits = 0;
d_decoded_bytes++;
/*
* If we decoded bytes have length greater than the preamble and
* the SYNC word, we lost the frame...
*/
if (d_decoded_bytes
> d_preamble_len - d_search_for_sync_thrhld
+ d_sync_word_len) {
reset_state ();
}
}
break;
case HAVE_SYNC_WORD:
d_decoded_bits++;
if (d_decoded_bits == 8) {
d_decoded_bits = 0;
if (d_shifting_byte == d_sync_word[d_decoded_bytes]) {
d_decoded_bytes++;
if (d_decoded_bytes == d_sync_word_len) {
if(d_var_packet_len) {
have_frame_len ();
}
else{
have_payload();
}
}
}
else {
reset_state ();
}
}
break;
case HAVE_FRAME_LEN:
d_decoded_bits++;
if (d_decoded_bits == 8) {
/* Length field has been whitened if the option is enabled */
if (d_whitening) {
/* Frame length field is needed for the CRC calculation */
d_descrambler.descramble (d_pdu, &d_shifting_byte, 1);
/* CRC is not included in the frame length field, but we want it */
d_frame_len = 1 + d_pdu[0] + sizeof(uint16_t);
}
else {
/* Frame length field is needed for the CRC calculation */
d_pdu[0] = d_shifting_byte;
/* CRC is not included in the frame length field, but we want it */
d_frame_len = 1 + d_shifting_byte + sizeof(uint16_t);
}
have_payload ();
}
break;
case HAVE_PAYLOAD:
d_decoded_bits++;
if (d_decoded_bits == 8) {
if(d_var_packet_len) {
payload = d_pdu + 1;
payload_len = d_frame_len - 1;
}
else{
payload = d_pdu;
payload_len = d_frame_len;
}
d_decoded_bits = 0;
d_pdu[d_decoded_bytes] = d_shifting_byte;
d_decoded_bytes++;
if (d_decoded_bytes == d_frame_len) {
if (d_is_ax25) {
unpack_ax25_bytes (payload_len);
status = ax25_decode (d_ax25_buf, &ax25_frame_len,
d_ax25_tmp_buf, payload_len * 8);
if (status == AX25_DEC_OK) {
/* Skip the AX.25 header */
message_port_pub (
pmt::mp ("pdu"),
pmt::make_blob (
d_ax25_buf + AX25_MIN_ADDR_LEN + 2,
ax25_frame_len - AX25_MIN_ADDR_LEN - 2));
}
/*
* We are done here. Whitening and FSK CRC is not supported
* when transmitting/receiving AX.25 frames
*/
reset_state ();
break;
}
if (d_whitening) {
d_descrambler.descramble (payload, payload, payload_len);
}
if (!d_check_crc) {
message_port_pub (
pmt::mp ("pdu"),
pmt::make_blob (payload,
payload_len - sizeof(uint16_t)));
reset_state ();
break;
}
/* Retrieve and check the CRC */
memcpy (&crc_received, d_pdu + d_frame_len - sizeof(uint16_t),
sizeof(uint16_t));
/* The CRC is transmitted in network byte order */
crc_received = ntohs (crc_received);
crc_calc = crc16_ccitt (d_pdu, d_frame_len - sizeof(uint16_t));
if (crc_calc == crc_received) {
message_port_pub (
pmt::mp ("pdu"),
pmt::make_blob (payload,
payload_len - sizeof(uint16_t)));
}
else {
LOG_WARN("Frame with wrong CRC got 0x%x calc 0x%x",
crc_received, crc_calc);
}
reset_state ();
}
}
break;
default:
LOG_WARN("Unknown decoding state");
}
}
return noutput_items;
}
} /* namespace satnogs */
} /* namespace gr */

110
lib/upsat_fsk_frame_acquisition_impl.h
View File

@ -1,110 +0,0 @@
/* -*- c++ -*- */
/*
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
*
* Copyright (C) 2016,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_UPSAT_FSK_FRAME_ACQUISITION_IMPL_H
#define INCLUDED_SATNOGS_UPSAT_FSK_FRAME_ACQUISITION_IMPL_H
#include <satnogs/config.h>
#include <satnogs/upsat_fsk_frame_acquisition.h>
#include <satnogs/whitening.h>
namespace gr
{
namespace satnogs
{
class upsat_fsk_frame_acquisition_impl : public upsat_fsk_frame_acquisition
{
private:
/**
* Decoding FSM
*/
typedef enum
{
SEARCHING, //!< SEARCHING when searching for the start of the preamble
HAVE_PREAMBLE, //!< HAVE_PREAMBLE when the decoder is inside the preamble
SEARCHING_SYNC_WORD,
HAVE_SYNC_WORD, //!< HAVE_SYNC_WORD when the decoder is inside the sync word
HAVE_FRAME_LEN, //!< HAVE_FRAME_LEN when the decoder is inside the frame length field
HAVE_PAYLOAD //!< HAVE_PAYLOAD when the decoder process the palyload of the frame
} decoding_state_t;
const std::vector<uint8_t> d_preamble;
const size_t d_preamble_len;
const std::vector<uint8_t> d_sync_word;
const size_t d_sync_word_len;
const size_t d_search_for_sync_thrhld;
const bool d_whitening;
const bool d_manchester;
const bool d_check_crc;
const bool d_is_ax25;
const bool d_var_packet_len;
decoding_state_t d_state;
uint8_t d_shifting_byte;
size_t d_decoded_bytes;
size_t d_decoded_bits;
size_t d_frame_len;
whitening d_descrambler;
uint8_t *d_pdu;
uint8_t *d_ax25_tmp_buf;
uint8_t *d_ax25_buf;
inline void
slice_and_shift (float in);
inline void
reset_state ();
inline void
have_preamble ();
inline void
searching_sync_word ();
inline void
have_sync ();
inline void
have_frame_len ();
inline void
have_payload ();
inline void
unpack_ax25_bytes (size_t len_bytes);
public:
upsat_fsk_frame_acquisition_impl (const std::vector<uint8_t> &preamble,
const std::vector<uint8_t> &sync_word,
bool whitening, bool manchester,
bool check_crc, bool ax25_format,
uint32_t whitening_mask,
uint32_t whitening_seed,
uint32_t whitening_order,
size_t packet_len);
~upsat_fsk_frame_acquisition_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_UPSAT_FSK_FRAME_ACQUISITION_IMPL_H */

5
lib/upsat_fsk_frame_encoder_impl.cc
View File

@ -26,6 +26,7 @@
#include "upsat_fsk_frame_encoder_impl.h"
#include <satnogs/log.h>
#include <satnogs/utils.h>
#include <satnogs/crc.h>
#include <arpa/inet.h>
namespace gr
@ -223,8 +224,8 @@ namespace gr
/* If it is necessary calculate and append the CRC */
if (d_append_crc) {
crc = crc16_ccitt (d_pdu + d_preamble_len + d_sync_word_len,
d_pdu_len + 1);
crc = crc::crc16_ccitt (d_pdu + d_preamble_len + d_sync_word_len,
d_pdu_len + 1);
/* CRC must be transmitted MSB first */
crc = htons (crc);
memcpy (d_pdu + d_preamble_len + d_sync_word_len + 1 + d_pdu_len,

11
swig/satnogs_swig0.i
View File

@ -26,7 +26,6 @@
#include "satnogs/doppler_correction_cc.h"
#include "satnogs/frame_decoder.h"
#include "satnogs/frame_encoder.h"
#include "satnogs/upsat_fsk_frame_acquisition.h"
#include "satnogs/upsat_fsk_frame_encoder.h"
#include "satnogs/whitening.h"
#include "satnogs/udp_msg_sink.h"
@ -42,8 +41,8 @@
#include "satnogs/json_converter.h"
#include "satnogs/lrpt_decoder.h"
#include "satnogs/lrpt_sync.h"
#include "satnogs/frame_acquisition.h"
#include "satnogs/metadata.h"
#include "satnogs/crc.h"
%}
@ -52,6 +51,8 @@
%include "satnogs/amsat_duv_decoder.h"
%include "satnogs/ax25_decoder.h"
%include "satnogs/metadata.h"
%include "satnogs/crc.h"
%include "satnogs/morse_decoder.h"
GR_SWIG_BLOCK_MAGIC2(satnogs, morse_decoder);
@ -77,9 +78,6 @@ 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);
@ -123,6 +121,3 @@ GR_SWIG_BLOCK_MAGIC2(satnogs, lrpt_sync);
%include "satnogs/lrpt_decoder.h"
GR_SWIG_BLOCK_MAGIC2(satnogs, lrpt_decoder);
%include "satnogs/frame_acquisition.h"
GR_SWIG_BLOCK_MAGIC2(satnogs, frame_acquisition);