Compare commits
No commits in common. 'gr-3.8' and 'dev' have entirely different histories.
62 changed files with 15287 additions and 3703 deletions
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,4 @@
|
||||
[Dolphin] |
||||
Timestamp=2016,12,6,13,18,42 |
||||
Version=3 |
||||
ViewMode=2 |
||||
@ -0,0 +1,36 @@
|
||||
INCLUDE(FindPkgConfig) |
||||
PKG_CHECK_MODULES(PC_GNURADIO_RUNTIME gnuradio-runtime) |
||||
|
||||
if(PC_GNURADIO_RUNTIME_FOUND) |
||||
# look for include files |
||||
FIND_PATH( |
||||
GNURADIO_RUNTIME_INCLUDE_DIRS |
||||
NAMES gnuradio/top_block.h |
||||
HINTS $ENV{GNURADIO_RUNTIME_DIR}/include |
||||
${PC_GNURADIO_RUNTIME_INCLUDE_DIRS} |
||||
${CMAKE_INSTALL_PREFIX}/include |
||||
PATHS /usr/local/include |
||||
/usr/include |
||||
) |
||||
|
||||
# look for libs |
||||
FIND_LIBRARY( |
||||
GNURADIO_RUNTIME_LIBRARIES |
||||
NAMES gnuradio-runtime |
||||
HINTS $ENV{GNURADIO_RUNTIME_DIR}/lib |
||||
${PC_GNURADIO_RUNTIME_LIBDIR} |
||||
${CMAKE_INSTALL_PREFIX}/lib/ |
||||
${CMAKE_INSTALL_PREFIX}/lib64/ |
||||
PATHS /usr/local/lib |
||||
/usr/local/lib64 |
||||
/usr/lib |
||||
/usr/lib64 |
||||
) |
||||
|
||||
set(GNURADIO_RUNTIME_FOUND ${PC_GNURADIO_RUNTIME_FOUND}) |
||||
endif(PC_GNURADIO_RUNTIME_FOUND) |
||||
|
||||
INCLUDE(FindPackageHandleStandardArgs) |
||||
# do not check GNURADIO_RUNTIME_INCLUDE_DIRS, is not set when default include path us used. |
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(GNURADIO_RUNTIME DEFAULT_MSG GNURADIO_RUNTIME_LIBRARIES) |
||||
MARK_AS_ADVANCED(GNURADIO_RUNTIME_LIBRARIES GNURADIO_RUNTIME_INCLUDE_DIRS) |
||||
@ -0,0 +1,528 @@
|
||||
# Copyright 2010-2011,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. |
||||
|
||||
if(DEFINED __INCLUDED_GR_MISC_UTILS_CMAKE) |
||||
return() |
||||
endif() |
||||
set(__INCLUDED_GR_MISC_UTILS_CMAKE TRUE) |
||||
|
||||
######################################################################## |
||||
# Set global variable macro. |
||||
# Used for subdirectories to export settings. |
||||
# Example: include and library paths. |
||||
######################################################################## |
||||
function(GR_SET_GLOBAL var) |
||||
set(${var} ${ARGN} CACHE INTERNAL "" FORCE) |
||||
endfunction(GR_SET_GLOBAL) |
||||
|
||||
######################################################################## |
||||
# Set the pre-processor definition if the condition is true. |
||||
# - def the pre-processor definition to set and condition name |
||||
######################################################################## |
||||
function(GR_ADD_COND_DEF def) |
||||
if(${def}) |
||||
add_definitions(-D${def}) |
||||
endif(${def}) |
||||
endfunction(GR_ADD_COND_DEF) |
||||
|
||||
######################################################################## |
||||
# Check for a header and conditionally set a compile define. |
||||
# - hdr the relative path to the header file |
||||
# - def the pre-processor definition to set |
||||
######################################################################## |
||||
function(GR_CHECK_HDR_N_DEF hdr def) |
||||
include(CheckIncludeFileCXX) |
||||
CHECK_INCLUDE_FILE_CXX(${hdr} ${def}) |
||||
GR_ADD_COND_DEF(${def}) |
||||
endfunction(GR_CHECK_HDR_N_DEF) |
||||
|
||||
######################################################################## |
||||
# Include subdirectory macro. |
||||
# Sets the CMake directory variables, |
||||
# includes the subdirectory CMakeLists.txt, |
||||
# resets the CMake directory variables. |
||||
# |
||||
# This macro includes subdirectories rather than adding them |
||||
# so that the subdirectory can affect variables in the level above. |
||||
# This provides a work-around for the lack of convenience libraries. |
||||
# This way a subdirectory can append to the list of library sources. |
||||
######################################################################## |
||||
macro(GR_INCLUDE_SUBDIRECTORY subdir) |
||||
#insert the current directories on the front of the list |
||||
list(INSERT _cmake_source_dirs 0 ${CMAKE_CURRENT_SOURCE_DIR}) |
||||
list(INSERT _cmake_binary_dirs 0 ${CMAKE_CURRENT_BINARY_DIR}) |
||||
|
||||
#set the current directories to the names of the subdirs |
||||
set(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}) |
||||
set(CMAKE_CURRENT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${subdir}) |
||||
|
||||
#include the subdirectory CMakeLists to run it |
||||
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) |
||||
include(${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt) |
||||
|
||||
#reset the value of the current directories |
||||
list(GET _cmake_source_dirs 0 CMAKE_CURRENT_SOURCE_DIR) |
||||
list(GET _cmake_binary_dirs 0 CMAKE_CURRENT_BINARY_DIR) |
||||
|
||||
#pop the subdir names of the front of the list |
||||
list(REMOVE_AT _cmake_source_dirs 0) |
||||
list(REMOVE_AT _cmake_binary_dirs 0) |
||||
endmacro(GR_INCLUDE_SUBDIRECTORY) |
||||
|
||||
######################################################################## |
||||
# Check if a compiler flag works and conditionally set a compile define. |
||||
# - flag the compiler flag to check for |
||||
# - have the variable to set with result |
||||
######################################################################## |
||||
macro(GR_ADD_CXX_COMPILER_FLAG_IF_AVAILABLE flag have) |
||||
include(CheckCXXCompilerFlag) |
||||
CHECK_CXX_COMPILER_FLAG(${flag} ${have}) |
||||
if(${have}) |
||||
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) |
||||
|
||||
######################################################################## |
||||
# Generates the .la libtool file |
||||
# This appears to generate libtool files that cannot be used by auto*. |
||||
# Usage GR_LIBTOOL(TARGET [target] DESTINATION [dest]) |
||||
# Notice: there is not COMPONENT option, these will not get distributed. |
||||
######################################################################## |
||||
function(GR_LIBTOOL) |
||||
if(NOT DEFINED GENERATE_LIBTOOL) |
||||
set(GENERATE_LIBTOOL OFF) #disabled by default |
||||
endif() |
||||
|
||||
if(GENERATE_LIBTOOL) |
||||
include(CMakeParseArgumentsCopy) |
||||
CMAKE_PARSE_ARGUMENTS(GR_LIBTOOL "" "TARGET;DESTINATION" "" ${ARGN}) |
||||
|
||||
find_program(LIBTOOL libtool) |
||||
if(LIBTOOL) |
||||
include(CMakeMacroLibtoolFile) |
||||
CREATE_LIBTOOL_FILE(${GR_LIBTOOL_TARGET} /${GR_LIBTOOL_DESTINATION}) |
||||
endif(LIBTOOL) |
||||
endif(GENERATE_LIBTOOL) |
||||
|
||||
endfunction(GR_LIBTOOL) |
||||
|
||||
######################################################################## |
||||
# Do standard things to the library target |
||||
# - set target properties |
||||
# - make install rules |
||||
# Also handle gnuradio custom naming conventions w/ extras mode. |
||||
######################################################################## |
||||
function(GR_LIBRARY_FOO target) |
||||
#parse the arguments for component names |
||||
include(CMakeParseArgumentsCopy) |
||||
CMAKE_PARSE_ARGUMENTS(GR_LIBRARY "" "RUNTIME_COMPONENT;DEVEL_COMPONENT" "" ${ARGN}) |
||||
|
||||
#set additional target properties |
||||
set_target_properties(${target} PROPERTIES SOVERSION ${LIBVER}) |
||||
|
||||
#install the generated files like so... |
||||
install(TARGETS ${target} |
||||
LIBRARY DESTINATION ${GR_LIBRARY_DIR} COMPONENT ${GR_LIBRARY_RUNTIME_COMPONENT} # .so/.dylib file |
||||
ARCHIVE DESTINATION ${GR_LIBRARY_DIR} COMPONENT ${GR_LIBRARY_DEVEL_COMPONENT} # .lib file |
||||
RUNTIME DESTINATION ${GR_RUNTIME_DIR} COMPONENT ${GR_LIBRARY_RUNTIME_COMPONENT} # .dll file |
||||
) |
||||
|
||||
#extras mode enabled automatically on linux |
||||
if(NOT DEFINED LIBRARY_EXTRAS) |
||||
set(LIBRARY_EXTRAS ${LINUX}) |
||||
endif() |
||||
|
||||
#special extras mode to enable alternative naming conventions |
||||
if(LIBRARY_EXTRAS) |
||||
|
||||
#create .la file before changing props |
||||
GR_LIBTOOL(TARGET ${target} DESTINATION ${GR_LIBRARY_DIR}) |
||||
|
||||
#give the library a special name with ultra-zero soversion |
||||
set_target_properties(${target} PROPERTIES OUTPUT_NAME ${target}-${LIBVER} SOVERSION "0.0.0") |
||||
set(target_name lib${target}-${LIBVER}.so.0.0.0) |
||||
|
||||
#custom command to generate symlinks |
||||
add_custom_command( |
||||
TARGET ${target} |
||||
POST_BUILD |
||||
COMMAND ${CMAKE_COMMAND} -E create_symlink ${target_name} ${CMAKE_CURRENT_BINARY_DIR}/lib${target}.so |
||||
COMMAND ${CMAKE_COMMAND} -E create_symlink ${target_name} ${CMAKE_CURRENT_BINARY_DIR}/lib${target}-${LIBVER}.so.0 |
||||
COMMAND ${CMAKE_COMMAND} -E touch ${target_name} #so the symlinks point to something valid so cmake 2.6 will install |
||||
) |
||||
|
||||
#and install the extra symlinks |
||||
install( |
||||
FILES |
||||
${CMAKE_CURRENT_BINARY_DIR}/lib${target}.so |
||||
${CMAKE_CURRENT_BINARY_DIR}/lib${target}-${LIBVER}.so.0 |
||||
DESTINATION ${GR_LIBRARY_DIR} COMPONENT ${GR_LIBRARY_RUNTIME_COMPONENT} |
||||
) |
||||
|
||||
endif(LIBRARY_EXTRAS) |
||||
endfunction(GR_LIBRARY_FOO) |
||||
|
||||
######################################################################## |
||||
# Create a dummy custom command that depends on other targets. |
||||
# Usage: |
||||
# GR_GEN_TARGET_DEPS(unique_name target_deps <target1> <target2> ...) |
||||
# ADD_CUSTOM_COMMAND(<the usual args> ${target_deps}) |
||||
# |
||||
# Custom command cant depend on targets, but can depend on executables, |
||||
# and executables can depend on targets. So this is the process: |
||||
######################################################################## |
||||
function(GR_GEN_TARGET_DEPS name var) |
||||
file( |
||||
WRITE ${CMAKE_CURRENT_BINARY_DIR}/${name}.cpp.in |
||||
"int main(void){return 0;}\n" |
||||
) |
||||
execute_process( |
||||
COMMAND ${CMAKE_COMMAND} -E copy_if_different |
||||
${CMAKE_CURRENT_BINARY_DIR}/${name}.cpp.in |
||||
${CMAKE_CURRENT_BINARY_DIR}/${name}.cpp |
||||
) |
||||
add_executable(${name} ${CMAKE_CURRENT_BINARY_DIR}/${name}.cpp) |
||||
if(ARGN) |
||||
add_dependencies(${name} ${ARGN}) |
||||
endif(ARGN) |
||||
|
||||
if(CMAKE_CROSSCOMPILING) |
||||
set(${var} "DEPENDS;${name}" PARENT_SCOPE) #cant call command when cross |
||||
else() |
||||
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}') |
||||
sys.path.append('${CMAKE_SOURCE_DIR}/python') |
||||
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}') |
||||
sys.path.append('${CMAKE_SOURCE_DIR}/python') |
||||
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}') |
||||
sys.path.append('${CMAKE_SOURCE_DIR}/python') |
||||
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) |
||||
@ -0,0 +1,54 @@
|
||||
# Copyright 2011 Free Software Foundation, Inc. |
||||
# |
||||
# This file is part of GNU Radio |
||||
# |
||||
# GNU Radio is free software; you can redistribute it and/or modify |
||||
# it under the terms of the GNU General Public License as published by |
||||
# the Free Software Foundation; either version 3, or (at your option) |
||||
# any later version. |
||||
# |
||||
# GNU Radio is distributed in the hope that it will be useful, |
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
# GNU General Public License for more details. |
||||
# |
||||
# You should have received a copy of the GNU General Public License |
||||
# along with GNU Radio; see the file COPYING. If not, write to |
||||
# the Free Software Foundation, Inc., 51 Franklin Street, |
||||
# Boston, MA 02110-1301, USA. |
||||
|
||||
if(DEFINED __INCLUDED_GR_PLATFORM_CMAKE) |
||||
return() |
||||
endif() |
||||
set(__INCLUDED_GR_PLATFORM_CMAKE TRUE) |
||||
|
||||
######################################################################## |
||||
# Setup additional defines for OS types |
||||
######################################################################## |
||||
if(CMAKE_SYSTEM_NAME STREQUAL "Linux") |
||||
set(LINUX TRUE) |
||||
endif() |
||||
|
||||
if(NOT CMAKE_CROSSCOMPILING AND LINUX AND EXISTS "/etc/debian_version") |
||||
set(DEBIAN TRUE) |
||||
endif() |
||||
|
||||
if(NOT CMAKE_CROSSCOMPILING AND LINUX AND EXISTS "/etc/redhat-release") |
||||
set(REDHAT TRUE) |
||||
endif() |
||||
|
||||
if(NOT CMAKE_CROSSCOMPILING AND LINUX AND EXISTS "/etc/slackware-version") |
||||
set(SLACKWARE TRUE) |
||||
endif() |
||||
|
||||
######################################################################## |
||||
# when the library suffix should be 64 (applies to redhat linux family) |
||||
######################################################################## |
||||
if (REDHAT OR SLACKWARE) |
||||
set(LIB64_CONVENTION TRUE) |
||||
endif() |
||||
|
||||
if(NOT DEFINED LIB_SUFFIX AND LIB64_CONVENTION AND CMAKE_SYSTEM_PROCESSOR MATCHES "64$") |
||||
set(LIB_SUFFIX 64) |
||||
endif() |
||||
set(LIB_SUFFIX ${LIB_SUFFIX} CACHE STRING "lib directory suffix") |
||||
@ -0,0 +1,241 @@
|
||||
# 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_PYTHON_CMAKE) |
||||
return() |
||||
endif() |
||||
set(__INCLUDED_GR_PYTHON_CMAKE TRUE) |
||||
|
||||
######################################################################## |
||||
# Setup the python interpreter: |
||||
# This allows the user to specify a specific interpreter, |
||||
# or finds the interpreter via the built-in cmake module. |
||||
######################################################################## |
||||
#this allows the user to override PYTHON_EXECUTABLE |
||||
if(PYTHON_EXECUTABLE) |
||||
|
||||
set(PYTHONINTERP_FOUND TRUE) |
||||
|
||||
#otherwise if not set, try to automatically find it |
||||
else(PYTHON_EXECUTABLE) |
||||
|
||||
#use the built-in find script |
||||
find_package(PythonInterp 2) |
||||
|
||||
#and if that fails use the find program routine |
||||
if(NOT PYTHONINTERP_FOUND) |
||||
find_program(PYTHON_EXECUTABLE NAMES python python2 python2.7 python2.6 python2.5) |
||||
if(PYTHON_EXECUTABLE) |
||||
set(PYTHONINTERP_FOUND TRUE) |
||||
endif(PYTHON_EXECUTABLE) |
||||
endif(NOT PYTHONINTERP_FOUND) |
||||
|
||||
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) |
||||
execute_process( |
||||
COMMAND ${PYTHON_EXECUTABLE} -B -c "" |
||||
OUTPUT_QUIET ERROR_QUIET |
||||
RESULT_VARIABLE PYTHON_HAS_DASH_B_RESULT |
||||
) |
||||
if(PYTHON_HAS_DASH_B_RESULT EQUAL 0) |
||||
set(PYTHON_DASH_B "-B") |
||||
endif() |
||||
endif(PYTHON_EXECUTABLE) |
||||
|
||||
######################################################################## |
||||
# Check for the existence of a python module: |
||||
# - desc a string description of the check |
||||
# - mod the name of the module to import |
||||
# - cmd an additional command to run |
||||
# - have the result variable to set |
||||
######################################################################## |
||||
macro(GR_PYTHON_CHECK_MODULE desc mod cmd have) |
||||
message(STATUS "") |
||||
message(STATUS "Python checking for ${desc}") |
||||
execute_process( |
||||
COMMAND ${PYTHON_EXECUTABLE} -c " |
||||
######################################### |
||||
try: |
||||
import ${mod} |
||||
assert ${cmd} |
||||
except ImportError, AssertionError: exit(-1) |
||||
except: pass |
||||
#########################################" |
||||
RESULT_VARIABLE ${have} |
||||
) |
||||
if(${have} EQUAL 0) |
||||
message(STATUS "Python checking for ${desc} - found") |
||||
set(${have} TRUE) |
||||
else(${have} EQUAL 0) |
||||
message(STATUS "Python checking for ${desc} - not found") |
||||
set(${have} FALSE) |
||||
endif(${have} EQUAL 0) |
||||
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) |
||||
|
||||
######################################################################## |
||||
# Create an always-built target with a unique name |
||||
# Usage: GR_UNIQUE_TARGET(<description> <dependencies list>) |
||||
######################################################################## |
||||
function(GR_UNIQUE_TARGET desc) |
||||
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', '_', '${desc} ${reldir} ' + unique))" |
||||
OUTPUT_VARIABLE _target OUTPUT_STRIP_TRAILING_WHITESPACE) |
||||
add_custom_target(${_target} ALL DEPENDS ${ARGN}) |
||||
endfunction(GR_UNIQUE_TARGET) |
||||
|
||||
######################################################################## |
||||
# Install python sources (also builds and installs byte-compiled python) |
||||
######################################################################## |
||||
function(GR_PYTHON_INSTALL) |
||||
include(CMakeParseArgumentsCopy) |
||||
CMAKE_PARSE_ARGUMENTS(GR_PYTHON_INSTALL "" "DESTINATION;COMPONENT" "FILES;PROGRAMS" ${ARGN}) |
||||
|
||||
#################################################################### |
||||
if(GR_PYTHON_INSTALL_FILES) |
||||
#################################################################### |
||||
install(${ARGN}) #installs regular python files |
||||
|
||||
#create a list of all generated files |
||||
unset(pysrcfiles) |
||||
unset(pycfiles) |
||||
unset(pyofiles) |
||||
foreach(pyfile ${GR_PYTHON_INSTALL_FILES}) |
||||
get_filename_component(pyfile ${pyfile} ABSOLUTE) |
||||
list(APPEND pysrcfiles ${pyfile}) |
||||
|
||||
#determine if this file is in the source or binary directory |
||||
file(RELATIVE_PATH source_rel_path ${CMAKE_CURRENT_SOURCE_DIR} ${pyfile}) |
||||
string(LENGTH "${source_rel_path}" source_rel_path_len) |
||||
file(RELATIVE_PATH binary_rel_path ${CMAKE_CURRENT_BINARY_DIR} ${pyfile}) |
||||
string(LENGTH "${binary_rel_path}" binary_rel_path_len) |
||||
|
||||
#and set the generated path appropriately |
||||
if(${source_rel_path_len} GREATER ${binary_rel_path_len}) |
||||
set(pygenfile ${CMAKE_CURRENT_BINARY_DIR}/${binary_rel_path}) |
||||
else() |
||||
set(pygenfile ${CMAKE_CURRENT_BINARY_DIR}/${source_rel_path}) |
||||
endif() |
||||
list(APPEND pycfiles ${pygenfile}c) |
||||
list(APPEND pyofiles ${pygenfile}o) |
||||
|
||||
#ensure generation path exists |
||||
get_filename_component(pygen_path ${pygenfile} PATH) |
||||
file(MAKE_DIRECTORY ${pygen_path}) |
||||
|
||||
endforeach(pyfile) |
||||
|
||||
#the command to generate the pyc files |
||||
add_custom_command( |
||||
DEPENDS ${pysrcfiles} OUTPUT ${pycfiles} |
||||
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_BINARY_DIR}/python_compile_helper.py ${pysrcfiles} ${pycfiles} |
||||
) |
||||
|
||||
#the command to generate the pyo files |
||||
add_custom_command( |
||||
DEPENDS ${pysrcfiles} OUTPUT ${pyofiles} |
||||
COMMAND ${PYTHON_EXECUTABLE} -O ${CMAKE_BINARY_DIR}/python_compile_helper.py ${pysrcfiles} ${pyofiles} |
||||
) |
||||
|
||||
#create install rule and add generated files to target list |
||||
set(python_install_gen_targets ${pycfiles} ${pyofiles}) |
||||
install(FILES ${python_install_gen_targets} |
||||
DESTINATION ${GR_PYTHON_INSTALL_DESTINATION} |
||||
COMPONENT ${GR_PYTHON_INSTALL_COMPONENT} |
||||
) |
||||
|
||||
#################################################################### |
||||
elseif(GR_PYTHON_INSTALL_PROGRAMS) |
||||
#################################################################### |
||||
file(TO_NATIVE_PATH ${PYTHON_EXECUTABLE} pyexe_native) |
||||
|
||||
if (CMAKE_CROSSCOMPILING) |
||||
set(pyexe_native "/usr/bin/env python") |
||||
endif() |
||||
|
||||
foreach(pyfile ${GR_PYTHON_INSTALL_PROGRAMS}) |
||||
get_filename_component(pyfile_name ${pyfile} NAME) |
||||
get_filename_component(pyfile ${pyfile} ABSOLUTE) |
||||
string(REPLACE "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" pyexefile "${pyfile}.exe") |
||||
list(APPEND python_install_gen_targets ${pyexefile}) |
||||
|
||||
get_filename_component(pyexefile_path ${pyexefile} PATH) |
||||
file(MAKE_DIRECTORY ${pyexefile_path}) |
||||
|
||||
add_custom_command( |
||||
OUTPUT ${pyexefile} DEPENDS ${pyfile} |
||||
COMMAND ${PYTHON_EXECUTABLE} -c |
||||
"import re; R=re.compile('^\#!.*$\\n',flags=re.MULTILINE); open('${pyexefile}','w').write('\#!${pyexe_native}\\n'+R.sub('',open('${pyfile}','r').read()))" |
||||
COMMENT "Shebangin ${pyfile_name}" |
||||
VERBATIM |
||||
) |
||||
|
||||
#on windows, python files need an extension to execute |
||||
get_filename_component(pyfile_ext ${pyfile} EXT) |
||||
if(WIN32 AND NOT pyfile_ext) |
||||
set(pyfile_name "${pyfile_name}.py") |
||||
endif() |
||||
|
||||
install(PROGRAMS ${pyexefile} RENAME ${pyfile_name} |
||||
DESTINATION ${GR_PYTHON_INSTALL_DESTINATION} |
||||
COMPONENT ${GR_PYTHON_INSTALL_COMPONENT} |
||||
) |
||||
endforeach(pyfile) |
||||
|
||||
endif() |
||||
|
||||
GR_UNIQUE_TARGET("pygen" ${python_install_gen_targets}) |
||||
|
||||
endfunction(GR_PYTHON_INSTALL) |
||||
|
||||
######################################################################## |
||||
# Write the python helper script that generates byte code files |
||||
######################################################################## |
||||
file(WRITE ${CMAKE_BINARY_DIR}/python_compile_helper.py " |
||||
import sys, py_compile |
||||
files = sys.argv[1:] |
||||
srcs, gens = files[:len(files)/2], files[len(files)/2:] |
||||
for src, gen in zip(srcs, gens): |
||||
py_compile.compile(file=src, cfile=gen, doraise=True) |
||||
") |
||||
@ -0,0 +1,251 @@
|
||||
# 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_SWIG_CMAKE) |
||||
return() |
||||
endif() |
||||
set(__INCLUDED_GR_SWIG_CMAKE TRUE) |
||||
|
||||
include(GrPython) |
||||
|
||||
######################################################################## |
||||
# Builds a swig documentation file to be generated into python docstrings |
||||
# Usage: GR_SWIG_MAKE_DOCS(output_file input_path input_path....) |
||||
# |
||||
# Set the following variable to specify extra dependent targets: |
||||
# - GR_SWIG_DOCS_SOURCE_DEPS |
||||
# - GR_SWIG_DOCS_TARGET_DEPS |
||||
######################################################################## |
||||
function(GR_SWIG_MAKE_DOCS output_file) |
||||
if(ENABLE_DOXYGEN) |
||||
|
||||
#setup the input files variable list, quote formated |
||||
set(input_files) |
||||
unset(INPUT_PATHS) |
||||
foreach(input_path ${ARGN}) |
||||
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}) |
||||
endif() |
||||
list(APPEND input_files ${input_path_h_files}) |
||||
set(INPUT_PATHS "${INPUT_PATHS} \"${input_path}\"") |
||||
endforeach(input_path) |
||||
|
||||
#determine the output directory |
||||
get_filename_component(name ${output_file} NAME_WE) |
||||
get_filename_component(OUTPUT_DIRECTORY ${output_file} PATH) |
||||
set(OUTPUT_DIRECTORY ${OUTPUT_DIRECTORY}/${name}_swig_docs) |
||||
make_directory(${OUTPUT_DIRECTORY}) |
||||
|
||||
#generate the Doxyfile used by doxygen |
||||
configure_file( |
||||
${CMAKE_SOURCE_DIR}/docs/doxygen/Doxyfile.swig_doc.in |
||||
${OUTPUT_DIRECTORY}/Doxyfile |
||||
@ONLY) |
||||
|
||||
#Create a dummy custom command that depends on other targets |
||||
include(GrMiscUtils) |
||||
GR_GEN_TARGET_DEPS(_${name}_tag tag_deps ${GR_SWIG_DOCS_TARGET_DEPS}) |
||||
|
||||
#call doxygen on the Doxyfile + input headers |
||||
add_custom_command( |
||||
OUTPUT ${OUTPUT_DIRECTORY}/xml/index.xml |
||||
DEPENDS ${input_files} ${GR_SWIG_DOCS_SOURCE_DEPS} ${tag_deps} |
||||
COMMAND ${DOXYGEN_EXECUTABLE} ${OUTPUT_DIRECTORY}/Doxyfile |
||||
COMMENT "Generating doxygen xml for ${name} docs" |
||||
) |
||||
|
||||
#call the swig_doc script on the xml files |
||||
add_custom_command( |
||||
OUTPUT ${output_file} |
||||
DEPENDS ${input_files} ${stamp-file} ${OUTPUT_DIRECTORY}/xml/index.xml |
||||
COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B} |
||||
${CMAKE_SOURCE_DIR}/docs/doxygen/swig_doc.py |
||||
${OUTPUT_DIRECTORY}/xml |
||||
${output_file} |
||||
COMMENT "Generating python docstrings for ${name}" |
||||
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/docs/doxygen |
||||
) |
||||
|
||||
else(ENABLE_DOXYGEN) |
||||
file(WRITE ${output_file} "\n") #no doxygen -> empty file |
||||
endif(ENABLE_DOXYGEN) |
||||
endfunction(GR_SWIG_MAKE_DOCS) |
||||
|
||||
######################################################################## |
||||
# Build a swig target for the common gnuradio use case. Usage: |
||||
# GR_SWIG_MAKE(target ifile ifile ifile...) |
||||
# |
||||
# Set the following variables before calling: |
||||
# - GR_SWIG_FLAGS |
||||
# - GR_SWIG_INCLUDE_DIRS |
||||
# - GR_SWIG_LIBRARIES |
||||
# - GR_SWIG_SOURCE_DEPS |
||||
# - GR_SWIG_TARGET_DEPS |
||||
# - GR_SWIG_DOC_FILE |
||||
# - GR_SWIG_DOC_DIRS |
||||
######################################################################## |
||||
macro(GR_SWIG_MAKE name) |
||||
set(ifiles ${ARGN}) |
||||
|
||||
# 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) |
||||
set(GR_SWIG_DOCS_SOURCE_DEPS ${GR_SWIG_SOURCE_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 ${GR_RUNTIME_SWIG_DOC_FILE}) |
||||
endif() |
||||
|
||||
#append additional include directories |
||||
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}) |
||||
|
||||
#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( |
||||
COMMAND ${PYTHON_EXECUTABLE} |
||||
${CMAKE_BINARY_DIR}/get_swig_deps.py |
||||
"${ifiles}" "${GR_SWIG_INCLUDE_DIRS}" |
||||
OUTPUT_STRIP_TRAILING_WHITESPACE |
||||
OUTPUT_VARIABLE SWIG_MODULE_${name}_EXTRA_DEPS |
||||
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} |
||||
) |
||||
|
||||
#Create a dummy custom command that depends on other targets |
||||
include(GrMiscUtils) |
||||
GR_GEN_TARGET_DEPS(_${name}_swig_tag tag_deps ${GR_SWIG_TARGET_DEPS}) |
||||
set(tag_file ${CMAKE_CURRENT_BINARY_DIR}/${name}.tag) |
||||
add_custom_command( |
||||
OUTPUT ${tag_file} |
||||
DEPENDS ${GR_SWIG_SOURCE_DEPS} ${tag_deps} |
||||
COMMAND ${CMAKE_COMMAND} -E touch ${tag_file} |
||||
) |
||||
|
||||
#append the specified include directories |
||||
include_directories(${GR_SWIG_INCLUDE_DIRS}) |
||||
list(APPEND SWIG_MODULE_${name}_EXTRA_DEPS ${tag_file}) |
||||
|
||||
#setup the swig flags with flags and include directories |
||||
set(CMAKE_SWIG_FLAGS -fvirtual -modern -keyword -w511 -module ${name} ${GR_SWIG_FLAGS}) |
||||
foreach(dir ${GR_SWIG_INCLUDE_DIRS}) |
||||
list(APPEND CMAKE_SWIG_FLAGS "-I${dir}") |
||||
endforeach(dir) |
||||
|
||||
#set the C++ property on the swig .i file so it builds |
||||
set_source_files_properties(${ifiles} PROPERTIES CPLUSPLUS ON) |
||||
|
||||
#setup the actual swig library target to be built |
||||
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) |
||||
|
||||
######################################################################## |
||||
# Install swig targets generated by GR_SWIG_MAKE. Usage: |
||||
# GR_SWIG_INSTALL( |
||||
# TARGETS target target target... |
||||
# [DESTINATION destination] |
||||
# [COMPONENT component] |
||||
# ) |
||||
######################################################################## |
||||
macro(GR_SWIG_INSTALL) |
||||
|
||||
include(CMakeParseArgumentsCopy) |
||||
CMAKE_PARSE_ARGUMENTS(GR_SWIG_INSTALL "" "DESTINATION;COMPONENT" "TARGETS" ${ARGN}) |
||||
|
||||
foreach(name ${GR_SWIG_INSTALL_TARGETS}) |
||||
install(TARGETS ${SWIG_MODULE_${name}_REAL_NAME} |
||||
DESTINATION ${GR_SWIG_INSTALL_DESTINATION} |
||||
COMPONENT ${GR_SWIG_INSTALL_COMPONENT} |
||||
) |
||||
|
||||
include(GrPython) |
||||
GR_PYTHON_INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name}.py |
||||
DESTINATION ${GR_SWIG_INSTALL_DESTINATION} |
||||
COMPONENT ${GR_SWIG_INSTALL_COMPONENT} |
||||
) |
||||
|
||||
GR_LIBTOOL( |
||||
TARGET ${SWIG_MODULE_${name}_REAL_NAME} |
||||
DESTINATION ${GR_SWIG_INSTALL_DESTINATION} |
||||
) |
||||
|
||||
endforeach(name) |
||||
|
||||
endmacro(GR_SWIG_INSTALL) |
||||
|
||||
######################################################################## |
||||
# Generate a python file that can determine swig dependencies. |
||||
# Used by the make macro above to determine extra dependencies. |
||||
# When you build C++, CMake figures out the header dependencies. |
||||
# This code essentially performs that logic for swig includes. |
||||
######################################################################## |
||||
file(WRITE ${CMAKE_BINARY_DIR}/get_swig_deps.py " |
||||
|
||||
import os, sys, re |
||||
|
||||
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 matcher.findall(file_contents, re.MULTILINE) |
||||
|
||||
def get_swig_deps(file_path, level): |
||||
deps = [file_path] |
||||
if level == 0: return deps |
||||
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__': |
||||
ifiles = sys.argv[1].split(';') |
||||
deps = sum([get_swig_deps(ifile, 3) for ifile in ifiles], []) |
||||
#sys.stderr.write(';'.join(set(deps)) + '\\n\\n') |
||||
print(';'.join(set(deps))) |
||||
") |
||||
@ -0,0 +1,143 @@
|
||||
# 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_TEST_CMAKE) |
||||
return() |
||||
endif() |
||||
set(__INCLUDED_GR_TEST_CMAKE TRUE) |
||||
|
||||
######################################################################## |
||||
# Add a unit test and setup the environment for a unit test. |
||||
# Takes the same arguments as the ADD_TEST function. |
||||
# |
||||
# Before calling set the following variables: |
||||
# 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) |
||||
|
||||
#Ensure that the build exe also appears in the PATH. |
||||
list(APPEND GR_TEST_TARGET_DEPS ${ARGN}) |
||||
|
||||
#In the land of windows, all libraries must be in the PATH. |
||||
#Since the dependent libraries are not yet installed, |
||||
#we must manually set them in the PATH to run tests. |
||||
#The following appends the path of a target dependency. |
||||
foreach(target ${GR_TEST_TARGET_DEPS}) |
||||
get_target_property(location ${target} LOCATION) |
||||
if(location) |
||||
get_filename_component(path ${location} PATH) |
||||
string(REGEX REPLACE "\\$\\(.*\\)" ${CMAKE_BUILD_TYPE} path ${path}) |
||||
list(APPEND GR_TEST_LIBRARY_DIRS ${path}) |
||||
endif(location) |
||||
endforeach(target) |
||||
|
||||
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 ${GR_TEST_PYTHON_DIRS}) |
||||
get_filename_component(name ${pydir} NAME) |
||||
if(name MATCHES "^(swig|lib|src)$") |
||||
list(APPEND GR_TEST_PYTHON_DIRS ${pydir}/${CMAKE_BUILD_TYPE}) |
||||
endif() |
||||
endforeach(pydir) |
||||
endif(WIN32) |
||||
|
||||
file(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR} srcdir) |
||||
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 "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. |
||||
#Its nicer to be able to manually run the shell script to diagnose problems. |
||||
#ADD_TEST(${ARGV}) |
||||
#SET_TESTS_PROPERTIES(${test_name} PROPERTIES ENVIRONMENT "${environs}") |
||||
|
||||
if(UNIX) |
||||
set(LD_PATH_VAR "LD_LIBRARY_PATH") |
||||
if(APPLE) |
||||
set(LD_PATH_VAR "DYLD_LIBRARY_PATH") |
||||
endif() |
||||
|
||||
set(binpath "${CMAKE_CURRENT_BINARY_DIR}:$PATH") |
||||
list(APPEND libpath "$${LD_PATH_VAR}") |
||||
list(APPEND pypath "$PYTHONPATH") |
||||
|
||||
#replace list separator with the path separator |
||||
string(REPLACE ";" ":" libpath "${libpath}") |
||||
string(REPLACE ";" ":" pypath "${pypath}") |
||||
list(APPEND environs "PATH=${binpath}" "${LD_PATH_VAR}=${libpath}" "PYTHONPATH=${pypath}") |
||||
|
||||
#generate a bat file that sets the environment and runs the test |
||||
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 |
||||
foreach(environ ${environs}) |
||||
file(APPEND ${sh_file} "export ${environ}\n") |
||||
endforeach(environ) |
||||
#load the command to run with its arguments |
||||
foreach(arg ${ARGN}) |
||||
file(APPEND ${sh_file} "${arg} ") |
||||
endforeach(arg) |
||||
file(APPEND ${sh_file} "\n") |
||||
|
||||
#make the shell file executable |
||||
execute_process(COMMAND chmod +x ${sh_file}) |
||||
|
||||
add_test(${test_name} ${SHELL} ${sh_file}) |
||||
|
||||
endif(UNIX) |
||||
|
||||
if(WIN32) |
||||
list(APPEND libpath ${DLL_PATHS} "%PATH%") |
||||
list(APPEND pypath "%PYTHONPATH%") |
||||
|
||||
#replace list separator with the path separator (escaped) |
||||
string(REPLACE ";" "\\;" libpath "${libpath}") |
||||
string(REPLACE ";" "\\;" pypath "${pypath}") |
||||
list(APPEND environs "PATH=${libpath}" "PYTHONPATH=${pypath}") |
||||
|
||||
#generate a bat file that sets the environment and runs the test |
||||
set(bat_file ${CMAKE_CURRENT_BINARY_DIR}/${test_name}_test.bat) |
||||
file(WRITE ${bat_file} "@echo off\n") |
||||
#each line sets an environment variable |
||||
foreach(environ ${environs}) |
||||
file(APPEND ${bat_file} "SET ${environ}\n") |
||||
endforeach(environ) |
||||
#load the command to run with its arguments |
||||
foreach(arg ${ARGN}) |
||||
file(APPEND ${bat_file} "${arg} ") |
||||
endforeach(arg) |
||||
file(APPEND ${bat_file} "\n") |
||||
|
||||
add_test(${test_name} ${bat_file}) |
||||
endif(WIN32) |
||||
|
||||
endfunction(GR_ADD_TEST) |
||||
@ -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() |
||||
@ -1,25 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_decoder_compare |
||||
label: decoder_compare |
||||
category: '[multirds]' |
||||
|
||||
parameters: |
||||
- id: nPorts |
||||
label: Number of Ports |
||||
dtype: int |
||||
default: '2' |
||||
hide: part |
||||
|
||||
inputs: |
||||
- domain: message |
||||
id: in |
||||
multiplicity: ${ nPorts } |
||||
asserts: |
||||
- ${ nPorts > 0 } |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: multirds.decoder_compare(${nPorts}) |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,28 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>decoder_compare</name> |
||||
<key>multirds_decoder_compare</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>multirds.decoder_compare($nPorts)</make> |
||||
<!-- Make one 'param' node for every Parameter you want settable from the GUI. |
||||
Sub-nodes: |
||||
* name |
||||
* key (makes the value accessible as $keyname, e.g. in the make node) |
||||
* type --> |
||||
<param> |
||||
<name>Number of Ports</name> |
||||
<key>nPorts</key> |
||||
<value>2</value> |
||||
<type>int</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
|
||||
<check>$nPorts > 0</check> |
||||
<sink> |
||||
<name>in</name> |
||||
<type>message</type> |
||||
<nports>$nPorts</nports> |
||||
<!-- <optional>1</optional> --> |
||||
</sink> |
||||
</block> |
||||
@ -1,57 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_pilot_SNR |
||||
label: pilot_SNR |
||||
category: '[multirds]' |
||||
|
||||
parameters: |
||||
- id: debug |
||||
label: Debug |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
- id: carrier_freq |
||||
label: carrier_freq |
||||
dtype: float |
||||
default: 19e3 |
||||
- id: gap_width |
||||
label: gap_width |
||||
dtype: float |
||||
default: 4e3 |
||||
- id: update_period |
||||
label: update_period |
||||
dtype: float |
||||
default: '0.2' |
||||
- id: samp_rate |
||||
label: samp_rate |
||||
dtype: int |
||||
default: '240000' |
||||
- id: fft_len |
||||
label: fft_len |
||||
dtype: int |
||||
default: '2048' |
||||
- id: msg_adr |
||||
label: msg_adr |
||||
dtype: int |
||||
default: '3' |
||||
|
||||
inputs: |
||||
- domain: stream |
||||
dtype: float |
||||
vlen: ${ fft_len } |
||||
|
||||
outputs: |
||||
- domain: message |
||||
id: out |
||||
optional: true |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: multirds.pilot_SNR(${debug}, ${samp_rate}, ${fft_len}, ${carrier_freq},${gap_width}, |
||||
${msg_adr},${update_period}) |
||||
|
||||
documentation: |- |
||||
outputs PMT pair of longs (msg_adr . SNR) SNR is calculated as difference (in dB) between the 19k carrier power and the average power between carrier_freq-gap_width and carrier_freq+gap_width \ |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,84 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>pilot_SNR</name> |
||||
<key>multirds_pilot_SNR</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>multirds.pilot_SNR($debug, $samp_rate, $fft_len, $carrier_freq,$gap_width, $msg_adr,$update_period)</make> |
||||
<!-- Make one 'param' node for every Parameter you want settable from the GUI. |
||||
Sub-nodes: |
||||
* name |
||||
* key (makes the value accessible as $keyname, e.g. in the make node) |
||||
* type --> |
||||
<param> |
||||
<name>Debug</name> |
||||
<key>debug</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>carrier_freq</name> |
||||
<key>carrier_freq</key> |
||||
<value>19e3</value> |
||||
<type>float</type> |
||||
</param> |
||||
<param> |
||||
<name>gap_width</name> |
||||
<key>gap_width</key> |
||||
<value>4e3</value> |
||||
<type>float</type> |
||||
</param> |
||||
<param> |
||||
<name>update_period</name> |
||||
<key>update_period</key> |
||||
<value>0.2</value> |
||||
<type>float</type> |
||||
</param> |
||||
<param> |
||||
<name>samp_rate</name> |
||||
<key>samp_rate</key> |
||||
<value>240000</value> |
||||
<type>int</type> |
||||
</param> |
||||
<param> |
||||
<name>fft_len</name> |
||||
<key>fft_len</key> |
||||
<value>2048</value> |
||||
<type>int</type> |
||||
</param> |
||||
<param> |
||||
<name>msg_adr</name> |
||||
<key>msg_adr</key> |
||||
<value>3</value> |
||||
<type>int</type> |
||||
</param> |
||||
<!-- Make one 'sink' node per input. Sub-nodes: |
||||
* name (an identifier for the GUI) |
||||
* type |
||||
* vlen |
||||
* optional (set to 1 for optional inputs) --> |
||||
<sink> |
||||
<name>in</name> |
||||
<type>float</type> |
||||
<vlen>$fft_len</vlen> |
||||
</sink> |
||||
<source> |
||||
<name>out</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</source> |
||||
<doc>outputs PMT pair of longs (msg_adr . SNR) \ |
||||
SNR is calculated as difference (in dB)\ |
||||
between the 19k carrier power and the \ |
||||
average power between carrier_freq-gap_width and carrier_freq+gap_width \ |
||||
|
||||
</doc> |
||||
</block> |
||||
@ -0,0 +1,136 @@
|
||||
<?xml version="1.0"?> |
||||
|
||||
<block> |
||||
<name>qtgui_range (cr)</name> |
||||
<key>variable_multirds_qtgui_range</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<import>from multirds.qtgui_range import qtgui_range, RangeWidget</import> |
||||
<var_make>self.$(id) = $(id) = $value</var_make> |
||||
<make>#set $win = 'self._%s_win'%$id |
||||
#set $range = 'self.%s_range'%$id |
||||
#if not $label() |
||||
#set $label = '"%s"'%$id |
||||
#end if |
||||
$(range) = qtgui_range($start, $stop, $step, $value, $min_len) |
||||
$(win) = RangeWidget($range, self.set_$(id), $label, "$widget", $rangeType) |
||||
$(gui_hint()($win))</make> |
||||
<!--<callback>self.freq2_range.set_test($value);</callback>--> |
||||
<!-- <callback>self.set_$(id)($value)</callback> --> |
||||
<!-- <callback>set_test($(id));</callback> --> |
||||
|
||||
<!-- <callback>self._$(id)_win.set_test($(id));</callback>--> |
||||
|
||||
<param> |
||||
<name>Label</name> |
||||
<key>label</key> |
||||
<value></value> |
||||
<type>string</type> |
||||
<hide>#if $label() then 'none' else 'part'#</hide> |
||||
</param> |
||||
|
||||
<param> |
||||
<name>Type</name> |
||||
<key>rangeType</key> |
||||
<value>"float"</value> |
||||
<type>enum</type> |
||||
<hide>part</hide> |
||||
<option><name>Float</name><key>float</key><opt>type:float</opt></option> |
||||
<option><name>Int</name><key>int</key><opt>type:int</opt></option> |
||||
</param> |
||||
|
||||
<param> |
||||
<name>Default Value</name> |
||||
<key>value</key> |
||||
<value>50</value> |
||||
<type>$rangeType.type</type> |
||||
</param> |
||||
|
||||
<param> |
||||
<name>Start</name> |
||||
<key>start</key> |
||||
<value>0</value> |
||||
<type>$rangeType.type</type> |
||||
</param> |
||||
|
||||
<param> |
||||
<name>Stop</name> |
||||
<key>stop</key> |
||||
<value>100</value> |
||||
<type>$rangeType.type</type> |
||||
</param> |
||||
|
||||
<param> |
||||
<name>Step</name> |
||||
<key>step</key> |
||||
<value>1</value> |
||||
<type>$rangeType.type</type> |
||||
</param> |
||||
|
||||
<param> |
||||
<name>Widget</name> |
||||
<key>widget</key> |
||||
<value>counter_slider</value> |
||||
<type>enum</type> |
||||
<hide>part</hide> |
||||
<option><name>Counter + Slider</name><key>counter_slider</key></option> |
||||
<option><name>Counter</name><key>counter</key></option> |
||||
<option><name>Slider</name><key>slider</key></option> |
||||
<option><name>Knob</name><key>dial</key></option> |
||||
</param> |
||||
|
||||
<param> |
||||
<name>Orientation</name> |
||||
<key>orient</key> |
||||
<value>Qt.Horizontal</value> |
||||
<type>enum</type> |
||||
<hide>#if $widget() == "slider" then 'part' else 'all'#</hide> |
||||
<option> |
||||
<name>Horizontal</name> |
||||
<key>Qt.Horizontal</key> |
||||
<opt>scalepos:BottomScale</opt> |
||||
<opt>minfcn:setMinimumWidth</opt> |
||||
</option> |
||||
<option> |
||||
<name>Vertical</name> |
||||
<key>Qt.Vertical</key> |
||||
<opt>scalepos:LeftScale</opt> |
||||
<opt>minfcn:setMinimumHeight</opt> |
||||
</option> |
||||
</param> |
||||
|
||||
<param> |
||||
<name>Minimum Length</name> |
||||
<key>min_len</key> |
||||
<value>200</value> |
||||
<type>int</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
<!-- from min_len <hide>#if $widget().split('_')[0] in ("slider", "counter") then 'part' else 'all'#</hide>--> |
||||
|
||||
<param> |
||||
<name>GUI Hint</name> |
||||
<key>gui_hint</key> |
||||
<value></value> |
||||
<type>gui_hint</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
|
||||
<check>$start <= $value <= $stop</check> |
||||
<check>$start < $stop</check> |
||||
<!-- <sink> |
||||
<name>set</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</sink>--> |
||||
<doc> |
||||
This block creates a variable with a slider. \ |
||||
Leave the label blank to use the variable id as the label. \ |
||||
The value must be a real number. \ |
||||
The value must be between the start and the stop. |
||||
|
||||
The GUI hint can be used to position the widget within the application. \ |
||||
The hint is of the form [tab_id@tab_index]: [row, col, row_span, col_span]. \ |
||||
Both the tab specification and the grid position are optional. |
||||
</doc> |
||||
</block> |
||||
@ -1,32 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_rds_decoder |
||||
label: multirds Rds decoder |
||||
category: '[multirds]' |
||||
|
||||
parameters: |
||||
- id: log |
||||
label: Log |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
- id: debug |
||||
label: Debug |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
|
||||
inputs: |
||||
- domain: stream |
||||
dtype: byte |
||||
outputs: |
||||
- domain: message |
||||
optional: true |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: multirds.rds_decoder(${log}, ${debug}) |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,45 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>RDS Decoder (cr)</name> |
||||
<key>multirds_rds_decoder</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>multirds.rds_decoder($log, $debug)</make> |
||||
<param> |
||||
<name>Log</name> |
||||
<key>log</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>Debug</name> |
||||
<key>debug</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<sink> |
||||
<name>in</name> |
||||
<type>byte</type> |
||||
</sink> |
||||
<source> |
||||
<name>out</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</source> |
||||
</block> |
||||
@ -1,32 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_rds_decoder_redsea |
||||
label: multirds Rds decoder redsea |
||||
category: '[multirds]' |
||||
|
||||
parameters: |
||||
- id: log |
||||
label: Log |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
- id: debug |
||||
label: Debug |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
|
||||
inputs: |
||||
- domain: stream |
||||
dtype: byte |
||||
outputs: |
||||
- domain: message |
||||
optional: true |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: multirds.rds_decoder_redsea(${log}, ${debug}) |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,45 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>RDS Decoder (redsea)</name> |
||||
<key>multirds_rds_decoder_redsea</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>multirds.rds_decoder_redsea($log, $debug)</make> |
||||
<param> |
||||
<name>Log</name> |
||||
<key>log</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>Debug</name> |
||||
<key>debug</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<sink> |
||||
<name>in</name> |
||||
<type>byte</type> |
||||
</sink> |
||||
<source> |
||||
<name>out</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</source> |
||||
</block> |
||||
@ -1,96 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_rds_parser_table_qt |
||||
label: RDS Parser Table (qt) |
||||
category: '[multirds]' |
||||
|
||||
parameters: |
||||
- id: freq_tune |
||||
label: tuned frequency |
||||
dtype: float |
||||
- id: label |
||||
label: Label |
||||
dtype: string |
||||
hide: ${ ('none' if label else 'part') } |
||||
- id: workdir |
||||
label: work directory |
||||
dtype: string |
||||
hide: part |
||||
- id: gui_hint |
||||
label: GUI Hint |
||||
dtype: gui_hint |
||||
hide: part |
||||
- id: nPorts |
||||
label: Number of Ports |
||||
dtype: int |
||||
default: '2' |
||||
hide: part |
||||
- id: log |
||||
label: Log |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
- id: debug |
||||
label: Debug |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
- id: writeDB |
||||
label: write Database |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
|
||||
inputs: |
||||
- domain: message |
||||
id: in |
||||
multiplicity: ${ nPorts } |
||||
- domain: message |
||||
id: freq |
||||
optional: true |
||||
|
||||
outputs: |
||||
- domain: message |
||||
id: ctrl |
||||
optional: true |
||||
- domain: message |
||||
id: tmc_raw |
||||
optional: true |
||||
asserts: |
||||
- ${ open(workdir+"pty-list.csv").close() or True } |
||||
- ${ open(workdir+"directory_writable","w").close() or True } |
||||
- ${ nPorts > 0 } |
||||
|
||||
templates: |
||||
imports: |- |
||||
import multirds |
||||
from multirds.rds_parser_table_qt import rds_parser_table_qt, rds_parser_table_qt_Widget,rds_parser_table_qt_Signals |
||||
make: "<% win = 'self._%s_win'%id %>\n\t\t<% signals = 'self._%s_signals'%id %>\n\ |
||||
% if not label:\n\t<% label = '\"%s\"'%id %>\n% endif\n${signals} = rds_parser_table_qt_Signals()\n\ |
||||
self.${id} = multirds.rds_parser_table_qt(${signals},${nPorts},self.set_${freq_tune},${freq_tune},${log},\ |
||||
\ ${debug},${workdir},${writeDB})\n${win} = rds_parser_table_qt_Widget(${signals},\ |
||||
\ ${label},self.${id})\n${gui_hint(in)}" |
||||
make: |- |
||||
<% |
||||
win = 'self._%s_win'%id |
||||
signals = 'self._%s_signals'%id |
||||
%>\ |
||||
${signals} = rds_parser_table_qt_Signals() |
||||
self.${id} = multirds.rds_parser_table_qt(${signals},${nPorts},self.set_${freq_tune},${freq_tune},${log},${debug},${workdir},${writeDB}) |
||||
${win} = rds_parser_table_qt_Widget(${signals},${label},self.${id}) |
||||
${gui_hint() % win} |
||||
|
||||
callbacks: |
||||
- set_freq_tune(${freq_tune}); |
||||
|
||||
documentation: "show RDS data from multiple stations in QT table input: raw group\ |
||||
\ data (array of ints) 4x2 raw block data, 4x1 offset chars, 1x1 number of valid\ |
||||
\ blocks (of last 50) [block1_upper,block1_lower,block2_upper,block2_lower,...,offset1,offset2,offset3,offset4,numerrors]\\\ |
||||
\ \n The GUI hint can be used to position the widget within the application.\ |
||||
\ The hint is of the form \"tab_id@tab_index: row, col, row_span, col_span\"\ |
||||
\ Both the tab specification and the grid position are optional." |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,141 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>RDS Parser Table (qt)</name> |
||||
<key>multirds_rds_parser_table_qt</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<import>from multirds.rds_parser_table_qt import rds_parser_table_qt, rds_parser_table_qt_Widget,rds_parser_table_qt_Signals</import> |
||||
<!-- |
||||
<var_make>self.$(id) = $(id) = $value</var_make> |
||||
--> |
||||
<make>#set $win = 'self._%s_win'%$id |
||||
#set $signals = 'self._%s_signals'%$id |
||||
#if not $label() |
||||
#set $label = '"%s"'%$id |
||||
#end if |
||||
$(signals) = rds_parser_table_qt_Signals() |
||||
self.$(id) = multirds.rds_parser_table_qt($(signals),$nPorts,self.set_$(freq_tune),$freq_tune,$log, $debug,$workdir,$writeDB) |
||||
$(win) = rds_parser_table_qt_Widget($signals, $label,self.$(id)) |
||||
$(gui_hint()($win))</make> |
||||
<callback>set_freq_tune($freq_tune);</callback> |
||||
<param> |
||||
<name>tuned frequency</name> |
||||
<key>freq_tune</key> |
||||
<value></value> |
||||
<type>float</type> |
||||
</param> |
||||
<param> |
||||
<name>Label</name> |
||||
<key>label</key> |
||||
<value></value> |
||||
<type>string</type> |
||||
<hide>#if $label() then 'none' else 'part'#</hide> |
||||
</param> |
||||
<param> |
||||
<name>work directory</name> |
||||
<key>workdir</key> |
||||
<value></value> |
||||
<type>string</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
<param> |
||||
<name>GUI Hint</name> |
||||
<key>gui_hint</key> |
||||
<value></value> |
||||
<type>gui_hint</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
<param> |
||||
<name>Number of Ports</name> |
||||
<key>nPorts</key> |
||||
<value>2</value> |
||||
<type>int</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
<param> |
||||
<name>Log</name> |
||||
<key>log</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>Debug</name> |
||||
<key>debug</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>write Database</name> |
||||
<key>writeDB</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<!--<hide>part</hide>--> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
|
||||
<!-- |
||||
check if pty list file exists |
||||
check directory doesnt work: |
||||
<check>os.path.isdir($workdir)</check> |
||||
--> |
||||
<check>open($workdir+"pty-list.csv").close() or True</check> |
||||
<!-- |
||||
check if workdir is writable |
||||
--> |
||||
<check>open($workdir+"directory_writable","w").close() or True</check> |
||||
<check>$nPorts > 0</check> |
||||
<sink> |
||||
<name>in</name> |
||||
<type>message</type> |
||||
<nports>$nPorts</nports> |
||||
<!-- <optional>1</optional> --> |
||||
</sink> |
||||
<sink> |
||||
<name>freq</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</sink> |
||||
<source> |
||||
<name>ctrl</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</source> |
||||
<source> |
||||
<name>tmc_raw</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</source> |
||||
<doc>show RDS data from multiple stations in QT table \ |
||||
input: raw group data (array of ints) \ |
||||
4x2 raw block data, 4x1 offset chars, 1x1 number of valid blocks (of last 50) \ |
||||
[block1_upper,block1_lower,block2_upper,block2_lower,...,offset1,offset2,offset3,offset4,numerrors]\\ |
||||
|
||||
The GUI hint can be used to position the widget within the application. \ |
||||
The hint is of the form "tab_id@tab_index: row, col, row_span, col_span" \ |
||||
Both the tab specification and the grid position are optional. |
||||
</doc> |
||||
|
||||
</block> |
||||
@ -1,37 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_rds_table_qt |
||||
label: RDS Table (qt) |
||||
category: '[multirds]' |
||||
|
||||
parameters: |
||||
- id: label |
||||
label: Label |
||||
dtype: string |
||||
hide: ${ ('none' if label else 'part') } |
||||
- id: gui_hint |
||||
label: GUI Hint |
||||
dtype: gui_hint |
||||
hide: part |
||||
- id: nPorts |
||||
label: Number of Ports |
||||
dtype: int |
||||
default: '2' |
||||
hide: part |
||||
|
||||
inputs: |
||||
- domain: message |
||||
id: in |
||||
multiplicity: ${ nPorts } |
||||
|
||||
templates: |
||||
imports: |- |
||||
import multirds |
||||
from multirds.rds_table_qt import rds_table_qt, rds_table_qt_Widget,rds_table_qt_Signals |
||||
var_make: self.${id} = ${id} = ${value} |
||||
make: "<% win = 'self._%s_win'%id %>\n\t\t<% signals = 'self._%s_signals'%id %>\n\ |
||||
% if not label:\n\t<% label = '\"%s\"'%id %>\n% endif\n${signals} = rds_table_qt_Signals()\n\ |
||||
self.${id} = multirds.rds_table_qt(${signals},${nPorts})\n${win} = rds_table_qt_Widget(${signals},\ |
||||
\ ${label})\n${gui_hint(in)}" |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,46 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>RDS Table (qt)</name> |
||||
<key>multirds_rds_table_qt</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<import>from multirds.rds_table_qt import rds_table_qt, rds_table_qt_Widget,rds_table_qt_Signals</import> |
||||
<var_make>self.$(id) = $(id) = $value</var_make> |
||||
<make>#set $win = 'self._%s_win'%$id |
||||
#set $signals = 'self._%s_signals'%$id |
||||
#if not $label() |
||||
#set $label = '"%s"'%$id |
||||
#end if |
||||
$(signals) = rds_table_qt_Signals() |
||||
self.$(id) = multirds.rds_table_qt($(signals),$nPorts) |
||||
$(win) = rds_table_qt_Widget($signals, $label) |
||||
$(gui_hint()($win))</make> |
||||
<param> |
||||
<name>Label</name> |
||||
<key>label</key> |
||||
<value></value> |
||||
<type>string</type> |
||||
<hide>#if $label() then 'none' else 'part'#</hide> |
||||
</param> |
||||
<param> |
||||
<name>GUI Hint</name> |
||||
<key>gui_hint</key> |
||||
<value></value> |
||||
<type>gui_hint</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
<param> |
||||
<name>Number of Ports</name> |
||||
<key>nPorts</key> |
||||
<value>2</value> |
||||
<type>int</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
<sink> |
||||
<name>in</name> |
||||
<type>message</type> |
||||
<nports>$nPorts</nports> |
||||
<!--<optional>1</optional>--> |
||||
</sink> |
||||
|
||||
</block> |
||||
@ -1,52 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_station_search |
||||
label: station_search |
||||
category: '[multirds]' |
||||
|
||||
parameters: |
||||
- id: fft_len |
||||
label: fft lenngth |
||||
dtype: int |
||||
hide: ${ 'part' if vlen == 1 else 'none' } |
||||
- id: round_to |
||||
label: round to (in hz) |
||||
dtype: int |
||||
- id: num_decoders |
||||
label: number of decoders |
||||
dtype: int |
||||
hide: part |
||||
- id: center_freq |
||||
label: center frequency |
||||
dtype: float |
||||
- id: samp_rate |
||||
label: sample rate |
||||
dtype: int |
||||
- id: debug |
||||
label: Debug |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
hide: part |
||||
|
||||
inputs: |
||||
- domain: stream |
||||
dtype: float |
||||
vlen: ${ fft_len } |
||||
- domain: message |
||||
id: ctrl |
||||
optional: true |
||||
|
||||
outputs: |
||||
- domain: message |
||||
id: out |
||||
optional: true |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: multirds.station_search(${fft_len}, ${num_decoders}, ${center_freq}, ${samp_rate},${round_to},${debug}) |
||||
callbacks: |
||||
- set_center_freq(${center_freq}); |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,78 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>station_search</name> |
||||
<key>multirds_station_search</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>multirds.station_search($fft_len, $num_decoders, $center_freq, $samp_rate,$round_to,$debug)</make> |
||||
<!-- Make one 'param' node for every Parameter you want settable from the GUI. |
||||
Sub-nodes: |
||||
* name |
||||
* key (makes the value accessible as $keyname, e.g. in the make node) |
||||
* type --> |
||||
<callback>set_center_freq($center_freq);</callback> |
||||
<param> |
||||
<name>fft lenngth</name> |
||||
<key>fft_len</key> |
||||
<type>int</type> |
||||
</param> |
||||
<param> |
||||
<name>round to (in hz)</name> |
||||
<key>round_to</key> |
||||
<type>int</type> |
||||
</param> |
||||
<param> |
||||
<name>number of decoders</name> |
||||
<key>num_decoders</key> |
||||
<type>int</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
<param> |
||||
<name>center frequency</name> |
||||
<key>center_freq</key> |
||||
<type>float</type> |
||||
</param> |
||||
<param> |
||||
<name>sample rate</name> |
||||
<key>samp_rate</key> |
||||
<type>int</type> |
||||
</param> |
||||
<param> |
||||
<name>Debug</name> |
||||
<key>debug</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<hide>part</hide> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
|
||||
|
||||
<!-- Make one 'sink' node per input. Sub-nodes: |
||||
* name (an identifier for the GUI) |
||||
* type |
||||
* vlen |
||||
* optional (set to 1 for optional inputs) --> |
||||
<sink> |
||||
<name>in</name> |
||||
<type>float</type> |
||||
<vlen>$fft_len</vlen> |
||||
</sink> |
||||
<sink> |
||||
<name>ctrl</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</sink> |
||||
<source> |
||||
<name>out</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</source> |
||||
|
||||
</block> |
||||
@ -1,29 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_stream_router |
||||
label: Stream router |
||||
category: '[MULTIRDS]' |
||||
|
||||
parameters: |
||||
- id: ninputs |
||||
label: Ninputs |
||||
dtype: int |
||||
- id: noutputs |
||||
label: Noutputs |
||||
dtype: int |
||||
|
||||
inputs: |
||||
- domain: stream |
||||
dtype: float |
||||
multiplicity: '9' |
||||
|
||||
outputs: |
||||
- domain: stream |
||||
dtype: float |
||||
multiplicity: '3' |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: multirds.stream_router(${ninputs}, ${noutputs}) |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,54 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>stream_router</name> |
||||
<key>multirds_stream_router</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>multirds.stream_router($ninputs, $noutputs)</make> |
||||
|
||||
<param> |
||||
<name>Type</name> |
||||
<key>type</key> |
||||
<value>float</value> |
||||
<type>enum</type> |
||||
<option><name>Complex</name><key>complex</key><opt>fcn:sink_c</opt></option> |
||||
<option><name>Float</name><key>float</key><opt>fcn:sink_f</opt></option> |
||||
</param> |
||||
<param> |
||||
<name>Number of inputs</name> |
||||
<key>ninputs</key> |
||||
<value>9</value> |
||||
<type>int</type> |
||||
</param> |
||||
<param> |
||||
<name>Number of outputs</name> |
||||
<key>noutputs</key> |
||||
<value>3</value> |
||||
<type>int</type> |
||||
</param> |
||||
|
||||
<!-- Make one 'sink' node per input. Sub-nodes: |
||||
* name (an identifier for the GUI) |
||||
* type |
||||
* vlen |
||||
* optional (set to 1 for optional inputs) --> |
||||
<sink> |
||||
<name>in</name> |
||||
<type>$type</type> |
||||
<nports>$ninputs</nports> |
||||
</sink> |
||||
<sink> |
||||
<name>ctrl</name> |
||||
<type>message</type> |
||||
</sink> |
||||
<!-- Make one 'source' node per output. Sub-nodes: |
||||
* name (an identifier for the GUI) |
||||
* type |
||||
* vlen |
||||
* optional (set to 1 for optional inputs) --> |
||||
<source> |
||||
<name>out</name> |
||||
<type>$type</type> |
||||
<nports>$noutputs</nports> |
||||
</source> |
||||
</block> |
||||
@ -1,30 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_stream_selector |
||||
label: stream_selector |
||||
category: '[multirds]' |
||||
|
||||
inputs: |
||||
- label: in_re |
||||
domain: stream |
||||
dtype: float |
||||
- label: in_arg |
||||
domain: stream |
||||
dtype: float |
||||
- domain: message |
||||
id: rds_re |
||||
optional: true |
||||
- domain: message |
||||
id: rds_arg |
||||
optional: true |
||||
|
||||
outputs: |
||||
- domain: message |
||||
id: rds_out |
||||
optional: true |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: multirds.stream_selector() |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,38 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>stream_selector</name> |
||||
<key>multirds_stream_selector</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>multirds.stream_selector()</make> |
||||
|
||||
<!-- <param> |
||||
<name>...</name> |
||||
<key>...</key> |
||||
<type>...</type> |
||||
</param>--> |
||||
|
||||
<sink> |
||||
<name>in_re</name> |
||||
<type>float</type> |
||||
</sink> |
||||
<sink> |
||||
<name>in_arg</name> |
||||
<type>float</type> |
||||
</sink> |
||||
<sink> |
||||
<name>rds_re</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</sink> |
||||
<sink> |
||||
<name>rds_arg</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</sink> |
||||
<source> |
||||
<name>rds_out</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</source> |
||||
</block> |
||||
@ -1,30 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_symbol_combiner |
||||
label: Symbol combiner |
||||
category: '[MULTIRDS]' |
||||
|
||||
parameters: |
||||
- id: threshold |
||||
label: Threshold |
||||
dtype: float |
||||
- id: min_diff |
||||
label: Min_diff |
||||
dtype: float |
||||
- id: log |
||||
label: Log |
||||
dtype: raw |
||||
|
||||
inputs: |
||||
- domain: stream |
||||
dtype: float |
||||
|
||||
outputs: |
||||
- domain: stream |
||||
dtype: float |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: multirds.symbol_combiner(${threshold}, ${min_diff}, ${log}) |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,70 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>symbol_combiner</name> |
||||
<key>multirds_symbol_combiner</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>multirds.symbol_combiner($threshold, $min_diff, $log)</make> |
||||
<!-- Make one 'param' node for every Parameter you want settable from the GUI. |
||||
Sub-nodes: |
||||
* name |
||||
* key (makes the value accessible as $keyname, e.g. in the make node) |
||||
* type --> |
||||
<param> |
||||
<name>Log</name> |
||||
<key>log</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>Threshold</name> |
||||
<key>threshold</key> |
||||
<value>0.25</value> |
||||
<type>float</type> |
||||
</param> |
||||
<param> |
||||
<name>min_diff</name> |
||||
<key>min_diff</key> |
||||
<value>0.2</value> |
||||
<type>float</type> |
||||
</param> |
||||
<check>0 < $min_diff < 1</check> |
||||
|
||||
<!-- Make one 'sink' node per input. Sub-nodes: |
||||
* name (an identifier for the GUI) |
||||
* type |
||||
* vlen |
||||
* optional (set to 1 for optional inputs) --> |
||||
<sink> |
||||
<name>in</name> |
||||
<type>float</type> |
||||
</sink> |
||||
<sink> |
||||
<name>ctrl</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</sink> |
||||
|
||||
<!-- Make one 'source' node per output. Sub-nodes: |
||||
* name (an identifier for the GUI) |
||||
* type |
||||
* vlen |
||||
* optional (set to 1 for optional inputs) --> |
||||
<source> |
||||
<name>ctrl</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</source> |
||||
<source> |
||||
<name>out</name> |
||||
<type>float</type> |
||||
</source> |
||||
</block> |
||||
@ -1,62 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_tmc_parser |
||||
label: tmc_parser |
||||
category: '[multirds]' |
||||
|
||||
parameters: |
||||
- id: maxheight |
||||
label: maxheight |
||||
dtype: int |
||||
default: '160' |
||||
hide: part |
||||
- id: workdir |
||||
label: work directory |
||||
dtype: string |
||||
hide: part |
||||
- id: label |
||||
label: Label |
||||
dtype: string |
||||
hide: ${ ('none' if label else 'part') } |
||||
- id: log |
||||
label: Log |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
- id: debug |
||||
label: Debug |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
- id: writeDB |
||||
label: write Database |
||||
dtype: bool |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: [Enable, Disable] |
||||
- id: gui_hint |
||||
label: GUI Hint |
||||
dtype: gui_hint |
||||
hide: part |
||||
|
||||
inputs: |
||||
- domain: message |
||||
id: in |
||||
optional: true |
||||
asserts: |
||||
- ${ open(workdir+"event-list_with_forecast_sort.csv").close() or True } |
||||
- ${ open(workdir+"directory_writable","w").close() or True } |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: "<% win = 'self._%s_win'%id %>\n <% parser = 'self.%s_parser'%id\ |
||||
\ %>\n% if not label:\n\t<% label = '\"%s\"'%id %>\n% endif\n${parser} = multirds.tmc_parser(${workdir},\ |
||||
\ ${log}, ${debug}, ${writeDB},${maxheight})\n${win} = ${parser}.getqtwidget()\n\ |
||||
${gui_hint(in)}\n " |
||||
|
||||
documentation: "maxheight = max height of widget in pixels\n\t maxheight == 0 ->\ |
||||
\ no restriction" |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,112 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>tmc_parser</name> |
||||
<key>multirds_tmc_parser</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>#set $win = 'self._%s_win'%$id |
||||
#set $parser = 'self.%s_parser'%$id |
||||
#if not $label() |
||||
#set $label = '"%s"'%$id |
||||
#end if |
||||
$(parser) = multirds.tmc_parser($workdir, $log, $debug, $writeDB,$maxheight) |
||||
$(win) = $(parser).getqtwidget() |
||||
$(gui_hint()($win)) |
||||
</make> |
||||
<!-- |
||||
multirds.tmc_parser($workdir, $log, $debug, $writeDB) |
||||
--> |
||||
<param> |
||||
<name>maxheight</name> |
||||
<key>maxheight</key> |
||||
<value>160</value> |
||||
<type>int</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
|
||||
<param> |
||||
<name>work directory</name> |
||||
<key>workdir</key> |
||||
<value></value> |
||||
<type>string</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
<param> |
||||
<name>Label</name> |
||||
<key>label</key> |
||||
<value></value> |
||||
<type>string</type> |
||||
<hide>#if $label() then 'none' else 'part'#</hide> |
||||
</param> |
||||
<param> |
||||
<name>Log</name> |
||||
<key>log</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>Debug</name> |
||||
<key>debug</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>write Database</name> |
||||
<key>writeDB</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<!--<hide>part</hide>--> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>GUI Hint</name> |
||||
<key>gui_hint</key> |
||||
<value></value> |
||||
<type>gui_hint</type> |
||||
<hide>part</hide> |
||||
</param> |
||||
<!-- |
||||
check if event-list file exists |
||||
check directory doesnt work: |
||||
<check>os.path.isdir($workdir)</check> |
||||
--> |
||||
<check>open($workdir+"event-list_with_forecast_sort.csv").close() or True</check> |
||||
|
||||
<!-- |
||||
check if workdir is writable |
||||
--> |
||||
<check>open($workdir+"directory_writable","w").close() or True</check> |
||||
|
||||
<sink> |
||||
<name>in</name> |
||||
<type>message</type> |
||||
<optional>1</optional> |
||||
</sink> |
||||
<doc> |
||||
maxheight = max height of widget in pixels |
||||
maxheight == 0 -> no restriction |
||||
</doc> |
||||
</block> |
||||
@ -1,37 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_variable_setter |
||||
label: variable_setter |
||||
category: '[multirds]' |
||||
|
||||
parameters: |
||||
- id: varname |
||||
label: varname |
||||
dtype: raw |
||||
- id: is_pair |
||||
label: Pair Mode |
||||
dtype: enum |
||||
default: 'False' |
||||
options: ['False', 'True'] |
||||
- id: msgkey |
||||
label: Key |
||||
dtype: string |
||||
hide: ${ ('none' if is_pair == 'True' else 'all') } |
||||
|
||||
inputs: |
||||
- domain: message |
||||
id: in |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: |- |
||||
<% block = 'self.%s'%id %> |
||||
<% varsetter = 'self.set_%s'%varname %> |
||||
<% guiupdater = 'self._%s_win.update_gui'%varname %> |
||||
multirds.variable_setter("$varname",${varsetter},${guiupdater},${is_pair},${msgkey}) |
||||
|
||||
documentation: |- |
||||
in pair mode this block only accepts PMT pairs that have a matching CAR |
||||
no pair mode: block accepts pmt symbols directly |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,59 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>variable_setter</name> |
||||
<key>multirds_variable_setter</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>#set $block = 'self.%s'%$id |
||||
#set $varsetter = 'self.set_%s'%$varname |
||||
#set $guiupdater = 'self._%s_win.update_gui'%$varname |
||||
multirds.variable_setter("$varname",$varsetter,$guiupdater,$is_pair,$msgkey)</make> |
||||
<!--$(block) = multirds.variable_setter($varname,$varsetter) --> |
||||
<param> |
||||
<name>varname</name> |
||||
<key>varname</key> |
||||
<value></value> |
||||
<type>raw</type> |
||||
</param> |
||||
<param> |
||||
<name>Pair Mode</name> |
||||
<key>is_pair</key> |
||||
<value>False</value> |
||||
<type>enum</type> |
||||
<option> |
||||
<name>False</name> |
||||
<key>False</key> |
||||
</option> |
||||
<option> |
||||
<name>True</name> |
||||
<key>True</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>Key</name> |
||||
<key>msgkey</key> |
||||
<value></value> |
||||
<type>string</type> |
||||
<hide>#if $is_pair() == 'True' then 'none' else 'all'#</hide> |
||||
</param> |
||||
<!-- Make one 'sink' node per input. Sub-nodes: |
||||
* name (an identifier for the GUI) |
||||
* type |
||||
* vlen |
||||
* optional (set to 1 for optional inputs) --> |
||||
<sink> |
||||
<name>in</name> |
||||
<type>message</type> |
||||
</sink> |
||||
|
||||
<!-- Make one 'source' node per output. Sub-nodes: |
||||
* name (an identifier for the GUI) |
||||
* type |
||||
* vlen |
||||
* optional (set to 1 for optional inputs) --> |
||||
<doc> |
||||
in pair mode this block only accepts PMT pairs that have a matching CAR |
||||
no pair mode: block accepts pmt symbols directly |
||||
</doc> |
||||
|
||||
</block> |
||||
@ -1,55 +0,0 @@
|
||||
# auto-generated by grc.converter |
||||
|
||||
id: multirds_vector_cutter |
||||
label: vector_cutter |
||||
category: '[multirds]' |
||||
|
||||
parameters: |
||||
- id: pad_out |
||||
label: padded output |
||||
dtype: enum |
||||
default: 'False' |
||||
options: ['True', 'False'] |
||||
option_labels: ['Yes', 'No'] |
||||
hide: part |
||||
- id: zero_len |
||||
label: num-zeros |
||||
dtype: int |
||||
default: '0' |
||||
- id: insize |
||||
label: insize |
||||
dtype: int |
||||
default: '2048' |
||||
- id: outsize |
||||
label: outsize |
||||
dtype: int |
||||
default: '1024' |
||||
- id: cutpoint |
||||
label: cutpoint |
||||
dtype: int |
||||
default: '512' |
||||
|
||||
inputs: |
||||
- domain: stream |
||||
dtype: complex |
||||
vlen: ${ insize } |
||||
|
||||
outputs: |
||||
- domain: stream |
||||
dtype: complex |
||||
vlen: ${ outsize } |
||||
- label: out_padded |
||||
domain: stream |
||||
dtype: complex |
||||
vlen: ${ insize } |
||||
optional: true |
||||
hide: ${ ('False' if pad_out == 'True' else 'True') } |
||||
|
||||
templates: |
||||
imports: import multirds |
||||
make: multirds.vector_cutter(${insize}, ${outsize}, ${cutpoint},${pad_out},${zero_len}) |
||||
callbacks: |
||||
- set_cutpoint(${cutpoint}); |
||||
- set_zero_len(${zero_len}); |
||||
|
||||
file_format: 1 |
||||
@ -0,0 +1,87 @@
|
||||
<?xml version="1.0"?> |
||||
<block> |
||||
<name>vector_cutter</name> |
||||
<key>multirds_vector_cutter</key> |
||||
<category>[multirds]</category> |
||||
<import>import multirds</import> |
||||
<make>multirds.vector_cutter($insize, $outsize, $cutpoint,$pad_out,$zero_len)</make> |
||||
<!-- Make one 'param' node for every Parameter you want settable from the GUI. |
||||
Sub-nodes: |
||||
* name |
||||
* key (makes the value accessible as $keyname, e.g. in the make node) |
||||
* type --> |
||||
<callback>set_cutpoint($cutpoint);</callback> |
||||
<callback>set_zero_len($zero_len);</callback> |
||||
<!-- <param> |
||||
<name>padded output</name> |
||||
<key>pad_out</key> |
||||
<value>False</value> |
||||
<type>bool</type> |
||||
<option> |
||||
<name>Enable</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>Disable</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param>--> |
||||
<param> |
||||
<name>padded output</name> |
||||
<key>pad_out</key> |
||||
<value>False</value> |
||||
<type>enum</type> |
||||
<hide>part</hide> |
||||
<option> |
||||
<name>Yes</name> |
||||
<key>True</key> |
||||
</option> |
||||
<option> |
||||
<name>No</name> |
||||
<key>False</key> |
||||
</option> |
||||
</param> |
||||
<param> |
||||
<name>num-zeros</name> |
||||
<key>zero_len</key> |
||||
<value>0</value> |
||||
<type>int</type> |
||||
</param> |
||||
<param> |
||||
<name>insize</name> |
||||
<key>insize</key> |
||||
<value>2048</value> |
||||
<type>int</type> |
||||
</param> |
||||
<param> |
||||
<name>outsize</name> |
||||
<key>outsize</key> |
||||
<value>1024</value> |
||||
<type>int</type> |
||||
</param> |
||||
<param> |
||||
<name>cutpoint</name> |
||||
<key>cutpoint</key> |
||||
<value>512</value> |
||||
<type>int</type> |
||||
</param> |
||||
|
||||
<sink> |
||||
<name>in</name> |
||||
<type>complex</type> |
||||
<vlen>$insize</vlen> |
||||
</sink> |
||||
<source> |
||||
<name>out</name> |
||||
<type>complex</type> |
||||
<vlen>$outsize</vlen> |
||||
</source> |
||||
<source> |
||||
<name>out_padded</name> |
||||
<type>complex</type> |
||||
<vlen>$insize</vlen> |
||||
<optional>#if $pad_out() == 'True' then 'False' else 'True'#</optional> |
||||
<!--<optional>#if $pad_out==True then '1' else '0'#</optional>--> |
||||
<hide>#if $pad_out() == 'True' then 'False' else 'True'#</hide> |
||||
</source> |
||||
</block> |
||||
@ -0,0 +1,226 @@
|
||||
# |
||||
# Copyright 2004,2009,2012 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. |
||||
# |
||||
|
||||
"""Misc utilities used at build time |
||||
""" |
||||
|
||||
import re, os, os.path |
||||
from build_utils_codes import * |
||||
|
||||
|
||||
# set srcdir to the directory that contains Makefile.am |
||||
try: |
||||
srcdir = os.environ['srcdir'] |
||||
except KeyError, e: |
||||
srcdir = "." |
||||
srcdir = srcdir + '/' |
||||
|
||||
# set do_makefile to either true or false dependeing on the environment |
||||
try: |
||||
if os.environ['do_makefile'] == '0': |
||||
do_makefile = False |
||||
else: |
||||
do_makefile = True |
||||
except KeyError, e: |
||||
do_makefile = False |
||||
|
||||
# set do_sources to either true or false dependeing on the environment |
||||
try: |
||||
if os.environ['do_sources'] == '0': |
||||
do_sources = False |
||||
else: |
||||
do_sources = True |
||||
except KeyError, e: |
||||
do_sources = True |
||||
|
||||
name_dict = {} |
||||
|
||||
def log_output_name (name): |
||||
(base, ext) = os.path.splitext (name) |
||||
ext = ext[1:] # drop the leading '.' |
||||
|
||||
entry = name_dict.setdefault (ext, []) |
||||
entry.append (name) |
||||
|
||||
def open_and_log_name (name, dir): |
||||
global do_sources |
||||
if do_sources: |
||||
f = open (name, dir) |
||||
else: |
||||
f = None |
||||
log_output_name (name) |
||||
return f |
||||
|
||||
def expand_template (d, template_filename, extra = ""): |
||||
'''Given a dictionary D and a TEMPLATE_FILENAME, expand template into output file |
||||
''' |
||||
global do_sources |
||||
output_extension = extract_extension (template_filename) |
||||
template = open_src (template_filename, 'r') |
||||
output_name = d['NAME'] + extra + '.' + output_extension |
||||
log_output_name (output_name) |
||||
if do_sources: |
||||
output = open (output_name, 'w') |
||||
do_substitution (d, template, output) |
||||
output.close () |
||||
template.close () |
||||
|
||||
def output_glue (dirname): |
||||
output_makefile_fragment () |
||||
output_ifile_include (dirname) |
||||
|
||||
def output_makefile_fragment (): |
||||
global do_makefile |
||||
if not do_makefile: |
||||
return |
||||
# overwrite the source, which must be writable; this should have been |
||||
# checked for beforehand in the top-level Makefile.gen.gen . |
||||
f = open (os.path.join (os.environ.get('gendir', os.environ.get('srcdir', '.')), 'Makefile.gen'), 'w') |
||||
f.write ('#\n# This file is machine generated. All edits will be overwritten\n#\n') |
||||
output_subfrag (f, 'h') |
||||
output_subfrag (f, 'i') |
||||
output_subfrag (f, 'cc') |
||||
f.close () |
||||
|
||||
def output_ifile_include (dirname): |
||||
global do_sources |
||||
if do_sources: |
||||
f = open ('%s_generated.i' % (dirname,), 'w') |
||||
f.write ('//\n// This file is machine generated. All edits will be overwritten\n//\n') |
||||
files = name_dict.setdefault ('i', []) |
||||
files.sort () |
||||
f.write ('%{\n') |
||||
for file in files: |
||||
f.write ('#include <%s>\n' % (file[0:-1] + 'h',)) |
||||
f.write ('%}\n\n') |
||||
for file in files: |
||||
f.write ('%%include <%s>\n' % (file,)) |
||||
|
||||
def output_subfrag (f, ext): |
||||
files = name_dict.setdefault (ext, []) |
||||
files.sort () |
||||
f.write ("GENERATED_%s =" % (ext.upper ())) |
||||
for file in files: |
||||
f.write (" \\\n\t%s" % (file,)) |
||||
f.write ("\n\n") |
||||
|
||||
def extract_extension (template_name): |
||||
# template name is something like: GrFIRfilterXXX.h.t |
||||
# we return everything between the penultimate . and .t |
||||
mo = re.search (r'\.([a-z]+)\.t$', template_name) |
||||
if not mo: |
||||
raise ValueError, "Incorrectly formed template_name '%s'" % (template_name,) |
||||
return mo.group (1) |
||||
|
||||
def open_src (name, mode): |
||||
global srcdir |
||||
return open (os.path.join (srcdir, name), mode) |
||||
|
||||
def do_substitution (d, in_file, out_file): |
||||
def repl (match_obj): |
||||
key = match_obj.group (1) |
||||
# print key |
||||
return d[key] |
||||
|
||||
inp = in_file.read () |
||||
out = re.sub (r"@([a-zA-Z0-9_]+)@", repl, inp) |
||||
out_file.write (out) |
||||
|
||||
|
||||
|
||||
copyright = '''/* -*- c++ -*- */ |
||||
/* |
||||
* Copyright 2003,2004 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. |
||||
*/ |
||||
''' |
||||
|
||||
def is_complex (code3): |
||||
if i_code (code3) == 'c' or o_code (code3) == 'c': |
||||
return '1' |
||||
else: |
||||
return '0' |
||||
|
||||
|
||||
def standard_dict (name, code3, package='gr'): |
||||
d = {} |
||||
d['NAME'] = name |
||||
d['NAME_IMPL'] = name+'_impl' |
||||
d['GUARD_NAME'] = 'INCLUDED_%s_%s_H' % (package.upper(), name.upper()) |
||||
d['GUARD_NAME_IMPL'] = 'INCLUDED_%s_%s_IMPL_H' % (package.upper(), name.upper()) |
||||
d['BASE_NAME'] = re.sub ('^' + package + '_', '', name) |
||||
d['SPTR_NAME'] = '%s_sptr' % name |
||||
d['WARNING'] = 'WARNING: this file is machine generated. Edits will be overwritten' |
||||
d['COPYRIGHT'] = copyright |
||||
d['TYPE'] = i_type (code3) |
||||
d['I_TYPE'] = i_type (code3) |
||||
d['O_TYPE'] = o_type (code3) |
||||
d['TAP_TYPE'] = tap_type (code3) |
||||
d['IS_COMPLEX'] = is_complex (code3) |
||||
return d |
||||
|
||||
|
||||
def standard_dict2 (name, code3, package): |
||||
d = {} |
||||
d['NAME'] = name |
||||
d['BASE_NAME'] = name |
||||
d['GUARD_NAME'] = 'INCLUDED_%s_%s_H' % (package.upper(), name.upper()) |
||||
d['WARNING'] = 'WARNING: this file is machine generated. Edits will be overwritten' |
||||
d['COPYRIGHT'] = copyright |
||||
d['TYPE'] = i_type (code3) |
||||
d['I_TYPE'] = i_type (code3) |
||||
d['O_TYPE'] = o_type (code3) |
||||
d['TAP_TYPE'] = tap_type (code3) |
||||
d['IS_COMPLEX'] = is_complex (code3) |
||||
return d |
||||
|
||||
def standard_impl_dict2 (name, code3, package): |
||||
d = {} |
||||
d['NAME'] = name |
||||
d['IMPL_NAME'] = name |
||||
d['BASE_NAME'] = name.rstrip("impl").rstrip("_") |
||||
d['GUARD_NAME'] = 'INCLUDED_%s_%s_H' % (package.upper(), name.upper()) |
||||
d['WARNING'] = 'WARNING: this file is machine generated. Edits will be overwritten' |
||||
d['COPYRIGHT'] = copyright |
||||
d['FIR_TYPE'] = "fir_filter_" + code3 |
||||
d['CFIR_TYPE'] = "fir_filter_" + code3[0:2] + 'c' |
||||
d['TYPE'] = i_type (code3) |
||||
d['I_TYPE'] = i_type (code3) |
||||
d['O_TYPE'] = o_type (code3) |
||||
d['TAP_TYPE'] = tap_type (code3) |
||||
d['IS_COMPLEX'] = is_complex (code3) |
||||
return d |
||||
@ -0,0 +1,52 @@
|
||||
# |
||||
# Copyright 2004 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. |
||||
# |
||||
|
||||
def i_code (code3): |
||||
return code3[0] |
||||
|
||||
def o_code (code3): |
||||
if len (code3) >= 2: |
||||
return code3[1] |
||||
else: |
||||
return code3[0] |
||||
|
||||
def tap_code (code3): |
||||
if len (code3) >= 3: |
||||
return code3[2] |
||||
else: |
||||
return code3[0] |
||||
|
||||
def i_type (code3): |
||||
return char_to_type[i_code (code3)] |
||||
|
||||
def o_type (code3): |
||||
return char_to_type[o_code (code3)] |
||||
|
||||
def tap_type (code3): |
||||
return char_to_type[tap_code (code3)] |
||||
|
||||
|
||||
char_to_type = {} |
||||
char_to_type['s'] = 'short' |
||||
char_to_type['i'] = 'int' |
||||
char_to_type['f'] = 'float' |
||||
char_to_type['c'] = 'gr_complex' |
||||
char_to_type['b'] = 'unsigned char' |
||||
@ -0,0 +1,279 @@
|
||||
#!/usr/bin/env python |
||||
# -*- coding: utf-8 -*- |
||||
# |
||||
# Copyright 2015 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. |
||||
# |
||||
|
||||
from PyQt4 import Qt, QtCore, QtGui |
||||
import pmt |
||||
from gnuradio import gr |
||||
|
||||
class qtgui_range(gr.basic_block): |
||||
def set_test(self,value): |
||||
print("test callback invoked") |
||||
print(value) |
||||
def __init__(self, minv, maxv, step, default, min_length): |
||||
gr.basic_block.__init__(self, |
||||
name="qtgui_range", |
||||
in_sig=None, |
||||
out_sig=None) |
||||
self.min = float(minv) |
||||
self.max = float(maxv) |
||||
self.step = float(step) |
||||
self.default = float(default) |
||||
self.min_length = min_length |
||||
self.find_precision() |
||||
self.find_nsteps() |
||||
def find_precision(self): |
||||
# Get the decimal part of the step |
||||
temp = str(float(self.step) - int(self.step))[2:] |
||||
precision = len(temp) if temp is not '0' else 0 |
||||
precision = min(precision, 13) |
||||
|
||||
if precision == 0 and self.max < 100: |
||||
self.precision = 1 # Always have a decimal in this case |
||||
else: |
||||
self.precision = (precision + 2) if precision > 0 else 0 |
||||
|
||||
def find_nsteps(self): |
||||
self.nsteps = (self.max + self.step - self.min)/self.step |
||||
|
||||
def demap_range(self, val): |
||||
if val > self.max: |
||||
val = self.max |
||||
if val < self.min: |
||||
val = self.min |
||||
return ((val-self.min)/self.step) |
||||
|
||||
def map_range(self, val): |
||||
if val > self.nsteps: |
||||
val = self.max |
||||
if val < 0: |
||||
val = 0 |
||||
return (val*self.step+self.min) |
||||
|
||||
|
||||
class RangeWidget(QtGui.QWidget): |
||||
def update_gui(self,value): |
||||
#print("update_gui called on widget %s"%self.label) |
||||
#print(value) |
||||
#self.d_widget.slider.setValue(value) |
||||
if self.range.min < value < self.range.max: |
||||
if self.style=="counter_slider": |
||||
self.d_widget.counter.setValue(value) |
||||
else: |
||||
self.d_widget.setValue(value) |
||||
else: |
||||
print("value %i not in range %i...%i"%(value,self.range.min,self.range.max)) |
||||
#self.notifyChanged(self.rangeType(value)) |
||||
def __init__(self, ranges, slot, label, style, rangeType=float): |
||||
""" Creates the QT Range widget """ |
||||
QtGui.QWidget.__init__(self) |
||||
|
||||
self.range = ranges |
||||
self.style = style |
||||
self.label=label |
||||
|
||||
# rangeType tells the block how to return the value as a standard |
||||
self.rangeType = rangeType |
||||
|
||||
# Top-block function to call when any value changes |
||||
# Some widgets call this directly when their value changes. |
||||
# Others have intermediate functions to map the value into the right range. |
||||
self.notifyChanged = slot |
||||
|
||||
layout = Qt.QHBoxLayout() |
||||
label = Qt.QLabel(label) |
||||
layout.addWidget(label) |
||||
|
||||
if style == "dial": |
||||
self.d_widget = self.Dial(self, self.range, self.notifyChanged, rangeType) |
||||
elif style == "slider": |
||||
self.d_widget = self.Slider(self, self.range, self.notifyChanged, rangeType) |
||||
elif style == "counter": |
||||
# The counter widget can be directly wired to the notifyChanged slot |
||||
self.d_widget = self.Counter(self, self.range, self.notifyChanged, rangeType) |
||||
else: |
||||
# The CounterSlider needs its own internal handlers before calling notifyChanged |
||||
self.d_widget = self.CounterSlider(self, self.range, self.notifyChanged, rangeType) |
||||
|
||||
layout.addWidget(self.d_widget) |
||||
self.setLayout(layout) |
||||
|
||||
class Dial(QtGui.QDial): |
||||
""" Creates the range using a dial """ |
||||
def __init__(self, parent, ranges, slot, rangeType=float): |
||||
QtGui.QDial.__init__(self, parent) |
||||
|
||||
self.rangeType = rangeType |
||||
|
||||
# Setup the dial |
||||
self.setRange(0, ranges.nsteps-1) |
||||
self.setSingleStep(1) |
||||
self.setNotchesVisible(True) |
||||
self.range = ranges |
||||
|
||||
# Round the initial value to the closest tick |
||||
temp = int(round(ranges.demap_range(ranges.default), 0)) |
||||
self.setValue(temp) |
||||
|
||||
# Setup the slots |
||||
self.valueChanged.connect(self.changed) |
||||
self.notifyChanged = slot |
||||
|
||||
def changed(self, value): |
||||
""" Handles maping the value to the right range before calling the slot. """ |
||||
val = self.range.map_range(value) |
||||
self.notifyChanged(self.rangeType(val)) |
||||
|
||||
class Slider(QtGui.QSlider): |
||||
""" Creates the range using a slider """ |
||||
def __init__(self, parent, ranges, slot, rangeType=float): |
||||
QtGui.QSlider.__init__(self, QtCore.Qt.Horizontal, parent) |
||||
|
||||
self.rangeType = rangeType |
||||
|
||||
# Setup the slider |
||||
#self.setFocusPolicy(QtCore.Qt.NoFocus) |
||||
self.setRange(0, ranges.nsteps - 1) |
||||
self.setTickPosition(2) |
||||
self.setSingleStep(1) |
||||
self.range = ranges |
||||
|
||||
# Round the initial value to the closest tick |
||||
temp = int(round(ranges.demap_range(ranges.default), 0)) |
||||
self.setValue(temp) |
||||
|
||||
if ranges.nsteps > ranges.min_length: |
||||
interval = int(ranges.nsteps/ranges.min_length) |
||||
self.setTickInterval(interval) |
||||
self.setPageStep(interval) |
||||
else: |
||||
self.setTickInterval(1) |
||||
self.setPageStep(1) |
||||
|
||||
# Setup the handler function |
||||
self.valueChanged.connect(self.changed) |
||||
self.notifyChanged = slot |
||||
|
||||
def changed(self, value): |
||||
""" Handle the valueChanged signal and map the value into the correct range """ |
||||
val = self.range.map_range(value) |
||||
self.notifyChanged(self.rangeType(val)) |
||||
|
||||
def mousePressEvent(self, event): |
||||
if((event.button() == QtCore.Qt.LeftButton)): |
||||
new = self.minimum() + ((self.maximum()-self.minimum()) * event.x()) / self.width() |
||||
self.setValue(new) |
||||
event.accept() |
||||
# Use repaint rather than calling the super mousePressEvent. |
||||
# Calling super causes issue where slider jumps to wrong value. |
||||
QtGui.QSlider.repaint(self) |
||||
|
||||
def mouseMoveEvent(self, event): |
||||
new = self.minimum() + ((self.maximum()-self.minimum()) * event.x()) / self.width() |
||||
self.setValue(new) |
||||
event.accept() |
||||
QtGui.QSlider.repaint(self) |
||||
|
||||
class Counter(QtGui.QDoubleSpinBox): |
||||
""" Creates the range using a counter """ |
||||
def __init__(self, parent, ranges, slot, rangeType=float): |
||||
QtGui.QDoubleSpinBox.__init__(self, parent) |
||||
|
||||
self.rangeType = rangeType |
||||
|
||||
# Setup the counter |
||||
self.setRange(ranges.min, ranges.max) |
||||
self.setValue(ranges.default) |
||||
self.setSingleStep(ranges.step) |
||||
self.setKeyboardTracking(False) |
||||
self.setDecimals(ranges.precision) |
||||
|
||||
# The counter already handles floats and can be connected directly. |
||||
self.valueChanged.connect(self.changed) |
||||
self.notifyChanged = slot |
||||
|
||||
def changed(self, value): |
||||
""" Handle the valueChanged signal by converting to the right type """ |
||||
self.notifyChanged(self.rangeType(value)) |
||||
|
||||
class CounterSlider(QtGui.QWidget): |
||||
""" Creates the range using a counter and slider """ |
||||
def __init__(self, parent, ranges, slot, rangeType=float): |
||||
QtGui.QWidget.__init__(self, parent) |
||||
|
||||
self.rangeType = rangeType |
||||
|
||||
# Slot to call in the parent |
||||
self.notifyChanged = slot |
||||
|
||||
self.slider = RangeWidget.Slider(parent, ranges, self.sliderChanged, rangeType) |
||||
self.counter = RangeWidget.Counter(parent, ranges, self.counterChanged, rangeType) |
||||
|
||||
# Need another horizontal layout to wrap the other widgets. |
||||
layout = Qt.QHBoxLayout() |
||||
layout.addWidget(self.slider) |
||||
layout.addWidget(self.counter) |
||||
self.setLayout(layout) |
||||
|
||||
# Flag to ignore the slider event caused by a change to the counter. |
||||
self.ignoreSlider = False |
||||
self.range = ranges |
||||
|
||||
def sliderChanged(self, value): |
||||
""" Handles changing the counter when the slider is updated """ |
||||
# If the counter was changed, ignore any of these events |
||||
if not self.ignoreSlider: |
||||
# Value is already float. Just set the counter |
||||
self.counter.setValue(self.rangeType(value)) |
||||
self.notifyChanged(self.rangeType(value)) |
||||
self.ignoreSlider = False |
||||
|
||||
def counterChanged(self, value): |
||||
""" Handles changing the slider when the counter is updated """ |
||||
# Get the current slider value and check to see if the new value changes it |
||||
current = self.slider.value() |
||||
new = int(round(self.range.demap_range(value), 0)) |
||||
|
||||
# If it needs to change, ignore the slider event |
||||
# Otherwise, the slider will cause the counter to round to the nearest tick |
||||
if current != new: |
||||
self.ignoreSlider = True |
||||
self.slider.setValue(new) |
||||
|
||||
self.notifyChanged(self.rangeType(value)) |
||||
|
||||
|
||||
if __name__ == "__main__": |
||||
from PyQt4 import Qt |
||||
import sys |
||||
|
||||
def valueChanged(frequency): |
||||
print("Value updated - " + str(frequency)) |
||||
|
||||
app = Qt.QApplication(sys.argv) |
||||
widget = RangeWidget(qtgui_range(0, 100, 10, 1, 100), valueChanged, "Test", "counter_slider", int) |
||||
|
||||
widget.show() |
||||
widget.setWindowTitle("Test Qt Range") |
||||
app.exec_() |
||||
|
||||
widget = None |
||||
@ -0,0 +1,105 @@
|
||||
#!/usr/bin/env python2 |
||||
# -*- coding: utf-8 -*- |
||||
################################################## |
||||
# GNU Radio Python Flow Graph |
||||
# Title: Top Block |
||||
# Generated: Thu Jun 8 13:38:58 2017 |
||||
################################################## |
||||
|
||||
if __name__ == '__main__': |
||||
import ctypes |
||||
import sys |
||||
if sys.platform.startswith('linux'): |
||||
try: |
||||
x11 = ctypes.cdll.LoadLibrary('libX11.so') |
||||
x11.XInitThreads() |
||||
except: |
||||
print "Warning: failed to XInitThreads()" |
||||
|
||||
from PyQt4 import Qt |
||||
from gnuradio import blocks |
||||
from gnuradio import eng_notation |
||||
from gnuradio import gr |
||||
from gnuradio.eng_option import eng_option |
||||
from gnuradio.filter import firdes |
||||
from optparse import OptionParser |
||||
import multirds |
||||
import sys |
||||
from gnuradio import qtgui |
||||
|
||||
|
||||
class top_block(gr.top_block, Qt.QWidget): |
||||
|
||||
def __init__(self): |
||||
gr.top_block.__init__(self, "Top Block") |
||||
Qt.QWidget.__init__(self) |
||||
self.setWindowTitle("Top Block") |
||||
qtgui.util.check_set_qss() |
||||
try: |
||||
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) |
||||
except: |
||||
pass |
||||
self.top_scroll_layout = Qt.QVBoxLayout() |
||||
self.setLayout(self.top_scroll_layout) |
||||
self.top_scroll = Qt.QScrollArea() |
||||
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) |
||||
self.top_scroll_layout.addWidget(self.top_scroll) |
||||
self.top_scroll.setWidgetResizable(True) |
||||
self.top_widget = Qt.QWidget() |
||||
self.top_scroll.setWidget(self.top_widget) |
||||
self.top_layout = Qt.QVBoxLayout(self.top_widget) |
||||
self.top_grid_layout = Qt.QGridLayout() |
||||
self.top_layout.addLayout(self.top_grid_layout) |
||||
|
||||
self.settings = Qt.QSettings("GNU Radio", "top_block") |
||||
self.restoreGeometry(self.settings.value("geometry").toByteArray()) |
||||
|
||||
################################################## |
||||
# Variables |
||||
################################################## |
||||
self.samp_rate = samp_rate = 32000 |
||||
|
||||
################################################## |
||||
# Blocks |
||||
################################################## |
||||
self.multirds_rds_decoder_redsea_0 = multirds.rds_decoder_redsea(False, True) |
||||
self.blocks_null_source_0 = blocks.null_source(gr.sizeof_char*1) |
||||
|
||||
################################################## |
||||
# Connections |
||||
################################################## |
||||
self.connect((self.blocks_null_source_0, 0), (self.multirds_rds_decoder_redsea_0, 0)) |
||||
|
||||
def closeEvent(self, event): |
||||
self.settings = Qt.QSettings("GNU Radio", "top_block") |
||||
self.settings.setValue("geometry", self.saveGeometry()) |
||||
event.accept() |
||||
|
||||
def get_samp_rate(self): |
||||
return self.samp_rate |
||||
|
||||
def set_samp_rate(self, samp_rate): |
||||
self.samp_rate = samp_rate |
||||
|
||||
|
||||
def main(top_block_cls=top_block, options=None): |
||||
|
||||
from distutils.version import StrictVersion |
||||
if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"): |
||||
style = gr.prefs().get_string('qtgui', 'style', 'raster') |
||||
Qt.QApplication.setGraphicsSystem(style) |
||||
qapp = Qt.QApplication(sys.argv) |
||||
|
||||
tb = top_block_cls() |
||||
tb.start() |
||||
tb.show() |
||||
|
||||
def quitting(): |
||||
tb.stop() |
||||
tb.wait() |
||||
qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting) |
||||
qapp.exec_() |
||||
|
||||
|
||||
if __name__ == '__main__': |
||||
main() |
||||
Loading…
Reference in new issue