Fix PyQt4 finding during compile.

Update doxygen config to eliminate warning from current doxygen.
Signed-off-by: Philip Balister <philip@balister.org>
2015-01-29 11:23:14 -08:00 · 2015-01-29 14:38:27 +01:00 · 2015-01-29 14:37:30 +01:00
27 changed files with 849 additions and 347 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,23 +1,22 @@
-# Copyright 2011,2013 Free Software Foundation, Inc.
-# 
+# Copyright 2011,2012,2014 Free Software Foundation, Inc.
+#
 # This file is part of GNU Radio
-# 
+#
 # GNU Radio is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3, or (at your option)
 # any later version.
-# 
+#
 # GNU Radio is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.

-
 ########################################################################
 # Project setup
 ########################################################################
@@ -34,7 +33,8 @@ if(NOT CMAKE_BUILD_TYPE)
 endif(NOT CMAKE_BUILD_TYPE)
 set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")

-list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules)
+#make sure our local CMake Modules path comes first
+list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_SOURCE_DIR}/cmake/Modules)

 ########################################################################
 # Compiler specific setup
@@ -47,9 +47,23 @@ endif()
 ########################################################################
 # Find boost
 ########################################################################
-include(GrBoost)
+if(UNIX AND EXISTS "/usr/lib64")
+    list(APPEND BOOST_LIBRARYDIR "/usr/lib64") #fedora 64-bit fix
+endif(UNIX AND EXISTS "/usr/lib64")
+set(Boost_ADDITIONAL_VERSIONS
+    "1.35.0" "1.35" "1.36.0" "1.36" "1.37.0" "1.37" "1.38.0" "1.38" "1.39.0" "1.39"
+    "1.40.0" "1.40" "1.41.0" "1.41" "1.42.0" "1.42" "1.43.0" "1.43" "1.44.0" "1.44"
+    "1.45.0" "1.45" "1.46.0" "1.46" "1.47.0" "1.47" "1.48.0" "1.48" "1.49.0" "1.49"
+    "1.50.0" "1.50" "1.51.0" "1.51" "1.52.0" "1.52" "1.53.0" "1.53" "1.54.0" "1.54"
+    "1.55.0" "1.55" "1.56.0" "1.56" "1.57.0" "1.57" "1.58.0" "1.58" "1.59.0" "1.59"
+    "1.60.0" "1.60" "1.61.0" "1.61" "1.62.0" "1.62" "1.63.0" "1.63" "1.64.0" "1.64"
+    "1.65.0" "1.65" "1.66.0" "1.66" "1.67.0" "1.67" "1.68.0" "1.68" "1.69.0" "1.69"
+)
+find_package(Boost "1.35" COMPONENTS filesystem system)

-find_package(PythonLibs 2)
+if(NOT Boost_FOUND)
+    message(FATAL_ERROR "Boost required to compile air-modes")
+endif()

 ########################################################################
 # Install directories
@@ -57,7 +71,7 @@ find_package(PythonLibs 2)
 include(GrPlatform) #define LIB_SUFFIX
 set(GR_RUNTIME_DIR      bin)
 set(GR_LIBRARY_DIR      lib${LIB_SUFFIX})
-set(GR_INCLUDE_DIR      include)
+set(GR_INCLUDE_DIR      include/gr_air_modes)
 set(GR_DATA_DIR         share)
 set(GR_PKG_DATA_DIR     ${GR_DATA_DIR}/${CMAKE_PROJECT_NAME})
 set(GR_DOC_DIR          ${GR_DATA_DIR}/doc)
@@ -68,36 +82,68 @@ set(GR_LIBEXEC_DIR      libexec)
 set(GR_PKG_LIBEXEC_DIR  ${GR_LIBEXEC_DIR}/${CMAKE_PROJECT_NAME})
 set(GRC_BLOCKS_DIR      ${GR_PKG_DATA_DIR}/grc/blocks)

+########################################################################
+# On Apple only, set install name and use rpath correctly, if not already set
+########################################################################
+if(APPLE)
+    if(NOT CMAKE_INSTALL_NAME_DIR)
+        set(CMAKE_INSTALL_NAME_DIR
+            ${CMAKE_INSTALL_PREFIX}/${GR_LIBRARY_DIR} CACHE
+            PATH "Library Install Name Destination Directory" FORCE)
+    endif(NOT CMAKE_INSTALL_NAME_DIR)
+    if(NOT CMAKE_INSTALL_RPATH)
+        set(CMAKE_INSTALL_RPATH
+            ${CMAKE_INSTALL_PREFIX}/${GR_LIBRARY_DIR} CACHE
+            PATH "Library Install RPath" FORCE)
+    endif(NOT CMAKE_INSTALL_RPATH)
+    if(NOT CMAKE_BUILD_WITH_INSTALL_RPATH)
+        set(CMAKE_BUILD_WITH_INSTALL_RPATH ON CACHE
+            BOOL "Do Build Using Library Install RPath" FORCE)
+    endif(NOT CMAKE_BUILD_WITH_INSTALL_RPATH)
+endif(APPLE)
+
 ########################################################################
 # Find gnuradio build dependencies
 ########################################################################
+find_package(CppUnit)
+find_package(Doxygen)
+
+# Search for GNU Radio and its components and versions. Add any
+# components required to the list of GR_REQUIRED_COMPONENTS (in all
+# caps such as FILTER or FFT) and change the version to the minimum
+# API compatible version required.
 set(GR_REQUIRED_COMPONENTS RUNTIME)
 find_package(Gnuradio "3.7.2" REQUIRED)

-if(NOT GNURADIO_RUNTIME_FOUND)
-    message(FATAL_ERROR "GnuRadio Runtime required to compile gr-air-modes")
+if(NOT CPPUNIT_FOUND)
+    message(FATAL_ERROR "CppUnit required to compile airmodes")
 endif()

 ########################################################################
-# Find PyZMQ bindings
+# Setup doxygen option
 ########################################################################
-include(GrPython)
-#GR_PYTHON_CHECK_MODULE("PyZMQ" "zmq" "int(zmq.__version__.split('.')[0]) >= 13" PYZMQ_FOUND)
-#if(NOT PYZMQ_FOUND)
-#    message(FATAL_ERROR "Python ZMQ bindings not found.")
-#endif()
+if(DOXYGEN_FOUND)
+	option(ENABLE_DOXYGEN "Build docs using Doxygen" ON)
+else(DOXYGEN_FOUND)
+	option(ENABLE_DOXYGEN "Build docs using Doxygen" OFF)
+endif(DOXYGEN_FOUND)

 ########################################################################
 # Setup the include and linker paths
 ########################################################################
 include_directories(
+    ${CMAKE_SOURCE_DIR}/lib
    ${CMAKE_SOURCE_DIR}/include
+    ${CMAKE_BINARY_DIR}/lib
+    ${CMAKE_BINARY_DIR}/include
    ${Boost_INCLUDE_DIRS}
-    ${GNURADIO_RUNTIME_INCLUDE_DIRS}
+    ${CPPUNIT_INCLUDE_DIRS}
+    ${GNURADIO_ALL_INCLUDE_DIRS}
 )

 link_directories(
    ${Boost_LIBRARY_DIRS}
+    ${CPPUNIT_LIBRARY_DIRS}
    ${GNURADIO_RUNTIME_LIBRARY_DIRS}
 )

@@ -128,3 +174,14 @@ add_subdirectory(grc)
 add_subdirectory(apps)
 add_subdirectory(docs)
 add_subdirectory(res)
+
+########################################################################
+# Install cmake search helper for this library
+########################################################################
+if(NOT CMAKE_MODULES_DIR)
+  set(CMAKE_MODULES_DIR lib${LIB_SUFFIX}/cmake)
+endif(NOT CMAKE_MODULES_DIR)
+
+install(FILES cmake/Modules/gr_air_modesConfig.cmake
+    DESTINATION ${CMAKE_MODULES_DIR}/gr_air_modes
+)
--- a/10
+++ b/10
@@ -1,10 +0,0 @@
-FROM bistromath/gnuradio:3.7.11
-
-ENV num_threads 10
-MAINTAINER bistromath@gmail.com version: 0.1
-
-WORKDIR /opt
-RUN mkdir gr-air-modes
-COPY . gr-air-modes/
-WORKDIR /opt/gr-air-modes
-RUN mkdir build && cd build && cmake ../ && make -j${num_threads} && make install && ldconfig
--- a/1
+++ b/1
@@ -97,7 +97,6 @@ gr-air-modes requires:

 * Python >= 2.5 (written for Python 2.7, Python 3.0 might work)
 ** NumPy and SciPy are required for the FlightGear output plugin.
-* PyZMQ
 * Gnuradio >= 3.5.0
 * Ettus UHD >= 3.4.0 for use with USRPs
 * osmosdr (any version) for use with RTLSDR dongles
--- a/apps/modes_gui
+++ b/apps/modes_gui
@@ -30,7 +30,6 @@ import air_modes
 from air_modes.exceptions import *
 from air_modes.modes_rx_ui import Ui_MainWindow
 from air_modes.gui_model import *
-from air_modes.az_map import *
 import sqlite3
 import zmq

@@ -88,9 +87,7 @@ class mainwindow(QtGui.QMainWindow):
            self.ui.line_my_lat.insert(defaults["latitude"])
        if defaults["longitude"] is not None:
            self.ui.line_my_lon.insert(defaults["longitude"])
-        if defaults["apikey"] is not None:
-            self.ui.line_my_api_key.insert(defaults["apikey"])
-        
+
        #disable by default
        self.ui.check_adsbonly.setCheckState(QtCore.Qt.Unchecked)

@@ -107,7 +104,7 @@ class mainwindow(QtGui.QMainWindow):
        self.ui.list_aircraft.setModel(self.datamodel)
        self.ui.list_aircraft.setModelColumn(0)

-        self.az_model = air_modes.az_map.az_map_model(None)
+        self.az_model = air_modes.az_map_model(None)
        self.ui.azimuth_map.setModel(self.az_model)

        #set up dashboard views
@@ -324,11 +321,6 @@ class mainwindow(QtGui.QMainWindow):
            except:
                my_position = None

-            try:
-                my_apikey = str(self.ui.line_my_api_key.text())
-            except:
-                my_apikey = None
-
            self._cpr_dec = air_modes.cpr_decoder(my_position)

            self.datamodelout = dashboard_output(self._cpr_dec, self.datamodel, self._publisher)
@@ -351,7 +343,7 @@ class mainwindow(QtGui.QMainWindow):

            #add azimuth map output and hook it up
            if my_position is not None:
-                self.az_map_output = air_modes.az_map.az_map_output(self._cpr_dec, self.az_model, self._publisher)
+                self.az_map_output = air_modes.az_map_output(self._cpr_dec, self.az_model, self._publisher)
                #self._relay.subscribe("dl_data", self.az_map_output.output)

            #set up map
@@ -367,7 +359,7 @@ class mainwindow(QtGui.QMainWindow):
            #create SQL database for KML and dashboard displays
            self.dbwriter = air_modes.output_sql(self._cpr_dec, self.dbname, self.lock, self._publisher)
            self.jsonpgen = air_modes.output_jsonp(self._jsonfile.name, self.dbname, my_position, self.lock, timeout=1)
-            htmlstring = air_modes.html_template(my_apikey, my_position, self._jsonfile.name)
+            htmlstring = air_modes.html_template(my_position, self._jsonfile.name)
            self._htmlfile.write(htmlstring)
            self._htmlfile.flush()
            class WebPage(QtWebKit.QWebPage):
@@ -412,11 +404,7 @@ class mainwindow(QtGui.QMainWindow):
                self.prefs["longitude"] = float(self.ui.line_my_lon.text())
            except:
                pass
-            try:
-                self.prefs["apikey"] = self.ui.line_my_api_key.text()
-            except:
-                pass
-                
+
    def on_quit(self):
        if self.running is True:
            self._radio.close()
@@ -475,7 +463,6 @@ class mainwindow(QtGui.QMainWindow):
        defaults["threshold"] = "5"
        defaults["latitude"] = None
        defaults["longitude"] = None
-        defaults["apikey"] = None

        prefs = ConfigParser.ConfigParser(defaults)
        prefs.optionxform = str
--- a/cmake/Modules/FindCppUnit.cmake
+++ b/cmake/Modules/FindCppUnit.cmake
@@ -0,0 +1,39 @@
+# http://www.cmake.org/pipermail/cmake/2006-October/011446.html
+# Modified to use pkg config and use standard var names
+
+#
+# Find the CppUnit includes and library
+#
+# This module defines
+# CPPUNIT_INCLUDE_DIR, where to find tiff.h, etc.
+# CPPUNIT_LIBRARIES, the libraries to link against to use CppUnit.
+# CPPUNIT_FOUND, If false, do not try to use CppUnit.
+
+INCLUDE(FindPkgConfig)
+PKG_CHECK_MODULES(PC_CPPUNIT "cppunit")
+
+FIND_PATH(CPPUNIT_INCLUDE_DIRS
+    NAMES cppunit/TestCase.h
+    HINTS ${PC_CPPUNIT_INCLUDE_DIR}
+    ${CMAKE_INSTALL_PREFIX}/include
+    PATHS
+    /usr/local/include
+    /usr/include
+)
+
+FIND_LIBRARY(CPPUNIT_LIBRARIES
+    NAMES cppunit
+    HINTS ${PC_CPPUNIT_LIBDIR}
+    ${CMAKE_INSTALL_PREFIX}/lib
+    ${CMAKE_INSTALL_PREFIX}/lib64
+    PATHS
+    ${CPPUNIT_INCLUDE_DIRS}/../lib
+    /usr/local/lib
+    /usr/lib
+)
+
+LIST(APPEND CPPUNIT_LIBRARIES ${CMAKE_DL_LIBS})
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(CPPUNIT DEFAULT_MSG CPPUNIT_LIBRARIES CPPUNIT_INCLUDE_DIRS)
+MARK_AS_ADVANCED(CPPUNIT_LIBRARIES CPPUNIT_INCLUDE_DIRS)
--- a/cmake/Modules/FindQwt.cmake
+++ b/cmake/Modules/FindQwt.cmake
@@ -1,41 +0,0 @@
-# - try to find Qwt libraries and include files
-# QWT_INCLUDE_DIR where to find qwt_plot.h, etc.
-# QWT_LIBRARIES libraries to link against
-# QWT_FOUND If false, do not try to use Qwt
-
-find_path (QWT_INCLUDE_DIRS
-    NAMES qwt_plot.h
-    HINTS
-    ${CMAKE_INSTALL_PREFIX}/include/qwt
-    ${CMAKE_PREFIX_PATH}/include/qwt
-    PATHS
-    /usr/local/include/qwt-qt4
-    /usr/local/include/qwt
-    /usr/include/qwt6
-    /usr/include/qwt-qt4
-    /usr/include/qwt
-    /usr/include/qwt5
-    /opt/local/include/qwt
-    /sw/include/qwt
-    /usr/local/lib/qwt.framework/Headers
-)
-
-find_library (QWT_LIBRARIES
-    NAMES qwt6 qwt6-qt4 qwt qwt-qt4 qwt5 qwtd5
-    HINTS
-    ${CMAKE_INSTALL_PREFIX}/lib
-    ${CMAKE_INSTALL_PREFIX}/lib64
-    ${CMAKE_PREFIX_PATH}/lib 
-    PATHS
-    /usr/local/lib
-    /usr/lib
-    /opt/local/lib
-    /sw/lib
-    /usr/local/lib/qwt.framework
-)
-
-# handle the QUIETLY and REQUIRED arguments and set QWT_FOUND to TRUE if
-# all listed variables are TRUE
-include ( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( Qwt DEFAULT_MSG QWT_LIBRARIES QWT_INCLUDE_DIRS )
-MARK_AS_ADVANCED(QWT_LIBRARIES QWT_INCLUDE_DIRS)
--- a/cmake/Modules/GrBoost.cmake
+++ b/cmake/Modules/GrBoost.cmake
@@ -1,99 +0,0 @@
-# Copyright 2010-2011 Free Software Foundation, Inc.
-#
-# This file is part of GNU Radio
-#
-# GNU Radio is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3, or (at your option)
-# any later version.
-#
-# GNU Radio is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with GNU Radio; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-
-if(DEFINED __INCLUDED_GR_BOOST_CMAKE)
-    return()
-endif()
-set(__INCLUDED_GR_BOOST_CMAKE TRUE)
-
-########################################################################
-# Setup Boost and handle some system specific things
-########################################################################
-
-set(BOOST_REQUIRED_COMPONENTS
-    date_time
-    program_options
-    filesystem
-    system
-    thread
-)
-
-if(UNIX AND NOT BOOST_ROOT AND EXISTS "/usr/lib64")
-    list(APPEND BOOST_LIBRARYDIR "/usr/lib64") #fedora 64-bit fix
-endif(UNIX AND NOT BOOST_ROOT AND EXISTS "/usr/lib64")
-
-if(MSVC)
-    set(BOOST_REQUIRED_COMPONENTS ${BOOST_REQUIRED_COMPONENTS} chrono)
-
-    if (NOT DEFINED BOOST_ALL_DYN_LINK)
-        set(BOOST_ALL_DYN_LINK TRUE)
-    endif()
-    set(BOOST_ALL_DYN_LINK "${BOOST_ALL_DYN_LINK}" CACHE BOOL "boost enable dynamic linking")
-    if(BOOST_ALL_DYN_LINK)
-        add_definitions(-DBOOST_ALL_DYN_LINK) #setup boost auto-linking in msvc
-    else(BOOST_ALL_DYN_LINK)
-        unset(BOOST_REQUIRED_COMPONENTS) #empty components list for static link
-    endif(BOOST_ALL_DYN_LINK)
-endif(MSVC)
-
-find_package(Boost "1.35" COMPONENTS ${BOOST_REQUIRED_COMPONENTS})
-
-# This does not allow us to disable specific versions. It is used
-# internally by cmake to know the formation newer versions. As newer
-# Boost version beyond what is shown here are produced, we must extend
-# this list. To disable Boost versions, see below.
-set(Boost_ADDITIONAL_VERSIONS
-    "1.35.0" "1.35" "1.36.0" "1.36" "1.37.0" "1.37" "1.38.0" "1.38" "1.39.0" "1.39"
-    "1.40.0" "1.40" "1.41.0" "1.41" "1.42.0" "1.42" "1.43.0" "1.43" "1.44.0" "1.44"
-    "1.45.0" "1.45" "1.46.0" "1.46" "1.47.0" "1.47" "1.48.0" "1.48" "1.49.0" "1.49"
-    "1.50.0" "1.50" "1.51.0" "1.51" "1.52.0" "1.52" "1.53.0" "1.53" "1.54.0" "1.54"
-    "1.55.0" "1.55" "1.56.0" "1.56" "1.57.0" "1.57" "1.58.0" "1.58" "1.59.0" "1.59"
-    "1.60.0" "1.60" "1.61.0" "1.61" "1.62.0" "1.62" "1.63.0" "1.63" "1.64.0" "1.64"
-    "1.65.0" "1.65" "1.66.0" "1.66" "1.67.0" "1.67" "1.68.0" "1.68" "1.69.0" "1.69"
-)
-
-# Boost 1.52 disabled, see https://svn.boost.org/trac/boost/ticket/7669
-# Similar problems with Boost 1.46 and 1.47.
-
-OPTION(ENABLE_BAD_BOOST "Enable known bad versions of Boost" OFF)
-if(ENABLE_BAD_BOOST)
-  MESSAGE(STATUS "Enabling use of known bad versions of Boost.")
-endif(ENABLE_BAD_BOOST)
-
-# For any unsuitable Boost version, add the version number below in
-# the following format: XXYYZZ
-# Where:
-#     XX is the major version ('10' for version 1)
-#     YY is the minor version number ('46' for 1.46)
-#     ZZ is the patcher version number (typically just '00')
-set(Boost_NOGO_VERSIONS
-  104600 104601 104700 105200
-  )
-
-foreach(ver ${Boost_NOGO_VERSIONS})
-  if("${Boost_VERSION}" STREQUAL "${ver}")
-    if(NOT ENABLE_BAD_BOOST)
-      MESSAGE(STATUS "WARNING: Found a known bad version of Boost (v${Boost_VERSION}). Disabling.")
-      set(Boost_FOUND FALSE)
-    else(NOT ENABLE_BAD_BOOST)
-      MESSAGE(STATUS "WARNING: Found a known bad version of Boost (v${Boost_VERSION}). Continuing anyway.")
-      set(Boost_FOUND TRUE)
-    endif(NOT ENABLE_BAD_BOOST)
-  endif("${Boost_VERSION}" STREQUAL "${ver}")
-endforeach(ver)
--- a/cmake/Modules/GrMiscUtils.cmake
+++ b/cmake/Modules/GrMiscUtils.cmake
@@ -1,4 +1,4 @@
-# Copyright 2010-2011 Free Software Foundation, Inc.
+# Copyright 2010-2011,2014 Free Software Foundation, Inc.
 #
 # This file is part of GNU Radio
 #
@@ -94,7 +94,13 @@ macro(GR_ADD_CXX_COMPILER_FLAG_IF_AVAILABLE flag have)
    include(CheckCXXCompilerFlag)
    CHECK_CXX_COMPILER_FLAG(${flag} ${have})
    if(${have})
-        add_definitions(${flag})
+      if(${CMAKE_VERSION} VERSION_GREATER "2.8.4")
+        STRING(FIND "${CMAKE_CXX_FLAGS}" "${flag}" flag_dup)
+        if(${flag_dup} EQUAL -1)
+          set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
+          set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
+        endif(${flag_dup} EQUAL -1)
+      endif(${CMAKE_VERSION} VERSION_GREATER "2.8.4")
    endif(${have})
 endmacro(GR_ADD_CXX_COMPILER_FLAG_IF_AVAILABLE)

@@ -208,3 +214,312 @@ function(GR_GEN_TARGET_DEPS name var)
        set(${var} "DEPENDS;${name};COMMAND;${name}" PARENT_SCOPE)
    endif()
 endfunction(GR_GEN_TARGET_DEPS)
+
+########################################################################
+# Control use of gr_logger
+# Usage:
+#   GR_LOGGING()
+#
+# Will set ENABLE_GR_LOG to 1 by default.
+# Can manually set with -DENABLE_GR_LOG=0|1
+########################################################################
+function(GR_LOGGING)
+  find_package(Log4cpp)
+
+  OPTION(ENABLE_GR_LOG "Use gr_logger" ON)
+  if(ENABLE_GR_LOG)
+    # If gr_logger is enabled, make it usable
+    add_definitions( -DENABLE_GR_LOG )
+
+    # also test LOG4CPP; if we have it, use this version of the logger
+    # otherwise, default to the stdout/stderr model.
+    if(LOG4CPP_FOUND)
+      SET(HAVE_LOG4CPP True CACHE INTERNAL "" FORCE)
+      add_definitions( -DHAVE_LOG4CPP )
+    else(not LOG4CPP_FOUND)
+      SET(HAVE_LOG4CPP False CACHE INTERNAL "" FORCE)
+      SET(LOG4CPP_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
+      SET(LOG4CPP_LIBRARY_DIRS "" CACHE INTERNAL "" FORCE)
+      SET(LOG4CPP_LIBRARIES "" CACHE INTERNAL "" FORCE)
+    endif(LOG4CPP_FOUND)
+
+    SET(ENABLE_GR_LOG ${ENABLE_GR_LOG} CACHE INTERNAL "" FORCE)
+
+  else(ENABLE_GR_LOG)
+    SET(HAVE_LOG4CPP False CACHE INTERNAL "" FORCE)
+    SET(LOG4CPP_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
+    SET(LOG4CPP_LIBRARY_DIRS "" CACHE INTERNAL "" FORCE)
+    SET(LOG4CPP_LIBRARIES "" CACHE INTERNAL "" FORCE)
+  endif(ENABLE_GR_LOG)
+
+  message(STATUS "ENABLE_GR_LOG set to ${ENABLE_GR_LOG}.")
+  message(STATUS "HAVE_LOG4CPP set to ${HAVE_LOG4CPP}.")
+  message(STATUS "LOG4CPP_LIBRARIES set to ${LOG4CPP_LIBRARIES}.")
+
+endfunction(GR_LOGGING)
+
+########################################################################
+# Run GRCC to compile .grc files into .py files.
+#
+# Usage: GRCC(filename, directory)
+#    - filenames: List of file name of .grc file
+#    - directory: directory of built .py file - usually in
+#                 ${CMAKE_CURRENT_BINARY_DIR}
+#    - Sets PYFILES: output converted GRC file names to Python files.
+########################################################################
+function(GRCC)
+  # Extract directory from list of args, remove it for the list of filenames.
+  list(GET ARGV -1 directory)
+  list(REMOVE_AT ARGV -1)
+  set(filenames ${ARGV})
+  file(MAKE_DIRECTORY ${directory})
+
+  SET(GRCC_COMMAND ${CMAKE_SOURCE_DIR}/gr-utils/python/grcc)
+
+  # GRCC uses some stuff in grc and gnuradio-runtime, so we force
+  # the known paths here
+  list(APPEND PYTHONPATHS
+    ${CMAKE_SOURCE_DIR}
+    ${CMAKE_SOURCE_DIR}/gnuradio-runtime/python
+    ${CMAKE_SOURCE_DIR}/gnuradio-runtime/lib/swig
+    ${CMAKE_BINARY_DIR}/gnuradio-runtime/lib/swig
+    )
+
+  if(WIN32)
+    #SWIG generates the python library files into a subdirectory.
+    #Therefore, we must append this subdirectory into PYTHONPATH.
+    #Only do this for the python directories matching the following:
+    foreach(pydir ${PYTHONPATHS})
+      get_filename_component(name ${pydir} NAME)
+      if(name MATCHES "^(swig|lib|src)$")
+        list(APPEND PYTHONPATHS ${pydir}/${CMAKE_BUILD_TYPE})
+      endif()
+    endforeach(pydir)
+  endif(WIN32)
+
+  file(TO_NATIVE_PATH "${PYTHONPATHS}" pypath)
+
+  if(UNIX)
+    list(APPEND pypath "$PYTHONPATH")
+    string(REPLACE ";" ":" pypath "${pypath}")
+    set(ENV{PYTHONPATH} ${pypath})
+  endif(UNIX)
+
+  if(WIN32)
+    list(APPEND pypath "%PYTHONPATH%")
+    string(REPLACE ";" "\\;" pypath "${pypath}")
+    #list(APPEND environs "PYTHONPATH=${pypath}")
+    set(ENV{PYTHONPATH} ${pypath})
+  endif(WIN32)
+
+  foreach(f ${filenames})
+    execute_process(
+      COMMAND ${GRCC_COMMAND} -d ${directory} ${f}
+      )
+    string(REPLACE ".grc" ".py" pyfile "${f}")
+    string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}" pyfile "${pyfile}")
+    list(APPEND pyfiles ${pyfile})
+  endforeach(f)
+
+  set(PYFILES ${pyfiles} PARENT_SCOPE)
+endfunction(GRCC)
+
+########################################################################
+# Check if HAVE_PTHREAD_SETSCHEDPARAM and HAVE_SCHED_SETSCHEDULER
+#  should be defined
+########################################################################
+macro(GR_CHECK_LINUX_SCHED_AVAIL)
+set(CMAKE_REQUIRED_LIBRARIES -lpthread)
+    CHECK_CXX_SOURCE_COMPILES("
+        #include <pthread.h>
+        int main(){
+            pthread_t pthread;
+            pthread_setschedparam(pthread,  0, 0);
+            return 0;
+        } " HAVE_PTHREAD_SETSCHEDPARAM
+    )
+    GR_ADD_COND_DEF(HAVE_PTHREAD_SETSCHEDPARAM)
+
+    CHECK_CXX_SOURCE_COMPILES("
+        #include <sched.h>
+        int main(){
+            pid_t pid;
+            sched_setscheduler(pid, 0, 0);
+            return 0;
+        } " HAVE_SCHED_SETSCHEDULER
+    )
+    GR_ADD_COND_DEF(HAVE_SCHED_SETSCHEDULER)
+endmacro(GR_CHECK_LINUX_SCHED_AVAIL)
+
+########################################################################
+# Macros to generate source and header files from template
+########################################################################
+macro(GR_EXPAND_X_H component root)
+
+  include(GrPython)
+
+  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
+"#!${PYTHON_EXECUTABLE}
+
+import sys, os, re
+sys.path.append('${GR_RUNTIME_PYTHONPATH}')
+os.environ['srcdir'] = '${CMAKE_CURRENT_SOURCE_DIR}'
+os.chdir('${CMAKE_CURRENT_BINARY_DIR}')
+
+if __name__ == '__main__':
+    import build_utils
+    root, inp = sys.argv[1:3]
+    for sig in sys.argv[3:]:
+        name = re.sub ('X+', sig, root)
+        d = build_utils.standard_dict2(name, sig, '${component}')
+        build_utils.expand_template(d, inp)
+")
+
+  #make a list of all the generated headers
+  unset(expanded_files_h)
+  foreach(sig ${ARGN})
+    string(REGEX REPLACE "X+" ${sig} name ${root})
+    list(APPEND expanded_files_h ${CMAKE_CURRENT_BINARY_DIR}/${name}.h)
+  endforeach(sig)
+  unset(name)
+
+  #create a command to generate the headers
+  add_custom_command(
+    OUTPUT ${expanded_files_h}
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.h.t
+    COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
+    ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
+    ${root} ${root}.h.t ${ARGN}
+  )
+
+  #install rules for the generated headers
+  list(APPEND generated_includes ${expanded_files_h})
+
+endmacro(GR_EXPAND_X_H)
+
+macro(GR_EXPAND_X_CC_H component root)
+
+  include(GrPython)
+
+  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
+"#!${PYTHON_EXECUTABLE}
+
+import sys, os, re
+sys.path.append('${GR_RUNTIME_PYTHONPATH}')
+os.environ['srcdir'] = '${CMAKE_CURRENT_SOURCE_DIR}'
+os.chdir('${CMAKE_CURRENT_BINARY_DIR}')
+
+if __name__ == '__main__':
+    import build_utils
+    root, inp = sys.argv[1:3]
+    for sig in sys.argv[3:]:
+        name = re.sub ('X+', sig, root)
+        d = build_utils.standard_impl_dict2(name, sig, '${component}')
+        build_utils.expand_template(d, inp)
+")
+
+  #make a list of all the generated files
+  unset(expanded_files_cc)
+  unset(expanded_files_h)
+  foreach(sig ${ARGN})
+    string(REGEX REPLACE "X+" ${sig} name ${root})
+    list(APPEND expanded_files_cc ${CMAKE_CURRENT_BINARY_DIR}/${name}.cc)
+    list(APPEND expanded_files_h  ${CMAKE_CURRENT_BINARY_DIR}/${name}.h)
+  endforeach(sig)
+  unset(name)
+
+  #create a command to generate the source files
+  add_custom_command(
+    OUTPUT ${expanded_files_cc}
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.cc.t
+    COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
+    ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
+    ${root} ${root}.cc.t ${ARGN}
+  )
+
+  #create a command to generate the header files
+  add_custom_command(
+    OUTPUT ${expanded_files_h}
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.h.t
+    COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
+    ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
+    ${root} ${root}.h.t ${ARGN}
+  )
+
+  #make source files depends on headers to force generation
+  set_source_files_properties(${expanded_files_cc}
+    PROPERTIES OBJECT_DEPENDS "${expanded_files_h}"
+  )
+
+  #install rules for the generated files
+  list(APPEND generated_sources ${expanded_files_cc})
+  list(APPEND generated_headers ${expanded_files_h})
+
+endmacro(GR_EXPAND_X_CC_H)
+
+macro(GR_EXPAND_X_CC_H_IMPL component root)
+
+  include(GrPython)
+
+  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
+"#!${PYTHON_EXECUTABLE}
+
+import sys, os, re
+sys.path.append('${GR_RUNTIME_PYTHONPATH}')
+os.environ['srcdir'] = '${CMAKE_CURRENT_SOURCE_DIR}'
+os.chdir('${CMAKE_CURRENT_BINARY_DIR}')
+
+if __name__ == '__main__':
+    import build_utils
+    root, inp = sys.argv[1:3]
+    for sig in sys.argv[3:]:
+        name = re.sub ('X+', sig, root)
+        d = build_utils.standard_dict(name, sig, '${component}')
+        build_utils.expand_template(d, inp, '_impl')
+")
+
+  #make a list of all the generated files
+  unset(expanded_files_cc_impl)
+  unset(expanded_files_h_impl)
+  unset(expanded_files_h)
+  foreach(sig ${ARGN})
+    string(REGEX REPLACE "X+" ${sig} name ${root})
+    list(APPEND expanded_files_cc_impl ${CMAKE_CURRENT_BINARY_DIR}/${name}_impl.cc)
+    list(APPEND expanded_files_h_impl ${CMAKE_CURRENT_BINARY_DIR}/${name}_impl.h)
+    list(APPEND expanded_files_h ${CMAKE_CURRENT_BINARY_DIR}/../include/gnuradio/${component}/${name}.h)
+  endforeach(sig)
+  unset(name)
+
+  #create a command to generate the _impl.cc files
+  add_custom_command(
+    OUTPUT ${expanded_files_cc_impl}
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}_impl.cc.t
+    COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
+    ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
+    ${root} ${root}_impl.cc.t ${ARGN}
+  )
+
+  #create a command to generate the _impl.h files
+  add_custom_command(
+    OUTPUT ${expanded_files_h_impl}
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}_impl.h.t
+    COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
+    ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
+    ${root} ${root}_impl.h.t ${ARGN}
+  )
+
+  #make _impl.cc source files depend on _impl.h to force generation
+  set_source_files_properties(${expanded_files_cc_impl}
+    PROPERTIES OBJECT_DEPENDS "${expanded_files_h_impl}"
+  )
+
+  #make _impl.h source files depend on headers to force generation
+  set_source_files_properties(${expanded_files_h_impl}
+    PROPERTIES OBJECT_DEPENDS "${expanded_files_h}"
+  )
+
+  #install rules for the generated files
+  list(APPEND generated_sources ${expanded_files_cc_impl})
+  list(APPEND generated_headers ${expanded_files_h_impl})
+
+endmacro(GR_EXPAND_X_CC_H_IMPL)
--- a/cmake/Modules/GrPython.cmake
+++ b/cmake/Modules/GrPython.cmake
@@ -36,11 +36,11 @@ if(PYTHON_EXECUTABLE)
 else(PYTHON_EXECUTABLE)

    #use the built-in find script
-    find_package(PythonInterp)
+    find_package(PythonInterp 2)

    #and if that fails use the find program routine
    if(NOT PYTHONINTERP_FOUND)
-        find_program(PYTHON_EXECUTABLE NAMES python python2.7 python2.6 python2.5)
+        find_program(PYTHON_EXECUTABLE NAMES python python2 python2.7 python2.6 python2.5)
        if(PYTHON_EXECUTABLE)
            set(PYTHONINTERP_FOUND TRUE)
        endif(PYTHON_EXECUTABLE)
@@ -48,8 +48,15 @@ else(PYTHON_EXECUTABLE)

 endif(PYTHON_EXECUTABLE)

+if (CMAKE_CROSSCOMPILING)
+    set(QA_PYTHON_EXECUTABLE "/usr/bin/python")
+else (CMAKE_CROSSCOMPILING)
+    set(QA_PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})
+endif(CMAKE_CROSSCOMPILING)
+
 #make the path to the executable appear in the cmake gui
 set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE} CACHE FILEPATH "python interpreter")
+set(QA_PYTHON_EXECUTABLE ${QA_PYTHON_EXECUTABLE} CACHE FILEPATH "python interpreter for QA tests")

 #make sure we can use -B with python (introduced in 2.6)
 if(PYTHON_EXECUTABLE)
@@ -96,11 +103,13 @@ endmacro(GR_PYTHON_CHECK_MODULE)
 ########################################################################
 # Sets the python installation directory GR_PYTHON_DIR
 ########################################################################
+if(NOT DEFINED GR_PYTHON_DIR)
 execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "
 from distutils import sysconfig
 print sysconfig.get_python_lib(plat_specific=True, prefix='')
 " OUTPUT_VARIABLE GR_PYTHON_DIR OUTPUT_STRIP_TRAILING_WHITESPACE
 )
+endif()
 file(TO_CMAKE_PATH ${GR_PYTHON_DIR} GR_PYTHON_DIR)

 ########################################################################
@@ -183,7 +192,7 @@ function(GR_PYTHON_INSTALL)
        file(TO_NATIVE_PATH ${PYTHON_EXECUTABLE} pyexe_native)

        if (CMAKE_CROSSCOMPILING)
-           set(pyexe_native /usr/bin/env python)
+           set(pyexe_native "/usr/bin/env python")
        endif()

        foreach(pyfile ${GR_PYTHON_INSTALL_PROGRAMS})
@@ -198,8 +207,9 @@ function(GR_PYTHON_INSTALL)
            add_custom_command(
                OUTPUT ${pyexefile} DEPENDS ${pyfile}
                COMMAND ${PYTHON_EXECUTABLE} -c
-                \"open('${pyexefile}', 'w').write('\#!${pyexe_native}\\n'+open('${pyfile}').read())\"
+                "open('${pyexefile}','w').write('\#!${pyexe_native}\\n'+open('${pyfile}').read())"
                COMMENT "Shebangin ${pyfile_name}"
+                VERBATIM
            )

            #on windows, python files need an extension to execute
--- a/cmake/Modules/GrSwig.cmake
+++ b/cmake/Modules/GrSwig.cmake
@@ -39,7 +39,7 @@ function(GR_SWIG_MAKE_DOCS output_file)
        set(input_files)
        unset(INPUT_PATHS)
        foreach(input_path ${ARGN})
-            if (IS_DIRECTORY ${input_path}) #when input path is a directory
+            if(IS_DIRECTORY ${input_path}) #when input path is a directory
                file(GLOB input_path_h_files ${input_path}/*.h)
            else() #otherwise its just a file, no glob
                set(input_path_h_files ${input_path})
@@ -105,23 +105,35 @@ endfunction(GR_SWIG_MAKE_DOCS)
 macro(GR_SWIG_MAKE name)
    set(ifiles ${ARGN})

-    list(APPEND GR_SWIG_TARGET_DEPS ${GR_SWIG_LIBRARIES})
+    # Shimming this in here to take care of a SWIG bug with handling
+    # vector<size_t> and vector<unsigned int> (on 32-bit machines) and
+    # vector<long unsigned int> (on 64-bit machines). Use this to test
+    # the size of size_t, then set SIZE_T_32 if it's a 32-bit machine
+    # or not if it's 64-bit. The logic in gr_type.i handles the rest.
+    INCLUDE(CheckTypeSize)
+    CHECK_TYPE_SIZE("size_t" SIZEOF_SIZE_T)
+    CHECK_TYPE_SIZE("unsigned int" SIZEOF_UINT)
+    if(${SIZEOF_SIZE_T} EQUAL ${SIZEOF_UINT})
+      list(APPEND GR_SWIG_FLAGS -DSIZE_T_32)
+    endif(${SIZEOF_SIZE_T} EQUAL ${SIZEOF_UINT})

    #do swig doc generation if specified
-    if (GR_SWIG_DOC_FILE)
+    if(GR_SWIG_DOC_FILE)
        set(GR_SWIG_DOCS_SOURCE_DEPS ${GR_SWIG_SOURCE_DEPS})
-        set(GR_SWIG_DOCS_TAREGT_DEPS ${GR_SWIG_TARGET_DEPS})
+        list(APPEND GR_SWIG_DOCS_TARGET_DEPS ${GR_SWIG_TARGET_DEPS})
        GR_SWIG_MAKE_DOCS(${GR_SWIG_DOC_FILE} ${GR_SWIG_DOC_DIRS})
        add_custom_target(${name}_swig_doc DEPENDS ${GR_SWIG_DOC_FILE})
-        list(APPEND GR_SWIG_TARGET_DEPS ${name}_swig_doc)
+        list(APPEND GR_SWIG_TARGET_DEPS ${name}_swig_doc ${GR_RUNTIME_SWIG_DOC_FILE})
    endif()

    #append additional include directories
-    find_package(PythonLibs)
+    find_package(PythonLibs 2)
    list(APPEND GR_SWIG_INCLUDE_DIRS ${PYTHON_INCLUDE_PATH}) #deprecated name (now dirs)
    list(APPEND GR_SWIG_INCLUDE_DIRS ${PYTHON_INCLUDE_DIRS})
-    list(APPEND GR_SWIG_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR})
-    list(APPEND GR_SWIG_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
+
+    #prepend local swig directories
+    list(INSERT GR_SWIG_INCLUDE_DIRS 0 ${CMAKE_CURRENT_SOURCE_DIR})
+    list(INSERT GR_SWIG_INCLUDE_DIRS 0 ${CMAKE_CURRENT_BINARY_DIR})

    #determine include dependencies for swig file
    execute_process(
@@ -160,6 +172,9 @@ macro(GR_SWIG_MAKE name)
    include(UseSWIG)
    SWIG_ADD_MODULE(${name} python ${ifiles})
    SWIG_LINK_LIBRARIES(${name} ${PYTHON_LIBRARIES} ${GR_SWIG_LIBRARIES})
+    if(${name} STREQUAL "runtime_swig")
+        SET_TARGET_PROPERTIES(${SWIG_MODULE_runtime_swig_REAL_NAME} PROPERTIES DEFINE_SYMBOL "gnuradio_runtime_EXPORTS")
+    endif(${name} STREQUAL "runtime_swig")

 endmacro(GR_SWIG_MAKE)

@@ -207,21 +222,25 @@ file(WRITE ${CMAKE_BINARY_DIR}/get_swig_deps.py "

 import os, sys, re

-include_matcher = re.compile('[#|%]include\\s*[<|\"](.*)[>|\"]')
+i_include_matcher = re.compile('%(include|import)\\s*[<|\"](.*)[>|\"]')
+h_include_matcher = re.compile('#(include)\\s*[<|\"](.*)[>|\"]')
 include_dirs = sys.argv[2].split(';')

 def get_swig_incs(file_path):
+    if file_path.endswith('.i'): matcher = i_include_matcher
+    else: matcher = h_include_matcher
    file_contents = open(file_path, 'r').read()
-    return include_matcher.findall(file_contents, re.MULTILINE)
+    return matcher.findall(file_contents, re.MULTILINE)

 def get_swig_deps(file_path, level):
    deps = [file_path]
    if level == 0: return deps
-    for inc_file in get_swig_incs(file_path):
+    for keyword, inc_file in get_swig_incs(file_path):
        for inc_dir in include_dirs:
            inc_path = os.path.join(inc_dir, inc_file)
            if not os.path.exists(inc_path): continue
            deps.extend(get_swig_deps(inc_path, level-1))
+            break #found, we dont search in lower prio inc dirs
    return deps

 if __name__ == '__main__':
--- a/cmake/Modules/GrTest.cmake
+++ b/cmake/Modules/GrTest.cmake
@@ -30,6 +30,7 @@ set(__INCLUDED_GR_TEST_CMAKE TRUE)
 # GR_TEST_TARGET_DEPS  - built targets for the library path
 # GR_TEST_LIBRARY_DIRS - directories for the library path
 # GR_TEST_PYTHON_DIRS  - directories for the python path
+# GR_TEST_ENVIRONS  - other environment key/value pairs
 ########################################################################
 function(GR_ADD_TEST test_name)

@@ -65,7 +66,8 @@ function(GR_ADD_TEST test_name)
    file(TO_NATIVE_PATH "${GR_TEST_LIBRARY_DIRS}" libpath) #ok to use on dir list?
    file(TO_NATIVE_PATH "${GR_TEST_PYTHON_DIRS}" pypath) #ok to use on dir list?

-    set(environs "GR_DONT_LOAD_PREFS=1" "srcdir=${srcdir}")
+    set(environs "VOLK_GENERIC=1" "GR_DONT_LOAD_PREFS=1" "srcdir=${srcdir}")
+    list(APPEND environs ${GR_TEST_ENVIRONS})

    #http://www.cmake.org/pipermail/cmake/2009-May/029464.html
    #Replaced this add test + set environs code with the shell script generation.
@@ -89,7 +91,11 @@ function(GR_ADD_TEST test_name)
        list(APPEND environs "PATH=${binpath}" "${LD_PATH_VAR}=${libpath}" "PYTHONPATH=${pypath}")

        #generate a bat file that sets the environment and runs the test
-        find_program(SHELL sh)
+	if (CMAKE_CROSSCOMPILING)
+                set(SHELL "/bin/sh")
+        else(CMAKE_CROSSCOMPILING)
+                find_program(SHELL sh)
+        endif(CMAKE_CROSSCOMPILING)
        set(sh_file ${CMAKE_CURRENT_BINARY_DIR}/${test_name}_test.sh)
        file(WRITE ${sh_file} "#!${SHELL}\n")
        #each line sets an environment variable
--- a/cmake/Modules/UseSWIG.cmake
+++ b/cmake/Modules/UseSWIG.cmake
@@ -0,0 +1,304 @@
+# - SWIG module for CMake
+# Defines the following macros:
+#   SWIG_ADD_MODULE(name language [ files ])
+#     - Define swig module with given name and specified language
+#   SWIG_LINK_LIBRARIES(name [ libraries ])
+#     - Link libraries to swig module
+# All other macros are for internal use only.
+# To get the actual name of the swig module,
+# use: ${SWIG_MODULE_${name}_REAL_NAME}.
+# Set Source files properties such as CPLUSPLUS and SWIG_FLAGS to specify
+# special behavior of SWIG. Also global CMAKE_SWIG_FLAGS can be used to add
+# special flags to all swig calls.
+# Another special variable is CMAKE_SWIG_OUTDIR, it allows one to specify
+# where to write all the swig generated module (swig -outdir option)
+# The name-specific variable SWIG_MODULE_<name>_EXTRA_DEPS may be used
+# to specify extra dependencies for the generated modules.
+# If the source file generated by swig need some special flag you can use
+# set_source_files_properties( ${swig_generated_file_fullname}
+#        PROPERTIES COMPILE_FLAGS "-bla")
+
+
+#=============================================================================
+# Copyright 2004-2009 Kitware, Inc.
+# Copyright 2009 Mathieu Malaterre <mathieu.malaterre@gmail.com>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+set(SWIG_CXX_EXTENSION "cxx")
+set(SWIG_EXTRA_LIBRARIES "")
+
+set(SWIG_PYTHON_EXTRA_FILE_EXTENSION "py")
+
+#
+# For given swig module initialize variables associated with it
+#
+macro(SWIG_MODULE_INITIALIZE name language)
+  string(TOUPPER "${language}" swig_uppercase_language)
+  string(TOLOWER "${language}" swig_lowercase_language)
+  set(SWIG_MODULE_${name}_LANGUAGE "${swig_uppercase_language}")
+  set(SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG "${swig_lowercase_language}")
+
+  set(SWIG_MODULE_${name}_REAL_NAME "${name}")
+  if("${SWIG_MODULE_${name}_LANGUAGE}" STREQUAL "UNKNOWN")
+    message(FATAL_ERROR "SWIG Error: Language \"${language}\" not found")
+  elseif("${SWIG_MODULE_${name}_LANGUAGE}" STREQUAL "PYTHON")
+    # when swig is used without the -interface it will produce in the module.py
+    # a 'import _modulename' statement, which implies having a corresponding
+    # _modulename.so (*NIX), _modulename.pyd (Win32).
+    set(SWIG_MODULE_${name}_REAL_NAME "_${name}")
+  elseif("${SWIG_MODULE_${name}_LANGUAGE}" STREQUAL "PERL")
+    set(SWIG_MODULE_${name}_EXTRA_FLAGS "-shadow")
+  endif()
+endmacro()
+
+#
+# For a given language, input file, and output file, determine extra files that
+# will be generated. This is internal swig macro.
+#
+
+macro(SWIG_GET_EXTRA_OUTPUT_FILES language outfiles generatedpath infile)
+  set(${outfiles} "")
+  get_source_file_property(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename
+    ${infile} SWIG_MODULE_NAME)
+  if(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename STREQUAL "NOTFOUND")
+    get_filename_component(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename "${infile}" NAME_WE)
+  endif()
+  foreach(it ${SWIG_${language}_EXTRA_FILE_EXTENSION})
+    set(${outfiles} ${${outfiles}}
+      "${generatedpath}/${SWIG_GET_EXTRA_OUTPUT_FILES_module_basename}.${it}")
+  endforeach()
+endmacro()
+
+#
+# Take swig (*.i) file and add proper custom commands for it
+#
+macro(SWIG_ADD_SOURCE_TO_MODULE name outfiles infile)
+  set(swig_full_infile ${infile})
+  get_filename_component(swig_source_file_path "${infile}" PATH)
+  get_filename_component(swig_source_file_name_we "${infile}" NAME_WE)
+  get_source_file_property(swig_source_file_generated ${infile} GENERATED)
+  get_source_file_property(swig_source_file_cplusplus ${infile} CPLUSPLUS)
+  get_source_file_property(swig_source_file_flags ${infile} SWIG_FLAGS)
+  if("${swig_source_file_flags}" STREQUAL "NOTFOUND")
+    set(swig_source_file_flags "")
+  endif()
+  set(swig_source_file_fullname "${infile}")
+  if(${swig_source_file_path} MATCHES "^${CMAKE_CURRENT_SOURCE_DIR}")
+    string(REGEX REPLACE
+      "^${CMAKE_CURRENT_SOURCE_DIR}" ""
+      swig_source_file_relative_path
+      "${swig_source_file_path}")
+  else()
+    if(${swig_source_file_path} MATCHES "^${CMAKE_CURRENT_BINARY_DIR}")
+      string(REGEX REPLACE
+        "^${CMAKE_CURRENT_BINARY_DIR}" ""
+        swig_source_file_relative_path
+        "${swig_source_file_path}")
+      set(swig_source_file_generated 1)
+    else()
+      set(swig_source_file_relative_path "${swig_source_file_path}")
+      if(swig_source_file_generated)
+        set(swig_source_file_fullname "${CMAKE_CURRENT_BINARY_DIR}/${infile}")
+      else()
+        set(swig_source_file_fullname "${CMAKE_CURRENT_SOURCE_DIR}/${infile}")
+      endif()
+    endif()
+  endif()
+
+  set(swig_generated_file_fullname
+    "${CMAKE_CURRENT_BINARY_DIR}")
+  if(swig_source_file_relative_path)
+    set(swig_generated_file_fullname
+      "${swig_generated_file_fullname}/${swig_source_file_relative_path}")
+  endif()
+  # If CMAKE_SWIG_OUTDIR was specified then pass it to -outdir
+  if(CMAKE_SWIG_OUTDIR)
+    set(swig_outdir ${CMAKE_SWIG_OUTDIR})
+  else()
+    set(swig_outdir ${CMAKE_CURRENT_BINARY_DIR})
+  endif()
+  SWIG_GET_EXTRA_OUTPUT_FILES(${SWIG_MODULE_${name}_LANGUAGE}
+    swig_extra_generated_files
+    "${swig_outdir}"
+    "${infile}")
+  set(swig_generated_file_fullname
+    "${swig_generated_file_fullname}/${swig_source_file_name_we}")
+  # add the language into the name of the file (i.e. TCL_wrap)
+  # this allows for the same .i file to be wrapped into different languages
+  set(swig_generated_file_fullname
+    "${swig_generated_file_fullname}${SWIG_MODULE_${name}_LANGUAGE}_wrap")
+
+  if(swig_source_file_cplusplus)
+    set(swig_generated_file_fullname
+      "${swig_generated_file_fullname}.${SWIG_CXX_EXTENSION}")
+  else()
+    set(swig_generated_file_fullname
+      "${swig_generated_file_fullname}.c")
+  endif()
+
+  # Shut up some warnings from poor SWIG code generation that we
+  # can do nothing about, when this flag is available
+  include(CheckCXXCompilerFlag)
+  check_cxx_compiler_flag("-Wno-unused-but-set-variable" HAVE_WNO_UNUSED_BUT_SET_VARIABLE)
+  if(HAVE_WNO_UNUSED_BUT_SET_VARIABLE)
+    set_source_files_properties(${swig_generated_file_fullname}
+      PROPERTIES COMPILE_FLAGS "-Wno-unused-but-set-variable")
+  endif(HAVE_WNO_UNUSED_BUT_SET_VARIABLE)
+
+  get_directory_property(cmake_include_directories INCLUDE_DIRECTORIES)
+  set(swig_include_dirs)
+  foreach(it ${cmake_include_directories})
+    set(swig_include_dirs ${swig_include_dirs} "-I${it}")
+  endforeach()
+
+  set(swig_special_flags)
+  # default is c, so add c++ flag if it is c++
+  if(swig_source_file_cplusplus)
+    set(swig_special_flags ${swig_special_flags} "-c++")
+  endif()
+  set(swig_extra_flags)
+  if(SWIG_MODULE_${name}_EXTRA_FLAGS)
+    set(swig_extra_flags ${swig_extra_flags} ${SWIG_MODULE_${name}_EXTRA_FLAGS})
+  endif()
+
+  # hack to work around CMake bug in add_custom_command with multiple OUTPUT files
+
+  file(RELATIVE_PATH reldir ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR})
+  execute_process(
+    COMMAND ${PYTHON_EXECUTABLE} -c "import re, hashlib
+unique = hashlib.md5('${reldir}${ARGN}').hexdigest()[:5]
+print(re.sub('\\W', '_', '${name} ${reldir} ' + unique))"
+    OUTPUT_VARIABLE _target OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+
+  file(
+    WRITE ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp.in
+   "int main(void){return 0;}\n"
+  )
+
+  # create dummy dependencies
+  add_custom_command(
+    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp
+    COMMAND ${CMAKE_COMMAND} -E copy
+        ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp.in
+        ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp
+    DEPENDS "${swig_source_file_fullname}" ${SWIG_MODULE_${name}_EXTRA_DEPS}
+    COMMENT ""
+  )
+
+  # create the dummy target
+  add_executable(${_target} ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp)
+
+  # add a custom command to the dummy target
+  add_custom_command(
+    TARGET ${_target}
+    # Let's create the ${swig_outdir} at execution time, in case dir contains $(OutDir)
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${swig_outdir}
+    COMMAND "${SWIG_EXECUTABLE}"
+    ARGS "-${SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG}"
+    ${swig_source_file_flags}
+    ${CMAKE_SWIG_FLAGS}
+    -outdir ${swig_outdir}
+    ${swig_special_flags}
+    ${swig_extra_flags}
+    ${swig_include_dirs}
+    -o "${swig_generated_file_fullname}"
+    "${swig_source_file_fullname}"
+    COMMENT "Swig source"
+  )
+
+  #add dummy independent dependencies from the _target to each file
+  #that will be generated by the SWIG command above
+
+  set(${outfiles} "${swig_generated_file_fullname}" ${swig_extra_generated_files})
+
+  foreach(swig_gen_file ${${outfiles}})
+    add_custom_command(
+      OUTPUT ${swig_gen_file}
+      COMMAND ""
+      DEPENDS ${_target}
+      COMMENT ""
+    )
+  endforeach()
+
+  set_source_files_properties(
+    ${outfiles} PROPERTIES GENERATED 1
+  )
+
+endmacro()
+
+#
+# Create Swig module
+#
+macro(SWIG_ADD_MODULE name language)
+  SWIG_MODULE_INITIALIZE(${name} ${language})
+  set(swig_dot_i_sources)
+  set(swig_other_sources)
+  foreach(it ${ARGN})
+    if(${it} MATCHES ".*\\.i$")
+      set(swig_dot_i_sources ${swig_dot_i_sources} "${it}")
+    else()
+      set(swig_other_sources ${swig_other_sources} "${it}")
+    endif()
+  endforeach()
+
+  set(swig_generated_sources)
+  foreach(it ${swig_dot_i_sources})
+    SWIG_ADD_SOURCE_TO_MODULE(${name} swig_generated_source ${it})
+    set(swig_generated_sources ${swig_generated_sources} "${swig_generated_source}")
+  endforeach()
+  get_directory_property(swig_extra_clean_files ADDITIONAL_MAKE_CLEAN_FILES)
+  set_directory_properties(PROPERTIES
+    ADDITIONAL_MAKE_CLEAN_FILES "${swig_extra_clean_files};${swig_generated_sources}")
+  add_library(${SWIG_MODULE_${name}_REAL_NAME}
+    MODULE
+    ${swig_generated_sources}
+    ${swig_other_sources})
+  string(TOLOWER "${language}" swig_lowercase_language)
+  if ("${swig_lowercase_language}" STREQUAL "java")
+    if (APPLE)
+        # In java you want:
+        #      System.loadLibrary("LIBRARY");
+        # then JNI will look for a library whose name is platform dependent, namely
+        #   MacOS  : libLIBRARY.jnilib
+        #   Windows: LIBRARY.dll
+        #   Linux  : libLIBRARY.so
+        set_target_properties (${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES SUFFIX ".jnilib")
+      endif ()
+  endif ()
+  if ("${swig_lowercase_language}" STREQUAL "python")
+    # this is only needed for the python case where a _modulename.so is generated
+    set_target_properties(${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES PREFIX "")
+    # Python extension modules on Windows must have the extension ".pyd"
+    # instead of ".dll" as of Python 2.5.  Older python versions do support
+    # this suffix.
+    # http://docs.python.org/whatsnew/ports.html#SECTION0001510000000000000000
+    # <quote>
+    # Windows: .dll is no longer supported as a filename extension for extension modules.
+    # .pyd is now the only filename extension that will be searched for.
+    # </quote>
+    if(WIN32 AND NOT CYGWIN)
+      set_target_properties(${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES SUFFIX ".pyd")
+    endif()
+  endif ()
+endmacro()
+
+#
+# Like TARGET_LINK_LIBRARIES but for swig modules
+#
+macro(SWIG_LINK_LIBRARIES name)
+  if(SWIG_MODULE_${name}_REAL_NAME)
+    target_link_libraries(${SWIG_MODULE_${name}_REAL_NAME} ${ARGN})
+  else()
+    message(SEND_ERROR "Cannot find Swig library \"${name}\".")
+  endif()
+endmacro()
--- a/docs/doxygen/Doxyfile.in
+++ b/docs/doxygen/Doxyfile.in
@@ -261,22 +261,6 @@ SUBGROUPING            = YES

 TYPEDEF_HIDES_STRUCT   = NO

-# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to 
-# determine which symbols to keep in memory and which to flush to disk.
-# When the cache is full, less often used symbols will be written to disk.
-# For small to medium size projects (<1000 input files) the default value is 
-# probably good enough. For larger projects a too small cache size can cause 
-# doxygen to be busy swapping symbols to and from disk most of the time 
-# causing a significant performance penality. 
-# If the system has enough physical memory increasing the cache will improve the 
-# performance by keeping more symbols in memory. Note that the value works on 
-# a logarithmic scale so increasing the size by one will rougly double the 
-# memory usage. The cache size is given by this formula: 
-# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, 
-# corresponding to a cache size of 2^16 = 65536 symbols
-
-SYMBOL_CACHE_SIZE      = 4
-
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
@@ -455,12 +439,6 @@ MAX_INITIALIZER_LINES  = 30

 SHOW_USED_FILES        = YES

-# If the sources in your project are distributed over multiple directories 
-# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy 
-# in the documentation. The default is NO.
-
-SHOW_DIRECTORIES       = NO
-
 # Set the SHOW_FILES tag to NO to disable the generation of the Files page.
 # This will remove the Files entry from the Quick Index and from the 
 # Folder Tree View (if specified). The default is YES.
@@ -807,12 +785,6 @@ HTML_FOOTER            =

 HTML_STYLESHEET        = 

-# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
-# files or namespaces will be aligned in HTML using tables. If set to 
-# NO a bullet list will be used.
-
-HTML_ALIGN_MEMBERS     = YES
-
 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML 
 # documentation will contain sections that can be hidden and shown after the 
 # page has loaded. For this to work a browser that supports 
@@ -1127,18 +1099,6 @@ GENERATE_XML           = @enable_xml_docs@

 XML_OUTPUT             = xml

-# The XML_SCHEMA tag can be used to specify an XML schema, 
-# which can be used by a validating XML parser to check the 
-# syntax of the XML files.
-
-XML_SCHEMA             = 
-
-# The XML_DTD tag can be used to specify an XML DTD, 
-# which can be used by a validating XML parser to check the 
-# syntax of the XML files.
-
-XML_DTD                = 
-
 # If the XML_PROGRAMLISTING tag is set to YES Doxygen will 
 # dump the program listings (including syntax highlighting 
 # and cross-referencing information) to the XML output. Note that 
@@ -1344,7 +1304,7 @@ HAVE_DOT               = @HAVE_DOT@
 # DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory 
 # containing the font.

-DOT_FONTNAME           = FreeSans
+#DOT_FONTNAME           = FreeSans

 # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. 
 # The default size is 10pt.
--- a/include/gr_air_modes/preamble.h
+++ b/include/gr_air_modes/preamble.h
@@ -37,11 +37,11 @@ class AIR_MODES_API preamble : virtual public gr::block
 {
 public:
    typedef boost::shared_ptr<preamble> sptr;
-    static sptr make(float channel_rate, float threshold_db);
+    static sptr make(int channel_rate, float threshold_db);

-    virtual void set_rate(float channel_rate) = 0;
+    virtual void set_rate(int channel_rate) = 0;
    virtual void set_threshold(float threshold_db) = 0;
-    virtual float get_rate(void) = 0;
+    virtual int get_rate(void) = 0;
    virtual float get_threshold(void) = 0;
 };

--- a/lib/preamble_impl.cc
+++ b/lib/preamble_impl.cc
@@ -34,11 +34,11 @@

 namespace gr {

-air_modes::preamble::sptr air_modes::preamble::make(float channel_rate, float threshold_db) {
+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(float channel_rate, float 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
@@ -53,11 +53,11 @@ air_modes::preamble_impl::preamble_impl(float channel_rate, float threshold_db)
    d_key = pmt::string_to_symbol("preamble_found");
 }

-void air_modes::preamble_impl::set_rate(float channel_rate) {
+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_sample_rate = channel_rate;
+    d_secs_per_sample = 1.0/channel_rate;
    set_output_multiple(1+d_check_width*2);
    set_history(d_samples_per_symbol);
 }
@@ -71,8 +71,8 @@ float air_modes::preamble_impl::get_threshold(void) {
    return d_threshold_db;
 }

-float air_modes::preamble_impl::get_rate(void) {
-    return d_sample_rate;
+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) {
@@ -97,42 +97,19 @@ static double correlate_preamble(const float *in, int samples_per_chip) {
    return corr;
 }

-static pmt::pmt_t tag_to_timestamp(gr::tag_t tstamp, uint64_t abs_sample_cnt, int rate) {
-    uint64_t last_whole_stamp;
+//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;
-    pmt::pmt_t tstime = pmt::make_tuple(pmt::from_uint64(0), pmt::from_double(0));
-    if(tstamp.key == NULL 
-    || !pmt::is_symbol(tstamp.key) 
-    || pmt::symbol_to_string(tstamp.key) != "rx_time") {
-        last_whole_stamp = 0;
-        last_frac_stamp = 0;
-    } else {
-        last_whole_stamp = pmt::to_uint64(pmt::tuple_ref(tstamp.value, 0));
-        last_frac_stamp = pmt::to_double(pmt::tuple_ref(tstamp.value, 1));
-    }

-    //the timestamp tag has tstamp.offset, the sample index of the timestamp tag
-    //also tstamp.value, a pmt pair with (uint64, double) representing int and
-    //fractional timestamp, respectively.
-    //this function also gets an abs_sample_cnt which represents the sample count to
-    //find a timestamp for. sps is obviously samples per second.
-    //
-    //so (abs_sample_cnt - tstamp.offset) is the delay we apply to the tag
-    //   int((abs_sample_cnt - tstamp.offset)/sps) is the integer offset
-    //   (abs_sample_cnt - tstamp.offset)/sps is the fractional offset
+    if(tstamp.key == NULL || pmt::symbol_to_string(tstamp.key) != "rx_time") return 0;

-    uint64_t int_offset = (abs_sample_cnt - tstamp.offset)/rate;
-    double frac_offset = ((abs_sample_cnt - tstamp.offset) % rate) / double(rate);
-
-    uint64_t abs_whole = last_whole_stamp + int_offset;
-    double abs_frac = last_frac_stamp + frac_offset;
-    if(abs_frac > 1.0f) {
-        abs_frac -= 1.0f;
-        abs_whole += 1;
-    }
-
-    tstime = pmt::make_tuple(pmt::from_uint64(abs_whole), pmt::from_double(abs_frac));
+    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;
 }

@@ -147,7 +124,7 @@ int air_modes::preamble_impl::general_work(int noutput_items,
    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 % int(d_samples_per_chip)) - int(d_samples_per_chip), 0);
+    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];
@@ -217,20 +194,22 @@ int air_modes::preamble_impl::general_work(int noutput_items,

            //all right i'm prepared to call this a preamble
            for(int j=0; j<240; j++) {
-                out[j] = in[i+int(j*d_samples_per_chip)] - inavg[i];
+                out[j] = in[i+j*d_samples_per_chip] - inavg[i];
            }

            //get the timestamp of the preamble
-            pmt::pmt_t tstamp = tag_to_timestamp(d_timestamp, abs_sample_cnt + i, d_sample_rate);
+            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
-                     tstamp,
+                     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;

--- a/lib/preamble_impl.h
+++ b/lib/preamble_impl.h
@@ -15,26 +15,26 @@ private:
    int d_check_width;
    int d_chip_rate;
    float d_preamble_length_us;
-    float d_samples_per_chip;
-    float d_samples_per_symbol;
+    int d_samples_per_chip;
+    int d_samples_per_symbol;
    float d_threshold_db;
    float d_threshold;
-    gr::tag_t d_timestamp;
    pmt::pmt_t d_me, d_key;
-    int d_sample_rate;
+    gr::tag_t d_timestamp;
+    double d_secs_per_sample;

 public:
-    preamble_impl(float channel_rate, float threshold_db);
+    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(float channel_rate);
+    void set_rate(int channel_rate);
    void set_threshold(float threshold_db);
    float get_threshold(void);
-    float get_rate(void);
+    int get_rate(void);
 };

 } //namespace air_modes
--- a/lib/slicer_impl.cc
+++ b/lib/slicer_impl.cc
@@ -158,6 +158,8 @@ int air_modes::slicer_impl::work(int noutput_items,
            }
        }

+        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++) {
@@ -181,15 +183,13 @@ int air_modes::slicer_impl::work(int noutput_items,
        //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;}

-        pmt::pmt_t tstamp = tag_iter->value;
-
        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
-                  << " " << pmt::to_uint64(pmt::tuple_ref(tstamp, 0)) << " " << std::setprecision(10) << pmt::to_double(pmt::tuple_ref(tstamp, 1));
+                  << " " << 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);
    }
--- a/lib/slicer_impl.h
+++ b/lib/slicer_impl.h
@@ -38,7 +38,6 @@ private:
    int d_chip_rate;
    int d_samples_per_chip;
    int d_samples_per_symbol;
-    gr::tag_t d_timestamp;
    gr::msg_queue::sptr d_queue;
    std::ostringstream d_payload;

--- a/python/init.py
+++ b/python/init.py
@@ -67,6 +67,7 @@ from kml import output_kml, output_jsonp
 from raw_server import raw_server
 from radio import modes_radio
 from exceptions import *
+from az_map import *
 from types import *
 from altitude import *
 from cpr import cpr_decoder
--- a/python/html_template.py
+++ b/python/html_template.py
@@ -2,7 +2,7 @@
 #HTML template for Mode S map display
 #Nick Foster, 2013

-def html_template(my_apikey, my_position, json_file):
+def html_template(my_position, json_file):
    if my_position is None:
        my_position = [37, -122]

@@ -25,9 +25,9 @@ def html_template(my_apikey, my_position, json_file):
                white-space: nowrap;
            }
        </style>
-        <script type="text/javascript" src="http://maps.google.com/maps/api/js?key=%s">
+        <script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false">
        </script>
-        <script type="text/javascript" src="https://raw.githubusercontent.com/googlemaps/v3-utility-library/master/markerwithlabel/src/markerwithlabel.js">
+        <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;
@@ -152,4 +152,4 @@ def html_template(my_apikey, my_position, json_file):
        <div id="map_canvas" style="width:100%%; height:100%%">
        </div>
    </body>
-</html>""" % (my_apikey, my_position[0], my_position[1], json_file)
+</html>""" % (my_position[0], my_position[1], json_file)
--- a/python/parse.py
+++ b/python/parse.py
@@ -335,13 +335,13 @@ def parseBDS09_1(data):
  ew = bool(data["dew"])
  subtype = data["sub"]
  if subtype == 0x02:
-    ns_vel *= 4
-    ew_vel *= 4
+    ns_vel <<= 2
+    ew_vel <<= 2

  velocity = math.hypot(ns_vel, ew_vel)
  if ew:
    ew_vel = 0 - ew_vel
-
+	
  if ns_vel == 0:
    heading = 0
  else:
@@ -423,12 +423,12 @@ def parse_TCAS_CRM(data):
 def make_parser(pub):
  publisher = pub
  def publish(message):
-    [data, ecc, reference, int_timestamp, frac_timestamp] = message.split()
+    [data, ecc, reference, timestamp] = message.split()
    try:
      ret = air_modes.modes_report(modes_reply(int(data, 16)),
                                   int(ecc, 16),
                                   10.0*math.log10(max(1e-8,float(reference))),
-                                   air_modes.stamp(int(int_timestamp), float(frac_timestamp)))
+                                   air_modes.stamp(0, float(timestamp)))
      pub["modes_dl"] = ret
      pub["type%i_dl" % ret.data.get_type()] = ret
    except ADSBError:
--- a/python/radio.py
+++ b/python/radio.py
@@ -219,7 +219,7 @@ class modes_radio (gr.top_block, pubsub):
          ip, port = re.search("(.*)\:(\d{1,5})", options.source).groups()
        except:
          raise Exception("Please input UDP source e.g. 192.168.10.1:12345")
-        self._u = blocks.udp_source(gr.sizeof_gr_complex, ip, int(port))
+        self._u = gr.udp_source(gr.sizeof_gr_complex, ip, int(port))
        print "Using UDP source %s:%s" % (ip, port)
      else:
        self._u = blocks.file_source(gr.sizeof_gr_complex, options.source)
--- a/python/rx_path.py
+++ b/python/rx_path.py
@@ -83,6 +83,6 @@ class rx_path(gr.hier_block2):
    def get_pmf(self, pmf):
        return not (self._bb == self._demod)

-    def get_threshold(self):
+    def get_threshold(self, threshold):
        return self._sync.get_threshold()

--- a/python/sbs1.py
+++ b/python/sbs1.py
@@ -83,7 +83,7 @@ class output_sbs1:
    # dictionary is getting too large.
    if len(self._aircraft_id_map) > 1e4:
      minimum = min(self._aircraft_id_map.values()) + (len(self._aircraft_id_map) - 1e4)
-      for icao, _id in dict(self._aircraft_id_map).iteritems():
+      for icao, _id in self._aircraft_id_map.iteritems():
        if _id < minimum:
            del self._aircraft_id_map[icao]

--- a/res/modes_rx.ui
+++ b/res/modes_rx.ui
@@ -6,8 +6,8 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>719</width>
-    <height>454</height>
+    <width>687</width>
+    <height>422</height>
   </rect>
  </property>
  <property name="sizePolicy">
@@ -102,8 +102,8 @@
             <rect>
              <x>10</x>
              <y>20</y>
-              <width>241</width>
-              <height>281</height>
+              <width>236</width>
+              <height>251</height>
             </rect>
            </property>
            <property name="title">
@@ -307,7 +307,7 @@
             <property name="geometry">
              <rect>
               <x>10</x>
-               <y>190</y>
+               <y>200</y>
               <width>221</width>
               <height>22</height>
              </rect>
@@ -320,7 +320,7 @@
             <property name="geometry">
              <rect>
               <x>10</x>
-               <y>210</y>
+               <y>220</y>
               <width>221</width>
               <height>22</height>
              </rect>
@@ -329,16 +329,6 @@
              <string>Use DC blocking filter</string>
             </property>
            </widget>
-            <widget class="QLineEdit" name="line_my_api_key">
-             <property name="geometry">
-              <rect>
-               <x>90</x>
-               <y>250</y>
-               <width>121</width>
-               <height>27</height>
-              </rect>
-             </property>
-            </widget>
           </widget>
           <widget class="QGroupBox" name="group_output">
            <property name="geometry">
@@ -559,19 +549,6 @@
             </property>
            </widget>
           </widget>
-           <widget class="QLabel" name="label_34">
-            <property name="geometry">
-             <rect>
-              <x>20</x>
-              <y>270</y>
-              <width>67</width>
-              <height>17</height>
-             </rect>
-            </property>
-            <property name="text">
-             <string>API Key</string>
-            </property>
-           </widget>
          </widget>
          <widget class="QWidget" name="dashboard">
           <attribute name="title">
@@ -1054,7 +1031,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-     <width>719</width>
+     <width>687</width>
     <height>25</height>
    </rect>
   </property>
--- a/swig/CMakeLists.txt
+++ b/swig/CMakeLists.txt
@@ -39,7 +39,7 @@ set(GR_SWIG_LIBRARIES air_modes)
 #set(GR_SWIG_DOC_FILE ${CMAKE_CURRENT_BINARY_DIR}/gr-air-modes_swig_doc.i)
 #set(GR_SWIG_DOC_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../include)

-GR_SWIG_MAKE(air_modes_swig air_modes_swig.i)
+GR_SWIG_MAKE(air_modes_swig air_modes.i)

 ########################################################################
 # Install the build swig module
--- a/swig/air_modes_swig.i
+++ b/swig/air_modes_swig.i
Author	SHA1	Message	Date
Nick Foster	0c98c44011	Fix PyQt4 finding during compile.	2015-01-29 11:23:14 -08:00
Philip Balister	2182e5c6b8	Update doxygen config to eliminate warning from current doxygen. Signed-off-by: Philip Balister <philip@balister.org>	2015-01-29 14:38:27 +01:00
Philip Balister	77f4245c35	Update cmake files from gnuradio master gr_modtool output. I ran gr_modtool to create a new module. Then replaces the top level CMakeLists file and tweaked the details. Also about the cmake Modules. The output compiles for x86 native and armv7a cross. Signed-off-by: Philip Balister <philip@balister.org>	2015-01-29 14:37:30 +01:00