gnuradio-3.7.2.1/ 0000755 0001750 0001750 00000000000 12246237611 013326 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/CMakeLists.txt 0000664 0001750 0001750 00000030520 12246225607 016072 0 ustar jcorgan jcorgan # Copyright 2010-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.
########################################################################
if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
message(FATAL_ERROR "Prevented in-tree build. This is bad practice.")
endif(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
########################################################################
# Project setup
########################################################################
cmake_minimum_required(VERSION 2.6)
project(gnuradio CXX C)
enable_testing()
#select the release build type by default to get optimization flags
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "Release")
message(STATUS "Build type not specified: defaulting to release.")
endif(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")
list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules)
# Set the version information here
set(VERSION_INFO_MAJOR_VERSION 3)
set(VERSION_INFO_API_COMPAT 7)
set(VERSION_INFO_MINOR_VERSION 2)
set(VERSION_INFO_MAINT_VERSION 1)
include(GrVersion) #setup version info
# Append -O2 optimization flag for Debug builds
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O2")
SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -O2")
########################################################################
# Environment setup
########################################################################
IF(NOT DEFINED BOOST_ROOT)
SET(BOOST_ROOT ${CMAKE_INSTALL_PREFIX})
ENDIF()
if(ENABLE_GR_CTRLPORT)
set(GR_CTRLPORT True)
endif(ENABLE_GR_CTRLPORT)
########################################################################
# Import executables from a native build (for cross compiling)
# http://www.vtk.org/Wiki/CMake_Cross_Compiling#Using_executables_in_the_build_created_during_the_build
########################################################################
if(IMPORT_EXECUTABLES)
include(${IMPORT_EXECUTABLES})
endif(IMPORT_EXECUTABLES)
#set file that the native build will fill with exports
set(EXPORT_FILE ${CMAKE_BINARY_DIR}/ImportExecutables.cmake)
file(WRITE ${EXPORT_FILE}) #blank the file (subdirs will append)
########################################################################
# Compiler specific setup
########################################################################
include(GrMiscUtils) #compiler flag check
if(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
#http://gcc.gnu.org/wiki/Visibility
GR_ADD_CXX_COMPILER_FLAG_IF_AVAILABLE(-fvisibility=hidden HAVE_VISIBILITY_HIDDEN)
endif()
if(CMAKE_COMPILER_IS_GNUCXX)
GR_ADD_CXX_COMPILER_FLAG_IF_AVAILABLE(-Wsign-compare HAVE_WARN_SIGN_COMPARE)
GR_ADD_CXX_COMPILER_FLAG_IF_AVAILABLE(-Wall HAVE_WARN_ALL)
GR_ADD_CXX_COMPILER_FLAG_IF_AVAILABLE(-Wno-uninitialized HAVE_WARN_NO_UNINITIALIZED)
endif(CMAKE_COMPILER_IS_GNUCXX)
if(MSVC)
include_directories(${CMAKE_SOURCE_DIR}/cmake/msvc) #missing headers
add_definitions(-D_WIN32_WINNT=0x0501) #minimum version required is windows xp
add_definitions(-DNOMINMAX) #disables stupidity and enables std::min and std::max
add_definitions( #stop all kinds of compatibility warnings
-D_SCL_SECURE_NO_WARNINGS
-D_CRT_SECURE_NO_WARNINGS
-D_CRT_SECURE_NO_DEPRECATE
-D_CRT_NONSTDC_NO_DEPRECATE
)
add_definitions(-DHAVE_CONFIG_H)
add_definitions(/MP) #build with multiple processors
add_definitions(/bigobj) #allow for larger object files
endif(MSVC)
########################################################################
# Install directories
########################################################################
include(GrPlatform) #define LIB_SUFFIX
set(GR_RUNTIME_DIR bin)
set(GR_LIBRARY_DIR lib${LIB_SUFFIX})
set(GR_INCLUDE_DIR include)
set(GR_DATA_DIR share)
set(GR_PKG_DATA_DIR ${GR_DATA_DIR}/${CMAKE_PROJECT_NAME})
set(GR_DOC_DIR ${GR_DATA_DIR}/doc)
set(GR_PKG_DOC_DIR ${GR_DOC_DIR}/${CMAKE_PROJECT_NAME}-${DOCVER})
set(GR_CONF_DIR etc)
set(GR_PKG_CONF_DIR ${GR_CONF_DIR}/${CMAKE_PROJECT_NAME}/conf.d)
set(GR_LIBEXEC_DIR libexec)
set(GR_PKG_LIBEXEC_DIR ${GR_LIBEXEC_DIR}/${CMAKE_PROJECT_NAME})
set(GRC_BLOCKS_DIR ${GR_PKG_DATA_DIR}/grc/blocks)
# Special exception if prefix is /usr so we don't make a /usr/etc.
string(COMPARE EQUAL ${CMAKE_INSTALL_PREFIX} "/usr" isusr)
if(isusr)
set(SYSCONFDIR "/${GR_CONF_DIR}" CACHE PATH "System configuration directory")
else(isusr)
set(SYSCONFDIR "${CMAKE_INSTALL_PREFIX}/${GR_CONF_DIR}" CACHE PATH "System configuration directory" FORCE)
endif(isusr)
set(GR_PREFSDIR ${SYSCONFDIR}/${CMAKE_PROJECT_NAME}/conf.d)
OPTION(ENABLE_PERFORMANCE_COUNTERS "Enable block performance counters" OFF)
if(ENABLE_PERFORMANCE_COUNTERS)
message(STATUS "ADDING PERF COUNTERS")
SET(GR_PERFORMANCE_COUNTERS True)
add_definitions(-DGR_PERFORMANCE_COUNTERS)
else(ENABLE_PERFORMANCE_COUNTERS)
SET(GR_PERFORMANCE_COUNTERS False)
message(STATUS "NO PERF COUNTERS")
endif(ENABLE_PERFORMANCE_COUNTERS)
########################################################################
# Variables replaced when configuring the package config files
########################################################################
file(TO_NATIVE_PATH "${CMAKE_INSTALL_PREFIX}" prefix)
file(TO_NATIVE_PATH "\${prefix}" exec_prefix)
file(TO_NATIVE_PATH "\${exec_prefix}/${GR_LIBRARY_DIR}" libdir)
file(TO_NATIVE_PATH "\${prefix}/${GR_INCLUDE_DIR}" includedir)
file(TO_NATIVE_PATH "${SYSCONFDIR}" SYSCONFDIR)
file(TO_NATIVE_PATH "${GR_PREFSDIR}" GR_PREFSDIR)
########################################################################
# Create uninstall target
########################################################################
configure_file(
${CMAKE_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
@ONLY)
add_custom_target(uninstall
${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
)
########################################################################
# Enable python component
########################################################################
find_package(PythonLibs 2)
find_package(SWIG)
if(SWIG_FOUND)
message(STATUS "Minimum SWIG version required is 1.3.31")
set(SWIG_VERSION_CHECK FALSE)
if("${SWIG_VERSION}" VERSION_GREATER "1.3.30")
set(SWIG_VERSION_CHECK TRUE)
endif()
endif(SWIG_FOUND)
include(GrComponent)
GR_REGISTER_COMPONENT("python-support" ENABLE_PYTHON
PYTHONLIBS_FOUND
SWIG_FOUND
SWIG_VERSION_CHECK
)
find_package(CppUnit)
GR_REGISTER_COMPONENT("testing-support" ENABLE_TESTING
CPPUNIT_FOUND
)
########################################################################
# Add optional dlls specified in DLL_PATHS
########################################################################
foreach(path ${DLL_PATHS})
file(GLOB _dlls "${path}/*.dll")
list(APPEND ALL_DLL_FILES ${_dlls})
endforeach(path)
if(DEFINED ALL_DLL_FILES)
include(GrPackage)
CPACK_COMPONENT("extra_dlls"
DISPLAY_NAME "Extra DLLs"
DESCRIPTION "Extra DLLs for runtime dependency requirements"
)
message(STATUS "")
message(STATUS "Including the following dlls into the install:")
foreach(_dll ${ALL_DLL_FILES})
message(STATUS " ${_dll}")
endforeach(_dll)
install(FILES ${ALL_DLL_FILES} DESTINATION ${GR_RUNTIME_DIR} COMPONENT "extra_dlls")
endif()
########################################################################
# Setup volk as a subproject
########################################################################
include(GrComponent)
GR_REGISTER_COMPONENT("volk" ENABLE_VOLK)
set(VOLK_INCLUDE_DIRS
${CMAKE_CURRENT_SOURCE_DIR}/volk/include
${CMAKE_CURRENT_BINARY_DIR}/volk/include
)
if(ENABLE_VOLK)
include(GrPackage)
CPACK_SET(CPACK_COMPONENT_GROUP_VOLK_DESCRIPTION "Vector optimized library of kernels")
CPACK_COMPONENT("volk_runtime"
GROUP "Volk"
DISPLAY_NAME "Runtime"
DESCRIPTION "Dynamic link libraries"
)
CPACK_COMPONENT("volk_devel"
GROUP "Volk"
DISPLAY_NAME "Development"
DESCRIPTION "C++ headers, package config, import libraries"
)
add_subdirectory(volk)
endif(ENABLE_VOLK)
# Handle gr_log enable/disable
GR_LOGGING()
########################################################################
# Distribute the README file
########################################################################
install(
FILES README README.hacking
DESTINATION ${GR_PKG_DOC_DIR}
COMPONENT "docs"
)
########################################################################
# The following dependency libraries are needed by all gr modules:
########################################################################
list(APPEND GR_TEST_TARGET_DEPS volk gnuradio-runtime)
list(APPEND GR_TEST_PYTHON_DIRS
${CMAKE_BINARY_DIR}/gnuradio-runtime/python
${CMAKE_SOURCE_DIR}/gnuradio-runtime/python
${CMAKE_BINARY_DIR}/gnuradio-runtime/swig
)
# Note that above we put the binary gnuradio-runtime/python directory
# before the source directory. This is due to a quirk with ControlPort
# and how slice generates files and names. We want the QA and
# installed code to import the same names, so we have to grab from the
# binary directory first.
########################################################################
# Add subdirectories (in order of deps)
########################################################################
add_subdirectory(docs)
add_subdirectory(gnuradio-runtime)
add_subdirectory(gr-blocks)
add_subdirectory(grc)
add_subdirectory(gr-fec)
add_subdirectory(gr-fft)
add_subdirectory(gr-filter)
add_subdirectory(gr-analog)
add_subdirectory(gr-digital)
add_subdirectory(gr-atsc)
add_subdirectory(gr-audio)
add_subdirectory(gr-comedi)
add_subdirectory(gr-channels)
add_subdirectory(gr-noaa)
add_subdirectory(gr-pager)
add_subdirectory(gr-qtgui)
add_subdirectory(gr-trellis)
add_subdirectory(gr-uhd)
add_subdirectory(gr-utils)
add_subdirectory(gr-video-sdl)
add_subdirectory(gr-vocoder)
add_subdirectory(gr-fcd)
add_subdirectory(gr-wavelet)
add_subdirectory(gr-wxgui)
# Install our Cmake modules into $prefix/lib/cmake/gnuradio
# See "Package Configuration Files" on page:
# http://www.cmake.org/Wiki/CMake/Tutorials/Packaging
configure_file(
${CMAKE_SOURCE_DIR}/cmake/Modules/GnuradioConfigVersion.cmake.in
${CMAKE_BINARY_DIR}/cmake/Modules/GnuradioConfigVersion.cmake
@ONLY)
SET(cmake_configs
${CMAKE_SOURCE_DIR}/cmake/Modules/GnuradioConfig.cmake
${CMAKE_BINARY_DIR}/cmake/Modules/GnuradioConfigVersion.cmake
)
if(NOT CMAKE_MODULES_DIR)
set(CMAKE_MODULES_DIR lib${LIB_SUFFIX}/cmake/gnuradio)
endif(NOT CMAKE_MODULES_DIR)
# Install all other cmake files into same directory
file(GLOB cmake_others "cmake/Modules/*.cmake")
list(REMOVE_ITEM cmake_others
"${CMAKE_SOURCE_DIR}/cmake/Modules/FindGnuradio.cmake"
)
install(
FILES ${cmake_configs} ${cmake_others}
DESTINATION ${CMAKE_MODULES_DIR}
COMPONENT "runtime_devel"
)
#finalize cpack after subdirs processed
include(GrPackage)
CPACK_FINALIZE()
########################################################################
# Print summary
########################################################################
GR_PRINT_COMPONENT_SUMMARY()
message(STATUS "Using install prefix: ${CMAKE_INSTALL_PREFIX}")
message(STATUS "Building for version: ${VERSION} / ${LIBVER}")
# Create a config.h with some definitions to export to other projects.
CONFIGURE_FILE(
${CMAKE_CURRENT_SOURCE_DIR}/config.h.in
${CMAKE_CURRENT_BINARY_DIR}/config.h
)
# Install config.h in include/gnuradio
install(
FILES
${CMAKE_CURRENT_BINARY_DIR}/config.h
DESTINATION ${GR_INCLUDE_DIR}/gnuradio
COMPONENT "runtime_devel"
)
gnuradio-3.7.2.1/grc/ 0000755 0001750 0001750 00000000000 12207440367 014102 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/CMakeLists.txt 0000664 0001750 0001750 00000011222 12207440367 016642 0 ustar jcorgan jcorgan # Copyright 2011,2013 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.
########################################################################
# Setup dependencies
########################################################################
include(GrPython)
GR_PYTHON_CHECK_MODULE("python >= 2.5" sys "sys.version.split()[0] >= '2.5'" PYTHON_MIN_VER_FOUND)
GR_PYTHON_CHECK_MODULE("Cheetah >= 2.0.0" Cheetah "Cheetah.Version >= '2.0.0'" CHEETAH_FOUND)
GR_PYTHON_CHECK_MODULE("lxml >= 1.3.6" lxml.etree "lxml.etree.LXML_VERSION >= (1, 3, 6, 0)" LXML_FOUND)
GR_PYTHON_CHECK_MODULE("pygtk >= 2.10.0" gtk "gtk.pygtk_version >= (2, 10, 0)" PYGTK_FOUND)
GR_PYTHON_CHECK_MODULE("numpy" numpy True NUMPY_FOUND)
########################################################################
# Register component
########################################################################
include(GrComponent)
if(NOT CMAKE_CROSSCOMPILING)
set(grc_python_deps
PYTHON_MIN_VER_FOUND
CHEETAH_FOUND
LXML_FOUND
PYGTK_FOUND
NUMPY_FOUND
)
endif(NOT CMAKE_CROSSCOMPILING)
GR_REGISTER_COMPONENT("gnuradio-companion" ENABLE_GRC
ENABLE_GNURADIO_RUNTIME
ENABLE_PYTHON
${grc_python_deps}
)
########################################################################
# Begin conditional configuration
########################################################################
if(ENABLE_GRC)
########################################################################
# Setup CPack components
########################################################################
include(GrPackage)
CPACK_COMPONENT("grc"
DISPLAY_NAME "GNU Radio Companion"
DESCRIPTION "Graphical flow graph designer"
DEPENDS "runtime_python"
)
########################################################################
# Create and install the grc conf file
########################################################################
file(TO_NATIVE_PATH ${CMAKE_INSTALL_PREFIX}/${GRC_BLOCKS_DIR} blocksdir)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/grc.conf.in
${CMAKE_CURRENT_BINARY_DIR}/grc.conf
@ONLY)
install(
FILES ${CMAKE_CURRENT_BINARY_DIR}/grc.conf
DESTINATION ${GR_PREFSDIR}
COMPONENT "grc"
)
GR_PYTHON_INSTALL(
FILES __init__.py
DESTINATION ${GR_PYTHON_DIR}/gnuradio/grc
COMPONENT "grc"
)
########################################################################
# Appens NSIS commands to set environment variables
########################################################################
if(WIN32)
file(TO_NATIVE_PATH ${GR_PKG_DOC_DIR} GR_DOC_DIR)
string(REPLACE "\\" "\\\\" GR_DOC_DIR ${GR_DOC_DIR})
file(TO_NATIVE_PATH ${GRC_BLOCKS_DIR} GRC_BLOCKS_PATH)
string(REPLACE "\\" "\\\\" GRC_BLOCKS_PATH ${GRC_BLOCKS_PATH})
file(TO_NATIVE_PATH ${GR_PYTHON_DIR} GR_PYTHON_POSTFIX)
string(REPLACE "\\" "\\\\" GR_PYTHON_POSTFIX ${GR_PYTHON_POSTFIX})
CPACK_SET(CPACK_NSIS_EXTRA_INSTALL_COMMANDS "${CPACK_NSIS_EXTRA_INSTALL_COMMANDS}
#!include \\\"winmessages.nsh\\\"
WriteRegStr HKLM ${HLKM_ENV} \\\"GRC_BLOCKS_PATH\\\" \\\"$INSTDIR\\\\${GRC_BLOCKS_PATH}\\\"
SendMessage \\\${HWND_BROADCAST} \\\${WM_WININICHANGE} 0 \\\"STR:Environment\\\" /TIMEOUT=5000
")
CPACK_SET(CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS "${CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS}
#!include \\\"winmessages.nsh\\\"
DeleteRegValue HKLM ${HLKM_ENV} \\\"GRC_BLOCKS_PATH\\\"
SendMessage \\\${HWND_BROADCAST} \\\${WM_WININICHANGE} 0 \\\"STR:Environment\\\" /TIMEOUT=5000
")
endif(WIN32)
########################################################################
# Add subdirectories
########################################################################
add_subdirectory(base)
add_subdirectory(blocks)
add_subdirectory(freedesktop)
add_subdirectory(grc_gnuradio)
add_subdirectory(gui)
add_subdirectory(python)
add_subdirectory(scripts)
add_subdirectory(examples)
endif(ENABLE_GRC)
gnuradio-3.7.2.1/grc/todo.txt 0000664 0001750 0001750 00000005346 12207440367 015622 0 ustar jcorgan jcorgan ##################################################
# Examples
##################################################
* Push-to-Talk example
* Start/Stop the flow graph
##################################################
# Blocks
##################################################
* probe: also non-float outputs
* log slider gui control
* packet mod: whitening offset
* wx min window size in options block
* gr_adaptive_fir_ccf
* size params for the graphical sinks
* callbacks for set average on fft, waterfall, number sinks
* add units to params: Sps, Hz, dB...
* add bool type to command line option store_true or store_false
* messages for packet blocks and probe blocks
##################################################
# Features
##################################################
* extract category from doxygen
* fix up block tree to mirror current doxygen group
* remove blocks in block tree covered by doxygen
* param editor, expand entry boxes in focus
* change param dialog to panel within main window
* gui grid editor for configuring grid params/placing wxgui plots and controls
* drag from one port to another to connect
* per parameter docs
* extract individual param docs from doxygen
* doc tag in param for handwritten notes
* separate generated code into top block and gui class
* use gui.py in gr-wxgui and remove custom top_block_gui
* configuration option for adding block paths
* orientations for ports (top, right, bottom, left)
* source defaults to right, sink defaults to left
* separation of variables and gui controls
* speedup w/ background layer and animation layer
* multiple doxygen directories (doc_dir becomes doc_path)
* use pango markup in tooltips for params
* use get_var_make to determine if it is a variable, not regexp
* concept of a project, or project flow graph
* collection of blocks, hier and top
* system-wide, default/work, and user created
* use templates/macros to generate the repetative stuff in the xml
##################################################
# Problems
##################################################
* msg ports dont work with virtual connections
* dont fix this until pmts are used?
* hier block generation
* auto generate hier library on changes
* auto clean hier library when block removed
* add hier blocks to tree without restart
* dont generate py files in saved flowgraph dir
* save/restore cwd
* threads dont die on exit in probe and variable sink
* align param titles in properties dialog
* weird grid params misbehaving
* gr hier blocks have more diverse IO capabilities than we allow for
##################################################
# Future
##################################################
* require pygtk 2.12 for treeview tooltips
* remove try/except in BlockTreeWindow.py
gnuradio-3.7.2.1/grc/freedesktop/ 0000755 0001750 0001750 00000000000 11744612271 016415 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/freedesktop/CMakeLists.txt 0000644 0001750 0001750 00000003110 11744612271 021150 0 ustar jcorgan jcorgan # Copyright 2011-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.
########################################################################
set(grc_freedesktop_path ${GR_PKG_DATA_DIR}/grc/freedesktop)
install(FILES
grc-icon-256.png
grc-icon-128.png
grc-icon-64.png
grc-icon-48.png
grc-icon-32.png
gnuradio-grc.xml
gnuradio-grc.desktop
DESTINATION ${grc_freedesktop_path}
COMPONENT "grc"
)
find_program(HAVE_XDG_UTILS xdg-desktop-menu)
if(UNIX AND HAVE_XDG_UTILS)
set(SRCDIR ${CMAKE_INSTALL_PREFIX}/${grc_freedesktop_path})
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/grc_setup_freedesktop.in
${CMAKE_CURRENT_BINARY_DIR}/grc_setup_freedesktop
@ONLY)
install(
PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/grc_setup_freedesktop
DESTINATION ${GR_PKG_LIBEXEC_DIR} COMPONENT "grc"
)
endif(UNIX AND HAVE_XDG_UTILS)
gnuradio-3.7.2.1/grc/freedesktop/grc-icon-48.png 0000644 0001750 0001750 00000003233 11700377701 021054 0 ustar jcorgan jcorgan PNG
IHDR 0 0 W sRGB bKGD pHYs
B(x tIME 99@D IDAThLe __8RD *e+q4V Rp3-Ғ-YXmMZkdƖ&e%&e6Je,4]b wGď~p}g>y~>?z±
"W = ᴹ,Ilf _{=X k7n?m_L|E}V_{&^0 =}tW Α>w
6Oq}'S cj2( Q1wuwfzv
>ؐs]W6\ΌblpE h9{Ȍ0?M>̀3|e^\!pX @x_}!ۀ Bj]@,P Tε8xP?HU)T.R>9QvEIII%jE"`px x\.; "G őt aaC DvuJ .T'jڊbAQj5FN#>>ޗʀɬ,Uf (; Nkrj5 $??#O n~yҀ 7U444PYYҥKB`bw^JKK#22ҫ8 7OI,Z-.LMMEH^^7Gj S(ܐ6O hUUpGBՊkNtb Ѵan p8-r%P__իWY~5PPPdj =ޱ? ORS'7%!222DZZ o]("L&7x[z5,[LŻ; UUUBQQWW'#) ;w 2,<
-c <>ЫhB_Dm`6EYYPTHxK "**Jz nQZ1]?'$ B!RRR*zu /RSSZM6 "|ZhDDDHKK pE)FmY/ukꁚykqPXXHFFFn:ө Wf˔y\`4ޛ;M[7111fΜ9X,`?uze˖=ڽ{7vU+!Y/opRTLU`u`,l2ݵٌ"h>k,waL$N^?/5e
|"^Y㎦e^%+ò Ng. R/3R[(Q*TNo;/TχoxW ވ+J>o54=))$U(S>τ @vv
F?@>
߳mhfŶ=~5dku FyƠx*|]ּ
jsw<2 deeqײjv!2e>1" jc0 TLz{}
b1N } ;6q R6!ĹSCBYYYdd0 /4ĨP[[۠_
:1I"P*Pf' IENDB` gnuradio-3.7.2.1/grc/freedesktop/gnuradio-grc.xml 0000644 0001750 0001750 00000000411 11700377701 021512 0 ustar jcorgan jcorgan
gnuradio-3.7.2.1/grc/freedesktop/grc-icon-128.png 0000644 0001750 0001750 00000006762 11700377701 021145 0 ustar jcorgan jcorgan PNG
IHDR >a sRGB bKGD pHYs
B(x tIME !礁
rIDATx{t ?&"G1"A!1zBW) ֪E[VBSxE"/OBU!S %9 C6q sv'dws$3sw;9 Enڪtx/h|iHHH2",,>H;O˷jѳ^ *>=ekI @Rn|q$ lk5=*x7Z >N-JVG j77$[S*An][^}kV+?պvfJ z 9mq9'{n HHHH%_8y}rQ> Nxūu5`QW!<^"e! 2<:hr9t@wIf0`Z֝9_Cũ,5C aa<;{b0q; X˨G
) h Ms|2 'K
>:*Nc t`> 怸( >mu[|
|
\Dvj~X%̰!j-6>uzs@ͱQB(֣fd_{7
}Lbp/7 l\7OݿLwp3`=59$3
աS ob) /iUe da! \sC+
d ''ŀw@Pف[dޢk'_-J`RR"a$gJ`_T6DssW VCpD#0-L7O B# p1I`9SR d7x e e0! 8K]5R0h h ,'*;ߴ EP a#zm
kaPWQX9 Ο?ŋ)--ł٬*ш` 66XbbbK.-IMM%##Hˀ睜
,E
^I38tf`eeҿ|Æ
Se6Pj in'0a'hӧO QB|lb GA$rv TXXYɓ' G;P@RHׅl=[p K,&--F&[455aZihhW@}}}1[ڸq# 9җ45ܫ[nyt܌:cqnݔZ˳Zʴi[B{v8
30?>̙t -"**ؖ-[cȉ_
o1 _n ٯ_?&Mt]lٗuI[% ^ C\g=EFx. 0X)Yڞ5 !NxMWPݢ`rf)S[ p t֭eΝ |k G "+QcP'.q2[XnԩSu+;**F
|h6= Bf4x| طo6d =&OqDzNzư#G"1PCzŴitĉ۷SWWG\\/ f|!"8j#q= F.A78L/::3f {嗽]4< xJ# ڃF8,}DjK PRRەuVoPp႒jWhT ;3TWWY X,oxVԤс: 7iPˀ!CA*oҥ>YlYz)MMM m.:4AXs`N &͛gW~J|R#!mTTT(><Êj9,ު>~{n 0ΣF'& vR x%JJJx"'N{(Sƍڵk1|6oxx8S]]r3t y HLL'[\/s%:ѐF߈H2H
\ 4~aK]vkSfߓ:˕6{ $JT@zYr%k֬!::IIIa߾}dee]sn.ذu?:X\C&JE.V!r =X MXK8\gϞILL (T^(,,dժU,X3gY֯] ;st\l+&
MHiEs,jFy[Ol4ѣɌ5c2~xOQ`00g زe 6mi5 6ͨ&;bԴb|!{fB$
Q"
BHe%%%QUUE(ԩSTVVRSSCZZS5` [e!i^+7U(|#HHHH\Lj#l%@詶Jo̴ q'wQ ۤl@v5d* l rH|o:t\ x Xxj(Q^MJ :R tu} .TWq{:d=~BݣGnc&`.=U |!@| cQs~!IG{D& Ł 'HY:u~i("y < Zl[v% y]eJ LBvM$@hA13 1$B ڥ>2=&4 $c1 F>ߢ/I3''h :pe2绦 ԪG~eZ} q8B
>PD@HjpdHxz;1t[@B zIԯz .* |% M¦@BH1A
$v 'Ka>B ^/%$$H@B@B@B@B@BZmAI ! ! :I ! ! ! ! ! ! Ñ-TJ I I @8#v IENDB` gnuradio-3.7.2.1/grc/freedesktop/gnuradio-grc.desktop 0000644 0001750 0001750 00000000236 11700377701 022370 0 ustar jcorgan jcorgan [Desktop Entry]
Version=1.0
Type=Application
Name=GRC
Exec=gnuradio-companion %F
Categories=Development;
MimeType=application/gnuradio-grc;
Icon=gnuradio-grc
gnuradio-3.7.2.1/grc/freedesktop/grc-icon-32.png 0000644 0001750 0001750 00000002044 11700377701 021044 0 ustar jcorgan jcorgan PNG
IHDR szz sBIT|d pHYs : tEXtSoftware www.inkscape.org< IDATX_HdU ?wtPri
d% L@{Ȃ | km! m{"XحZX ڶ Rzr BX%t$nýNWΌ s~ {
n3`WsE_ .x㣯T
p=R, Vt]_}Il - _ Y瓊%勅+h{. U%xADSFE pQD=
iTċl6G.
. |Y$@DԲ3 hhh hs]^& ?PKH$+++} ΙWVYt``s###:88XJ@&Jcu +0??pXwvv<j8 e/Q Hgp02eiOKKKӣ---:33imnn~n`tfM`x ɵa3 ujjJOL~H"q]]]u x1 x |A6X)&0< ̪Gz .AM]8^i7Z√D :8"@3]!R4= 6_ P.0 /PѥMzc"ccc%
gsUn yGDMU= j
nCZPT nuTl1^9a3Ԥi jU\*mX+DDҪeJ?%t
e IENDB` gnuradio-3.7.2.1/grc/freedesktop/grc-icon-256.svg 0000644 0001750 0001750 00000022453 11700377701 021155 0 ustar jcorgan jcorgan
gnuradio-3.7.2.1/grc/freedesktop/grc_setup_freedesktop.in 0000644 0001750 0001750 00000005444 11700377701 023340 0 ustar jcorgan jcorgan #!/bin/bash
#
# Copyright 2008-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.
#
##################################################
# setup grc on a freedesktop platform
# $1 should be install or uninstall
# $2 is the optional path to the files
# when $2 is unspecified, the path is:
# @SRCDIR@
##################################################
ICON_SIZES="32 48 64 128 256"
if [ -n "$2" ]; then
SRCDIR="$2"
else
SRCDIR="@SRCDIR@"
fi
case "$1" in
'install')
echo "Begin freedesktop install..."
for size in ${ICON_SIZES}; do \
echo "Install icon: ${size}x${size}"
xdg-icon-resource install --noupdate --context mimetypes --theme gnome --size ${size} ${SRCDIR}/grc-icon-${size}.png application-gnuradio-grc; \
xdg-icon-resource install --noupdate --context mimetypes --size ${size} ${SRCDIR}/grc-icon-${size}.png application-gnuradio-grc; \
xdg-icon-resource install --noupdate --context apps --theme gnome --size ${size} ${SRCDIR}/grc-icon-${size}.png gnuradio-grc; \
xdg-icon-resource install --noupdate --context apps --size ${size} ${SRCDIR}/grc-icon-${size}.png gnuradio-grc; \
done
xdg-icon-resource forceupdate
echo "Install mime type"
xdg-mime install ${SRCDIR}/gnuradio-grc.xml
echo "Install menu items"
xdg-desktop-menu install ${SRCDIR}/*.desktop
echo "Done!"
echo ""
;;
'uninstall')
echo "Begin freedesktop uninstall..."
for size in ${ICON_SIZES}; do \
echo "Uninstall icon: ${size}x${size}"
xdg-icon-resource uninstall --noupdate --context mimetypes --theme gnome --size ${size} application-gnuradio-grc; \
xdg-icon-resource uninstall --noupdate --context mimetypes --size ${size} application-gnuradio-grc; \
xdg-icon-resource uninstall --noupdate --context apps --theme gnome --size ${size} gnuradio-grc; \
xdg-icon-resource uninstall --noupdate --context apps --size ${size} gnuradio-grc; \
done
xdg-icon-resource forceupdate
echo "Uninstall mime type"
xdg-mime uninstall ${SRCDIR}/gnuradio-grc.xml
echo "Uninstall menu items"
xdg-desktop-menu uninstall `ls ${SRCDIR}/*.desktop | xargs -n1 basename`
echo "Done!"
echo ""
;;
*)
echo "Usage: $0 [install|uninstall]"
;;
esac
gnuradio-3.7.2.1/grc/freedesktop/grc-icon-256.png 0000644 0001750 0001750 00000017243 11700377701 021143 0 ustar jcorgan jcorgan PNG
IHDR \rf sBIT|d pHYs
B(x tEXtSoftware www.inkscape.org< IDATxyչ3 ʎDEYE%:cB_+u5}5yըK(+"bE
*DV 2?Nꥺs>CwmO]O:uꔨ*Qh0J݁ b Ǒlw-L ٟO=<8S cb11f `LYȡvޢ|؇#7LLX`QD );0@H kV0&ZMD俁 @{P[MDV+ 7EƘ(
"Tt6n 䘈."gD/u;%"ta"R;ZEFibg%V0& " U/"〹"2k&9 ;G/Dx\pK ƤAD~ B I0W"o骚
'Uį oQ3.z _U z0&$80<te" x
cE䗪:83}|Dd 5088\=q[sR L D9ސߗ,^"Z
`Z&WDdޗR5I; 72P>˵Q`
zsG\ : H5V'~lI. ܀!w V0E-[xsNI{{,¬o9W`6Yu 'πlw;f d#0jʫa
p^ǍƳ,BD~ \
0u@ ;0q4 POߊvV̟m3Ed$07 U LQ˰ 8pj
Ϩ!ߗ\ cUuGbˀ&vTP^2w.~!?=뿰Scxǹ⋣#-eee{ r!Q,0b.
| |(>{?GH
78ȶ,XMM
={dѢEQ>}Ӵi&?0", wM|^}aCv0&O{wޝ.]PRRTW~mm-7ofӦM;wMMMVϟ?'|QFeB'";Υnp3pzZ
T{駟e˖>|[lI6mķ~~;{ϻXϞ=O())Nv.
⮭ EQYԻcZ/=Z5U^zɷ%ꫯ,jׯoSL,t$=ܣ-.Vm K-n W),=?KӦMuŊƸdm֬gƘ >
K[v){}|ƒ 6nܨ垟墋.:LUUꪫqkqC-O O {:k <
|v%7dՂ|)@UU6ms@'qy~2]fMadڵZVVVTI+ }woM`b"&#W;x1@\_Nr_YYI֭M0{'z<4o oHYWpktUͮV
wcDY{a K+V`ٞ1"OѤgСg͚EUUUɫpȕZ@OT)UM" D~:a KO=T],-Zpg1 LYY6֫ӫ'`PpR:?̖whK Yz)2f͚)4`,ͯ_>z.MHI<7>-@>3͛9OV 5<~=
P*wPUOVs VF߸ˉt_XȂ_> 5Ӏ}pnݰ;(P nڵF f o ~80
I닻|m/eG߁Ir.t?kL*q4,q]wvPJ1&*mѢg7pCaeРASN:ĤH χ|)'W;'/6 Ǥ7zS
`yt$أUt 5۬-0U}' ҴzjƎ 9O^'MglAUe̘1y(T'Gy%,
<_zd M<ѣMjՊJgeN0 3mU5p8p 4rOD irT*Qիe˖vUnu9s9 u; I{g+_\{VsQdoS}wvշo_];: 2L k};"r vm!~doKߥKݲeKԡfo@ !g6IA
\JY%\wu;mafm˖-ھ}{ٻw!gC| n05F 7FA 鸛~L,tkw2*`ZZZgN
j;eԩQ'7}BO%ۆn~R|*+"Y~n!xg @pׯ7· z(Ps;wuE j }.^m"z5r 57 :?u9ue~+"03M ׄ} 8(I |b| R8vH Â 4qV"":k֬H0'Wӵ>ɶς+
c=(M?:s}?{וֹ-,L;
RVH|v5@CZJ۴i <Ȇ=" wImGQT82 ]wt y/
A mذ!e ܢuYTx77~< TU[C СC[ h;Y&j|m^g=\@A_O. `Μ9}FK:,fk律uKtjK#O 555:q@ʱ 6m
=Bxbs=֭[3[ p2/~ZwϡE
ۻU)SЧO ?|.]h^zK/Q^^ r[n<쳞Yv-1E!w@d\X!"
kg"QDF "fI6!657 /W^yeZukrʜTL&NjҤ^z饺pb
IKzB>e ?=E8M@ ܀%ml+q*e=dmx
-[ƪUXj˗/wa] H1c:uqcҥz뭁߾};<<ݻw
@˖-C9^~r~u,KU[plX{YWFRj vX.3 _gKctfO[j=zg8?~iG탺( ڵku =YfѡC ?s1?֭/୷bԩ9 l;TW=)%K )4oޜɓ'=0j(x㍜%ƶmd=
{2״l zCA@ӦMY`Hqׯ_?Ν' ~HB*sqc_˃.h .?qѹsg ;v/ ӧO#x=yN ~{ U?zw'?__ߺ wHuyf[VzmnNҥ
={ )Ư
Nʭ yN >W'{SU?n䣁h0o6-ۚv2ITX'V^ N8O?JzRtg2x`M/YlryN + { O?qD88 w; %Su[n 6mҮ];ڶmۗ-ZD bVRR A4=|gL>iӦ fjkkwZ& @%6U];-4:+mj_z]Rռ^y\? VȄLjjjbժU;Jee%[N{]< XDX衪+X0E-0DK)0݅Q^0ǫjQ`bGUq#~Ռ"V d#) h`=+ '
o{l> {챌5O "CWDUNVwfkVd[ND4*oR
/Ҙ4`."{% kZ ^JsSׁe"r_Â=U %T4WD1"r X Fؘtj5p8\]z
lM* `LB&pL
=SMT Yn'c' m=-LMUg!C N9dm $UupnpͰ =Y0ƃU3#Cy!ח% cPTu9\}^C1iPz-7,ܓwR䍀D79 8^pd 1K d) %ʣ "RK,@v
`LTukEI11f `LY0&,c 1K Ę% cb,E0*RQL6`LY0&,c 1K Ę% cb11@l:V9e!Fj Ę% cb1;ծKIX0&| }KIX0&|})Ci`LL`L#W2/Q$a ٬`L#u A^G X0&\L_KI |f{: &;ahcf2<H*V0&"pl U|ē% cq'gH19'">U! O !9uCH,#"r 2g=G19 "G{C!b ,h`67 LWթ!(r -HGD:c
$g5 c$" ?*U"K @DZq]{JX8CU?#lX0ā^9 A_Y9d x
^ / +Q% c18GU#'k4&8~1 pΈ:`L>} /jb ~ f~q)!F$yUB 241 (V7 hiiahhMӰX,XVl66
),, m:U |'X_PL n]vV($a 4|,̚5L&>˥Kx<\.Ξ=KQQ'O$77XO_u`=Aڟ @f4?1g@WWTyy|au6o -| ! bzfsXݵk/ [nvVӓ@.xX$qV/TVV*@uttD4M*ɤzzzaS16 cʀ6:;;bƌ322C4v-ۃ `K֗ Kw#r)V\ qFÌinnVIp똠+ lGL.\` ߯&O uW6HNx8Ć4K/ jΜ9
P֭szi&ڈ#Ot lI wcЁ zEz \p6uTv U
PWV6hJ ,_ ,F*x/Yw CUZZ ۣ.rZZZjU;wjjjR IH .yz: X|(TVV*1JoϞ=`ܫV2b1 /C˖-bpq ow
SZ&̜9KR__OVVָ q8 lذ۷Ӄ yxxx)o- .nl>}ΝSRR2rmĉx<@- " ]1,# lٲՊ 5k4-
%)ڀ ; n;H4L$ N;'I5 gΜA)t&ؤYMw QQ D罍H$@/I<K ClnJTKR5 Hf@4>\1#&% 2W juQP5q1P%LN*Zm= iX|8(h[
S)8+f1r:f%5 ӉP2 ] k䒐=d;
`8H Q E֚f@7wW. IENDB` gnuradio-3.7.2.1/grc/base/ 0000755 0001750 0001750 00000000000 12237515112 015006 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/base/Platform.py 0000664 0001750 0001750 00000017253 12237515112 017156 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import os
import sys
from .. base import ParseXML, odict
from Element import Element as _Element
from FlowGraph import FlowGraph as _FlowGraph
from Connection import Connection as _Connection
from Block import Block as _Block
from Port import Port as _Port
from Param import Param as _Param
from Constants import BLOCK_TREE_DTD, FLOW_GRAPH_DTD
class Platform(_Element):
def __init__(self, name, version, key,
block_paths, block_dtd, default_flow_graph, generator,
license='', website=None, colors=[]):
"""
Make a platform from the arguments.
Args:
name: the platform name
version: the version string
key: the unique platform key
block_paths: the file paths to blocks in this platform
block_dtd: the dtd validator for xml block wrappers
default_flow_graph: the default flow graph file path
generator: the generator class for this platform
colors: a list of title, color_spec tuples
license: a multi-line license (first line is copyright)
website: the website url for this platform
Returns:
a platform object
"""
_Element.__init__(self)
self._name = name
self._version = version
self._key = key
self._license = license
self._website = website
self._block_paths = block_paths
self._block_dtd = block_dtd
self._default_flow_graph = default_flow_graph
self._generator = generator
self._colors = colors
#create a dummy flow graph for the blocks
self._flow_graph = _Element(self)
#search for *.xml files in the given search path
self.loadblocks();
def loadblocks(self):
xml_files = list()
for block_path in self._block_paths:
if os.path.isfile(block_path): xml_files.append(block_path)
elif os.path.isdir(block_path):
for dirpath, dirnames, filenames in os.walk(block_path):
for filename in sorted(filter(lambda f: f.endswith('.xml'), filenames)):
xml_files.append(os.path.join(dirpath, filename))
#load the blocks
self._blocks = odict()
self._blocks_n = odict()
self._block_tree_files = list()
for xml_file in xml_files:
try: #try to add the xml file as a block wrapper
ParseXML.validate_dtd(xml_file, self._block_dtd)
n = ParseXML.from_file(xml_file).find('block')
#inject block wrapper path
n['block_wrapper_path'] = xml_file
block = self.Block(self._flow_graph, n)
key = block.get_key()
#test against repeated keys
if key in self.get_block_keys():
print >> sys.stderr, 'Warning: Block with key "%s" already exists.\n\tIgnoring: %s'%(key, xml_file)
#store the block
else:
self._blocks[key] = block
self._blocks_n[key] = n
except ParseXML.XMLSyntaxError, e:
try: #try to add the xml file as a block tree
ParseXML.validate_dtd(xml_file, BLOCK_TREE_DTD)
self._block_tree_files.append(xml_file)
except ParseXML.XMLSyntaxError, e:
print >> sys.stderr, 'Warning: Block validation failed:\n\t%s\n\tIgnoring: %s'%(e, xml_file)
except Exception, e:
print >> sys.stderr, 'Warning: Block loading failed:\n\t%s\n\tIgnoring: %s'%(e, xml_file)
def parse_flow_graph(self, flow_graph_file):
"""
Parse a saved flow graph file.
Ensure that the file exists, and passes the dtd check.
Args:
flow_graph_file: the flow graph file
Returns:
nested data
@throws exception if the validation fails
"""
flow_graph_file = flow_graph_file or self._default_flow_graph
open(flow_graph_file, 'r') #test open
ParseXML.validate_dtd(flow_graph_file, FLOW_GRAPH_DTD)
return ParseXML.from_file(flow_graph_file)
def load_block_tree(self, block_tree):
"""
Load a block tree with categories and blocks.
Step 1: Load all blocks from the xml specification.
Step 2: Load blocks with builtin category specifications.
Args:
block_tree: the block tree object
"""
#recursive function to load categories and blocks
def load_category(cat_n, parent=[]):
#add this category
parent = parent + [cat_n.find('name')]
block_tree.add_block(parent)
#recursive call to load sub categories
map(lambda c: load_category(c, parent), cat_n.findall('cat'))
#add blocks in this category
for block_key in cat_n.findall('block'):
if block_key not in self.get_block_keys():
print >> sys.stderr, 'Warning: Block key "%s" not found when loading category tree.'%(block_key)
continue
block = self.get_block(block_key)
#if it exists, the block's category shall not be overridden by the xml tree
if not block.get_category(): block.set_category(parent)
#load the block tree and update the categories for each block
for block_tree_file in self._block_tree_files:
#recursivly put categories in blocks
load_category(ParseXML.from_file(block_tree_file).find('cat'))
#add blocks to block tree
for block in self.get_blocks():
#blocks with empty categories are hidden
if not block.get_category(): continue
block_tree.add_block(block.get_category(), block)
def __str__(self): return 'Platform - %s(%s)'%(self.get_key(), self.get_name())
def is_platform(self): return True
def get_new_flow_graph(self): return self.FlowGraph(platform=self)
def get_generator(self): return self._generator
##############################################
# Access Blocks
##############################################
def get_block_keys(self): return self._blocks.keys()
def get_block(self, key): return self._blocks[key]
def get_blocks(self): return self._blocks.values()
def get_new_block(self, flow_graph, key): return self.Block(flow_graph, n=self._blocks_n[key])
def get_name(self): return self._name
def get_version(self): return self._version
def get_key(self): return self._key
def get_license(self): return self._license
def get_website(self): return self._website
def get_colors(self): return self._colors
##############################################
# Constructors
##############################################
FlowGraph = _FlowGraph
Connection = _Connection
Block = _Block
Port = _Port
Param = _Param
gnuradio-3.7.2.1/grc/base/Port.py 0000664 0001750 0001750 00000007772 12207702530 016322 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Element import Element
class Port(Element):
def __init__(self, block, n, dir):
"""
Make a new port from nested data.
Args:
block: the parent element
n: the nested odict
dir: the direction source or sink
"""
#build the port
Element.__init__(self, block)
#grab the data
self._name = n['name']
self._key = n['key']
self._type = n['type']
self._dir = dir
def validate(self):
"""
Validate the port.
The port must be non-empty and type must a possible type.
"""
Element.validate(self)
if self.get_type() not in self.get_types():
self.add_error_message('Type "%s" is not a possible type.'%self.get_type())
def __str__(self):
if self.is_source():
return 'Source - %s(%s)'%(self.get_name(), self.get_key())
if self.is_sink():
return 'Sink - %s(%s)'%(self.get_name(), self.get_key())
def get_types(self):
"""
Get a list of all possible port types.
@throw NotImplementedError
"""
raise NotImplementedError
def is_port(self): return True
def get_color(self): return '#FFFFFF'
def get_name(self):
number = ''
if self.get_type() == 'bus':
busses = filter(lambda a: a._dir == self._dir, self.get_parent().get_ports_gui());
number = str(busses.index(self)) + '#' + str(len(self.get_associated_ports()));
return self._name + number
def get_key(self): return self._key
def is_sink(self): return self._dir == 'sink'
def is_source(self): return self._dir == 'source'
def get_type(self): return self.get_parent().resolve_dependencies(self._type)
def get_connections(self):
"""
Get all connections that use this port.
Returns:
a list of connection objects
"""
connections = self.get_parent().get_parent().get_connections()
connections = filter(lambda c: c.get_source() is self or c.get_sink() is self, connections)
return connections
def get_enabled_connections(self):
"""
Get all enabled connections that use this port.
Returns:
a list of connection objects
"""
return filter(lambda c: c.get_enabled(), self.get_connections())
def get_associated_ports(self):
if not self.get_type() == 'bus':
return [self];
else:
if self.is_source():
get_p = self.get_parent().get_sources;
bus_structure = self.get_parent().current_bus_structure['source'];
direc = 'source'
else:
get_p = self.get_parent().get_sinks;
bus_structure = self.get_parent().current_bus_structure['sink'];
direc = 'sink'
ports = [i for i in get_p() if not i.get_type() == 'bus'];
if bus_structure:
busses = [i for i in get_p() if i.get_type() == 'bus'];
bus_index = busses.index(self);
ports = filter(lambda a: ports.index(a) in bus_structure[bus_index], ports);
return ports;
gnuradio-3.7.2.1/grc/base/CMakeLists.txt 0000644 0001750 0001750 00000002331 11744612271 017553 0 ustar jcorgan jcorgan # 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.
########################################################################
GR_PYTHON_INSTALL(FILES
odict.py
ParseXML.py
Block.py
Connection.py
Constants.py
Element.py
FlowGraph.py
Param.py
Platform.py
Port.py
__init__.py
DESTINATION ${GR_PYTHON_DIR}/gnuradio/grc/base
COMPONENT "grc"
)
install(FILES
block_tree.dtd
flow_graph.dtd
DESTINATION ${GR_PYTHON_DIR}/gnuradio/grc/base
COMPONENT "grc"
)
gnuradio-3.7.2.1/grc/base/Constants.py 0000644 0001750 0001750 00000001704 11700377701 017342 0 ustar jcorgan jcorgan """
Copyright 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import os
#data files
DATA_DIR = os.path.dirname(__file__)
FLOW_GRAPH_DTD = os.path.join(DATA_DIR, 'flow_graph.dtd')
BLOCK_TREE_DTD = os.path.join(DATA_DIR, 'block_tree.dtd')
gnuradio-3.7.2.1/grc/base/block_tree.dtd 0000664 0001750 0001750 00000001726 12207702530 017623 0 ustar jcorgan jcorgan
gnuradio-3.7.2.1/grc/base/Param.py 0000664 0001750 0001750 00000016011 12207702530 016420 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from . import odict
from Element import Element
def _get_keys(lst): return [elem.get_key() for elem in lst]
def _get_elem(lst, key):
try: return lst[_get_keys(lst).index(key)]
except ValueError: raise ValueError, 'Key "%s" not found in %s.'%(key, _get_keys(lst))
class Option(Element):
def __init__(self, param, n):
Element.__init__(self, param)
self._name = n.find('name')
self._key = n.find('key')
self._opts = dict()
opts = n.findall('opt')
#test against opts when non enum
if not self.get_parent().is_enum() and opts:
raise Exception, 'Options for non-enum types cannot have sub-options'
#extract opts
for opt in opts:
#separate the key:value
try: key, value = opt.split(':')
except: raise Exception, 'Error separating "%s" into key:value'%opt
#test against repeated keys
if self._opts.has_key(key):
raise Exception, 'Key "%s" already exists in option'%key
#store the option
self._opts[key] = value
def __str__(self): return 'Option %s(%s)'%(self.get_name(), self.get_key())
def get_name(self): return self._name
def get_key(self): return self._key
##############################################
# Access Opts
##############################################
def get_opt_keys(self): return self._opts.keys()
def get_opt(self, key): return self._opts[key]
def get_opts(self): return self._opts.values()
class Param(Element):
def __init__(self, block, n):
"""
Make a new param from nested data.
Args:
block: the parent element
n: the nested odict
"""
#grab the data
self._name = n.find('name')
self._key = n.find('key')
value = n.find('value') or ''
self._type = n.find('type')
self._hide = n.find('hide') or ''
#build the param
Element.__init__(self, block)
#create the Option objects from the n data
self._options = list()
for option in map(lambda o: Option(param=self, n=o), n.findall('option')):
key = option.get_key()
#test against repeated keys
if key in self.get_option_keys():
raise Exception, 'Key "%s" already exists in options'%key
#store the option
self.get_options().append(option)
#test the enum options
if self.is_enum():
#test against options with identical keys
if len(set(self.get_option_keys())) != len(self.get_options()):
raise Exception, 'Options keys "%s" are not unique.'%self.get_option_keys()
#test against inconsistent keys in options
opt_keys = self.get_options()[0].get_opt_keys()
for option in self.get_options():
if set(opt_keys) != set(option.get_opt_keys()):
raise Exception, 'Opt keys "%s" are not identical across all options.'%opt_keys
#if a value is specified, it must be in the options keys
self._value = value if value or value in self.get_option_keys() else self.get_option_keys()[0]
if self.get_value() not in self.get_option_keys():
raise Exception, 'The value "%s" is not in the possible values of "%s".'%(self.get_value(), self.get_option_keys())
else: self._value = value or ''
def validate(self):
"""
Validate the param.
The value must be evaluated and type must a possible type.
"""
Element.validate(self)
if self.get_type() not in self.get_types():
self.add_error_message('Type "%s" is not a possible type.'%self.get_type())
def get_evaluated(self): raise NotImplementedError
def to_code(self):
"""
Convert the value to code.
@throw NotImplementedError
"""
raise NotImplementedError
def get_types(self):
"""
Get a list of all possible param types.
@throw NotImplementedError
"""
raise NotImplementedError
def get_color(self): return '#FFFFFF'
def __str__(self): return 'Param - %s(%s)'%(self.get_name(), self.get_key())
def is_param(self): return True
def get_name(self): return self._name
def get_key(self): return self._key
def get_hide(self): return self.get_parent().resolve_dependencies(self._hide).strip()
def get_value(self):
value = self._value
if self.is_enum() and value not in self.get_option_keys():
value = self.get_option_keys()[0]
self.set_value(value)
return value
def set_value(self, value): self._value = str(value) #must be a string
def get_type(self): return self.get_parent().resolve_dependencies(self._type)
def is_enum(self): return self._type == 'enum'
def __repr__(self):
"""
Get the repr (nice string format) for this param.
Just return the value (special case enum).
Derived classes can handle complex formatting.
Returns:
the string representation
"""
if self.is_enum(): return self.get_option(self.get_value()).get_name()
return self.get_value()
##############################################
# Access Options
##############################################
def get_option_keys(self): return _get_keys(self.get_options())
def get_option(self, key): return _get_elem(self.get_options(), key)
def get_options(self): return self._options
##############################################
# Access Opts
##############################################
def get_opt_keys(self): return self.get_option(self.get_value()).get_opt_keys()
def get_opt(self, key): return self.get_option(self.get_value()).get_opt(key)
def get_opts(self): return self.get_option(self.get_value()).get_opts()
##############################################
## Import/Export Methods
##############################################
def export_data(self):
"""
Export this param's key/value.
Returns:
a nested data odict
"""
n = odict()
n['key'] = self.get_key()
n['value'] = self.get_value()
return n
gnuradio-3.7.2.1/grc/base/Connection.py 0000664 0001750 0001750 00000010443 12207702530 017462 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Element import Element
from . import odict
class Connection(Element):
def __init__(self, flow_graph, porta, portb):
"""
Make a new connection given the parent and 2 ports.
Args:
flow_graph: the parent of this element
porta: a port (any direction)
portb: a port (any direction)
@throws Error cannot make connection
Returns:
a new connection
"""
Element.__init__(self, flow_graph)
source = sink = None
#separate the source and sink
for port in (porta, portb):
if port.is_source(): source = port
if port.is_sink(): sink = port
if not source: raise ValueError('Connection could not isolate source')
if not sink: raise ValueError('Connection could not isolate sink')
busses = len(filter(lambda a: a.get_type() == 'bus', [source, sink]))%2
if not busses == 0: raise ValueError('busses must get with busses')
if not len(source.get_associated_ports()) == len(sink.get_associated_ports()):
raise ValueError('port connections must have same cardinality');
#ensure that this connection (source -> sink) is unique
for connection in self.get_parent().get_connections():
if connection.get_source() is source and connection.get_sink() is sink:
raise Exception('This connection between source and sink is not unique.')
self._source = source
self._sink = sink
if source.get_type() == 'bus':
sources = source.get_associated_ports();
sinks = sink.get_associated_ports();
for i in range(len(sources)):
try:
flow_graph.connect(sources[i], sinks[i]);
except:
pass
def __str__(self):
return 'Connection (\n\t%s\n\t\t%s\n\t%s\n\t\t%s\n)'%(
self.get_source().get_parent(),
self.get_source(),
self.get_sink().get_parent(),
self.get_sink(),
)
def is_connection(self): return True
def validate(self):
"""
Validate the connections.
The ports must match in type.
"""
Element.validate(self)
source_type = self.get_source().get_type()
sink_type = self.get_sink().get_type()
if source_type != sink_type:
self.add_error_message('Source type "%s" does not match sink type "%s".'%(source_type, sink_type))
def get_enabled(self):
"""
Get the enabled state of this connection.
Returns:
true if source and sink blocks are enabled
"""
return self.get_source().get_parent().get_enabled() and \
self.get_sink().get_parent().get_enabled()
#############################
# Access Ports
#############################
def get_sink(self): return self._sink
def get_source(self): return self._source
##############################################
## Import/Export Methods
##############################################
def export_data(self):
"""
Export this connection's info.
Returns:
a nested data odict
"""
n = odict()
n['source_block_id'] = self.get_source().get_parent().get_id()
n['sink_block_id'] = self.get_sink().get_parent().get_id()
n['source_key'] = self.get_source().get_key()
n['sink_key'] = self.get_sink().get_key()
return n
gnuradio-3.7.2.1/grc/base/Element.py 0000664 0001750 0001750 00000006501 12207702530 016754 0 ustar jcorgan jcorgan """
Copyright 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
class Element(object):
def __init__(self, parent=None):
self._parent = parent
##################################################
# Element Validation API
##################################################
def validate(self):
"""
Validate this element and call validate on all children.
Call this base method before adding error messages in the subclass.
"""
self._error_messages = list()
for child in self.get_children(): child.validate()
def is_valid(self):
"""
Is this element valid?
Returns:
true when the element is enabled and has no error messages
"""
return not self.get_error_messages() or not self.get_enabled()
def add_error_message(self, msg):
"""
Add an error message to the list of errors.
Args:
msg: the error message string
"""
self._error_messages.append(msg)
def get_error_messages(self):
"""
Get the list of error messages from this element and all of its children.
Do not include the error messages from disabled children.
Cleverly indent the children error messages for printing purposes.
Returns:
a list of error message strings
"""
error_messages = list(self._error_messages) #make a copy
for child in filter(lambda c: c.get_enabled(), self.get_children()):
for msg in child.get_error_messages():
error_messages.append("%s:\n\t%s"%(child, msg.replace("\n", "\n\t")))
return error_messages
def rewrite(self):
"""
Rewrite this element and call rewrite on all children.
Call this base method before rewriting the element.
"""
for child in self.get_children(): child.rewrite()
def get_enabled(self): return True
##############################################
## Tree-like API
##############################################
def get_parent(self): return self._parent
def get_children(self): return list()
##############################################
## Type testing methods
##############################################
def is_element(self): return True
def is_platform(self): return False
def is_flow_graph(self): return False
def is_connection(self): return False
def is_block(self): return False
def is_source(self): return False
def is_sink(self): return False
def is_port(self): return False
def is_param(self): return False
gnuradio-3.7.2.1/grc/base/ParseXML.py 0000664 0001750 0001750 00000007226 12207702530 017023 0 ustar jcorgan jcorgan """
Copyright 2008 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from lxml import etree
from . import odict
class XMLSyntaxError(Exception):
def __init__(self, error_log):
self._error_log = error_log
def __str__(self):
return '\n'.join(map(str, self._error_log.filter_from_errors()))
def validate_dtd(xml_file, dtd_file=None):
"""
Validate an xml file against its dtd.
Args:
xml_file: the xml file
dtd_file: the optional dtd file
@throws Exception validation fails
"""
#perform parsing, use dtd validation if dtd file is not specified
parser = etree.XMLParser(dtd_validation=not dtd_file)
xml = etree.parse(xml_file, parser=parser)
if parser.error_log: raise XMLSyntaxError(parser.error_log)
#perform dtd validation if the dtd file is specified
if not dtd_file: return
dtd = etree.DTD(dtd_file)
if not dtd.validate(xml.getroot()): raise XMLSyntaxError(dtd.error_log)
def from_file(xml_file):
"""
Create nested data from an xml file using the from xml helper.
Args:
xml_file: the xml file path
Returns:
the nested data
"""
xml = etree.parse(xml_file).getroot()
return _from_file(xml)
def _from_file(xml):
"""
Recursivly parse the xml tree into nested data format.
Args:
xml: the xml tree
Returns:
the nested data
"""
tag = xml.tag
if not len(xml):
return odict({tag: xml.text or ''}) #store empty tags (text is None) as empty string
nested_data = odict()
for elem in xml:
key, value = _from_file(elem).items()[0]
if nested_data.has_key(key): nested_data[key].append(value)
else: nested_data[key] = [value]
#delistify if the length of values is 1
for key, values in nested_data.iteritems():
if len(values) == 1: nested_data[key] = values[0]
return odict({tag: nested_data})
def to_file(nested_data, xml_file):
"""
Write an xml file and use the to xml helper method to load it.
Args:
nested_data: the nested data
xml_file: the xml file path
"""
xml = _to_file(nested_data)[0]
open(xml_file, 'w').write(etree.tostring(xml, xml_declaration=True, pretty_print=True))
def _to_file(nested_data):
"""
Recursivly parse the nested data into xml tree format.
Args:
nested_data: the nested data
Returns:
the xml tree filled with child nodes
"""
nodes = list()
for key, values in nested_data.iteritems():
#listify the values if not a list
if not isinstance(values, (list, set, tuple)):
values = [values]
for value in values:
node = etree.Element(key)
if isinstance(value, (str, unicode)): node.text = value
else: node.extend(_to_file(value))
nodes.append(node)
return nodes
if __name__ == '__main__':
"""Use the main method to test parse xml's functions."""
pass
gnuradio-3.7.2.1/grc/base/FlowGraph.py 0000664 0001750 0001750 00000027470 12207702530 017264 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from . import odict
from Element import Element
from .. gui import Messages
class FlowGraph(Element):
def __init__(self, platform):
"""
Make a flow graph from the arguments.
Args:
platform: a platforms with blocks and contrcutors
Returns:
the flow graph object
"""
#initialize
Element.__init__(self, platform)
#inital blank import
self.import_data()
def _get_unique_id(self, base_id=''):
"""
Get a unique id starting with the base id.
Args:
base_id: the id starts with this and appends a count
Returns:
a unique id
"""
index = 0
while True:
id = '%s_%d'%(base_id, index)
index = index + 1
#make sure that the id is not used by another block
if not filter(lambda b: b.get_id() == id, self.get_blocks()): return id
def __str__(self): return 'FlowGraph - %s(%s)'%(self.get_option('title'), self.get_option('id'))
def rewrite(self):
def refactor_bus_structure():
for block in self.get_blocks():
for direc in ['source', 'sink']:
if direc == 'source':
get_p = block.get_sources;
get_p_gui = block.get_sources_gui;
bus_structure = block.form_bus_structure('source');
else:
get_p = block.get_sinks;
get_p_gui = block.get_sinks_gui
bus_structure = block.form_bus_structure('sink');
if 'bus' in map(lambda a: a.get_type(), get_p_gui()):
if len(get_p_gui()) > len(bus_structure):
times = range(len(bus_structure), len(get_p_gui()));
for i in times:
for connect in get_p_gui()[-1].get_connections():
block.get_parent().remove_element(connect);
get_p().remove(get_p_gui()[-1]);
elif len(get_p_gui()) < len(bus_structure):
n = {'name':'bus','type':'bus'};
if True in map(lambda a: isinstance(a.get_nports(), int), get_p()):
n['nports'] = str(1);
times = range(len(get_p_gui()), len(bus_structure));
for i in times:
n['key'] = str(len(get_p()));
n = odict(n);
port = block.get_parent().get_parent().Port(block=block, n=n, dir=direc);
get_p().append(port);
for child in self.get_children(): child.rewrite()
refactor_bus_structure();
def get_option(self, key):
"""
Get the option for a given key.
The option comes from the special options block.
Args:
key: the param key for the options block
Returns:
the value held by that param
"""
return self._options_block.get_param(key).get_evaluated()
def is_flow_graph(self): return True
##############################################
## Access Elements
##############################################
def get_block(self, id): return filter(lambda b: b.get_id() == id, self.get_blocks())[0]
def get_blocks_unordered(self): return filter(lambda e: e.is_block(), self.get_elements())
def get_blocks(self):
blocks = self.get_blocks_unordered();
for i in range(len(blocks)):
if blocks[i].get_key() == 'variable':
blk = blocks[i];
blocks.remove(blk);
blocks.insert(1, blk);
return blocks;
def get_connections(self): return filter(lambda e: e.is_connection(), self.get_elements())
def get_children(self): return self.get_elements()
def get_elements(self):
"""
Get a list of all the elements.
Always ensure that the options block is in the list (only once).
Returns:
the element list
"""
options_block_count = self._elements.count(self._options_block)
if not options_block_count:
self._elements.append(self._options_block)
for i in range(options_block_count-1):
self._elements.remove(self._options_block)
return self._elements
def get_enabled_blocks(self):
"""
Get a list of all blocks that are enabled.
Returns:
a list of blocks
"""
return filter(lambda b: b.get_enabled(), self.get_blocks())
def get_enabled_connections(self):
"""
Get a list of all connections that are enabled.
Returns:
a list of connections
"""
return filter(lambda c: c.get_enabled(), self.get_connections())
def get_new_block(self, key):
"""
Get a new block of the specified key.
Add the block to the list of elements.
Args:
key: the block key
Returns:
the new block or None if not found
"""
if key not in self.get_parent().get_block_keys(): return None
block = self.get_parent().get_new_block(self, key)
self.get_elements().append(block);
if block._bussify_sink:
block.bussify({'name':'bus','type':'bus'}, 'sink')
if block._bussify_source:
block.bussify({'name':'bus','type':'bus'}, 'source')
return block;
def connect(self, porta, portb):
"""
Create a connection between porta and portb.
Args:
porta: a port
portb: another port
@throw Exception bad connection
Returns:
the new connection
"""
connection = self.get_parent().Connection(flow_graph=self, porta=porta, portb=portb)
self.get_elements().append(connection)
return connection
def remove_element(self, element):
"""
Remove the element from the list of elements.
If the element is a port, remove the whole block.
If the element is a block, remove its connections.
If the element is a connection, just remove the connection.
"""
if element not in self.get_elements(): return
#found a port, set to parent signal block
if element.is_port():
element = element.get_parent()
#remove block, remove all involved connections
if element.is_block():
for port in element.get_ports():
map(self.remove_element, port.get_connections())
if element.is_connection():
if element.is_bus():
cons_list = []
for i in map(lambda a: a.get_connections(), element.get_source().get_associated_ports()):
cons_list.extend(i);
map(self.remove_element, cons_list);
self.get_elements().remove(element)
def evaluate(self, expr):
"""
Evaluate the expression.
Args:
expr: the string expression
@throw NotImplementedError
"""
raise NotImplementedError
##############################################
## Import/Export Methods
##############################################
def export_data(self):
"""
Export this flow graph to nested data.
Export all block and connection data.
Returns:
a nested data odict
"""
import time
n = odict()
n['timestamp'] = time.ctime()
n['block'] = [block.export_data() for block in self.get_blocks()]
n['connection'] = [connection.export_data() for connection in self.get_connections()]
return odict({'flow_graph': n})
def import_data(self, n=None):
"""
Import blocks and connections into this flow graph.
Clear this flowgraph of all previous blocks and connections.
Any blocks or connections in error will be ignored.
Args:
n: the nested data odict
"""
#remove previous elements
self._elements = list()
#use blank data if none provided
fg_n = n and n.find('flow_graph') or odict()
blocks_n = fg_n.findall('block')
connections_n = fg_n.findall('connection')
#create option block
self._options_block = self.get_parent().get_new_block(self, 'options')
#build the blocks
for block_n in blocks_n:
key = block_n.find('key')
if key == 'options': block = self._options_block
else: block = self.get_new_block(key)
#only load the block when the block key was valid
if block: block.import_data(block_n)
else: Messages.send_error_load('Block key "%s" not found in %s'%(key, self.get_parent()))
#build the connections
for connection_n in connections_n:
#try to make the connection
try:
#get the block ids
source_block_id = connection_n.find('source_block_id')
sink_block_id = connection_n.find('sink_block_id')
#get the port keys
source_key = connection_n.find('source_key')
sink_key = connection_n.find('sink_key')
#verify the blocks
block_ids = map(lambda b: b.get_id(), self.get_blocks())
if source_block_id not in block_ids:
raise LookupError('source block id "%s" not in block ids'%source_block_id)
if sink_block_id not in block_ids:
raise LookupError('sink block id "%s" not in block ids'%sink_block_id)
#get the blocks
source_block = self.get_block(source_block_id)
sink_block = self.get_block(sink_block_id)
#verify the ports
if source_key not in source_block.get_source_keys():
raise LookupError('source key "%s" not in source block keys'%source_key)
if sink_key not in sink_block.get_sink_keys():
raise LookupError('sink key "%s" not in sink block keys'%sink_key)
#get the ports
source = source_block.get_source(source_key)
sink = sink_block.get_sink(sink_key)
#build the connection
self.connect(source, sink)
except LookupError, e: Messages.send_error_load(
'Connection between %s(%s) and %s(%s) could not be made.\n\t%s'%(
source_block_id, source_key, sink_block_id, sink_key, e
)
)
self.rewrite() #global rewrite
gnuradio-3.7.2.1/grc/base/odict.py 0000664 0001750 0001750 00000006366 12207702530 016476 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from UserDict import DictMixin
class odict(DictMixin):
def __init__(self, d={}):
self._keys = list(d.keys())
self._data = dict(d.copy())
def __setitem__(self, key, value):
if key not in self._data:
self._keys.append(key)
self._data[key] = value
def __getitem__(self, key):
return self._data[key]
def __delitem__(self, key):
del self._data[key]
self._keys.remove(key)
def keys(self):
return list(self._keys)
def copy(self):
copy_dict = odict()
copy_dict._data = self._data.copy()
copy_dict._keys = list(self._keys)
return copy_dict
def insert_after(self, pos_key, key, val):
"""
Insert the new key, value entry after the entry given by the position key.
If the positional key is None, insert at the end.
Args:
pos_key: the positional key
key: the key for the new entry
val: the value for the new entry
"""
index = (pos_key is None) and len(self._keys) or self._keys.index(pos_key)
if key in self._keys: raise KeyError('Cannot insert, key "%s" already exists'%str(key))
self._keys.insert(index+1, key)
self._data[key] = val
def insert_before(self, pos_key, key, val):
"""
Insert the new key, value entry before the entry given by the position key.
If the positional key is None, insert at the begining.
Args:
pos_key: the positional key
key: the key for the new entry
val: the value for the new entry
"""
index = (pos_key is not None) and self._keys.index(pos_key) or 0
if key in self._keys: raise KeyError('Cannot insert, key "%s" already exists'%str(key))
self._keys.insert(index, key)
self._data[key] = val
def find(self, key):
"""
Get the value for this key if exists.
Args:
key: the key to search for
Returns:
the value or None
"""
if self.has_key(key): return self[key]
return None
def findall(self, key):
"""
Get a list of values for this key.
Args:
key: the key to search for
Returns:
a list of values or empty list
"""
obj = self.find(key)
if obj is None: obj = list()
if isinstance(obj, list): return obj
return [obj]
gnuradio-3.7.2.1/grc/base/flow_graph.dtd 0000664 0001750 0001750 00000002644 12207702530 017642 0 ustar jcorgan jcorgan
gnuradio-3.7.2.1/grc/base/__init__.py 0000644 0001750 0001750 00000001446 11700377701 017130 0 ustar jcorgan jcorgan """
Copyright 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from odict import odict
gnuradio-3.7.2.1/grc/base/Block.py 0000664 0001750 0001750 00000037042 12237515112 016422 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from . import odict
from Element import Element
from Cheetah.Template import Template
from UserDict import UserDict
from .. gui import Actions
class TemplateArg(UserDict):
"""
A cheetah template argument created from a param.
The str of this class evaluates to the param's to code method.
The use of this class as a dictionary (enum only) will reveal the enum opts.
The __call__ or () method can return the param evaluated to a raw python data type.
"""
def __init__(self, param):
UserDict.__init__(self)
self._param = param
if param.is_enum():
for key in param.get_opt_keys():
self[key] = str(param.get_opt(key))
def __str__(self):
return str(self._param.to_code())
def __call__(self):
return self._param.get_evaluated()
def _get_keys(lst): return [elem.get_key() for elem in lst]
def _get_elem(lst, key):
try: return lst[_get_keys(lst).index(key)]
except ValueError: raise ValueError, 'Key "%s" not found in %s.'%(key, _get_keys(lst))
class Block(Element):
def __init__(self, flow_graph, n):
"""
Make a new block from nested data.
Args:
flow: graph the parent element
n: the nested odict
Returns:
block a new block
"""
#build the block
Element.__init__(self, flow_graph)
#grab the data
params = n.findall('param')
sources = n.findall('source')
sinks = n.findall('sink')
self._name = n.find('name')
self._key = n.find('key')
self._category = n.find('category') or ''
self._grc_source = n.find('grc_source') or ''
self._block_wrapper_path = n.find('block_wrapper_path')
self._bussify_sink = n.find('bus_sink')
self._bussify_source = n.find('bus_source')
#create the param objects
self._params = list()
#add the id param
self.get_params().append(self.get_parent().get_parent().Param(
block=self,
n=odict({
'name': 'ID',
'key': 'id',
'type': 'id',
})
))
self.get_params().append(self.get_parent().get_parent().Param(
block=self,
n=odict({
'name': 'Enabled',
'key': '_enabled',
'type': 'raw',
'value': 'True',
'hide': 'all',
})
))
for param in map(lambda n: self.get_parent().get_parent().Param(block=self, n=n), params):
key = param.get_key()
#test against repeated keys
if key in self.get_param_keys():
raise Exception, 'Key "%s" already exists in params'%key
#store the param
self.get_params().append(param)
#create the source objects
self._sources = list()
for source in map(lambda n: self.get_parent().get_parent().Port(block=self, n=n, dir='source'), sources):
key = source.get_key()
#test against repeated keys
if key in self.get_source_keys():
raise Exception, 'Key "%s" already exists in sources'%key
#store the port
self.get_sources().append(source)
self.back_ofthe_bus(self.get_sources())
#create the sink objects
self._sinks = list()
for sink in map(lambda n: self.get_parent().get_parent().Port(block=self, n=n, dir='sink'), sinks):
key = sink.get_key()
#test against repeated keys
if key in self.get_sink_keys():
raise Exception, 'Key "%s" already exists in sinks'%key
#store the port
self.get_sinks().append(sink)
self.back_ofthe_bus(self.get_sinks())
self.current_bus_structure = {'source':'','sink':''};
# Virtual source/sink and pad source/sink blocks are
# indistinguishable from normal GR blocks. Make explicit
# checks for them here since they have no work function or
# buffers to manage.
is_not_virtual_or_pad = ((self._key != "virtual_source") \
and (self._key != "virtual_sink") \
and (self._key != "pad_source") \
and (self._key != "pad_sink"))
if (len(sources) or len(sinks)) and is_not_virtual_or_pad:
self.get_params().append(self.get_parent().get_parent().Param(
block=self,
n=odict({'name': 'Core Affinity',
'key': 'affinity',
'type': 'int_vector',
'hide': 'part',
})
))
if len(sources) and is_not_virtual_or_pad:
self.get_params().append(self.get_parent().get_parent().Param(
block=self,
n=odict({'name': 'Min Output Buffer',
'key': 'minoutbuf',
'type': 'int',
'hide': 'part',
'value': '0'
})
))
self.get_params().append(self.get_parent().get_parent().Param(
block=self,
n=odict({'name': 'Max Output Buffer',
'key': 'maxoutbuf',
'type': 'int',
'hide': 'part',
'value': '0'
})
))
def back_ofthe_bus(self, portlist):
portlist.sort(key=lambda a: a.get_type() == 'bus');
def filter_bus_port(self, ports):
buslist = [i for i in ports if i.get_type() == 'bus'];
if len(buslist) == 0:
return ports;
else:
return buslist;
def get_enabled(self):
"""
Get the enabled state of the block.
Returns:
true for enabled
"""
try: return eval(self.get_param('_enabled').get_value())
except: return True
def set_enabled(self, enabled):
"""
Set the enabled state of the block.
Args:
enabled: true for enabled
"""
self.get_param('_enabled').set_value(str(enabled))
def __str__(self): return 'Block - %s - %s(%s)'%(self.get_id(), self.get_name(), self.get_key())
def get_id(self): return self.get_param('id').get_value()
def is_block(self): return True
def get_name(self): return self._name
def get_key(self): return self._key
def get_category(self): return self._category
def set_category(self, cat): self._category = cat
def get_doc(self): return ''
def get_ports(self): return self.get_sources() + self.get_sinks()
def get_ports_gui(self): return self.filter_bus_port(self.get_sources()) + self.filter_bus_port(self.get_sinks());
def get_children(self): return self.get_ports() + self.get_params()
def get_children_gui(self): return self.get_ports_gui() + self.get_params()
def get_block_wrapper_path(self): return self._block_wrapper_path
##############################################
# Access Params
##############################################
def get_param_keys(self): return _get_keys(self._params)
def get_param(self, key): return _get_elem(self._params, key)
def get_params(self): return self._params
def has_param(self, key):
try:
_get_elem(self._params, key);
return True;
except:
return False;
##############################################
# Access Sinks
##############################################
def get_sink_keys(self): return _get_keys(self._sinks)
def get_sink(self, key): return _get_elem(self._sinks, key)
def get_sinks(self): return self._sinks
def get_sinks_gui(self): return self.filter_bus_port(self.get_sinks())
##############################################
# Access Sources
##############################################
def get_source_keys(self): return _get_keys(self._sources)
def get_source(self, key): return _get_elem(self._sources, key)
def get_sources(self): return self._sources
def get_sources_gui(self): return self.filter_bus_port(self.get_sources());
def get_connections(self):
return sum([port.get_connections() for port in self.get_ports()], [])
def resolve_dependencies(self, tmpl):
"""
Resolve a paramater dependency with cheetah templates.
Args:
tmpl: the string with dependencies
Returns:
the resolved value
"""
tmpl = str(tmpl)
if '$' not in tmpl: return tmpl
n = dict((p.get_key(), TemplateArg(p)) for p in self.get_params())
try: return str(Template(tmpl, n))
except Exception, e: return "-------->\n%s: %s\n<--------"%(e, tmpl)
##############################################
# Controller Modify
##############################################
def type_controller_modify(self, direction):
"""
Change the type controller.
Args:
direction: +1 or -1
Returns:
true for change
"""
changed = False
type_param = None
for param in filter(lambda p: p.is_enum(), self.get_params()):
children = self.get_ports() + self.get_params()
#priority to the type controller
if param.get_key() in ' '.join(map(lambda p: p._type, children)): type_param = param
#use param if type param is unset
if not type_param: type_param = param
if type_param:
#try to increment the enum by direction
try:
keys = type_param.get_option_keys()
old_index = keys.index(type_param.get_value())
new_index = (old_index + direction + len(keys))%len(keys)
type_param.set_value(keys[new_index])
changed = True
except: pass
return changed
def port_controller_modify(self, direction):
"""
Change the port controller.
Args:
direction: +1 or -1
Returns:
true for change
"""
return False
def form_bus_structure(self, direc):
if direc == 'source':
get_p = self.get_sources;
get_p_gui = self.get_sources_gui;
bus_structure = self.get_bus_structure('source');
else:
get_p = self.get_sinks;
get_p_gui = self.get_sinks_gui
bus_structure = self.get_bus_structure('sink');
struct = [range(len(get_p()))];
if True in map(lambda a: isinstance(a.get_nports(), int), get_p()):
structlet = [];
last = 0;
for j in [i.get_nports() for i in get_p() if isinstance(i.get_nports(), int)]:
structlet.extend(map(lambda a: a+last, range(j)));
last = structlet[-1] + 1;
struct = [structlet];
if bus_structure:
struct = bus_structure
self.current_bus_structure[direc] = struct;
return struct
def bussify(self, n, direc):
if direc == 'source':
get_p = self.get_sources;
get_p_gui = self.get_sources_gui;
bus_structure = self.get_bus_structure('source');
else:
get_p = self.get_sinks;
get_p_gui = self.get_sinks_gui
bus_structure = self.get_bus_structure('sink');
for elt in get_p():
for connect in elt.get_connections():
self.get_parent().remove_element(connect);
if (not 'bus' in map(lambda a: a.get_type(), get_p())) and len(get_p()) > 0:
struct = self.form_bus_structure(direc);
self.current_bus_structure[direc] = struct;
if get_p()[0].get_nports():
n['nports'] = str(1);
for i in range(len(struct)):
n['key'] = str(len(get_p()));
n = odict(n);
port = self.get_parent().get_parent().Port(block=self, n=n, dir=direc);
get_p().append(port);
elif 'bus' in map(lambda a: a.get_type(), get_p()):
for elt in get_p_gui():
get_p().remove(elt);
self.current_bus_structure[direc] = ''
##############################################
## Import/Export Methods
##############################################
def export_data(self):
"""
Export this block's params to nested data.
Returns:
a nested data odict
"""
n = odict()
n['key'] = self.get_key()
n['param'] = map(lambda p: p.export_data(), self.get_params())
if 'bus' in map(lambda a: a.get_type(), self.get_sinks()):
n['bus_sink'] = str(1);
if 'bus' in map(lambda a: a.get_type(), self.get_sources()):
n['bus_source'] = str(1);
return n
def import_data(self, n):
"""
Import this block's params from nested data.
Any param keys that do not exist will be ignored.
Since params can be dynamically created based another param,
call rewrite, and repeat the load until the params stick.
This call to rewrite will also create any dynamic ports
that are needed for the connections creation phase.
Args:
n: the nested data odict
"""
get_hash = lambda: hash(tuple(map(hash, self.get_params())))
my_hash = 0
while get_hash() != my_hash:
params_n = n.findall('param')
for param_n in params_n:
key = param_n.find('key')
value = param_n.find('value')
#the key must exist in this block's params
if key in self.get_param_keys():
self.get_param(key).set_value(value)
#store hash and call rewrite
my_hash = get_hash()
self.rewrite()
bussinks = n.findall('bus_sink');
if len(bussinks) > 0 and not self._bussify_sink:
self.bussify({'name':'bus','type':'bus'}, 'sink')
elif len(bussinks) > 0:
self.bussify({'name':'bus','type':'bus'}, 'sink')
self.bussify({'name':'bus','type':'bus'}, 'sink')
bussrcs = n.findall('bus_source');
if len(bussrcs) > 0 and not self._bussify_source:
self.bussify({'name':'bus','type':'bus'}, 'source')
elif len(bussrcs) > 0:
self.bussify({'name':'bus','type':'bus'}, 'source')
self.bussify({'name':'bus','type':'bus'}, 'source')
gnuradio-3.7.2.1/grc/python/ 0000755 0001750 0001750 00000000000 12237515112 015415 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/python/Platform.py 0000664 0001750 0001750 00000004604 12207702530 017560 0 ustar jcorgan jcorgan __doc__ = """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import os
from gnuradio import gr
from .. base.Platform import Platform as _Platform
from .. gui.Platform import Platform as _GUIPlatform
from FlowGraph import FlowGraph as _FlowGraph
from Connection import Connection as _Connection
from Block import Block as _Block
from Port import Port as _Port
from Param import Param as _Param
from Generator import Generator
from Constants import \
HIER_BLOCKS_LIB_DIR, BLOCK_DTD, \
DEFAULT_FLOW_GRAPH, BLOCKS_DIRS
import Constants
COLORS = [(name, color) for name, key, sizeof, color in Constants.CORE_TYPES]
class Platform(_Platform, _GUIPlatform):
def __init__(self):
"""
Make a platform for gnuradio.
"""
#ensure hier dir
if not os.path.exists(HIER_BLOCKS_LIB_DIR): os.mkdir(HIER_BLOCKS_LIB_DIR)
#convert block paths to absolute paths
block_paths = set(map(os.path.abspath, BLOCKS_DIRS))
#init
_Platform.__init__(
self,
name='GNU Radio Companion',
version=gr.version(),
key='grc',
license=__doc__.strip(),
website='http://gnuradio.org/redmine/wiki/gnuradio/GNURadioCompanion',
block_paths=block_paths,
block_dtd=BLOCK_DTD,
default_flow_graph=DEFAULT_FLOW_GRAPH,
generator=Generator,
colors=COLORS,
)
_GUIPlatform.__init__(self)
##############################################
# Constructors
##############################################
FlowGraph = _FlowGraph
Connection = _Connection
Block = _Block
Port = _Port
Param = _Param
gnuradio-3.7.2.1/grc/python/Port.py 0000664 0001750 0001750 00000021360 12207702530 016716 0 ustar jcorgan jcorgan """
Copyright 2008-2012 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from .. base.Port import Port as _Port
from .. gui.Port import Port as _GUIPort
import Constants
def _get_source_from_virtual_sink_port(vsp):
"""
Resolve the source port that is connected to the given virtual sink port.
Use the get source from virtual source to recursively resolve subsequent ports.
"""
try: return _get_source_from_virtual_source_port(
vsp.get_enabled_connections()[0].get_source())
except: raise Exception, 'Could not resolve source for virtual sink port %s'%vsp
def _get_source_from_virtual_source_port(vsp, traversed=[]):
"""
Recursively resolve source ports over the virtual connections.
Keep track of traversed sources to avoid recursive loops.
"""
if not vsp.get_parent().is_virtual_source(): return vsp
if vsp in traversed: raise Exception, 'Loop found when resolving virtual source %s'%vsp
try: return _get_source_from_virtual_source_port(
_get_source_from_virtual_sink_port(
filter(#get all virtual sinks with a matching stream id
lambda vs: vs.get_param('stream_id').get_value() == vsp.get_parent().get_param('stream_id').get_value(),
filter(#get all enabled blocks that are also virtual sinks
lambda b: b.is_virtual_sink(),
vsp.get_parent().get_parent().get_enabled_blocks(),
),
)[0].get_sinks()[0]
), traversed + [vsp],
)
except: raise Exception, 'Could not resolve source for virtual source port %s'%vsp
def _get_sink_from_virtual_source_port(vsp):
"""
Resolve the sink port that is connected to the given virtual source port.
Use the get sink from virtual sink to recursively resolve subsequent ports.
"""
try: return _get_sink_from_virtual_sink_port(
vsp.get_enabled_connections()[0].get_sink()) # Could have many connections, but use first
except: raise Exception, 'Could not resolve source for virtual source port %s'%vsp
def _get_sink_from_virtual_sink_port(vsp, traversed=[]):
"""
Recursively resolve sink ports over the virtual connections.
Keep track of traversed sinks to avoid recursive loops.
"""
if not vsp.get_parent().is_virtual_sink(): return vsp
if vsp in traversed: raise Exception, 'Loop found when resolving virtual sink %s'%vsp
try: return _get_sink_from_virtual_sink_port(
_get_sink_from_virtual_source_port(
filter(#get all virtual source with a matching stream id
lambda vs: vs.get_param('stream_id').get_value() == vsp.get_parent().get_param('stream_id').get_value(),
filter(#get all enabled blocks that are also virtual sinks
lambda b: b.is_virtual_source(),
vsp.get_parent().get_parent().get_enabled_blocks(),
),
)[0].get_sources()[0]
), traversed + [vsp],
)
except: raise Exception, 'Could not resolve source for virtual sink port %s'%vsp
class Port(_Port, _GUIPort):
def __init__(self, block, n, dir):
"""
Make a new port from nested data.
Args:
block: the parent element
n: the nested odict
dir: the direction
"""
self._n = n
if n['type'] == 'msg': n['key'] = 'msg'
if n['type'] == 'message': n['key'] = n['name']
if dir == 'source' and not n.find('key'):
n['key'] = str(block._source_count)
block._source_count += 1
if dir == 'sink' and not n.find('key'):
n['key'] = str(block._sink_count)
block._sink_count += 1
#build the port
_Port.__init__(
self,
block=block,
n=n,
dir=dir,
)
_GUIPort.__init__(self)
self._nports = n.find('nports') or ''
self._vlen = n.find('vlen') or ''
self._optional = bool(n.find('optional'))
def get_types(self): return Constants.TYPE_TO_SIZEOF.keys()
def is_type_empty(self): return not self._n['type']
def validate(self):
_Port.validate(self)
if not self.get_enabled_connections() and not self.get_optional():
self.add_error_message('Port is not connected.')
if not self.is_source() and (not self.get_type() == "message") and len(self.get_enabled_connections()) > 1:
self.add_error_message('Port has too many connections.')
#message port logic
if self.get_type() == 'msg':
if self.get_nports():
self.add_error_message('A port of type "msg" cannot have "nports" set.')
if self.get_vlen() != 1:
self.add_error_message('A port of type "msg" must have a "vlen" of 1.')
def rewrite(self):
"""
Handle the port cloning for virtual blocks.
"""
_Port.rewrite(self)
if self.is_type_empty():
try: #clone type and vlen
source = self.resolve_empty_type()
self._type = str(source.get_type())
self._vlen = str(source.get_vlen())
except: #reset type and vlen
self._type = ''
self._vlen = ''
def resolve_virtual_source(self):
if self.get_parent().is_virtual_sink(): return _get_source_from_virtual_sink_port(self)
if self.get_parent().is_virtual_source(): return _get_source_from_virtual_source_port(self)
def resolve_empty_type(self):
if self.is_sink():
try:
src = _get_source_from_virtual_sink_port(self)
if not src.is_type_empty(): return src
except: pass
sink = _get_sink_from_virtual_sink_port(self)
if not sink.is_type_empty(): return sink
if self.is_source():
try:
src = _get_source_from_virtual_source_port(self)
if not src.is_type_empty(): return src
except: pass
sink = _get_sink_from_virtual_source_port(self)
if not sink.is_type_empty(): return sink
def get_vlen(self):
"""
Get the vector length.
If the evaluation of vlen cannot be cast to an integer, return 1.
Returns:
the vector length or 1
"""
vlen = self.get_parent().resolve_dependencies(self._vlen)
try: return int(self.get_parent().get_parent().evaluate(vlen))
except: return 1
def get_nports(self):
"""
Get the number of ports.
If already blank, return a blank
If the evaluation of nports cannot be cast to an integer, return 1.
Returns:
the number of ports or 1
"""
nports = self.get_parent().resolve_dependencies(self._nports)
#return blank if nports is blank
if not nports: return ''
try:
nports = int(self.get_parent().get_parent().evaluate(nports))
if 0 < nports: return nports
except: return 1
def get_optional(self): return bool(self._optional)
def get_color(self):
"""
Get the color that represents this port's type.
Codes differ for ports where the vec length is 1 or greater than 1.
Returns:
a hex color code.
"""
try:
color = Constants.TYPE_TO_COLOR[self.get_type()]
vlen = self.get_vlen()
if vlen == 1: return color
color_val = int(color[1:], 16)
r = (color_val >> 16) & 0xff
g = (color_val >> 8) & 0xff
b = (color_val >> 0) & 0xff
dark = (0, 0, 30, 50, 70)[min(4, vlen)]
r = max(r-dark, 0)
g = max(g-dark, 0)
b = max(b-dark, 0)
return '#%.2x%.2x%.2x'%(r, g, b)
except: return _Port.get_color(self)
def copy(self, new_key=None):
n = self._n.copy()
#remove nports from the key so the copy cannot be a duplicator
if n.has_key('nports'): n.pop('nports')
if new_key: n['key'] = new_key
return self.__class__(self.get_parent(), n, self._dir)
gnuradio-3.7.2.1/grc/python/CMakeLists.txt 0000644 0001750 0001750 00000002423 11744612271 020164 0 ustar jcorgan jcorgan # 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.
########################################################################
GR_PYTHON_INSTALL(FILES
convert_hier.py
expr_utils.py
extract_docs.py
Block.py
Connection.py
Constants.py
FlowGraph.py
Generator.py
Param.py
Platform.py
Port.py
__init__.py
DESTINATION ${GR_PYTHON_DIR}/gnuradio/grc/python
COMPONENT "grc"
)
install(FILES
block.dtd
default_flow_graph.grc
flow_graph.tmpl
DESTINATION ${GR_PYTHON_DIR}/gnuradio/grc/python
COMPONENT "grc"
)
gnuradio-3.7.2.1/grc/python/Constants.py 0000664 0001750 0001750 00000006476 12207702530 017761 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import os
import stat
from gnuradio import gr
_gr_prefs = gr.prefs()
#setup paths
PATH_SEP = {'/':':', '\\':';'}[os.path.sep]
HIER_BLOCKS_LIB_DIR = os.path.join(os.path.expanduser('~'), '.grc_gnuradio')
BLOCKS_DIRS = filter( #filter blank strings
lambda x: x, PATH_SEP.join([
os.environ.get('GRC_BLOCKS_PATH', ''),
_gr_prefs.get_string('grc', 'local_blocks_path', ''),
_gr_prefs.get_string('grc', 'global_blocks_path', ''),
]).split(PATH_SEP),
) + [HIER_BLOCKS_LIB_DIR]
#file creation modes
TOP_BLOCK_FILE_MODE = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IXGRP | stat.S_IROTH
HIER_BLOCK_FILE_MODE = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IROTH
#data files
DATA_DIR = os.path.dirname(__file__)
FLOW_GRAPH_TEMPLATE = os.path.join(DATA_DIR, 'flow_graph.tmpl')
BLOCK_DTD = os.path.join(DATA_DIR, 'block.dtd')
DEFAULT_FLOW_GRAPH = os.path.join(DATA_DIR, 'default_flow_graph.grc')
CORE_TYPES = ( #name, key, sizeof, color
('Complex Float 64', 'fc64', 16, '#CC8C69'),
('Complex Float 32', 'fc32', 8, '#3399FF'),
('Complex Integer 64', 'sc64', 16, '#66CC00'),
('Complex Integer 32', 'sc32', 8, '#33cc66'),
('Complex Integer 16', 'sc16', 4, '#cccc00'),
('Complex Integer 8', 'sc8', 2, '#cc00cc'),
('Float 64', 'f64', 8, '#66CCCC'),
('Float 32', 'f32', 4, '#FF8C69'),
('Integer 64', 's64', 8, '#99FF33'),
('Integer 32', 's32', 4, '#00FF99'),
('Integer 16', 's16', 2, '#FFFF66'),
('Integer 8', 's8', 1, '#FF66FF'),
('Message Queue', 'msg', 0, '#777777'),
('Async Message', 'message', 0, '#C0C0C0'),
('Bus Connection', 'bus', 0, '#FFFFFF'),
('Wildcard', '', 0, '#FFFFFF'),
)
ALIAS_TYPES = {
'complex' : (8, '#3399FF'),
'float' : (4, '#FF8C69'),
'int' : (4, '#00FF99'),
'short' : (2, '#FFFF66'),
'byte' : (1, '#FF66FF'),
}
TYPE_TO_COLOR = dict()
TYPE_TO_SIZEOF = dict()
for name, key, sizeof, color in CORE_TYPES:
TYPE_TO_COLOR[key] = color
TYPE_TO_SIZEOF[key] = sizeof
for key, (sizeof, color) in ALIAS_TYPES.iteritems():
TYPE_TO_COLOR[key] = color
TYPE_TO_SIZEOF[key] = sizeof
#coloring
COMPLEX_COLOR_SPEC = '#3399FF'
FLOAT_COLOR_SPEC = '#FF8C69'
INT_COLOR_SPEC = '#00FF99'
SHORT_COLOR_SPEC = '#FFFF66'
BYTE_COLOR_SPEC = '#FF66FF'
COMPLEX_VECTOR_COLOR_SPEC = '#3399AA'
FLOAT_VECTOR_COLOR_SPEC = '#CC8C69'
INT_VECTOR_COLOR_SPEC = '#00CC99'
SHORT_VECTOR_COLOR_SPEC = '#CCCC33'
BYTE_VECTOR_COLOR_SPEC = '#CC66CC'
ID_COLOR_SPEC = '#DDDDDD'
WILDCARD_COLOR_SPEC = '#FFFFFF'
MSG_COLOR_SPEC = '#777777'
gnuradio-3.7.2.1/grc/python/expr_utils.py 0000664 0001750 0001750 00000012556 12207702530 020177 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import string
VAR_CHARS = string.letters + string.digits + '_'
class graph(object):
"""
Simple graph structure held in a dictionary.
"""
def __init__(self): self._graph = dict()
def __str__(self): return str(self._graph)
def add_node(self, node_key):
if self._graph.has_key(node_key): return
self._graph[node_key] = set()
def remove_node(self, node_key):
if not self._graph.has_key(node_key): return
for edges in self._graph.values():
if node_key in edges: edges.remove(node_key)
self._graph.pop(node_key)
def add_edge(self, src_node_key, dest_node_key):
self._graph[src_node_key].add(dest_node_key)
def remove_edge(self, src_node_key, dest_node_key):
self._graph[src_node_key].remove(dest_node_key)
def get_nodes(self): return self._graph.keys()
def get_edges(self, node_key): return self._graph[node_key]
def expr_split(expr):
"""
Split up an expression by non alphanumeric characters, including underscore.
Leave strings in-tact.
#TODO ignore escaped quotes, use raw strings.
Args:
expr: an expression string
Returns:
a list of string tokens that form expr
"""
toks = list()
tok = ''
quote = ''
for char in expr:
if quote or char in VAR_CHARS:
if char == quote: quote = ''
tok += char
elif char in ("'", '"'):
toks.append(tok)
tok = char
quote = char
else:
toks.append(tok)
toks.append(char)
tok = ''
toks.append(tok)
return filter(lambda t: t, toks)
def expr_replace(expr, replace_dict):
"""
Search for vars in the expression and add the prepend.
Args:
expr: an expression string
replace_dict: a dict of find:replace
Returns:
a new expression with the prepend
"""
expr_splits = expr_split(expr)
for i, es in enumerate(expr_splits):
if es in replace_dict.keys():
expr_splits[i] = replace_dict[es]
return ''.join(expr_splits)
def get_variable_dependencies(expr, vars):
"""
Return a set of variables used in this expression.
Args:
expr: an expression string
vars: a list of variable names
Returns:
a subset of vars used in the expression
"""
expr_toks = expr_split(expr)
return set(filter(lambda v: v in expr_toks, vars))
def get_graph(exprs):
"""
Get a graph representing the variable dependencies
Args:
exprs: a mapping of variable name to expression
Returns:
a graph of variable deps
"""
vars = exprs.keys()
#get dependencies for each expression, load into graph
var_graph = graph()
for var in vars: var_graph.add_node(var)
for var, expr in exprs.iteritems():
for dep in get_variable_dependencies(expr, vars):
if dep != var: var_graph.add_edge(dep, var)
return var_graph
def sort_variables(exprs):
"""
Get a list of variables in order of dependencies.
Args:
exprs: a mapping of variable name to expression
Returns:
a list of variable names
@throws Exception circular dependencies
"""
var_graph = get_graph(exprs)
sorted_vars = list()
#determine dependency order
while var_graph.get_nodes():
#get a list of nodes with no edges
indep_vars = filter(lambda var: not var_graph.get_edges(var), var_graph.get_nodes())
if not indep_vars: raise Exception('circular dependency caught in sort_variables')
#add the indep vars to the end of the list
sorted_vars.extend(sorted(indep_vars))
#remove each edge-less node from the graph
for var in indep_vars: var_graph.remove_node(var)
return reversed(sorted_vars)
def sort_objects(objects, get_id, get_expr):
"""
Sort a list of objects according to their expressions.
Args:
objects: the list of objects to sort
get_id: the function to extract an id from the object
get_expr: the function to extract an expression from the object
Returns:
a list of sorted objects
"""
id2obj = dict([(get_id(obj), obj) for obj in objects])
#map obj id to expression code
id2expr = dict([(get_id(obj), get_expr(obj)) for obj in objects])
#sort according to dependency
sorted_ids = sort_variables(id2expr)
#return list of sorted objects
return [id2obj[id] for id in sorted_ids]
if __name__ == '__main__':
for i in sort_variables({'x':'1', 'y':'x+1', 'a':'x+y', 'b':'y+1', 'c':'a+b+x+y'}): print i
gnuradio-3.7.2.1/grc/python/convert_hier.py 0000664 0001750 0001750 00000011006 12207702530 020455 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Constants import BLOCK_DTD
from .. base import ParseXML
from .. base import odict
def convert_hier(flow_graph, python_file):
#extract info from the flow graph
input_sigs = flow_graph.get_io_signaturev('in')
output_sigs = flow_graph.get_io_signaturev('out')
input_msgp = flow_graph.get_msg_pad_sources();
output_msgp = flow_graph.get_msg_pad_sinks();
parameters = flow_graph.get_parameters()
bussink = flow_graph.get_bussink()
bussrc = flow_graph.get_bussrc()
bus_struct_sink = flow_graph.get_bus_structure_sink()
bus_struct_src = flow_graph.get_bus_structure_src()
block_key = flow_graph.get_option('id')
block_name = flow_graph.get_option('title') or flow_graph.get_option('id').replace('_', ' ').title()
block_category = flow_graph.get_option('category')
block_desc = flow_graph.get_option('description')
block_author = flow_graph.get_option('author')
#build the nested data
block_n = odict()
block_n['name'] = block_name
block_n['key'] = block_key
block_n['category'] = block_category
block_n['import'] = 'execfile("%s")'%python_file
#make data
if parameters: block_n['make'] = '%s(\n %s,\n)'%(
block_key,
',\n '.join(['%s=$%s'%(param.get_id(), param.get_id()) for param in parameters]),
)
else: block_n['make'] = '%s()'%block_key
#callback data
block_n['callback'] = ['set_%s($%s)'%(param.get_id(), param.get_id()) for param in parameters]
#param data
params_n = list()
for param in parameters:
param_n = odict()
param_n['name'] = param.get_param('label').get_value() or param.get_id()
param_n['key'] = param.get_id()
param_n['value'] = param.get_param('value').get_value()
param_n['type'] = 'raw'
params_n.append(param_n)
block_n['param'] = params_n
#sink data stream ports
if bussink:
block_n['bus_sink'] = '1';
if bussrc:
block_n['bus_source'] = '1';
block_n['sink'] = list()
for input_sig in input_sigs:
sink_n = odict()
sink_n['name'] = input_sig['label']
sink_n['type'] = input_sig['type']
sink_n['vlen'] = input_sig['vlen']
if input_sig['optional']: sink_n['optional'] = '1'
block_n['sink'].append(sink_n)
#sink data msg ports
for input_sig in input_msgp:
sink_n = odict()
sink_n['name'] = input_sig.get_param("label").get_value();
sink_n['type'] = "message"
sink_n['optional'] = input_sig.get_param("optional").get_value();
block_n['sink'].append(sink_n)
#source data stream ports
block_n['source'] = list()
if bus_struct_sink:
block_n['bus_structure_sink'] = bus_struct_sink[0].get_param('struct').get_value();
if bus_struct_src:
block_n['bus_structure_source'] = bus_struct_src[0].get_param('struct').get_value();
for output_sig in output_sigs:
source_n = odict()
source_n['name'] = output_sig['label']
source_n['type'] = output_sig['type']
source_n['vlen'] = output_sig['vlen']
if output_sig['optional']: source_n['optional'] = '1'
block_n['source'].append(source_n)
#source data msg ports
for output_sig in output_msgp:
source_n = odict()
source_n['name'] = output_sig.get_param("label").get_value();
source_n['type'] = "message"
source_n['optional'] = output_sig.get_param("optional").get_value();
block_n['source'].append(source_n)
#doc data
block_n['doc'] = "%s\n%s\n%s"%(block_author, block_desc, python_file)
block_n['grc_source'] = "%s"%(flow_graph.grc_file_path)
#write the block_n to file
xml_file = python_file + '.xml'
ParseXML.to_file({'block': block_n}, xml_file)
ParseXML.validate_dtd(xml_file, BLOCK_DTD)
gnuradio-3.7.2.1/grc/python/Param.py 0000664 0001750 0001750 00000051660 12207702530 017040 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from .. base.Param import Param as _Param
from .. gui.Param import Param as _GUIParam
from .. gui.Param import EntryParam
import Constants
import numpy
import os
import pygtk
pygtk.require('2.0')
import gtk
from gnuradio import eng_notation
import re
from gnuradio import gr
_check_id_matcher = re.compile('^[a-z|A-Z]\w*$')
_show_id_matcher = re.compile('^(variable\w*|parameter|options|notebook)$')
class FileParam(EntryParam):
"""Provide an entry box for filename and a button to browse for a file."""
def __init__(self, *args, **kwargs):
EntryParam.__init__(self, *args, **kwargs)
input = gtk.Button('...')
input.connect('clicked', self._handle_clicked)
self.pack_start(input, False)
def _handle_clicked(self, widget=None):
"""
If the button was clicked, open a file dialog in open/save format.
Replace the text in the entry with the new filename from the file dialog.
"""
#get the paths
file_path = self.param.is_valid() and self.param.get_evaluated() or ''
(dirname, basename) = os.path.isfile(file_path) and os.path.split(file_path) or (file_path, '')
if not os.path.exists(dirname): dirname = os.getcwd() #fix bad paths
#build the dialog
if self.param.get_type() == 'file_open':
file_dialog = gtk.FileChooserDialog('Open a Data File...', None,
gtk.FILE_CHOOSER_ACTION_OPEN, ('gtk-cancel',gtk.RESPONSE_CANCEL,'gtk-open',gtk.RESPONSE_OK))
elif self.param.get_type() == 'file_save':
file_dialog = gtk.FileChooserDialog('Save a Data File...', None,
gtk.FILE_CHOOSER_ACTION_SAVE, ('gtk-cancel',gtk.RESPONSE_CANCEL, 'gtk-save',gtk.RESPONSE_OK))
file_dialog.set_do_overwrite_confirmation(True)
file_dialog.set_current_name(basename) #show the current filename
file_dialog.set_current_folder(dirname) #current directory
file_dialog.set_select_multiple(False)
file_dialog.set_local_only(True)
if gtk.RESPONSE_OK == file_dialog.run(): #run the dialog
file_path = file_dialog.get_filename() #get the file path
self._input.set_text(file_path)
self._handle_changed()
file_dialog.destroy() #destroy the dialog
#blacklist certain ids, its not complete, but should help
import __builtin__
ID_BLACKLIST = ['self', 'options', 'gr', 'blks2', 'wxgui', 'wx', 'math', 'forms', 'firdes'] + \
filter(lambda x: not x.startswith('_'), dir(gr.top_block())) + dir(__builtin__)
#define types, native python + numpy
VECTOR_TYPES = (tuple, list, set, numpy.ndarray)
COMPLEX_TYPES = [complex, numpy.complex, numpy.complex64, numpy.complex128]
REAL_TYPES = [float, numpy.float, numpy.float32, numpy.float64]
INT_TYPES = [int, long, numpy.int, numpy.int8, numpy.int16, numpy.int32, numpy.uint64,
numpy.uint, numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64]
#cast to tuple for isinstance, concat subtypes
COMPLEX_TYPES = tuple(COMPLEX_TYPES + REAL_TYPES + INT_TYPES)
REAL_TYPES = tuple(REAL_TYPES + INT_TYPES)
INT_TYPES = tuple(INT_TYPES)
class Param(_Param, _GUIParam):
def __init__(self, **kwargs):
_Param.__init__(self, **kwargs)
_GUIParam.__init__(self)
self._init = False
self._hostage_cells = list()
def get_types(self): return (
'raw', 'enum',
'complex', 'real', 'float', 'int',
'complex_vector', 'real_vector', 'float_vector', 'int_vector',
'hex', 'string', 'bool',
'file_open', 'file_save',
'id', 'stream_id',
'grid_pos', 'notebook', 'gui_hint',
'import',
)
def __repr__(self):
"""
Get the repr (nice string format) for this param.
Returns:
the string representation
"""
##################################################
# truncate helper method
##################################################
def _truncate(string, style=0):
max_len = max(27 - len(self.get_name()), 3)
if len(string) > max_len:
if style < 0: #front truncate
string = '...' + string[3-max_len:]
elif style == 0: #center truncate
string = string[:max_len/2 -3] + '...' + string[-max_len/2:]
elif style > 0: #rear truncate
string = string[:max_len-3] + '...'
return string
##################################################
# simple conditions
##################################################
if not self.is_valid(): return _truncate(self.get_value())
if self.get_value() in self.get_option_keys(): return self.get_option(self.get_value()).get_name()
##################################################
# display logic for numbers
##################################################
def num_to_str(num):
if isinstance(num, COMPLEX_TYPES):
num = complex(num) #cast to python complex
if num == 0: return '0' #value is zero
elif num.imag == 0: return '%s'%eng_notation.num_to_str(num.real) #value is real
elif num.real == 0: return '%sj'%eng_notation.num_to_str(num.imag) #value is imaginary
elif num.imag < 0: return '%s-%sj'%(eng_notation.num_to_str(num.real), eng_notation.num_to_str(abs(num.imag)))
else: return '%s+%sj'%(eng_notation.num_to_str(num.real), eng_notation.num_to_str(num.imag))
else: return str(num)
##################################################
# split up formatting by type
##################################################
truncate = 0 #default center truncate
e = self.get_evaluated()
t = self.get_type()
if isinstance(e, bool): return str(e)
elif isinstance(e, COMPLEX_TYPES): dt_str = num_to_str(e)
elif isinstance(e, VECTOR_TYPES): #vector types
if len(e) > 8:
dt_str = self.get_value() #large vectors use code
truncate = 1
else: dt_str = ', '.join(map(num_to_str, e)) #small vectors use eval
elif t in ('file_open', 'file_save'):
dt_str = self.get_value()
truncate = -1
else: dt_str = str(e) #other types
##################################################
# done
##################################################
return _truncate(dt_str, truncate)
def get_input(self, *args, **kwargs):
if self.get_type() in ('file_open', 'file_save'): return FileParam(self, *args, **kwargs)
return _GUIParam.get_input(self, *args, **kwargs)
def get_color(self):
"""
Get the color that represents this param's type.
Returns:
a hex color code.
"""
try:
return {
#number types
'complex': Constants.COMPLEX_COLOR_SPEC,
'real': Constants.FLOAT_COLOR_SPEC,
'float': Constants.FLOAT_COLOR_SPEC,
'int': Constants.INT_COLOR_SPEC,
#vector types
'complex_vector': Constants.COMPLEX_VECTOR_COLOR_SPEC,
'real_vector': Constants.FLOAT_VECTOR_COLOR_SPEC,
'float_vector': Constants.FLOAT_VECTOR_COLOR_SPEC,
'int_vector': Constants.INT_VECTOR_COLOR_SPEC,
#special
'bool': Constants.INT_COLOR_SPEC,
'hex': Constants.INT_COLOR_SPEC,
'string': Constants.BYTE_VECTOR_COLOR_SPEC,
'id': Constants.ID_COLOR_SPEC,
'stream_id': Constants.ID_COLOR_SPEC,
'grid_pos': Constants.INT_VECTOR_COLOR_SPEC,
'notebook': Constants.INT_VECTOR_COLOR_SPEC,
'raw': Constants.WILDCARD_COLOR_SPEC,
}[self.get_type()]
except: return _Param.get_color(self)
def get_hide(self):
"""
Get the hide value from the base class.
Hide the ID parameter for most blocks. Exceptions below.
If the parameter controls a port type, vlen, or nports, return part.
If the parameter is an empty grid position, return part.
These parameters are redundant to display in the flow graph view.
Returns:
hide the hide property string
"""
hide = _Param.get_hide(self)
if hide: return hide
#hide ID in non variable blocks
if self.get_key() == 'id' and not _show_id_matcher.match(self.get_parent().get_key()): return 'part'
#hide port controllers for type and nports
if self.get_key() in ' '.join(map(
lambda p: ' '.join([p._type, p._nports]), self.get_parent().get_ports())
): return 'part'
#hide port controllers for vlen, when == 1
if self.get_key() in ' '.join(map(
lambda p: p._vlen, self.get_parent().get_ports())
):
try:
if int(self.get_evaluated()) == 1: return 'part'
except: pass
#hide empty grid positions
if self.get_key() in ('grid_pos', 'notebook') and not self.get_value(): return 'part'
return hide
def validate(self):
"""
Validate the param.
A test evaluation is performed
"""
_Param.validate(self) #checks type
self._evaluated = None
try: self._evaluated = self.evaluate()
except Exception, e: self.add_error_message(str(e))
def get_evaluated(self): return self._evaluated
def evaluate(self):
"""
Evaluate the value.
Returns:
evaluated type
"""
self._init = True
self._lisitify_flag = False
self._stringify_flag = False
self._hostage_cells = list()
def eval_string(v):
try:
e = self.get_parent().get_parent().evaluate(v)
if isinstance(e, str): return e
raise Exception #want to stringify
except:
self._stringify_flag = True
return v
t = self.get_type()
v = self.get_value()
#########################
# Enum Type
#########################
if self.is_enum(): return v
#########################
# Numeric Types
#########################
elif t in ('raw', 'complex', 'real', 'float', 'int', 'hex', 'bool'):
#raise exception if python cannot evaluate this value
try: e = self.get_parent().get_parent().evaluate(v)
except Exception, e: raise Exception, 'Value "%s" cannot be evaluated:\n%s'%(v, e)
#raise an exception if the data is invalid
if t == 'raw': return e
elif t == 'complex':
if not isinstance(e, COMPLEX_TYPES):
raise Exception, 'Expression "%s" is invalid for type complex.'%str(e)
return e
elif t == 'real' or t == 'float':
if not isinstance(e, REAL_TYPES):
raise Exception, 'Expression "%s" is invalid for type float.'%str(e)
return e
elif t == 'int':
if not isinstance(e, INT_TYPES):
raise Exception, 'Expression "%s" is invalid for type integer.'%str(e)
return e
elif t == 'hex': return hex(e)
elif t == 'bool':
if not isinstance(e, bool):
raise Exception, 'Expression "%s" is invalid for type bool.'%str(e)
return e
else: raise TypeError, 'Type "%s" not handled'%t
#########################
# Numeric Vector Types
#########################
elif t in ('complex_vector', 'real_vector', 'float_vector', 'int_vector'):
if not v: v = '()' #turn a blank string into an empty list, so it will eval
#raise exception if python cannot evaluate this value
try: e = self.get_parent().get_parent().evaluate(v)
except Exception, e: raise Exception, 'Value "%s" cannot be evaluated:\n%s'%(v, e)
#raise an exception if the data is invalid
if t == 'complex_vector':
if not isinstance(e, VECTOR_TYPES):
self._lisitify_flag = True
e = [e]
if not all([isinstance(ei, COMPLEX_TYPES) for ei in e]):
raise Exception, 'Expression "%s" is invalid for type complex vector.'%str(e)
return e
elif t == 'real_vector' or t == 'float_vector':
if not isinstance(e, VECTOR_TYPES):
self._lisitify_flag = True
e = [e]
if not all([isinstance(ei, REAL_TYPES) for ei in e]):
raise Exception, 'Expression "%s" is invalid for type float vector.'%str(e)
return e
elif t == 'int_vector':
if not isinstance(e, VECTOR_TYPES):
self._lisitify_flag = True
e = [e]
if not all([isinstance(ei, INT_TYPES) for ei in e]):
raise Exception, 'Expression "%s" is invalid for type integer vector.'%str(e)
return e
#########################
# String Types
#########################
elif t in ('string', 'file_open', 'file_save'):
#do not check if file/directory exists, that is a runtime issue
e = eval_string(v)
return str(e)
#########################
# Unique ID Type
#########################
elif t == 'id':
#can python use this as a variable?
if not _check_id_matcher.match(v):
raise Exception, 'ID "%s" must begin with a letter and may contain letters, numbers, and underscores.'%v
ids = [param.get_value() for param in self.get_all_params(t)]
if ids.count(v) > 1: #id should only appear once, or zero times if block is disabled
raise Exception, 'ID "%s" is not unique.'%v
if v in ID_BLACKLIST:
raise Exception, 'ID "%s" is blacklisted.'%v
return v
#########################
# Stream ID Type
#########################
elif t == 'stream_id':
#get a list of all stream ids used in the virtual sinks
ids = [param.get_value() for param in filter(
lambda p: p.get_parent().is_virtual_sink(),
self.get_all_params(t),
)]
#check that the virtual sink's stream id is unique
if self.get_parent().is_virtual_sink():
if ids.count(v) > 1: #id should only appear once, or zero times if block is disabled
raise Exception, 'Stream ID "%s" is not unique.'%v
#check that the virtual source's steam id is found
if self.get_parent().is_virtual_source():
if v not in ids:
raise Exception, 'Stream ID "%s" is not found.'%v
return v
#########################
# GUI Position/Hint
#########################
elif t == 'gui_hint':
if ':' in v: tab, pos = v.split(':')
elif '@' in v: tab, pos = v, ''
else: tab, pos = '', v
if '@' in tab: tab, index = tab.split('@')
else: index = '?'
widget_str = ({
(True, True): 'self.%(tab)s_grid_layout_%(index)s.addWidget(%(widget)s, %(pos)s)',
(True, False): 'self.%(tab)s_layout_%(index)s.addWidget(%(widget)s)',
(False, True): 'self.top_grid_layout.addWidget(%(widget)s, %(pos)s)',
(False, False): 'self.top_layout.addWidget(%(widget)s)',
}[bool(tab), bool(pos)])%{'tab': tab, 'index': index, 'widget': '%s', 'pos': pos}
def gui_hint(ws, w):
if 'layout' in w: ws = ws.replace('addWidget', 'addLayout')
return ws%w
return lambda w: gui_hint(widget_str, w)
#########################
# Grid Position Type
#########################
elif t == 'grid_pos':
if not v: return '' #allow for empty grid pos
e = self.get_parent().get_parent().evaluate(v)
if not isinstance(e, (list, tuple)) or len(e) != 4 or not all([isinstance(ei, int) for ei in e]):
raise Exception, 'A grid position must be a list of 4 integers.'
row, col, row_span, col_span = e
#check row, col
if row < 0 or col < 0:
raise Exception, 'Row and column must be non-negative.'
#check row span, col span
if row_span <= 0 or col_span <= 0:
raise Exception, 'Row and column span must be greater than zero.'
#get hostage cell parent
try: my_parent = self.get_parent().get_param('notebook').evaluate()
except: my_parent = ''
#calculate hostage cells
for r in range(row_span):
for c in range(col_span):
self._hostage_cells.append((my_parent, (row+r, col+c)))
#avoid collisions
params = filter(lambda p: p is not self, self.get_all_params('grid_pos'))
for param in params:
for parent, cell in param._hostage_cells:
if (parent, cell) in self._hostage_cells:
raise Exception, 'Another graphical element is using parent "%s", cell "%s".'%(str(parent), str(cell))
return e
#########################
# Notebook Page Type
#########################
elif t == 'notebook':
if not v: return '' #allow for empty notebook
#get a list of all notebooks
notebook_blocks = filter(lambda b: b.get_key() == 'notebook', self.get_parent().get_parent().get_enabled_blocks())
#check for notebook param syntax
try: notebook_id, page_index = map(str.strip, v.split(','))
except: raise Exception, 'Bad notebook page format.'
#check that the notebook id is valid
try: notebook_block = filter(lambda b: b.get_id() == notebook_id, notebook_blocks)[0]
except: raise Exception, 'Notebook id "%s" is not an existing notebook id.'%notebook_id
#check that page index exists
if int(page_index) not in range(len(notebook_block.get_param('labels').evaluate())):
raise Exception, 'Page index "%s" is not a valid index number.'%page_index
return notebook_id, page_index
#########################
# Import Type
#########################
elif t == 'import':
n = dict() #new namespace
try: exec v in n
except ImportError: raise Exception, 'Import "%s" failed.'%v
except Exception: raise Exception, 'Bad import syntax: "%s".'%v
return filter(lambda k: str(k) != '__builtins__', n.keys())
#########################
else: raise TypeError, 'Type "%s" not handled'%t
def to_code(self):
"""
Convert the value to code.
For string and list types, check the init flag, call evaluate().
This ensures that evaluate() was called to set the xxxify_flags.
Returns:
a string representing the code
"""
v = self.get_value()
t = self.get_type()
if t in ('string', 'file_open', 'file_save'): #string types
if not self._init: self.evaluate()
if self._stringify_flag: return '"%s"'%v.replace('"', '\"')
else: return v
elif t in ('complex_vector', 'real_vector', 'float_vector', 'int_vector'): #vector types
if not self._init: self.evaluate()
if self._lisitify_flag: return '(%s, )'%v
else: return '(%s)'%v
else: return v
def get_all_params(self, type):
"""
Get all the params from the flowgraph that have the given type.
Args:
type: the specified type
Returns:
a list of params
"""
return sum([filter(lambda p: p.get_type() == type, block.get_params()) for block in self.get_parent().get_parent().get_enabled_blocks()], [])
gnuradio-3.7.2.1/grc/python/Connection.py 0000664 0001750 0001750 00000003657 12207702530 020102 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import Constants
from .. base.Element import Element
from .. base.Connection import Connection as _Connection
from .. gui.Connection import Connection as _GUIConnection
class Connection(_Connection, _GUIConnection):
def __init__(self, **kwargs):
_Connection.__init__(self, **kwargs)
_GUIConnection.__init__(self)
def is_msg(self):
return self.get_source().get_type() == self.get_sink().get_type() == 'msg'
def is_message(self):
return self.get_source().get_type() == self.get_sink().get_type() == 'message'
def is_bus(self):
return self.get_source().get_type() == self.get_sink().get_type() == 'bus'
def validate(self):
"""
Validate the connections.
The ports must match in io size.
"""
Element.validate(self)
source_size = Constants.TYPE_TO_SIZEOF[self.get_source().get_type()] * self.get_source().get_vlen()
sink_size = Constants.TYPE_TO_SIZEOF[self.get_sink().get_type()] * self.get_sink().get_vlen()
if source_size != sink_size:
self.add_error_message('Source IO size "%s" does not match sink IO size "%s".'%(source_size, sink_size))
gnuradio-3.7.2.1/grc/python/FlowGraph.py 0000664 0001750 0001750 00000021717 12232637747 017710 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import expr_utils
from .. base.FlowGraph import FlowGraph as _FlowGraph
from .. gui.FlowGraph import FlowGraph as _GUIFlowGraph
from .. base.odict import odict
import re
_variable_matcher = re.compile('^(variable\w*)$')
_parameter_matcher = re.compile('^(parameter)$')
_monitors_searcher = re.compile('(ctrlport_monitor)')
_bussink_searcher = re.compile('^(bus_sink)$')
_bussrc_searcher = re.compile('^(bus_source)$')
_bus_struct_sink_searcher = re.compile('^(bus_structure_sink)$')
_bus_struct_src_searcher = re.compile('^(bus_structure_source)$')
class FlowGraph(_FlowGraph, _GUIFlowGraph):
def __init__(self, **kwargs):
_FlowGraph.__init__(self, **kwargs)
_GUIFlowGraph.__init__(self)
self._eval_cache = dict()
def _eval(self, code, namespace, namespace_hash):
"""
Evaluate the code with the given namespace.
Args:
code: a string with python code
namespace: a dict representing the namespace
namespace_hash: a unique hash for the namespace
Returns:
the resultant object
"""
if not code: raise Exception, 'Cannot evaluate empty statement.'
my_hash = hash(code) ^ namespace_hash
#cache if does not exist
if not self._eval_cache.has_key(my_hash):
self._eval_cache[my_hash] = eval(code, namespace, namespace)
#return from cache
return self._eval_cache[my_hash]
def get_io_signaturev(self, direction):
"""
Get a list of io signatures for this flow graph.
Args:
direction: a string of 'in' or 'out'
Returns:
a list of dicts with: type, label, vlen, size
"""
sorted_pads = {
'in': self.get_pad_sources(),
'out': self.get_pad_sinks(),
}[direction]
# we only want stream ports
sorted_pads = filter(lambda b: b.get_param('type').get_evaluated() != 'message', sorted_pads);
expanded_pads = [];
for i in sorted_pads:
for j in range(i.get_param('num_streams').get_evaluated()):
expanded_pads.append(i);
#load io signature
return [{
'label': str(pad.get_param('label').get_evaluated()),
'type': str(pad.get_param('type').get_evaluated()),
'vlen': str(pad.get_param('vlen').get_value()),
'size': pad.get_param('type').get_opt('size'),
'optional': bool(pad.get_param('optional').get_evaluated()),
} for pad in expanded_pads]
def get_pad_sources(self):
"""
Get a list of pad source blocks sorted by id order.
Returns:
a list of pad source blocks in this flow graph
"""
pads = filter(lambda b: b.get_key() == 'pad_source', self.get_enabled_blocks())
return sorted(pads, lambda x, y: cmp(x.get_id(), y.get_id()))
def get_pad_sinks(self):
"""
Get a list of pad sink blocks sorted by id order.
Returns:
a list of pad sink blocks in this flow graph
"""
pads = filter(lambda b: b.get_key() == 'pad_sink', self.get_enabled_blocks())
return sorted(pads, lambda x, y: cmp(x.get_id(), y.get_id()))
def get_msg_pad_sources(self):
ps = self.get_pad_sources();
return filter(lambda b: b.get_param('type').get_evaluated() == 'message', ps);
def get_msg_pad_sinks(self):
ps = self.get_pad_sinks();
return filter(lambda b: b.get_param('type').get_evaluated() == 'message', ps);
def get_imports(self):
"""
Get a set of all import statments in this flow graph namespace.
Returns:
a set of import statements
"""
imports = sum([block.get_imports() for block in self.get_enabled_blocks()], [])
imports = sorted(set(imports))
return imports
def get_variables(self):
"""
Get a list of all variables in this flow graph namespace.
Exclude paramterized variables.
Returns:
a sorted list of variable blocks in order of dependency (indep -> dep)
"""
variables = filter(lambda b: _variable_matcher.match(b.get_key()), self.get_enabled_blocks())
return expr_utils.sort_objects(variables, lambda v: v.get_id(), lambda v: v.get_var_make())
def get_parameters(self):
"""
Get a list of all paramterized variables in this flow graph namespace.
Returns:
a list of paramterized variables
"""
parameters = filter(lambda b: _parameter_matcher.match(b.get_key()), self.get_enabled_blocks())
return parameters
def get_monitors(self):
"""
Get a list of all ControlPort monitors
"""
monitors = filter(lambda b: _monitors_searcher.search(b.get_key()), self.get_enabled_blocks())
return monitors
def get_bussink(self):
bussink = filter(lambda b: _bussink_searcher.search(b.get_key()), self.get_enabled_blocks())
for i in bussink:
for j in i.get_params():
if j.get_name() == 'On/Off' and j.get_value() == 'on':
return True;
return False
def get_bussrc(self):
bussrc = filter(lambda b: _bussrc_searcher.search(b.get_key()), self.get_enabled_blocks())
for i in bussrc:
for j in i.get_params():
if j.get_name() == 'On/Off' and j.get_value() == 'on':
return True;
return False
def get_bus_structure_sink(self):
bussink = filter(lambda b: _bus_struct_sink_searcher.search(b.get_key()), self.get_enabled_blocks())
return bussink
def get_bus_structure_src(self):
bussrc = filter(lambda b: _bus_struct_src_searcher.search(b.get_key()), self.get_enabled_blocks())
return bussrc
def rewrite(self):
"""
Flag the namespace to be renewed.
"""
def reconnect_bus_blocks():
for block in self.get_blocks():
if 'bus' in map(lambda a: a.get_type(), block.get_sources_gui()):
for i in range(len(block.get_sources_gui())):
if len(block.get_sources_gui()[i].get_connections()) > 0:
source = block.get_sources_gui()[i]
sink = []
for j in range(len(source.get_connections())):
sink.append(source.get_connections()[j].get_sink());
for elt in source.get_connections():
self.remove_element(elt);
for j in sink:
self.connect(source, j);
self._renew_eval_ns = True
_FlowGraph.rewrite(self);
reconnect_bus_blocks();
def evaluate(self, expr):
"""
Evaluate the expression.
Args:
expr: the string expression
@throw Exception bad expression
Returns:
the evaluated data
"""
if self._renew_eval_ns:
self._renew_eval_ns = False
#reload namespace
n = dict()
#load imports
for imp in self.get_imports():
try: exec imp in n
except: pass
#load parameters
np = dict()
for parameter in self.get_parameters():
try:
e = eval(parameter.get_param('value').to_code(), n, n)
np[parameter.get_id()] = e
except: pass
n.update(np) #merge param namespace
#load variables
for variable in self.get_variables():
try:
e = eval(variable.get_param('value').to_code(), n, n)
n[variable.get_id()] = e
except: pass
#make namespace public
self.n = n
self.n_hash = hash(str(n))
#evaluate
e = self._eval(expr, self.n, self.n_hash)
return e
gnuradio-3.7.2.1/grc/python/__init__.py 0000644 0001750 0001750 00000000001 11700377701 017521 0 ustar jcorgan jcorgan
gnuradio-3.7.2.1/grc/python/flow_graph.tmpl 0000664 0001750 0001750 00000030347 12237515112 020454 0 ustar jcorgan jcorgan #!/usr/bin/env python
########################################################
##Cheetah template - gnuradio_python
##
##@param imports the import statements
##@param flow_graph the flow_graph
##@param variables the variable blocks
##@param parameters the paramater blocks
##@param blocks the signal blocks
##@param connections the connections
##@param messages the msg type connections
##@param generate_options the type of flow graph
##@param var_id2cbs variable id map to callback strings
########################################################
#def indent($code)
#set $code = '\n '.join(str($code).splitlines())
$code#slurp
#end def
#import time
#set $DIVIDER = '#'*50
$DIVIDER
# Gnuradio Python Flow Graph
# Title: $title
#if $flow_graph.get_option('author')
# Author: $flow_graph.get_option('author')
#end if
#if $flow_graph.get_option('description')
# Description: $flow_graph.get_option('description')
#end if
# Generated: $time.ctime()
$DIVIDER
########################################################
##Create Imports
########################################################
#for $imp in $imports
$imp
#end for
########################################################
##Create Class
## Write the class declaration for a top or hier block.
## The parameter names are the arguments to __init__.
## Determine the absolute icon path (wx gui only).
## Setup the IO signature (hier block only).
########################################################
#set $class_name = $flow_graph.get_option('id')
#set $param_str = ', '.join(['self'] + ['%s=%s'%(param.get_id(), param.get_make()) for param in $parameters])
#if $generate_options == 'wx_gui'
#import gtk
#set $icon = gtk.IconTheme().lookup_icon('gnuradio-grc', 32, 0)
class $(class_name)(grc_wxgui.top_block_gui):
def __init__($param_str):
grc_wxgui.top_block_gui.__init__(self, title="$title")
#if $icon
_icon_path = "$icon.get_filename()"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
#end if
#elif $generate_options == 'qt_gui'
class $(class_name)(gr.top_block, Qt.QWidget):
def __init__($param_str):
gr.top_block.__init__(self, "$title")
Qt.QWidget.__init__(self)
self.setWindowTitle("$title")
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", "$class_name")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
#elif $generate_options == 'no_gui'
class $(class_name)(gr.top_block):
def __init__($param_str):
gr.top_block.__init__(self, "$title")
#elif $generate_options == 'hb'
#set $in_sigs = $flow_graph.get_io_signaturev('in')
#set $out_sigs = $flow_graph.get_io_signaturev('out')
class $(class_name)(gr.hier_block2):
#def make_io_sig($io_sigs)
#set $size_strs = ['%s*%s'%(io_sig['size'], io_sig['vlen']) for io_sig in $io_sigs]
#if len($io_sigs) == 0
gr.io_signature(0, 0, 0)#slurp
#elif len($io_sigs) == 1
gr.io_signature(1, 1, $size_strs[0])#slurp
#else
gr.io_signaturev($(len($io_sigs)), $(len($io_sigs)), [$(', '.join($size_strs))])#slurp
#end if
#end def
def __init__($param_str):
gr.hier_block2.__init__(
self, "$title",
$make_io_sig($in_sigs),
$make_io_sig($out_sigs),
)
#end if
########################################################
##Create Parameters
## Set the parameter to a property of self.
########################################################
#if $parameters
$DIVIDER
# Parameters
$DIVIDER
#end if
#for $param in $parameters
$indent($param.get_var_make())
#end for
########################################################
##Create Variables
########################################################
#if $variables
$DIVIDER
# Variables
$DIVIDER
#end if
#for $var in $variables
$indent($var.get_var_make())
#end for
########################################################
##Create Message Queues
########################################################
#if $messages
$DIVIDER
# Message Queues
$DIVIDER
#end if
#for $msg in $messages
$(msg.get_source().get_parent().get_id())_msgq_out = $(msg.get_sink().get_parent().get_id())_msgq_in = gr.msg_queue(2)
#end for
########################################################
##Create Blocks
########################################################
#if $blocks
$DIVIDER
# Blocks
$DIVIDER
#end if
#for $blk in filter(lambda b: b.get_make(), $blocks)
#if $blk in $variables
$indent($blk.get_make())
#else
self.$blk.get_id() = $indent($blk.get_make())
#if $blk.has_param('affinity') and $blk.get_param('affinity').get_evaluated()
(self.$blk.get_id()).set_processor_affinity($blk.get_param('affinity').get_evaluated())
#end if
#if (len($blk.get_sources())>0) and $blk.has_param('minoutbuf') and (int($blk.get_param('minoutbuf').get_evaluated()) > 0)
(self.$blk.get_id()).set_min_output_buffer($blk.get_param('minoutbuf').get_evaluated())
#end if
#if (len($blk.get_sources())>0) and $blk.has_param('maxoutbuf') and (int($blk.get_param('maxoutbuf').get_evaluated()) > 0)
(self.$blk.get_id()).set_max_output_buffer($blk.get_param('maxoutbuf').get_evaluated())
#end if
#end if
#end for
########################################################
##Create Connections
## The port name should be the id of the parent block.
## However, port names for IO pads should be self.
########################################################
#def make_port_sig($port)
#if $port.get_parent().get_key() == 'pad_source'
(self, $flow_graph.get_pad_sources().index($port.get_parent()))#slurp
#elif $port.get_parent().get_key() == 'pad_sink'
(self, $flow_graph.get_pad_sinks().index($port.get_parent()))#slurp
#else
(self.$port.get_parent().get_id(), $port.get_key())#slurp
#end if
#end def
#if $connections
$DIVIDER
# Connections
$DIVIDER
#end if
#for $con in $connections
#set $source = $con.get_source()
#set $sink = $con.get_sink()
##resolve virtual sources to the actual sources
#if $source.get_parent().is_virtual_source()
#set $source = $source.resolve_virtual_source()
#end if
##do not generate connections with virtual sinks
#if not $sink.get_parent().is_virtual_sink()
self.connect($make_port_sig($source), $make_port_sig($sink))
#end if
#end for
########################################################
##Create Asynch Message Connections
########################################################
#if $messages2
$DIVIDER
# Asynch Message Connections
$DIVIDER
#end if
#for $msg in $messages2
#set $sr = $msg.get_source()
#set $source = "self.%s"%($sr.get_parent().get_id())
#set $source_port = $sr.get_name();
#if $sr.get_parent().get_key() == "pad_source"
#set $source = "self"
#set $source_port = $sr.get_parent().get_param("label").get_value();
#end if
#set $sk = $msg.get_sink()
#set $sink = "self.%s"%($sk.get_parent().get_id())
#set $sink_port = $sk.get_name();
#if $sk.get_parent().get_key() == "pad_sink"
#set $sink = "self"
#set $sink_port = $sk.get_parent().get_param("label").get_value();
#end if
self.msg_connect($source, "$source_port", $sink, "$sink_port")
#end for
########################################################
# QT sink close method reimplementation
########################################################
#if $generate_options == 'qt_gui'
def closeEvent(self, event):
self.settings = Qt.QSettings("GNU Radio", "$class_name")
self.settings.setValue("geometry", self.saveGeometry())
event.accept()
#end if
########################################################
##Create Callbacks
## Write a set method for this variable that calls the callbacks
########################################################
#for $var in $parameters + $variables
#set $id = $var.get_id()
def get_$(id)(self):
return self.$id
def set_$(id)(self, $id):
self.$id = $id
#for $callback in $var_id2cbs[$id]
$indent($callback)
#end for
#end for
########################################################
##Create Main
## For top block code, generate a main routine.
## Instantiate the top block and run as gui or cli.
########################################################
#def make_default($type, $param)
#if $type == 'eng_float'
eng_notation.num_to_str($param.get_make())#slurp
#else
$param.get_make()#slurp
#end if
#end def
#def make_short_id($param)
#set $short_id = $param.get_param('short_id').get_evaluated()
#if $short_id
#set $short_id = '-' + $short_id
#end if
$short_id#slurp
#end def
#if $generate_options != 'hb'
if __name__ == '__main__':
#if $generate_options in ('wx_gui', 'qt_gui')
import ctypes
import os
if os.name == 'posix':
try:
x11 = ctypes.cdll.LoadLibrary('libX11.so')
x11.XInitThreads()
except:
print "Warning: failed to XInitThreads()"
#end if
parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
#set $params_eq_list = list()
#for $param in $parameters
#set $type = $param.get_param('type').get_value()
#if $type
#silent $params_eq_list.append('%s=options.%s'%($param.get_id(), $param.get_id()))
parser.add_option("$make_short_id($param)", "--$param.get_id().replace('_', '-')", dest="$param.get_id()", type="$type", default=$make_default($type, $param),
help="Set $($param.get_param('label').get_evaluated() or $param.get_id()) [default=%default]")
#end if
#end for
(options, args) = parser.parse_args()
#if $flow_graph.get_option('realtime_scheduling')
if gr.enable_realtime_scheduling() != gr.RT_OK:
print "Error: failed to enable realtime scheduling."
#end if
#if $generate_options == 'wx_gui'
tb = $(class_name)($(', '.join($params_eq_list)))
#if $flow_graph.get_option('max_nouts')
tb.Run($flow_graph.get_option('run'), $flow_graph.get_option('max_nouts'))
#else
tb.Start($flow_graph.get_option('run'))
#for $m in $monitors
(tb.$m.get_id()).start()
#end for
tb.Wait()
#end if
#elif $generate_options == 'qt_gui'
qapp = Qt.QApplication(sys.argv)
tb = $(class_name)($(', '.join($params_eq_list)))
#if $flow_graph.get_option('run')
#if $flow_graph.get_option('max_nouts')
tb.start($flow_graph.get_option('max_nouts'))
#else
tb.start()
#end if
#end if
tb.show()
def quitting():
tb.stop()
tb.wait()
qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting)
#for $m in $monitors
(tb.$m.get_id()).start()
#end for
qapp.exec_()
tb = None #to clean up Qt widgets
#elif $generate_options == 'no_gui'
tb = $(class_name)($(', '.join($params_eq_list)))
#set $run_options = $flow_graph.get_option('run_options')
#if $run_options == 'prompt'
#if $flow_graph.get_option('max_nouts')
tb.start($flow_graph.get_option('max_nouts'))
#else
tb.start()
#end if
#for $m in $monitors
(tb.$m.get_id()).start()
#end for
raw_input('Press Enter to quit: ')
tb.stop()
#elif $run_options == 'run'
#if $flow_graph.get_option('max_nouts')
tb.start($flow_graph.get_option('max_nouts'))
#else
tb.start()
#end if
#end if
#for $m in $monitors
(tb.$m.get_id()).start()
#end for
tb.wait()
#end if
#end if
gnuradio-3.7.2.1/grc/python/Generator.py 0000664 0001750 0001750 00000014726 12207702530 017730 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import os
import sys
import subprocess
import tempfile
from Cheetah.Template import Template
import expr_utils
from Constants import \
TOP_BLOCK_FILE_MODE, HIER_BLOCK_FILE_MODE, \
HIER_BLOCKS_LIB_DIR, FLOW_GRAPH_TEMPLATE
import convert_hier
from .. gui import Messages
class Generator(object):
def __init__(self, flow_graph, file_path):
"""
Initialize the generator object.
Determine the file to generate.
Args:
flow_graph: the flow graph object
file_path: the path to write the file to
"""
self._flow_graph = flow_graph
self._generate_options = self._flow_graph.get_option('generate_options')
if self._generate_options == 'hb':
self._mode = HIER_BLOCK_FILE_MODE
dirname = HIER_BLOCKS_LIB_DIR
else:
self._mode = TOP_BLOCK_FILE_MODE
dirname = os.path.dirname(file_path)
#handle the case where the directory is read-only
#in this case, use the system's temp directory
if not os.access(dirname, os.W_OK):
dirname = tempfile.gettempdir()
filename = self._flow_graph.get_option('id') + '.py'
self._file_path = os.path.join(dirname, filename)
def get_file_path(self): return self._file_path
def write(self):
#do throttle warning
throttled = any(map(lambda b: b.throttle(), self._flow_graph.get_enabled_blocks()))
if not throttled and self._generate_options != 'hb':
Messages.send_warning('''\
This flow graph may not have flow control: no audio or usrp blocks found. \
Add a Misc->Throttle block to your flow graph to avoid CPU congestion.''')
#generate
open(self.get_file_path(), 'w').write(str(self))
if self._generate_options == 'hb':
#convert hier block to xml wrapper
convert_hier.convert_hier(self._flow_graph, self.get_file_path())
os.chmod(self.get_file_path(), self._mode)
def get_popen(self):
"""
Execute this python flow graph.
Returns:
a popen object
"""
#extract the path to the python executable
python_exe = sys.executable
#when using wx gui on mac os, execute with pythonw
#using pythonw is not necessary anymore, disabled below
#if self._generate_options == 'wx_gui' and 'darwin' in sys.platform.lower():
# python_exe = 'pythonw'
#setup the command args to run
cmds = [python_exe, '-u', self.get_file_path()] #-u is unbuffered stdio
#when in no gui mode on linux, use an xterm (looks nice)
if self._generate_options == 'no_gui' and 'linux' in sys.platform.lower():
cmds = ['xterm', '-e'] + cmds
p = subprocess.Popen(args=cmds, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=False, universal_newlines=True)
return p
def __str__(self):
"""
Convert the flow graph to python code.
Returns:
a string of python code
"""
title = self._flow_graph.get_option('title') or self._flow_graph.get_option('id').replace('_', ' ').title()
imports = self._flow_graph.get_imports()
variables = self._flow_graph.get_variables()
parameters = self._flow_graph.get_parameters()
monitors = self._flow_graph.get_monitors()
#list of blocks not including variables and imports and parameters and disabled
def _get_block_sort_text(block):
code = block.get_make().replace(block.get_id(), ' ')
try: code += block.get_param('notebook').get_value() #older gui markup w/ wxgui
except: pass
try: code += block.get_param('gui_hint').get_value() #newer gui markup w/ qtgui
except: pass
return code
blocks = expr_utils.sort_objects(
self._flow_graph.get_enabled_blocks(),
lambda b: b.get_id(), _get_block_sort_text
)
#list of regular blocks (all blocks minus the special ones)
blocks = filter(lambda b: b not in (imports + parameters), blocks)
#list of connections where each endpoint is enabled
connections = filter(lambda c: not (c.is_bus() or c.is_msg() or c.is_message()), self._flow_graph.get_enabled_connections())
messages = filter(lambda c: c.is_msg(), self._flow_graph.get_enabled_connections())
messages2 = filter(lambda c: c.is_message(), self._flow_graph.get_enabled_connections())
#list of variable names
var_ids = [var.get_id() for var in parameters + variables]
#prepend self.
replace_dict = dict([(var_id, 'self.%s'%var_id) for var_id in var_ids])
#list of callbacks
callbacks = [
expr_utils.expr_replace(cb, replace_dict)
for cb in sum([block.get_callbacks() for block in self._flow_graph.get_enabled_blocks()], [])
]
#map var id to callbacks
var_id2cbs = dict(
[(var_id, filter(lambda c: expr_utils.get_variable_dependencies(c, [var_id]), callbacks))
for var_id in var_ids]
)
#load the namespace
namespace = {
'title': title,
'imports': imports,
'flow_graph': self._flow_graph,
'variables': variables,
'parameters': parameters,
'monitors': monitors,
'blocks': blocks,
'connections': connections,
'messages': messages,
'messages2': messages2,
'generate_options': self._generate_options,
'var_id2cbs': var_id2cbs,
}
#build the template
t = Template(open(FLOW_GRAPH_TEMPLATE, 'r').read(), namespace)
return str(t)
gnuradio-3.7.2.1/grc/python/default_flow_graph.grc 0000664 0001750 0001750 00000002014 12207702530 021744 0 ustar jcorgan jcorgan
optionsidtop_block_coordinate(10, 10)_rotation0variableidsamp_ratevalue32000_coordinate(10, 170)_rotation0
gnuradio-3.7.2.1/grc/python/extract_docs.py 0000664 0001750 0001750 00000004412 12207702530 020453 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import re
def _extract(key):
"""
Extract the documentation from the python __doc__ strings.
If multiple modules match, combine the docs.
Args:
key: the block key
Returns:
a string with documentation
"""
#extract matches
try:
module_name, constructor_name = key.split('_', 1)
module = __import__('gnuradio.'+module_name)
module = getattr(module, module_name)
except ImportError:
try:
module_name, constructor_name = key.split('_', 1)
module = __import__(module_name)
except: return ''
except:
return ''
pattern = constructor_name.replace('_', '_*').replace('x', '\w')
pattern_matcher = re.compile('^%s\w*$'%pattern)
matches = filter(lambda x: pattern_matcher.match(x), dir(module))
#combine all matches
doc_strs = list()
for match in matches:
try:
title = ' --- ' + match + ' --- '
doc_strs.append('\n\n'.join([title, getattr(module, match).__doc__]).strip())
except: pass
return '\n\n'.join(doc_strs)
_docs_cache = dict()
def extract(key):
"""
Call the private extract and cache the result.
Args:
key: the block key
Returns:
a string with documentation
"""
if not _docs_cache.has_key(key):
_docs_cache[key] = _extract(key)
return _docs_cache[key]
if __name__ == '__main__':
import sys
print extract(sys.argv[1])
gnuradio-3.7.2.1/grc/python/Block.py 0000664 0001750 0001750 00000017010 12207702530 017021 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from .. base.Block import Block as _Block
from .. gui.Block import Block as _GUIBlock
import extract_docs
class Block(_Block, _GUIBlock):
def is_virtual_sink(self): return self.get_key() == 'virtual_sink'
def is_virtual_source(self): return self.get_key() == 'virtual_source'
##for make source to keep track of indexes
_source_count = 0
##for make sink to keep track of indexes
_sink_count = 0
def __init__(self, flow_graph, n):
"""
Make a new block from nested data.
Args:
flow: graph the parent element
n: the nested odict
Returns:
block a new block
"""
#grab the data
self._doc = n.find('doc') or ''
self._imports = map(lambda i: i.strip(), n.findall('import'))
self._make = n.find('make')
self._var_make = n.find('var_make')
self._checks = n.findall('check')
self._callbacks = n.findall('callback')
self._throttle = n.find('throttle') or ''
self._bus_structure_source = n.find('bus_structure_source') or ''
self._bus_structure_sink = n.find('bus_structure_sink') or ''
#build the block
_Block.__init__(
self,
flow_graph=flow_graph,
n=n,
)
_GUIBlock.__init__(self)
def get_bus_structure(self, direction):
if direction == 'source':
bus_structure = self._bus_structure_source;
else:
bus_structure = self._bus_structure_sink;
bus_structure = self.resolve_dependencies(bus_structure);
if not bus_structure: return ''
try:
clean_bus_structure = self.get_parent().evaluate(bus_structure)
return clean_bus_structure
except: return ''
def throttle(self): return bool(self._throttle)
def validate(self):
"""
Validate this block.
Call the base class validate.
Evaluate the checks: each check must evaluate to True.
"""
_Block.validate(self)
#evaluate the checks
for check in self._checks:
check_res = self.resolve_dependencies(check)
try:
if not self.get_parent().evaluate(check_res):
self.add_error_message('Check "%s" failed.'%check)
except: self.add_error_message('Check "%s" did not evaluate.'%check)
def rewrite(self):
"""
Add and remove ports to adjust for the nports.
"""
_Block.rewrite(self)
def rectify(ports):
#restore integer contiguity after insertion
#rectify the port names with the index
self.back_ofthe_bus(ports);
for i, port in enumerate(ports):
port._key = str(i)
port._name = port._n['name']
if len(ports) > 1 and not port._type == 'bus': port._name += str(i)
def insert_port(get_ports, get_port, key):
prev_port = get_port(str(int(key)-1))
get_ports().insert(
get_ports().index(prev_port)+1,
prev_port.copy(new_key=key),
)
rectify(get_ports())
def remove_port(get_ports, get_port, key):
port = get_port(key)
for connection in port.get_connections():
self.get_parent().remove_element(connection)
get_ports().remove(port)
rectify(get_ports())
#adjust nports
for get_ports, get_port in (
(self.get_sources, self.get_source),
(self.get_sinks, self.get_sink),
):
master_ports = filter(lambda p: p.get_nports(), get_ports())
for i, master_port in enumerate(master_ports):
nports = master_port.get_nports()
index_first = get_ports().index(master_port)
try: index_last = get_ports().index(master_ports[i+1])
except IndexError: index_last = len(get_ports())
num_ports = index_last - index_first
#do nothing if nports is already num ports
if nports == num_ports: continue
#remove excess ports and connections
if nports < num_ports:
for key in reversed(map(str, range(index_first+nports, index_first+num_ports))):
remove_port(get_ports, get_port, key);
continue
#add more ports
if nports > num_ports:
for key in map(str, range(index_first+num_ports, index_first+nports)):
insert_port(get_ports, get_port, key)
continue
def port_controller_modify(self, direction):
"""
Change the port controller.
Args:
direction: +1 or -1
Returns:
true for change
"""
changed = False
#concat the nports string from the private nports settings of all ports
nports_str = ' '.join([port._nports for port in self.get_ports()])
#modify all params whose keys appear in the nports string
for param in self.get_params():
if param.is_enum() or param.get_key() not in nports_str: continue
#try to increment the port controller by direction
try:
value = param.get_evaluated()
value = value + direction
if 0 < value:
param.set_value(value)
changed = True
except: pass
return changed
def get_doc(self):
doc = self._doc.strip('\n').replace('\\\n', '')
#merge custom doc with doxygen docs
return '\n'.join([doc, extract_docs.extract(self.get_key())]).strip('\n')
def get_category(self):
return _Block.get_category(self)
def get_imports(self):
"""
Resolve all import statements.
Split each import statement at newlines.
Combine all import statments into a list.
Filter empty imports.
Returns:
a list of import statements
"""
return filter(lambda i: i, sum(map(lambda i: self.resolve_dependencies(i).split('\n'), self._imports), []))
def get_make(self): return self.resolve_dependencies(self._make)
def get_var_make(self): return self.resolve_dependencies(self._var_make)
def get_callbacks(self):
"""
Get a list of function callbacks for this block.
Returns:
a list of strings
"""
def make_callback(callback):
callback = self.resolve_dependencies(callback)
if 'self.' in callback: return callback
return 'self.%s.%s'%(self.get_id(), callback)
return map(make_callback, self._callbacks)
gnuradio-3.7.2.1/grc/python/block.dtd 0000664 0001750 0001750 00000004134 12207702530 017207 0 ustar jcorgan jcorgan
gnuradio-3.7.2.1/grc/scripts/ 0000755 0001750 0001750 00000000000 12207702530 015562 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/scripts/CMakeLists.txt 0000644 0001750 0001750 00000001677 11744612271 020344 0 ustar jcorgan jcorgan # 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.
########################################################################
GR_PYTHON_INSTALL(
PROGRAMS gnuradio-companion
DESTINATION ${GR_RUNTIME_DIR}
COMPONENT "grc"
)
gnuradio-3.7.2.1/grc/scripts/gnuradio-companion 0000775 0001750 0001750 00000004624 12207702530 021311 0 ustar jcorgan jcorgan #!/usr/bin/env python
"""
Copyright 2009-2012 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import pygtk
pygtk.require('2.0')
import gtk
try: from gnuradio import gr
except ImportError, e:
d = gtk.MessageDialog(type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_CLOSE, message_format="""
Cannot import gnuradio.
Is the python path environment variable set correctly?
All OS: PYTHONPATH
Is the library path environment variable set correctly?
Linux: LD_LIBRARY_PATH
Windows: PATH
MacOSX: DYLD_LIBRARY_PATH
""")
d.set_title(str(e))
d.run()
exit(-1)
from optparse import OptionParser
import os
if __name__ == "__main__":
if ('GR_DONT_LOAD_PREFS' in os.environ.keys() and
(not 'GRC_BLOCKS_PATH' in os.environ.keys() or len(os.environ['GRC_BLOCKS_PATH']) == 0)):
d = gtk.MessageDialog(
type=gtk.MESSAGE_ERROR,
buttons=gtk.BUTTONS_CLOSE,
message_format="""Can't find block definitions. Use config.conf or GRC_BLOCKS_PATH. """)
d.set_title("No block definitions available.")
d.run()
exit(-1)
usage = 'usage: %prog [options] [saved flow graphs]'
version = """
GNU Radio Companion %s
This program is part of GNU Radio
GRC comes with ABSOLUTELY NO WARRANTY.
This is free software,
and you are welcome to redistribute it.
"""%gr.version()
parser = OptionParser(usage=usage, version=version)
(options, args) = parser.parse_args()
from gnuradio.grc.python.Platform import Platform
from gnuradio.grc.gui.ActionHandler import ActionHandler
#setup icon using icon theme
try: gtk.window_set_default_icon(gtk.IconTheme().load_icon('gnuradio-grc', 256, 0))
except: pass
ActionHandler(args, Platform())
gnuradio-3.7.2.1/grc/grc_gnuradio/ 0000755 0001750 0001750 00000000000 11744612271 016545 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/grc_gnuradio/CMakeLists.txt 0000644 0001750 0001750 00000002215 11700377701 021303 0 ustar jcorgan jcorgan # 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.
########################################################################
GR_PYTHON_INSTALL(
FILES __init__.py
DESTINATION ${GR_PYTHON_DIR}/grc_gnuradio
COMPONENT "grc"
)
GR_PYTHON_INSTALL(FILES
blks2/__init__.py
blks2/error_rate.py
blks2/packet.py
blks2/selector.py
blks2/tcp.py
DESTINATION ${GR_PYTHON_DIR}/grc_gnuradio/blks2
COMPONENT "grc"
)
gnuradio-3.7.2.1/grc/grc_gnuradio/blks2/ 0000755 0001750 0001750 00000000000 12237515112 017554 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/grc_gnuradio/blks2/packet.py 0000664 0001750 0001750 00000023612 12237515112 021403 0 ustar jcorgan jcorgan # Copyright 2008,2009,2012-2013 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 gnuradio import gr, digital
from gnuradio import blocks
from gnuradio.digital import packet_utils
import gnuradio.gr.gr_threading as _threading
##payload length in bytes
DEFAULT_PAYLOAD_LEN = 512
##how many messages in a queue
DEFAULT_MSGQ_LIMIT = 2
##threshold for unmaking packets
DEFAULT_THRESHOLD = 12
##################################################
## Options Class for OFDM
##################################################
class options(object):
def __init__(self, **kwargs):
for key, value in kwargs.iteritems(): setattr(self, key, value)
##################################################
## Packet Encoder
##################################################
class _packet_encoder_thread(_threading.Thread):
def __init__(self, msgq, payload_length, send):
self._msgq = msgq
self._payload_length = payload_length
self._send = send
_threading.Thread.__init__(self)
self.setDaemon(1)
self.keep_running = True
self.start()
def run(self):
sample = '' #residual sample
while self.keep_running:
msg = self._msgq.delete_head() #blocking read of message queue
sample = sample + msg.to_string() #get the body of the msg as a string
while len(sample) >= self._payload_length:
payload = sample[:self._payload_length]
sample = sample[self._payload_length:]
self._send(payload)
class packet_encoder(gr.hier_block2):
"""
Hierarchical block for wrapping packet-based modulators.
"""
def __init__(self, samples_per_symbol, bits_per_symbol, preamble='', access_code='', pad_for_usrp=True):
"""
packet_mod constructor.
Args:
samples_per_symbol: number of samples per symbol
bits_per_symbol: number of bits per symbol
access_code: AKA sync vector
pad_for_usrp: If true, packets are padded such that they end up a multiple of 128 samples
payload_length: number of bytes in a data-stream slice
"""
#setup parameters
self._samples_per_symbol = samples_per_symbol
self._bits_per_symbol = bits_per_symbol
self._pad_for_usrp = pad_for_usrp
if not preamble: #get preamble
preamble = packet_utils.default_preamble
if not access_code: #get access code
access_code = packet_utils.default_access_code
if not packet_utils.is_1_0_string(preamble):
raise ValueError, "Invalid preamble %r. Must be string of 1's and 0's" % (preamble,)
if not packet_utils.is_1_0_string(access_code):
raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
self._preamble = preamble
self._access_code = access_code
self._pad_for_usrp = pad_for_usrp
#create blocks
msg_source = blocks.message_source(gr.sizeof_char, DEFAULT_MSGQ_LIMIT)
self._msgq_out = msg_source.msgq()
#initialize hier2
gr.hier_block2.__init__(
self,
"packet_encoder",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(1, 1, gr.sizeof_char) # Output signature
)
#connect
self.connect(msg_source, self)
def send_pkt(self, payload):
"""
Wrap the payload in a packet and push onto the message queue.
Args:
payload: string, data to send
"""
packet = packet_utils.make_packet(
payload,
self._samples_per_symbol,
self._bits_per_symbol,
self._preamble,
self._access_code,
self._pad_for_usrp
)
msg = gr.message_from_string(packet)
self._msgq_out.insert_tail(msg)
##################################################
## Packet Decoder
##################################################
class _packet_decoder_thread(_threading.Thread):
def __init__(self, msgq, callback):
_threading.Thread.__init__(self)
self.setDaemon(1)
self._msgq = msgq
self.callback = callback
self.keep_running = True
self.start()
def run(self):
while self.keep_running:
msg = self._msgq.delete_head()
ok, payload = packet_utils.unmake_packet(msg.to_string(), int(msg.arg1()))
if self.callback:
self.callback(ok, payload)
class packet_decoder(gr.hier_block2):
"""
Hierarchical block for wrapping packet-based demodulators.
"""
def __init__(self, access_code='', threshold=-1, callback=None):
"""
packet_demod constructor.
Args:
access_code: AKA sync vector
threshold: detect access_code with up to threshold bits wrong (0 -> use default)
callback: a function of args: ok, payload
"""
#access code
if not access_code: #get access code
access_code = packet_utils.default_access_code
if not packet_utils.is_1_0_string(access_code):
raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
self._access_code = access_code
#threshold
if threshold < 0: threshold = DEFAULT_THRESHOLD
self._threshold = threshold
#blocks
msgq = gr.msg_queue(DEFAULT_MSGQ_LIMIT) #holds packets from the PHY
correlator = digital.correlate_access_code_bb(self._access_code, self._threshold)
framer_sink = digital.framer_sink_1(msgq)
#initialize hier2
gr.hier_block2.__init__(
self,
"packet_decoder",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(0, 0, 0) # Output signature
)
#connect
self.connect(self, correlator, framer_sink)
#start thread
_packet_decoder_thread(msgq, callback)
##################################################
## Packet Mod for OFDM Mod and Packet Encoder
##################################################
class packet_mod_base(gr.hier_block2):
"""
Hierarchical block for wrapping packet source block.
"""
def __init__(self, packet_source=None, payload_length=0):
if not payload_length: #get payload length
payload_length = DEFAULT_PAYLOAD_LEN
if payload_length%self._item_size_in != 0: #verify that packet length is a multiple of the stream size
raise ValueError, 'The payload length: "%d" is not a mutiple of the stream size: "%d".'%(payload_length, self._item_size_in)
#initialize hier2
gr.hier_block2.__init__(
self,
"ofdm_mod",
gr.io_signature(1, 1, self._item_size_in), # Input signature
gr.io_signature(1, 1, packet_source._hb.output_signature().sizeof_stream_item(0)) # Output signature
)
#create blocks
msgq = gr.msg_queue(DEFAULT_MSGQ_LIMIT)
msg_sink = blocks.message_sink(self._item_size_in, msgq, False) #False -> blocking
#connect
self.connect(self, msg_sink)
self.connect(packet_source, self)
#start thread
_packet_encoder_thread(msgq, payload_length, packet_source.send_pkt)
class packet_mod_b(packet_mod_base): _item_size_in = gr.sizeof_char
class packet_mod_s(packet_mod_base): _item_size_in = gr.sizeof_short
class packet_mod_i(packet_mod_base): _item_size_in = gr.sizeof_int
class packet_mod_f(packet_mod_base): _item_size_in = gr.sizeof_float
class packet_mod_c(packet_mod_base): _item_size_in = gr.sizeof_gr_complex
##################################################
## Packet Demod for OFDM Demod and Packet Decoder
##################################################
class packet_demod_base(gr.hier_block2):
"""
Hierarchical block for wrapping packet sink block.
"""
def __init__(self, packet_sink=None):
#initialize hier2
gr.hier_block2.__init__(
self,
"ofdm_mod",
gr.io_signature(1, 1, packet_sink._hb.input_signature().sizeof_stream_item(0)), # Input signature
gr.io_signature(1, 1, self._item_size_out) # Output signature
)
#create blocks
msg_source = blocks.message_source(self._item_size_out, DEFAULT_MSGQ_LIMIT)
self._msgq_out = msg_source.msgq()
#connect
self.connect(self, packet_sink)
self.connect(msg_source, self)
if packet_sink._hb.output_signature().sizeof_stream_item(0):
self.connect(packet_sink,
blocks.null_sink(packet_sink._hb.output_signature().sizeof_stream_item(0)))
def recv_pkt(self, ok, payload):
msg = gr.message_from_string(payload, 0, self._item_size_out,
len(payload)/self._item_size_out)
if ok: self._msgq_out.insert_tail(msg)
class packet_demod_b(packet_demod_base): _item_size_out = gr.sizeof_char
class packet_demod_s(packet_demod_base): _item_size_out = gr.sizeof_short
class packet_demod_i(packet_demod_base): _item_size_out = gr.sizeof_int
class packet_demod_f(packet_demod_base): _item_size_out = gr.sizeof_float
class packet_demod_c(packet_demod_base): _item_size_out = gr.sizeof_gr_complex
gnuradio-3.7.2.1/grc/grc_gnuradio/blks2/selector.py 0000664 0001750 0001750 00000013311 12233246672 021757 0 ustar jcorgan jcorgan #
# Copyright 2008,2013 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 gnuradio import gr
from gnuradio import blocks
class selector(gr.hier_block2):
"""A hier2 block with N inputs and M outputs, where data is only forwarded through input n to output m."""
def __init__(self, item_size, num_inputs, num_outputs, input_index, output_index):
"""
Selector constructor.
Args:
item_size: the size of the gr data stream in bytes
num_inputs: the number of inputs (integer)
num_outputs: the number of outputs (integer)
input_index: the index for the source data
output_index: the index for the destination data
"""
gr.hier_block2.__init__(
self, 'selector',
gr.io_signature(num_inputs, num_inputs, item_size),
gr.io_signature(num_outputs, num_outputs, item_size),
)
#terminator blocks for unused inputs and outputs
self.input_terminators = [blocks.null_sink(item_size) for i in range(num_inputs)]
self.output_terminators = [blocks.head(item_size, 0) for i in range(num_outputs)]
self.copy = blocks.copy(item_size)
#connections
for i in range(num_inputs): self.connect((self, i), self.input_terminators[i])
for i in range(num_outputs): self.connect(blocks.null_source(item_size),
self.output_terminators[i], (self, i))
self.item_size = item_size
self.input_index = input_index
self.output_index = output_index
self.num_inputs = num_inputs
self.num_outputs = num_outputs
self._connect_current()
def _indexes_valid(self):
"""
Are the input and output indexes within range of the number of inputs and outputs?
Returns:
true if input index and output index are in range
"""
return self.input_index in range(self.num_inputs) and self.output_index in range(self.num_outputs)
def _connect_current(self):
"""If the input and output indexes are valid:
disconnect the blocks at the input and output index from their terminators,
and connect them to one another. Then connect the terminators to one another."""
if self._indexes_valid():
self.disconnect((self, self.input_index), self.input_terminators[self.input_index])
self.disconnect(self.output_terminators[self.output_index], (self, self.output_index))
self.connect((self, self.input_index), self.copy)
self.connect(self.copy, (self, self.output_index))
self.connect(self.output_terminators[self.output_index], self.input_terminators[self.input_index])
def _disconnect_current(self):
"""If the input and output indexes are valid:
disconnect the blocks at the input and output index from one another,
and the terminators at the input and output index from one another.
Reconnect the blocks to the terminators."""
if self._indexes_valid():
self.disconnect((self, self.input_index), self.copy)
self.disconnect(self.copy, (self, self.output_index))
self.disconnect(self.output_terminators[self.output_index], self.input_terminators[self.input_index])
self.connect((self, self.input_index), self.input_terminators[self.input_index])
self.connect(self.output_terminators[self.output_index], (self, self.output_index))
def set_input_index(self, input_index):
"""
Change the block to the new input index if the index changed.
Args:
input_index: the new input index
"""
if self.input_index != input_index:
self.lock()
self._disconnect_current()
self.input_index = input_index
self._connect_current()
self.unlock()
def set_output_index(self, output_index):
"""
Change the block to the new output index if the index changed.
Args:
output_index: the new output index
"""
if self.output_index != output_index:
self.lock()
self._disconnect_current()
self.output_index = output_index
self._connect_current()
self.unlock()
class valve(selector):
"""Wrapper for selector with 1 input and 1 output."""
def __init__(self, item_size, open):
"""
Constructor for valve.
Args:
item_size: the size of the gr data stream in bytes
open: true if initial valve state is open
"""
if open: output_index = -1
else: output_index = 0
selector.__init__(self, item_size, 1, 1, 0, output_index)
def set_open(self, open):
"""
Callback to set open state.
Args:
open: true to set valve state to open
"""
if open: output_index = -1
else: output_index = 0
self.set_output_index(output_index)
gnuradio-3.7.2.1/grc/grc_gnuradio/blks2/error_rate.py 0000664 0001750 0001750 00000012216 12233246672 022306 0 ustar jcorgan jcorgan # Copyright 2008 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.
#
default_win_size = 1000
from gnuradio import gr
from gnuradio import blocks
import gnuradio.gr.gr_threading as _threading
import numpy
#generate 1s counts array
_1s_counts = [sum([1&(i>>j) for j in range(8)]) for i in range(2**8)]
class input_watcher(_threading.Thread):
"""
Read samples from the message queue and hand them to the callback.
"""
def __init__(self, msgq, callback):
self._msgq = msgq
self._callback = callback
_threading.Thread.__init__(self)
self.setDaemon(1)
self.keep_running = True
self.start()
def run(self):
r = ''
while True:
msg = self._msgq.delete_head()
itemsize = int(msg.arg1())
nitems = int(msg.arg2())
s = r + msg.to_string()
i = (nitems-nitems%2)*itemsize
r = s[i:]
s = s[:i]
samples = numpy.fromstring(s, numpy.int8)
self._callback(samples)
class error_rate(gr.hier_block2):
"""
Sample the incoming data streams (byte) and calculate the bit or symbol error rate.
Write the running rate to the output data stream (float).
"""
def __init__(self, type='BER', win_size=default_win_size, bits_per_symbol=2):
"""
Error rate constructor.
Args:
type: a string 'BER' or 'SER'
win_size: the number of samples to calculate over
bits_per_symbol: the number of information bits per symbol (BER only)
"""
#init
gr.hier_block2.__init__(
self, 'error_rate',
gr.io_signature(2, 2, gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_float),
)
assert type in ('BER', 'SER')
self._max_samples = win_size
self._bits_per_symbol = bits_per_symbol
#setup message queue
msg_source = blocks.message_source(gr.sizeof_float, 1)
self._msgq_source = msg_source.msgq()
msgq_sink = gr.msg_queue(2)
msg_sink = blocks.message_sink(gr.sizeof_char, msgq_sink, False) #False -> blocking
inter = blocks.interleave(gr.sizeof_char)
#start thread
self._num_errs = 0
self._err_index = 0
self._num_samps = 0
self._err_array = numpy.zeros(self._max_samples, numpy.int8)
if type == 'BER':
input_watcher(msgq_sink, self._handler_ber)
elif type == 'SER':
input_watcher(msgq_sink, self._handler_ser)
#connect
self.connect(msg_source, self)
self.connect((self, 0), (inter, 0))
self.connect((self, 1), (inter, 1))
self.connect(inter, msg_sink)
def _handler_ber(self, samples):
num = len(samples)/2
arr = numpy.zeros(num, numpy.float32)
for i in range(num):
old_err = self._err_array[self._err_index]
#record error
self._err_array[self._err_index] = _1s_counts[samples[i*2] ^ samples[i*2 + 1]]
self._num_errs = self._num_errs + self._err_array[self._err_index] - old_err
#increment index
self._err_index = (self._err_index + 1)%self._max_samples
self._num_samps = min(self._num_samps + 1, self._max_samples)
#write sample
arr[i] = float(self._num_errs)/float(self._num_samps*self._bits_per_symbol)
#write message
msg = gr.message_from_string(arr.tostring(), 0, gr.sizeof_float, num)
self._msgq_source.insert_tail(msg)
def _handler_ser(self, samples):
num = len(samples)/2
arr = numpy.zeros(num, numpy.float32)
for i in range(num):
old_err = self._err_array[self._err_index]
#record error
ref = samples[i*2]
res = samples[i*2 + 1]
if ref == res:
self._err_array[self._err_index] = 0
else:
self._err_array[self._err_index] = 1
#update number of errors
self._num_errs = self._num_errs + self._err_array[self._err_index] - old_err
#increment index
self._err_index = (self._err_index + 1)%self._max_samples
self._num_samps = min(self._num_samps + 1, self._max_samples)
#write sample
arr[i] = float(self._num_errs)/float(self._num_samps)
#write message
msg = gr.message_from_string(arr.tostring(), 0, gr.sizeof_float, num)
self._msgq_source.insert_tail(msg)
gnuradio-3.7.2.1/grc/grc_gnuradio/blks2/__init__.py 0000664 0001750 0001750 00000002133 12233246672 021676 0 ustar jcorgan jcorgan # Copyright 2008-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.
#
from selector import selector, valve
from packet import options, packet_encoder, packet_decoder, \
packet_mod_b, packet_mod_s, packet_mod_i, packet_mod_f, packet_mod_c, \
packet_demod_b, packet_demod_s, packet_demod_i, packet_demod_f, packet_demod_c
from error_rate import error_rate
from tcp import tcp_source, tcp_sink
gnuradio-3.7.2.1/grc/grc_gnuradio/blks2/tcp.py 0000664 0001750 0001750 00000004450 12233246672 020731 0 ustar jcorgan jcorgan #
# Copyright 2009 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 gnuradio import gr, blocks
import socket
import os
def _get_sock_fd(addr, port, server):
"""
Get the file descriptor for the socket.
As a client, block on connect, dup the socket descriptor.
As a server, block on accept, dup the client descriptor.
Args:
addr: the ip address string
port: the tcp port number
server: true for server mode, false for client mode
Returns:
the file descriptor number
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if server:
sock.bind((addr, port))
sock.listen(1)
clientsock, address = sock.accept()
return os.dup(clientsock.fileno())
else:
sock.connect((addr, port))
return os.dup(sock.fileno())
class tcp_source(gr.hier_block2):
def __init__(self, itemsize, addr, port, server=True):
#init hier block
gr.hier_block2.__init__(
self, 'tcp_source',
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, itemsize),
)
fd = _get_sock_fd(addr, port, server)
self.connect(blocks.file_descriptor_source(itemsize, fd), self)
class tcp_sink(gr.hier_block2):
def __init__(self, itemsize, addr, port, server=False):
#init hier block
gr.hier_block2.__init__(
self, 'tcp_sink',
gr.io_signature(1, 1, itemsize),
gr.io_signature(0, 0, 0),
)
fd = _get_sock_fd(addr, port, server)
self.connect(self, blocks.file_descriptor_sink(itemsize, fd))
gnuradio-3.7.2.1/grc/grc_gnuradio/README 0000644 0001750 0001750 00000001061 11700377701 017421 0 ustar jcorgan jcorgan This is the grc_gnuradio module.
It contains supplemental python modules that grc uses at runtime.
The supplemental modules are meant to mimic modules in gnuradio.
These will be phased-out as new functionaility is merged into gnuradio.
The blk2s module wraps many blocks in blks2 and gives them streaming outputs.
Will be phased-out by new message passing implementations.
Other blks2 blocks will hopefully make their way into blks2impl.
The wxgui module contains a top_block + wxgui frame.
Will be phased-out by gui.py in wxgui and a new top block template.
gnuradio-3.7.2.1/grc/grc_gnuradio/__init__.py 0000644 0001750 0001750 00000000001 11700377701 020643 0 ustar jcorgan jcorgan
gnuradio-3.7.2.1/grc/__init__.py 0000644 0001750 0001750 00000000000 11700377701 016177 0 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/cpp/ 0000755 0001750 0001750 00000000000 11700377701 014662 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/cpp/README 0000644 0001750 0001750 00000000312 11700377701 015536 0 ustar jcorgan jcorgan GRC could be used to generate c++ based flowgraphs:
* A few base and gui classes would be overridden.
* Block info could be extracted from the doxygen xml.
* New flowgraph templates would be designed.
gnuradio-3.7.2.1/grc/grc.conf.in 0000644 0001750 0001750 00000000327 11700377701 016131 0 ustar jcorgan jcorgan # This file contains system wide configuration data for GNU Radio.
# You may override any setting on a per-user basis by editing
# ~/.gnuradio/config.conf
[grc]
global_blocks_path = @blocksdir@
local_blocks_path =
gnuradio-3.7.2.1/grc/examples/ 0000755 0001750 0001750 00000000000 11744612271 015720 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/examples/CMakeLists.txt 0000644 0001750 0001750 00000002160 11744612271 020457 0 ustar jcorgan jcorgan # 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.
# SIMPLE
install(
FILES
simple/variable_config.grc
DESTINATION ${GR_PKG_DATA_DIR}/examples/grc/simple
COMPONENT "grc"
)
# XMLRPC
install(
FILES
xmlrpc/readme.txt
xmlrpc/xmlrpc_client.grc
xmlrpc/xmlrpc_client_script.py
xmlrpc/xmlrpc_server.grc
DESTINATION ${GR_PKG_DATA_DIR}/examples/grc/xmlrpc
COMPONENT "grc"
)
gnuradio-3.7.2.1/grc/examples/simple/ 0000755 0001750 0001750 00000000000 12207440367 017211 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/examples/simple/variable_config.grc 0000664 0001750 0001750 00000016161 12207440367 023027 0 ustar jcorgan jcorgan
Sat Nov 10 15:20:12 2012optionsidvariable_config_demo_enabledTruetitleVariable Config Block DemonstrationauthorExampledescriptionSave/Load freq from a config file.window_size1280, 1024generate_optionswx_guicategoryCustomrun_optionspromptrunTruemax_nouts0realtime_scheduling_coordinate(10, 10)_rotation0variableidsamp_rate_enabledTruevalue32000_coordinate(10, 170)_rotation0variable_configidfreq_init_enabledTruevalue1000typerealconfig_fileconfig.confsectionmainoptionfreqwritebackfreq_coordinate(255, 17)_rotation0variable_slideridfreq_enabledTruelabelFrequency (Hz)valuefreq_initmin-samp_rate/2maxsamp_rate/2num_steps100stylewx.SL_HORIZONTALconververfloat_convertergrid_posnotebook_coordinate(429, 24)_rotation0wxgui_fftsink2idwxgui_fftsink2_0_enabledTruetypecomplextitleFFT Plotsamp_ratesamp_ratebaseband_freq0y_per_div10y_divs10ref_level50ref_scale2.0fft_size1024fft_rate30peak_holdFalseaverageFalseavg_alpha0winNonewin_sizegrid_posnotebookfreqvarNone_coordinate(671, 233)_rotation0blocks_throttleidblocks_throttle_0_enabledTruetypecomplexsamples_per_secondsamp_ratevlen1_coordinate(392, 233)_rotation0analog_sig_source_xidanalog_sig_source_x_0_enabledTruetypecomplexsamp_ratesamp_ratewaveformanalog.GR_COS_WAVEfreqfreqamp1offset0_coordinate(173, 201)_rotation0blocks_throttle_0wxgui_fftsink2_000analog_sig_source_x_0blocks_throttle_000
gnuradio-3.7.2.1/grc/examples/xmlrpc/ 0000755 0001750 0001750 00000000000 12207702530 017216 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/examples/xmlrpc/xmlrpc_server.grc 0000664 0001750 0001750 00000021125 12207440367 022620 0 ustar jcorgan jcorgan
Sat Nov 10 15:20:55 2012optionsidserver_block_enabledTruetitleXMLRPC ServerauthorExampledescriptionexample flow graphwindow_size1280, 1024generate_optionswx_guicategoryCustomrun_optionspromptrunTruemax_nouts0realtime_scheduling_coordinate(10, 10)_rotation0variableidoffset_enabledTruevalue0_coordinate(12, 390)_rotation0xmlrpc_serveridxmlrpc_server_enabledTrueaddrlocalhostport1234_coordinate(395, 240)_rotation0wxgui_scopesink2idwxgui_scopesink2_enabledTruetypefloattitleScope Plotsamp_ratesamp_ratev_scale0v_offset0t_scale.001ac_coupleFalsexy_modeFalsenum_inputs1win_sizegrid_pos0, 0, 2, 4notebooktrig_modewxgui.TRIG_MODE_AUTOy_axis_labelCounts_coordinate(623, 28)_rotation0wxgui_fftsink2idwxgui_fftsink2_enabledTruetypefloattitleFFT Plotsamp_ratesamp_ratebaseband_freq0y_per_div10y_divs8ref_level50ref_scale2.0fft_size512fft_rate15peak_holdFalseaverageFalseavg_alpha0winNonewin_sizegrid_pos2, 0, 2, 4notebookfreqvarNone_coordinate(630, 233)_rotation0variableidsamp_rate_enabledTruevalue32000_coordinate(11, 160)_rotation0variableidfreq_enabledTruevalue1000_coordinate(11, 237)_rotation0variableidampl_enabledTruevalue1_coordinate(13, 315)_rotation0blocks_throttleidblocks_throttle_enabledTruetypefloatsamples_per_secondsamp_ratevlen1_coordinate(386, 93)_rotation0analog_sig_source_xidanalog_sig_source_x_0_enabledTruetypefloatsamp_ratesamp_ratewaveformanalog.GR_COS_WAVEfreqfreqampamploffsetoffset_coordinate(164, 154)_rotation0blocks_throttlewxgui_scopesink200blocks_throttlewxgui_fftsink200analog_sig_source_x_0blocks_throttle00
gnuradio-3.7.2.1/grc/examples/xmlrpc/xmlrpc_client_script.py 0000664 0001750 0001750 00000000760 12207702530 024024 0 ustar jcorgan jcorgan #!/usr/bin/env python
import time
import random
import xmlrpclib
#create server object
s = xmlrpclib.Server("http://localhost:1234")
#randomly change parameters of the sinusoid
for i in range(10):
#generate random values
new_freq = random.uniform(0, 5000)
new_ampl = random.uniform(0, 2)
new_offset = random.uniform(-1, 1)
#set new values
time.sleep(1)
s.set_freq(new_freq)
time.sleep(1)
s.set_ampl(new_ampl)
time.sleep(1)
s.set_offset(new_offset)
gnuradio-3.7.2.1/grc/examples/xmlrpc/xmlrpc_client.grc 0000644 0001750 0001750 00000013762 11744612271 022576 0 ustar jcorgan jcorgan
Thu Jul 24 14:27:44 2008optionsidclient_block_enabledTruetitleXMLRPC ClientauthorExampledescriptionexample flow graphwindow_size1280, 1024generate_optionswx_guicategoryCustom_coordinate(10, 10)_rotation0xmlrpc_clientidxmlrpc_client0_enabledTrueaddrlocalhostport1234callbackset_amplvariableampl_coordinate(409, 35)_rotation0xmlrpc_clientidxmlrpc_client_enabledTrueaddrlocalhostport1234callbackset_freqvariablefreq_coordinate(222, 34)_rotation0variable_slideridfreq_enabledTruelabelFrequency (Hz)value1000min0max5000num_steps100slider_typehorizontalgrid_pos0, 0, 1, 2_coordinate(207, 162)_rotation0variable_slideridampl_enabledTruelabelAmplitudevalue1min0max2num_steps100slider_typehorizontalgrid_pos1, 0, 1, 2_coordinate(397, 167)_rotation0variable_chooseridoffset_enabledTruelabelOffsetvalue_index1choices[-1, 0, 1]labels["neg", "zero", "pos"]chooser_typeradio_buttons_horizontalgrid_pos2, 0, 1, 2_coordinate(596, 177)_rotation0xmlrpc_clientidxmlrpc_client1_enabledTrueaddrlocalhostport1234callbackset_offsetvariableoffset*ampl_coordinate(608, 39)_rotation0variableidsamp_rate_enabledTruevalue32000_coordinate(13, 172)_rotation0 gnuradio-3.7.2.1/grc/examples/xmlrpc/readme.txt 0000644 0001750 0001750 00000001572 11744612271 021230 0 ustar jcorgan jcorgan ##################################################
# XMLRPC example
##################################################
XMLRPC allows software to make remote function calls over http.
In the case of GRC, one can use XMLRPC to modify variables in a running flow graph.
See http://www.xmlrpc.com/
--- Server Example ---
Place an "XMLRPC Server" block inside of any flow graph.
The server will provide set functions for every variable in the flow graph.
If a variable is called "freq", the server will provide a function set_freq(new_freq).
Run the server example and experiment with the example client script.
-- Client Example --
The "XMLRPC Client" block will give a variable control over one remove function.
In the example client, there is one client block and gui control per variable.
This technique can be used to remotely control a flow graph, perhaps running on a non-gui machine.
gnuradio-3.7.2.1/grc/blocks/ 0000755 0001750 0001750 00000000000 12237515112 015351 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/blocks/CMakeLists.txt 0000664 0001750 0001750 00000001674 12207440367 020131 0 ustar jcorgan jcorgan # 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.
########################################################################
file(GLOB xml_files "*.xml")
install(FILES ${xml_files} DESTINATION ${GRC_BLOCKS_DIR} COMPONENT "grc")
gnuradio-3.7.2.1/grc/blocks/block_tree.xml 0000664 0001750 0001750 00000001744 12207440367 020222 0 ustar jcorgan jcorgan
Miscpad_sourcepad_sinkvirtual_sourcevirtual_sinknoteimportblks2_selectorblks2_valveblks2_error_ratexmlrpc_serverxmlrpc_clientNetworking Toolsblks2_tcp_sourceblks2_tcp_sinkPacket Operatorsblks2_packet_decoderblks2_packet_encoderVariablesvariablevariable_configvariable_function_probeparameter
gnuradio-3.7.2.1/grc/blocks/blks2_packet_decoder.xml 0000644 0001750 0001750 00000003014 11700377701 022126 0 ustar jcorgan jcorgan
Packet Decoderblks2_packet_decoderfrom grc_gnuradio import blks2 as grc_blks2grc_blks2.packet_demod_$(type.fcn)(grc_blks2.packet_decoder(
access_code=$access_code,
threshold=$threshold,
callback=lambda ok, payload: self.$(id).recv_pkt(ok, payload),
),
)Output TypetypefloatenumAccess Codeaccess_codestringThresholdthreshold-1intinbyteout$type
Packet decoder block, for use with the gnuradio demodulator blocks: gmsk, psk, qam.
Access Code: string of 1's and 0's, leave blank for automatic.
Threshold: -1 for automatic.
gnuradio-3.7.2.1/grc/blocks/import.xml 0000664 0001750 0001750 00000001022 12207440367 017410 0 ustar jcorgan jcorgan
Importimport$importImportimportimport
Import additional python modules into the namespace.
Examples:
from gnuradio.filter import firdes
import math,cmath
from math import pi
gnuradio-3.7.2.1/grc/blocks/note.xml 0000644 0001750 0001750 00000000502 11700377701 017041 0 ustar jcorgan jcorgan
NotenoteNotenotestring
gnuradio-3.7.2.1/grc/blocks/pad_sink.xml 0000664 0001750 0001750 00000004010 12207702530 017657 0 ustar jcorgan jcorgan
Pad Sinkpad_sink#if str($type) == "message"
None;self.message_port_register_hier_in($label)
#end ifLabellabeloutstringInput TypetypeenumVec Lengthvlen1intNum Streamsnum_streams1intOptionaloptionalFalseboolpart$vlen > 0$num_streams > 0in$type$vlen$num_streams
The inputs of this block will become the outputs to this flow graph when it is instantiated as a hierarchical block.
Pad sink will be ordered alphabetically by their ids. The first pad sink will have an index of 0.
gnuradio-3.7.2.1/grc/blocks/parameter.xml 0000644 0001750 0001750 00000004164 11700377701 020064 0 ustar jcorgan jcorgan
Parameterparameterself.$(id) = $(id)$valueLabellabelstring#if $label() then 'none' else 'part'#Valuevalue0$type.typeTypetypeenum#if $type() then 'none' else 'part'#Short IDshort_idstring#if not $type()
all#slurp
#elif $short_id()
none#slurp
#else
part#slurp
#end iflen($short_id) in (0, 1)$short_id == '' or $(short_id).isalpha()
This block represents a parameter to the flow graph. \
A parameter can be used to pass command line arguments into a top block. \
Or, parameters can pass arguments into an instantiated hierarchical block.
The paramater value cannot depend on any variables.
Leave the label blank to use the parameter id as the label.
When type is not None, this parameter also becomes a command line option of the form:
-[short_id] --[id] [value]
The Short ID field may be left blank.
gnuradio-3.7.2.1/grc/blocks/bus_structure_source.xml 0000664 0001750 0001750 00000000543 12207702530 022367 0 ustar jcorgan jcorgan
Bus Source Structurebus_structure_sourceNoneStructurestructraw
gnuradio-3.7.2.1/grc/blocks/blks2_valve.xml 0000644 0001750 0001750 00000002742 11700377701 020316 0 ustar jcorgan jcorgan
Valveblks2_valvefrom grc_gnuradio import blks2 as grc_blks2grc_blks2.valve(item_size=$type.size*$vlen, open=bool($open))set_open(bool($open))TypetypeenumOpenopen0rawVec Lengthvlen1int$vlen > 0in$type$vlen$num_inputsout$type$vlen$num_outputs
Connect output to input when valve is closed (not open).
gnuradio-3.7.2.1/grc/blocks/variable_function_probe.xml 0000644 0001750 0001750 00000003760 11700377701 022766 0 ustar jcorgan jcorgan
Function Probevariable_function_probeimport timeimport threadingself.$(id) = $(id) = $value#slurp
def _$(id)_probe():
while True:
val = self.$(block_id()).$(function_name())($(function_args()))
try: self.set_$(id)(val)
except AttributeError, e: pass
time.sleep(1.0/($poll_rate))
_$(id)_thread = threading.Thread(target=_$(id)_probe)
_$(id)_thread.daemon = True
_$(id)_thread.start()self.set_$(id)($value)Valuevalue0rawBlock IDblock_idmy_block_0stringFunction Namefunction_nameget_numberstringFunction Argsfunction_argsstring#if $function_args() then 'none' else 'part'#Poll Rate (Hz)poll_rate10real
Periodically probe a function and set its value to this variable.
Set the values for block ID, function name, and function args appropriately: \
Block ID should be the ID of another block in this flow graph. \
Function name should be the name of a class method on that block. \
Function args are the parameters passed into that function. \
For a function with no arguments, leave function args blank. \
When passing a string for the function arguments, quote the string literal: '"arg"'.
The values will used literally, and generated into the following form:
self.block_id.function_name(function_args)
To poll a stream for a level, use this with the probe signal block.
gnuradio-3.7.2.1/grc/blocks/bus_structure_sink.xml 0000664 0001750 0001750 00000000537 12207702530 022036 0 ustar jcorgan jcorgan
Bus Sink Structurebus_structure_sinkNoneStructurestructraw
gnuradio-3.7.2.1/grc/blocks/blks2_packet_encoder.xml 0000664 0001750 0001750 00000004447 12237515112 022151 0 ustar jcorgan jcorgan
Packet Encoderblks2_packet_encoderfrom grc_gnuradio import blks2 as grc_blks2grc_blks2.packet_mod_$(type.fcn)(grc_blks2.packet_encoder(
samples_per_symbol=$samples_per_symbol,
bits_per_symbol=$bits_per_symbol,
preamble=$preamble,
access_code=$access_code,
pad_for_usrp=$pad_for_usrp,
),
payload_length=$payload_length,
)Input TypetypefloatenumSamples/Symbolsamples_per_symbolintBits/Symbolbits_per_symbolintPreamblepreamblestringAccess Codeaccess_codestringPad for USRPpad_for_usrpenumPayload Lengthpayload_length0intin$typeoutbyte
Packet encoder block, for use with the gnuradio modulator blocks: gmsk, dpsk, qam.
Preamble: string of 1's and 0's, leave blank for automatic.
Access Code: string of 1's and 0's, leave blank for automatic.
Payload Length: 0 for automatic.
Bits/Symbol should be set accordingly:
gmsk -> 1
dbpsk -> 1
dqpsk -> 2
d8psk -> 3
qam8 -> 3
qam16 -> 4
qam64 -> 6
qam256 -> 8
gnuradio-3.7.2.1/grc/blocks/xmlrpc_server.xml 0000644 0001750 0001750 00000002155 11700377701 020775 0 ustar jcorgan jcorgan
XMLRPC Serverxmlrpc_serverimport SimpleXMLRPCServerimport threadingSimpleXMLRPCServer.SimpleXMLRPCServer(($addr, $port), allow_none=True)
self.$(id).register_instance(self)
threading.Thread(target=self.$(id).serve_forever).start()AddressaddrlocalhoststringPortport8080int
This block will start an XMLRPC server. \
The server provides access to the run, start, stop, wait functions of the flow graph. \
The server also provides access to the variable callbacks in the flow graph. \
Ex: If the variable is called freq, the function provided by the server will be called set_freq(new_freq).
Example client in python:
import xmlrpclib
s = xmlrpclib.Server('http://localhost:8080')
s.set_freq(5000)
gnuradio-3.7.2.1/grc/blocks/blks2_selector.xml 0000644 0001750 0001750 00000004023 11700377701 021013 0 ustar jcorgan jcorgan
Selectorblks2_selectorfrom grc_gnuradio import blks2 as grc_blks2grc_blks2.selector(
item_size=$type.size*$vlen,
num_inputs=$num_inputs,
num_outputs=$num_outputs,
input_index=$input_index,
output_index=$output_index,
)set_input_index(int($input_index))set_output_index(int($output_index))TypetypeenumNum Inputsnum_inputs2intNum Outputsnum_outputs2intInput Indexinput_index0intOutput Indexoutput_index0intVec Lengthvlen1int$vlen > 0in$type$vlen$num_inputsout$type$vlen$num_outputs
Connect the sink at input index to the source at output index. Leave all other ports disconnected.
gnuradio-3.7.2.1/grc/blocks/blks2_tcp_sink.xml 0000644 0001750 0001750 00000003435 11700377701 021013 0 ustar jcorgan jcorgan
TCP Sinkblks2_tcp_sinkfrom grc_gnuradio import blks2 as grc_blks2grc_blks2.tcp_sink(
itemsize=$type.size*$vlen,
addr=$addr,
port=$port,
server=$server,
)Input TypetypeenumAddressaddr127.0.0.1stringPortport0intModeserverFalseenumVec Lengthvlen1int$vlen > 0in$type$vlen
In client mode, we attempt to connect to a server at the given address and port. \
In server mode, we bind a socket to the given address and port and accept the first client.
gnuradio-3.7.2.1/grc/blocks/blks2_tcp_source.xml 0000644 0001750 0001750 00000003451 11700377701 021345 0 ustar jcorgan jcorgan
TCP Sourceblks2_tcp_sourcefrom grc_gnuradio import blks2 as grc_blks2grc_blks2.tcp_source(
itemsize=$type.size*$vlen,
addr=$addr,
port=$port,
server=$server,
)Output TypetypeenumAddressaddr127.0.0.1stringPortport0intModeserverTrueenumVec Lengthvlen1int$vlen > 0out$type$vlen
In client mode, we attempt to connect to a server at the given address and port. \
In server mode, we bind a socket to the given address and port and accept the first client.
gnuradio-3.7.2.1/grc/blocks/variable_config.xml 0000644 0001750 0001750 00000004222 11700377701 021211 0 ustar jcorgan jcorgan
Variable Configvariable_configimport ConfigParserself._$(id)_config = ConfigParser.ConfigParser()
self._$(id)_config.read($config_file)
try: $(id) = self._$(id)_config.$(type.get)($section, $option)
except: $(id) = $value
self.$(id) = $(id)self.set_$(id)($value)self._$(id)_config = ConfigParser.ConfigParser()
self._$(id)_config.read($config_file)
if not self._$(id)_config.has_section($section):
self._$(id)_config.add_section($section)
self._$(id)_config.set($section, $option, str($writeback))
self._$(id)_config.write(open($config_file, 'w'))Default Valuevalue0$typeTypetyperealenumConfig Fileconfig_filedefaultfile_openSectionsectionmainstringOptionoptionkeystringWriteBackwritebackNoneraw
This block represents a variable that can be read from a config file.
To save the value back into the config file: \
enter the name of another variable into the writeback param. \
When the other variable is changed at runtime, the config file will be re-written.
gnuradio-3.7.2.1/grc/blocks/options.xml 0000664 0001750 0001750 00000011072 12207440367 017577 0 ustar jcorgan jcorgan
Optionsoptionsfrom gnuradio import grfrom gnuradio.filter import firdes#if $generate_options() == 'wx_gui'
from grc_gnuradio import wxgui as grc_wxgui
import wx
#end if
#if $generate_options() == 'qt_gui'
from PyQt4 import Qt
import sys
#end if
#if $generate_options() != 'hb'
from optparse import OptionParser
from gnuradio.eng_option import eng_option
from gnuradio import eng_notation
#end ifif $run: self.start()
else: self.stop(); self.wait()Titletitlestring#if $title() then 'none' else 'part'#Authorauthorstring#if $author() then 'none' else 'part'#Descriptiondescriptionstring#if $description() then 'none' else 'part'#Window Sizewindow_size1280, 1024int_vectorpartGenerate Optionsgenerate_optionswx_guienumCategorycategoryCustomstring#if $generate_options() == 'hb' then 'none' else 'all'#Run Optionsrun_optionspromptenum#if $generate_options() == 'no_gui' then 'none' else 'all'#RunrunTruebool
#if $generate_options() in ('qt_gui', 'wx_gui')
#if $run()
part
#else
none
#end if
#else
all
#end if
Max Number of Outputmax_nouts0int#if $generate_options() == 'hb'
all#slurp
#elif $max_nouts()
none#slurp
#else
part#slurp
#end ifRealtime Schedulingrealtime_schedulingenum#if $generate_options() == 'hb'
all#slurp
#elif $realtime_scheduling()
none#slurp
#else
part#slurp
#end iflen($window_size) == 2300 <= $(window_size)[0] <= 4096300 <= $(window_size)[1] <= 4096
The options block sets special parameters for the flow graph. \
Only one option block is allowed per flow graph.
Title, author, and description parameters are for identification purposes.
The window size controls the dimensions of the flow graph editor. \
The window size (width, height) must be between (300, 300) and (4096, 4096).
The generate options controls the type of code generated. \
Non-graphical flow graphs should avoid using graphical sinks or graphical variable controls.
In a graphical application, \
run can be controlled by a variable to start and stop the flowgraph at runtime.
The id of this block determines the name of the generated file and the name of the class. \
For example, an id of my_block will generate the file my_block.py and class my_block(gr....
The category parameter determines the placement of the block in the block selection window. \
The category only applies when creating hier blocks. \
To put hier blocks into the root category, enter / for the category.
The Max Number of Output is the maximum number of output items allowed for any block \
in the flowgraph; to disable this set the max_nouts equal to 0.\
Use this to adjust the maximum latency a flowgraph can exhibit.
gnuradio-3.7.2.1/grc/blocks/virtual_source.xml 0000644 0001750 0001750 00000000627 11700377701 021152 0 ustar jcorgan jcorgan
Virtual Sourcevirtual_sourceStream IDstream_idstream_idout
gnuradio-3.7.2.1/grc/blocks/virtual_sink.xml 0000644 0001750 0001750 00000000614 11700377701 020612 0 ustar jcorgan jcorgan
Virtual Sinkvirtual_sinkStream IDstream_idstream_idin
gnuradio-3.7.2.1/grc/blocks/variable.xml 0000644 0001750 0001750 00000001071 11700377701 017663 0 ustar jcorgan jcorgan
Variablevariableself.$(id) = $(id) = $valueself.set_$(id)($value)Valuevalue0raw
This block maps a value to a unique variable. \
This variable block has no graphical representation.
gnuradio-3.7.2.1/grc/blocks/pad_source.xml 0000664 0001750 0001750 00000004033 12207702530 020220 0 ustar jcorgan jcorgan
Pad Sourcepad_source#if str($type) == "message"
None;self.message_port_register_hier_out($label)
#end ifLabellabelinstringOutput TypetypeenumVec Lengthvlen1intNum Streamsnum_streams1intOptionaloptionalFalseboolpart$vlen > 0$num_streams > 0out$type$vlen$num_streams
The outputs of this block will become the inputs to this flow graph when it is instantiated as a hierarchical block.
Pad sources will be ordered alphabetically by their ids. The first pad source will have an index of 0.
gnuradio-3.7.2.1/grc/blocks/bus_sink.xml 0000664 0001750 0001750 00000000754 12207702530 017717 0 ustar jcorgan jcorgan
Bus Sinkbus_sink$yesno.yesnoOn/Offyesnoenum
gnuradio-3.7.2.1/grc/blocks/xmlrpc_client.xml 0000644 0001750 0001750 00000002064 11700377701 020744 0 ustar jcorgan jcorgan
XMLRPC Clientxmlrpc_clientimport xmlrpclibxmlrpclib.Server('http://$(addr()):$(port)')$(callback())($variable)AddressaddrlocalhoststringPortport8080intCallbackcallbackset_stringVariablevariableraw
This block will create an XMLRPC client. \
The client will execute the callback on the server when the variable is changed. \
The callback should be a the name of a function registered on the server. \
The variable should be an expression containing a the name of a variable in flow graph.
gnuradio-3.7.2.1/grc/blocks/bus_source.xml 0000664 0001750 0001750 00000000760 12207702530 020250 0 ustar jcorgan jcorgan
Bus Sourcebus_source$yesno.yesnoOn/Offyesnoenum
gnuradio-3.7.2.1/grc/blocks/blks2_error_rate.xml 0000644 0001750 0001750 00000003425 11700377701 021344 0 ustar jcorgan jcorgan
Error Rateblks2_error_ratefrom grc_gnuradio import blks2 as grc_blks2grc_blks2.error_rate(
type=$type,
win_size=$win_size,
bits_per_symbol=$bits_per_symbol,
)TypetypeenumWindow Sizewin_size1000intBits per Symbolbits_per_symbol2int$type.hide_bpsrefbyteinbyteoutfloat
Calculate the bit error rate (BER) or the symbol error rate (SER) over a number of samples given by the window size. \
The actual window size will start at size one and grow to the full window size as new samples arrive. \
Once the window has reached full size, old samples are shifted out of the window and new samples shfited in.
The error block compares the input byte stream to the reference byte stream. \
For example, the reference byte stream could be the input to a modulator, \
and the input byte stream could be the output of a modulator.
Each byte in the incoming stream represents one symbol. \
The bits per symbol parameter is only useful for calculating the BER.
gnuradio-3.7.2.1/grc/gui/ 0000755 0001750 0001750 00000000000 12245466767 014704 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/grc/gui/Platform.py 0000664 0001750 0001750 00000001571 12207702530 017023 0 ustar jcorgan jcorgan """
Copyright 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Element import Element
class Platform(Element):
def __init__(self): Element.__init__(self)
gnuradio-3.7.2.1/grc/gui/Port.py 0000664 0001750 0001750 00000017760 12207702530 016172 0 ustar jcorgan jcorgan """
Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Element import Element
from Constants import \
PORT_SEPARATION, CONNECTOR_EXTENSION_MINIMAL, \
CONNECTOR_EXTENSION_INCREMENT, \
PORT_LABEL_PADDING, PORT_MIN_WIDTH
import Utils
import Colors
import pygtk
pygtk.require('2.0')
import gtk
PORT_MARKUP_TMPL="""\
$encode($port.get_name())"""
class Port(Element):
"""The graphical port."""
def __init__(self):
"""
Port contructor.
Create list of connector coordinates.
"""
Element.__init__(self)
self.connector_coordinates = dict()
def create_shapes(self):
"""Create new areas and labels for the port."""
Element.create_shapes(self)
#get current rotation
rotation = self.get_rotation()
#get all sibling ports
if self.is_source(): ports = self.get_parent().get_sources_gui()
elif self.is_sink(): ports = self.get_parent().get_sinks_gui()
#get the max width
self.W = max([port.W for port in ports] + [PORT_MIN_WIDTH])
#get a numeric index for this port relative to its sibling ports
try:
index = ports.index(self)
except:
if hasattr(self, '_connector_length'):
del self._connector_length;
return
length = len(ports)
#reverse the order of ports for these rotations
if rotation in (180, 270): index = length-index-1
offset = (self.get_parent().H - length*self.H - (length-1)*PORT_SEPARATION)/2
#create areas and connector coordinates
if (self.is_sink() and rotation == 0) or (self.is_source() and rotation == 180):
x = -1*self.W
y = (PORT_SEPARATION+self.H)*index+offset
self.add_area((x, y), (self.W, self.H))
self._connector_coordinate = (x-1, y+self.H/2)
elif (self.is_source() and rotation == 0) or (self.is_sink() and rotation == 180):
x = self.get_parent().W
y = (PORT_SEPARATION+self.H)*index+offset
self.add_area((x, y), (self.W, self.H))
self._connector_coordinate = (x+1+self.W, y+self.H/2)
elif (self.is_source() and rotation == 90) or (self.is_sink() and rotation == 270):
y = -1*self.W
x = (PORT_SEPARATION+self.H)*index+offset
self.add_area((x, y), (self.H, self.W))
self._connector_coordinate = (x+self.H/2, y-1)
elif (self.is_sink() and rotation == 90) or (self.is_source() and rotation == 270):
y = self.get_parent().W
x = (PORT_SEPARATION+self.H)*index+offset
self.add_area((x, y), (self.H, self.W))
self._connector_coordinate = (x+self.H/2, y+1+self.W)
#the connector length
self._connector_length = CONNECTOR_EXTENSION_MINIMAL + CONNECTOR_EXTENSION_INCREMENT*index
def modify_height(self, start_height):
type_dict = {'bus':(lambda a: a * 3)};
if self.get_type() in type_dict:
return type_dict[self.get_type()](start_height);
else:
return start_height;
def create_labels(self):
"""Create the labels for the socket."""
Element.create_labels(self)
self._bg_color = Colors.get_color(self.get_color())
#create the layout
layout = gtk.DrawingArea().create_pango_layout('')
layout.set_markup(Utils.parse_template(PORT_MARKUP_TMPL, port=self))
self.w, self.h = layout.get_pixel_size()
self.W, self.H = 2*PORT_LABEL_PADDING+self.w, 2*PORT_LABEL_PADDING+self.h
self.H = self.modify_height(self.H);
#create the pixmap
pixmap = self.get_parent().get_parent().new_pixmap(self.w, self.h)
gc = pixmap.new_gc()
gc.set_foreground(self._bg_color)
pixmap.draw_rectangle(gc, True, 0, 0, self.w, self.h)
pixmap.draw_layout(gc, 0, 0, layout)
#create vertical and horizontal pixmaps
self.horizontal_label = pixmap
if self.is_vertical():
self.vertical_label = self.get_parent().get_parent().new_pixmap(self.h, self.w)
Utils.rotate_pixmap(gc, self.horizontal_label, self.vertical_label)
def draw(self, gc, window):
"""
Draw the socket with a label.
Args:
gc: the graphics context
window: the gtk window to draw on
"""
Element.draw(
self, gc, window, bg_color=self._bg_color,
border_color=self.is_highlighted() and Colors.HIGHLIGHT_COLOR or Colors.BORDER_COLOR,
)
X,Y = self.get_coordinate()
(x,y),(w,h) = self._areas_list[0] #use the first area's sizes to place the labels
if self.is_horizontal():
window.draw_drawable(gc, self.horizontal_label, 0, 0, x+X+(self.W-self.w)/2, y+Y+(self.H-self.h)/2, -1, -1)
elif self.is_vertical():
window.draw_drawable(gc, self.vertical_label, 0, 0, x+X+(self.H-self.h)/2, y+Y+(self.W-self.w)/2, -1, -1)
def get_connector_coordinate(self):
"""
Get the coordinate where connections may attach to.
Returns:
the connector coordinate (x, y) tuple
"""
x,y = self._connector_coordinate
X,Y = self.get_coordinate()
return (x+X, y+Y)
def get_connector_direction(self):
"""
Get the direction that the socket points: 0,90,180,270.
This is the rotation degree if the socket is an output or
the rotation degree + 180 if the socket is an input.
Returns:
the direction in degrees
"""
if self.is_source(): return self.get_rotation()
elif self.is_sink(): return (self.get_rotation() + 180)%360
def get_connector_length(self):
"""
Get the length of the connector.
The connector length increases as the port index changes.
Returns:
the length in pixels
"""
return self._connector_length
def get_rotation(self):
"""
Get the parent's rotation rather than self.
Returns:
the parent's rotation
"""
return self.get_parent().get_rotation()
def move(self, delta_coor):
"""
Move the parent rather than self.
Args:
delta_corr: the (delta_x, delta_y) tuple
"""
self.get_parent().move(delta_coor)
def rotate(self, direction):
"""
Rotate the parent rather than self.
Args:
direction: degrees to rotate
"""
self.get_parent().rotate(direction)
def get_coordinate(self):
"""
Get the parent's coordinate rather than self.
Returns:
the parents coordinate
"""
return self.get_parent().get_coordinate()
def set_highlighted(self, highlight):
"""
Set the parent highlight rather than self.
Args:
highlight: true to enable highlighting
"""
self.get_parent().set_highlighted(highlight)
def is_highlighted(self):
"""
Get the parent's is highlight rather than self.
Returns:
the parent's highlighting status
"""
return self.get_parent().is_highlighted()
gnuradio-3.7.2.1/grc/gui/NotebookPage.py 0000664 0001750 0001750 00000014171 12207702530 017614 0 ustar jcorgan jcorgan """
Copyright 2008, 2009, 2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import pygtk
pygtk.require('2.0')
import gtk
import Actions
from StateCache import StateCache
from Constants import MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT
from DrawingArea import DrawingArea
import os
############################################################
## Notebook Page
############################################################
class NotebookPage(gtk.HBox):
"""A page in the notebook."""
def __init__(self, main_window, flow_graph, file_path=''):
"""
Page constructor.
Args:
main_window: main window
file_path: path to a flow graph file
"""
self._flow_graph = flow_graph
self.set_proc(None)
#import the file
self.main_window = main_window
self.set_file_path(file_path)
initial_state = flow_graph.get_parent().parse_flow_graph(file_path)
self.state_cache = StateCache(initial_state)
self.set_saved(True)
#import the data to the flow graph
self.get_flow_graph().import_data(initial_state)
#initialize page gui
gtk.HBox.__init__(self, False, 0)
self.show()
#tab box to hold label and close button
self.tab = gtk.HBox(False, 0)
#setup tab label
self.label = gtk.Label()
self.tab.pack_start(self.label, False)
#setup button image
image = gtk.Image()
image.set_from_stock('gtk-close', gtk.ICON_SIZE_MENU)
#setup image box
image_box = gtk.HBox(False, 0)
image_box.pack_start(image, True, False, 0)
#setup the button
button = gtk.Button()
button.connect("clicked", self._handle_button)
button.set_relief(gtk.RELIEF_NONE)
button.add(image_box)
#button size
w, h = gtk.icon_size_lookup_for_settings(button.get_settings(), gtk.ICON_SIZE_MENU)
button.set_size_request(w+6, h+6)
self.tab.pack_start(button, False)
self.tab.show_all()
#setup scroll window and drawing area
self.scrolled_window = gtk.ScrolledWindow()
self.scrolled_window.set_size_request(MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT)
self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.drawing_area = DrawingArea(self.get_flow_graph())
self.scrolled_window.add_with_viewport(self.get_drawing_area())
self.pack_start(self.scrolled_window)
#inject drawing area into flow graph
self.get_flow_graph().drawing_area = self.get_drawing_area()
self.show_all()
def get_drawing_area(self): return self.drawing_area
def get_generator(self):
"""
Get the generator object for this flow graph.
Returns:
generator
"""
return self.get_flow_graph().get_parent().get_generator()(
self.get_flow_graph(),
self.get_file_path(),
)
def _handle_button(self, button):
"""
The button was clicked.
Make the current page selected, then close.
Args:
the: button
"""
self.main_window.page_to_be_closed = self
Actions.FLOW_GRAPH_CLOSE()
def set_markup(self, markup):
"""
Set the markup in this label.
Args:
markup: the new markup text
"""
self.label.set_markup(markup)
def get_tab(self):
"""
Get the gtk widget for this page's tab.
Returns:
gtk widget
"""
return self.tab
def get_proc(self):
"""
Get the subprocess for the flow graph.
Returns:
the subprocess object
"""
return self.process
def set_proc(self, process):
"""
Set the subprocess object.
Args:
process: the new subprocess
"""
self.process = process
def get_flow_graph(self):
"""
Get the flow graph.
Returns:
the flow graph
"""
return self._flow_graph
def get_read_only(self):
"""
Get the read-only state of the file.
Always false for empty path.
Returns:
true for read-only
"""
if not self.get_file_path(): return False
return os.path.exists(self.get_file_path()) and \
not os.access(self.get_file_path(), os.W_OK)
def get_file_path(self):
"""
Get the file path for the flow graph.
Returns:
the file path or ''
"""
return self.file_path
def set_file_path(self, file_path=''):
"""
Set the file path, '' for no file path.
Args:
file_path: file path string
"""
if file_path: self.file_path = os.path.abspath(file_path)
else: self.file_path = ''
def get_saved(self):
"""
Get the saved status for the flow graph.
Returns:
true if saved
"""
return self.saved
def set_saved(self, saved=True):
"""
Set the saved status.
Args:
saved: boolean status
"""
self.saved = saved
def get_state_cache(self):
"""
Get the state cache for the flow graph.
Returns:
the state cache
"""
return self.state_cache
gnuradio-3.7.2.1/grc/gui/CMakeLists.txt 0000644 0001750 0001750 00000002502 11700377701 017423 0 ustar jcorgan jcorgan # 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.
########################################################################
GR_PYTHON_INSTALL(FILES
Block.py
Colors.py
Constants.py
Connection.py
Element.py
FlowGraph.py
Param.py
Platform.py
Port.py
Utils.py
ActionHandler.py
Actions.py
Bars.py
BlockTreeWindow.py
Dialogs.py
DrawingArea.py
FileDialogs.py
MainWindow.py
Messages.py
NotebookPage.py
PropsDialog.py
Preferences.py
StateCache.py
__init__.py
DESTINATION ${GR_PYTHON_DIR}/gnuradio/grc/gui
COMPONENT "grc"
)
gnuradio-3.7.2.1/grc/gui/Constants.py 0000644 0001750 0001750 00000004547 11700377701 017224 0 ustar jcorgan jcorgan """
Copyright 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import pygtk
pygtk.require('2.0')
import gtk
import os
##default path for the open/save dialogs
DEFAULT_FILE_PATH = os.getcwd()
##file extensions
IMAGE_FILE_EXTENSION = '.png'
##name for new/unsaved flow graphs
NEW_FLOGRAPH_TITLE = 'untitled'
##main window constraints
MIN_WINDOW_WIDTH = 600
MIN_WINDOW_HEIGHT = 400
##dialog constraints
MIN_DIALOG_WIDTH = 500
MIN_DIALOG_HEIGHT = 500
##default sizes
DEFAULT_BLOCKS_WINDOW_WIDTH = 100
DEFAULT_REPORTS_WINDOW_WIDTH = 100
##The size of the state saving cache in the flow graph (for undo/redo functionality)
STATE_CACHE_SIZE = 42
##Shared targets for drag and drop of blocks
DND_TARGETS = [('STRING', gtk.TARGET_SAME_APP, 0)]
#label constraint dimensions
LABEL_SEPARATION = 3
BLOCK_LABEL_PADDING = 7
PORT_LABEL_PADDING = 2
#port constraint dimensions
PORT_SEPARATION = 17
PORT_BORDER_SEPARATION = 9
PORT_MIN_WIDTH = 20
#minimal length of connector
CONNECTOR_EXTENSION_MINIMAL = 11
#increment length for connector
CONNECTOR_EXTENSION_INCREMENT = 11
#connection arrow dimensions
CONNECTOR_ARROW_BASE = 13
CONNECTOR_ARROW_HEIGHT = 17
#possible rotations in degrees
POSSIBLE_ROTATIONS = (0, 90, 180, 270)
#How close can the mouse get to the window border before mouse events are ignored.
BORDER_PROXIMITY_SENSITIVITY = 50
#How close the mouse can get to the edge of the visible window before scrolling is invoked.
SCROLL_PROXIMITY_SENSITIVITY = 30
#When the window has to be scrolled, move it this distance in the required direction.
SCROLL_DISTANCE = 15
#How close the mouse click can be to a line and register a connection select.
LINE_SELECT_SENSITIVITY = 5
gnuradio-3.7.2.1/grc/gui/FileDialogs.py 0000664 0001750 0001750 00000016762 12207702530 017431 0 ustar jcorgan jcorgan """
Copyright 2007 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import pygtk
pygtk.require('2.0')
import gtk
from Dialogs import MessageDialogHelper
from Constants import \
DEFAULT_FILE_PATH, IMAGE_FILE_EXTENSION, \
NEW_FLOGRAPH_TITLE
import Preferences
from os import path
import Utils
##################################################
# Constants
##################################################
OPEN_FLOW_GRAPH = 'open flow graph'
SAVE_FLOW_GRAPH = 'save flow graph'
SAVE_IMAGE = 'save image'
FILE_OVERWRITE_MARKUP_TMPL="""\
File $encode($filename) Exists!\nWould you like to overwrite the existing file?"""
FILE_DNE_MARKUP_TMPL="""\
File $encode($filename) Does not Exist!"""
##################################################
# File Filters
##################################################
##the filter for flow graph files
def get_flow_graph_files_filter():
filter = gtk.FileFilter()
filter.set_name('Flow Graph Files')
filter.add_pattern('*'+Preferences.file_extension())
return filter
##the filter for image files
def get_image_files_filter():
filter = gtk.FileFilter()
filter.set_name('Image Files')
filter.add_pattern('*'+IMAGE_FILE_EXTENSION)
return filter
##the filter for all files
def get_all_files_filter():
filter = gtk.FileFilter()
filter.set_name('All Files')
filter.add_pattern('*')
return filter
##################################################
# File Dialogs
##################################################
class FileDialogHelper(gtk.FileChooserDialog):
"""
A wrapper class for the gtk file chooser dialog.
Implement a file chooser dialog with only necessary parameters.
"""
def __init__(self, action, title):
"""
FileDialogHelper contructor.
Create a save or open dialog with cancel and ok buttons.
Use standard settings: no multiple selection, local files only, and the * filter.
Args:
action: gtk.FILE_CHOOSER_ACTION_OPEN or gtk.FILE_CHOOSER_ACTION_SAVE
title: the title of the dialog (string)
"""
ok_stock = {gtk.FILE_CHOOSER_ACTION_OPEN : 'gtk-open', gtk.FILE_CHOOSER_ACTION_SAVE : 'gtk-save'}[action]
gtk.FileChooserDialog.__init__(self, title, None, action, ('gtk-cancel', gtk.RESPONSE_CANCEL, ok_stock, gtk.RESPONSE_OK))
self.set_select_multiple(False)
self.set_local_only(True)
self.add_filter(get_all_files_filter())
class FileDialog(FileDialogHelper):
"""A dialog box to save or open flow graph files. This is a base class, do not use."""
def __init__(self, current_file_path=''):
"""
FileDialog constructor.
Args:
current_file_path: the current directory or path to the open flow graph
"""
if not current_file_path: current_file_path = path.join(DEFAULT_FILE_PATH, NEW_FLOGRAPH_TITLE + Preferences.file_extension())
if self.type == OPEN_FLOW_GRAPH:
FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_OPEN, 'Open a Flow Graph from a File...')
self.add_and_set_filter(get_flow_graph_files_filter())
self.set_select_multiple(True)
elif self.type == SAVE_FLOW_GRAPH:
FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_SAVE, 'Save a Flow Graph to a File...')
self.add_and_set_filter(get_flow_graph_files_filter())
self.set_current_name(path.basename(current_file_path)) #show the current filename
elif self.type == SAVE_IMAGE:
FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_SAVE, 'Save a Flow Graph Screen Shot...')
self.add_and_set_filter(get_image_files_filter())
current_file_path = current_file_path + IMAGE_FILE_EXTENSION
self.set_current_name(path.basename(current_file_path)) #show the current filename
self.set_current_folder(path.dirname(current_file_path)) #current directory
def add_and_set_filter(self, filter):
"""
Add the gtk file filter to the list of filters and set it as the default file filter.
Args:
filter: a gtk file filter.
"""
self.add_filter(filter)
self.set_filter(filter)
def get_rectified_filename(self):
"""
Run the dialog and get the filename.
If this is a save dialog and the file name is missing the extension, append the file extension.
If the file name with the extension already exists, show a overwrite dialog.
If this is an open dialog, return a list of filenames.
Returns:
the complete file path
"""
if gtk.FileChooserDialog.run(self) != gtk.RESPONSE_OK: return None #response was cancel
#############################################
# Handle Save Dialogs
#############################################
if self.type in (SAVE_FLOW_GRAPH, SAVE_IMAGE):
filename = self.get_filename()
extension = {
SAVE_FLOW_GRAPH: Preferences.file_extension(),
SAVE_IMAGE: IMAGE_FILE_EXTENSION,
}[self.type]
#append the missing file extension if the filter matches
if path.splitext(filename)[1].lower() != extension: filename += extension
self.set_current_name(path.basename(filename)) #show the filename with extension
if path.exists(filename): #ask the user to confirm overwrite
if MessageDialogHelper(
gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, 'Confirm Overwrite!',
Utils.parse_template(FILE_OVERWRITE_MARKUP_TMPL, filename=filename),
) == gtk.RESPONSE_NO: return self.get_rectified_filename()
return filename
#############################################
# Handle Open Dialogs
#############################################
elif self.type in (OPEN_FLOW_GRAPH,):
filenames = self.get_filenames()
for filename in filenames:
if not path.exists(filename): #show a warning and re-run
MessageDialogHelper(
gtk.MESSAGE_WARNING, gtk.BUTTONS_CLOSE, 'Cannot Open!',
Utils.parse_template(FILE_DNE_MARKUP_TMPL, filename=filename),
)
return self.get_rectified_filename()
return filenames
def run(self):
"""
Get the filename and destroy the dialog.
Returns:
the filename or None if a close/cancel occured.
"""
filename = self.get_rectified_filename()
self.destroy()
return filename
class OpenFlowGraphFileDialog(FileDialog): type = OPEN_FLOW_GRAPH
class SaveFlowGraphFileDialog(FileDialog): type = SAVE_FLOW_GRAPH
class SaveImageFileDialog(FileDialog): type = SAVE_IMAGE
gnuradio-3.7.2.1/grc/gui/DrawingArea.py 0000664 0001750 0001750 00000013544 12244173003 017424 0 ustar jcorgan jcorgan """
Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import pygtk
pygtk.require('2.0')
import gtk
from Constants import MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT, DND_TARGETS
class DrawingArea(gtk.DrawingArea):
"""
DrawingArea is the gtk pixel map that graphical elements may draw themselves on.
The drawing area also responds to mouse and key events.
"""
def __init__(self, flow_graph):
"""
DrawingArea contructor.
Connect event handlers.
Args:
main_window: the main_window containing all flow graphs
"""
self.ctrl_mask = False
self._flow_graph = flow_graph
gtk.DrawingArea.__init__(self)
self.set_size_request(MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT)
self.connect('realize', self._handle_window_realize)
self.connect('configure-event', self._handle_window_configure)
self.connect('expose-event', self._handle_window_expose)
self.connect('motion-notify-event', self._handle_mouse_motion)
self.connect('button-press-event', self._handle_mouse_button_press)
self.connect('button-release-event', self._handle_mouse_button_release)
self.add_events(
gtk.gdk.BUTTON_PRESS_MASK | \
gtk.gdk.POINTER_MOTION_MASK | \
gtk.gdk.BUTTON_RELEASE_MASK | \
gtk.gdk.LEAVE_NOTIFY_MASK | \
gtk.gdk.ENTER_NOTIFY_MASK | \
gtk.gdk.FOCUS_CHANGE_MASK
)
#setup drag and drop
self.drag_dest_set(gtk.DEST_DEFAULT_ALL, DND_TARGETS, gtk.gdk.ACTION_COPY)
self.connect('drag-data-received', self._handle_drag_data_received)
#setup the focus flag
self._focus_flag = False
self.get_focus_flag = lambda: self._focus_flag
def _handle_notify_event(widget, event, focus_flag): self._focus_flag = focus_flag
self.connect('leave-notify-event', _handle_notify_event, False)
self.connect('enter-notify-event', _handle_notify_event, True)
self.set_can_focus(True)
self.connect('focus-out-event', self._handle_focus_lost_event)
def new_pixmap(self, width, height): return gtk.gdk.Pixmap(self.window, width, height, -1)
def get_pixbuf(self):
width, height = self._pixmap.get_size()
pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, 0, 8, width, height)
pixbuf.get_from_drawable(self._pixmap, self._pixmap.get_colormap(), 0, 0, 0, 0, width, height)
return pixbuf
##########################################################################
## Handlers
##########################################################################
def _handle_drag_data_received(self, widget, drag_context, x, y, selection_data, info, time):
"""
Handle a drag and drop by adding a block at the given coordinate.
"""
self._flow_graph.add_new_block(selection_data.data, (x, y))
def _handle_mouse_button_press(self, widget, event):
"""
Forward button click information to the flow graph.
"""
self.grab_focus()
self.ctrl_mask = event.state & gtk.gdk.CONTROL_MASK
if event.button == 1: self._flow_graph.handle_mouse_selector_press(
double_click=(event.type == gtk.gdk._2BUTTON_PRESS),
coordinate=(event.x, event.y),
)
if event.button == 3: self._flow_graph.handle_mouse_context_press(
coordinate=(event.x, event.y),
event=event,
)
def _handle_mouse_button_release(self, widget, event):
"""
Forward button release information to the flow graph.
"""
self.ctrl_mask = event.state & gtk.gdk.CONTROL_MASK
if event.button == 1: self._flow_graph.handle_mouse_selector_release(
coordinate=(event.x, event.y),
)
def _handle_mouse_motion(self, widget, event):
"""
Forward mouse motion information to the flow graph.
"""
self.ctrl_mask = event.state & gtk.gdk.CONTROL_MASK
self._flow_graph.handle_mouse_motion(
coordinate=(event.x, event.y),
)
def _handle_window_realize(self, widget):
"""
Called when the window is realized.
Update the flowgraph, which calls new pixmap.
"""
self._flow_graph.update()
def _handle_window_configure(self, widget, event):
"""
Called when the window is resized.
Create a new pixmap for background buffer.
"""
self._pixmap = self.new_pixmap(*self.get_size_request())
def _handle_window_expose(self, widget, event):
"""
Called when window is exposed, or queue_draw is called.
Double buffering: draw to pixmap, then draw pixmap to window.
"""
gc = self.window.new_gc()
self._flow_graph.draw(gc, self._pixmap)
self.window.draw_drawable(gc, self._pixmap, 0, 0, 0, 0, -1, -1)
def _handle_focus_lost_event(self, widget, event):
# don't clear selection while context menu is active
if self._flow_graph.get_context_menu().get_visible(): return
self._flow_graph.unselect()
self._flow_graph.update_selected()
self._flow_graph.queue_draw()
gnuradio-3.7.2.1/grc/gui/Utils.py 0000664 0001750 0001750 00000006742 12207702530 016344 0 ustar jcorgan jcorgan """
Copyright 2008-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Constants import POSSIBLE_ROTATIONS
from Cheetah.Template import Template
import pygtk
pygtk.require('2.0')
import gtk
import gobject
def rotate_pixmap(gc, src_pixmap, dst_pixmap, angle=gtk.gdk.PIXBUF_ROTATE_COUNTERCLOCKWISE):
"""
Load the destination pixmap with a rotated version of the source pixmap.
The source pixmap will be loaded into a pixbuf, rotated, and drawn to the destination pixmap.
The pixbuf is a client-side drawable, where a pixmap is a server-side drawable.
Args:
gc: the graphics context
src_pixmap: the source pixmap
dst_pixmap: the destination pixmap
angle: the angle to rotate by
"""
width, height = src_pixmap.get_size()
pixbuf = gtk.gdk.Pixbuf(
colorspace=gtk.gdk.COLORSPACE_RGB,
has_alpha=False, bits_per_sample=8,
width=width, height=height,
)
pixbuf.get_from_drawable(src_pixmap, src_pixmap.get_colormap(), 0, 0, 0, 0, -1, -1)
pixbuf = pixbuf.rotate_simple(angle)
dst_pixmap.draw_pixbuf(gc, pixbuf, 0, 0, 0, 0)
def get_rotated_coordinate(coor, rotation):
"""
Rotate the coordinate by the given rotation.
Args:
coor: the coordinate x, y tuple
rotation: the angle in degrees
Returns:
the rotated coordinates
"""
#handles negative angles
rotation = (rotation + 360)%360
if rotation not in POSSIBLE_ROTATIONS:
raise ValueError('unusable rotation angle "%s"'%str(rotation))
#determine the number of degrees to rotate
cos_r, sin_r = {
0: (1, 0),
90: (0, 1),
180: (-1, 0),
270: (0, -1),
}[rotation]
x, y = coor
return (x*cos_r + y*sin_r, -x*sin_r + y*cos_r)
def get_angle_from_coordinates((x1,y1), (x2,y2)):
"""
Given two points, calculate the vector direction from point1 to point2, directions are multiples of 90 degrees.
Args:
(x1,y1): the coordinate of point 1
(x2,y2): the coordinate of point 2
Returns:
the direction in degrees
"""
if y1 == y2:#0 or 180
if x2 > x1: return 0
else: return 180
else:#90 or 270
if y2 > y1: return 270
else: return 90
def parse_template(tmpl_str, **kwargs):
"""
Parse the template string with the given args.
Pass in the xml encode method for pango escape chars.
Args:
tmpl_str: the template as a string
Returns:
a string of the parsed template
"""
kwargs['encode'] = gobject.markup_escape_text
#try:
# cat = str(Template(tmpl_str, kwargs))
#except TypeError:
# print 'guppy'
# print tmpl_str
# print str(kwargs['param'].get_error_messages())
return str(Template(tmpl_str, kwargs))
gnuradio-3.7.2.1/grc/gui/Bars.py 0000664 0001750 0001750 00000011211 12245466767 016143 0 ustar jcorgan jcorgan """
Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import Actions
import pygtk
pygtk.require('2.0')
import gtk
##The list of actions for the toolbar.
TOOLBAR_LIST = (
Actions.FLOW_GRAPH_NEW,
Actions.FLOW_GRAPH_OPEN,
Actions.FLOW_GRAPH_SAVE,
Actions.FLOW_GRAPH_CLOSE,
None,
Actions.FLOW_GRAPH_SCREEN_CAPTURE,
None,
Actions.BLOCK_CUT,
Actions.BLOCK_COPY,
Actions.BLOCK_PASTE,
Actions.ELEMENT_DELETE,
None,
Actions.FLOW_GRAPH_UNDO,
Actions.FLOW_GRAPH_REDO,
None,
Actions.ERRORS_WINDOW_DISPLAY,
Actions.FLOW_GRAPH_GEN,
Actions.FLOW_GRAPH_EXEC,
Actions.FLOW_GRAPH_KILL,
None,
Actions.BLOCK_ROTATE_CCW,
Actions.BLOCK_ROTATE_CW,
None,
Actions.BLOCK_ENABLE,
Actions.BLOCK_DISABLE,
None,
Actions.FIND_BLOCKS,
Actions.RELOAD_BLOCKS,
Actions.OPEN_HIER,
Actions.BUSSIFY_SOURCES,
)
##The list of actions and categories for the menu bar.
MENU_BAR_LIST = (
(gtk.Action('File', '_File', None, None), [
Actions.FLOW_GRAPH_NEW,
Actions.FLOW_GRAPH_OPEN,
None,
Actions.FLOW_GRAPH_SAVE,
Actions.FLOW_GRAPH_SAVE_AS,
None,
Actions.FLOW_GRAPH_SCREEN_CAPTURE,
None,
Actions.FLOW_GRAPH_CLOSE,
Actions.APPLICATION_QUIT,
]),
(gtk.Action('Edit', '_Edit', None, None), [
Actions.FLOW_GRAPH_UNDO,
Actions.FLOW_GRAPH_REDO,
None,
Actions.BLOCK_CUT,
Actions.BLOCK_COPY,
Actions.BLOCK_PASTE,
Actions.ELEMENT_DELETE,
None,
Actions.BLOCK_ROTATE_CCW,
Actions.BLOCK_ROTATE_CW,
None,
Actions.BLOCK_ENABLE,
Actions.BLOCK_DISABLE,
None,
Actions.BLOCK_PARAM_MODIFY,
]),
(gtk.Action('View', '_View', None, None), [
Actions.ERRORS_WINDOW_DISPLAY,
Actions.FIND_BLOCKS,
]),
(gtk.Action('Build', '_Build', None, None), [
Actions.FLOW_GRAPH_GEN,
Actions.FLOW_GRAPH_EXEC,
Actions.FLOW_GRAPH_KILL,
]),
(gtk.Action('Help', '_Help', None, None), [
Actions.HELP_WINDOW_DISPLAY,
Actions.TYPES_WINDOW_DISPLAY,
None,
Actions.ABOUT_WINDOW_DISPLAY,
]),
)
class Toolbar(gtk.Toolbar):
"""The gtk toolbar with actions added from the toolbar list."""
def __init__(self):
"""
Parse the list of action names in the toolbar list.
Look up the action for each name in the action list and add it to the toolbar.
"""
gtk.Toolbar.__init__(self)
self.set_style(gtk.TOOLBAR_ICONS)
for action in TOOLBAR_LIST:
if action: #add a tool item
self.add(action.create_tool_item())
#this reset of the tooltip property is required (after creating the tool item) for the tooltip to show
action.set_property('tooltip', action.get_property('tooltip'))
else: self.add(gtk.SeparatorToolItem())
class MenuBar(gtk.MenuBar):
"""The gtk menu bar with actions added from the menu bar list."""
def __init__(self):
"""
Parse the list of submenus from the menubar list.
For each submenu, get a list of action names.
Look up the action for each name in the action list and add it to the submenu.
Add the submenu to the menu bar.
"""
gtk.MenuBar.__init__(self)
for main_action, actions in MENU_BAR_LIST:
#create the main menu item
main_menu_item = main_action.create_menu_item()
self.append(main_menu_item)
#create the menu
main_menu = gtk.Menu()
main_menu_item.set_submenu(main_menu)
for action in actions:
if action: #append a menu item
main_menu.append(action.create_menu_item())
else: main_menu.append(gtk.SeparatorMenuItem())
main_menu.show_all() #this show all is required for the separators to show
gnuradio-3.7.2.1/grc/gui/PropsDialog.py 0000664 0001750 0001750 00000015250 12207702530 017461 0 ustar jcorgan jcorgan """
Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import pygtk
pygtk.require('2.0')
import gtk
from Dialogs import TextDisplay
from Constants import MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT
def get_title_label(title):
"""
Get a title label for the params window.
The title will be bold, underlined, and left justified.
Args:
title: the text of the title
Returns:
a gtk object
"""
label = gtk.Label()
label.set_markup('\n%s:\n'%title)
hbox = gtk.HBox()
hbox.pack_start(label, False, False, padding=11)
return hbox
class PropsDialog(gtk.Dialog):
"""
A dialog to set block parameters, view errors, and view documentation.
"""
def __init__(self, block):
"""
Properties dialog contructor.
Args:
block: a block instance
"""
self._hash = 0
LABEL_SPACING = 7
gtk.Dialog.__init__(self,
title='Properties: %s'%block.get_name(),
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT),
)
self._block = block
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
vbox = gtk.VBox()
#Create the scrolled window to hold all the parameters
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add_with_viewport(vbox)
self.vbox.pack_start(scrolled_window, True)
#Params box for block parameters
self._params_box = gtk.VBox()
self._params_box.pack_start(get_title_label('Parameters'), False)
self._input_object_params = list()
#Error Messages for the block
self._error_box = gtk.VBox()
self._error_messages_text_display = TextDisplay()
self._error_box.pack_start(gtk.Label(), False, False, LABEL_SPACING)
self._error_box.pack_start(get_title_label('Error Messages'), False)
self._error_box.pack_start(self._error_messages_text_display, False)
#Docs for the block
self._docs_box = err_box = gtk.VBox()
self._docs_text_display = TextDisplay()
self._docs_box.pack_start(gtk.Label(), False, False, LABEL_SPACING)
self._docs_box.pack_start(get_title_label('Documentation'), False)
self._docs_box.pack_start(self._docs_text_display, False)
#Add the boxes
vbox.pack_start(self._params_box, False)
vbox.pack_start(self._error_box, False)
vbox.pack_start(self._docs_box, False)
#connect events
self.connect('key-press-event', self._handle_key_press)
self.connect('show', self._update_gui)
#show all (performs initial gui update)
self.show_all()
def _params_changed(self):
"""
Have the params in this dialog changed?
Ex: Added, removed, type change, hide change...
To the props dialog, the hide setting of 'none' and 'part' are identical.
Therfore, the props dialog only cares if the hide setting is/not 'all'.
Make a hash that uniquely represents the params' state.
Returns:
true if changed
"""
old_hash = self._hash
#create a tuple of things from each param that affects the params box
self._hash = hash(tuple([(
hash(param), param.get_type(), param.get_hide() == 'all',
) for param in self._block.get_params()]))
return self._hash != old_hash
def _handle_changed(self, *args):
"""
A change occured within a param:
Rewrite/validate the block and update the gui.
"""
#update for the block
self._block.rewrite()
self._block.validate()
self._update_gui()
def _update_gui(self, *args):
"""
Repopulate the parameters box (if changed).
Update all the input parameters.
Update the error messages box.
Hide the box if there are no errors.
Update the documentation block.
Hide the box if there are no docs.
"""
#update the params box
if self._params_changed():
#hide params box before changing
self._params_box.hide_all()
#empty the params box
for io_param in list(self._input_object_params):
self._params_box.remove(io_param)
self._input_object_params.remove(io_param)
io_param.destroy()
#repopulate the params box
for param in self._block.get_params():
if param.get_hide() == 'all': continue
io_param = param.get_input(self._handle_changed)
self._input_object_params.append(io_param)
self._params_box.pack_start(io_param, False)
#show params box with new params
self._params_box.show_all()
#update the errors box
if self._block.is_valid(): self._error_box.hide()
else: self._error_box.show()
messages = '\n\n'.join(self._block.get_error_messages())
self._error_messages_text_display.set_text(messages)
#update the docs box
if self._block.get_doc(): self._docs_box.show()
else: self._docs_box.hide()
self._docs_text_display.set_text(self._block.get_doc())
def _handle_key_press(self, widget, event):
"""
Handle key presses from the keyboard.
Call the ok response when enter is pressed.
Returns:
false to forward the keypress
"""
if event.keyval == gtk.keysyms.Return:
self.response(gtk.RESPONSE_ACCEPT)
return True #handled here
return False #forward the keypress
def run(self):
"""
Run the dialog and get its response.
Returns:
true if the response was accept
"""
response = gtk.Dialog.run(self)
self.destroy()
return response == gtk.RESPONSE_ACCEPT
gnuradio-3.7.2.1/grc/gui/Param.py 0000664 0001750 0001750 00000016743 12207702530 016306 0 ustar jcorgan jcorgan """
Copyright 2007-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import Utils
from Element import Element
import pygtk
pygtk.require('2.0')
import gtk
import Colors
class InputParam(gtk.HBox):
"""The base class for an input parameter inside the input parameters dialog."""
def __init__(self, param, callback=None):
gtk.HBox.__init__(self)
self.param = param
self._callback = callback
self.label = gtk.Label() #no label, markup is added by set_markup
self.label.set_size_request(150, -1)
self.pack_start(self.label, False)
self.set_markup = lambda m: self.label.set_markup(m)
self.tp = None
#connect events
self.connect('show', self._update_gui)
def set_color(self, color): pass
def set_tooltip_text(self, text): pass
def _update_gui(self, *args):
"""
Set the markup, color, tooltip, show/hide.
"""
#set the markup
has_cb = \
hasattr(self.param.get_parent(), 'get_callbacks') and \
filter(lambda c: self.param.get_key() in c, self.param.get_parent()._callbacks)
self.set_markup(Utils.parse_template(PARAM_LABEL_MARKUP_TMPL, param=self.param, has_cb=has_cb))
#set the color
self.set_color(self.param.get_color())
#set the tooltip
self.set_tooltip_text(
Utils.parse_template(TIP_MARKUP_TMPL, param=self.param).strip(),
)
#show/hide
if self.param.get_hide() == 'all': self.hide_all()
else: self.show_all()
def _handle_changed(self, *args):
"""
Handle a gui change by setting the new param value,
calling the callback (if applicable), and updating.
"""
#set the new value
self.param.set_value(self.get_text())
#call the callback
if self._callback: self._callback(*args)
else: self.param.validate()
#gui update
self._update_gui()
class EntryParam(InputParam):
"""Provide an entry box for strings and numbers."""
def __init__(self, *args, **kwargs):
InputParam.__init__(self, *args, **kwargs)
self._input = gtk.Entry()
self._input.set_text(self.param.get_value())
self._input.connect('changed', self._handle_changed)
self.pack_start(self._input, True)
def get_text(self): return self._input.get_text()
def set_color(self, color):
self._input.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
self._input.modify_text(gtk.STATE_NORMAL, Colors.PARAM_ENTRY_TEXT_COLOR)
def set_tooltip_text(self, text): self._input.set_tooltip_text(text)
class EnumParam(InputParam):
"""Provide an entry box for Enum types with a drop down menu."""
def __init__(self, *args, **kwargs):
InputParam.__init__(self, *args, **kwargs)
self._input = gtk.combo_box_new_text()
for option in self.param.get_options(): self._input.append_text(option.get_name())
self._input.set_active(self.param.get_option_keys().index(self.param.get_value()))
self._input.connect('changed', self._handle_changed)
self.pack_start(self._input, False)
def get_text(self): return self.param.get_option_keys()[self._input.get_active()]
def set_tooltip_text(self, text): self._input.set_tooltip_text(text)
class EnumEntryParam(InputParam):
"""Provide an entry box and drop down menu for Raw Enum types."""
def __init__(self, *args, **kwargs):
InputParam.__init__(self, *args, **kwargs)
self._input = gtk.combo_box_entry_new_text()
for option in self.param.get_options(): self._input.append_text(option.get_name())
try: self._input.set_active(self.param.get_option_keys().index(self.param.get_value()))
except:
self._input.set_active(-1)
self._input.get_child().set_text(self.param.get_value())
self._input.connect('changed', self._handle_changed)
self._input.get_child().connect('changed', self._handle_changed)
self.pack_start(self._input, False)
def get_text(self):
if self._input.get_active() == -1: return self._input.get_child().get_text()
return self.param.get_option_keys()[self._input.get_active()]
def set_tooltip_text(self, text):
if self._input.get_active() == -1: #custom entry
self._input.get_child().set_tooltip_text(text)
else: self._input.set_tooltip_text(text)
def set_color(self, color):
if self._input.get_active() == -1: #custom entry, use color
self._input.get_child().modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
self._input.get_child().modify_text(gtk.STATE_NORMAL, Colors.PARAM_ENTRY_TEXT_COLOR)
else: #from enum, make pale background
self._input.get_child().modify_base(gtk.STATE_NORMAL, Colors.ENTRYENUM_CUSTOM_COLOR)
self._input.get_child().modify_text(gtk.STATE_NORMAL, Colors.PARAM_ENTRY_TEXT_COLOR)
PARAM_MARKUP_TMPL="""\
#set $foreground = $param.is_valid() and 'black' or 'red'
$encode($param.get_name()): $encode(repr($param))"""
PARAM_LABEL_MARKUP_TMPL="""\
#set $foreground = $param.is_valid() and 'black' or 'red'
#set $underline = $has_cb and 'low' or 'none'
$encode($param.get_name())"""
TIP_MARKUP_TMPL="""\
########################################
#def truncate(string)
#set $max_len = 100
#set $string = str($string)
#if len($string) > $max_len
$('%s...%s'%($string[:$max_len/2], $string[-$max_len/2:]))#slurp
#else
$string#slurp
#end if
#end def
########################################
Key: $param.get_key()
Type: $param.get_type()
#if $param.is_valid()
Value: $truncate($param.get_evaluated())
#elif len($param.get_error_messages()) == 1
Error: $(param.get_error_messages()[0])
#else
Error:
#for $error_msg in $param.get_error_messages()
* $error_msg
#end for
#end if"""
class Param(Element):
"""The graphical parameter."""
def __init__(self): Element.__init__(self)
def get_input(self, *args, **kwargs):
"""
Get the graphical gtk class to represent this parameter.
An enum requires and combo parameter.
A non-enum with options gets a combined entry/combo parameter.
All others get a standard entry parameter.
Returns:
gtk input class
"""
if self.is_enum(): return EnumParam(self, *args, **kwargs)
if self.get_options(): return EnumEntryParam(self, *args, **kwargs)
return EntryParam(self, *args, **kwargs)
def get_markup(self):
"""
Get the markup for this param.
Returns:
a pango markup string
"""
return Utils.parse_template(PARAM_MARKUP_TMPL, param=self)
gnuradio-3.7.2.1/grc/gui/StateCache.py 0000664 0001750 0001750 00000007131 12207702530 017241 0 ustar jcorgan jcorgan """
Copyright 2007 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import Actions
from Constants import STATE_CACHE_SIZE
class StateCache(object):
"""
The state cache is an interface to a list to record data/states and to revert to previous states.
States are recorded into the list in a circular fassion by using an index for the current state,
and counters for the range where states are stored.
"""
def __init__(self, initial_state):
"""
StateCache constructor.
Args:
initial_state: the intial state (nested data)
"""
self.states = [None] * STATE_CACHE_SIZE #fill states
self.current_state_index = 0
self.num_prev_states = 0
self.num_next_states = 0
self.states[0] = initial_state
self.update_actions()
def save_new_state(self, state):
"""
Save a new state.
Place the new state at the next index and add one to the number of previous states.
Args:
state: the new state
"""
self.current_state_index = (self.current_state_index + 1)%STATE_CACHE_SIZE
self.states[self.current_state_index] = state
self.num_prev_states = self.num_prev_states + 1
if self.num_prev_states == STATE_CACHE_SIZE: self.num_prev_states = STATE_CACHE_SIZE - 1
self.num_next_states = 0
self.update_actions()
def get_current_state(self):
"""
Get the state at the current index.
Returns:
the current state (nested data)
"""
self.update_actions()
return self.states[self.current_state_index]
def get_prev_state(self):
"""
Get the previous state and decrement the current index.
Returns:
the previous state or None
"""
if self.num_prev_states > 0:
self.current_state_index = (self.current_state_index + STATE_CACHE_SIZE -1)%STATE_CACHE_SIZE
self.num_next_states = self.num_next_states + 1
self.num_prev_states = self.num_prev_states - 1
return self.get_current_state()
return None
def get_next_state(self):
"""
Get the nest state and increment the current index.
Returns:
the next state or None
"""
if self.num_next_states > 0:
self.current_state_index = (self.current_state_index + 1)%STATE_CACHE_SIZE
self.num_next_states = self.num_next_states - 1
self.num_prev_states = self.num_prev_states + 1
return self.get_current_state()
return None
def update_actions(self):
"""
Update the undo and redo actions based on the number of next and prev states.
"""
Actions.FLOW_GRAPH_REDO.set_sensitive(self.num_next_states != 0)
Actions.FLOW_GRAPH_UNDO.set_sensitive(self.num_prev_states != 0)
gnuradio-3.7.2.1/grc/gui/Actions.py 0000664 0001750 0001750 00000023472 12245466767 016670 0 ustar jcorgan jcorgan """
Copyright 2007-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import pygtk
pygtk.require('2.0')
import gtk
NO_MODS_MASK = 0
########################################################################
# Actions API
########################################################################
_actions_keypress_dict = dict()
_keymap = gtk.gdk.keymap_get_default()
_used_mods_mask = NO_MODS_MASK
def handle_key_press(event):
"""
Call the action associated with the key press event.
Both the key value and the mask must have a match.
Args:
event: a gtk key press event
Returns:
true if handled
"""
_used_mods_mask = reduce(lambda x, y: x | y, [mod_mask for keyval, mod_mask in _actions_keypress_dict], NO_MODS_MASK)
#extract the key value and the consumed modifiers
keyval, egroup, level, consumed = _keymap.translate_keyboard_state(
event.hardware_keycode, event.state, event.group)
#get the modifier mask and ignore irrelevant modifiers
mod_mask = event.state & ~consumed & _used_mods_mask
#look up the keypress and call the action
try: _actions_keypress_dict[(keyval, mod_mask)]()
except KeyError: return False #not handled
return True #handled here
_all_actions_list = list()
def get_all_actions(): return _all_actions_list
_accel_group = gtk.AccelGroup()
def get_accel_group(): return _accel_group
class Action(gtk.Action):
"""
A custom Action class based on gtk.Action.
Pass additional arguments such as keypresses.
Register actions and keypresses with this module.
"""
def __init__(self, keypresses=(), name=None, label=None, tooltip=None, stock_id=None):
"""
Create a new Action instance.
Args:
key_presses: a tuple of (keyval1, mod_mask1, keyval2, mod_mask2, ...)
the: regular gtk.Action parameters (defaults to None)
"""
if name is None: name = label
gtk.Action.__init__(self,
name=name, label=label,
tooltip=tooltip, stock_id=stock_id,
)
#register this action
_all_actions_list.append(self)
for i in range(len(keypresses)/2):
keyval, mod_mask = keypresses[i*2:(i+1)*2]
#register this keypress
if _actions_keypress_dict.has_key((keyval, mod_mask)):
raise KeyError('keyval/mod_mask pair already registered "%s"'%str((keyval, mod_mask)))
_actions_keypress_dict[(keyval, mod_mask)] = self
#set the accelerator group, and accelerator path
#register the key name and mod mask with the accelerator path
if label is None: continue #dont register accel
accel_path = '/'+self.get_name()
self.set_accel_group(get_accel_group())
self.set_accel_path(accel_path)
gtk.accel_map_add_entry(accel_path, keyval, mod_mask)
def __str__(self):
"""
The string representation should be the name of the action id.
Try to find the action id for this action by searching this module.
"""
try:
import Actions
return filter(lambda attr: getattr(Actions, attr) == self, dir(Actions))[0]
except: return self.get_name()
def __repr__(self): return str(self)
def __call__(self):
"""
Emit the activate signal when called with ().
"""
self.emit('activate')
########################################################################
# Actions
########################################################################
PAGE_CHANGE = Action()
FLOW_GRAPH_NEW = Action(
label='_New',
tooltip='Create a new flow graph',
stock_id=gtk.STOCK_NEW,
keypresses=(gtk.keysyms.n, gtk.gdk.CONTROL_MASK),
)
FLOW_GRAPH_OPEN = Action(
label='_Open',
tooltip='Open an existing flow graph',
stock_id=gtk.STOCK_OPEN,
keypresses=(gtk.keysyms.o, gtk.gdk.CONTROL_MASK),
)
FLOW_GRAPH_SAVE = Action(
label='_Save',
tooltip='Save the current flow graph',
stock_id=gtk.STOCK_SAVE,
keypresses=(gtk.keysyms.s, gtk.gdk.CONTROL_MASK),
)
FLOW_GRAPH_SAVE_AS = Action(
label='Save _As',
tooltip='Save the current flow graph as...',
stock_id=gtk.STOCK_SAVE_AS,
keypresses=(gtk.keysyms.s, gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK),
)
FLOW_GRAPH_CLOSE = Action(
label='_Close',
tooltip='Close the current flow graph',
stock_id=gtk.STOCK_CLOSE,
keypresses=(gtk.keysyms.w, gtk.gdk.CONTROL_MASK),
)
APPLICATION_INITIALIZE = Action()
APPLICATION_QUIT = Action(
label='_Quit',
tooltip='Quit program',
stock_id=gtk.STOCK_QUIT,
keypresses=(gtk.keysyms.q, gtk.gdk.CONTROL_MASK),
)
FLOW_GRAPH_UNDO = Action(
label='_Undo',
tooltip='Undo a change to the flow graph',
stock_id=gtk.STOCK_UNDO,
keypresses=(gtk.keysyms.z, gtk.gdk.CONTROL_MASK),
)
FLOW_GRAPH_REDO = Action(
label='_Redo',
tooltip='Redo a change to the flow graph',
stock_id=gtk.STOCK_REDO,
keypresses=(gtk.keysyms.y, gtk.gdk.CONTROL_MASK),
)
NOTHING_SELECT = Action()
ELEMENT_SELECT = Action()
ELEMENT_CREATE = Action()
ELEMENT_DELETE = Action(
label='_Delete',
tooltip='Delete the selected blocks',
stock_id=gtk.STOCK_DELETE,
keypresses=(gtk.keysyms.Delete, NO_MODS_MASK),
)
BLOCK_MOVE = Action()
BLOCK_ROTATE_CCW = Action(
label='Rotate Counterclockwise',
tooltip='Rotate the selected blocks 90 degrees to the left',
stock_id=gtk.STOCK_GO_BACK,
keypresses=(gtk.keysyms.Left, NO_MODS_MASK),
)
BLOCK_ROTATE_CW = Action(
label='Rotate Clockwise',
tooltip='Rotate the selected blocks 90 degrees to the right',
stock_id=gtk.STOCK_GO_FORWARD,
keypresses=(gtk.keysyms.Right, NO_MODS_MASK),
)
BLOCK_PARAM_MODIFY = Action(
label='_Properties',
tooltip='Modify params for the selected block',
stock_id=gtk.STOCK_PROPERTIES,
keypresses=(gtk.keysyms.Return, NO_MODS_MASK),
)
BLOCK_ENABLE = Action(
label='E_nable',
tooltip='Enable the selected blocks',
stock_id=gtk.STOCK_CONNECT,
keypresses=(gtk.keysyms.e, NO_MODS_MASK),
)
BLOCK_DISABLE = Action(
label='D_isable',
tooltip='Disable the selected blocks',
stock_id=gtk.STOCK_DISCONNECT,
keypresses=(gtk.keysyms.d, NO_MODS_MASK),
)
BLOCK_CREATE_HIER = Action(
label='C_reate Hier',
tooltip='Create hier block from selected blocks',
stock_id=gtk.STOCK_CONNECT,
# keypresses=(gtk.keysyms.c, NO_MODS_MASK),
)
BLOCK_CUT = Action(
label='Cu_t',
tooltip='Cut',
stock_id=gtk.STOCK_CUT,
keypresses=(gtk.keysyms.x, gtk.gdk.CONTROL_MASK),
)
BLOCK_COPY = Action(
label='_Copy',
tooltip='Copy',
stock_id=gtk.STOCK_COPY,
keypresses=(gtk.keysyms.c, gtk.gdk.CONTROL_MASK),
)
BLOCK_PASTE = Action(
label='_Paste',
tooltip='Paste',
stock_id=gtk.STOCK_PASTE,
keypresses=(gtk.keysyms.v, gtk.gdk.CONTROL_MASK),
)
ERRORS_WINDOW_DISPLAY = Action(
label='_Errors',
tooltip='View flow graph errors',
stock_id=gtk.STOCK_DIALOG_ERROR,
)
ABOUT_WINDOW_DISPLAY = Action(
label='_About',
tooltip='About this program',
stock_id=gtk.STOCK_ABOUT,
)
HELP_WINDOW_DISPLAY = Action(
label='_Help',
tooltip='Usage tips',
stock_id=gtk.STOCK_HELP,
keypresses=(gtk.keysyms.F1, NO_MODS_MASK),
)
TYPES_WINDOW_DISPLAY = Action(
label='_Types',
tooltip='Types color mapping',
stock_id=gtk.STOCK_DIALOG_INFO,
)
FLOW_GRAPH_GEN = Action(
label='_Generate',
tooltip='Generate the flow graph',
stock_id=gtk.STOCK_CONVERT,
keypresses=(gtk.keysyms.F5, NO_MODS_MASK),
)
FLOW_GRAPH_EXEC = Action(
label='_Execute',
tooltip='Execute the flow graph',
stock_id=gtk.STOCK_EXECUTE,
keypresses=(gtk.keysyms.F6, NO_MODS_MASK),
)
FLOW_GRAPH_KILL = Action(
label='_Kill',
tooltip='Kill the flow graph',
stock_id=gtk.STOCK_STOP,
keypresses=(gtk.keysyms.F7, NO_MODS_MASK),
)
FLOW_GRAPH_SCREEN_CAPTURE = Action(
label='S_creen Capture',
tooltip='Create a screen capture of the flow graph',
stock_id=gtk.STOCK_PRINT,
keypresses=(gtk.keysyms.Print, NO_MODS_MASK),
)
PORT_CONTROLLER_DEC = Action(
keypresses=(gtk.keysyms.minus, NO_MODS_MASK, gtk.keysyms.KP_Subtract, NO_MODS_MASK),
)
PORT_CONTROLLER_INC = Action(
keypresses=(gtk.keysyms.plus, NO_MODS_MASK, gtk.keysyms.KP_Add, NO_MODS_MASK),
)
BLOCK_INC_TYPE = Action(
keypresses=(gtk.keysyms.Down, NO_MODS_MASK),
)
BLOCK_DEC_TYPE = Action(
keypresses=(gtk.keysyms.Up, NO_MODS_MASK),
)
RELOAD_BLOCKS = Action(
label='Reload _Blocks',
tooltip='Reload Blocks',
stock_id=gtk.STOCK_REFRESH
)
FIND_BLOCKS = Action(
label='_Find Blocks',
tooltip='Search for a block by name (and key)',
stock_id=gtk.STOCK_FIND,
keypresses=(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,
gtk.keysyms.slash, NO_MODS_MASK),
)
OPEN_HIER = Action(
label='Open H_ier',
tooltip='Open the source of the selected hierarchical block',
stock_id=gtk.STOCK_JUMP_TO,
)
BUSSIFY_SOURCES = Action(
label='Toggle So_urce Bus',
tooltip='Gang source ports into a single bus port',
stock_id=gtk.STOCK_JUMP_TO,
)
BUSSIFY_SINKS = Action(
label='Toggle S_ink Bus',
tooltip='Gang sink ports into a single bus port',
stock_id=gtk.STOCK_JUMP_TO,
)
gnuradio-3.7.2.1/grc/gui/MainWindow.py 0000664 0001750 0001750 00000030657 12245466767 017347 0 ustar jcorgan jcorgan """
Copyright 2008, 2009, 2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Constants import \
NEW_FLOGRAPH_TITLE, DEFAULT_REPORTS_WINDOW_WIDTH
import Actions
import pygtk
pygtk.require('2.0')
import gtk
import Bars
from BlockTreeWindow import BlockTreeWindow
from Dialogs import TextDisplay, MessageDialogHelper
from NotebookPage import NotebookPage
import Preferences
import Messages
import Utils
import os
MAIN_WINDOW_TITLE_TMPL = """\
#if not $saved
*#slurp
#end if
#if $basename
$basename#slurp
#else
$new_flowgraph_title#slurp
#end if
#if $read_only
(read only)#slurp
#end if
#if $dirname
- $dirname#slurp
#end if
- $platform_name#slurp
"""
PAGE_TITLE_MARKUP_TMPL = """\
#set $foreground = $saved and 'black' or 'red'
$encode($title or $new_flowgraph_title)#slurp
#if $read_only
(ro)#slurp
#end if
"""
############################################################
# Main window
############################################################
class MainWindow(gtk.Window):
"""The topmost window with menus, the tool bar, and other major windows."""
def __init__(self, platform):
"""
MainWindow contructor
Setup the menu, toolbar, flowgraph editor notebook, block selection window...
"""
self._platform = platform
#setup window
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
vbox = gtk.VBox()
self.hpaned = gtk.HPaned()
self.add(vbox)
#create the menu bar and toolbar
self.add_accel_group(Actions.get_accel_group())
vbox.pack_start(Bars.MenuBar(), False)
vbox.pack_start(Bars.Toolbar(), False)
vbox.pack_start(self.hpaned)
#create the notebook
self.notebook = gtk.Notebook()
self.page_to_be_closed = None
self.current_page = None
self.notebook.set_show_border(False)
self.notebook.set_scrollable(True) #scroll arrows for page tabs
self.notebook.connect('switch-page', self._handle_page_change)
#setup containers
self.flow_graph_vpaned = gtk.VPaned()
#flow_graph_box.pack_start(self.scrolled_window)
self.flow_graph_vpaned.pack1(self.notebook)
self.hpaned.pack1(self.flow_graph_vpaned)
self.btwin = BlockTreeWindow(platform, self.get_flow_graph);
self.hpaned.pack2(self.btwin, False) #dont allow resize
#create the reports window
self.text_display = TextDisplay()
#house the reports in a scrolled window
self.reports_scrolled_window = gtk.ScrolledWindow()
self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.reports_scrolled_window.add_with_viewport(self.text_display)
self.reports_scrolled_window.set_size_request(-1, DEFAULT_REPORTS_WINDOW_WIDTH)
self.flow_graph_vpaned.pack2(self.reports_scrolled_window, False) #dont allow resize
#load preferences and show the main window
Preferences.load(platform)
self.resize(*Preferences.main_window_size())
self.flow_graph_vpaned.set_position(Preferences.reports_window_position())
self.hpaned.set_position(Preferences.blocks_window_position())
self.show_all()
############################################################
# Event Handlers
############################################################
def _quit(self, window, event):
"""
Handle the delete event from the main window.
Generated by pressing X to close, alt+f4, or right click+close.
This method in turns calls the state handler to quit.
Returns:
true
"""
Actions.APPLICATION_QUIT()
return True
def _handle_page_change(self, notebook, page, page_num):
"""
Handle a page change. When the user clicks on a new tab,
reload the flow graph to update the vars window and
call handle states (select nothing) to update the buttons.
Args:
notebook: the notebook
page: new page
page_num: new page number
"""
self.current_page = self.notebook.get_nth_page(page_num)
Messages.send_page_switch(self.current_page.get_file_path())
Actions.PAGE_CHANGE()
############################################################
# Report Window
############################################################
def add_report_line(self, line):
"""
Place line at the end of the text buffer, then scroll its window all the way down.
Args:
line: the new text
"""
self.text_display.insert(line)
vadj = self.reports_scrolled_window.get_vadjustment()
vadj.value = vadj.upper - vadj.page_size
vadj.changed()
############################################################
# Pages: create and close
############################################################
def new_page(self, file_path='', show=False):
"""
Create a new notebook page.
Set the tab to be selected.
Args:
file_path: optional file to load into the flow graph
show: true if the page should be shown after loading
"""
#if the file is already open, show the open page and return
if file_path and file_path in self._get_files(): #already open
page = self.notebook.get_nth_page(self._get_files().index(file_path))
self._set_page(page)
return
try: #try to load from file
if file_path: Messages.send_start_load(file_path)
flow_graph = self._platform.get_new_flow_graph()
flow_graph.grc_file_path = file_path;
#print flow_graph
page = NotebookPage(
self,
flow_graph=flow_graph,
file_path=file_path,
)
if file_path: Messages.send_end_load()
except Exception, e: #return on failure
Messages.send_fail_load(e)
if isinstance(e, KeyError) and str(e) == "'options'":
# This error is unrecoverable, so crash gracefully
exit(-1)
return
#add this page to the notebook
self.notebook.append_page(page, page.get_tab())
try: self.notebook.set_tab_reorderable(page, True)
except: pass #gtk too old
self.notebook.set_tab_label_packing(page, False, False, gtk.PACK_START)
#only show if blank or manual
if not file_path or show: self._set_page(page)
def close_pages(self):
"""
Close all the pages in this notebook.
Returns:
true if all closed
"""
open_files = filter(lambda file: file, self._get_files()) #filter blank files
open_file = self.get_page().get_file_path()
#close each page
for page in self._get_pages():
self.page_to_be_closed = page
self.close_page(False)
if self.notebook.get_n_pages(): return False
#save state before closing
Preferences.files_open(open_files)
Preferences.file_open(open_file)
Preferences.main_window_size(self.get_size())
Preferences.reports_window_position(self.flow_graph_vpaned.get_position())
Preferences.blocks_window_position(self.hpaned.get_position())
Preferences.save()
return True
def close_page(self, ensure=True):
"""
Close the current page.
If the notebook becomes empty, and ensure is true,
call new page upon exit to ensure that at least one page exists.
Args:
ensure: boolean
"""
if not self.page_to_be_closed: self.page_to_be_closed = self.get_page()
#show the page if it has an executing flow graph or is unsaved
if self.page_to_be_closed.get_proc() or not self.page_to_be_closed.get_saved():
self._set_page(self.page_to_be_closed)
#unsaved? ask the user
if not self.page_to_be_closed.get_saved() and self._save_changes():
Actions.FLOW_GRAPH_SAVE() #try to save
if not self.page_to_be_closed.get_saved(): #still unsaved?
self.page_to_be_closed = None #set the page to be closed back to None
return
#stop the flow graph if executing
if self.page_to_be_closed.get_proc(): Actions.FLOW_GRAPH_KILL()
#remove the page
self.notebook.remove_page(self.notebook.page_num(self.page_to_be_closed))
if ensure and self.notebook.get_n_pages() == 0: self.new_page() #no pages, make a new one
self.page_to_be_closed = None #set the page to be closed back to None
############################################################
# Misc
############################################################
def update(self):
"""
Set the title of the main window.
Set the titles on the page tabs.
Show/hide the reports window.
Args:
title: the window title
"""
gtk.Window.set_title(self, Utils.parse_template(MAIN_WINDOW_TITLE_TMPL,
basename=os.path.basename(self.get_page().get_file_path()),
dirname=os.path.dirname(self.get_page().get_file_path()),
new_flowgraph_title=NEW_FLOGRAPH_TITLE,
read_only=self.get_page().get_read_only(),
saved=self.get_page().get_saved(),
platform_name=self._platform.get_name(),
)
)
#set tab titles
for page in self._get_pages(): page.set_markup(
Utils.parse_template(PAGE_TITLE_MARKUP_TMPL,
#get filename and strip out file extension
title=os.path.splitext(os.path.basename(page.get_file_path()))[0],
read_only=page.get_read_only(), saved=page.get_saved(),
new_flowgraph_title=NEW_FLOGRAPH_TITLE,
)
)
#show/hide notebook tabs
self.notebook.set_show_tabs(len(self._get_pages()) > 1)
def get_page(self):
"""
Get the selected page.
Returns:
the selected page
"""
return self.current_page
def get_flow_graph(self):
"""
Get the selected flow graph.
Returns:
the selected flow graph
"""
return self.get_page().get_flow_graph()
def get_focus_flag(self):
"""
Get the focus flag from the current page.
Returns:
the focus flag
"""
return self.get_page().get_drawing_area().get_focus_flag()
############################################################
# Helpers
############################################################
def _set_page(self, page):
"""
Set the current page.
Args:
page: the page widget
"""
self.current_page = page
self.notebook.set_current_page(self.notebook.page_num(self.current_page))
def _save_changes(self):
"""
Save changes to flow graph?
Returns:
true if yes
"""
return MessageDialogHelper(
gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, 'Unsaved Changes!',
'Would you like to save changes before closing?'
) == gtk.RESPONSE_YES
def _get_files(self):
"""
Get the file names for all the pages, in order.
Returns:
list of file paths
"""
return map(lambda page: page.get_file_path(), self._get_pages())
def _get_pages(self):
"""
Get a list of all pages in the notebook.
Returns:
list of pages
"""
return [self.notebook.get_nth_page(page_num) for page_num in range(self.notebook.get_n_pages())]
gnuradio-3.7.2.1/grc/gui/BlockTreeWindow.py 0000664 0001750 0001750 00000024533 12245466767 020331 0 ustar jcorgan jcorgan """
Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Constants import DEFAULT_BLOCKS_WINDOW_WIDTH, DND_TARGETS
import Actions
import Utils
import pygtk
pygtk.require('2.0')
import gtk
import gobject
NAME_INDEX = 0
KEY_INDEX = 1
DOC_INDEX = 2
DOC_MARKUP_TMPL="""\
#if $doc
$encode($doc)#slurp
#else
undocumented#slurp
#end if"""
CAT_MARKUP_TMPL="""Category: $cat"""
class BlockTreeWindow(gtk.VBox):
"""The block selection panel."""
def __init__(self, platform, get_flow_graph):
"""
BlockTreeWindow constructor.
Create a tree view of the possible blocks in the platform.
The tree view nodes will be category names, the leaves will be block names.
A mouse double click or button press action will trigger the add block event.
Args:
platform: the particular platform will all block prototypes
get_flow_graph: get the selected flow graph
"""
gtk.VBox.__init__(self)
self.platform = platform
self.get_flow_graph = get_flow_graph
# search entry
self.search_entry = gtk.Entry()
self.search_entry.set_icon_from_stock(gtk.ENTRY_ICON_PRIMARY, gtk.STOCK_FIND)
self.search_entry.set_icon_activatable(gtk.ENTRY_ICON_PRIMARY, False)
self.search_entry.set_icon_from_stock(gtk.ENTRY_ICON_SECONDARY, gtk.STOCK_CLOSE)
self.search_entry.connect('icon-release', self._handle_icon_event)
self.search_entry.connect('changed', self._update_search_tree)
self.search_entry.connect('key-press-event', self._handle_search_key_press)
self.pack_start(self.search_entry, False)
#make the tree model for holding blocks and a temporary one for search results
self.treestore = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
self.treestore_search = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
self.treeview = gtk.TreeView(self.treestore)
self.treeview.set_enable_search(False) #disable pop up search box
self.treeview.set_search_column(-1) # really disable search
self.treeview.set_headers_visible(False)
self.treeview.add_events(gtk.gdk.BUTTON_PRESS_MASK)
self.treeview.connect('button-press-event', self._handle_mouse_button_press)
self.treeview.connect('key-press-event', self._handle_search_key_press)
self.treeview.get_selection().set_mode('single')
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('Blocks', renderer, text=NAME_INDEX)
self.treeview.append_column(column)
#try to enable the tooltips (available in pygtk 2.12 and above)
try: self.treeview.set_tooltip_column(DOC_INDEX)
except: pass
#setup sort order
column.set_sort_column_id(0)
self.treestore.set_sort_column_id(0, gtk.SORT_ASCENDING)
#setup drag and drop
self.treeview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, DND_TARGETS, gtk.gdk.ACTION_COPY)
self.treeview.connect('drag-data-get', self._handle_drag_get_data)
#make the scrolled window to hold the tree view
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add_with_viewport(self.treeview)
scrolled_window.set_size_request(DEFAULT_BLOCKS_WINDOW_WIDTH, -1)
self.pack_start(scrolled_window)
#map categories to iters, automatic mapping for root
self._categories = {tuple(): None}
self._categories_search = {tuple(): None}
#add blocks and categories
self.platform.load_block_tree(self)
def clear(self):
self.treestore.clear();
self._categories = {tuple(): None}
############################################################
## Block Tree Methods
############################################################
def add_block(self, category, block=None, treestore=None, categories=None):
"""
Add a block with category to this selection window.
Add only the category when block is None.
Args:
category: the category list or path string
block: the block object or None
"""
if treestore is None: treestore = self.treestore
if categories is None: categories = self._categories
if isinstance(category, str): category = category.split('/')
category = tuple(filter(lambda x: x, category)) #tuple is hashable
#add category and all sub categories
for i, cat_name in enumerate(category):
sub_category = category[:i+1]
if sub_category not in categories:
iter = treestore.insert_before(categories[sub_category[:-1]], None)
treestore.set_value(iter, NAME_INDEX, '[ %s ]'%cat_name)
treestore.set_value(iter, KEY_INDEX, '')
treestore.set_value(iter, DOC_INDEX, Utils.parse_template(CAT_MARKUP_TMPL, cat=cat_name))
categories[sub_category] = iter
#add block
if block is None: return
iter = treestore.insert_before(categories[category], None)
treestore.set_value(iter, NAME_INDEX, block.get_name())
treestore.set_value(iter, KEY_INDEX, block.get_key())
treestore.set_value(iter, DOC_INDEX, Utils.parse_template(DOC_MARKUP_TMPL, doc=block.get_doc()))
############################################################
## Helper Methods
############################################################
def _get_selected_block_key(self):
"""
Get the currently selected block key.
Returns:
the key of the selected block or a empty string
"""
selection = self.treeview.get_selection()
treestore, iter = selection.get_selected()
return iter and treestore.get_value(iter, KEY_INDEX) or ''
def _add_selected_block(self):
"""
Add the selected block with the given key to the flow graph.
"""
key = self._get_selected_block_key()
if key:
self.get_flow_graph().add_new_block(key)
return True
return False
def _expand_category(self):
treestore, iter = self.treeview.get_selection().get_selected()
if iter and treestore.iter_has_child(iter):
path = self.treestore.get_path(iter)
self.treeview.expand_to_path(path)
############################################################
## Event Handlers
############################################################
def _handle_icon_event(self, widget, icon, event):
if icon == gtk.ENTRY_ICON_PRIMARY:
pass
elif icon == gtk.ENTRY_ICON_SECONDARY:
widget.set_text('')
self.search_entry.hide()
def _update_search_tree(self, widget):
key = widget.get_text().lower()
if not key:
self.treeview.set_model(self.treestore)
self.treeview.collapse_all()
else:
blocks = self.get_flow_graph().get_parent().get_blocks()
matching_blocks = filter(lambda b: key in b.get_key().lower() or key in b.get_name().lower(), blocks)
self.treestore_search.clear()
self._categories_search = {tuple(): None}
for block in matching_blocks:
self.add_block(block.get_category() or 'None', block,
self.treestore_search, self._categories_search)
self.treeview.set_model(self.treestore_search)
self.treeview.expand_all()
def _handle_search_key_press(self, widget, event):
"""Handle Return and Escape key events in search entry and treeview"""
if event.keyval == gtk.keysyms.Return:
# add block on enter
if widget == self.search_entry:
# Get the first block in the search tree and add it
selected = self.treestore_search.get_iter_first()
while self.treestore_search.iter_children(selected):
selected = self.treestore_search.iter_children(selected)
if selected is not None:
key = self.treestore_search.get_value(selected, KEY_INDEX)
if key: self.get_flow_graph().add_new_block(key)
elif widget == self.treeview:
self._add_selected_block() or self._expand_category()
else:
return False # propagate event
elif event.keyval == gtk.keysyms.Escape:
# reset the search
self.search_entry.set_text('')
self.search_entry.hide()
elif (event.state & gtk.gdk.CONTROL_MASK and event.keyval == gtk.keysyms.f) \
or event.keyval == gtk.keysyms.slash:
# propagation doesn't work although treeview search is disabled =(
# manually trigger action...
Actions.FIND_BLOCKS.activate()
else:
return False # propagate event
return True
def _handle_drag_get_data(self, widget, drag_context, selection_data, info, time):
"""
Handle a drag and drop by setting the key to the selection object.
This will call the destination handler for drag and drop.
Only call set when the key is valid to ignore DND from categories.
"""
key = self._get_selected_block_key()
if key: selection_data.set(selection_data.target, 8, key)
def _handle_mouse_button_press(self, widget, event):
"""
Handle the mouse button press.
If a left double click is detected, call add selected block.
"""
if event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS:
self._add_selected_block()
gnuradio-3.7.2.1/grc/gui/Messages.py 0000664 0001750 0001750 00000006753 12207702530 017015 0 ustar jcorgan jcorgan """
Copyright 2007 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import traceback
import sys
## A list of functions that can receive a message.
MESSENGERS_LIST = list()
def register_messenger(messenger):
"""
Append the given messenger to the list of messengers.
Args:
messenger: a method thats takes a string
"""
MESSENGERS_LIST.append(messenger)
def send(message):
"""
Give the message to each of the messengers.
Args:
message: a message string
"""
for messenger in MESSENGERS_LIST: messenger(message)
#register stdout by default
register_messenger(sys.stdout.write)
###########################################################################
# Special functions for specific program functionalities
###########################################################################
def send_init(platform):
send("""<<< Welcome to %s %s >>>\n"""%(platform.get_name(), platform.get_version()))
def send_page_switch(file_path):
send('\nShowing: "%s"\n'%file_path)
################# functions for loading flow graphs ########################################
def send_start_load(file_path):
send('\nLoading: "%s"'%file_path + '\n')
def send_error_load(error):
send('>>> Error: %s\n'%error)
traceback.print_exc()
def send_end_load():
send('>>> Done\n')
def send_fail_load(error):
send('Error: %s\n'%error)
send('>>> Failure\n')
traceback.print_exc()
################# functions for generating flow graphs ########################################
def send_start_gen(file_path):
send('\nGenerating: "%s"'%file_path + '\n')
def send_fail_gen(error):
send('Generate Error: %s\n'%error)
send('>>> Failure\n')
traceback.print_exc()
################# functions for executing flow graphs ########################################
def send_start_exec(file_path):
send('\nExecuting: "%s"'%file_path + '\n')
def send_verbose_exec(verbose):
send(verbose)
def send_end_exec():
send('\n>>> Done\n')
################# functions for saving flow graphs ########################################
def send_fail_save(file_path):
send('>>> Error: Cannot save: %s\n'%file_path)
################# functions for connections ########################################
def send_fail_connection():
send('>>> Error: Cannot create connection.\n')
################# functions for preferences ########################################
def send_fail_load_preferences(prefs_file_path):
send('>>> Error: Cannot load preferences file: "%s"\n'%prefs_file_path)
def send_fail_save_preferences(prefs_file_path):
send('>>> Error: Cannot save preferences file: "%s"\n'%prefs_file_path)
################# functions for warning ########################################
def send_warning(warning):
send('>>> Warning: %s\n'%warning)
gnuradio-3.7.2.1/grc/gui/Connection.py 0000664 0001750 0001750 00000015662 12245466767 017371 0 ustar jcorgan jcorgan """
Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import Utils
from Element import Element
import Colors
from Constants import CONNECTOR_ARROW_BASE, CONNECTOR_ARROW_HEIGHT
class Connection(Element):
"""
A graphical connection for ports.
The connection has 2 parts, the arrow and the wire.
The coloring of the arrow and wire exposes the status of 3 states:
enabled/disabled, valid/invalid, highlighted/non-highlighted.
The wire coloring exposes the enabled and highlighted states.
The arrow coloring exposes the enabled and valid states.
"""
def __init__(self): Element.__init__(self)
def get_coordinate(self):
"""
Get the 0,0 coordinate.
Coordinates are irrelevant in connection.
Returns:
0, 0
"""
return (0, 0)
def get_rotation(self):
"""
Get the 0 degree rotation.
Rotations are irrelevant in connection.
Returns:
0
"""
return 0
def create_shapes(self):
"""Precalculate relative coordinates."""
Element.create_shapes(self)
self._sink_rot = None
self._source_rot = None
self._sink_coor = None
self._source_coor = None
#get the source coordinate
try:
connector_length = self.get_source().get_connector_length()
except:
return
self.x1, self.y1 = Utils.get_rotated_coordinate((connector_length, 0), self.get_source().get_rotation())
#get the sink coordinate
connector_length = self.get_sink().get_connector_length() + CONNECTOR_ARROW_HEIGHT
self.x2, self.y2 = Utils.get_rotated_coordinate((-connector_length, 0), self.get_sink().get_rotation())
#build the arrow
self.arrow = [(0, 0),
Utils.get_rotated_coordinate((-CONNECTOR_ARROW_HEIGHT, -CONNECTOR_ARROW_BASE/2), self.get_sink().get_rotation()),
Utils.get_rotated_coordinate((-CONNECTOR_ARROW_HEIGHT, CONNECTOR_ARROW_BASE/2), self.get_sink().get_rotation()),
]
self._update_after_move()
if not self.get_enabled(): self._arrow_color = Colors.CONNECTION_DISABLED_COLOR
elif not self.is_valid(): self._arrow_color = Colors.CONNECTION_ERROR_COLOR
else: self._arrow_color = Colors.CONNECTION_ENABLED_COLOR
def _update_after_move(self):
"""Calculate coordinates."""
self.clear() #FIXME do i want this here?
#source connector
source = self.get_source()
X, Y = source.get_connector_coordinate()
x1, y1 = self.x1 + X, self.y1 + Y
self.add_line((x1, y1), (X, Y))
#sink connector
sink = self.get_sink()
X, Y = sink.get_connector_coordinate()
x2, y2 = self.x2 + X, self.y2 + Y
self.add_line((x2, y2), (X, Y))
#adjust arrow
self._arrow = [(x+X, y+Y) for x,y in self.arrow]
#add the horizontal and vertical lines in this connection
if abs(source.get_connector_direction() - sink.get_connector_direction()) == 180:
#2 possible point sets to create a 3-line connector
mid_x, mid_y = (x1 + x2)/2.0, (y1 + y2)/2.0
points = [((mid_x, y1), (mid_x, y2)), ((x1, mid_y), (x2, mid_y))]
#source connector -> points[0][0] should be in the direction of source (if possible)
if Utils.get_angle_from_coordinates((x1, y1), points[0][0]) != source.get_connector_direction(): points.reverse()
#points[0][0] -> sink connector should not be in the direction of sink
if Utils.get_angle_from_coordinates(points[0][0], (x2, y2)) == sink.get_connector_direction(): points.reverse()
#points[0][0] -> source connector should not be in the direction of source
if Utils.get_angle_from_coordinates(points[0][0], (x1, y1)) == source.get_connector_direction(): points.reverse()
#create 3-line connector
p1, p2 = map(int, points[0][0]), map(int, points[0][1])
self.add_line((x1, y1), p1)
self.add_line(p1, p2)
self.add_line((x2, y2), p2)
else:
#2 possible points to create a right-angled connector
points = [(x1, y2), (x2, y1)]
#source connector -> points[0] should be in the direction of source (if possible)
if Utils.get_angle_from_coordinates((x1, y1), points[0]) != source.get_connector_direction(): points.reverse()
#points[0] -> sink connector should not be in the direction of sink
if Utils.get_angle_from_coordinates(points[0], (x2, y2)) == sink.get_connector_direction(): points.reverse()
#points[0] -> source connector should not be in the direction of source
if Utils.get_angle_from_coordinates(points[0], (x1, y1)) == source.get_connector_direction(): points.reverse()
#create right-angled connector
self.add_line((x1, y1), points[0])
self.add_line((x2, y2), points[0])
def draw(self, gc, window):
"""
Draw the connection.
Args:
gc: the graphics context
window: the gtk window to draw on
"""
sink = self.get_sink()
source = self.get_source()
#check for changes
if self._sink_rot != sink.get_rotation() or self._source_rot != source.get_rotation(): self.create_shapes()
elif self._sink_coor != sink.get_coordinate() or self._source_coor != source.get_coordinate():
try:
self._update_after_move()
except:
return
#cache values
self._sink_rot = sink.get_rotation()
self._source_rot = source.get_rotation()
self._sink_coor = sink.get_coordinate()
self._source_coor = source.get_coordinate()
#draw
if self.is_highlighted(): border_color = Colors.HIGHLIGHT_COLOR
elif self.get_enabled(): border_color = Colors.CONNECTION_ENABLED_COLOR
else: border_color = Colors.CONNECTION_DISABLED_COLOR
Element.draw(self, gc, window, bg_color=None, border_color=border_color)
#draw arrow on sink port
try:
gc.set_foreground(self._arrow_color)
window.draw_polygon(gc, True, self._arrow)
except:
return
gnuradio-3.7.2.1/grc/gui/Dialogs.py 0000664 0001750 0001750 00000012001 12237027233 016612 0 ustar jcorgan jcorgan """
Copyright 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import pygtk
pygtk.require('2.0')
import gtk
import Utils
class TextDisplay(gtk.TextView):
"""A non editable gtk text view."""
def __init__(self, text=''):
"""
TextDisplay constructor.
Args:
text: the text to display (string)
"""
text_buffer = gtk.TextBuffer()
text_buffer.set_text(text)
self.set_text = text_buffer.set_text
gtk.TextView.__init__(self, text_buffer)
self.set_editable(False)
self.set_cursor_visible(False)
self.set_wrap_mode(gtk.WRAP_WORD_CHAR)
def insert(self, line):
# make backspaces work
line = self._consume_backspaces(line)
# add the remaining text to buffer
self.get_buffer().insert(self.get_buffer().get_end_iter(), line)
def _consume_backspaces(self, line):
"""removes text from the buffer if line starts with \b*"""
if not line: return
# for each \b delete one char from the buffer
back_count = 0
start_iter = self.get_buffer().get_end_iter()
while line[back_count] == '\b':
# stop at the beginning of a line
if not start_iter.starts_line(): start_iter.backward_char()
back_count += 1
# remove chars
self.get_buffer().delete(start_iter, self.get_buffer().get_end_iter())
# return remaining text
return line[back_count:]
def MessageDialogHelper(type, buttons, title=None, markup=None):
"""
Create a modal message dialog and run it.
Args:
type: the type of message: gtk.MESSAGE_INFO, gtk.MESSAGE_WARNING, gtk.MESSAGE_QUESTION or gtk.MESSAGE_ERROR
buttons: the predefined set of buttons to use:
gtk.BUTTONS_NONE, gtk.BUTTONS_OK, gtk.BUTTONS_CLOSE, gtk.BUTTONS_CANCEL, gtk.BUTTONS_YES_NO, gtk.BUTTONS_OK_CANCEL
Args:
tittle: the title of the window (string)
markup: the message text with pango markup
Returns:
the gtk response from run()
"""
message_dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL, type, buttons)
if title: message_dialog.set_title(title)
if markup: message_dialog.set_markup(markup)
response = message_dialog.run()
message_dialog.destroy()
return response
ERRORS_MARKUP_TMPL="""\
#for $i, $err_msg in enumerate($errors)
Error $i:
$encode($err_msg.replace('\t', ' '))
#end for"""
def ErrorsDialog(flowgraph): MessageDialogHelper(
type=gtk.MESSAGE_ERROR,
buttons=gtk.BUTTONS_CLOSE,
title='Flow Graph Errors',
markup=Utils.parse_template(ERRORS_MARKUP_TMPL, errors=flowgraph.get_error_messages()),
)
class AboutDialog(gtk.AboutDialog):
"""A cute little about dialog."""
def __init__(self, platform):
"""AboutDialog constructor."""
gtk.AboutDialog.__init__(self)
self.set_name(platform.get_name())
self.set_version(platform.get_version())
self.set_license(platform.get_license())
self.set_copyright(platform.get_license().splitlines()[0])
self.set_website(platform.get_website())
self.run()
self.destroy()
def HelpDialog(): MessageDialogHelper(
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_CLOSE,
title='Help',
markup="""\
Usage TipsAdd block: drag and drop or double click a block in the block selection window.
Rotate block: Select a block, press left/right on the keyboard.
Change type: Select a block, press up/down on the keyboard.
Edit parameters: double click on a block in the flow graph.
Make connection: click on the source port of one block, then click on the sink port of another block.
Remove connection: select the connection and press delete, or drag the connection.
* See the menu for other keyboard shortcuts.""")
COLORS_DIALOG_MARKUP_TMPL = """\
Color Mapping
#if $colors
#set $max_len = max([len(color[0]) for color in $colors]) + 10
#for $title, $color_spec in $colors
$($encode($title).center($max_len))
#end for
#end if
"""
def TypesDialog(platform): MessageDialogHelper(
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_CLOSE,
title='Types',
markup=Utils.parse_template(COLORS_DIALOG_MARKUP_TMPL, colors=platform.get_colors()))
gnuradio-3.7.2.1/grc/gui/Preferences.py 0000664 0001750 0001750 00000006056 12245466767 017530 0 ustar jcorgan jcorgan """
Copyright 2008 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import ConfigParser
import os
_platform = None
_config_parser = ConfigParser.ConfigParser()
def file_extension(): return '.'+_platform.get_key()
def _prefs_file(): return os.path.join(os.path.expanduser('~'), file_extension())
def load(platform):
global _platform
_platform = platform
#create sections
_config_parser.add_section('main')
_config_parser.add_section('files_open')
try: _config_parser.read(_prefs_file())
except: pass
def save():
try: _config_parser.write(open(_prefs_file(), 'w'))
except: pass
###########################################################################
# Special methods for specific program functionalities
###########################################################################
def main_window_size(size=None):
if size is not None:
_config_parser.set('main', 'main_window_width', size[0])
_config_parser.set('main', 'main_window_height', size[1])
else:
try: return (
_config_parser.getint('main', 'main_window_width'),
_config_parser.getint('main', 'main_window_height'),
)
except: return (1, 1)
def file_open(file=None):
if file is not None: _config_parser.set('main', 'file_open', file)
else:
try: return _config_parser.get('main', 'file_open')
except: return ''
def files_open(files=None):
if files is not None:
_config_parser.remove_section('files_open') #clear section
_config_parser.add_section('files_open')
for i, file in enumerate(files):
_config_parser.set('files_open', 'file_open_%d'%i, file)
else:
files = list()
i = 0
while True:
try: files.append(_config_parser.get('files_open', 'file_open_%d'%i))
except: return files
i = i + 1
def reports_window_position(pos=None):
if pos is not None: _config_parser.set('main', 'reports_window_position', pos)
else:
try: return _config_parser.getint('main', 'reports_window_position') or 1 #greater than 0
except: return -1
def blocks_window_position(pos=None):
if pos is not None: _config_parser.set('main', 'blocks_window_position', pos)
else:
try: return _config_parser.getint('main', 'blocks_window_position') or 1 #greater than 0
except: return -1
gnuradio-3.7.2.1/grc/gui/Element.py 0000664 0001750 0001750 00000021431 12207702530 016625 0 ustar jcorgan jcorgan """
Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Constants import LINE_SELECT_SENSITIVITY
from Constants import POSSIBLE_ROTATIONS
class Element(object):
"""
GraphicalElement is the base class for all graphical elements.
It contains an X,Y coordinate, a list of rectangular areas that the element occupies,
and methods to detect selection of those areas.
"""
def __init__(self):
"""
Make a new list of rectangular areas and lines, and set the coordinate and the rotation.
"""
self.set_rotation(POSSIBLE_ROTATIONS[0])
self.set_coordinate((0, 0))
self.clear()
self.set_highlighted(False)
def is_horizontal(self, rotation=None):
"""
Is this element horizontal?
If rotation is None, use this element's rotation.
Args:
rotation: the optional rotation
Returns:
true if rotation is horizontal
"""
rotation = rotation or self.get_rotation()
return rotation in (0, 180)
def is_vertical(self, rotation=None):
"""
Is this element vertical?
If rotation is None, use this element's rotation.
Args:
rotation: the optional rotation
Returns:
true if rotation is vertical
"""
rotation = rotation or self.get_rotation()
return rotation in (90, 270)
def create_labels(self):
"""
Create labels (if applicable) and call on all children.
Call this base method before creating labels in the element.
"""
for child in self.get_children():child.create_labels()
def create_shapes(self):
"""
Create shapes (if applicable) and call on all children.
Call this base method before creating shapes in the element.
"""
self.clear()
for child in self.get_children(): child.create_shapes()
def draw(self, gc, window, border_color, bg_color):
"""
Draw in the given window.
Args:
gc: the graphics context
window: the gtk window to draw on
border_color: the color for lines and rectangle borders
bg_color: the color for the inside of the rectangle
"""
X,Y = self.get_coordinate()
for (rX,rY),(W,H) in self._areas_list:
aX = X + rX
aY = Y + rY
gc.set_foreground(bg_color)
window.draw_rectangle(gc, True, aX, aY, W, H)
gc.set_foreground(border_color)
window.draw_rectangle(gc, False, aX, aY, W, H)
for (x1, y1),(x2, y2) in self._lines_list:
gc.set_foreground(border_color)
window.draw_line(gc, X+x1, Y+y1, X+x2, Y+y2)
def rotate(self, rotation):
"""
Rotate all of the areas by 90 degrees.
Args:
rotation: multiple of 90 degrees
"""
self.set_rotation((self.get_rotation() + rotation)%360)
def clear(self):
"""Empty the lines and areas."""
self._areas_list = list()
self._lines_list = list()
def set_coordinate(self, coor):
"""
Set the reference coordinate.
Args:
coor: the coordinate tuple (x,y)
"""
self.coor = coor
def get_parent(self):
"""
Get the parent of this element.
Returns:
the parent
"""
return self.parent
def set_highlighted(self, highlighted):
"""
Set the highlight status.
Args:
highlighted: true to enable highlighting
"""
self.highlighted = highlighted
def is_highlighted(self):
"""
Get the highlight status.
Returns:
true if highlighted
"""
return self.highlighted
def get_coordinate(self):
"""Get the coordinate.
Returns:
the coordinate tuple (x,y)
"""
return self.coor
def move(self, delta_coor):
"""
Move the element by adding the delta_coor to the current coordinate.
Args:
delta_coor: (delta_x,delta_y) tuple
"""
deltaX, deltaY = delta_coor
X, Y = self.get_coordinate()
self.set_coordinate((X+deltaX, Y+deltaY))
def add_area(self, rel_coor, area):
"""
Add an area to the area list.
An area is actually a coordinate relative to the main coordinate
with a width/height pair relative to the area coordinate.
A positive width is to the right of the coordinate.
A positive height is above the coordinate.
The area is associated with a rotation.
Args:
rel_coor: (x,y) offset from this element's coordinate
area: (width,height) tuple
"""
self._areas_list.append((rel_coor, area))
def add_line(self, rel_coor1, rel_coor2):
"""
Add a line to the line list.
A line is defined by 2 relative coordinates.
Lines must be horizontal or vertical.
The line is associated with a rotation.
Args:
rel_coor1: relative (x1,y1) tuple
rel_coor2: relative (x2,y2) tuple
"""
self._lines_list.append((rel_coor1, rel_coor2))
def what_is_selected(self, coor, coor_m=None):
"""
One coordinate specified:
Is this element selected at given coordinate?
ie: is the coordinate encompassed by one of the areas or lines?
Both coordinates specified:
Is this element within the rectangular region defined by both coordinates?
ie: do any area corners or line endpoints fall within the region?
Args:
coor: the selection coordinate, tuple x, y
coor_m: an additional selection coordinate.
Returns:
self if one of the areas/lines encompasses coor, else None.
"""
#function to test if p is between a and b (inclusive)
in_between = lambda p, a, b: p >= min(a, b) and p <= max(a, b)
#relative coordinate
x, y = [a-b for a,b in zip(coor, self.get_coordinate())]
if coor_m:
x_m, y_m = [a-b for a,b in zip(coor_m, self.get_coordinate())]
#handle rectangular areas
for (x1,y1), (w,h) in self._areas_list:
if in_between(x1, x, x_m) and in_between(y1, y, y_m) or \
in_between(x1+w, x, x_m) and in_between(y1, y, y_m) or \
in_between(x1, x, x_m) and in_between(y1+h, y, y_m) or \
in_between(x1+w, x, x_m) and in_between(y1+h, y, y_m):
return self
#handle horizontal or vertical lines
for (x1, y1), (x2, y2) in self._lines_list:
if in_between(x1, x, x_m) and in_between(y1, y, y_m) or \
in_between(x2, x, x_m) and in_between(y2, y, y_m):
return self
return None
else:
#handle rectangular areas
for (x1,y1), (w,h) in self._areas_list:
if in_between(x, x1, x1+w) and in_between(y, y1, y1+h): return self
#handle horizontal or vertical lines
for (x1, y1), (x2, y2) in self._lines_list:
if x1 == x2: x1, x2 = x1-LINE_SELECT_SENSITIVITY, x2+LINE_SELECT_SENSITIVITY
if y1 == y2: y1, y2 = y1-LINE_SELECT_SENSITIVITY, y2+LINE_SELECT_SENSITIVITY
if in_between(x, x1, x2) and in_between(y, y1, y2): return self
return None
def get_rotation(self):
"""
Get the rotation in degrees.
Returns:
the rotation
"""
return self.rotation
def set_rotation(self, rotation):
"""
Set the rotation in degrees.
Args:
rotation: the rotation"""
if rotation not in POSSIBLE_ROTATIONS:
raise Exception('"%s" is not one of the possible rotations: (%s)'%(rotation, POSSIBLE_ROTATIONS))
self.rotation = rotation
gnuradio-3.7.2.1/grc/gui/FlowGraph.py 0000664 0001750 0001750 00000054540 12237515112 017135 0 ustar jcorgan jcorgan """
Copyright 2007-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Constants import SCROLL_PROXIMITY_SENSITIVITY, SCROLL_DISTANCE
import Actions
import Colors
import Utils
from Element import Element
import pygtk
pygtk.require('2.0')
import gtk
import random
import Messages
class FlowGraph(Element):
"""
FlowGraph is the data structure to store graphical signal blocks,
graphical inputs and outputs,
and the connections between inputs and outputs.
"""
def __init__(self):
"""
FlowGraph contructor.
Create a list for signal blocks and connections. Connect mouse handlers.
"""
Element.__init__(self)
#when is the flow graph selected? (used by keyboard event handler)
self.is_selected = lambda: bool(self.get_selected_elements())
#important vars dealing with mouse event tracking
self.element_moved = False
self.mouse_pressed = False
self.unselect()
self.press_coor = (0, 0)
#selected ports
self._old_selected_port = None
self._new_selected_port = None
#context menu
self._context_menu = gtk.Menu()
for action in [
Actions.BLOCK_CUT,
Actions.BLOCK_COPY,
Actions.BLOCK_PASTE,
Actions.ELEMENT_DELETE,
None,
Actions.BLOCK_ROTATE_CCW,
Actions.BLOCK_ROTATE_CW,
Actions.BLOCK_ENABLE,
Actions.BLOCK_DISABLE,
None,
Actions.BLOCK_CREATE_HIER,
Actions.OPEN_HIER,
Actions.BUSSIFY_SOURCES,
Actions.BUSSIFY_SINKS,
None,
Actions.BLOCK_PARAM_MODIFY
]: self._context_menu.append(action.create_menu_item() if action else gtk.SeparatorMenuItem())
self.get_context_menu = lambda: self._context_menu
###########################################################################
# Access Drawing Area
###########################################################################
def get_drawing_area(self): return self.drawing_area
def queue_draw(self): self.get_drawing_area().queue_draw()
def get_size(self): return self.get_drawing_area().get_size_request()
def set_size(self, *args): self.get_drawing_area().set_size_request(*args)
def get_scroll_pane(self): return self.drawing_area.get_parent()
def get_ctrl_mask(self): return self.drawing_area.ctrl_mask
def new_pixmap(self, *args): return self.get_drawing_area().new_pixmap(*args)
def add_new_block(self, key, coor=None):
"""
Add a block of the given key to this flow graph.
Args:
key: the block key
coor: an optional coordinate or None for random
"""
id = self._get_unique_id(key)
#calculate the position coordinate
h_adj = self.get_scroll_pane().get_hadjustment()
v_adj = self.get_scroll_pane().get_vadjustment()
if coor is None: coor = (
int(random.uniform(.25, .75)*h_adj.page_size + h_adj.get_value()),
int(random.uniform(.25, .75)*v_adj.page_size + v_adj.get_value()),
)
#get the new block
block = self.get_new_block(key)
block.set_coordinate(coor)
block.set_rotation(0)
block.get_param('id').set_value(id)
Actions.ELEMENT_CREATE()
return id
###########################################################################
# Copy Paste
###########################################################################
def copy_to_clipboard(self):
"""
Copy the selected blocks and connections into the clipboard.
Returns:
the clipboard
"""
#get selected blocks
blocks = self.get_selected_blocks()
if not blocks: return None
#calc x and y min
x_min, y_min = blocks[0].get_coordinate()
for block in blocks:
x, y = block.get_coordinate()
x_min = min(x, x_min)
y_min = min(y, y_min)
#get connections between selected blocks
connections = filter(
lambda c: c.get_source().get_parent() in blocks and c.get_sink().get_parent() in blocks,
self.get_connections(),
)
clipboard = (
(x_min, y_min),
[block.export_data() for block in blocks],
[connection.export_data() for connection in connections],
)
return clipboard
def paste_from_clipboard(self, clipboard):
"""
Paste the blocks and connections from the clipboard.
Args:
clipboard: the nested data of blocks, connections
"""
selected = set()
(x_min, y_min), blocks_n, connections_n = clipboard
old_id2block = dict()
#recalc the position
h_adj = self.get_scroll_pane().get_hadjustment()
v_adj = self.get_scroll_pane().get_vadjustment()
x_off = h_adj.get_value() - x_min + h_adj.page_size/4
y_off = v_adj.get_value() - y_min + v_adj.page_size/4
#create blocks
for block_n in blocks_n:
block_key = block_n.find('key')
if block_key == 'options': continue
block = self.get_new_block(block_key)
selected.add(block)
#set params
params_n = block_n.findall('param')
for param_n in params_n:
param_key = param_n.find('key')
param_value = param_n.find('value')
#setup id parameter
if param_key == 'id':
old_id2block[param_value] = block
#if the block id is not unique, get a new block id
if param_value in [bluck.get_id() for bluck in self.get_blocks()]:
param_value = self._get_unique_id(param_value)
#set value to key
block.get_param(param_key).set_value(param_value)
#move block to offset coordinate
block.move((x_off, y_off))
#update before creating connections
self.update()
#create connections
for connection_n in connections_n:
source = old_id2block[connection_n.find('source_block_id')].get_source(connection_n.find('source_key'))
sink = old_id2block[connection_n.find('sink_block_id')].get_sink(connection_n.find('sink_key'))
self.connect(source, sink)
#set all pasted elements selected
for block in selected: selected = selected.union(set(block.get_connections()))
self._selected_elements = list(selected)
###########################################################################
# Modify Selected
###########################################################################
def type_controller_modify_selected(self, direction):
"""
Change the registered type controller for the selected signal blocks.
Args:
direction: +1 or -1
Returns:
true for change
"""
return any([sb.type_controller_modify(direction) for sb in self.get_selected_blocks()])
def port_controller_modify_selected(self, direction):
"""
Change port controller for the selected signal blocks.
Args:
direction: +1 or -1
Returns:
true for changed
"""
return any([sb.port_controller_modify(direction) for sb in self.get_selected_blocks()])
def enable_selected(self, enable):
"""
Enable/disable the selected blocks.
Args:
enable: true to enable
Returns:
true if changed
"""
changed = False
for selected_block in self.get_selected_blocks():
if selected_block.get_enabled() != enable:
selected_block.set_enabled(enable)
changed = True
return changed
def move_selected(self, delta_coordinate):
"""
Move the element and by the change in coordinates.
Args:
delta_coordinate: the change in coordinates
"""
for selected_block in self.get_selected_blocks():
selected_block.move(delta_coordinate)
self.element_moved = True
def rotate_selected(self, rotation):
"""
Rotate the selected blocks by multiples of 90 degrees.
Args:
rotation: the rotation in degrees
Returns:
true if changed, otherwise false.
"""
if not self.get_selected_blocks(): return False
#initialize min and max coordinates
min_x, min_y = self.get_selected_block().get_coordinate()
max_x, max_y = self.get_selected_block().get_coordinate()
#rotate each selected block, and find min/max coordinate
for selected_block in self.get_selected_blocks():
selected_block.rotate(rotation)
#update the min/max coordinate
x, y = selected_block.get_coordinate()
min_x, min_y = min(min_x, x), min(min_y, y)
max_x, max_y = max(max_x, x), max(max_y, y)
#calculate center point of slected blocks
ctr_x, ctr_y = (max_x + min_x)/2, (max_y + min_y)/2
#rotate the blocks around the center point
for selected_block in self.get_selected_blocks():
x, y = selected_block.get_coordinate()
x, y = Utils.get_rotated_coordinate((x - ctr_x, y - ctr_y), rotation)
selected_block.set_coordinate((x + ctr_x, y + ctr_y))
return True
def remove_selected(self):
"""
Remove selected elements
Returns:
true if changed.
"""
changed = False
for selected_element in self.get_selected_elements():
self.remove_element(selected_element)
changed = True
return changed
def draw(self, gc, window):
"""
Draw the background and grid if enabled.
Draw all of the elements in this flow graph onto the pixmap.
Draw the pixmap to the drawable window of this flow graph.
"""
W,H = self.get_size()
#draw the background
gc.set_foreground(Colors.FLOWGRAPH_BACKGROUND_COLOR)
window.draw_rectangle(gc, True, 0, 0, W, H)
#draw multi select rectangle
if self.mouse_pressed and (not self.get_selected_elements() or self.get_ctrl_mask()):
#coordinates
x1, y1 = self.press_coor
x2, y2 = self.get_coordinate()
#calculate top-left coordinate and width/height
x, y = int(min(x1, x2)), int(min(y1, y2))
w, h = int(abs(x1 - x2)), int(abs(y1 - y2))
#draw
gc.set_foreground(Colors.HIGHLIGHT_COLOR)
window.draw_rectangle(gc, True, x, y, w, h)
gc.set_foreground(Colors.BORDER_COLOR)
window.draw_rectangle(gc, False, x, y, w, h)
#draw blocks on top of connections
for element in self.get_connections() + self.get_blocks():
element.draw(gc, window)
#draw selected blocks on top of selected connections
for selected_element in self.get_selected_connections() + self.get_selected_blocks():
selected_element.draw(gc, window)
def update_selected(self):
"""
Remove deleted elements from the selected elements list.
Update highlighting so only the selected are highlighted.
"""
selected_elements = self.get_selected_elements()
elements = self.get_elements()
#remove deleted elements
for selected in selected_elements:
if selected in elements: continue
selected_elements.remove(selected)
if self._old_selected_port and self._old_selected_port.get_parent() not in elements:
self._old_selected_port = None
if self._new_selected_port and self._new_selected_port.get_parent() not in elements:
self._new_selected_port = None
#update highlighting
for element in elements:
element.set_highlighted(element in selected_elements)
def update(self):
"""
Call the top level rewrite and validate.
Call the top level create labels and shapes.
"""
self.rewrite()
self.validate()
self.create_labels()
self.create_shapes()
##########################################################################
## Get Selected
##########################################################################
def unselect(self):
"""
Set selected elements to an empty set.
"""
self._selected_elements = []
def what_is_selected(self, coor, coor_m=None):
"""
What is selected?
At the given coordinate, return the elements found to be selected.
If coor_m is unspecified, return a list of only the first element found to be selected:
Iterate though the elements backwards since top elements are at the end of the list.
If an element is selected, place it at the end of the list so that is is drawn last,
and hence on top. Update the selected port information.
Args:
coor: the coordinate of the mouse click
coor_m: the coordinate for multi select
Returns:
the selected blocks and connections or an empty list
"""
selected_port = None
selected = set()
#check the elements
for element in reversed(self.get_elements()):
selected_element = element.what_is_selected(coor, coor_m)
if not selected_element: continue
#update the selected port information
if selected_element.is_port():
if not coor_m: selected_port = selected_element
selected_element = selected_element.get_parent()
selected.add(selected_element)
#place at the end of the list
self.get_elements().remove(element)
self.get_elements().append(element)
#single select mode, break
if not coor_m: break
#update selected ports
self._old_selected_port = self._new_selected_port
self._new_selected_port = selected_port
return list(selected)
def get_selected_connections(self):
"""
Get a group of selected connections.
Returns:
sub set of connections in this flow graph
"""
selected = set()
for selected_element in self.get_selected_elements():
if selected_element.is_connection(): selected.add(selected_element)
return list(selected)
def get_selected_blocks(self):
"""
Get a group of selected blocks.
Returns:
sub set of blocks in this flow graph
"""
selected = set()
for selected_element in self.get_selected_elements():
if selected_element.is_block(): selected.add(selected_element)
return list(selected)
def get_selected_block(self):
"""
Get the selected block when a block or port is selected.
Returns:
a block or None
"""
return self.get_selected_blocks() and self.get_selected_blocks()[0] or None
def get_selected_elements(self):
"""
Get the group of selected elements.
Returns:
sub set of elements in this flow graph
"""
return self._selected_elements
def get_selected_element(self):
"""
Get the selected element.
Returns:
a block, port, or connection or None
"""
return self.get_selected_elements() and self.get_selected_elements()[0] or None
def update_selected_elements(self):
"""
Update the selected elements.
The update behavior depends on the state of the mouse button.
When the mouse button pressed the selection will change when
the control mask is set or the new selection is not in the current group.
When the mouse button is released the selection will change when
the mouse has moved and the control mask is set or the current group is empty.
Attempt to make a new connection if the old and ports are filled.
If the control mask is set, merge with the current elements.
"""
selected_elements = None
if self.mouse_pressed:
new_selections = self.what_is_selected(self.get_coordinate())
#update the selections if the new selection is not in the current selections
#allows us to move entire selected groups of elements
if self.get_ctrl_mask() or not (
new_selections and new_selections[0] in self.get_selected_elements()
): selected_elements = new_selections
else: #called from a mouse release
if not self.element_moved and (not self.get_selected_elements() or self.get_ctrl_mask()):
selected_elements = self.what_is_selected(self.get_coordinate(), self.press_coor)
#this selection and the last were ports, try to connect them
if self._old_selected_port and self._new_selected_port and \
self._old_selected_port is not self._new_selected_port:
try:
self.connect(self._old_selected_port, self._new_selected_port)
Actions.ELEMENT_CREATE()
except: Messages.send_fail_connection()
self._old_selected_port = None
self._new_selected_port = None
return
#update selected elements
if selected_elements is None: return
old_elements = set(self.get_selected_elements())
self._selected_elements = list(set(selected_elements))
new_elements = set(self.get_selected_elements())
#if ctrl, set the selected elements to the union - intersection of old and new
if self.get_ctrl_mask():
self._selected_elements = list(
set.union(old_elements, new_elements) - set.intersection(old_elements, new_elements)
)
Actions.ELEMENT_SELECT()
##########################################################################
## Event Handlers
##########################################################################
def handle_mouse_context_press(self, coordinate, event):
"""
The context mouse button was pressed:
If no elements were selected, perform re-selection at this coordinate.
Then, show the context menu at the mouse click location.
"""
selections = self.what_is_selected(coordinate)
if not set(selections).intersection(self.get_selected_elements()):
self.set_coordinate(coordinate)
self.mouse_pressed = True
self.update_selected_elements()
self.mouse_pressed = False
self._context_menu.popup(None, None, None, event.button, event.time)
def handle_mouse_selector_press(self, double_click, coordinate):
"""
The selector mouse button was pressed:
Find the selected element. Attempt a new connection if possible.
Open the block params window on a double click.
Update the selection state of the flow graph.
"""
self.press_coor = coordinate
self.set_coordinate(coordinate)
self.time = 0
self.mouse_pressed = True
if double_click: self.unselect()
self.update_selected_elements()
#double click detected, bring up params dialog if possible
if double_click and self.get_selected_block():
self.mouse_pressed = False
Actions.BLOCK_PARAM_MODIFY()
def handle_mouse_selector_release(self, coordinate):
"""
The selector mouse button was released:
Update the state, handle motion (dragging).
And update the selected flowgraph elements.
"""
self.set_coordinate(coordinate)
self.time = 0
self.mouse_pressed = False
if self.element_moved:
Actions.BLOCK_MOVE()
self.element_moved = False
self.update_selected_elements()
def handle_mouse_motion(self, coordinate):
"""
The mouse has moved, respond to mouse dragging.
Move a selected element to the new coordinate.
Auto-scroll the scroll bars at the boundaries.
"""
#to perform a movement, the mouse must be pressed
# (no longer checking pending events via gtk.events_pending() - always true in Windows)
if not self.mouse_pressed: return
#perform autoscrolling
width, height = self.get_size()
x, y = coordinate
h_adj = self.get_scroll_pane().get_hadjustment()
v_adj = self.get_scroll_pane().get_vadjustment()
for pos, length, adj, adj_val, adj_len in (
(x, width, h_adj, h_adj.get_value(), h_adj.page_size),
(y, height, v_adj, v_adj.get_value(), v_adj.page_size),
):
#scroll if we moved near the border
if pos-adj_val > adj_len-SCROLL_PROXIMITY_SENSITIVITY and adj_val+SCROLL_DISTANCE < length-adj_len:
adj.set_value(adj_val+SCROLL_DISTANCE)
adj.emit('changed')
elif pos-adj_val < SCROLL_PROXIMITY_SENSITIVITY:
adj.set_value(adj_val-SCROLL_DISTANCE)
adj.emit('changed')
#remove the connection if selected in drag event
if len(self.get_selected_elements()) == 1 and self.get_selected_element().is_connection():
Actions.ELEMENT_DELETE()
#move the selected elements and record the new coordinate
X, Y = self.get_coordinate()
if not self.get_ctrl_mask(): self.move_selected((int(x - X), int(y - Y)))
self.set_coordinate((x, y))
#queue draw for animation
self.queue_draw()
gnuradio-3.7.2.1/grc/gui/Colors.py 0000664 0001750 0001750 00000003151 12207440367 016503 0 ustar jcorgan jcorgan """
Copyright 2008,2013 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
try:
import pygtk
pygtk.require('2.0')
import gtk
_COLORMAP = gtk.gdk.colormap_get_system() #create all of the colors
def get_color(color_code): return _COLORMAP.alloc_color(color_code, True, True)
HIGHLIGHT_COLOR = get_color('#00FFFF')
BORDER_COLOR = get_color('black')
#param entry boxes
PARAM_ENTRY_TEXT_COLOR = get_color('black')
ENTRYENUM_CUSTOM_COLOR = get_color('#EEEEEE')
#flow graph color constants
FLOWGRAPH_BACKGROUND_COLOR = get_color('#FFF9FF')
#block color constants
BLOCK_ENABLED_COLOR = get_color('#F1ECFF')
BLOCK_DISABLED_COLOR = get_color('#CCCCCC')
#connection color constants
CONNECTION_ENABLED_COLOR = get_color('black')
CONNECTION_DISABLED_COLOR = get_color('#999999')
CONNECTION_ERROR_COLOR = get_color('red')
except:
print 'Unable to import Colors'
gnuradio-3.7.2.1/grc/gui/__init__.py 0000644 0001750 0001750 00000000001 11700377701 016764 0 ustar jcorgan jcorgan
gnuradio-3.7.2.1/grc/gui/ActionHandler.py 0000664 0001750 0001750 00000070013 12245466767 017774 0 ustar jcorgan jcorgan """
Copyright 2007-2011 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
import os
import signal
from Constants import IMAGE_FILE_EXTENSION
import Actions
import pygtk
pygtk.require('2.0')
import gtk
import gobject
import Preferences
from threading import Thread
import Messages
from .. base import ParseXML
from MainWindow import MainWindow
from PropsDialog import PropsDialog
import Dialogs
from FileDialogs import OpenFlowGraphFileDialog, SaveFlowGraphFileDialog, SaveImageFileDialog
gobject.threads_init()
class ActionHandler:
"""
The action handler will setup all the major window components,
and handle button presses and flow graph operations from the GUI.
"""
def __init__(self, file_paths, platform):
"""
ActionHandler constructor.
Create the main window, setup the message handler, import the preferences,
and connect all of the action handlers. Finally, enter the gtk main loop and block.
Args:
file_paths: a list of flow graph file passed from command line
platform: platform module
"""
self.clipboard = None
for action in Actions.get_all_actions(): action.connect('activate', self._handle_action)
#setup the main window
self.platform = platform;
self.main_window = MainWindow(platform)
self.main_window.connect('delete-event', self._quit)
self.main_window.connect('key-press-event', self._handle_key_press)
self.get_page = self.main_window.get_page
self.get_flow_graph = self.main_window.get_flow_graph
self.get_focus_flag = self.main_window.get_focus_flag
#setup the messages
Messages.register_messenger(self.main_window.add_report_line)
Messages.send_init(platform)
#initialize
self.init_file_paths = file_paths
Actions.APPLICATION_INITIALIZE()
#enter the mainloop
gtk.main()
def _handle_key_press(self, widget, event):
"""
Handle key presses from the keyboard and translate key combinations into actions.
This key press handler is called prior to the gtk key press handler.
This handler bypasses built in accelerator key handling when in focus because
* some keys are ignored by the accelerators like the direction keys,
* some keys are not registered to any accelerators but are still used.
When not in focus, gtk and the accelerators handle the the key press.
Returns:
false to let gtk handle the key action
"""
# prevent key event stealing while the search box is active
if self.main_window.btwin.search_entry.has_focus(): return False
if not self.get_focus_flag(): return False
return Actions.handle_key_press(event)
def _quit(self, window, event):
"""
Handle the delete event from the main window.
Generated by pressing X to close, alt+f4, or right click+close.
This method in turns calls the state handler to quit.
Returns:
true
"""
Actions.APPLICATION_QUIT()
return True
def _handle_action(self, action):
#print action
##################################################
# Initalize/Quit
##################################################
if action == Actions.APPLICATION_INITIALIZE:
for action in Actions.get_all_actions(): action.set_sensitive(False) #set all actions disabled
#enable a select few actions
for action in (
Actions.APPLICATION_QUIT, Actions.FLOW_GRAPH_NEW,
Actions.FLOW_GRAPH_OPEN, Actions.FLOW_GRAPH_SAVE_AS,
Actions.FLOW_GRAPH_CLOSE, Actions.ABOUT_WINDOW_DISPLAY,
Actions.FLOW_GRAPH_SCREEN_CAPTURE, Actions.HELP_WINDOW_DISPLAY,
Actions.TYPES_WINDOW_DISPLAY,
): action.set_sensitive(True)
if not self.init_file_paths:
self.init_file_paths = Preferences.files_open()
if not self.init_file_paths: self.init_file_paths = ['']
for file_path in self.init_file_paths:
if file_path: self.main_window.new_page(file_path) #load pages from file paths
if Preferences.file_open() in self.init_file_paths:
self.main_window.new_page(Preferences.file_open(), show=True)
if not self.get_page(): self.main_window.new_page() #ensure that at least a blank page exists
self.main_window.btwin.search_entry.hide()
elif action == Actions.APPLICATION_QUIT:
if self.main_window.close_pages():
gtk.main_quit()
exit(0)
##################################################
# Selections
##################################################
elif action == Actions.ELEMENT_SELECT:
pass #do nothing, update routines below
elif action == Actions.NOTHING_SELECT:
self.get_flow_graph().unselect()
##################################################
# Enable/Disable
##################################################
elif action == Actions.BLOCK_ENABLE:
if self.get_flow_graph().enable_selected(True):
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
elif action == Actions.BLOCK_DISABLE:
if self.get_flow_graph().enable_selected(False):
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
##################################################
# Cut/Copy/Paste
##################################################
elif action == Actions.BLOCK_CUT:
Actions.BLOCK_COPY()
Actions.ELEMENT_DELETE()
elif action == Actions.BLOCK_COPY:
self.clipboard = self.get_flow_graph().copy_to_clipboard()
elif action == Actions.BLOCK_PASTE:
if self.clipboard:
self.get_flow_graph().paste_from_clipboard(self.clipboard)
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
##################################################
# Create heir block
##################################################
elif action == Actions.BLOCK_CREATE_HIER:
# keeping track of coordinates for pasting later
coords = self.get_flow_graph().get_selected_blocks()[0].get_coordinate()
x,y = coords
x_min = x
y_min = y
pads = [];
params = [];
# Save the state of the leaf blocks
for block in self.get_flow_graph().get_selected_blocks():
# Check for string variables within the blocks
for param in block.get_params():
for variable in self.get_flow_graph().get_variables():
# If a block parameter exists that is a variable, create a parameter for it
if param.get_value() == variable.get_id():
params.append(param.get_value())
for flow_param in self.get_flow_graph().get_parameters():
# If a block parameter exists that is a parameter, create a parameter for it
if param.get_value() == flow_param.get_id():
params.append(param.get_value())
# keep track of x,y mins for pasting later
(x,y) = block.get_coordinate()
if x < x_min:
x_min = x
if y < y_min:
y_min = y
for connection in block.get_connections():
# Get id of connected blocks
source_id = connection.get_source().get_parent().get_id()
sink_id = connection.get_sink().get_parent().get_id()
# If connected block is not in the list of selected blocks create a pad for it
if self.get_flow_graph().get_block(source_id) not in self.get_flow_graph().get_selected_blocks():
pads.append({'key': connection.get_sink().get_key(), 'coord': connection.get_source().get_coordinate(), 'block_id' : block.get_id(), 'direction': 'source'})
if self.get_flow_graph().get_block(sink_id) not in self.get_flow_graph().get_selected_blocks():
pads.append({'key': connection.get_source().get_key(), 'coord': connection.get_sink().get_coordinate(), 'block_id' : block.get_id(), 'direction': 'sink'})
# Copy the selected blocks and paste them into a new page
# then move the flowgraph to a reasonable position
Actions.BLOCK_COPY()
self.main_window.new_page()
Actions.BLOCK_PASTE()
coords = (x_min,y_min)
self.get_flow_graph().move_selected(coords)
# Set flow graph to heir block type
top_block = self.get_flow_graph().get_block("top_block")
top_block.get_param('generate_options').set_value('hb')
# this needs to be a unique name
top_block.get_param('id').set_value('new_heir')
# Remove the default samp_rate variable block that is created
remove_me = self.get_flow_graph().get_block("samp_rate")
self.get_flow_graph().remove_element(remove_me)
# Add the param blocks along the top of the window
x_pos = 150
for param in params:
param_id = self.get_flow_graph().add_new_block('parameter',(x_pos,10))
param_block = self.get_flow_graph().get_block(param_id)
param_block.get_param('id').set_value(param)
x_pos = x_pos + 100
for pad in pads:
# Add the pad sources and sinks within the new heir block
if pad['direction'] == 'sink':
# Add new PAD_SINK block to the canvas
pad_id = self.get_flow_graph().add_new_block('pad_sink', pad['coord'])
# setup the references to the sink and source
pad_block = self.get_flow_graph().get_block(pad_id)
pad_sink = pad_block.get_sinks()[0]
source_block = self.get_flow_graph().get_block(pad['block_id'])
source = source_block.get_source(pad['key'])
# Ensure the port types match
while pad_sink.get_type() != source.get_type():
# Special case for some blocks that have non-standard type names, e.g. uhd
if pad_sink.get_type() == 'complex' and source.get_type() == 'fc32':
break;
pad_block.type_controller_modify(1)
# Connect the pad to the proper sinks
new_connection = self.get_flow_graph().connect(source,pad_sink)
elif pad['direction'] == 'source':
pad_id = self.get_flow_graph().add_new_block('pad_source', pad['coord'])
# setup the references to the sink and source
pad_block = self.get_flow_graph().get_block(pad_id)
pad_source = pad_block.get_sources()[0]
sink_block = self.get_flow_graph().get_block(pad['block_id'])
sink = sink_block.get_sink(pad['key'])
# Ensure the port types match
while sink.get_type() != pad_source.get_type():
# Special case for some blocks that have non-standard type names, e.g. uhd
if pad_source.get_type() == 'complex' and sink.get_type() == 'fc32':
break;
pad_block.type_controller_modify(1)
# Connect the pad to the proper sinks
new_connection = self.get_flow_graph().connect(pad_source,sink)
# update the new heir block flow graph
self.get_flow_graph().update()
##################################################
# Move/Rotate/Delete/Create
##################################################
elif action == Actions.BLOCK_MOVE:
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
elif action == Actions.BLOCK_ROTATE_CCW:
if self.get_flow_graph().rotate_selected(90):
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
elif action == Actions.BLOCK_ROTATE_CW:
if self.get_flow_graph().rotate_selected(-90):
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
elif action == Actions.ELEMENT_DELETE:
if self.get_flow_graph().remove_selected():
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
Actions.NOTHING_SELECT()
self.get_page().set_saved(False)
elif action == Actions.ELEMENT_CREATE:
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
Actions.NOTHING_SELECT()
self.get_page().set_saved(False)
elif action == Actions.BLOCK_INC_TYPE:
if self.get_flow_graph().type_controller_modify_selected(1):
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
elif action == Actions.BLOCK_DEC_TYPE:
if self.get_flow_graph().type_controller_modify_selected(-1):
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
elif action == Actions.PORT_CONTROLLER_INC:
if self.get_flow_graph().port_controller_modify_selected(1):
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
elif action == Actions.PORT_CONTROLLER_DEC:
if self.get_flow_graph().port_controller_modify_selected(-1):
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
##################################################
# Window stuff
##################################################
elif action == Actions.ABOUT_WINDOW_DISPLAY:
Dialogs.AboutDialog(self.get_flow_graph().get_parent())
elif action == Actions.HELP_WINDOW_DISPLAY:
Dialogs.HelpDialog()
elif action == Actions.TYPES_WINDOW_DISPLAY:
Dialogs.TypesDialog(self.get_flow_graph().get_parent())
elif action == Actions.ERRORS_WINDOW_DISPLAY:
Dialogs.ErrorsDialog(self.get_flow_graph())
##################################################
# Param Modifications
##################################################
elif action == Actions.BLOCK_PARAM_MODIFY:
selected_block = self.get_flow_graph().get_selected_block()
if selected_block:
if PropsDialog(selected_block).run():
#save the new state
self.get_flow_graph().update()
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())
self.get_page().set_saved(False)
else:
#restore the current state
n = self.get_page().get_state_cache().get_current_state()
self.get_flow_graph().import_data(n)
self.get_flow_graph().update()
##################################################
# Undo/Redo
##################################################
elif action == Actions.FLOW_GRAPH_UNDO:
n = self.get_page().get_state_cache().get_prev_state()
if n:
self.get_flow_graph().unselect()
self.get_flow_graph().import_data(n)
self.get_flow_graph().update()
self.get_page().set_saved(False)
elif action == Actions.FLOW_GRAPH_REDO:
n = self.get_page().get_state_cache().get_next_state()
if n:
self.get_flow_graph().unselect()
self.get_flow_graph().import_data(n)
self.get_flow_graph().update()
self.get_page().set_saved(False)
##################################################
# New/Open/Save/Close
##################################################
elif action == Actions.FLOW_GRAPH_NEW:
self.main_window.new_page()
elif action == Actions.FLOW_GRAPH_OPEN:
file_paths = OpenFlowGraphFileDialog(self.get_page().get_file_path()).run()
if file_paths: #open a new page for each file, show only the first
for i,file_path in enumerate(file_paths):
self.main_window.new_page(file_path, show=(i==0))
elif action == Actions.FLOW_GRAPH_CLOSE:
self.main_window.close_page()
elif action == Actions.FLOW_GRAPH_SAVE:
#read-only or undefined file path, do save-as
if self.get_page().get_read_only() or not self.get_page().get_file_path():
Actions.FLOW_GRAPH_SAVE_AS()
#otherwise try to save
else:
try:
ParseXML.to_file(self.get_flow_graph().export_data(), self.get_page().get_file_path())
self.get_flow_graph().grc_file_path = self.get_page().get_file_path()
self.get_page().set_saved(True)
except IOError:
Messages.send_fail_save(self.get_page().get_file_path())
self.get_page().set_saved(False)
elif action == Actions.FLOW_GRAPH_SAVE_AS:
file_path = SaveFlowGraphFileDialog(self.get_page().get_file_path()).run()
if file_path is not None:
self.get_page().set_file_path(file_path)
Actions.FLOW_GRAPH_SAVE()
elif action == Actions.FLOW_GRAPH_SCREEN_CAPTURE:
file_path = SaveImageFileDialog(self.get_page().get_file_path()).run()
if file_path is not None:
pixbuf = self.get_flow_graph().get_drawing_area().get_pixbuf()
pixbuf.save(file_path, IMAGE_FILE_EXTENSION[1:])
##################################################
# Gen/Exec/Stop
##################################################
elif action == Actions.FLOW_GRAPH_GEN:
if not self.get_page().get_proc():
if not self.get_page().get_saved() or not self.get_page().get_file_path():
Actions.FLOW_GRAPH_SAVE() #only save if file path missing or not saved
if self.get_page().get_saved() and self.get_page().get_file_path():
generator = self.get_page().get_generator()
try:
Messages.send_start_gen(generator.get_file_path())
generator.write()
except Exception,e: Messages.send_fail_gen(e)
else: self.generator = None
elif action == Actions.FLOW_GRAPH_EXEC:
if not self.get_page().get_proc():
Actions.FLOW_GRAPH_GEN()
if self.get_page().get_saved() and self.get_page().get_file_path():
ExecFlowGraphThread(self)
elif action == Actions.FLOW_GRAPH_KILL:
if self.get_page().get_proc():
try: self.get_page().get_proc().kill()
except: print "could not kill process: %d"%self.get_page().get_proc().pid
elif action == Actions.PAGE_CHANGE: #pass and run the global actions
pass
elif action == Actions.RELOAD_BLOCKS:
self.platform.loadblocks()
self.main_window.btwin.clear();
self.platform.load_block_tree(self.main_window.btwin);
elif action == Actions.FIND_BLOCKS:
self.main_window.btwin.search_entry.show()
self.main_window.set_focus(self.main_window.btwin.search_entry)
elif action == Actions.OPEN_HIER:
bn = [];
for b in self.get_flow_graph().get_selected_blocks():
if b._grc_source:
self.main_window.new_page(b._grc_source, show=True);
elif action == Actions.BUSSIFY_SOURCES:
n = {'name':'bus', 'type':'bus'}
for b in self.get_flow_graph().get_selected_blocks():
b.bussify(n, 'source');
self.get_flow_graph()._old_selected_port = None;
self.get_flow_graph()._new_selected_port = None;
Actions.ELEMENT_CREATE();
elif action == Actions.BUSSIFY_SINKS:
n = {'name':'bus', 'type':'bus'}
for b in self.get_flow_graph().get_selected_blocks():
b.bussify(n, 'sink')
self.get_flow_graph()._old_selected_port = None;
self.get_flow_graph()._new_selected_port = None;
Actions.ELEMENT_CREATE();
else: print '!!! Action "%s" not handled !!!'%action
##################################################
# Global Actions for all States
##################################################
#update general buttons
Actions.ERRORS_WINDOW_DISPLAY.set_sensitive(not self.get_flow_graph().is_valid())
Actions.ELEMENT_DELETE.set_sensitive(bool(self.get_flow_graph().get_selected_elements()))
Actions.BLOCK_PARAM_MODIFY.set_sensitive(bool(self.get_flow_graph().get_selected_block()))
Actions.BLOCK_ROTATE_CCW.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))
Actions.BLOCK_ROTATE_CW.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))
#update cut/copy/paste
Actions.BLOCK_CUT.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))
Actions.BLOCK_COPY.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))
Actions.BLOCK_PASTE.set_sensitive(bool(self.clipboard))
#update enable/disable
Actions.BLOCK_ENABLE.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))
Actions.BLOCK_DISABLE.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))
Actions.BLOCK_CREATE_HIER.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))
Actions.OPEN_HIER.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))
Actions.BUSSIFY_SOURCES.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))
Actions.BUSSIFY_SINKS.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))
Actions.RELOAD_BLOCKS.set_sensitive(True)
Actions.FIND_BLOCKS.set_sensitive(True)
#set the exec and stop buttons
self.update_exec_stop()
#saved status
Actions.FLOW_GRAPH_SAVE.set_sensitive(not self.get_page().get_saved())
self.main_window.update()
try: #set the size of the flow graph area (if changed)
new_size = self.get_flow_graph().get_option('window_size')
if self.get_flow_graph().get_size() != tuple(new_size):
self.get_flow_graph().set_size(*new_size)
except: pass
#draw the flow graph
self.get_flow_graph().update_selected()
self.get_flow_graph().queue_draw()
return True #action was handled
def update_exec_stop(self):
"""
Update the exec and stop buttons.
Lock and unlock the mutex for race conditions with exec flow graph threads.
"""
sensitive = self.get_flow_graph().is_valid() and not self.get_page().get_proc()
Actions.FLOW_GRAPH_GEN.set_sensitive(sensitive)
Actions.FLOW_GRAPH_EXEC.set_sensitive(sensitive)
Actions.FLOW_GRAPH_KILL.set_sensitive(self.get_page().get_proc() != None)
class ExecFlowGraphThread(Thread):
"""Execute the flow graph as a new process and wait on it to finish."""
def __init__ (self, action_handler):
"""
ExecFlowGraphThread constructor.
Args:
action_handler: an instance of an ActionHandler
"""
Thread.__init__(self)
self.update_exec_stop = action_handler.update_exec_stop
self.flow_graph = action_handler.get_flow_graph()
#store page and dont use main window calls in run
self.page = action_handler.get_page()
Messages.send_start_exec(self.page.get_generator().get_file_path())
#get the popen
try:
self.p = self.page.get_generator().get_popen()
self.page.set_proc(self.p)
#update
self.update_exec_stop()
self.start()
except Exception, e:
Messages.send_verbose_exec(str(e))
Messages.send_end_exec()
def run(self):
"""
Wait on the executing process by reading from its stdout.
Use gobject.idle_add when calling functions that modify gtk objects.
"""
#handle completion
r = "\n"
while(r):
gobject.idle_add(Messages.send_verbose_exec, r)
r = os.read(self.p.stdout.fileno(), 1024)
gobject.idle_add(self.done)
def done(self):
"""Perform end of execution tasks."""
Messages.send_end_exec()
self.page.set_proc(None)
self.update_exec_stop()
gnuradio-3.7.2.1/grc/gui/Block.py 0000664 0001750 0001750 00000017733 12207702530 016300 0 ustar jcorgan jcorgan """
Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Radio
GNU Radio Companion 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 2
of the License, or (at your option) any later version.
GNU Radio Companion is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from Element import Element
import Utils
import Colors
from .. base import odict
from Constants import BORDER_PROXIMITY_SENSITIVITY
from Constants import \
BLOCK_LABEL_PADDING, \
PORT_SEPARATION, LABEL_SEPARATION, \
PORT_BORDER_SEPARATION, POSSIBLE_ROTATIONS
import pygtk
pygtk.require('2.0')
import gtk
import pango
BLOCK_MARKUP_TMPL="""\
#set $foreground = $block.is_valid() and 'black' or 'red'
$encode($block.get_name())"""
class Block(Element):
"""The graphical signal block."""
def __init__(self):
"""
Block contructor.
Add graphics related params to the block.
"""
#add the position param
self.get_params().append(self.get_parent().get_parent().Param(
block=self,
n=odict({
'name': 'GUI Coordinate',
'key': '_coordinate',
'type': 'raw',
'value': '(0, 0)',
'hide': 'all',
})
))
self.get_params().append(self.get_parent().get_parent().Param(
block=self,
n=odict({
'name': 'GUI Rotation',
'key': '_rotation',
'type': 'raw',
'value': '0',
'hide': 'all',
})
))
Element.__init__(self)
def get_coordinate(self):
"""
Get the coordinate from the position param.
Returns:
the coordinate tuple (x, y) or (0, 0) if failure
"""
try: #should evaluate to tuple
coor = eval(self.get_param('_coordinate').get_value())
x, y = map(int, coor)
fgW,fgH = self.get_parent().get_size()
if x <= 0:
x = 0
elif x >= fgW - BORDER_PROXIMITY_SENSITIVITY:
x = fgW - BORDER_PROXIMITY_SENSITIVITY
if y <= 0:
y = 0
elif y >= fgH - BORDER_PROXIMITY_SENSITIVITY:
y = fgH - BORDER_PROXIMITY_SENSITIVITY
return (x, y)
except:
self.set_coordinate((0, 0))
return (0, 0)
def set_coordinate(self, coor):
"""
Set the coordinate into the position param.
Args:
coor: the coordinate tuple (x, y)
"""
self.get_param('_coordinate').set_value(str(coor))
def get_rotation(self):
"""
Get the rotation from the position param.
Returns:
the rotation in degrees or 0 if failure
"""
try: #should evaluate to dict
rotation = eval(self.get_param('_rotation').get_value())
return int(rotation)
except:
self.set_rotation(POSSIBLE_ROTATIONS[0])
return POSSIBLE_ROTATIONS[0]
def set_rotation(self, rot):
"""
Set the rotation into the position param.
Args:
rot: the rotation in degrees
"""
self.get_param('_rotation').set_value(str(rot))
def create_shapes(self):
"""Update the block, parameters, and ports when a change occurs."""
Element.create_shapes(self)
if self.is_horizontal(): self.add_area((0, 0), (self.W, self.H))
elif self.is_vertical(): self.add_area((0, 0), (self.H, self.W))
def create_labels(self):
"""Create the labels for the signal block."""
Element.create_labels(self)
self._bg_color = self.get_enabled() and Colors.BLOCK_ENABLED_COLOR or Colors.BLOCK_DISABLED_COLOR
layouts = list()
#create the main layout
layout = gtk.DrawingArea().create_pango_layout('')
layouts.append(layout)
layout.set_markup(Utils.parse_template(BLOCK_MARKUP_TMPL, block=self))
self.label_width, self.label_height = layout.get_pixel_size()
#display the params
markups = [param.get_markup() for param in self.get_params() if param.get_hide() not in ('all', 'part')]
if markups:
layout = gtk.DrawingArea().create_pango_layout('')
layout.set_spacing(LABEL_SEPARATION*pango.SCALE)
layout.set_markup('\n'.join(markups))
layouts.append(layout)
w,h = layout.get_pixel_size()
self.label_width = max(w, self.label_width)
self.label_height += h + LABEL_SEPARATION
width = self.label_width
height = self.label_height
#setup the pixmap
pixmap = self.get_parent().new_pixmap(width, height)
gc = pixmap.new_gc()
gc.set_foreground(self._bg_color)
pixmap.draw_rectangle(gc, True, 0, 0, width, height)
#draw the layouts
h_off = 0
for i,layout in enumerate(layouts):
w,h = layout.get_pixel_size()
if i == 0: w_off = (width-w)/2
else: w_off = 0
pixmap.draw_layout(gc, w_off, h_off, layout)
h_off = h + h_off + LABEL_SEPARATION
#create vertical and horizontal pixmaps
self.horizontal_label = pixmap
if self.is_vertical():
self.vertical_label = self.get_parent().new_pixmap(height, width)
Utils.rotate_pixmap(gc, self.horizontal_label, self.vertical_label)
#calculate width and height needed
self.W = self.label_width + 2*BLOCK_LABEL_PADDING
self.H = max(*(
[self.label_height+2*BLOCK_LABEL_PADDING] + [2*PORT_BORDER_SEPARATION + \
sum([port.H + PORT_SEPARATION for port in ports]) - PORT_SEPARATION
for ports in (self.get_sources_gui(), self.get_sinks_gui())] +
[4*PORT_BORDER_SEPARATION + \
sum([(port.H) + PORT_SEPARATION for port in ports]) - PORT_SEPARATION
for ports in ([i for i in self.get_sources_gui() if i.get_type() == 'bus'], [i for i in self.get_sinks_gui() if i.get_type() == 'bus'])]
))
def draw(self, gc, window):
"""
Draw the signal block with label and inputs/outputs.
Args:
gc: the graphics context
window: the gtk window to draw on
"""
x, y = self.get_coordinate()
#draw main block
Element.draw(
self, gc, window, bg_color=self._bg_color,
border_color=self.is_highlighted() and Colors.HIGHLIGHT_COLOR or Colors.BORDER_COLOR,
)
#draw label image
if self.is_horizontal():
window.draw_drawable(gc, self.horizontal_label, 0, 0, x+BLOCK_LABEL_PADDING, y+(self.H-self.label_height)/2, -1, -1)
elif self.is_vertical():
window.draw_drawable(gc, self.vertical_label, 0, 0, x+(self.H-self.label_height)/2, y+BLOCK_LABEL_PADDING, -1, -1)
#draw ports
for port in self.get_ports_gui():
port.draw(gc, window)
def what_is_selected(self, coor, coor_m=None):
"""
Get the element that is selected.
Args:
coor: the (x,y) tuple
coor_m: the (x_m, y_m) tuple
Returns:
this block, a port, or None
"""
for port in self.get_ports_gui():
port_selected = port.what_is_selected(coor, coor_m)
if port_selected: return port_selected
return Element.what_is_selected(self, coor, coor_m)
gnuradio-3.7.2.1/gr-filter/ 0000755 0001750 0001750 00000000000 12237515112 015214 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/gr-filter/CMakeLists.txt 0000664 0001750 0001750 00000007275 12237515112 017771 0 ustar jcorgan jcorgan # Copyright 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.
########################################################################
# Setup dependencies
########################################################################
include(GrBoost)
########################################################################
# Register component
########################################################################
include(GrComponent)
GR_REGISTER_COMPONENT("gr-filter" ENABLE_GR_FILTER
ENABLE_VOLK
Boost_FOUND
ENABLE_GNURADIO_RUNTIME
ENABLE_GR_FFT
ENABLE_GR_BLOCKS
)
GR_SET_GLOBAL(GR_FILTER_INCLUDE_DIRS
${CMAKE_CURRENT_SOURCE_DIR}/lib
${CMAKE_CURRENT_SOURCE_DIR}/include
${CMAKE_CURRENT_BINARY_DIR}/lib
${CMAKE_CURRENT_BINARY_DIR}/include
${GR_FFT_INCLUDE_DIRS}
)
SET(GR_PKG_FILTER_EXAMPLES_DIR ${GR_PKG_DATA_DIR}/examples/filter)
########################################################################
# Begin conditional configuration
########################################################################
if(ENABLE_GR_FILTER)
########################################################################
# Setup CPack components
########################################################################
include(GrPackage)
CPACK_SET(CPACK_COMPONENT_GROUP_FILTER_DESCRIPTION "GNU Radio Filter Blocks")
CPACK_COMPONENT("filter_runtime"
GROUP "Filter"
DISPLAY_NAME "Runtime"
DESCRIPTION "Runtime"
DEPENDS "runtime_runtime"
)
CPACK_COMPONENT("filter_devel"
GROUP "Filter"
DISPLAY_NAME "Development"
DESCRIPTION "C++ headers, package config, import libraries"
DEPENDS "runtime_devel"
)
CPACK_COMPONENT("filter_python"
GROUP "Filter"
DISPLAY_NAME "Python"
DESCRIPTION "Python modules for runtime; GRC xml files"
DEPENDS "runtime_python;filter_runtime"
)
CPACK_COMPONENT("filter_swig"
GROUP "Filter"
DISPLAY_NAME "SWIG"
DESCRIPTION "SWIG development .i files"
DEPENDS "runtime_swig;filter_python;filter_devel"
)
########################################################################
# Add subdirectories
########################################################################
add_subdirectory(include/gnuradio/filter)
add_subdirectory(lib)
if(ENABLE_PYTHON)
add_subdirectory(swig)
add_subdirectory(python/filter)
add_subdirectory(python/filter/design)
add_subdirectory(python/filter/gui)
add_subdirectory(grc)
add_subdirectory(apps)
endif(ENABLE_PYTHON)
add_subdirectory(examples)
add_subdirectory(doc)
########################################################################
# Create Pkg Config File
########################################################################
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/gnuradio-filter.pc.in
${CMAKE_CURRENT_BINARY_DIR}/gnuradio-filter.pc
@ONLY)
install(
FILES ${CMAKE_CURRENT_BINARY_DIR}/gnuradio-filter.pc
DESTINATION ${GR_LIBRARY_DIR}/pkgconfig
COMPONENT "filter_devel"
)
endif(ENABLE_GR_FILTER)
gnuradio-3.7.2.1/gr-filter/include/ 0000775 0001750 0001750 00000000000 12207440367 016647 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/gr-filter/include/gnuradio/ 0000775 0001750 0001750 00000000000 12207440367 020457 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/ 0000775 0001750 0001750 00000000000 12245466767 021762 5 ustar jcorgan jcorgan gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/CMakeLists.txt 0000664 0001750 0001750 00000007325 12245466767 024531 0 ustar jcorgan jcorgan # Copyright 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.
########################################################################
# generate helper scripts to expand templated files
########################################################################
include(GrPython)
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py "
#!${PYTHON_EXECUTABLE}
import sys, os, re
sys.path.append('${GR_RUNTIME_PYTHONPATH}')
os.environ['srcdir'] = '${CMAKE_CURRENT_SOURCE_DIR}'
os.chdir('${CMAKE_CURRENT_BINARY_DIR}')
if __name__ == '__main__':
import build_utils
root, inp = sys.argv[1:3]
for sig in sys.argv[3:]:
name = re.sub ('X+', sig, root)
d = build_utils.standard_dict2(name, sig, 'filter')
build_utils.expand_template(d, inp)
")
macro(expand_h root)
#make a list of all the generated files
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)
#create a command to generate the 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}
)
#install rules for the generated h files
list(APPEND generated_includes ${expanded_files_h})
endmacro(expand_h)
########################################################################
# Invoke macro to generate various sources
#######################################################################
expand_h(fir_filter_XXX ccc ccf fcc fff fsf scc)
expand_h(freq_xlating_fir_filter_XXX ccc ccf fcc fcf scf scc)
expand_h(interp_fir_filter_XXX ccc ccf fcc fff fsf scc)
expand_h(rational_resampler_base_XXX ccc ccf fcc fff fsf scc)
add_custom_target(filter_generated_includes DEPENDS
${generated_includes}
)
########################################################################
# Install header files
########################################################################
install(FILES
${generated_includes}
api.h
adaptive_fir.h
firdes.h
fir_filter.h
fir_filter_with_buffer.h
fft_filter.h
iir_filter.h
interpolator_taps.h
mmse_fir_interpolator_cc.h
mmse_fir_interpolator_ff.h
pm_remez.h
polyphase_filterbank.h
single_pole_iir.h
adaptive_fir_ccc.h
adaptive_fir_ccf.h
dc_blocker_cc.h
dc_blocker_ff.h
filter_delay_fc.h
fft_filter_ccc.h
fft_filter_fff.h
fractional_interpolator_cc.h
fractional_interpolator_ff.h
fractional_resampler_cc.h
fractional_resampler_ff.h
hilbert_fc.h
iir_filter_ffd.h
pfb_arb_resampler.h
pfb_arb_resampler_ccf.h
pfb_arb_resampler_fff.h
pfb_channelizer_ccf.h
pfb_decimator_ccf.h
pfb_interpolator_ccf.h
pfb_synthesizer_ccf.h
single_pole_iir_filter_cc.h
single_pole_iir_filter_ff.h
DESTINATION ${GR_INCLUDE_DIR}/gnuradio/filter
COMPONENT "filter_devel"
)
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/adaptive_fir_ccc.h 0000664 0001750 0001750 00000005761 12245466767 025411 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2011,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.
*/
#ifndef INCLUDED_FILTER_ADAPTIVE_FIR_CCC_H
#define INCLUDED_FILTER_ADAPTIVE_FIR_CCC_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Adaptive FIR filter with gr_complex input, gr_complex output and gr_complex taps
* \ingroup filter_blk
*
* \details
* This is a base class to implement an adaptive FIR
* filter. Generally, another block will inherit from this one to
* build a new type of adaptive filter such as an equalizer.
*
* This class implements two functions that are designed to be
* overloaded by the child class: error(gr_complex out) and
* update_tap(gr_complex tap, gr_complex in).
*
* The error() function calculates the error value that will be
* used to adjust the taps. The update_tap function then uses the
* error and the input signal value to update a particular
* tap. Typically, the error is calculated for a given output and
* then this is used in a loop to update all of the filter taps in
* a loop:
*
* \code
* d_error = error(sum);
* for(k = 0; k < l; k++) {
* update_tap(d_taps[ntaps-k-1], in[i+k]);
* }
* \endcode
*
* See digital::cma_equalizer_cc and digital::lms_dd_equalizer_cc
* for example usage.
*/
class FILTER_API adaptive_fir_ccc : virtual public sync_decimator
{
protected:
public:
// gr::filter::adaptive_fir_ccc::sptr
typedef boost::shared_ptr sptr;
/*!
* \brief Adaptive FIR filter with gr_complex input, gr_complex output and gr_complex taps
*
* \param name Provides a name to identify this type of algorithm
* \param decimation (interger) decimation rate of the filter
* \param taps (complex) filter taps
*/
static sptr make(const char *name, int decimation,
const std::vector &taps);
virtual void set_taps(const std::vector &taps) = 0;
virtual std::vector taps() const = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_ADAPTIVE_FIR_CCC_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/fractional_resampler_cc.h 0000664 0001750 0001750 00000003706 12207440367 026764 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2004,2007,2012-2013 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.
*/
#ifndef INCLUDED_FRACTIONAL_RESAMPLER_CC_H
#define INCLUDED_FRACTIONAL_RESAMPLER_CC_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief resampling MMSE filter with complex input, complex output
* \ingroup resamplers_blk
*/
class FILTER_API fractional_resampler_cc : virtual public block
{
public:
// gr::filter::fractional_resampler_cc::sptr
typedef boost::shared_ptr sptr;
/*!
* \brief Build the resampling MMSE filter (complex input, complex output)
*
* \param phase_shift The phase shift of the output signal to the input
* \param resamp_ratio The resampling ratio = input_rate / output_rate.
*/
static sptr make(float phase_shift,
float resamp_ratio);
virtual float mu() const = 0;
virtual float resamp_ratio() const = 0;
virtual void set_mu (float mu) = 0;
virtual void set_resamp_ratio(float resamp_ratio) = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FRACTIONAL_RESAMPLER_FF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/iir_filter_ffd.h 0000664 0001750 0001750 00000005256 12244272666 025102 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2004,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.
*/
#ifndef INCLUDED_IIR_FILTER_FFD_H
#define INCLUDED_IIR_FILTER_FFD_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief IIR filter with float input, float output and double taps
* \ingroup filter_blk
*
* \details
* This filter uses the Direct Form I implementation, where
* \p fftaps contains the feed-forward taps, and \p fbtaps the feedback ones.
*
* \p oldstyle: The old style of the IIR filter uses feedback
* taps that are negative of what most definitions use (scipy
* and Matlab among them). This parameter keeps using the old
* GNU Radio style and is set to TRUE by default. When taps
* generated from scipy, Matlab, or gr_filter_design, use the
* new style by setting this to FALSE.
*
* The input and output satisfy a difference equation of the form
\f[
y[n] - \sum_{k=1}^{M} a_k y[n-k] = \sum_{k=0}^{N} b_k x[n-k]
\f]
\xmlonly
y[n] - \sum_{k=1}^{M} a_k y[n-k] = \sum_{k=0}^{N} b_k x[n-k]
\endxmlonly
* with the corresponding rational system function
\f[
H(z) = \frac{\sum_{k=0}^{M} b_k z^{-k}}{1 - \sum_{k=1}^{N} a_k z^{-k}}
\f]
\xmlonly
H(z) = \ frac{\sum_{k=0}^{M} b_k z^{-k}}{1 - \sum_{k=1}^{N} a_k z^{-k}}
\endxmlonly
*/
class FILTER_API iir_filter_ffd : virtual public sync_block
{
public:
// gr::filter::iir_filter_ffd::sptr
typedef boost::shared_ptr sptr;
static sptr make(const std::vector &fftaps,
const std::vector &fbtaps,
bool oldstyle=true);
virtual void set_taps(const std::vector &fftaps,
const std::vector &fbtaps) = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_IIR_FILTER_FFD_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/fractional_resampler_ff.h 0000664 0001750 0001750 00000003676 12207440367 027000 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2004,2007,2012-2013 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.
*/
#ifndef INCLUDED_FRACTIONAL_RESAMPLER_FF_H
#define INCLUDED_FRACTIONAL_RESAMPLER_FF_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Resampling MMSE filter with float input, float output
* \ingroup resamplers_blk
*/
class FILTER_API fractional_resampler_ff : virtual public block
{
public:
// gr::filter::fractional_resampler_ff::sptr
typedef boost::shared_ptr sptr;
/*!
* \brief Build the resampling MMSE filter (float input, float output)
*
* \param phase_shift The phase shift of the output signal to the input
* \param resamp_ratio The resampling ratio = input_rate / output_rate.
*/
static sptr make(float phase_shift,
float resamp_ratio);
virtual float mu() const = 0;
virtual float resamp_ratio() const = 0;
virtual void set_mu (float mu) = 0;
virtual void set_resamp_ratio(float resamp_ratio) = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FRACTIONAL_RESAMPLER_FF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/mmse_fir_interpolator_ff.h 0000664 0001750 0001750 00000004777 12207440367 027212 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2002,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.
*/
#ifndef _MMSE_FIR_INTERPOLATOR_FF_H_
#define _MMSE_FIR_INTERPOLATOR_FF_H_
#include
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Compute intermediate samples between signal samples x(k*Ts)
* \ingroup filter_primitive
*
* \details
* This implements a Mininum Mean Squared Error interpolator with
* 8 taps. It is suitable for signals where the bandwidth of
* interest B = 1/(4*Ts) Where Ts is the time between samples.
*
* Although mu, the fractional delay, is specified as a float, it
* is actually quantized. 0.0 <= mu <= 1.0. That is, mu is
* quantized in the interpolate method to 32nd's of a sample.
*
* For more information, in the GNU Radio source code, see:
* \li gr-filter/lib/gen_interpolator_taps/README
* \li gr-filter/lib/gen_interpolator_taps/praxis.txt
*/
class FILTER_API mmse_fir_interpolator_ff
{
public:
mmse_fir_interpolator_ff();
~mmse_fir_interpolator_ff();
unsigned ntaps() const;
unsigned nsteps() const;
/*!
* \brief compute a single interpolated output value.
* \p input must have ntaps() valid entries.
* input[0] .. input[ntaps() - 1] are referenced to compute the output value.
*
* \p mu must be in the range [0, 1] and specifies the fractional delay.
*
* \returns the interpolated input value.
*/
float interpolate(const float input[], float mu) const;
protected:
std::vector filters;
};
} /* namespace filter */
} /* namespace gr */
#endif /* _MMSE_FIR_INTERPOLATOR_FF_H_ */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/rational_resampler_base_XXX.h.t 0000664 0001750 0001750 00000003356 12207440367 030012 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2005,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.
*/
/* @WARNING@ */
#ifndef @GUARD_NAME@
#define @GUARD_NAME@
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Rational Resampling Polyphase FIR filter with @I_TYPE@
* input, @O_TYPE@ output and @TAP_TYPE@ taps.
* \ingroup resamplers_blk
*/
class FILTER_API @NAME@ : virtual public block
{
public:
// gr::filter::@BASE_NAME@::sptr
typedef boost::shared_ptr<@BASE_NAME@> sptr;
static sptr make(unsigned interpolation,
unsigned decimation,
const std::vector<@TAP_TYPE@> &taps);
virtual unsigned interpolation() const = 0;
virtual unsigned decimation() const = 0;
virtual void set_taps(const std::vector<@TAP_TYPE@> &taps) = 0;
virtual std::vector<@TAP_TYPE@> taps() const = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* @GUARD_NAME@ */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/pfb_arb_resampler_ccf.h 0000664 0001750 0001750 00000010151 12207440367 026373 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2009,2010,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.
*/
#ifndef INCLUDED_PFB_ARB_RESAMPLER_CCF_H
#define INCLUDED_PFB_ARB_RESAMPLER_CCF_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Polyphase filterbank arbitrary resampler with
* gr_complex input, gr_complex output and float taps
* \ingroup resamplers_blk
*
* \details
* This block takes in a signal stream and calls
* gr::filter::kernel::pfb_arb_resampler_ccf to perform
* arbitrary resampling on the stream.
*
* Output sampling rate is \p rate * input rate.
*/
class FILTER_API pfb_arb_resampler_ccf : virtual public block
{
public:
// gr::filter::pfb_arb_resampler_ccf::sptr
typedef boost::shared_ptr sptr;
/*!
* Build the polyphase filterbank arbitray resampler.
* \param rate (float) Specifies the resampling rate to use
* \param taps (vector/list of floats) The prototype filter to populate the filterbank. The taps
* should be generated at the filter_size sampling rate.
* \param filter_size (unsigned int) The number of filters in the filter bank. This is directly
* related to quantization noise introduced during the resampling.
* Defaults to 32 filters.
*/
static sptr make(float rate,
const std::vector &taps,
unsigned int filter_size=32);
/*!
* Resets the filterbank's filter taps with the new prototype filter
* \param taps (vector/list of floats) The prototype filter to populate the filterbank.
*/
virtual void set_taps(const std::vector &taps) = 0;
/*!
* Return a vector> of the filterbank taps
*/
virtual std::vector > taps() const = 0;
/*!
* Print all of the filterbank taps to screen.
*/
virtual void print_taps() = 0;
/*!
* Sets the resampling rate of the block.
*/
virtual void set_rate (float rate) = 0;
/*!
* Sets the current phase offset in radians (0 to 2pi).
*/
virtual void set_phase(float ph) = 0;
/*!
* Gets the current phase of the resampler in radians (2 to 2pi).
*/
virtual float phase() const = 0;
/*!
* Gets the number of taps per filter.
*/
virtual unsigned int taps_per_filter() const = 0;
/*!
* Gets the interpolation rate of the filter.
*/
virtual unsigned int interpolation_rate() const = 0;
/*!
* Gets the decimation rate of the filter.
*/
virtual unsigned int decimation_rate() const =0;
/*!
* Gets the fractional rate of the filter.
*/
virtual float fractional_rate() const = 0;
/*!
* Get the group delay of the filter.
*/
virtual int group_delay() const = 0;
/*!
* Calculates the phase offset expected by a sine wave of
* frequency \p freq and sampling rate \p fs (assuming input
* sine wave has 0 degree phase).
*/
virtual float phase_offset(float freq, float fs) = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_PFB_ARB_RESAMPLER_CCF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/adaptive_fir_ccf.h 0000664 0001750 0001750 00000005512 12245466767 025406 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2011,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.
*/
#ifndef INCLUDED_FILTER_ADAPTIVE_FIR_CCF_H
#define INCLUDED_FILTER_ADAPTIVE_FIR_CCF_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Adaptive FIR filter with gr_complex input, gr_complex output and float taps
* \ingroup filter_blk
*
* \details
* This is a base class to implement an adaptive FIR
* filter. Generally, another block will inherit from this one to
* build a new type of adaptive filter such as an equalizer.
*
* This class implements two functions that are designed to be
* overloaded by the child class: error(gr_complex out) and
* update_tap(float tap, gr_complex in).
*
* The error() function calculates the error value that will be
* used to adjust the taps. The update_tap function then uses the
* error and the input signal value to update a particular
* tap. Typically, the error is calculated for a given output and
* then this is used in a loop to update all of the filter taps in
* a loop:
*
* \code
* d_error = error(sum);
* for(k = 0; k < l; k++) {
* update_tap(d_taps[ntaps-k-1], in[i+k]);
* }
* \endcode
*/
class FILTER_API adaptive_fir_ccf : virtual public sync_decimator
{
public:
// gr::filter::adaptive_fir_ccf::sptr
typedef boost::shared_ptr sptr;
/*!
* \brief Adaptive FIR filter with gr_complex input, gr_complex output and float taps
*
* \param name Provides a name to identify this type of algorithm
* \param decimation (interger) decimation rate of the filter
* \param taps (real) filter taps
*/
static sptr make(const char *name, int decimation,
const std::vector &taps);
virtual void set_taps(const std::vector &taps) = 0;
virtual std::vector taps() = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_ADAPTIVE_FIR_CCF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/fir_filter.h 0000664 0001750 0001750 00000013652 12207440367 024251 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2004,2010,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.
*/
#ifndef INCLUDED_FILTER_FIR_FILTER_H
#define INCLUDED_FILTER_FIR_FILTER_H
#include
#include
#include
namespace gr {
namespace filter {
namespace kernel {
class FILTER_API fir_filter_fff
{
public:
fir_filter_fff(int decimation,
const std::vector &taps);
~fir_filter_fff();
void set_taps(const std::vector &taps);
void update_tap(float t, unsigned int index);
std::vector taps() const;
unsigned int ntaps() const;
float filter(const float input[]);
void filterN(float output[],
const float input[],
unsigned long n);
void filterNdec(float output[],
const float input[],
unsigned long n,
unsigned int decimate);
protected:
std::vector d_taps;
unsigned int d_ntaps;
float **d_aligned_taps;
float *d_output;
int d_align;
int d_naligned;
};
/**************************************************************/
class FILTER_API fir_filter_ccf
{
public:
fir_filter_ccf(int decimation,
const std::vector &taps);
~fir_filter_ccf();
void set_taps(const std::vector &taps);
void update_tap(float t, unsigned int index);
std::vector taps() const;
unsigned int ntaps() const;
gr_complex filter(const gr_complex input[]);
void filterN(gr_complex output[],
const gr_complex input[],
unsigned long n);
void filterNdec(gr_complex output[],
const gr_complex input[],
unsigned long n,
unsigned int decimate);
protected:
std::vector d_taps;
unsigned int d_ntaps;
float **d_aligned_taps;
gr_complex *d_output;
int d_align;
int d_naligned;
};
/**************************************************************/
class FILTER_API fir_filter_fcc
{
public:
fir_filter_fcc(int decimation,
const std::vector &taps);
~fir_filter_fcc();
void set_taps(const std::vector &taps);
void update_tap(gr_complex t, unsigned int index);
std::vector taps() const;
unsigned int ntaps() const;
gr_complex filter(const float input[]);
void filterN(gr_complex output[],
const float input[],
unsigned long n);
void filterNdec(gr_complex output[],
const float input[],
unsigned long n,
unsigned int decimate);
protected:
std::vector d_taps;
unsigned int d_ntaps;
gr_complex **d_aligned_taps;
gr_complex *d_output;
int d_align;
int d_naligned;
};
/**************************************************************/
class FILTER_API fir_filter_ccc
{
public:
fir_filter_ccc(int decimation,
const std::vector &taps);
~fir_filter_ccc();
void set_taps(const std::vector &taps);
void update_tap(gr_complex t, unsigned int index);
std::vector taps() const;
unsigned int ntaps() const;
gr_complex filter(const gr_complex input[]);
void filterN(gr_complex output[],
const gr_complex input[],
unsigned long n);
void filterNdec(gr_complex output[],
const gr_complex input[],
unsigned long n,
unsigned int decimate);
protected:
std::vector d_taps;
unsigned int d_ntaps;
gr_complex **d_aligned_taps;
gr_complex *d_output;
int d_align;
int d_naligned;
};
/**************************************************************/
class FILTER_API fir_filter_scc
{
public:
fir_filter_scc(int decimation,
const std::vector &taps);
~fir_filter_scc();
void set_taps(const std::vector &taps);
void update_tap(gr_complex t, unsigned int index);
std::vector taps() const;
unsigned int ntaps() const;
gr_complex filter(const short input[]);
void filterN(gr_complex output[],
const short input[],
unsigned long n);
void filterNdec(gr_complex output[],
const short input[],
unsigned long n,
unsigned int decimate);
protected:
std::vector d_taps;
unsigned int d_ntaps;
gr_complex **d_aligned_taps;
gr_complex *d_output;
int d_align;
int d_naligned;
};
/**************************************************************/
class FILTER_API fir_filter_fsf
{
public:
fir_filter_fsf(int decimation,
const std::vector &taps);
~fir_filter_fsf();
void set_taps(const std::vector &taps);
void update_tap(float t, unsigned int index);
std::vector taps() const;
unsigned int ntaps() const;
short filter(const float input[]);
void filterN(short output[],
const float input[],
unsigned long n);
void filterNdec(short output[],
const float input[],
unsigned long n,
unsigned int decimate);
protected:
std::vector d_taps;
unsigned int d_ntaps;
float **d_aligned_taps;
short *d_output;
int d_align;
int d_naligned;
};
} /* namespace kernel */
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_FIR_FILTER_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/single_pole_iir_filter_ff.h 0000664 0001750 0001750 00000004413 12207440367 027302 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2004,2005 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.
*/
#ifndef INCLUDED_SINGLE_POLE_IIR_FILTER_FF_H
#define INCLUDED_SINGLE_POLE_IIR_FILTER_FF_H
#include
#include
#include
#include
namespace gr {
namespace filter {
/*!
* \brief single pole IIR filter with float input, float output
* \ingroup filter_blk
*
* \details
* The input and output satisfy a difference equation of the form
\htmlonly
\f{
y[n] - (1-alpha) y[n-1] = alpha x[n]
\f}
\endhtmlonly
\xmlonly
y[n] - (1-alpha) y[n-1] = alpha x[n]
\endxmlonly
* with the corresponding rational system function
\htmlonly
\f{
H(z) = \frac{alpha}{1 - (1-alpha) z^{-1}}
\f}
\endhtmlonly
\xmlonly
H(z) = \ frac{alpha}{1 - (1-alpha) z^{-1}}
\endxmlonly
* Note that some texts define the system function with a + in the
* denominator. If you're using that convention, you'll need to
* negate the feedback tap.
*/
class FILTER_API single_pole_iir_filter_ff : virtual public sync_block
{
public:
// gr::filter::single_pole_iir_filter_ff::sptr
typedef boost::shared_ptr sptr;
static sptr make(double alpha, unsigned int vlen=1);
virtual void set_taps (double alpha) = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_SINGLE_POLE_IIR_FILTER_FF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/pfb_decimator_ccf.h 0000664 0001750 0001750 00000012113 12245466767 025542 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 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.
*/
#ifndef INCLUDED_PFB_DECIMATOR_CCF_H
#define INCLUDED_PFB_DECIMATOR_CCF_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Polyphase filterbank bandpass decimator with gr_complex
* input, gr_complex output and float taps
* \ingroup channelizers_blk
*
* \details
* This block takes in a signal stream and performs interger down-
* sampling (decimation) with a polyphase filterbank. The first
* input is the integer specifying how much to decimate by. The
* second input is a vector (Python list) of floating-point taps
* of the prototype filter. The third input specifies the channel
* to extract. By default, the zeroth channel is used, which is
* the baseband channel (first Nyquist zone).
*
* The channel parameter specifies which channel to use
* since this class is capable of bandpass decimation. Given a
* complex input stream at a sampling rate of fs and a
* decimation rate of decim, the input frequency domain
* is split into decim channels that represent the
* Nyquist zones. Using the polyphase filterbank, we can select
* any one of these channels to decimate.
*
* The output signal will be the basebanded and decimated signal
* from that channel. This concept is very similar to the PFB
* channelizer (see #gr::filter::pfb_channelizer_ccf) where only a single
* channel is extracted at a time.
*
* The filter's taps should be based on the sampling rate before
* decimation.
*
* For example, using the GNU Radio's firdes utility to building
* filters, we build a low-pass filter with a sampling rate of
* fs, a 3-dB bandwidth of BW and a transition
* bandwidth of TB. We can also specify the out-of-band
* attenuation to use, ATT, and the filter window
* function (a Blackman-harris window in this case). The first
* input is the gain of the filter, which we specify here as
* unity.
*
* self._taps = filter.firdes.low_pass_2(1, fs, BW, TB,
* attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)
*
* The PFB decimator code takes the taps generated above and
* builds a set of filters. The set contains decim number
* of filters and each filter contains ceil(taps.size()/decim)
* number of taps. Each tap from the filter prototype is
* sequentially inserted into the next filter. When all of the
* input taps are used, the remaining filters in the filterbank
* are filled out with 0's to make sure each filter has the same
* number of taps.
*
* The theory behind this block can be found in Chapter 6 of
* the following book.
*
* f. harris, "Multirate Signal Processing for Communication
* Systems," Upper Saddle River, NJ: Prentice Hall, Inc. 2004.
*/
class FILTER_API pfb_decimator_ccf : virtual public sync_block
{
public:
// gr::filter::pfb_decimator_ccf::sptr
typedef boost::shared_ptr sptr;
/*!
* Build the polyphase filterbank decimator.
* \param decim (unsigned integer) Specifies the decimation rate to use
* \param taps (vector/list of floats) The prototype filter to populate the filterbank.
* \param channel (unsigned integer) Selects the channel to return [default=0].
*/
static sptr make(unsigned int decim,
const std::vector &taps,
unsigned int channel);
/*!
* Resets the filterbank's filter taps with the new prototype filter
* \param taps (vector/list of floats) The prototype filter to populate the filterbank.
*/
virtual void set_taps(const std::vector &taps) = 0;
/*!
* Return a vector> of the filterbank taps
*/
virtual std::vector > taps() const = 0;
/*!
* Print all of the filterbank taps to screen.
*/
virtual void print_taps() = 0;
//virtual void set_channel(unsigned int channel) = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_PFB_DECIMATOR_CCF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/fir_filter_with_buffer.h 0000664 0001750 0001750 00000020675 12207440367 026640 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2010,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.
*/
#ifndef INCLUDED_FILTER_FIR_FILTER_WITH_BUFFER_H
#define INCLUDED_FILTER_FIR_FILTER_WITH_BUFFER_H
#include
#include
#include
namespace gr {
namespace filter {
namespace kernel {
/*!
* \brief FIR with internal buffer for float input, float output and float taps.
* \ingroup filter
*/
class FILTER_API fir_filter_with_buffer_fff
{
private:
std::vector d_taps;
unsigned int d_ntaps;
float *d_buffer_ptr;
float *d_buffer;
unsigned int d_idx;
float **d_aligned_taps;
float *d_output;
int d_align;
int d_naligned;
public:
// CONSTRUCTORS
/*!
* \brief construct new FIR with given taps.
*
* Note that taps must be in forward order, e.g., coefficient 0 is
* stored in new_taps[0], coefficient 1 is stored in
* new_taps[1], etc.
*/
fir_filter_with_buffer_fff(const std::vector &taps);
~fir_filter_with_buffer_fff();
// MANIPULATORS
/*!
* \brief compute a single output value.
*
* \p input is a single input value of the filter type
*
* \returns the filtered input value.
*/
float filter(float input);
/*!
* \brief compute a single output value; designed for decimating filters.
*
* \p input is a single input value of the filter type. The value of dec is the
* decimating value of the filter, so input[] must have dec valid values.
* The filter pushes dec number of items onto the circ. buffer before computing
* a single output.
*
* \returns the filtered input value.
*/
float filter(const float input[], unsigned long dec);
/*!
* \brief compute an array of N output values.
*
* \p input must have (n - 1 + ntaps()) valid entries.
* input[0] .. input[n - 1 + ntaps() - 1] are referenced to compute the output values.
*/
void filterN(float output[],
const float input[],
unsigned long n);
/*!
* \brief compute an array of N output values, decimating the input
*
* \p input must have (decimate * (n - 1) + ntaps()) valid entries.
* input[0] .. input[decimate * (n - 1) + ntaps() - 1] are referenced to
* compute the output values.
*/
void filterNdec(float output[], const float input[],
unsigned long n, unsigned long decimate);
// ACCESSORS
/*!
* \return number of taps in filter.
*/
unsigned int ntaps() const { return d_ntaps; }
/*!
* \brief install \p new_taps as the current taps.
*/
void set_taps(const std::vector &taps);
/*!
* \return current taps
*/
std::vector taps() const;
};
/**************************************************************/
/*!
* \brief FIR with internal buffer for gr_complex input, gr_complex output and gr_complex taps.
* \ingroup filter
*/
class FILTER_API fir_filter_with_buffer_ccc
{
private:
std::vector d_taps;
unsigned int d_ntaps;
gr_complex *d_buffer_ptr;
gr_complex *d_buffer;
unsigned int d_idx;
gr_complex **d_aligned_taps;
gr_complex *d_output;
int d_align;
int d_naligned;
public:
// CONSTRUCTORS
/*!
* \brief construct new FIR with given taps.
*
* Note that taps must be in forward order, e.g., coefficient 0 is
* stored in new_taps[0], coefficient 1 is stored in
* new_taps[1], etc.
*/
fir_filter_with_buffer_ccc(const std::vector &taps);
~fir_filter_with_buffer_ccc();
// MANIPULATORS
/*!
* \brief compute a single output value.
*
* \p input is a single input value of the filter type
*
* \returns the filtered input value.
*/
gr_complex filter(gr_complex input);
/*!
* \brief compute a single output value; designed for decimating filters.
*
* \p input is a single input value of the filter type. The value of dec is the
* decimating value of the filter, so input[] must have dec valid values.
* The filter pushes dec number of items onto the circ. buffer before computing
* a single output.
*
* \returns the filtered input value.
*/
gr_complex filter(const gr_complex input[], unsigned long dec);
/*!
* \brief compute an array of N output values.
*
* \p input must have (n - 1 + ntaps()) valid entries.
* input[0] .. input[n - 1 + ntaps() - 1] are referenced to compute the output values.
*/
void filterN(gr_complex output[],
const gr_complex input[],
unsigned long n);
/*!
* \brief compute an array of N output values, decimating the input
*
* \p input must have (decimate * (n - 1) + ntaps()) valid entries.
* input[0] .. input[decimate * (n - 1) + ntaps() - 1] are referenced to
* compute the output values.
*/
void filterNdec(gr_complex output[], const gr_complex input[],
unsigned long n, unsigned long decimate);
// ACCESSORS
/*!
* \return number of taps in filter.
*/
unsigned int ntaps() const { return d_ntaps; }
/*!
* \brief install \p new_taps as the current taps.
*/
void set_taps(const std::vector &taps);
/*!
* \return current taps
*/
std::vector taps() const;
};
/**************************************************************/
/*!
* \brief FIR with internal buffer for gr_complex input, gr_complex output and gr_complex taps.
* \ingroup filter
*/
class FILTER_API fir_filter_with_buffer_ccf
{
private:
std::vector d_taps;
unsigned int d_ntaps;
gr_complex *d_buffer_ptr;
gr_complex *d_buffer;
unsigned int d_idx;
float **d_aligned_taps;
gr_complex *d_output;
int d_align;
int d_naligned;
public:
// CONSTRUCTORS
/*!
* \brief construct new FIR with given taps.
*
* Note that taps must be in forward order, e.g., coefficient 0 is
* stored in new_taps[0], coefficient 1 is stored in
* new_taps[1], etc.
*/
fir_filter_with_buffer_ccf(const std::vector &taps);
~fir_filter_with_buffer_ccf();
// MANIPULATORS
/*!
* \brief compute a single output value.
*
* \p input is a single input value of the filter type
*
* \returns the filtered input value.
*/
gr_complex filter(gr_complex input);
/*!
* \brief compute a single output value; designed for decimating filters.
*
* \p input is a single input value of the filter type. The value of dec is the
* decimating value of the filter, so input[] must have dec valid values.
* The filter pushes dec number of items onto the circ. buffer before computing
* a single output.
*
* \returns the filtered input value.
*/
gr_complex filter(const gr_complex input[], unsigned long dec);
/*!
* \brief compute an array of N output values.
*
* \p input must have (n - 1 + ntaps()) valid entries.
* input[0] .. input[n - 1 + ntaps() - 1] are referenced to compute the output values.
*/
void filterN(gr_complex output[],
const gr_complex input[],
unsigned long n);
/*!
* \brief compute an array of N output values, decimating the input
*
* \p input must have (decimate * (n - 1) + ntaps()) valid entries.
* input[0] .. input[decimate * (n - 1) + ntaps() - 1] are referenced to
* compute the output values.
*/
void filterNdec(gr_complex output[], const gr_complex input[],
unsigned long n, unsigned long decimate);
// ACCESSORS
/*!
* \return number of taps in filter.
*/
unsigned int ntaps() const { return d_ntaps; }
/*!
* \brief install \p new_taps as the current taps.
*/
void set_taps(const std::vector &taps);
/*!
* \return current taps
*/
std::vector taps() const;
};
} /* namespace kernel */
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_FIR_FILTER_WITH_BUFFER_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/freq_xlating_fir_filter_XXX.h.t 0000664 0001750 0001750 00000006007 12207440367 030021 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2002,2004,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.
*/
/*
* WARNING: This file is automatically generated by cmake.
* Any changes made to this file will be overwritten.
*/
#ifndef @GUARD_NAME@
#define @GUARD_NAME@
#include
#include
namespace gr {
namespace filter {
/*!
* \brief FIR filter combined with frequency translation with
* @I_TYPE@ input, @O_TYPE@ output and @TAP_TYPE@ taps
*
* \ingroup channelizers_blk
*
* This class efficiently combines a frequency translation
* (typically "down conversion") with a FIR filter (typically
* low-pass) and decimation. It is ideally suited for a "channel
* selection filter" and can be efficiently used to select and
* decimate a narrow band signal out of wide bandwidth input.
*
* Uses a single input array to produce a single output array.
* Additional inputs and/or outputs are ignored.
*/
class FILTER_API @BASE_NAME@ : virtual public sync_decimator
{
public:
// gr::filter::@BASE_NAME@::sptr
typedef boost::shared_ptr<@BASE_NAME@> sptr;
/*!
* \brief FIR filter with @I_TYPE@ input, @O_TYPE@ output, and
* @TAP_TYPE@ taps that also frequency translates a signal from
* \p center_freq.
*
* Construct a FIR filter with the given taps and a composite
* frequency translation that shifts center_freq down to zero
* Hz. The frequency translation logically comes before the
* filtering operation.
*
* \param decimation set the integer decimation rate
* \param taps a vector/list of taps of type @TAP_TYPE@
* \param center_freq Center frequency of signal to down convert from (Hz)
* \param sampling_freq Sampling rate of signal (in Hz)
*/
static sptr make(int decimation,
const std::vector<@TAP_TYPE@> &taps,
double center_freq,
double sampling_freq);
virtual void set_center_freq(double center_freq) = 0;
virtual double center_freq() const = 0;
virtual void set_taps(const std::vector<@TAP_TYPE@> &taps) = 0;
virtual std::vector<@TAP_TYPE@> taps() const = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* @GUARD_NAME@ */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/fft_filter_ccc.h 0000664 0001750 0001750 00000006116 12207440367 025055 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2005,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.
*/
#ifndef INCLUDED_FILTER_FFT_FILTER_CCC_H
#define INCLUDED_FILTER_FFT_FILTER_CCC_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps
* \ingroup filter_blk
*
* \details
* This block implements a complex decimating filter using the
* fast convolution method via an FFT. The decimation factor is an
* interger that is greater than or equal to 1.
*
* The filter takes a set of complex (or real) taps to use in the
* filtering operation. These taps can be defined as anything that
* satisfies the user's filtering needs. For standard filters such
* as lowpass, highpass, bandpass, etc., the filter.firdes and
* filter.optfir classes provide convenient generating methods.
*
* This filter is implemented by using the FFTW package to perform
* the required FFTs. An optional argument, nthreads, may be
* passed to the constructor (or set using the set_nthreads member
* function) to split the FFT among N number of threads. This can
* improve performance on very large FFTs (that is, if the number
* of taps used is very large) if you have enough threads/cores to
* support it.
*/
class FILTER_API fft_filter_ccc : virtual public sync_decimator
{
public:
// gr::filter::fft_filter_ccc::sptr
typedef boost::shared_ptr sptr;
/*!
* Build an FFT filter blocks.
*
* \param decimation >= 1
* \param taps complex filter taps
* \param nthreads number of threads for the FFT to use
*/
static sptr make(int decimation,
const std::vector &taps,
int nthreads=1);
virtual void set_taps(const std::vector &taps) = 0;
virtual std::vector taps() const = 0;
/*!
* \brief Set number of threads to use.
*/
virtual void set_nthreads(int n) = 0;
/*!
* \brief Get number of threads being used.
*/
virtual int nthreads() const = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_FFT_FILTER_CCC_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/fractional_interpolator_cc.h 0000664 0001750 0001750 00000003713 12207440367 027512 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2004,2007,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.
*/
#ifndef INCLUDED_FRACTIONAL_INTERPOLATOR_CC_H
#define INCLUDED_FRACTIONAL_INTERPOLATOR_CC_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Interpolating MMSE filter with complex input, complex output
* \ingroup resamplers_blk
*/
class FILTER_API fractional_interpolator_cc : virtual public block
{
public:
// gr::filter::fractional_interpolator_cc::sptr
typedef boost::shared_ptr sptr;
/*!
* \brief Build the interpolating MMSE filter (complex input, complex output)
*
* \param phase_shift The phase shift of the output signal to the input
* \param interp_ratio The interpolation ratio = input_rate / output_rate.
*/
static sptr make(float phase_shift,
float interp_ratio);
virtual float mu() const = 0;
virtual float interp_ratio() const = 0;
virtual void set_mu (float mu) = 0;
virtual void set_interp_ratio(float interp_ratio) = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FRACTIONAL_INTERPOLATOR_FF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/fractional_interpolator_ff.h 0000664 0001750 0001750 00000003703 12207440367 027517 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2004,2007,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.
*/
#ifndef INCLUDED_FRACTIONAL_INTERPOLATOR_FF_H
#define INCLUDED_FRACTIONAL_INTERPOLATOR_FF_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Interpolating MMSE filter with float input, float output
* \ingroup resamplers_blk
*/
class FILTER_API fractional_interpolator_ff : virtual public block
{
public:
// gr::filter::fractional_interpolator_ff::sptr
typedef boost::shared_ptr sptr;
/*!
* \brief Build the interpolating MMSE filter (float input, float output)
*
* \param phase_shift The phase shift of the output signal to the input
* \param interp_ratio The interpolation ratio = input_rate / output_rate.
*/
static sptr make(float phase_shift,
float interp_ratio);
virtual float mu() const = 0;
virtual float interp_ratio() const = 0;
virtual void set_mu (float mu) = 0;
virtual void set_interp_ratio(float interp_ratio) = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FRACTIONAL_INTERPOLATOR_FF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/fir_filter_XXX.h.t 0000664 0001750 0001750 00000004744 12207440367 025264 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2004,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.
*/
/* @WARNING@ */
#ifndef @GUARD_NAME@
#define @GUARD_NAME@
#include
#include
namespace gr {
namespace filter {
/*!
* \brief FIR filter with @I_TYPE@ input, @O_TYPE@ output, and @TAP_TYPE@ taps
* \ingroup filter_blk
*
* \details
* The fir_filter_XXX blocks create finite impulse response
* (FIR) filters that perform the convolution in the time
* domain:
*
* \code
* out = 0
* for i in ntaps:
* out += input[n-i] * taps[i]
* \endcode
*
* The taps are a C++ vector (or Python list) of values of the
* type specified by the third letter in the block's suffix. For
* this block, the value is of type @TAP_TYPE@. Taps can be
* created using the firdes or optfir tools.
*
* These versions of the filter can also act as down-samplers
* (or decimators) by specifying an integer value for \p
* decimation.
*/
class FILTER_API @BASE_NAME@ : virtual public sync_decimator
{
public:
// gr::filter::@BASE_NAME@::sptr
typedef boost::shared_ptr<@BASE_NAME@> sptr;
/*!
* \brief FIR filter with @I_TYPE@ input, @O_TYPE@ output, and @TAP_TYPE@ taps
*
* \param decimation set the integer decimation rate
* \param taps a vector/list of taps of type @TAP_TYPE@
*/
static sptr make(int decimation,
const std::vector<@TAP_TYPE@> &taps);
virtual void set_taps(const std::vector<@TAP_TYPE@> &taps) = 0;
virtual std::vector<@TAP_TYPE@> taps() const = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* @GUARD_NAME@ */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/iir_filter.h 0000664 0001750 0001750 00000012115 12207440367 024245 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2002,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.
*/
#ifndef INCLUDED_IIR_FILTER_H
#define INCLUDED_IIR_FILTER_H
#include
#include
#include
namespace gr {
namespace filter {
namespace kernel {
/*!
* \brief base class template for Infinite Impulse Response filter (IIR)
*/
template
class iir_filter
{
public:
/*!
* \brief Construct an IIR with the given taps.
*
* This filter uses the Direct Form I implementation, where
* \p fftaps contains the feed-forward taps, and \p fbtaps the feedback ones.
*
* \p fftaps and \p fbtaps must have equal numbers of taps
*
* \p oldstyle: The old style of the IIR filter uses feedback
* taps that are negative of what most definitions use (scipy
* and Matlab among them). This parameter keeps using the old
* GNU Radio style and is set to TRUE by default. When taps
* generated from scipy, Matlab, or gr_filter_design, use the
* new style by setting this to FALSE.
*
* The input and output satisfy a difference equation of the form
\f[
y[n] \pm \sum_{k=1}^{M} a_k y[n-k] = \sum_{k=0}^{N} b_k x[n-k]
\f]
* with the corresponding rational system function
\f[
H(z) = \frac{\sum_{k=0}^{N} b_k z^{-k}}{1 \pm \sum_{k=1}^{M} a_k z^{-k}}
\f]
*/
iir_filter(const std::vector& fftaps,
const std::vector& fbtaps,
bool oldstyle=true)
throw (std::invalid_argument)
{
d_oldstyle = oldstyle;
set_taps(fftaps, fbtaps);
}
iir_filter() : d_latest_n(0),d_latest_m(0) { }
~iir_filter() {}
/*!
* \brief compute a single output value.
* \returns the filtered input value.
*/
o_type filter(const i_type input);
/*!
* \brief compute an array of N output values.
* \p input must have N valid entries.
*/
void filter_n(o_type output[], const i_type input[], long n);
/*!
* \return number of taps in filter.
*/
unsigned ntaps_ff() const { return d_fftaps.size(); }
unsigned ntaps_fb() const { return d_fbtaps.size(); }
/*!
* \brief install new taps.
*/
void set_taps(const std::vector &fftaps,
const std::vector &fbtaps)
throw (std::invalid_argument)
{
d_latest_n = 0;
d_latest_m = 0;
d_fftaps = fftaps;
if(d_oldstyle) {
d_fbtaps = fbtaps;
}
else {
// New style negates taps a[1:N-1] to fit with most IIR
// tap generating programs.
d_fbtaps.resize(fbtaps.size());
d_fbtaps[0] = fbtaps[0];
for(size_t i = 1; i < fbtaps.size(); i++) {
d_fbtaps[i] = -fbtaps[i];
}
}
int n = fftaps.size();
int m = fbtaps.size();
d_prev_input.clear();
d_prev_output.clear();
d_prev_input.resize(2 * n, 0);
d_prev_output.resize(2 * m, 0);
}
protected:
bool d_oldstyle;
std::vector d_fftaps;
std::vector d_fbtaps;
int d_latest_n;
int d_latest_m;
std::vector d_prev_output;
std::vector d_prev_input;
};
//
// general case. We may want to specialize this
//
template
o_type
iir_filter::filter(const i_type input)
{
tap_type acc;
unsigned i = 0;
unsigned n = ntaps_ff();
unsigned m = ntaps_fb();
if(n == 0)
return (o_type)0;
int latest_n = d_latest_n;
int latest_m = d_latest_m;
acc = d_fftaps[0] * input;
for(i = 1; i < n; i ++)
acc += (d_fftaps[i] * d_prev_input[latest_n + i]);
for(i = 1; i < m; i ++)
acc += (d_fbtaps[i] * d_prev_output[latest_m + i]);
// store the values twice to avoid having to handle wrap-around in the loop
d_prev_output[latest_m] = acc;
d_prev_output[latest_m+m] = acc;
d_prev_input[latest_n] = input;
d_prev_input[latest_n+n] = input;
latest_n--;
latest_m--;
if(latest_n < 0)
latest_n += n;
if(latest_m < 0)
latest_m += m;
d_latest_m = latest_m;
d_latest_n = latest_n;
return (o_type)acc;
}
template
void
iir_filter::filter_n(o_type output[],
const i_type input[],
long n)
{
for(int i = 0; i < n; i++)
output[i] = filter(input[i]);
}
} /* namespace kernel */
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_IIR_FILTER_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/dc_blocker_cc.h 0000664 0001750 0001750 00000005276 12207440367 024663 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2011,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.
*/
#ifndef INCLUDED_FILTER_DC_BLOCKER_CC_H
#define INCLUDED_FILTER_DC_BLOCKER_CC_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief a computationally efficient controllable DC blocker
* \ingroup filter_blk
*
* \details
* This block implements a computationally efficient DC blocker that produces
* a tighter notch filter around DC for a smaller group delay than an
* equivalent FIR filter or using a single pole IIR filter (though the IIR
* filter is computationally cheaper).
*
* The block defaults to using a delay line of length 32 and the long form
* of the filter. Optionally, the delay line length can be changed to alter
* the width of the DC notch (longer lines will decrease the width).
*
* The long form of the filter produces a nearly flat response outside of
* the notch but at the cost of a group delay of 2D-2.
*
* The short form of the filter does not have as flat a response in the
* passband but has a group delay of only D-1 and is cheaper to compute.
*
* The theory behind this block can be found in the paper:
*
* R. Yates, "DC Blocker Algorithms," IEEE Signal Processing Magazine,
* Mar. 2008, pp 132-134.
*/
class FILTER_API dc_blocker_cc : virtual public sync_block
{
public:
// gr::filter::dc_blocker_cc::sptr
typedef boost::shared_ptr sptr;
/*!
* Make a DC blocker block.
*
* \param D (int) the length of the delay line
* \param long_form (bool) whether to use long (true, default) or short form
*/
static sptr make(int D, bool long_form);
virtual int group_delay() = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_DC_BLOCKER_CC_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/pfb_arb_resampler.h 0000664 0001750 0001750 00000043727 12207440367 025577 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2013 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.
*/
#ifndef INCLUDED_PFB_ARB_RESAMPLER_H
#define INCLUDED_PFB_ARB_RESAMPLER_H
#include
namespace gr {
namespace filter {
namespace kernel {
/*!
* \brief Polyphase filterbank arbitrary resampler with
* gr_complex input, gr_complex output and float taps
* \ingroup resamplers_blk
*
* \details
* This takes in a signal stream and performs arbitrary
* resampling. The resampling rate can be any real number
* r. The resampling is done by constructing N
* filters where N is the interpolation rate. We then
* calculate D where D = floor(N/r).
*
* Using N and D, we can perform rational
* resampling where N/D is a rational number close to
* the input rate r where we have N filters
* and we cycle through them as a polyphase filterbank with a
* stride of D so that i+1 = (i + D) % N.
*
* To get the arbitrary rate, we want to interpolate between two
* points. For each value out, we take an output from the
* current filter, i, and the next filter i+1
* and then linearly interpolate between the two based on the
* real resampling rate we want.
*
* The linear interpolation only provides us with an
* approximation to the real sampling rate specified. The error
* is a quantization error between the two filters we used as
* our interpolation points. To this end, the number of
* filters, N, used determines the quantization error;
* the larger N, the smaller the noise. You can design
* for a specified noise floor by setting the filter size
* (parameters filter_size). The size defaults to 32
* filters, which is about as good as most implementations need.
*
* The trick with designing this filter is in how to specify the
* taps of the prototype filter. Like the PFB interpolator, the
* taps are specified using the interpolated filter rate. In
* this case, that rate is the input sample rate multiplied by
* the number of filters in the filterbank, which is also the
* interpolation rate. All other values should be relative to
* this rate.
*
* For example, for a 32-filter arbitrary resampler and using
* the GNU Radio's firdes utility to build the filter, we build
* a low-pass filter with a sampling rate of fs, a 3-dB
* bandwidth of BW and a transition bandwidth of
* TB. We can also specify the out-of-band attenuation
* to use, ATT, and the filter window function (a
* Blackman-harris window in this case). The first input is the
* gain of the filter, which we specify here as the
* interpolation rate (32).
*
* self._taps = filter.firdes.low_pass_2(32, 32*fs, BW, TB,
* attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)
*
* The theory behind this block can be found in Chapter 7.5 of
* the following book.
*
* f. harris, "Multirate Signal Processing for Communication
* Systems", Upper Saddle River, NJ: Prentice Hall, Inc. 2004.
*/
class FILTER_API pfb_arb_resampler_ccf
{
private:
std::vector d_filters;
std::vector d_diff_filters;
std::vector< std::vector > d_taps;
std::vector< std::vector > d_dtaps;
unsigned int d_int_rate; // the number of filters (interpolation rate)
unsigned int d_dec_rate; // the stride through the filters (decimation rate)
float d_flt_rate; // residual rate for the linear interpolation
float d_acc; // accumulator; holds fractional part of sample
unsigned int d_last_filter; // stores filter for re-entry
unsigned int d_taps_per_filter; // num taps for each arm of the filterbank
int d_delay; // filter's group delay
float d_est_phase_change; // est. of phase change of a sine wave through filt.
/*!
* Takes in the taps and convolves them with [-1,0,1], which
* creates a differential set of taps that are used in the
* difference filterbank.
* \param newtaps (vector of floats) The prototype filter.
* \param difftaps (vector of floats) (out) The differential filter taps.
*/
void create_diff_taps(const std::vector &newtaps,
std::vector &difftaps);
/*!
* Resets the filterbank's filter taps with the new prototype filter
* \param newtaps (vector of floats) The prototype filter to populate the filterbank.
* The taps should be generated at the interpolated sampling rate.
* \param ourtaps (vector of floats) Reference to our internal member of holding the taps.
* \param ourfilter (vector of filters) Reference to our internal filter to set the taps for.
*/
void create_taps(const std::vector &newtaps,
std::vector< std::vector > &ourtaps,
std::vector &ourfilter);
public:
/*!
* Creates a kernel to perform arbitrary resampling on a set of samples.
* \param rate (float) Specifies the resampling rate to use
* \param taps (vector/list of floats) The prototype filter to populate the filterbank. The taps * should be generated at the filter_size sampling rate.
* \param filter_size (unsigned int) The number of filters in the filter bank. This is directly
* related to quantization noise introduced during the resampling.
* Defaults to 32 filters.
*/
pfb_arb_resampler_ccf(float rate,
const std::vector &taps,
unsigned int filter_size);
~pfb_arb_resampler_ccf();
/*!
* Resets the filterbank's filter taps with the new prototype filter
* \param taps (vector/list of floats) The prototype filter to populate the filterbank.
*/
void set_taps(const std::vector &taps);
/*!
* Return a vector> of the filterbank taps
*/
std::vector > taps() const;
/*!
* Print all of the filterbank taps to screen.
*/
void print_taps();
/*!
* Sets the resampling rate of the block.
*/
void set_rate(float rate);
/*!
* Sets the current phase offset in radians (0 to 2pi).
*/
void set_phase(float ph);
/*!
* Gets the current phase of the resampler in radians (2 to 2pi).
*/
float phase() const;
/*!
* Gets the number of taps per filter.
*/
unsigned int taps_per_filter() const;
unsigned int interpolation_rate() const { return d_int_rate; }
unsigned int decimation_rate() const { return d_dec_rate; }
float fractional_rate() const { return d_flt_rate; }
/*!
* Get the group delay of the filter.
*/
int group_delay() const { return d_delay; }
/*!
* Calculates the phase offset expected by a sine wave of
* frequency \p freq and sampling rate \p fs (assuming input
* sine wave has 0 degree phase).
*/
float phase_offset(float freq, float fs);
/*!
* Performs the filter operation that resamples the signal.
*
* This block takes in a stream of samples and outputs a
* resampled and filtered stream. This block should be called
* such that the output has \p rate * \p n_to_read amount of
* space available in the \p output buffer.
*
* \param input An input vector of samples to be resampled
* \param output The output samples at the new sample rate.
* \param n_to_read Number of samples to read from \p input.
* \param n_read (out) Number of samples actually read from \p input.
* \return Number of samples put into \p output.
*/
int filter(gr_complex *input, gr_complex *output,
int n_to_read, int &n_read);
};
/**************************************************************/
/*!
* \brief Polyphase filterbank arbitrary resampler with
* float input, float output and float taps
* \ingroup resamplers_blk
*
* \details
* This takes in a signal stream and performs arbitrary
* resampling. The resampling rate can be any real number
* r. The resampling is done by constructing N
* filters where N is the interpolation rate. We then
* calculate D where D = floor(N/r).
*
* Using N and D, we can perform rational
* resampling where N/D is a rational number close to
* the input rate r where we have N filters
* and we cycle through them as a polyphase filterbank with a
* stride of D so that i+1 = (i + D) % N.
*
* To get the arbitrary rate, we want to interpolate between two
* points. For each value out, we take an output from the
* current filter, i, and the next filter i+1
* and then linearly interpolate between the two based on the
* real resampling rate we want.
*
* The linear interpolation only provides us with an
* approximation to the real sampling rate specified. The error
* is a quantization error between the two filters we used as
* our interpolation points. To this end, the number of
* filters, N, used determines the quantization error;
* the larger N, the smaller the noise. You can design
* for a specified noise floor by setting the filter size
* (parameters filter_size). The size defaults to 32
* filters, which is about as good as most implementations need.
*
* The trick with designing this filter is in how to specify the
* taps of the prototype filter. Like the PFB interpolator, the
* taps are specified using the interpolated filter rate. In
* this case, that rate is the input sample rate multiplied by
* the number of filters in the filterbank, which is also the
* interpolation rate. All other values should be relative to
* this rate.
*
* For example, for a 32-filter arbitrary resampler and using
* the GNU Radio's firdes utility to build the filter, we build
* a low-pass filter with a sampling rate of fs, a 3-dB
* bandwidth of BW and a transition bandwidth of
* TB. We can also specify the out-of-band attenuation
* to use, ATT, and the filter window function (a
* Blackman-harris window in this case). The first input is the
* gain of the filter, which we specify here as the
* interpolation rate (32).
*
* self._taps = filter.firdes.low_pass_2(32, 32*fs, BW, TB,
* attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)
*
* The theory behind this block can be found in Chapter 7.5 of
* the following book.
*
* f. harris, "Multirate Signal Processing for Communication
* Systems", Upper Saddle River, NJ: Prentice Hall, Inc. 2004.
*/
class FILTER_API pfb_arb_resampler_fff
{
private:
std::vector d_filters;
std::vector d_diff_filters;
std::vector< std::vector > d_taps;
std::vector< std::vector > d_dtaps;
unsigned int d_int_rate; // the number of filters (interpolation rate)
unsigned int d_dec_rate; // the stride through the filters (decimation rate)
float d_flt_rate; // residual rate for the linear interpolation
float d_acc; // accumulator; holds fractional part of sample
unsigned int d_last_filter; // stores filter for re-entry
unsigned int d_taps_per_filter; // num taps for each arm of the filterbank
int d_delay; // filter's group delay
float d_est_phase_change; // est. of phase change of a sine wave through filt.
/*!
* Takes in the taps and convolves them with [-1,0,1], which
* creates a differential set of taps that are used in the
* difference filterbank.
* \param newtaps (vector of floats) The prototype filter.
* \param difftaps (vector of floats) (out) The differential filter taps.
*/
void create_diff_taps(const std::vector &newtaps,
std::vector &difftaps);
/*!
* Resets the filterbank's filter taps with the new prototype filter
* \param newtaps (vector of floats) The prototype filter to populate the filterbank.
* The taps should be generated at the interpolated sampling rate.
* \param ourtaps (vector of floats) Reference to our internal member of holding the taps.
* \param ourfilter (vector of filters) Reference to our internal filter to set the taps for.
*/
void create_taps(const std::vector &newtaps,
std::vector< std::vector > &ourtaps,
std::vector &ourfilter);
public:
/*!
* Creates a kernel to perform arbitrary resampling on a set of samples.
* \param rate (float) Specifies the resampling rate to use
* \param taps (vector/list of floats) The prototype filter to populate the filterbank. The taps * should be generated at the filter_size sampling rate.
* \param filter_size (unsigned int) The number of filters in the filter bank. This is directly
* related to quantization noise introduced during the resampling.
* Defaults to 32 filters.
*/
pfb_arb_resampler_fff(float rate,
const std::vector &taps,
unsigned int filter_size);
~pfb_arb_resampler_fff();
/*!
* Resets the filterbank's filter taps with the new prototype filter
* \param taps (vector/list of floats) The prototype filter to populate the filterbank.
*/
void set_taps(const std::vector &taps);
/*!
* Return a vector> of the filterbank taps
*/
std::vector > taps() const;
/*!
* Print all of the filterbank taps to screen.
*/
void print_taps();
/*!
* Sets the resampling rate of the block.
*/
void set_rate(float rate);
/*!
* Sets the current phase offset in radians (0 to 2pi).
*/
void set_phase(float ph);
/*!
* Gets the current phase of the resampler in radians (2 to 2pi).
*/
float phase() const;
/*!
* Gets the number of taps per filter.
*/
unsigned int taps_per_filter() const;
unsigned int interpolation_rate() const { return d_int_rate; }
unsigned int decimation_rate() const { return d_dec_rate; }
float fractional_rate() const { return d_flt_rate; }
/*!
* Get the group delay of the filter.
*/
int group_delay() const { return d_delay; }
/*!
* Calculates the phase offset expected by a sine wave of
* frequency \p freq and sampling rate \p fs (assuming input
* sine wave has 0 degree phase).
*/
float phase_offset(float freq, float fs);
/*!
* Performs the filter operation that resamples the signal.
*
* This block takes in a stream of samples and outputs a
* resampled and filtered stream. This block should be called
* such that the output has \p rate * \p n_to_read amount of
* space available in the \p output buffer.
*
* \param input An input vector of samples to be resampled
* \param output The output samples at the new sample rate.
* \param n_to_read Number of samples to read from \p input.
* \param n_read (out) Number of samples actually read from \p input.
* \return Number of samples put into \p output.
*/
int filter(float *input, float *output,
int n_to_read, int &n_read);
};
} /* namespace kernel */
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_PFB_ARB_RESAMPLER_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/pfb_synthesizer_ccf.h 0000664 0001750 0001750 00000007013 12207440367 026147 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2010,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.
*/
#ifndef INCLUDED_PFB_SYNTHESIZER_CCF_H
#define INCLUDED_PFB_SYNTHESIZER_CCF_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Polyphase synthesis filterbank with
* gr_complex input, gr_complex output and float taps
* \ingroup channelizers_blk
*/
class FILTER_API pfb_synthesizer_ccf : virtual public sync_interpolator
{
public:
// gr::filter::pfb_synthesizer_ccf::sptr
typedef boost::shared_ptr sptr;
/*!
* Build the polyphase synthesis filterbank.
* \param numchans (unsigned integer) Specifies the number of
* channels M
* \param taps (vector/list of floats) The prototype filter to
* populate the filterbank.
* \param twox (bool) use 2x oversampling or not (default is no)
*/
static sptr make(unsigned int numchans,
const std::vector &taps,
bool twox=false);
/*!
* Resets the filterbank's filter taps with the new prototype filter
* \param taps (vector/list of floats) The prototype filter to
* populate the filterbank.
*/
virtual void set_taps(const std::vector &taps) = 0;
/*!
* Print all of the filterbank taps to screen.
*/
virtual void print_taps() = 0;
/*!
* Return a vector> of the filterbank taps
*/
virtual std::vector > taps() const = 0;
/*!
* Set the channel map. Channels are numbers as:
* N/2+1 | ... | N-1 | 0 | 1 | 2 | ... | N/2
* <------------------- 0 -------------------->
* freq
*
* So input stream 0 goes to channel 0, etc. Setting a new channel
* map allows the user to specify where in frequency he/she wants
* the input stream to go. This is especially useful to avoid
* putting signals into the channels on the edge of the spectrum
* which can either wrap around (in the case of odd number of
* channels) and be affected by filter rolloff in the transmitter.
*
* The map must be at least the number of streams being sent to the
* block. Less and the algorithm will not have enough data to
* properly setup the buffers. Any more channels specified will be
* ignored.
*/
virtual void set_channel_map(const std::vector &map) = 0;
/*!
* Gets the current channel map.
*/
virtual std::vector channel_map() const = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_PFB_SYNTHESIZER_CCF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/pm_remez.h 0000664 0001750 0001750 00000005067 12207440367 023743 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2004,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.
*/
#ifndef INCLUDED_FILTER_PM_REMEZ_H
#define INCLUDED_FILTER_PM_REMEZ_H
#include
#include
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Parks-McClellan FIR filter design using Remez algorithm.
* \ingroup filter_design
*
* \details
* Calculates the optimal (in the Chebyshev/minimax sense) FIR
* filter inpulse reponse given a set of band edges, the desired
* reponse on those bands, and the weight given to the error in
* those bands.
*
* \param order filter order (number of taps in the returned filter - 1)
* \param bands frequency at the band edges [ b1 e1 b2 e2 b3 e3 ...]
* \param ampl desired amplitude at the band edges [ a(b1) a(e1) a(b2) a(e2) ...]
* \param error_weight weighting applied to each band (usually 1)
* \param filter_type one of "bandpass", "hilbert" or "differentiator"
* \param grid_density determines how accurately the filter will be constructed. \
* The minimum value is 16; higher values are slower to compute.
*
* Frequency is in the range [0, 1], with 1 being the Nyquist
* frequency (Fs/2)
*
* \returns vector of computed taps
*
* \throws std::runtime_error if args are invalid or calculation
* fails to converge.
*/
FILTER_API std::vector
pm_remez(int order,
const std::vector &bands,
const std::vector &l,
const std::vector &error_weight,
const std::string filter_type = "bandpass",
int grid_density = 16
) throw (std::runtime_error);
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_PM_REMEZ_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/pfb_interpolator_ccf.h 0000664 0001750 0001750 00000010777 12207440367 026315 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 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.
*/
#ifndef INCLUDED_PFB_INTERPOLATOR_CCF_H
#define INCLUDED_PFB_INTERPOLATOR_CCF_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Polyphase filterbank interpolator with gr_complex input,
* gr_complex output and float taps
* \ingroup channelizers_blk
*
* \details
* This block takes in a signal stream and performs interger up-
* sampling (interpolation) with a polyphase filterbank. The first
* input is the integer specifying how much to interpolate by. The
* second input is a vector (Python list) of floating-point taps
* of the prototype filter.
*
* The filter's taps should be based on the interpolation rate
* specified. That is, the bandwidth specified is relative to the
* bandwidth after interpolation.
*
* For example, using the GNU Radio's firdes utility to building
* filters, we build a low-pass filter with a sampling rate of
* fs, a 3-dB bandwidth of BW and a transition
* bandwidth of TB. We can also specify the out-of-band
* attenuation to use, ATT, and the filter window function (a
* Blackman-harris window in this case). The first input is the
* gain, which is also specified as the interpolation rate so that
* the output levels are the same as the input (this creates an
* overall increase in power).
*
* self._taps = filter.firdes.low_pass_2(interp, interp*fs, BW, TB,
* attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)
*
* The PFB interpolator code takes the taps generated above and
* builds a set of filters. The set contains interp
* number of filters and each filter contains
* ceil(taps.size()/interp) number of taps. Each tap from the
* filter prototype is sequentially inserted into the next
* filter. When all of the input taps are used, the remaining
* filters in the filterbank are filled out with 0's to make sure
* each filter has the same number of taps.
*
* The theory behind this block can be found in Chapter 7.1 of the
* following book.
*
* f. harris, "Multirate Signal Processing for Communication
* Systems," Upper Saddle River, NJ: Prentice Hall,
* Inc. 2004.
*/
class FILTER_API pfb_interpolator_ccf : virtual public sync_interpolator
{
public:
// gr::filter::pfb_interpolator_ccf::sptr
typedef boost::shared_ptr sptr;
/*!
* Build the polyphase filterbank interpolator.
* \param interp (unsigned integer) Specifies the interpolation rate to use
* \param taps (vector/list of floats) The prototype filter to populate the filterbank. The taps
* should be generated at the interpolated sampling rate.
*/
static sptr make(unsigned int interp,
const std::vector &taps);
/*!
* Resets the filterbank's filter taps with the new prototype filter
* \param taps (vector/list of floats) The prototype filter to populate the filterbank.
* The taps should be generated at the interpolated sampling rate.
*/
virtual void set_taps(const std::vector &taps) = 0;
/*!
* Return a vector> of the filterbank taps
*/
virtual std::vector > taps() const = 0;
/*!
* Print all of the filterbank taps to screen.
*/
virtual void print_taps() = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_PFB_INTERPOLATOR_CCF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/single_pole_iir.h 0000664 0001750 0001750 00000011775 12207440367 025273 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2002,2006,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.
*/
#ifndef INCLUDED_SINGLE_POLE_IIR_H
#define INCLUDED_SINGLE_POLE_IIR_H
#include
#include
#include
namespace gr {
namespace filter {
/*!
* \brief class template for single pole IIR filter
*/
template
class single_pole_iir
{
public:
/*!
* \brief construct new single pole IIR with given alpha
*
* computes y(i) = (1-alpha) * y(i-1) + alpha * x(i)
*/
single_pole_iir(tap_type alpha = 1.0)
{
d_prev_output = 0;
set_taps(alpha);
}
/*!
* \brief compute a single output value.
* \returns the filtered input value.
*/
o_type filter(const i_type input);
/*!
* \brief compute an array of N output values.
* \p input must have n valid entries.
*/
void filterN(o_type output[], const i_type input[], unsigned long n);
/*!
* \brief install \p alpha as the current taps.
*/
void set_taps(tap_type alpha)
{
if(alpha < 0 || alpha > 1)
throw std::out_of_range("Alpha must be in [0, 1]\n");
d_alpha = alpha;
d_one_minus_alpha = 1.0 - alpha;
}
//! reset state to zero
void reset()
{
d_prev_output = 0;
}
o_type prev_output() const { return d_prev_output; }
protected:
tap_type d_alpha;
tap_type d_one_minus_alpha;
o_type d_prev_output;
};
//
// general case. We may want to specialize this
//
template
o_type
single_pole_iir::filter(const i_type input)
{
o_type output;
output = d_alpha * input + d_one_minus_alpha * d_prev_output;
d_prev_output = output;
return (o_type) output;
}
template
void
single_pole_iir::filterN(o_type output[],
const i_type input[],
unsigned long n)
{
for(unsigned i = 0; i < n; i++)
output[i] = filter(input[i]);
}
//
// Specialized case for gr_complex output and double taps
// We need to have a gr_complexd type for the calculations and prev_output variable (in stead of double)
template
class single_pole_iir
{
public:
/*!
* \brief construct new single pole IIR with given alpha
*
* computes y(i) = (1-alpha) * y(i-1) + alpha * x(i)
*/
single_pole_iir(double alpha = 1.0)
{
d_prev_output = 0;
set_taps(alpha);
}
/*!
* \brief compute a single output value.
* \returns the filtered input value.
*/
gr_complex filter(const i_type input);
/*!
* \brief compute an array of N output values.
* \p input must have n valid entries.
*/
void filterN(gr_complex output[], const i_type input[], unsigned long n);
/*!
* \brief install \p alpha as the current taps.
*/
void set_taps(double alpha)
{
if(alpha < 0 || alpha > 1)
throw std::out_of_range("Alpha must be in [0, 1]\n");
d_alpha = alpha;
d_one_minus_alpha = 1.0 - alpha;
}
//! reset state to zero
void reset()
{
d_prev_output = 0;
}
gr_complexd prev_output() const { return d_prev_output; }
protected:
double d_alpha;
double d_one_minus_alpha;
gr_complexd d_prev_output;
};
template< class i_type>
gr_complex
single_pole_iir::filter(const i_type input)
{
gr_complexd output;
output = d_alpha * (gr_complexd)input + d_one_minus_alpha * d_prev_output;
d_prev_output = output;
return (gr_complex) output;
}
//Do we need to specialize this, although it is the same as the general case?
template
void
single_pole_iir::filterN(gr_complex output[],
const i_type input[],
unsigned long n)
{
for(unsigned i = 0; i < n; i++)
output[i] = filter(input[i]);
}
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_SINGLE_POLE_IIR_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/fft_filter.h 0000664 0001750 0001750 00000013160 12237515112 024234 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2010,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.
*/
#ifndef INCLUDED_FILTER_FFT_FILTER_H
#define INCLUDED_FILTER_FFT_FILTER_H
#include
#include
#include
#include
namespace gr {
namespace filter {
namespace kernel {
/*!
* \brief Fast FFT filter with float input, float output and float taps
* \ingroup filter_blk
*/
class FILTER_API fft_filter_fff
{
private:
int d_ntaps;
int d_nsamples;
int d_fftsize; // fftsize = ntaps + nsamples - 1
int d_decimation;
fft::fft_real_fwd *d_fwdfft; // forward "plan"
fft::fft_real_rev *d_invfft; // inverse "plan"
int d_nthreads; // number of FFTW threads to use
std::vector d_tail; // state carried between blocks for overlap-add
std::vector d_taps; // stores time domain taps
gr_complex *d_xformed_taps; // Fourier xformed taps
void compute_sizes(int ntaps);
int tailsize() const { return d_ntaps - 1; }
public:
/*!
* \brief Construct an FFT filter for float vectors with the given taps and decimation rate.
*
* This is the basic implementation for performing FFT filter for fast convolution
* in other blocks for complex vectors (such as fft_filter_ccc).
*
* \param decimation The decimation rate of the filter (int)
* \param taps The filter taps (complex)
* \param nthreads The number of threads for the FFT to use (int)
*/
fft_filter_fff(int decimation,
const std::vector &taps,
int nthreads=1);
~fft_filter_fff();
/*!
* \brief Set new taps for the filter.
*
* Sets new taps and resets the class properties to handle different sizes
* \param taps The filter taps (complex)
*/
int set_taps(const std::vector &taps);
/*!
* \brief Set number of threads to use.
*/
void set_nthreads(int n);
/*!
* \brief Returns the taps.
*/
std::vector taps() const;
/*!
* \brief Returns the number of taps in the filter.
*/
unsigned int ntaps() const;
/*!
* \brief Get number of threads being used.
*/
int nthreads() const;
/*!
l * \brief Perform the filter operation
*
* \param nitems The number of items to produce
* \param input The input vector to be filtered
* \param output The result of the filter operation
*/
int filter(int nitems, const float *input, float *output);
};
/*!
* \brief Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps
* \ingroup filter_blk
*/
class FILTER_API fft_filter_ccc
{
private:
int d_ntaps;
int d_nsamples;
int d_fftsize; // fftsize = ntaps + nsamples - 1
int d_decimation;
fft::fft_complex *d_fwdfft; // forward "plan"
fft::fft_complex *d_invfft; // inverse "plan"
int d_nthreads; // number of FFTW threads to use
std::vector d_tail; // state carried between blocks for overlap-add
std::vector d_taps; // stores time domain taps
gr_complex *d_xformed_taps; // Fourier xformed taps
void compute_sizes(int ntaps);
int tailsize() const { return d_ntaps - 1; }
public:
/*!
* \brief Construct an FFT filter for complex vectors with the given taps and decimation rate.
*
* This is the basic implementation for performing FFT filter for fast convolution
* in other blocks for complex vectors (such as fft_filter_ccc).
*
* \param decimation The decimation rate of the filter (int)
* \param taps The filter taps (complex)
* \param nthreads The number of threads for the FFT to use (int)
*/
fft_filter_ccc(int decimation,
const std::vector &taps,
int nthreads=1);
~fft_filter_ccc();
/*!
* \brief Set new taps for the filter.
*
* Sets new taps and resets the class properties to handle different sizes
* \param taps The filter taps (complex)
*/
int set_taps(const std::vector &taps);
/*!
* \brief Set number of threads to use.
*/
void set_nthreads(int n);
/*!
* \brief Returns the taps.
*/
std::vector taps() const;
/*!
* \brief Returns the number of taps in the filter.
*/
unsigned int ntaps() const;
/*!
* \brief Get number of threads being used.
*/
int nthreads() const;
/*!
* \brief Perform the filter operation
*
* \param nitems The number of items to produce
* \param input The input vector to be filtered
* \param output The result of the filter operation
*/
int filter(int nitems, const gr_complex *input, gr_complex *output);
};
} /* namespace kernel */
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_FFT_FILTER_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/firdes.h 0000664 0001750 0001750 00000036406 12237515112 023374 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2002,2008,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.
*/
#ifndef _FILTER_FIRDES_H_
#define _FILTER_FIRDES_H_
#include
#include
#include
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Finite Impulse Response (FIR) filter design functions.
* \ingroup filter_design
*/
class FILTER_API firdes {
public:
// WARNING: deprecated, now located in gr::fft::window.
// We will be removing this in 3.8.
enum win_type {
WIN_NONE = -1, //!< don't use a window
WIN_HAMMING = 0, //!< Hamming window; max attenuation 53 dB
WIN_HANN = 1, //!< Hann window; max attenuation 44 dB
WIN_BLACKMAN = 2, //!< Blackman window; max attenuation 74 dB
WIN_RECTANGULAR = 3, //!< Basic rectangular window
WIN_KAISER = 4, //!< Kaiser window; max attenuation a function of beta, google it
WIN_BLACKMAN_hARRIS = 5, //!< Blackman-harris window
WIN_BLACKMAN_HARRIS = 5, //!< alias to WIN_BLACKMAN_hARRIS for capitalization consistency
WIN_BARTLETT = 6, //!< Barlett (triangular) window
WIN_FLATTOP = 7, //!< flat top window; useful in FFTs
};
static std::vector window(win_type type, int ntaps, double beta);
// ... class methods ...
/*!
* \brief use "window method" to design a low-pass FIR filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p cutoff_freq: center of transition band (Hz)
* \p transition_width: width of transition band (Hz).
* The normalized width of the transition
* band is what sets the number of taps
* required. Narrow --> more taps
* \p window_type: What kind of window to use. Determines
* maximum attenuation and passband ripple.
* \p beta: parameter for Kaiser window
*/
static std::vector
low_pass(double gain,
double sampling_freq,
double cutoff_freq, // Hz center of transition band
double transition_width, // Hz width of transition band
win_type window = WIN_HAMMING,
double beta = 6.76); // used only with Kaiser
/*!
* \brief use "window method" to design a low-pass FIR filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p cutoff_freq: center of transition band (Hz)
* \p transition_width: width of transition band (Hz).
* \p attenuation_dB required stopband attenuation
* The normalized width of the transition
* band and the required stop band
* attenuation is what sets the number of taps
* required. Narrow --> more taps
* More attenuatin --> more taps
* \p window_type: What kind of window to use. Determines
* maximum attenuation and passband ripple.
* \p beta: parameter for Kaiser window
*/
static std::vector
low_pass_2(double gain,
double sampling_freq,
double cutoff_freq, // Hz beginning transition band
double transition_width, // Hz width of transition band
double attenuation_dB, // out of band attenuation dB
win_type window = WIN_HAMMING,
double beta = 6.76); // used only with Kaiser
/*!
* \brief use "window method" to design a high-pass FIR filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p cutoff_freq: center of transition band (Hz)
* \p transition_width: width of transition band (Hz).
* The normalized width of the transition
* band is what sets the number of taps
* required. Narrow --> more taps
* \p window_type: What kind of window to use. Determines
* maximum attenuation and passband ripple.
* \p beta: parameter for Kaiser window
*/
static std::vector
high_pass(double gain,
double sampling_freq,
double cutoff_freq, // Hz center of transition band
double transition_width, // Hz width of transition band
win_type window = WIN_HAMMING,
double beta = 6.76); // used only with Kaiser
/*!
* \brief use "window method" to design a high-pass FIR filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p cutoff_freq: center of transition band (Hz)
* \p transition_width: width of transition band (Hz).
* \p attenuation_dB out of band attenuation
* The normalized width of the transition
* band and the required stop band
* attenuation is what sets the number of taps
* required. Narrow --> more taps
* More attenuation --> more taps
* \p window_type: What kind of window to use. Determines
* maximum attenuation and passband ripple.
* \p beta: parameter for Kaiser window
*/
static std::vector
high_pass_2(double gain,
double sampling_freq,
double cutoff_freq, // Hz center of transition band
double transition_width, // Hz width of transition band
double attenuation_dB, // out of band attenuation dB
win_type window = WIN_HAMMING,
double beta = 6.76); // used only with Kaiser
/*!
* \brief use "window method" to design a band-pass FIR filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p low_cutoff_freq: center of transition band (Hz)
* \p high_cutoff_freq: center of transition band (Hz)
* \p transition_width: width of transition band (Hz).
* The normalized width of the transition
* band is what sets the number of taps
* required. Narrow --> more taps
* \p window_type: What kind of window to use. Determines
* maximum attenuation and passband ripple.
* \p beta: parameter for Kaiser window
*/
static std::vector
band_pass(double gain,
double sampling_freq,
double low_cutoff_freq, // Hz center of transition band
double high_cutoff_freq, // Hz center of transition band
double transition_width, // Hz width of transition band
win_type window = WIN_HAMMING,
double beta = 6.76); // used only with Kaiser
/*!
* \brief use "window method" to design a band-pass FIR filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p low_cutoff_freq: center of transition band (Hz)
* \p high_cutoff_freq: center of transition band (Hz)
* \p transition_width: width of transition band (Hz).
* \p attenuation_dB out of band attenuation
* The normalized width of the transition
* band and the required stop band
* attenuation is what sets the number of taps
* required. Narrow --> more taps
* More attenuation --> more taps
* \p window_type: What kind of window to use. Determines
* maximum attenuation and passband ripple.
* \p beta: parameter for Kaiser window
*/
static std::vector
band_pass_2(double gain,
double sampling_freq,
double low_cutoff_freq, // Hz beginning transition band
double high_cutoff_freq, // Hz beginning transition band
double transition_width, // Hz width of transition band
double attenuation_dB, // out of band attenuation dB
win_type window = WIN_HAMMING,
double beta = 6.76); // used only with Kaiser
/*!
* \brief use "window method" to design a complex band-pass FIR filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p low_cutoff_freq: center of transition band (Hz)
* \p high_cutoff_freq: center of transition band (Hz)
* \p transition_width: width of transition band (Hz).
* The normalized width of the transition
* band is what sets the number of taps
* required. Narrow --> more taps
* \p window_type: What kind of window to use. Determines
* maximum attenuation and passband ripple.
* \p beta: parameter for Kaiser window
*/
static std::vector
complex_band_pass(double gain,
double sampling_freq,
double low_cutoff_freq, // Hz center of transition band
double high_cutoff_freq, // Hz center of transition band
double transition_width, // Hz width of transition band
win_type window = WIN_HAMMING,
double beta = 6.76); // used only with Kaiser
/*!
* \brief use "window method" to design a complex band-pass FIR filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p low_cutoff_freq: center of transition band (Hz)
* \p high_cutoff_freq: center of transition band (Hz)
* \p transition_width: width of transition band (Hz).
* \p attenuation_dB out of band attenuation
* The normalized width of the transition
* band and the required stop band
* attenuation is what sets the number of taps
* required. Narrow --> more taps
* More attenuation --> more taps
* \p window_type: What kind of window to use. Determines
* maximum attenuation and passband ripple.
* \p beta: parameter for Kaiser window
*/
static std::vector
complex_band_pass_2(double gain,
double sampling_freq,
double low_cutoff_freq, // Hz beginning transition band
double high_cutoff_freq, // Hz beginning transition band
double transition_width, // Hz width of transition band
double attenuation_dB, // out of band attenuation dB
win_type window = WIN_HAMMING,
double beta = 6.76); // used only with Kaiser
/*!
* \brief use "window method" to design a band-reject FIR filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p low_cutoff_freq: center of transition band (Hz)
* \p high_cutoff_freq: center of transition band (Hz)
* \p transition_width: width of transition band (Hz).
* The normalized width of the transition
* band is what sets the number of taps
* required. Narrow --> more taps
* \p window_type: What kind of window to use. Determines
* maximum attenuation and passband ripple.
* \p beta: parameter for Kaiser window
*/
static std::vector
band_reject(double gain,
double sampling_freq,
double low_cutoff_freq, // Hz center of transition band
double high_cutoff_freq, // Hz center of transition band
double transition_width, // Hz width of transition band
win_type window = WIN_HAMMING,
double beta = 6.76); // used only with Kaiser
/*!
* \brief use "window method" to design a band-reject FIR filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p low_cutoff_freq: center of transition band (Hz)
* \p high_cutoff_freq: center of transition band (Hz)
* \p transition_width: width of transition band (Hz).
* \p attenuation_dB out of band attenuation
* The normalized width of the transition
* band and the required stop band
* attenuation is what sets the number of taps
* required. Narrow --> more taps
* More attenuation --> more taps
* \p window_type: What kind of window to use. Determines
* maximum attenuation and passband ripple.
* \p beta: parameter for Kaiser window
*/
static std::vector
band_reject_2(double gain,
double sampling_freq,
double low_cutoff_freq, // Hz beginning transition band
double high_cutoff_freq, // Hz beginning transition band
double transition_width, // Hz width of transition band
double attenuation_dB, // out of band attenuation dB
win_type window = WIN_HAMMING,
double beta = 6.76); // used only with Kaiser
/*!\brief design a Hilbert Transform Filter
*
* \p ntaps: Number of taps, must be odd
* \p window_type: What kind of window to use
* \p beta: Only used for Kaiser
*/
static std::vector
hilbert(unsigned int ntaps = 19,
win_type windowtype = WIN_RECTANGULAR,
double beta = 6.76);
/*!
* \brief design a Root Cosine FIR Filter (do we need a window?)
*
* \p gain: overall gain of filter (typically 1.0)
* \p sampling_freq: sampling freq (Hz)
* \p symbol rate: symbol rate, must be a factor of sample rate
* \p alpha: excess bandwidth factor
* \p ntaps: number of taps
*/
static std::vector
root_raised_cosine(double gain,
double sampling_freq,
double symbol_rate, // Symbol rate, NOT bitrate (unless BPSK)
double alpha, // Excess Bandwidth Factor
int ntaps);
/*!
* \brief design a Gaussian filter
*
* \p gain: overall gain of filter (typically 1.0)
* \p symbols per bit: symbol rate, must be a factor of sample rate
* \p ntaps: number of taps
*/
static std::vector
gaussian(double gain,
double spb,
double bt, // Bandwidth to bitrate ratio
int ntaps);
private:
static double bessi0(double x);
static void sanity_check_1f(double sampling_freq, double f1,
double transition_width);
static void sanity_check_2f(double sampling_freq, double f1, double f2,
double transition_width);
static void sanity_check_2f_c(double sampling_freq, double f1, double f2,
double transition_width);
static int compute_ntaps(double sampling_freq,
double transition_width,
win_type window_type, double beta);
static int compute_ntaps_windes(double sampling_freq,
double transition_width,
double attenuation_dB);
};
} /* namespace filter */
} /* namespace gr */
#endif /* _FILTER_FIRDES_H_ */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/polyphase_filterbank.h 0000664 0001750 0001750 00000012614 12207440367 026326 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 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.
*/
#ifndef INCLUDED_FILTER_POLYPHASE_FILTERBANK_H
#define INCLUDED_FILTER_POLYPHASE_FILTERBANK_H
#include
#include
#include
namespace gr {
namespace filter {
namespace kernel {
/*!
* \brief Polyphase filterbank parent class
* \ingroup filter_blk
* \ingroup pfb_blk
*
* \details
* This block takes in complex inputs and channelizes it to
* M channels of equal bandwidth. Each of the resulting
* channels is decimated to the new rate that is the input
* sampling rate fs divided by the number of channels,
* M.
*
* The PFB channelizer code takes the taps generated above and
* builds a set of filters. The set contains M number
* of filters and each filter contains ceil(taps.size()/decim)
* number of taps. Each tap from the filter prototype is
* sequentially inserted into the next filter. When all of the
* input taps are used, the remaining filters in the filterbank
* are filled out with 0's to make sure each filter has the same
* number of taps.
*
* Each filter operates using the gr::filter::fir_filter_XXX
* classs of GNU Radio, which takes the input stream at
* i and performs the inner product calculation to
* i+(n-1) where n is the number of filter
* taps. To efficiently handle this in the GNU Radio structure,
* each filter input must come from its own input stream. So the
* channelizer must be provided with M streams where
* the input stream has been deinterleaved. This is most easily
* done using the gr::blocks::stream_to_streams block.
*
* The output is then produced as a vector, where index
* i in the vector is the next sample from the
* ith channel. This is most easily handled by sending
* the output to a gr::blocks::vector_to_streams block to handle
* the conversion and passing M streams out.
*
* The input and output formatting is done using a hier_block2
* called pfb_channelizer_ccf. This can take in a single stream
* and outputs M streams based on the behavior
* described above.
*
* The filter's taps should be based on the input sampling rate.
*
* For example, using the GNU Radio's firdes utility to building
* filters, we build a low-pass filter with a sampling rate of
* fs, a 3-dB bandwidth of BW and a transition
* bandwidth of TB. We can also specify the out-of-band
* attenuation to use, ATT, and the filter window
* function (a Blackman-harris window in this case). The first
* input is the gain of the filter, which we specify here as
* unity.
*
* self._taps = filter.firdes.low_pass_2(1, fs, BW, TB,
* attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)
*
* More on the theory of polyphase filterbanks can be found in
* the following book.
*
* f. harris, "Multirate Signal Processing for
* Communication Systems," Upper Saddle River, NJ:
* Prentice Hall, Inc. 2004.
*
*/
class FILTER_API polyphase_filterbank
{
protected:
unsigned int d_nfilts;
std::vector d_filters;
std::vector< std::vector > d_taps;
unsigned int d_taps_per_filter;
fft::fft_complex *d_fft;
public:
/*!
* Build the polyphase filterbank decimator.
* \param nfilts (unsigned integer) Specifies the number of
* channels M
* \param taps (vector/list of floats) The prototype filter to
* populate the filterbank.
*/
polyphase_filterbank(unsigned int nfilts,
const std::vector &taps);
~polyphase_filterbank();
/*!
* Update the filterbank's filter taps from a prototype
* filter.
*
* \param taps (vector/list of floats) The prototype filter to
* populate the filterbank.
*/
void set_taps(const std::vector &taps);
/*!
* Print all of the filterbank taps to screen.
*/
void print_taps();
/*!
* Return a vector> of the filterbank taps
*/
std::vector > taps() const;
};
} /* namespace kernel */
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_POLYPHASE_FILTERBANK_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/interpolator_taps.h 0000664 0001750 0001750 00000041114 12207440367 025667 0 ustar jcorgan jcorgan /*
* This file was machine generated by gen_interpolator_taps.
* DO NOT EDIT BY HAND.
*/
static const int NTAPS = 8;
static const int NSTEPS = 128;
static const float taps[NSTEPS+1][NTAPS] = {
// -4 -3 -2 -1 0 1 2 3 mu
{ 0.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00, 1.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00 }, // 0/128
{ -1.54700e-04, 8.53777e-04, -2.76968e-03, 7.89295e-03, 9.98534e-01, -5.41054e-03, 1.24642e-03, -1.98993e-04 }, // 1/128
{ -3.09412e-04, 1.70888e-03, -5.55134e-03, 1.58840e-02, 9.96891e-01, -1.07209e-02, 2.47942e-03, -3.96391e-04 }, // 2/128
{ -4.64053e-04, 2.56486e-03, -8.34364e-03, 2.39714e-02, 9.95074e-01, -1.59305e-02, 3.69852e-03, -5.92100e-04 }, // 3/128
{ -6.18544e-04, 3.42130e-03, -1.11453e-02, 3.21531e-02, 9.93082e-01, -2.10389e-02, 4.90322e-03, -7.86031e-04 }, // 4/128
{ -7.72802e-04, 4.27773e-03, -1.39548e-02, 4.04274e-02, 9.90917e-01, -2.60456e-02, 6.09305e-03, -9.78093e-04 }, // 5/128
{ -9.26747e-04, 5.13372e-03, -1.67710e-02, 4.87921e-02, 9.88580e-01, -3.09503e-02, 7.26755e-03, -1.16820e-03 }, // 6/128
{ -1.08030e-03, 5.98883e-03, -1.95925e-02, 5.72454e-02, 9.86071e-01, -3.57525e-02, 8.42626e-03, -1.35627e-03 }, // 7/128
{ -1.23337e-03, 6.84261e-03, -2.24178e-02, 6.57852e-02, 9.83392e-01, -4.04519e-02, 9.56876e-03, -1.54221e-03 }, // 8/128
{ -1.38589e-03, 7.69462e-03, -2.52457e-02, 7.44095e-02, 9.80543e-01, -4.50483e-02, 1.06946e-02, -1.72594e-03 }, // 9/128
{ -1.53777e-03, 8.54441e-03, -2.80746e-02, 8.31162e-02, 9.77526e-01, -4.95412e-02, 1.18034e-02, -1.90738e-03 }, // 10/128
{ -1.68894e-03, 9.39154e-03, -3.09033e-02, 9.19033e-02, 9.74342e-01, -5.39305e-02, 1.28947e-02, -2.08645e-03 }, // 11/128
{ -1.83931e-03, 1.02356e-02, -3.37303e-02, 1.00769e-01, 9.70992e-01, -5.82159e-02, 1.39681e-02, -2.26307e-03 }, // 12/128
{ -1.98880e-03, 1.10760e-02, -3.65541e-02, 1.09710e-01, 9.67477e-01, -6.23972e-02, 1.50233e-02, -2.43718e-03 }, // 13/128
{ -2.13733e-03, 1.19125e-02, -3.93735e-02, 1.18725e-01, 9.63798e-01, -6.64743e-02, 1.60599e-02, -2.60868e-03 }, // 14/128
{ -2.28483e-03, 1.27445e-02, -4.21869e-02, 1.27812e-01, 9.59958e-01, -7.04471e-02, 1.70776e-02, -2.77751e-03 }, // 15/128
{ -2.43121e-03, 1.35716e-02, -4.49929e-02, 1.36968e-01, 9.55956e-01, -7.43154e-02, 1.80759e-02, -2.94361e-03 }, // 16/128
{ -2.57640e-03, 1.43934e-02, -4.77900e-02, 1.46192e-01, 9.51795e-01, -7.80792e-02, 1.90545e-02, -3.10689e-03 }, // 17/128
{ -2.72032e-03, 1.52095e-02, -5.05770e-02, 1.55480e-01, 9.47477e-01, -8.17385e-02, 2.00132e-02, -3.26730e-03 }, // 18/128
{ -2.86289e-03, 1.60193e-02, -5.33522e-02, 1.64831e-01, 9.43001e-01, -8.52933e-02, 2.09516e-02, -3.42477e-03 }, // 19/128
{ -3.00403e-03, 1.68225e-02, -5.61142e-02, 1.74242e-01, 9.38371e-01, -8.87435e-02, 2.18695e-02, -3.57923e-03 }, // 20/128
{ -3.14367e-03, 1.76185e-02, -5.88617e-02, 1.83711e-01, 9.33586e-01, -9.20893e-02, 2.27664e-02, -3.73062e-03 }, // 21/128
{ -3.28174e-03, 1.84071e-02, -6.15931e-02, 1.93236e-01, 9.28650e-01, -9.53307e-02, 2.36423e-02, -3.87888e-03 }, // 22/128
{ -3.41815e-03, 1.91877e-02, -6.43069e-02, 2.02814e-01, 9.23564e-01, -9.84679e-02, 2.44967e-02, -4.02397e-03 }, // 23/128
{ -3.55283e-03, 1.99599e-02, -6.70018e-02, 2.12443e-01, 9.18329e-01, -1.01501e-01, 2.53295e-02, -4.16581e-03 }, // 24/128
{ -3.68570e-03, 2.07233e-02, -6.96762e-02, 2.22120e-01, 9.12947e-01, -1.04430e-01, 2.61404e-02, -4.30435e-03 }, // 25/128
{ -3.81671e-03, 2.14774e-02, -7.23286e-02, 2.31843e-01, 9.07420e-01, -1.07256e-01, 2.69293e-02, -4.43955e-03 }, // 26/128
{ -3.94576e-03, 2.22218e-02, -7.49577e-02, 2.41609e-01, 9.01749e-01, -1.09978e-01, 2.76957e-02, -4.57135e-03 }, // 27/128
{ -4.07279e-03, 2.29562e-02, -7.75620e-02, 2.51417e-01, 8.95936e-01, -1.12597e-01, 2.84397e-02, -4.69970e-03 }, // 28/128
{ -4.19774e-03, 2.36801e-02, -8.01399e-02, 2.61263e-01, 8.89984e-01, -1.15113e-01, 2.91609e-02, -4.82456e-03 }, // 29/128
{ -4.32052e-03, 2.43930e-02, -8.26900e-02, 2.71144e-01, 8.83893e-01, -1.17526e-01, 2.98593e-02, -4.94589e-03 }, // 30/128
{ -4.44107e-03, 2.50946e-02, -8.52109e-02, 2.81060e-01, 8.77666e-01, -1.19837e-01, 3.05345e-02, -5.06363e-03 }, // 31/128
{ -4.55932e-03, 2.57844e-02, -8.77011e-02, 2.91006e-01, 8.71305e-01, -1.22047e-01, 3.11866e-02, -5.17776e-03 }, // 32/128
{ -4.67520e-03, 2.64621e-02, -9.01591e-02, 3.00980e-01, 8.64812e-01, -1.24154e-01, 3.18153e-02, -5.28823e-03 }, // 33/128
{ -4.78866e-03, 2.71272e-02, -9.25834e-02, 3.10980e-01, 8.58189e-01, -1.26161e-01, 3.24205e-02, -5.39500e-03 }, // 34/128
{ -4.89961e-03, 2.77794e-02, -9.49727e-02, 3.21004e-01, 8.51437e-01, -1.28068e-01, 3.30021e-02, -5.49804e-03 }, // 35/128
{ -5.00800e-03, 2.84182e-02, -9.73254e-02, 3.31048e-01, 8.44559e-01, -1.29874e-01, 3.35600e-02, -5.59731e-03 }, // 36/128
{ -5.11376e-03, 2.90433e-02, -9.96402e-02, 3.41109e-01, 8.37557e-01, -1.31581e-01, 3.40940e-02, -5.69280e-03 }, // 37/128
{ -5.21683e-03, 2.96543e-02, -1.01915e-01, 3.51186e-01, 8.30432e-01, -1.33189e-01, 3.46042e-02, -5.78446e-03 }, // 38/128
{ -5.31716e-03, 3.02507e-02, -1.04150e-01, 3.61276e-01, 8.23188e-01, -1.34699e-01, 3.50903e-02, -5.87227e-03 }, // 39/128
{ -5.41467e-03, 3.08323e-02, -1.06342e-01, 3.71376e-01, 8.15826e-01, -1.36111e-01, 3.55525e-02, -5.95620e-03 }, // 40/128
{ -5.50931e-03, 3.13987e-02, -1.08490e-01, 3.81484e-01, 8.08348e-01, -1.37426e-01, 3.59905e-02, -6.03624e-03 }, // 41/128
{ -5.60103e-03, 3.19495e-02, -1.10593e-01, 3.91596e-01, 8.00757e-01, -1.38644e-01, 3.64044e-02, -6.11236e-03 }, // 42/128
{ -5.68976e-03, 3.24843e-02, -1.12650e-01, 4.01710e-01, 7.93055e-01, -1.39767e-01, 3.67941e-02, -6.18454e-03 }, // 43/128
{ -5.77544e-03, 3.30027e-02, -1.14659e-01, 4.11823e-01, 7.85244e-01, -1.40794e-01, 3.71596e-02, -6.25277e-03 }, // 44/128
{ -5.85804e-03, 3.35046e-02, -1.16618e-01, 4.21934e-01, 7.77327e-01, -1.41727e-01, 3.75010e-02, -6.31703e-03 }, // 45/128
{ -5.93749e-03, 3.39894e-02, -1.18526e-01, 4.32038e-01, 7.69305e-01, -1.42566e-01, 3.78182e-02, -6.37730e-03 }, // 46/128
{ -6.01374e-03, 3.44568e-02, -1.20382e-01, 4.42134e-01, 7.61181e-01, -1.43313e-01, 3.81111e-02, -6.43358e-03 }, // 47/128
{ -6.08674e-03, 3.49066e-02, -1.22185e-01, 4.52218e-01, 7.52958e-01, -1.43968e-01, 3.83800e-02, -6.48585e-03 }, // 48/128
{ -6.15644e-03, 3.53384e-02, -1.23933e-01, 4.62289e-01, 7.44637e-01, -1.44531e-01, 3.86247e-02, -6.53412e-03 }, // 49/128
{ -6.22280e-03, 3.57519e-02, -1.25624e-01, 4.72342e-01, 7.36222e-01, -1.45004e-01, 3.88454e-02, -6.57836e-03 }, // 50/128
{ -6.28577e-03, 3.61468e-02, -1.27258e-01, 4.82377e-01, 7.27714e-01, -1.45387e-01, 3.90420e-02, -6.61859e-03 }, // 51/128
{ -6.34530e-03, 3.65227e-02, -1.28832e-01, 4.92389e-01, 7.19116e-01, -1.45682e-01, 3.92147e-02, -6.65479e-03 }, // 52/128
{ -6.40135e-03, 3.68795e-02, -1.30347e-01, 5.02377e-01, 7.10431e-01, -1.45889e-01, 3.93636e-02, -6.68698e-03 }, // 53/128
{ -6.45388e-03, 3.72167e-02, -1.31800e-01, 5.12337e-01, 7.01661e-01, -1.46009e-01, 3.94886e-02, -6.71514e-03 }, // 54/128
{ -6.50285e-03, 3.75341e-02, -1.33190e-01, 5.22267e-01, 6.92808e-01, -1.46043e-01, 3.95900e-02, -6.73929e-03 }, // 55/128
{ -6.54823e-03, 3.78315e-02, -1.34515e-01, 5.32164e-01, 6.83875e-01, -1.45993e-01, 3.96678e-02, -6.75943e-03 }, // 56/128
{ -6.58996e-03, 3.81085e-02, -1.35775e-01, 5.42025e-01, 6.74865e-01, -1.45859e-01, 3.97222e-02, -6.77557e-03 }, // 57/128
{ -6.62802e-03, 3.83650e-02, -1.36969e-01, 5.51849e-01, 6.65779e-01, -1.45641e-01, 3.97532e-02, -6.78771e-03 }, // 58/128
{ -6.66238e-03, 3.86006e-02, -1.38094e-01, 5.61631e-01, 6.56621e-01, -1.45343e-01, 3.97610e-02, -6.79588e-03 }, // 59/128
{ -6.69300e-03, 3.88151e-02, -1.39150e-01, 5.71370e-01, 6.47394e-01, -1.44963e-01, 3.97458e-02, -6.80007e-03 }, // 60/128
{ -6.71985e-03, 3.90083e-02, -1.40136e-01, 5.81063e-01, 6.38099e-01, -1.44503e-01, 3.97077e-02, -6.80032e-03 }, // 61/128
{ -6.74291e-03, 3.91800e-02, -1.41050e-01, 5.90706e-01, 6.28739e-01, -1.43965e-01, 3.96469e-02, -6.79662e-03 }, // 62/128
{ -6.76214e-03, 3.93299e-02, -1.41891e-01, 6.00298e-01, 6.19318e-01, -1.43350e-01, 3.95635e-02, -6.78902e-03 }, // 63/128
{ -6.77751e-03, 3.94578e-02, -1.42658e-01, 6.09836e-01, 6.09836e-01, -1.42658e-01, 3.94578e-02, -6.77751e-03 }, // 64/128
{ -6.78902e-03, 3.95635e-02, -1.43350e-01, 6.19318e-01, 6.00298e-01, -1.41891e-01, 3.93299e-02, -6.76214e-03 }, // 65/128
{ -6.79662e-03, 3.96469e-02, -1.43965e-01, 6.28739e-01, 5.90706e-01, -1.41050e-01, 3.91800e-02, -6.74291e-03 }, // 66/128
{ -6.80032e-03, 3.97077e-02, -1.44503e-01, 6.38099e-01, 5.81063e-01, -1.40136e-01, 3.90083e-02, -6.71985e-03 }, // 67/128
{ -6.80007e-03, 3.97458e-02, -1.44963e-01, 6.47394e-01, 5.71370e-01, -1.39150e-01, 3.88151e-02, -6.69300e-03 }, // 68/128
{ -6.79588e-03, 3.97610e-02, -1.45343e-01, 6.56621e-01, 5.61631e-01, -1.38094e-01, 3.86006e-02, -6.66238e-03 }, // 69/128
{ -6.78771e-03, 3.97532e-02, -1.45641e-01, 6.65779e-01, 5.51849e-01, -1.36969e-01, 3.83650e-02, -6.62802e-03 }, // 70/128
{ -6.77557e-03, 3.97222e-02, -1.45859e-01, 6.74865e-01, 5.42025e-01, -1.35775e-01, 3.81085e-02, -6.58996e-03 }, // 71/128
{ -6.75943e-03, 3.96678e-02, -1.45993e-01, 6.83875e-01, 5.32164e-01, -1.34515e-01, 3.78315e-02, -6.54823e-03 }, // 72/128
{ -6.73929e-03, 3.95900e-02, -1.46043e-01, 6.92808e-01, 5.22267e-01, -1.33190e-01, 3.75341e-02, -6.50285e-03 }, // 73/128
{ -6.71514e-03, 3.94886e-02, -1.46009e-01, 7.01661e-01, 5.12337e-01, -1.31800e-01, 3.72167e-02, -6.45388e-03 }, // 74/128
{ -6.68698e-03, 3.93636e-02, -1.45889e-01, 7.10431e-01, 5.02377e-01, -1.30347e-01, 3.68795e-02, -6.40135e-03 }, // 75/128
{ -6.65479e-03, 3.92147e-02, -1.45682e-01, 7.19116e-01, 4.92389e-01, -1.28832e-01, 3.65227e-02, -6.34530e-03 }, // 76/128
{ -6.61859e-03, 3.90420e-02, -1.45387e-01, 7.27714e-01, 4.82377e-01, -1.27258e-01, 3.61468e-02, -6.28577e-03 }, // 77/128
{ -6.57836e-03, 3.88454e-02, -1.45004e-01, 7.36222e-01, 4.72342e-01, -1.25624e-01, 3.57519e-02, -6.22280e-03 }, // 78/128
{ -6.53412e-03, 3.86247e-02, -1.44531e-01, 7.44637e-01, 4.62289e-01, -1.23933e-01, 3.53384e-02, -6.15644e-03 }, // 79/128
{ -6.48585e-03, 3.83800e-02, -1.43968e-01, 7.52958e-01, 4.52218e-01, -1.22185e-01, 3.49066e-02, -6.08674e-03 }, // 80/128
{ -6.43358e-03, 3.81111e-02, -1.43313e-01, 7.61181e-01, 4.42134e-01, -1.20382e-01, 3.44568e-02, -6.01374e-03 }, // 81/128
{ -6.37730e-03, 3.78182e-02, -1.42566e-01, 7.69305e-01, 4.32038e-01, -1.18526e-01, 3.39894e-02, -5.93749e-03 }, // 82/128
{ -6.31703e-03, 3.75010e-02, -1.41727e-01, 7.77327e-01, 4.21934e-01, -1.16618e-01, 3.35046e-02, -5.85804e-03 }, // 83/128
{ -6.25277e-03, 3.71596e-02, -1.40794e-01, 7.85244e-01, 4.11823e-01, -1.14659e-01, 3.30027e-02, -5.77544e-03 }, // 84/128
{ -6.18454e-03, 3.67941e-02, -1.39767e-01, 7.93055e-01, 4.01710e-01, -1.12650e-01, 3.24843e-02, -5.68976e-03 }, // 85/128
{ -6.11236e-03, 3.64044e-02, -1.38644e-01, 8.00757e-01, 3.91596e-01, -1.10593e-01, 3.19495e-02, -5.60103e-03 }, // 86/128
{ -6.03624e-03, 3.59905e-02, -1.37426e-01, 8.08348e-01, 3.81484e-01, -1.08490e-01, 3.13987e-02, -5.50931e-03 }, // 87/128
{ -5.95620e-03, 3.55525e-02, -1.36111e-01, 8.15826e-01, 3.71376e-01, -1.06342e-01, 3.08323e-02, -5.41467e-03 }, // 88/128
{ -5.87227e-03, 3.50903e-02, -1.34699e-01, 8.23188e-01, 3.61276e-01, -1.04150e-01, 3.02507e-02, -5.31716e-03 }, // 89/128
{ -5.78446e-03, 3.46042e-02, -1.33189e-01, 8.30432e-01, 3.51186e-01, -1.01915e-01, 2.96543e-02, -5.21683e-03 }, // 90/128
{ -5.69280e-03, 3.40940e-02, -1.31581e-01, 8.37557e-01, 3.41109e-01, -9.96402e-02, 2.90433e-02, -5.11376e-03 }, // 91/128
{ -5.59731e-03, 3.35600e-02, -1.29874e-01, 8.44559e-01, 3.31048e-01, -9.73254e-02, 2.84182e-02, -5.00800e-03 }, // 92/128
{ -5.49804e-03, 3.30021e-02, -1.28068e-01, 8.51437e-01, 3.21004e-01, -9.49727e-02, 2.77794e-02, -4.89961e-03 }, // 93/128
{ -5.39500e-03, 3.24205e-02, -1.26161e-01, 8.58189e-01, 3.10980e-01, -9.25834e-02, 2.71272e-02, -4.78866e-03 }, // 94/128
{ -5.28823e-03, 3.18153e-02, -1.24154e-01, 8.64812e-01, 3.00980e-01, -9.01591e-02, 2.64621e-02, -4.67520e-03 }, // 95/128
{ -5.17776e-03, 3.11866e-02, -1.22047e-01, 8.71305e-01, 2.91006e-01, -8.77011e-02, 2.57844e-02, -4.55932e-03 }, // 96/128
{ -5.06363e-03, 3.05345e-02, -1.19837e-01, 8.77666e-01, 2.81060e-01, -8.52109e-02, 2.50946e-02, -4.44107e-03 }, // 97/128
{ -4.94589e-03, 2.98593e-02, -1.17526e-01, 8.83893e-01, 2.71144e-01, -8.26900e-02, 2.43930e-02, -4.32052e-03 }, // 98/128
{ -4.82456e-03, 2.91609e-02, -1.15113e-01, 8.89984e-01, 2.61263e-01, -8.01399e-02, 2.36801e-02, -4.19774e-03 }, // 99/128
{ -4.69970e-03, 2.84397e-02, -1.12597e-01, 8.95936e-01, 2.51417e-01, -7.75620e-02, 2.29562e-02, -4.07279e-03 }, // 100/128
{ -4.57135e-03, 2.76957e-02, -1.09978e-01, 9.01749e-01, 2.41609e-01, -7.49577e-02, 2.22218e-02, -3.94576e-03 }, // 101/128
{ -4.43955e-03, 2.69293e-02, -1.07256e-01, 9.07420e-01, 2.31843e-01, -7.23286e-02, 2.14774e-02, -3.81671e-03 }, // 102/128
{ -4.30435e-03, 2.61404e-02, -1.04430e-01, 9.12947e-01, 2.22120e-01, -6.96762e-02, 2.07233e-02, -3.68570e-03 }, // 103/128
{ -4.16581e-03, 2.53295e-02, -1.01501e-01, 9.18329e-01, 2.12443e-01, -6.70018e-02, 1.99599e-02, -3.55283e-03 }, // 104/128
{ -4.02397e-03, 2.44967e-02, -9.84679e-02, 9.23564e-01, 2.02814e-01, -6.43069e-02, 1.91877e-02, -3.41815e-03 }, // 105/128
{ -3.87888e-03, 2.36423e-02, -9.53307e-02, 9.28650e-01, 1.93236e-01, -6.15931e-02, 1.84071e-02, -3.28174e-03 }, // 106/128
{ -3.73062e-03, 2.27664e-02, -9.20893e-02, 9.33586e-01, 1.83711e-01, -5.88617e-02, 1.76185e-02, -3.14367e-03 }, // 107/128
{ -3.57923e-03, 2.18695e-02, -8.87435e-02, 9.38371e-01, 1.74242e-01, -5.61142e-02, 1.68225e-02, -3.00403e-03 }, // 108/128
{ -3.42477e-03, 2.09516e-02, -8.52933e-02, 9.43001e-01, 1.64831e-01, -5.33522e-02, 1.60193e-02, -2.86289e-03 }, // 109/128
{ -3.26730e-03, 2.00132e-02, -8.17385e-02, 9.47477e-01, 1.55480e-01, -5.05770e-02, 1.52095e-02, -2.72032e-03 }, // 110/128
{ -3.10689e-03, 1.90545e-02, -7.80792e-02, 9.51795e-01, 1.46192e-01, -4.77900e-02, 1.43934e-02, -2.57640e-03 }, // 111/128
{ -2.94361e-03, 1.80759e-02, -7.43154e-02, 9.55956e-01, 1.36968e-01, -4.49929e-02, 1.35716e-02, -2.43121e-03 }, // 112/128
{ -2.77751e-03, 1.70776e-02, -7.04471e-02, 9.59958e-01, 1.27812e-01, -4.21869e-02, 1.27445e-02, -2.28483e-03 }, // 113/128
{ -2.60868e-03, 1.60599e-02, -6.64743e-02, 9.63798e-01, 1.18725e-01, -3.93735e-02, 1.19125e-02, -2.13733e-03 }, // 114/128
{ -2.43718e-03, 1.50233e-02, -6.23972e-02, 9.67477e-01, 1.09710e-01, -3.65541e-02, 1.10760e-02, -1.98880e-03 }, // 115/128
{ -2.26307e-03, 1.39681e-02, -5.82159e-02, 9.70992e-01, 1.00769e-01, -3.37303e-02, 1.02356e-02, -1.83931e-03 }, // 116/128
{ -2.08645e-03, 1.28947e-02, -5.39305e-02, 9.74342e-01, 9.19033e-02, -3.09033e-02, 9.39154e-03, -1.68894e-03 }, // 117/128
{ -1.90738e-03, 1.18034e-02, -4.95412e-02, 9.77526e-01, 8.31162e-02, -2.80746e-02, 8.54441e-03, -1.53777e-03 }, // 118/128
{ -1.72594e-03, 1.06946e-02, -4.50483e-02, 9.80543e-01, 7.44095e-02, -2.52457e-02, 7.69462e-03, -1.38589e-03 }, // 119/128
{ -1.54221e-03, 9.56876e-03, -4.04519e-02, 9.83392e-01, 6.57852e-02, -2.24178e-02, 6.84261e-03, -1.23337e-03 }, // 120/128
{ -1.35627e-03, 8.42626e-03, -3.57525e-02, 9.86071e-01, 5.72454e-02, -1.95925e-02, 5.98883e-03, -1.08030e-03 }, // 121/128
{ -1.16820e-03, 7.26755e-03, -3.09503e-02, 9.88580e-01, 4.87921e-02, -1.67710e-02, 5.13372e-03, -9.26747e-04 }, // 122/128
{ -9.78093e-04, 6.09305e-03, -2.60456e-02, 9.90917e-01, 4.04274e-02, -1.39548e-02, 4.27773e-03, -7.72802e-04 }, // 123/128
{ -7.86031e-04, 4.90322e-03, -2.10389e-02, 9.93082e-01, 3.21531e-02, -1.11453e-02, 3.42130e-03, -6.18544e-04 }, // 124/128
{ -5.92100e-04, 3.69852e-03, -1.59305e-02, 9.95074e-01, 2.39714e-02, -8.34364e-03, 2.56486e-03, -4.64053e-04 }, // 125/128
{ -3.96391e-04, 2.47942e-03, -1.07209e-02, 9.96891e-01, 1.58840e-02, -5.55134e-03, 1.70888e-03, -3.09412e-04 }, // 126/128
{ -1.98993e-04, 1.24642e-03, -5.41054e-03, 9.98534e-01, 7.89295e-03, -2.76968e-03, 8.53777e-04, -1.54700e-04 }, // 127/128
{ 0.00000e+00, 0.00000e+00, 0.00000e+00, 1.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00 }, // 128/128
};
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/fft_filter_fff.h 0000664 0001750 0001750 00000006052 12207440367 025065 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2005,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.
*/
#ifndef INCLUDED_FILTER_FFT_FILTER_FFF_H
#define INCLUDED_FILTER_FFT_FILTER_FFF_H
#include
#include
namespace gr {
namespace filter {
/*!
* \brief Fast FFT filter with float input, float output and float taps
* \ingroup filter_blk
*
* \details
* This block implements a real-value decimating filter using the
* fast convolution method via an FFT. The decimation factor is an
* interger that is greater than or equal to 1.
*
* The filter takes a set of real-valued taps to use in the
* filtering operation. These taps can be defined as anything that
* satisfies the user's filtering needs. For standard filters such
* as lowpass, highpass, bandpass, etc., the filter.firdes and
* filter.optfir classes provide convenient generating methods.
*
* This filter is implemented by using the FFTW package to perform
* the required FFTs. An optional argument, nthreads, may be
* passed to the constructor (or set using the set_nthreads member
* function) to split the FFT among N number of threads. This can
* improve performance on very large FFTs (that is, if the number
* of taps used is very large) if you have enough threads/cores to
* support it.
*/
class FILTER_API fft_filter_fff : virtual public sync_decimator
{
public:
// gr::filter::fft_filter_fff::sptr
typedef boost::shared_ptr sptr;
/*!
* Build an FFT filter block.
*
* \param decimation >= 1
* \param taps float filter taps
* \param nthreads number of threads for the FFT to use
*/
static sptr make(int decimation,
const std::vector &taps,
int nthreads=1);
virtual void set_taps(const std::vector &taps) = 0;
virtual std::vector taps() const = 0;
/*!
* \brief Set number of threads to use.
*/
virtual void set_nthreads(int n) = 0;
/*!
* \brief Get number of threads being used.
*/
virtual int nthreads() const = 0;
};
} /* namespace filter */
} /* namespace gr */
#endif /* INCLUDED_FILTER_FFT_FILTER_FFF_H */
gnuradio-3.7.2.1/gr-filter/include/gnuradio/filter/pfb_channelizer_ccf.h 0000664 0001750 0001750 00000021376 12207440367 026072 0 ustar jcorgan jcorgan /* -*- c++ -*- */
/*
* Copyright 2009,2010,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.
*/
#ifndef INCLUDED_FILTER_PFB_CHANNELIZER_CCF_H
#define INCLUDED_FILTER_PFB_CHANNELIZER_CCF_H
#include
#include