Uplink: convert preliminary uplink work to next branch

with gain bin settings.

CMakeLists.txt

@@ -108,7 +108,7 @@ add_custom_target(uninstall
 ########################################################################
 # Add subdirectories
 ########################################################################
-add_subdirectory(include)
+add_subdirectory(include/gr_air_modes)
 add_subdirectory(lib)
 add_subdirectory(swig)
 add_subdirectory(python)

apps/modes_gui

@@ -19,7 +19,7 @@
 # Boston, MA 02110-1301, USA.
 # 
 
-import os, sys, time, threading, datetime, math, csv, tempfile
+import os, sys, time, threading, datetime, math, csv, tempfile, ConfigParser
 from optparse import OptionParser
 from PyQt4 import QtCore,QtGui,QtWebKit
 from PyQt4.Qwt5 import Qwt
@@ -48,27 +48,45 @@ class mainwindow(QtGui.QMainWindow):
         #populate antenna, rate combo boxes based on source
         self.populate_source_options()
 
+        defaults = self.get_defaults()
+
         #should round to actual achieved gain
-        self.ui.line_gain.insert("30")
+        self.ui.line_gain.insert(defaults["gain"])
 
         #default to 5dB
-        self.ui.line_threshold.insert("5")
+        self.ui.line_threshold.insert(defaults["threshold"])
 
-        self.ui.prog_rssi.setMinimum(0)
-        self.ui.prog_rssi.setMaximum(40)
+        if defaults["pmf"] is not None:
+            self.ui.check_pmf.setChecked(bool(defaults["pmf"]))
+        if defaults["dcblock"] is not None:
+            self.ui.check_dcblock.setChecked(bool(defaults["dcblock"]))
+        if defaults["samplerate"] is not None:
+            if defaults["samplerate"] in self.rates:
+                self.ui.combo_rate.setCurrentIndex(self.rates.index(int(defaults["samplerate"])))
 
-        self.ui.combo_ant.setCurrentIndex(self.ui.combo_ant.findText("RX2"))
+        self.ui.prog_rssi.setMinimum(-60)
+        self.ui.prog_rssi.setMaximum(0)
+
+        if defaults["antenna"] is None:
+            self.ui.combo_ant.setCurrentIndex(self.ui.combo_ant.findText("RX2"))
+        else:
+            self.ui.combo_ant.setCurrentIndex(self.ui.combo_ant.findText(defaults["antenna"]))
 
         #check KML by default, leave the rest unchecked.
-        self.ui.check_sbs1.setCheckState(QtCore.Qt.Unchecked)
-        self.ui.check_raw.setCheckState(QtCore.Qt.Unchecked)
-        self.ui.check_fgfs.setCheckState(QtCore.Qt.Unchecked)
-        self.ui.check_kml.setCheckState(QtCore.Qt.Checked)
+        self.ui.check_sbs1.setChecked(bool(defaults["sbs1"] == "1"))
+        self.ui.check_raw.setChecked(bool(defaults["raw"] == "1"))
+        self.ui.check_fgfs.setChecked(bool(defaults["fgfs"] == "1"))
+        self.ui.check_kml.setChecked(bool(defaults["kml"] == "1"))
 
-        self.ui.line_sbs1port.insert("30003")
-        self.ui.line_rawport.insert("9988")
-        self.ui.line_fgfsport.insert("5500")
-        self.ui.line_kmlfilename.insert("modes.kml")
+        self.ui.line_sbs1port.insert(defaults["sbs1port"])#"30003")
+        self.ui.line_rawport.insert(defaults["rawport"])#"9988")
+        self.ui.line_fgfsport.insert(defaults["fgfsport"])#"5500")
+        self.ui.line_kmlfilename.insert(defaults["kmlfile"])#"modes.kml")
+
+        if defaults["latitude"] is not None:
+            self.ui.line_my_lat.insert(defaults["latitude"])
+        if defaults["longitude"] is not None:
+            self.ui.line_my_lon.insert(defaults["longitude"])
 
         #disable by default
         self.ui.check_adsbonly.setCheckState(QtCore.Qt.Unchecked)
@@ -122,9 +140,27 @@ class mainwindow(QtGui.QMainWindow):
         self.ui.list_aircraft.selectionModel().currentRowChanged.connect(self.update_map_highlight)
         self.datamodel.dataChanged.connect(self.unmapped_widgets_dataChanged)
 
+        #hook up parameter-changed signals so we can change gain, rate, etc. while running
+        self.ui.combo_rate.currentIndexChanged['QString'].connect(self.update_sample_rate)
+        self.ui.line_gain.editingFinished.connect(self.update_gain)
+        self.ui.combo_source.currentIndexChanged['QString'].connect(self.populate_source_options)
+
         #hook up live data text box update signal
         self.live_data_changed_signal.connect(self.on_append_live_data)
 
+        self._last_live_data_update = time.time()
+        self._pending_msgstr = ""
+
+        self.prefs = None
+
+    def update_sample_rate(self, rate):
+        if self.running:
+            self._radio.set_rate(int(float(rate)*1e6))
+
+    def update_gain(self):
+        if self.running:
+            self._radio.set_gain(float(self.ui.line_gain.text()))
+
 ############ widget update functions for non-mapped widgets ############
     def update_heading_widget(self, index):
         if index.model() is not None:
@@ -196,7 +232,7 @@ class mainwindow(QtGui.QMainWindow):
         elif sourceid == "Osmocom":
             try:
                 import osmosdr
-                self.src = osmosdr.source_c("")
+                self.src = osmosdr.source("")
                 self.rates = [rate.start() for rate in self.src.get_sample_rates() if (rate.start() % 2.e6) == 0]
                 self.antennas = ["RX"]
                 self.src = None
@@ -226,11 +262,12 @@ class mainwindow(QtGui.QMainWindow):
         self.ui.combo_ant.addItems(self.antennas)
 
         #set up recommended sample rate
-        recommended_rate = min(x for x in self.rates if x >= 4e6 and
-                             max(self.rates) % x == 0)
-        if recommended_rate >= 8.e6:
-            self.ui.check_pmf.setChecked(True)
-        self.ui.combo_rate.setCurrentIndex(self.rates.index(recommended_rate))
+        if len(self.rates) > 1:
+            recommended_rate = min(x for x in self.rates if x >= 4e6 and
+                                 max(self.rates) % x == 0)
+            if recommended_rate >= 8.e6:
+                self.ui.check_pmf.setChecked(True)
+            self.ui.combo_rate.setCurrentIndex(self.rates.index(recommended_rate))
 
 ################ action handlers ####################
     def on_combo_source_currentIndexChanged(self, index):
@@ -259,7 +296,8 @@ class mainwindow(QtGui.QMainWindow):
             options.antenna = str(self.ui.combo_ant.currentText())
             options.gain = float(self.ui.line_gain.text())
             options.threshold = float(self.ui.line_threshold.text())
-            options.pmf = self.ui.check_pmf.checkState()
+            options.pmf = self.ui.check_pmf.isChecked()
+            options.dcblock = self.ui.check_dcblock.isChecked()
 
             self._servers = ["inproc://modes-radio-pub"] #TODO ADD REMOTES
             self._relay = air_modes.zmq_pubsub_iface(self.context, subaddr=self._servers, pubaddr=None)
@@ -337,6 +375,29 @@ class mainwindow(QtGui.QMainWindow):
             self.ui.button_start.setText("Stop")
             self.running = True
 
+            #grab prefs and save them
+            self.prefs = {}
+            self.prefs["samplerate"] = options.rate
+            self.prefs["antenna"] = options.antenna
+            self.prefs["gain"] = options.gain
+            self.prefs["pmf"] = "1" if options.pmf else "0"
+            self.prefs["dcblock"] = "1" if options.dcblock else "0"
+            self.prefs["source"] = self.ui.combo_source.currentText()
+            self.prefs["threshold"] = options.threshold
+            self.prefs["sbs1"] = "1" if self.ui.check_sbs1.isChecked() else "0"
+            self.prefs["sbs1port"] = int(self.ui.line_sbs1port.text())
+            self.prefs["fgfs"] = "1" if self.ui.check_fgfs.isChecked() else "0"
+            self.prefs["fgfsport"] = int(self.ui.line_fgfsport.text())
+            self.prefs["raw"] = "1" if self.ui.check_raw.isChecked() else "0"
+            self.prefs["rawport"] = int(self.ui.line_rawport.text())
+            self.prefs["kml"] = "1" if self.ui.check_kml.isChecked() else "0"
+            self.prefs["kmlfile"] = self.ui.line_kmlfilename.text()
+            try:
+                self.prefs["latitude"] = float(self.ui.line_my_lat.text())
+                self.prefs["longitude"] = float(self.ui.line_my_lon.text())
+            except:
+                pass
+
     def on_quit(self):
         if self.running is True:
             self._relay.close()
@@ -352,9 +413,19 @@ class mainwindow(QtGui.QMainWindow):
             except:
                 pass
 
+        if self.prefs is not None:
+            self.write_defaults(self.prefs)
+
     #slot to catch signal emitted by output_live_data (necessary for
     #thread safety since output_live_data is called by another thread)
     def on_append_live_data(self, msgstr):
+        self._pending_msgstr += msgstr + "\n"
+        if time.time() - self._last_live_data_update >= 0.1:
+            self._last_live_data_update = time.time()
+            self.update_live_data(self._pending_msgstr)
+            self._pending_msgstr = ""
+
+    def update_live_data(self, msgstr):
         #limit scrollback buffer size -- is there a faster way?
         if(self.ui.text_livedata.document().lineCount() > 500):
             cursor = self.ui.text_livedata.textCursor()
@@ -365,6 +436,56 @@ class mainwindow(QtGui.QMainWindow):
         self.ui.text_livedata.append(msgstr)
         self.ui.text_livedata.verticalScrollBar().setSliderPosition(self.ui.text_livedata.verticalScrollBar().maximum())
 
+    opt_file = "~/.gr-air-modes/prefs"
+    def get_defaults(self):
+        defaults = {}
+        defaults["samplerate"] = None #let app pick it
+        defaults["pmf"] = None
+        defaults["dcblock"] = None
+        defaults["antenna"] = None
+        defaults["gain"] = "25"
+        defaults["kml"] = "1"
+        defaults["kmlfile"] = "modes.kml"
+        defaults["sbs1"] = "0"
+        defaults["sbs1port"] = "30003"
+        defaults["raw"] = "0"
+        defaults["rawport"] = "9988"
+        defaults["fgfs"] = "0"
+        defaults["fgfsport"] = "5500"
+        defaults["source"] = "UHD"
+        defaults["threshold"] = "5"
+        defaults["latitude"] = None
+        defaults["longitude"] = None
+
+        prefs = ConfigParser.ConfigParser(defaults)
+        prefs.optionxform = str
+
+        try:
+            prefs.read(os.path.expanduser(self.opt_file))
+            for item in prefs.items("GUI"):
+                defaults[item[0]] = item[1]
+        except IOError:
+            print "No preferences file %s found, creating..." % os.path.expanduser(self.opt_file)
+            self.write_defaults(defaults)
+
+        return defaults
+
+
+    def write_defaults(self, defaults):
+        config = ConfigParser.RawConfigParser()
+        config.add_section('GUI')
+
+        for item in defaults:
+            config.set('GUI', item, str(defaults[item]))
+
+        dirname = os.path.dirname(os.path.expanduser(self.opt_file))
+        if not os.path.exists(dirname):
+            os.makedirs(dirname)
+
+        with open(os.path.expanduser(self.opt_file), 'wb') as prefsfile:
+            config.write(prefsfile)
+
+
 if __name__ == '__main__':
     app = QtGui.QApplication(sys.argv)
     window = mainwindow()

apps/modes_rx

@@ -86,13 +86,14 @@ def main():
     sbs1port = air_modes.output_sbs1(cpr_dec, 30003, publisher)
 
   tb.run()
+  time.sleep(0.2)
   tb.close()
-
+  time.sleep(0.2)
   relay.close()
 
   if options.kml is not None:
     kmlgen.close()
-    
+
 
 if __name__ == '__main__':
   main()

include/air_modes_int_and_dump.h

@@ -1,54 +0,0 @@
-/*
-# Copyright 2010 Nick Foster
-# 
-# This file is part of gr-air-modes
-# 
-# gr-air-modes 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.
-# 
-# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-# 
-*/
-
-#ifndef INCLUDED_AIR_MODES_int_and_dump_H
-#define INCLUDED_AIR_MODES_int_and_dump_H
-
-#include <gr_block.h>
-
-class air_modes_int_and_dump;
-typedef boost::shared_ptr<air_modes_int_and_dump> air_modes_int_and_dump_sptr;
-
-air_modes_int_and_dump_sptr air_make_modes_int_and_dump(int samples_per_chip);
-
-/*!
- * \brief mode select int_and_dump filter
- * \ingroup block
- */
-class air_modes_int_and_dump : public gr_block
-{
-private:
-    friend air_modes_int_and_dump_sptr air_make_modes_int_and_dump(int samples_per_chip);
-    air_modes_int_and_dump(int samples_per_chip);
-
-	int d_samples_per_chip;
-    float d_acc;
-    float d_pos;
-
-public:
-    int general_work (int noutput_items,
-              gr_vector_int &ninput_items,
-              gr_vector_const_void_star &input_items,
-              gr_vector_void_star &output_items);
-};
-
-#endif /* INCLUDED_AIR_MODES_int_and_dump_H */

include/air_modes_preamble.h

@@ -1,66 +0,0 @@
-/*
-# Copyright 2010 Nick Foster
-# 
-# This file is part of gr-air-modes
-# 
-# gr-air-modes 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.
-# 
-# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-# 
-*/
-
-#ifndef INCLUDED_AIR_MODES_PREAMBLE_H
-#define INCLUDED_AIR_MODES_PREAMBLE_H
-
-#include <gnuradio/block.h>
-#include <air_modes_api.h>
-
-class air_modes_preamble;
-typedef boost::shared_ptr<air_modes_preamble> air_modes_preamble_sptr;
-
-AIR_MODES_API air_modes_preamble_sptr air_make_modes_preamble(int channel_rate, float threshold_db);
-
-/*!
- * \brief mode select preamble detection
- * \ingroup block
- */
-class AIR_MODES_API air_modes_preamble : public gr::block
-{
-private:
-    friend air_modes_preamble_sptr air_make_modes_preamble(int channel_rate, float threshold_db);
-    air_modes_preamble(int channel_rate, float threshold_db);
-
-	int d_check_width;
-	int d_chip_rate;
-	float d_preamble_length_us;
-	int d_samples_per_chip;
-	int d_samples_per_symbol;
-	float d_threshold_db;
-	float d_threshold;
-	pmt::pmt_t d_me, d_key;
-    gr::tag_t d_timestamp;
-	double d_secs_per_sample;
-
-public:
-    int general_work (int noutput_items,
-              gr_vector_int &ninput_items,
-              gr_vector_const_void_star &input_items,
-              gr_vector_void_star &output_items);
-
-    void set_rate(int channel_rate);
-    void set_threshold(float threshold_db);
-    float get_threshold(void);
-};
-
-#endif /* INCLUDED_AIR_MODES_PREAMBLE_H */

include/gr_air_modes/CMakeLists.txt

@@ -21,9 +21,10 @@
 # Install public header files
 ########################################################################
 install(FILES
-    air_modes_preamble.h
-    air_modes_slicer.h
-    air_modes_types.h
-    air_modes_api.h
-    DESTINATION include/gr-air-modes
+    preamble.h
+    slicer.h
+    types.h
+    api.h
+    uplink.h
+    DESTINATION include/gr_air_modes
 )

include/gr_air_modes/preamble.h

@@ -0,0 +1,51 @@
+/*
+# Copyright 2013 Nick Foster
+# 
+# This file is part of gr-air-modes
+# 
+# gr-air-modes 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.
+# 
+# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+*/
+
+#ifndef INCLUDED_AIR_MODES_PREAMBLE_H
+#define INCLUDED_AIR_MODES_PREAMBLE_H
+
+#include <gnuradio/block.h>
+#include <gr_air_modes/api.h>
+
+namespace gr {
+namespace air_modes {
+
+/*!
+ * \brief mode select preamble detection
+ * \ingroup block
+ */
+class AIR_MODES_API preamble : virtual public gr::block
+{
+public:
+    typedef boost::shared_ptr<preamble> sptr;
+    static sptr make(int channel_rate, float threshold_db);
+
+    virtual void set_rate(int channel_rate) = 0;
+    virtual void set_threshold(float threshold_db) = 0;
+    virtual int get_rate(void) = 0;
+    virtual float get_threshold(void) = 0;
+};
+
+} // namespace air_modes
+} // namespace gr
+
+#endif /* INCLUDED_AIR_MODES_PREAMBLE_H */

include/gr_air_modes/slicer.h

@@ -0,0 +1,47 @@
+/*
+# Copyright 2013 Nick Foster
+# 
+# This file is part of gr-air-modes
+# 
+# gr-air-modes 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.
+# 
+# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+*/
+
+#ifndef INCLUDED_AIR_MODES_SLICER_H
+#define INCLUDED_AIR_MODES_SLICER_H
+
+#include <gnuradio/block.h>
+#include <gr_air_modes/api.h>
+#include <gnuradio/msg_queue.h>
+
+namespace gr {
+namespace air_modes {
+
+/*!
+ * \brief mode select slicer
+ * \ingroup block
+ */
+class AIR_MODES_API slicer : virtual public gr::sync_block
+{
+public:
+    typedef boost::shared_ptr<slicer> sptr;
+    static sptr make(gr::msg_queue::sptr queue);
+};
+
+} //namespace air_modes
+} //namespace gr
+
+#endif /* INCLUDED_AIR_MODES_SLICER_H */

include/gr_air_modes/uplink.h

@@ -0,0 +1,52 @@
+/*
+# Copyright 2013 Nick Foster
+# 
+# This file is part of gr-air-modes
+# 
+# gr-air-modes 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.
+# 
+# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+*/
+
+#ifndef INCLUDED_AIR_MODES_UPLINK_H
+#define INCLUDED_AIR_MODES_UPLINK_H
+
+#include <gnuradio/block.h>
+#include <gr_air_modes/api.h>
+#include <gnuradio/msg_queue.h>
+
+namespace gr {
+namespace air_modes {
+
+/*!
+ * \brief mode select preamble detection
+ * \ingroup block
+ */
+class AIR_MODES_API uplink : virtual public gr::block
+{
+public:
+    typedef boost::shared_ptr<uplink> sptr;
+    static sptr make(int channel_rate, float threshold_db, gr::msg_queue::sptr queue);
+
+    virtual void set_rate(int channel_rate) = 0;
+    virtual void set_threshold(float threshold_db) = 0;
+    virtual int get_rate(void) = 0;
+    virtual float get_threshold(void) = 0;
+};
+
+} // namespace air_modes
+} // namespace gr
+
+#endif /* INCLUDED_AIR_MODES_UPLINK_H */

lib/CMakeLists.txt

@@ -23,9 +23,10 @@
 include(GrPlatform) #define LIB_SUFFIX
 
 add_library(air_modes SHARED
-    air_modes_preamble.cc
-    air_modes_slicer.cc
+    preamble_impl.cc
+    slicer_impl.cc
     modes_crc.cc
+    uplink_impl.cc
 )
 target_link_libraries(air_modes ${Boost_LIBRARIES} ${GNURADIO_RUNTIME_LIBRARIES})
 set_target_properties(air_modes PROPERTIES DEFINE_SYMBOL "AIR_MODES_EXPORTS")

lib/air_modes_int_and_dump.cc

@@ -1,89 +0,0 @@
-/*
-# Copyright 2010 Nick Foster
-# 
-# This file is part of gr-air-modes
-# 
-# gr-air-modes 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.
-# 
-# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-# 
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <air_modes_int_and_dump.h>
-#include <gr_io_signature.h>
-#include <string.h>
-#include <iostream>
-
-air_modes_int_and_dump_sptr air_make_modes_int_and_dump(int samples_per_symbol)
-{
-	return air_modes_int_and_dump_sptr (new air_modes_int_and_dump(samples_per_symbol));
-}
-
-air_modes_int_and_dump::air_modes_int_and_dump(int samps_per_chip) :
-    gr_block ("modes_int_and_dump",
-                   gr_make_io_signature (1, 1, sizeof(float)),
-                   gr_make_io_signature (1, 1, sizeof(float)))
-{
-    d_samples_per_symbol = samples_per_symbol;
-	set_output_multiple(d_samples_per_symbol);
-    set_history(d_samples_per_symbol);
-    
-    d_acc = 0;
-    d_pos = 0;
-}
-
-int air_modes_int_and_dump::general_work(int noutput_items,
-                          gr_vector_int &ninput_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];
-
-    int input_items = std::min(ninput_items[0], ninput_items[1]); //just in case
-
-    //ok first of all we look for "preamble_found" tags in our input range.
-    //get a vector of these tags, then every time we hit one
-    //reset the integrator position and accumulator
-    std::vector<pmt::pmt_t> tags;
-	uint64_t abs_sample_cnt = nitems_read(0);
-	get_tags_in_range(tags, 0, abs_sample_cnt, abs_sample_cnt + ninput_items, pmt::pmt_string_to_symbol("preamble_found"));
-
-    int out_items = 0;
-
-    int offset = gr_tags::get_nitems(&tags[0]) - abs_sample_cnt;
-
-    for(int i=0; i<120*2; i++) { //for each symbol in a potential long packet
-        out[out_items] = 0;
-        for(int j=0; j<d_samples_per_symbol; j++) { //for each sample in the symbol
-            out[out_items] += in[offset+i+j]; //integrate
-        }
-        out_items++;
-    }
-
-    //insert tag here
-    add_item_tag(0, //stream ID
-                 nitems_written(0), //sample number
-                 pmt::pmt_string_to_symbol("preamble_found");
-                 pmt::PMT_T,
-                 pmt::pmt_string_to_symbol(unique_id());
-                );
-
-    consume_each(wat);
-    return out_items;
-}

lib/air_modes_preamble.cc

@@ -1,216 +0,0 @@
-/*
-# Copyright 2010 Nick Foster
-# Copyright 2013 Nicholas Corgan
-# 
-# This file is part of gr-air-modes
-# 
-# gr-air-modes 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.
-# 
-# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-# 
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <ciso646>
-#include <air_modes_preamble.h>
-#include <gnuradio/io_signature.h>
-#include <string.h>
-#include <iostream>
-#include <gnuradio/tags.h>
-
-air_modes_preamble_sptr air_make_modes_preamble(int channel_rate, float threshold_db)
-{
-	return air_modes_preamble_sptr (new air_modes_preamble(channel_rate, threshold_db));
-}
-
-air_modes_preamble::air_modes_preamble(int channel_rate, float threshold_db) :
-        gr::block ("modes_preamble",
-	       gr::io_signature::make2 (2, 2, sizeof(float), sizeof(float)), //stream 0 is received data, stream 1 is moving average for reference
-	       gr::io_signature::make (1, 1, sizeof(float))) //the output packets
-{
-	d_chip_rate = 2000000; //2Mchips per second
-	d_samples_per_chip = channel_rate / d_chip_rate; //must be integer number of samples per chip to work
-	d_samples_per_symbol = d_samples_per_chip * 2;
-	d_check_width = 120 * d_samples_per_symbol; //only search to this far from the end of the stream buffer
-	d_threshold_db = threshold_db;
-	d_threshold = powf(10., threshold_db/20.); //the level that the sample must be above the moving average in order to qualify as a pulse
-	d_secs_per_sample = 1.0 / channel_rate;
-	set_output_multiple(1+d_check_width*2);
-	
-	std::stringstream str;
-	str << name() << unique_id();
-	d_me = pmt::string_to_symbol(str.str());
-	d_key = pmt::string_to_symbol("preamble_found");
-	set_history(d_samples_per_symbol);
-}
-
-static void integrate_and_dump(float *out, const float *in, int chips, int samps_per_chip) {
-	for(int i=0; i<chips; i++) {
-		float acc = 0;
-		for(int j=0; j<samps_per_chip; j++) {
-			acc += in[i*samps_per_chip+j];
-		}
-		out[i] = acc;
-	}
-}
-
-//the preamble pattern in bits
-//fixme goes in .h
-static const bool preamble_bits[] = {1, 0, 1, 0, 0, 0, 0, 1, 0, 1};
-static double correlate_preamble(const float *in, int samples_per_chip) {
-	double corr = 0.0;
-	for(int i=0; i<10; i++) {
-		for(int j=0; j<samples_per_chip;j++)
-			if(preamble_bits[i]) corr += in[i*samples_per_chip+j];
-	}
-	return corr;
-}
-
-//todo: make it return a pair of some kind, otherwise you can lose precision
-static double tag_to_timestamp(gr::tag_t tstamp, uint64_t abs_sample_cnt, double secs_per_sample) {
-	uint64_t ts_sample, last_whole_stamp;
-	double last_frac_stamp;
-
-	if(tstamp.key == NULL || pmt::symbol_to_string(tstamp.key) != "rx_time") return 0;
-
-	last_whole_stamp = pmt::to_uint64(pmt::tuple_ref(tstamp.value, 0));
-	last_frac_stamp = pmt::to_double(pmt::tuple_ref(tstamp.value, 1));
-	ts_sample = tstamp.offset;
-	
-	double tstime = double(abs_sample_cnt * secs_per_sample) + last_whole_stamp + last_frac_stamp;
-	if(0) std::cout << "HEY WE GOT A STAMP AT " << tstime << " TICKS AT SAMPLE " << ts_sample << " ABS SAMPLE CNT IS " << abs_sample_cnt << std::endl;
-	return tstime;
-}
-
-int air_modes_preamble::general_work(int noutput_items,
-						  gr_vector_int &ninput_items,
-                          gr_vector_const_void_star &input_items,
-		                  gr_vector_void_star &output_items)
-{
-	const float *in = (const float *) input_items[0];
-	const float *inavg = (const float *) input_items[1];
-
-	int mininputs = std::min(ninput_items[0], ninput_items[1]); //they should be matched but let's be safe
-	//round number of input samples down to nearest d_samples_per_chip
-	//we also subtract off d_samples_per_chip to allow the bit center finder some leeway
-	const int ninputs = std::max(mininputs - (mininputs % d_samples_per_chip) - d_samples_per_chip, 0);
-	if (ninputs <= 0) { consume_each(0); return 0; }
-	
-	float *out = (float *) output_items[0];
-
-	if(0) std::cout << "Preamble called with " << ninputs << " samples" << std::endl;
-
-	//fixme move into .h
-	const int pulse_offsets[4] = {    0,
-	                              int(2 * d_samples_per_chip),
-	                              int(7 * d_samples_per_chip),
-	                              int(9 * d_samples_per_chip)
-	                             };
-
-	uint64_t abs_sample_cnt = nitems_read(0);
-	std::vector<gr::tag_t> tstamp_tags;
-	get_tags_in_range(tstamp_tags, 0, abs_sample_cnt, abs_sample_cnt + ninputs, pmt::string_to_symbol("rx_time"));
-	//tags.back() is the most recent timestamp, then.
-	if(tstamp_tags.size() > 0) {
-		d_timestamp = tstamp_tags.back();
-	}
-	
-	for(int i=0; i < ninputs; i++) {
-		float pulse_threshold = inavg[i] * d_threshold;
-		if(in[i] > pulse_threshold) { //hey we got a candidate
-			if(in[i+1] > in[i]) continue; //wait for the peak
-			//check to see the rest of the pulses are there
-			if( in[i+pulse_offsets[1]] < pulse_threshold ) continue;
-			if( in[i+pulse_offsets[2]] < pulse_threshold ) continue;
-			if( in[i+pulse_offsets[3]] < pulse_threshold ) continue;
-
-			//get a more accurate bit center by finding the correlation peak across all four preamble bits
-			bool late, early;
-			int how_late = 0;
-			do {
-				double now_corr = correlate_preamble(in+i, d_samples_per_chip);
-				double late_corr = correlate_preamble(in+i+1, d_samples_per_chip);
-				double early_corr = correlate_preamble(in+i-1, d_samples_per_chip);
-				late = (late_corr > now_corr);
-				//early = (early_corr > now_corr);
-				if(late) { i++; how_late++; }
-				//if(early && i>0) { std::cout << "EARLY " << i << std::endl; i--; }
-			} while(late and how_late < d_samples_per_chip);// xor early);
-
-			if(0) std::cout << "We were " << how_late << " samples late" << std::endl;
-
-			//now check to see that the non-peak symbols in the preamble
-			//are below the peaks by threshold dB
-			float avgpeak = ( in[i+pulse_offsets[0]]
-			                + in[i+pulse_offsets[1]]
-			                + in[i+pulse_offsets[2]]
-			                + in[i+pulse_offsets[3]]) / 4.0;
-
-			float space_threshold = inavg[i] + (avgpeak - inavg[i])/d_threshold;
-			bool valid_preamble = true; //f'in c++
-			for( int j=1.5*d_samples_per_symbol; j<=3*d_samples_per_symbol; j++)
-				if(in[i+j] > space_threshold) valid_preamble = false;
-			for( int j=5*d_samples_per_symbol; j<=7.5*d_samples_per_symbol; j++)
-				if(in[i+j] > space_threshold) valid_preamble = false;
-			if(!valid_preamble) continue;
-
-			//be sure we've got enough room in the input buffer to copy out a whole packet
-			if(ninputs-i < 240*d_samples_per_chip) {
-				consume_each(std::max(i-1,0));
-				if(0) std::cout << "Preamble consumed " << std::max(i-1,0) << ", returned 0 (no room)" << std::endl;
-				return 0;
-			}
-
-			//all right i'm prepared to call this a preamble			
-			//let's integrate and dump the output
-			//FIXME: disable and use center sample
-			bool life_sucks = true;
-			if(life_sucks) {
-				for(int j=0; j<240; j++) {
-					out[j] = in[i+j*d_samples_per_chip];
-				}
-			} else {
-				i -= d_samples_per_chip-1;
-				integrate_and_dump(out, &in[i], 240, d_samples_per_chip);
-			}
-
-			//get the timestamp of the preamble
-			double tstamp = tag_to_timestamp(d_timestamp, abs_sample_cnt + i, d_secs_per_sample);
-
-			//now tag the preamble
-			add_item_tag(0, //stream ID
-					 nitems_written(0), //sample
-					 d_key,      //frame_info
-			         pmt::from_double(tstamp),
-			         d_me        //block src id
-			        );
-					 
-			//std::cout << "PREAMBLE" << std::endl;
-			
-			//produce only one output per work call -- TODO this should probably change
-			if(0) std::cout << "Preamble consumed " << i+240*d_samples_per_chip << "with i=" << i << ", returned 240" << std::endl;
-
-			consume_each(i+240*d_samples_per_chip);
-			return 240;
-		}
-	}
-	
-	//didn't get anything this time
-	if(0) std::cout << "Preamble consumed " << ninputs << ", returned 0" << std::endl;
-	consume_each(ninputs);
-	return 0;
-}

lib/air_modes_slicer.cc

@@ -1,197 +0,0 @@
-/*
-# Copyright 2010 Nick Foster
-# Copyright 2013 Nicholas Corgan
-# 
-# This file is part of gr-air-modes
-# 
-# gr-air-modes 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.
-# 
-# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-# 
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <ciso646>
-#include <air_modes_slicer.h>
-#include <gnuradio/io_signature.h>
-#include <air_modes_types.h>
-#include <sstream>
-#include <iomanip>
-#include <modes_crc.h>
-#include <iostream>
-#include <gnuradio/tags.h>
-
-extern "C"
-{
-#include <stdio.h>
-#include <string.h>
-}
-
-air_modes_slicer_sptr air_make_modes_slicer(int channel_rate, gr::msg_queue::sptr queue)
-{
-	return air_modes_slicer_sptr (new air_modes_slicer(channel_rate, queue));
-}
-
-air_modes_slicer::air_modes_slicer(int channel_rate, gr::msg_queue::sptr queue) :
-  gr::sync_block ("modes_slicer",
-		  gr::io_signature::make (1, 1, sizeof(float)), //stream 0 is received data, stream 1 is binary preamble detector output
-                  gr::io_signature::make (0, 0, 0) )
-{
-	//initialize private data here
-	d_chip_rate = 2000000; //2Mchips per second
-	d_samples_per_chip = 2;//FIXME this is constant now channel_rate / d_chip_rate;
-	d_samples_per_symbol = d_samples_per_chip * 2;
-	d_check_width = 120 * d_samples_per_symbol; //how far you will have to look ahead
-	d_queue = queue;
-
-	set_output_multiple(d_check_width*2); //how do you specify buffer size for sinks?
-}
-
-//this slicer is courtesy of Lincoln Labs. supposedly it is more resistant to mode A/C FRUIT.
-//see http://adsb.tc.faa.gov/WG3_Meetings/Meeting8/Squitter-Lon.pdf
-static slice_result_t slicer(const float bit0, const float bit1, const float ref) {
-	slice_result_t result;
-
-	//3dB limits for bit slicing and confidence measurement
-	float highlimit=ref*1.414;
-	float lowlimit=ref*0.707;
-	
-	bool firstchip_inref  = ((bit0 > lowlimit) && (bit0 < highlimit));
-	bool secondchip_inref = ((bit1 > lowlimit) && (bit1 < highlimit));
-
-	if(firstchip_inref && !secondchip_inref) {
-		result.decision = 1;
-		result.confidence = 1;
-	}
-	else if(secondchip_inref && !firstchip_inref) {
-		result.decision = 0;
-		result.confidence = 1;
-	} 
-	else if(firstchip_inref && secondchip_inref) {
-		result.decision = bit0 > bit1;
-		result.confidence = 0;
-	}
-	else {//if(!firstchip_inref && !secondchip_inref) {
-		result.decision = bit0 > bit1;
-		if(result.decision) {
-			if(bit1 < lowlimit * 0.5) result.confidence = 1;
-			else result.confidence = 0;
-		} else {
-			if(bit0 < lowlimit * 0.5) result.confidence = 1;
-			else result.confidence = 0;
-		}
-	}
-	return result;
-}
-
-int air_modes_slicer::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];
-	int size = noutput_items - d_check_width; //since it's a sync block, i assume that it runs with ninput_items = noutput_items
-
-	if(0) std::cout << "Slicer called with " << size << " samples" << std::endl;
-	
-	std::vector<gr::tag_t> tags;
-	uint64_t abs_sample_cnt = nitems_read(0);
-	get_tags_in_range(tags, 0, abs_sample_cnt, abs_sample_cnt + size, pmt::string_to_symbol("preamble_found"));
-	std::vector<gr::tag_t>::iterator tag_iter;
-
-	for(tag_iter = tags.begin(); tag_iter != tags.end(); tag_iter++) {
-		uint64_t i = tag_iter->offset - abs_sample_cnt;
-		modes_packet rx_packet;
-
-		memset(&rx_packet.data, 0x00, 14 * sizeof(unsigned char));
-		memset(&rx_packet.lowconfbits, 0x00, 24 * sizeof(unsigned char));
-		rx_packet.numlowconf = 0;
-
-		//let's use the preamble to get a reference level for the packet
-		//fixme: a better thing to do is create a bi-level avg 1 and avg 0
-		//through simple statistics, then take the median for your slice level
-		//this won't improve decoding but will improve confidence
-		rx_packet.reference_level = (in[i]
-								   + in[i+2]
-								   + in[i+7]
-								   + in[i+9]) / 4.0;
-
-		i += 16; //move on up to the first bit of the packet data
-		//now let's slice the header so we can determine if it's a short pkt or a long pkt
-		unsigned char pkt_hdr = 0;
-		for(int j=0; j < 5; j++) {
-			slice_result_t slice_result = slicer(in[i+j*2], in[i+j*2+1], rx_packet.reference_level);
-			if(slice_result.decision) pkt_hdr += 1 << (4-j);
-		}
-		if(pkt_hdr == 16 or pkt_hdr == 17 or pkt_hdr == 20 or pkt_hdr == 21) rx_packet.type = Long_Packet;
-		else rx_packet.type = Short_Packet;
-		int packet_length = (rx_packet.type == framer_packet_type(Short_Packet)) ? 56 : 112;
-
-		//it's slice time!
-		//TODO: don't repeat your work here, you already have the first 5 bits
-		for(int j = 0; j < packet_length; j++) {
-			slice_result_t slice_result = slicer(in[i+j*2], in[i+j*2+1], rx_packet.reference_level);
-
-			//put the data into the packet
-			if(slice_result.decision) {
-				rx_packet.data[j/8] += 1 << (7-(j%8));
-			}
-			//put the confidence decision into the packet
-			if(slice_result.confidence) {
-				//rx_packet.confidence[j/8] += 1 << (7-(j%8));
-			} else {
-				if(rx_packet.numlowconf < 24) rx_packet.lowconfbits[rx_packet.numlowconf++] = j;
-			}
-		}
-			
-		/******************** BEGIN TIMESTAMP BS ******************/
-		rx_packet.timestamp = pmt::to_double(tag_iter->value);
-		/******************* END TIMESTAMP BS *********************/
-			
-		//increment for the next round
-
-		//here you might want to traverse the whole packet and if you find all 0's, just toss it. don't know why these packets turn up, but they pass ECC.
-		bool zeroes = 1;
-		for(int m = 0; m < 14; m++) {
-			if(rx_packet.data[m]) zeroes = 0;
-		}
-		if(zeroes) {continue;} //toss it
-
-		rx_packet.message_type = (rx_packet.data[0] >> 3) & 0x1F; //get the message type to make decisions on ECC methods
-
-		if(rx_packet.type == Short_Packet && rx_packet.message_type != 11 && rx_packet.numlowconf > 0) {continue;}
-		if(rx_packet.message_type == 11 && rx_packet.numlowconf >= 10) {continue;}
-			
-		rx_packet.crc = modes_check_crc(rx_packet.data, packet_length);
-
-		//crc for packets that aren't type 11 or type 17 is encoded with the transponder ID, which we don't know
-		//therefore we toss 'em if there's syndrome
-		//crc for the other short packets is usually nonzero, so they can't really be trusted that far
-		if(rx_packet.crc && (rx_packet.message_type == 11 || rx_packet.message_type == 17)) {continue;}
-
-		d_payload.str("");
-		for(int m = 0; m < packet_length/8; m++) {
-			d_payload << std::hex << std::setw(2) << std::setfill('0') << unsigned(rx_packet.data[m]);
-		}
-
-		d_payload << " " << std::setw(6) << rx_packet.crc << " " << std::dec << rx_packet.reference_level
-		          << " " << std::setprecision(10) << std::setw(10) << rx_packet.timestamp;
-		gr::message::sptr msg = gr::message::make_from_string(std::string(d_payload.str()));
-		d_queue->handle(msg);
-	}
-	if(0) std::cout << "Slicer consumed " << size << ", returned " << size << std::endl;
-	return size;
-}

lib/modes_crc.cc

@@ -26,8 +26,8 @@
 #endif
 
 #include <stdio.h>
-#include <air_modes_types.h>
-#include <modes_crc.h>
+#include <gr_air_modes/types.h>
+#include <gr_air_modes/modes_crc.h>
 #include <math.h>
 #include <stdlib.h>
 

lib/preamble_impl.cc

@@ -0,0 +1,227 @@
+/*
+# Copyright 2010 Nick Foster
+# Copyright 2013 Nicholas Corgan
+# 
+# This file is part of gr-air-modes
+# 
+# gr-air-modes 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.
+# 
+# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <ciso646>
+#include "preamble_impl.h"
+#include <gnuradio/io_signature.h>
+#include <string.h>
+#include <iostream>
+#include <gnuradio/tags.h>
+
+namespace gr {
+
+air_modes::preamble::sptr air_modes::preamble::make(int channel_rate, float threshold_db) {
+    return gnuradio::get_initial_sptr(new air_modes::preamble_impl(channel_rate, threshold_db));
+}
+
+air_modes::preamble_impl::preamble_impl(int channel_rate, float threshold_db) :
+        gr::block ("preamble",
+           gr::io_signature::make2 (2, 2, sizeof(float), sizeof(float)), //stream 0 is received data, stream 1 is moving average for reference
+           gr::io_signature::make (1, 1, sizeof(float))) //the output soft symbols
+{
+    d_chip_rate = 2000000; //2Mchips per second
+    set_rate(channel_rate);
+    set_threshold(threshold_db);
+
+    std::stringstream str;
+    str << name() << unique_id();
+    d_me = pmt::string_to_symbol(str.str());
+    d_key = pmt::string_to_symbol("preamble_found");
+}
+
+void air_modes::preamble_impl::set_rate(int channel_rate) {
+    d_samples_per_chip = channel_rate / d_chip_rate;
+    d_samples_per_symbol = d_samples_per_chip * 2;
+    d_check_width = 120 * d_samples_per_symbol;
+    d_secs_per_sample = 1.0/channel_rate;
+    set_output_multiple(1+d_check_width*2);
+    set_history(d_samples_per_symbol);
+}
+
+void air_modes::preamble_impl::set_threshold(float threshold_db) {
+    d_threshold_db = threshold_db;
+    d_threshold = powf(10., threshold_db/20.); //the level that the sample must be above the moving average in order to qualify as a pulse
+}
+
+float air_modes::preamble_impl::get_threshold(void) {
+    return d_threshold_db;
+}
+
+int air_modes::preamble_impl::get_rate(void) {
+    return d_samples_per_chip * d_chip_rate;
+}
+
+static void integrate_and_dump(float *out, const float *in, int chips, int samps_per_chip) {
+    for(int i=0; i<chips; i++) {
+        float acc = 0;
+        for(int j=0; j<samps_per_chip; j++) {
+            acc += in[i*samps_per_chip+j];
+        }
+        out[i] = acc;
+    }
+}
+
+//the preamble pattern in bits
+//fixme goes in .h
+static const bool preamble_bits[] = {1, 0, 1, 0, 0, 0, 0, 1, 0, 1};
+static double correlate_preamble(const float *in, int samples_per_chip) {
+    double corr = 0.0;
+    for(int i=0; i<10; i++) {
+        for(int j=0; j<samples_per_chip;j++)
+            if(preamble_bits[i]) corr += in[i*samples_per_chip+j];
+    }
+    return corr;
+}
+
+//todo: make it return a pair of some kind, otherwise you can lose precision
+static double tag_to_timestamp(gr::tag_t tstamp, uint64_t abs_sample_cnt, double secs_per_sample) {
+    uint64_t ts_sample, last_whole_stamp;
+    double last_frac_stamp;
+
+    if(tstamp.key == NULL || pmt::symbol_to_string(tstamp.key) != "rx_time") return 0;
+
+    last_whole_stamp = pmt::to_uint64(pmt::tuple_ref(tstamp.value, 0));
+    last_frac_stamp = pmt::to_double(pmt::tuple_ref(tstamp.value, 1));
+    ts_sample = tstamp.offset;
+
+    double tstime = double(abs_sample_cnt * secs_per_sample) + last_whole_stamp + last_frac_stamp;
+    if(0) std::cout << "HEY WE GOT A STAMP AT " << tstime << " TICKS AT SAMPLE " << ts_sample << " ABS SAMPLE CNT IS " << abs_sample_cnt << std::endl;
+    return tstime;
+}
+
+int air_modes::preamble_impl::general_work(int noutput_items,
+                          gr_vector_int &ninput_items,
+                          gr_vector_const_void_star &input_items,
+                          gr_vector_void_star &output_items)
+{
+    const float *in = (const float *) input_items[0];
+    const float *inavg = (const float *) input_items[1];
+
+    int mininputs = std::min(ninput_items[0], ninput_items[1]); //they should be matched but let's be safe
+    //round number of input samples down to nearest d_samples_per_chip
+    //we also subtract off d_samples_per_chip to allow the bit center finder some leeway
+    const int ninputs = std::max(mininputs - (mininputs % d_samples_per_chip) - d_samples_per_chip, 0);
+    if (ninputs <= 0) { consume_each(0); return 0; }
+
+    float *out = (float *) output_items[0];
+
+    if(0) std::cout << "Preamble called with " << ninputs << " samples" << std::endl;
+
+    //fixme move into .h
+    const int pulse_offsets[4] = {    0,
+                                  int(2 * d_samples_per_chip),
+                                  int(7 * d_samples_per_chip),
+                                  int(9 * d_samples_per_chip)
+                                 };
+
+    uint64_t abs_sample_cnt = nitems_read(0);
+    std::vector<gr::tag_t> tstamp_tags;
+    get_tags_in_range(tstamp_tags, 0, abs_sample_cnt, abs_sample_cnt + ninputs, pmt::string_to_symbol("rx_time"));
+    //tags.back() is the most recent timestamp, then.
+    if(tstamp_tags.size() > 0) {
+        d_timestamp = tstamp_tags.back();
+    }
+
+    for(int i=0; i < ninputs; i++) {
+        float pulse_threshold = inavg[i] * d_threshold;
+        if(in[i] > pulse_threshold) { //hey we got a candidate
+            if(in[i+1] > in[i]) continue; //wait for the peak
+            //check to see the rest of the pulses are there
+            if( in[i+pulse_offsets[1]] < pulse_threshold ) continue;
+            if( in[i+pulse_offsets[2]] < pulse_threshold ) continue;
+            if( in[i+pulse_offsets[3]] < pulse_threshold ) continue;
+
+            //get a more accurate bit center by finding the correlation peak across all four preamble bits
+            bool late, early;
+            int how_late = 0;
+            do {
+                double now_corr = correlate_preamble(in+i, d_samples_per_chip);
+                double late_corr = correlate_preamble(in+i+1, d_samples_per_chip);
+                double early_corr = correlate_preamble(in+i-1, d_samples_per_chip);
+                late = (late_corr > now_corr);
+                //early = (early_corr > now_corr);
+                if(late) { i++; how_late++; }
+                //if(early && i>0) { std::cout << "EARLY " << i << std::endl; i--; }
+            } while(late and how_late < d_samples_per_chip);// xor early);
+
+            if(0) std::cout << "We were " << how_late << " samples late" << std::endl;
+
+            //now check to see that the non-peak symbols in the preamble
+            //are below the peaks by threshold dB
+            float avgpeak = ( in[i+pulse_offsets[0]]
+                            + in[i+pulse_offsets[1]]
+                            + in[i+pulse_offsets[2]]
+                            + in[i+pulse_offsets[3]]) / 4.0;
+
+            float space_threshold = inavg[i] + (avgpeak - inavg[i])/d_threshold;
+            bool valid_preamble = true; //f'in c++
+            for( int j=1.5*d_samples_per_symbol; j<=3*d_samples_per_symbol; j++)
+                if(in[i+j] > space_threshold) valid_preamble = false;
+            for( int j=5*d_samples_per_symbol; j<=7.5*d_samples_per_symbol; j++)
+                if(in[i+j] > space_threshold) valid_preamble = false;
+            if(!valid_preamble) continue;
+
+            //be sure we've got enough room in the input buffer to copy out a whole packet
+            if(ninputs-i < 240*d_samples_per_chip) {
+                consume_each(std::max(i-1,0));
+                if(0) std::cout << "Preamble consumed " << std::max(i-1,0) << ", returned 0 (no room)" << std::endl;
+                return 0;
+            }
+
+            //all right i'm prepared to call this a preamble
+            for(int j=0; j<240; j++) {
+                out[j] = in[i+j*d_samples_per_chip] - inavg[i];
+            }
+
+            //get the timestamp of the preamble
+            double tstamp = tag_to_timestamp(d_timestamp, abs_sample_cnt + i, d_secs_per_sample);
+
+            //now tag the preamble
+            add_item_tag(0, //stream ID
+                     nitems_written(0), //sample
+                     d_key,      //frame_info
+                     pmt::from_double(tstamp),
+                     d_me        //block src id
+                    );
+
+            //std::cout << "PREAMBLE" << std::endl;
+
+            //produce only one output per work call -- TODO this should probably change
+            if(0) std::cout << "Preamble consumed " << i+240*d_samples_per_chip << "with i=" << i << ", returned 240" << std::endl;
+
+            consume_each(i+240*d_samples_per_chip);
+            return 240;
+        }
+    }
+
+    //didn't get anything this time
+    if(0) std::cout << "Preamble consumed " << ninputs << ", returned 0" << std::endl;
+    consume_each(ninputs);
+    return 0;
+}
+
+} //namespace gr

lib/preamble_impl.h

@@ -0,0 +1,43 @@
+
+#ifndef _AIR_MODES_PREAMBLE_IMPL_H_
+#define _AIR_MODES_PREAMBLE_IMPL_H_
+
+#include <gnuradio/block.h>
+#include <gr_air_modes/api.h>
+#include <gr_air_modes/preamble.h>
+
+namespace gr {
+namespace air_modes {
+
+class AIR_MODES_API preamble_impl : public preamble
+{
+private:
+    int d_check_width;
+    int d_chip_rate;
+    float d_preamble_length_us;
+    int d_samples_per_chip;
+    int d_samples_per_symbol;
+    float d_threshold_db;
+    float d_threshold;
+    pmt::pmt_t d_me, d_key;
+    gr::tag_t d_timestamp;
+    double d_secs_per_sample;
+
+public:
+    preamble_impl(int channel_rate, float threshold_db);
+
+    int general_work (int noutput_items,
+              gr_vector_int &ninput_items,
+              gr_vector_const_void_star &input_items,
+              gr_vector_void_star &output_items);
+
+    void set_rate(int channel_rate);
+    void set_threshold(float threshold_db);
+    float get_threshold(void);
+    int get_rate(void);
+};
+
+} //namespace air_modes
+} //namespace gr
+
+#endif //_AIR_MODES_PREAMBLE_IMPL_H_

lib/slicer_impl.cc

@@ -0,0 +1,196 @@
+/*
+# Copyright 2010 Nick Foster
+# Copyright 2013 Nicholas Corgan
+# 
+# This file is part of gr-air-modes
+# 
+# gr-air-modes 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.
+# 
+# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <ciso646>
+#include "slicer_impl.h"
+#include <gnuradio/io_signature.h>
+#include <gr_air_modes/types.h>
+#include <sstream>
+#include <iomanip>
+#include <gr_air_modes/modes_crc.h>
+#include <iostream>
+#include <gnuradio/tags.h>
+
+extern "C"
+{
+#include <stdio.h>
+#include <string.h>
+}
+
+namespace gr {
+
+air_modes::slicer::sptr air_modes::slicer::make(gr::msg_queue::sptr queue) {
+    return gnuradio::get_initial_sptr(new air_modes::slicer_impl(queue));
+}
+
+air_modes::slicer_impl::slicer_impl(gr::msg_queue::sptr queue) :
+  gr::sync_block ("slicer",
+                  gr::io_signature::make (1, 1, sizeof(float)),
+                  gr::io_signature::make (0, 0, 0) )
+{
+    //initialize private data here
+    d_chip_rate = 2000000; //2Mchips per second
+    d_samples_per_chip = 2;//FIXME this is constant now channel_rate / d_chip_rate;
+    d_samples_per_symbol = d_samples_per_chip * 2;
+    d_check_width = 120 * d_samples_per_symbol; //how far you will have to look ahead
+    d_queue = queue;
+
+    set_output_multiple(d_check_width*2); //how do you specify buffer size for sinks?
+}
+
+//this slicer is courtesy of Lincoln Labs. supposedly it is more resistant to mode A/C FRUIT.
+//see http://adsb.tc.faa.gov/WG3_Meetings/Meeting8/Squitter-Lon.pdf
+static slice_result_t llslicer(const float bit0, const float bit1, const float ref) {
+    slice_result_t result;
+
+    //3dB limits for bit slicing and confidence measurement
+    float highlimit=ref*1.414;
+    float lowlimit=ref*0.707;
+
+    bool firstchip_inref  = ((bit0 > lowlimit) && (bit0 < highlimit));
+    bool secondchip_inref = ((bit1 > lowlimit) && (bit1 < highlimit));
+
+    if(firstchip_inref && !secondchip_inref) {
+        result.decision = 1;
+        result.confidence = 1;
+    }
+    else if(secondchip_inref && !firstchip_inref) {
+        result.decision = 0;
+        result.confidence = 1;
+    } 
+    else if(firstchip_inref && secondchip_inref) {
+        result.decision = bit0 > bit1;
+        result.confidence = 0;
+    }
+    else {//if(!firstchip_inref && !secondchip_inref) {
+        result.decision = bit0 > bit1;
+        if(result.decision) {
+            if(bit1 < lowlimit * 0.5) result.confidence = 1;
+            else result.confidence = 0;
+        } else {
+            if(bit0 < lowlimit * 0.5) result.confidence = 1;
+            else result.confidence = 0;
+        }
+    }
+    return result;
+}
+
+int air_modes::slicer_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];
+    int size = noutput_items - d_check_width; //since it's a sync block, i assume that it runs with ninput_items = noutput_items
+
+    if(0) std::cout << "Slicer called with " << size << " samples" << std::endl;
+
+    std::vector<gr::tag_t> tags;
+    uint64_t abs_sample_cnt = nitems_read(0);
+    get_tags_in_range(tags, 0, abs_sample_cnt, abs_sample_cnt + size, pmt::string_to_symbol("preamble_found"));
+    std::vector<gr::tag_t>::iterator tag_iter;
+
+    for(tag_iter = tags.begin(); tag_iter != tags.end(); tag_iter++) {
+        uint64_t i = tag_iter->offset - abs_sample_cnt;
+        modes_packet rx_packet;
+
+        memset(&rx_packet.data, 0x00, 14 * sizeof(unsigned char));
+        memset(&rx_packet.lowconfbits, 0x00, 24 * sizeof(unsigned char));
+        rx_packet.numlowconf = 0;
+
+        //let's use the preamble to get a reference level for the packet
+        //fixme: a better thing to do is create a bi-level avg 1 and avg 0
+        //through simple statistics, then take the median for your slice level
+        //this won't improve decoding but will improve confidence
+        rx_packet.reference_level = (in[i]
+                                   + in[i+2]
+                                   + in[i+7]
+                                   + in[i+9]) / 4.0;
+
+        i += 16; //move on up to the first bit of the packet data
+        //now let's slice the header so we can determine if it's a short pkt or a long pkt
+        unsigned char pkt_hdr = 0;
+        for(int j=0; j < 5; j++) {
+            slice_result_t slice_result = llslicer(in[i+j*2], in[i+j*2+1], rx_packet.reference_level);
+            if(slice_result.decision) pkt_hdr += 1 << (4-j);
+        }
+        if(pkt_hdr == 16 or pkt_hdr == 17 or pkt_hdr == 20 or pkt_hdr == 21) rx_packet.type = Long_Packet;
+        else rx_packet.type = Short_Packet;
+        int packet_length = (rx_packet.type == framer_packet_type(Short_Packet)) ? 56 : 112;
+
+        //it's slice time!
+        //TODO: don't repeat your work here, you already have the first 5 bits
+        for(int j = 0; j < packet_length; j++) {
+            slice_result_t slice_result = llslicer(in[i+j*2], in[i+j*2+1], rx_packet.reference_level);
+
+            //put the data into the packet
+            if(slice_result.decision) {
+                rx_packet.data[j/8] += 1 << (7-(j%8));
+            }
+            //put the confidence decision into the packet
+            if(slice_result.confidence) {
+                //rx_packet.confidence[j/8] += 1 << (7-(j%8));
+            } else {
+                if(rx_packet.numlowconf < 24) rx_packet.lowconfbits[rx_packet.numlowconf++] = j;
+            }
+        }
+
+        rx_packet.timestamp = pmt::to_double(tag_iter->value);
+
+        //here you might want to traverse the whole packet and if you find all 0's, just toss it. don't know why these packets turn up, but they pass ECC.
+        bool zeroes = 1;
+        for(int m = 0; m < 14; m++) {
+            if(rx_packet.data[m]) zeroes = 0;
+        }
+        if(zeroes) {continue;} //toss it
+
+        rx_packet.message_type = (rx_packet.data[0] >> 3) & 0x1F; //get the message type to make decisions on ECC methods
+
+        if(rx_packet.type == Short_Packet && rx_packet.message_type != 11 && rx_packet.numlowconf > 0) {continue;}
+        if(rx_packet.message_type == 11 && rx_packet.numlowconf >= 10) {continue;}
+
+        rx_packet.crc = modes_check_crc(rx_packet.data, packet_length);
+
+        //crc for packets that aren't type 11 or type 17 is encoded with the transponder ID, which we don't know
+        //therefore we toss 'em if there's syndrome
+        //crc for the other short packets is usually nonzero, so they can't really be trusted that far
+        if(rx_packet.crc && (rx_packet.message_type == 11 || rx_packet.message_type == 17)) {continue;}
+
+        d_payload.str("");
+        for(int m = 0; m < packet_length/8; m++) {
+            d_payload << std::hex << std::setw(2) << std::setfill('0') << unsigned(rx_packet.data[m]);
+        }
+
+        d_payload << " " << std::setw(6) << rx_packet.crc << " " << std::dec << rx_packet.reference_level
+                  << " " << std::setprecision(10) << std::setw(10) << rx_packet.timestamp;
+        gr::message::sptr msg = gr::message::make_from_string(std::string(d_payload.str()));
+        d_queue->handle(msg);
+    }
+    if(0) std::cout << "Slicer consumed " << size << ", returned " << size << std::endl;
+    return size;
+}
+
+} //namespace gr

lib/slicer_impl.h

@@ -1,5 +1,5 @@
 /*
-# Copyright 2010 Nick Foster
+# Copyright 2013 Nick Foster
 # 
 # This file is part of gr-air-modes
 # 
@@ -20,28 +20,20 @@
 # 
 */
 
-#ifndef INCLUDED_AIR_MODES_slicer_H
-#define INCLUDED_AIR_MODES_slicer_H
+#ifndef INCLUDED_AIR_MODES_SLICER_IMPL_H
+#define INCLUDED_AIR_MODES_SLICER_IMPL_H
 
 #include <gnuradio/sync_block.h>
 #include <gnuradio/msg_queue.h>
-#include <air_modes_api.h>
+#include <gr_air_modes/api.h>
+#include <gr_air_modes/slicer.h>
 
-class air_modes_slicer;
-typedef boost::shared_ptr<air_modes_slicer> air_modes_slicer_sptr;
+namespace gr {
+namespace air_modes {
 
-AIR_MODES_API air_modes_slicer_sptr air_make_modes_slicer(int channel_rate, gr::msg_queue::sptr queue);
-
-/*!
- * \brief mode select slicer detection
- * \ingroup block
- */
-class AIR_MODES_API air_modes_slicer : public gr::sync_block
+class AIR_MODES_API slicer_impl : public slicer
 {
 private:
-    friend air_modes_slicer_sptr air_make_modes_slicer(int channel_rate, gr::msg_queue::sptr queue);
-    air_modes_slicer(int channel_rate, gr::msg_queue::sptr queue);
-
     int d_check_width;
     int d_chip_rate;
     int d_samples_per_chip;
@@ -50,9 +42,14 @@ private:
     std::ostringstream d_payload;
 
 public:
+    slicer_impl(gr::msg_queue::sptr queue);
+
     int work (int noutput_items,
               gr_vector_const_void_star &input_items,
               gr_vector_void_star &output_items);
 };
 
-#endif /* INCLUDED_AIR_MODES_slicer_H */
+} //namespace air_modes
+} //namespace gr
+
+#endif /* INCLUDED_AIR_MODES_SLICER_IMPL_H */

lib/uplink_impl.cc

@@ -0,0 +1,210 @@
+/*
+# Copyright 2013 Nick Foster
+# 
+# This file is part of gr-air-modes
+# 
+# gr-air-modes 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.
+# 
+# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gnuradio/io_signature.h>
+#include <string.h>
+#include <iostream>
+#include <iomanip>
+#include <gnuradio/tags.h>
+#include "uplink_impl.h"
+
+namespace gr {
+
+air_modes::uplink::sptr air_modes::uplink::make(int channel_rate, float threshold_db, gr::msg_queue::sptr queue) {
+    return gnuradio::get_initial_sptr(new air_modes::uplink_impl(channel_rate, threshold_db, queue));
+}
+
+air_modes::uplink_impl::uplink_impl(int channel_rate, float threshold_db, gr::msg_queue::sptr queue) :
+    gr::block ("uplink",
+                   gr::io_signature::make2 (2, 2, sizeof(float), sizeof(float)), //stream 0 is received data, stream 1 is moving average for reference
+                   gr::io_signature::make (1, 1, sizeof(float))) //the output packets
+{
+    d_chip_rate = 4000000;
+    set_rate(channel_rate);
+    set_threshold(threshold_db);
+
+    std::stringstream str;
+    str << name() << unique_id();
+    d_me = pmt::string_to_symbol(str.str());
+    d_key = pmt::string_to_symbol("uplink_found");
+    d_queue = queue;
+}
+
+void air_modes::uplink_impl::set_rate(int channel_rate) {
+    d_samples_per_chip = channel_rate / d_chip_rate;
+    d_samples_per_symbol = d_samples_per_chip * 2;
+    d_check_width = 120 * d_samples_per_symbol;
+    d_secs_per_sample = 1.0/channel_rate;
+    set_output_multiple(1+d_check_width*2);
+    set_history(d_samples_per_symbol);
+}
+
+void air_modes::uplink_impl::set_threshold(float threshold_db) {
+    d_threshold_db = threshold_db;
+    d_threshold = powf(10., threshold_db/20.);
+}
+
+float air_modes::uplink_impl::get_threshold(void) {
+    return d_threshold_db;
+}
+
+int air_modes::uplink_impl::get_rate(void) {
+    return d_samples_per_chip * d_chip_rate;
+}
+
+//todo: make it return a pair of some kind, otherwise you can lose precision
+static double tag_to_timestamp(gr::tag_t tstamp, uint64_t abs_sample_cnt, double secs_per_sample) {
+	uint64_t ts_sample, last_whole_stamp;
+	double last_frac_stamp;
+
+	if(tstamp.key == NULL || pmt::symbol_to_string(tstamp.key) != "rx_time") return 0;
+
+	last_whole_stamp = pmt::to_uint64(pmt::tuple_ref(tstamp.value, 0));
+	last_frac_stamp = pmt::to_double(pmt::tuple_ref(tstamp.value, 1));
+	ts_sample = tstamp.offset;
+	
+	double tstime = double(abs_sample_cnt * secs_per_sample) + last_whole_stamp + last_frac_stamp;
+	if(0) std::cout << "HEY WE GOT A STAMP AT " << tstime << " TICKS AT SAMPLE " << ts_sample << " ABS SAMPLE CNT IS " << abs_sample_cnt << std::endl;
+	return tstime;
+}
+
+//the preamble pattern in bits
+//fixme goes in .h
+//these are in 0.25us increments
+static const int preamble_bits[] = {1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, -1};
+static double correlate_preamble(const float *in, int samples_per_chip) {
+	double corr = 0.0;
+	for(int i=0; i<20; i++) {
+		for(int j=0; j<samples_per_chip;j++)
+			corr += preamble_bits[i]*in[i*samples_per_chip+j];
+	}
+	return corr/(20*samples_per_chip);
+}
+
+int air_modes::uplink_impl::general_work(int noutput_items,
+						  gr_vector_int &ninput_items,
+                          gr_vector_const_void_star &input_items,
+		                  gr_vector_void_star &output_items)
+{
+	const float *in = (const float *) input_items[0];
+	const float *inavg = (const float *) input_items[1];
+
+	int mininputs = std::min(ninput_items[0], ninput_items[1]); //they should be matched but let's be safe
+	//round number of input samples down to nearest d_samples_per_chip
+	//we also subtract off d_samples_per_chip to allow the bit center finder some leeway
+	const int ninputs = std::max(mininputs - (mininputs % d_samples_per_symbol) - d_samples_per_symbol, 0);
+	if (ninputs <= 0) { consume_each(0); return 0; }
+	
+	float *out = (float *) output_items[0];
+
+	if(0) std::cout << "Uplink called with " << ninputs << " samples" << std::endl;
+
+	uint64_t abs_sample_cnt = nitems_read(0);
+	std::vector<gr::tag_t> tstamp_tags;
+	get_tags_in_range(tstamp_tags, 0, abs_sample_cnt, abs_sample_cnt + ninputs, pmt::string_to_symbol("rx_time"));
+	//tags.back() is the most recent timestamp, then.
+	if(tstamp_tags.size() > 0) {
+		d_timestamp = tstamp_tags.back();
+	}
+	
+	for(int i=0; i < ninputs; i++) {
+		float pulse_threshold = inavg[i] * d_threshold;
+		//we're looking for negative pulses, since the sync
+		//phase reversal bit will always be negative.
+		if(in[i] < (0-fabs(pulse_threshold))) { //hey we got a candidate
+			if(0) std::cout << "Pulse threshold " << (0-fabs(pulse_threshold)) << " exceeded by sample at " << in[i] << std::endl;
+
+			while(in[i+1] < in[i] and (ninputs-112*d_samples_per_symbol) > i) i++;
+			bool ugly = false;
+			for(int j=0; j<8*d_samples_per_symbol; j++) {
+				if(in[i+j+d_samples_per_symbol] < fabs(pulse_threshold)) ugly=true;
+			}
+			if(ugly) continue;
+			if(0) std::cout << "Phase reversal sync found at " << i << " with value " << in[i] << std::endl;
+			//now we're at the phase reversal sync bit, and we can start pulling bits out
+			//next bit starts 0.5us later (2 bit periods)
+			float ref_level = 0;
+			for(int j=0; j<d_samples_per_symbol*2; j++) {
+				ref_level += in[i+j];
+			}
+			ref_level /= (d_samples_per_symbol*2);
+			
+			i+=d_samples_per_symbol*2;
+
+
+			//be sure we've got enough room in the input buffer to copy out a whole packet
+			if(ninputs-i < 112*d_samples_per_symbol) {
+				consume_each(std::max(i-1,0));
+				if(0) std::cout << "Uplink consumed " << std::max(i-1,0) << ", returned 0 (no room)" << std::endl;
+				return 0;
+			}
+
+			for(int j=0; j<ninputs; j++) {
+				out[j] = in[j];
+			}
+			out[i] = 1;
+
+			unsigned char bits[14];
+			memset((void *) bits, 0x00, 14);
+			for(int j=0; j<56; j++) {
+				if(in[i+j*d_samples_per_symbol] < 0) bits[j/8] += 1 << (7-(j%8));
+			}
+			if(0) {
+				std::cout << "Data: ";
+				for(int j=0; j<7; j++) {
+					std::cout << std::setw(2) << std::setfill('0') << std::hex << int(bits[j]);
+				}
+				std::cout << std::dec << std::endl;
+			}
+
+			//get the timestamp of the uplink tag
+			double tstamp = tag_to_timestamp(d_timestamp, abs_sample_cnt + i, d_secs_per_sample);
+
+			d_payload.str("");
+			for(int m=0; m<7; m++) {
+				d_payload << std::hex << std::setw(2) << std::setfill('0') << unsigned(bits[m]);
+			}
+
+			d_payload << " " << std::setw(6) << 0 << " " << std::dec << ref_level
+					  << " " << std::setprecision(10) << std::setw(10) << tstamp;
+            gr::message::sptr msg = gr::message::make_from_string(std::string(d_payload.str()));
+			d_queue->handle(msg);
+			
+			//produce only one output per work call -- TODO this should probably change
+			if(0) std::cout << "Uplink consumed " << i+112*d_samples_per_symbol << " with i=" << i << ", returned 112" << std::endl;
+
+			consume_each(ninputs);
+			return ninputs;
+		}
+	}
+	
+	//didn't get anything this time
+	//if(1) std::cout << "Uplink consumed " << ninputs << ", returned 0" << std::endl;
+	consume_each(ninputs);
+	return 0;
+}
+
+} //namespace gr

lib/uplink_impl.h

@@ -0,0 +1,46 @@
+
+#ifndef _AIR_MODES_UPLINK_IMPL_H_
+#define _AIR_MODES_UPLINK_IMPL_H_
+
+#include <gnuradio/block.h>
+#include <gr_air_modes/api.h>
+#include <gr_air_modes/uplink.h>
+#include <gnuradio/msg_queue.h>
+
+namespace gr {
+namespace air_modes {
+
+class AIR_MODES_API uplink_impl : public uplink
+{
+private:
+    int d_check_width;
+    int d_chip_rate;
+    float d_preamble_length_us;
+    int d_samples_per_chip;
+    int d_samples_per_symbol;
+    float d_threshold_db;
+    float d_threshold;
+    pmt::pmt_t d_me, d_key;
+    gr::tag_t d_timestamp;
+    double d_secs_per_sample;
+    gr::msg_queue::sptr d_queue;
+    std::ostringstream d_payload;
+
+public:
+    uplink_impl(int channel_rate, float threshold_db, gr::msg_queue::sptr queue);
+
+    int general_work (int noutput_items,
+              gr_vector_int &ninput_items,
+              gr_vector_const_void_star &input_items,
+              gr_vector_void_star &output_items);
+
+    void set_rate(int channel_rate);
+    void set_threshold(float threshold_db);
+    float get_threshold(void);
+    int get_rate(void);
+};
+
+} //namespace air_modes
+} //namespace gr
+
+#endif //_AIR_MODES_UPLINK_IMPL_H_

python/__init__.py

@@ -51,7 +51,7 @@ from air_modes_swig import *
 
 # import any pure python here
 #
-from rx_path import rx_path
+from rx_path import rx_path, uplink_rx_path
 from zmq_socket import zmq_pubsub_iface
 from parse import *
 from msprint import output_print

python/az_map.py

@@ -27,7 +27,7 @@ import threading
 import math
 import air_modes
 from air_modes.exceptions import *
-
+import numpy as np
 
 # model has max range vs. azimuth in n-degree increments
 # contains separate max range for a variety of altitudes so
@@ -53,7 +53,7 @@ class az_map_model(QtCore.QObject):
 
     def data(self, row, col):
         return self._data[row][col]
-    
+
     def addRecord(self, bearing, altitude, distance):
         with self.lock:
             #round up to nearest altitude in altitudes list
@@ -85,18 +85,15 @@ class az_map_model(QtCore.QObject):
 
 # the azimuth map widget
 class az_map(QtGui.QWidget):
-    maxrange = 450
-    ringsize = 100
+    maxrange = 200
     bgcolor = QtCore.Qt.black
     ringpen =  QtGui.QPen(QtGui.QColor(0,   96,  127, 255), 1.3)
-    #rangepen = QtGui.QPen(QtGui.QColor(255, 255, 0,   255), 1.0)
-    
+
     def __init__(self, parent=None):
         super(az_map, self).__init__(parent)
         self._model = None
         self._paths = []
         self.maxrange = az_map.maxrange
-        self.ringsize = az_map.ringsize
 
     def minimumSizeHint(self):
         return QtCore.QSize(50, 50)
@@ -118,7 +115,7 @@ class az_map(QtGui.QWidget):
 
         #set background
         painter.fillRect(event.rect(), QtGui.QBrush(az_map.bgcolor))
-        
+
         #draw the range rings
         self.drawRangeRings(painter)
         for i in range(len(self._paths)):
@@ -136,12 +133,12 @@ class az_map(QtGui.QWidget):
                     bearing = (i+0.5) * 360./az_map_model.npoints
                     distance = self._model._data[i][alt]
                     radius = min(self.width(), self.height()) / 2.0
-                    scale = radius * distance / self.maxrange
+                    scale = radius * distance / self.get_range()
                     #convert bearing,distance to x,y
                     xpts = scale * math.sin(bearing * math.pi / 180)
                     ypts = scale * math.cos(bearing * math.pi / 180)
                     #get the bounding rectangle of the arc
-                    
+
                     arcrect = QtCore.QRectF(QtCore.QPointF(0-scale, 0-scale),
                                             QtCore.QPointF(scale, scale))
 
@@ -153,44 +150,55 @@ class az_map(QtGui.QWidget):
 
                 self._paths.append(path)
 
+    #this is just to add a little buffer space for showing the ring & range
+    def get_range(self):
+        return int(self.maxrange * 1.1)
+
     def drawRangeRings(self, painter):
         painter.translate(self.width()/2, self.height()/2)
-        painter.setPen(az_map.ringpen)
-        for i in range(0, self.maxrange, self.ringsize):
-            diameter = (float(i) / az_map.maxrange) * min(self.width(), self.height())
+        #choose intelligent range step -- keep it between 3-5 rings
+        rangestep = 100
+        while self.get_range() / rangestep < 3:
+            rangestep /= 2.0
+        for i in np.arange(rangestep, self.get_range(), rangestep): 
+            diameter = (float(i) / self.get_range()) * min(self.width(), self.height())
+            painter.setPen(az_map.ringpen)
             painter.drawEllipse(QtCore.QRectF(-diameter / 2.0,
                                 -diameter / 2.0, diameter, diameter))
+            painter.setPen(QtGui.QColor(255,127,0,255))
+
+            painter.drawText(0-70/2.0, diameter/2.0, 70, 30, QtCore.Qt.AlignHCenter,
+                             "%.1fnm" % i)
 
     def setMaxRange(self, maxrange):
+        maxrange = max(3.25, maxrange)
+        maxrange = min(500., maxrange)
         self.maxrange = maxrange
-        self.drawPath()
+        self.repaint()
 
-    def setRingSize(self, ringsize):
-        self.ringsize = ringsize
-        self.drawPath()
+    def wheelEvent(self, event):
+        self.setMaxRange(self.maxrange + (event.delta()/120.)*self.maxrange/4.)
 
 class az_map_output:
     def __init__(self, cprdec, model, pub):
         self._cpr = cprdec
         self.model = model
         pub.subscribe("type17_dl", self.output)
-        
+
     def output(self, msg):
         try:
-            msgtype = msg.data["df"]
             now = time.time()
-        
-            if msgtype == 17:
-                icao = msg.data["aa"]
-                subtype = msg.data["ftc"]
-                distance, altitude, bearing = [0,0,0]
-                if 5 <= subtype <= 8:
-                    (ground_track, decoded_lat, decoded_lon, distance, bearing) = air_modes.parseBDS06(msg.data, self._cpr)
-                    altitude = 0
-                elif 9 <= subtype <= 18:
+
+            icao = msg.data["aa"]
+            subtype = msg.data["ftc"]
+            distance, altitude, bearing = [0,0,0]
+            if 5 <= subtype <= 8:
+                (ground_track, decoded_lat, decoded_lon, distance, bearing) = air_modes.parseBDS06(msg.data, self._cpr)
+                altitude = 0
+            elif 9 <= subtype <= 18:
                     (altitude, decoded_lat, decoded_lon, distance, bearing) = air_modes.parseBDS05(msg.data, self._cpr)
 
-                self.model.addRecord(bearing, altitude, distance)
+            self.model.addRecord(bearing, altitude, distance)
         except ADSBError:
             pass
 

python/get_uniq.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+
+import sys, re
+
+if __name__== '__main__':
+    data = sys.stdin.readlines()
+    icaos = []
+    num_icaos = 0
+    for line in data:
+        match = re.match(".*from (\w+)", line)
+        if match is not None:
+            icao = int(match.group(1), 16)
+            icaos.append(icao)
+
+    #get dupes
+    dupes = sorted([icao for icao in set(icaos) if icaos.count(icao) > 1])
+    for icao in dupes:        
+        print "%x" % icao
+    print "Found non-unique replies from %i aircraft" % len(dupes)
+
+

python/gui_model.py

@@ -131,7 +131,7 @@ class dashboard_data_model(QtCore.QAbstractTableModel):
         self.lock.release()
         self.prune()
 
-    #weeds out ICAOs older than 5 minutes
+    #weeds out ICAOs older than 1 minute
     def prune(self):
         self.lock.acquire()
         for (index,row) in enumerate(self._data):

python/html_template.py

@@ -14,19 +14,21 @@ def html_template(my_position, json_file):
         <meta http-equiv="content-type" content="text/html;charset=utf-8" />
         <style type="text/css">
             .labels {
-                color: red;
+                color: blue;
                 background-color: white;
                 font-family: "Lucida Grande", "Arial", sans-serif;
-                font-size: 10px;
+                font-size: 13px;
                 font-weight: bold;
                 text-align: center;
-                width: 40px;
-                border: 2px solid black;
+                width: 70px;
+                border: none;
                 white-space: nowrap;
             }
         </style>
         <script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false">
         </script>
+        <script type="text/javascript" src="http://google-maps-utility-library-v3.googlecode.com/svn/tags/markerwithlabel/1.1.9/src/markerwithlabel.js">
+        </script>
         <script type="text/javascript">
             var map;
             var markers = [];
@@ -83,22 +85,22 @@ def html_template(my_position, json_file):
                         //scaledSize: new google.maps.Size(4608,126)
                     };
 
-                    identstr = airplanes[airplane].ident;
-                    if (identstr === "" || !identstr) {
-                        identstr = airplanes[airplane].icao;
+                    if (airplanes[airplane].ident.length != 8) {
+                        identstr = airplane; 
+                    } else {
+                        identstr = airplanes[airplane].ident;
                     };
 
                     var planeOptions = {
                         map: map,
                         position: airplanes[airplane].center,
                         icon: plane_icon,
-                        //label content meaningless unless you use the MarkerWithLabel class from the Maps Utility Library
                         labelContent: identstr,
-                        labelAnchor: new google.maps.Point(64, 0),
+                        labelAnchor: new google.maps.Point(35, -32),
                         labelClass: "labels",
                         labelStyle: {opacity: 0.75}
                     };
-                    planeMarker = new google.maps.Marker(planeOptions);
+                    planeMarker = new MarkerWithLabel(planeOptions);
                     planes.push(planeMarker);
                 };
             };

python/kml.py

@@ -39,8 +39,8 @@ class output_kml(threading.Thread):
     def run(self):
         self._db = sqlite3.connect(self._dbname) #read from the db
         while self.shutdown.is_set() is False:
-            self.writekml()
             time.sleep(self._timeout)
+            self.writekml()
 
         self._db.close()
         self._db = None
@@ -188,7 +188,7 @@ class output_jsonp(output_kml):
 #        retstr +=  """\t<Folder>\n\t\t<name>Aircraft locations</name>\n\t\t<open>0</open>"""
 
         #read the database and add KML
-        q = "select distinct icao from positions where seen > datetime('now', '-5 minute')"
+        q = "select distinct icao from positions where seen > datetime('now', '-1 minute')"
         c = self._db.cursor()
         self.locked_execute(c, q)
         icaolist = c.fetchall()

python/mlat_client.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+#
+# Copyright 2012 Nick Foster
+# 
+# This file is part of gr-air-modes
+# 
+# gr-air-modes 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.
+# 
+# gr-air-modes 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 gr-air-modes; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+#multilateration client
+#outputs stamps to server, receives multilaterated outputs back
+
+import socket, pickle, time, sys
+import air_modes
+from gnuradio import gr
+
+pickle_prot = 0
+#pickle_prot = pickle.HIGHEST_PROTOCOL
+
+class client_info:
+    def __init__(self):
+        self.name = ""
+        self.position = []
+        self.offset_secs = 0
+        self.offset_frac_secs = 0.0
+        self.time_source = None  
+
+class mlat_client:
+    def __init__(self, queue, position, server_addr, time_source):
+        self._queue = queue
+        self._pos = position
+        self._name = socket.gethostname()
+        #connect to server
+        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._sock.setblocking(1)
+        self._sock.connect((server_addr, 19005))
+        info = client_info()
+        info.name = self._name
+        info.position = self._pos
+        info.time_source = time_source #"gpsdo" or None
+        self._sock.send(pickle.dumps(info))
+        reply = self._sock.recv(1024)
+        if reply != "HELO": #i know, shut up
+            raise Exception("Invalid reply from server: %s" % reply)
+        self._sock.setblocking(0)
+        self._remnant = None
+
+    def __del__(self):
+        self._sock.close()
+
+    #send a stamped report to the server
+    def output(self, message):
+        self._sock.send(message+"\n")
+
+    #this is called from the update() method list of the main app thread
+    def get_mlat_positions(self):
+        msg = None
+        try:
+            msg = self._sock.recv(1024)
+        except socket.error:
+            pass
+        if msg:
+            for line in msg.splitlines(True):
+                if line.endswith("\n"):
+                    if self._remnant:
+                        line = self._remnant + line
+                        self._remnant = None
+                    self._queue.insert_tail(gr.message_from_string(line))
+
+                else:
+                    if self._remnant is not None:
+                        raise Exception("Malformed data: " + line)
+                    else:
+                        self._remnant = line

python/mlat_types.py

@@ -0,0 +1 @@
+

python/parse.py

@@ -427,7 +427,7 @@ def make_parser(pub):
     try:
       ret = air_modes.modes_report(modes_reply(int(data, 16)),
                                    int(ecc, 16),
-                                   20.0*math.log10(float(reference)),
+                                   10.0*math.log10(max(1e-8,float(reference))),
                                    air_modes.stamp(0, float(timestamp)))
       pub["modes_dl"] = ret
       pub["type%i_dl" % ret.data.get_type()] = ret

python/radio.py

@@ -23,7 +23,7 @@
 # You pass it options, it gives you data.
 # It uses the pubsub interface to allow clients to subscribe to its data feeds.
 
-from gnuradio import gr, gru, eng_notation, filter
+from gnuradio import gr, gru, eng_notation, filter, blocks
 from gnuradio.filter import optfir
 from gnuradio.eng_option import eng_option
 from gnuradio.gr.pubsub import pubsub
@@ -45,7 +45,8 @@ class modes_radio (gr.top_block, pubsub):
     self._resample = None
     self._setup_source(options)
 
-    self._rx_path = air_modes.rx_path(self._rate, options.threshold, self._queue, options.pmf)
+    self._rx_path = air_modes.rx_path(self._rate, options.threshold,
+                                      self._queue, options.pmf, options.dcblock)
 
     #now subscribe to set various options via pubsub
     self.subscribe("freq", self.set_freq)
@@ -102,33 +103,42 @@ class modes_radio (gr.top_block, pubsub):
     #RX path args
     group.add_option("-r", "--rate", type="eng_float", default=4e6,
                       help="set sample rate [default=%default]")
-    group.add_option("-T", "--threshold", type="eng_float", default=5.0,
+    group.add_option("-T", "--threshold", type="eng_float", default=7.0,
                       help="set pulse detection threshold above noise in dB [default=%default]")
     group.add_option("-p","--pmf", action="store_true", default=False,
                       help="Use pulse matched filtering [default=%default]")
+    group.add_option("-d","--dcblock", action="store_true", default=False,
+                      help="Use a DC blocking filter (best for HackRF Jawbreaker) [default=%default]")
 
     parser.add_option_group(group)
 
   def live_source(self):
-    return self._options.source is 'uhd' or self._options.source is 'osmocom'
+    return self._options.source=="uhd" or self._options.source=="osmocom"
 
   def set_freq(self, freq):
-    return self._u.set_center_freq(freq, 0) if live_source() else 0
+    return self._u.set_center_freq(freq, 0) if self.live_source() else 0
 
   def set_gain(self, gain):
-    return self._u.set_gain(gain) if live_source() else 0
+    if self.live_source():
+        self._u.set_gain(gain)
+        print "Gain is %f" % self.get_gain()
+    return self.get_gain()
 
   def set_rate(self, rate):
-    return self._u.set_rate(rate) if live_source() else 0
+    self._rx_path.set_rate(rate)
+    return self._u.set_rate(rate) if self.live_source() else 0
+
+  def set_threshold(self, threshold):
+    self._rx_path.set_threshold(threshold)
 
   def get_freq(self, freq):
-    return self._u.get_center_freq(freq, 0) if live_source() else 1090e6
-    
-  def get_gain(self, gain):
-    return self._u.get_gain() if live_source() else 0
+    return self._u.get_center_freq(freq, 0) if self.live_source() else 1090e6
 
-  def get_rate(self, rate):
-    return self._u.get_rate() if live_source() else self._rate
+  def get_gain(self):
+    return self._u.get_gain() if self.live_source() else 0
+
+  def get_rate(self):
+    return self._u.get_rate() if self.live_source() else self._rate
 
   def _setup_source(self, options):
     if options.source == "uhd":
@@ -164,31 +174,24 @@ class modes_radio (gr.top_block, pubsub):
 
     #TODO: detect if you're using an RTLSDR or Jawbreaker
     #and set up accordingly.
-    #ALSO TODO: Actually set gain appropriately using gain bins in HackRF driver.
-    #osmocom doesn't have gain bucket distribution like UHD does
     elif options.source == "osmocom": #RTLSDR dongle or HackRF Jawbreaker
         import osmosdr
-        self._u = osmosdr.source_c(options.args)
+        self._u = osmosdr.source(options.args)
 #        self._u.set_sample_rate(3.2e6) #fixed for RTL dongles
         self._u.set_sample_rate(options.rate)
         if not self._u.set_center_freq(options.freq):
             print "Failed to set initial frequency"
 
-        self._u.set_gain_mode(0) #manual gain mode
+#        self._u.set_gain_mode(0) #manual gain mode
         if options.gain is None:
             options.gain = 34
-###DO NOT COMMIT
-        self._u.set_gain(14, "RF", 0)
-        self._u.set_gain(40, "IF", 0)
-        #self._u.set_gain(14, "BB", 0)
-###DO NOT COMMIT
-#        self._u.set_gain(options.gain)
+        self._u.set_gain(options.gain)
         print "Gain is %i" % self._u.get_gain()
 
         #Note: this should only come into play if using an RTLSDR.
 #        lpfiltcoeffs = gr.firdes.low_pass(1, 5*3.2e6, 1.6e6, 300e3)
 #        self._resample = filter.rational_resampler_ccf(interpolation=5, decimation=4, taps=lpfiltcoeffs)
-                
+
     else:
       #semantically detect whether it's ip.ip.ip.ip:port or filename
       if ':' in options.source:
@@ -199,10 +202,11 @@ class modes_radio (gr.top_block, pubsub):
         self._u = gr.udp_source(gr.sizeof_gr_complex, ip, int(port))
         print "Using UDP source %s:%s" % (ip, port)
       else:
-        self._u = gr.file_source(gr.sizeof_gr_complex, options.source)
+        self._u = blocks.file_source(gr.sizeof_gr_complex, options.source)
         print "Using file source %s" % options.source
 
     print "Rate is %i" % (options.rate,)
 
   def close(self):
     self._sender.close()
+    self._u = None

python/rx_path.py

@@ -19,12 +19,12 @@
 # Boston, MA 02110-1301, USA.
 # 
 
-from gnuradio import gr, blocks
+from gnuradio import gr, blocks, filter
 import air_modes_swig
 
 class rx_path(gr.hier_block2):
 
-    def __init__(self, rate, threshold, queue, use_pmf=False):
+    def __init__(self, rate, threshold, queue, use_pmf=False, use_dcblock=False):
         gr.hier_block2.__init__(self, "modes_rx_path",
                                 gr.io_signature(1, 1, gr.sizeof_gr_complex),
                                 gr.io_signature(0,0,0))
@@ -35,9 +35,15 @@ class rx_path(gr.hier_block2):
         self._spc = int(rate/2e6)
 
         # Convert incoming I/Q baseband to amplitude
-        self._demod = blocks.complex_to_mag()
-        self._bb = self._demod
+        self._demod = blocks.complex_to_mag_squared()
+        if use_dcblock:
+            self._dcblock = filter.dc_blocker_cc(100*self._spc,True)
+            self.connect(self, self._dcblock, self._demod)
+        else:
+            self.connect(self, self._demod)
+            self._dcblock = None
 
+        self._bb = self._demod
         # Pulse matched filter for 0.5us pulses
         if use_pmf:
             self._pmf = blocks.moving_average_ff(self._spc, 1.0/self._spc)#, self._rate)
@@ -48,24 +54,24 @@ class rx_path(gr.hier_block2):
         self._avg = blocks.moving_average_ff(48*self._spc, 1.0/(48*self._spc))#, self._rate) # 3 preambles
 
         # Synchronize to Mode-S preamble
-        self._sync = air_modes_swig.modes_preamble(self._rate, self._threshold)
+        self._sync = air_modes_swig.preamble(self._rate, self._threshold)
 
         # Slice Mode-S bits and send to message queue
-        self._slicer = air_modes_swig.modes_slicer(self._rate, self._queue)
+        self._slicer = air_modes_swig.slicer(self._queue)
 
         # Wire up the flowgraph
-        self.connect(self, self._demod)
         self.connect(self._bb, (self._sync, 0))
         self.connect(self._bb, self._avg, (self._sync, 1))
         self.connect(self._sync, self._slicer)
 
     def set_rate(self, rate):
         self._sync.set_rate(rate)
-        self._slicer.set_rate(rate)
         self._spc = int(rate/2e6)
         self._avg.set_length_and_scale(48*self._spc, 1.0/(48*self._spc))
         if self._bb != self._demod:
             self._pmf.set_length_and_scale(self._spc, 1.0/self._spc)
+        if self._dcblock is not None:
+            self._dcblock.set_length(100*self._spc)
 
     def set_threshold(self, threshold):
         self._sync.set_threshold(threshold)
@@ -79,4 +85,47 @@ class rx_path(gr.hier_block2):
 
     def get_threshold(self, threshold):
         return self._sync.get_threshold()
-            
+
+class uplink_rx_path(gr.hier_block2):
+    def __init__(self, rate, threshold, queue, use_pmf=False, use_dcblock=False):
+        gr.hier_block2.__init__(self, "modes_uplink_rx_path",
+                                gr.io_signature(1, 1, gr.sizeof_gr_complex),
+                                gr.io_signature(0,0,0))
+
+        self._rate = int(rate)
+        self._threshold = threshold
+        self._queue = queue
+        self._spc = int(rate/4e6)
+
+        #demodulate DPSK via delay
+        self._delay = gr.delay(gr.sizeof_gr_complex, self._spc)
+        self._mult = gr.multiply_cc()
+        self._conj = gr.conjugate_cc()
+        self._c2r = gr.complex_to_real()
+        #self._bb = self._demod
+
+        self.filesink = gr.file_sink(gr.sizeof_float, "wat.dat")
+
+        # Pulse matched filter for 0.25us pulses
+#        if use_pmf:
+#            self._pmf = gr.moving_average_ff(self._spc, 1.0/self._spc, self._rate)
+#            self.connect(self._demod, self._pmf)
+#            self._bb = self._pmf
+
+        # Establish baseline amplitude (noise, interference)
+        self._avg = gr.moving_average_ff(48*self._spc, 1.0/(48*self._spc), self._rate) # 3 preambles
+
+        # Synchronize to uplink preamble
+        self._sync = air_modes_swig.modes_uplink(self._rate, self._threshold)
+
+        # Slice Mode-S bits and send to message queue
+#        self._slicer = air_modes_swig.modes_slicer(self._rate, self._queue)
+
+        # Wire up the flowgraph
+        self.connect(self, (self._mult, 0))
+        self.connect(self, self._delay, self._conj, (self._mult, 1))
+        self.connect(self._mult, self._c2r)
+        self.connect(self._c2r, (self._sync, 0))
+        self.connect(self._c2r, self._avg, (self._sync, 1))
+#        self.connect(self._sync, self._slicer)
+        self.connect(self._sync, self.filesink)

res/modes_rx.ui

@@ -316,6 +316,19 @@
               <string>Use Pulse Matched Filtering</string>
              </property>
             </widget>
+            <widget class="QCheckBox" name="check_dcblock">
+             <property name="geometry">
+              <rect>
+               <x>10</x>
+               <y>220</y>
+               <width>221</width>
+               <height>22</height>
+              </rect>
+             </property>
+             <property name="text">
+              <string>Use DC blocking filter</string>
+             </property>
+            </widget>
            </widget>
            <widget class="QGroupBox" name="group_output">
             <property name="geometry">
@@ -835,12 +848,12 @@
              <rect>
               <x>483</x>
               <y>125</y>
-              <width>31</width>
+              <width>51</width>
               <height>17</height>
              </rect>
             </property>
             <property name="text">
-             <string>ft/s</string>
+             <string>ft/min</string>
             </property>
            </widget>
            <widget class="QLabel" name="label_31">

swig/air_modes.i

@@ -1,45 +1,20 @@
 /* -*- c++ -*- */
 
-%include "gnuradio.i"			// the common stuff
+#define AIR_MODES_API
+
+%include "gnuradio.i"
 
 %{
-#include "air_modes_preamble.h"
-#include "air_modes_slicer.h"
-#include <gnuradio/msg_queue.h>
+#include "gr_air_modes/preamble.h"
+#include "gr_air_modes/slicer.h"
+#include "gr_air_modes/uplink.h"
 %}
 
-// ----------------------------------------------------------------
+%include "gr_air_modes/preamble.h"
+%include "gr_air_modes/slicer.h"
+%include "gr_air_modes/uplink.h"
 
-/*
- * First arg is the package prefix.
- * Second arg is the name of the class minus the prefix.
- *
- * This does some behind-the-scenes magic so we can
- * access howto_square_ff from python as howto.square_ff
- */
-GR_SWIG_BLOCK_MAGIC(air,modes_preamble);
-
-air_modes_preamble_sptr air_make_modes_preamble (int channel_rate, float threshold_db);
-
-class air_modes_preamble : public gr::sync_block
-{
-  set_rate(int channel_rate);
-  set_threshold(float threshold_db);
-  int get_threshold(void);
-private:
-  air_modes_preamble (int channel_rate, float threshold_db);
-};
-
-GR_SWIG_BLOCK_MAGIC(air,modes_slicer);
-
-air_modes_slicer_sptr air_make_modes_slicer (int channel_rate, gr::msg_queue::sptr queue);
-
-class air_modes_slicer : public gr::block
-{
-  set_rate(int channel_rate);
-private:
-    air_modes_slicer (int channel_rate, gr::msg_queue::sptr queue);
-};
-
-// ----------------------------------------------------------------
+GR_SWIG_BLOCK_MAGIC2(air_modes,preamble);
+GR_SWIG_BLOCK_MAGIC2(air_modes,slicer);
+GR_SWIG_BLOCK_MAGIC2(air_modes,uplink);