diff options
Diffstat (limited to 'gr-blocks')
55 files changed, 1621 insertions, 329 deletions
diff --git a/gr-blocks/CMakeLists.txt b/gr-blocks/CMakeLists.txt index 7e2f43562f..1fab5d90e0 100644 --- a/gr-blocks/CMakeLists.txt +++ b/gr-blocks/CMakeLists.txt @@ -34,6 +34,7 @@ GR_REGISTER_COMPONENT("gr-blocks" ENABLE_GR_BLOCKS GR_SET_GLOBAL(GR_BLOCKS_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/lib ${CMAKE_CURRENT_SOURCE_DIR}/include + ${CMAKE_CURRENT_BINARY_DIR}/include ) ######################################################################## diff --git a/gr-blocks/examples/CMakeLists.txt b/gr-blocks/examples/CMakeLists.txt index 79535daa05..0f9db57b63 100644 --- a/gr-blocks/examples/CMakeLists.txt +++ b/gr-blocks/examples/CMakeLists.txt @@ -18,3 +18,4 @@ # Boston, MA 02110-1301, USA. add_subdirectory(metadata) +add_subdirectory(tags) diff --git a/gr-blocks/examples/metadata/file_metadata_source.grc b/gr-blocks/examples/metadata/file_metadata_source.grc index 23757881bc..f45c151d3f 100644 --- a/gr-blocks/examples/metadata/file_metadata_source.grc +++ b/gr-blocks/examples/metadata/file_metadata_source.grc @@ -84,10 +84,10 @@ </param> </block> <block> - <key>gr_tag_debug</key> + <key>blocks_tag_debug</key> <param> <key>id</key> - <value>gr_tag_debug_0</value> + <value>blocks_tag_debug_0</value> </param> <param> <key>_enabled</key> @@ -244,10 +244,10 @@ </param> </block> <block> - <key>gr_throttle</key> + <key>blocks_throttle</key> <param> <key>id</key> - <value>gr_throttle_0</value> + <value>blocks_throttle_0</value> </param> <param> <key>_enabled</key> @@ -318,19 +318,19 @@ </param> </block> <connection> - <source_block_id>gr_throttle_0</source_block_id> + <source_block_id>blocks_throttle_0</source_block_id> <sink_block_id>gr_file_sink_1</sink_block_id> <source_key>0</source_key> <sink_key>0</sink_key> </connection> <connection> - <source_block_id>gr_throttle_0</source_block_id> - <sink_block_id>gr_tag_debug_0</sink_block_id> + <source_block_id>blocks_throttle_0</source_block_id> + <sink_block_id>blocks_tag_debug_0</sink_block_id> <source_key>0</source_key> <sink_key>0</sink_key> </connection> <connection> - <source_block_id>gr_throttle_0</source_block_id> + <source_block_id>blocks_throttle_0</source_block_id> <sink_block_id>analog_agc2_xx_0</sink_block_id> <source_key>0</source_key> <sink_key>0</sink_key> @@ -343,7 +343,7 @@ </connection> <connection> <source_block_id>blocks_file_meta_source_0</source_block_id> - <sink_block_id>gr_throttle_0</sink_block_id> + <sink_block_id>blocks_throttle_0</sink_block_id> <source_key>0</source_key> <sink_key>0</sink_key> </connection> diff --git a/gr-blocks/examples/metadata/file_metadata_vector_source.grc b/gr-blocks/examples/metadata/file_metadata_vector_source.grc index d52257e06d..584a033c2d 100644 --- a/gr-blocks/examples/metadata/file_metadata_vector_source.grc +++ b/gr-blocks/examples/metadata/file_metadata_vector_source.grc @@ -119,10 +119,10 @@ </param> </block> <block> - <key>gr_tag_debug</key> + <key>blocks_tag_debug</key> <param> <key>id</key> - <value>gr_tag_debug_0</value> + <value>blocks_tag_debug_0</value> </param> <param> <key>_enabled</key> @@ -232,10 +232,10 @@ </param> </block> <block> - <key>gr_throttle</key> + <key>blocks_throttle</key> <param> <key>id</key> - <value>gr_throttle_0</value> + <value>blocks_throttle_0</value> </param> <param> <key>_enabled</key> @@ -306,14 +306,14 @@ </param> </block> <connection> - <source_block_id>gr_throttle_0</source_block_id> + <source_block_id>blocks_throttle_0</source_block_id> <sink_block_id>gr_file_sink_1</sink_block_id> <source_key>0</source_key> <sink_key>0</sink_key> </connection> <connection> - <source_block_id>gr_throttle_0</source_block_id> - <sink_block_id>gr_tag_debug_0</sink_block_id> + <source_block_id>blocks_throttle_0</source_block_id> + <sink_block_id>blocks_tag_debug_0</sink_block_id> <source_key>0</source_key> <sink_key>0</sink_key> </connection> @@ -324,14 +324,14 @@ <sink_key>0</sink_key> </connection> <connection> - <source_block_id>gr_throttle_0</source_block_id> + <source_block_id>blocks_throttle_0</source_block_id> <sink_block_id>blocks_vector_to_stream_0</sink_block_id> <source_key>0</source_key> <sink_key>0</sink_key> </connection> <connection> <source_block_id>blocks_file_meta_source_0</source_block_id> - <sink_block_id>gr_throttle_0</sink_block_id> + <sink_block_id>blocks_throttle_0</sink_block_id> <source_key>0</source_key> <sink_key>0</sink_key> </connection> diff --git a/gr-blocks/examples/msg_passing/CMakeLists.txt b/gr-blocks/examples/msg_passing/CMakeLists.txt new file mode 100644 index 0000000000..c4b207a1e4 --- /dev/null +++ b/gr-blocks/examples/msg_passing/CMakeLists.txt @@ -0,0 +1,27 @@ +# 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. + +include(GrPython) + +install( + FILES + strobe.grc + DESTINATION ${GR_PKG_DATA_DIR}/examples/msg_passing + COMPONENT "core_python" +) diff --git a/gr-blocks/examples/msg_passing/hier/test_msg_hier.grc b/gr-blocks/examples/msg_passing/hier/test_msg_hier.grc new file mode 100644 index 0000000000..4fa8a18d83 --- /dev/null +++ b/gr-blocks/examples/msg_passing/hier/test_msg_hier.grc @@ -0,0 +1,287 @@ +<?xml version='1.0' encoding='ASCII'?> +<flow_graph> + <timestamp>Mon Dec 10 19:56:24 2012</timestamp> + <block> + <key>options</key> + <param> + <key>id</key> + <value>test_msg_hier</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>title</key> + <value></value> + </param> + <param> + <key>author</key> + <value></value> + </param> + <param> + <key>description</key> + <value></value> + </param> + <param> + <key>window_size</key> + <value>1280, 1024</value> + </param> + <param> + <key>generate_options</key> + <value>hb</value> + </param> + <param> + <key>category</key> + <value>Custom</value> + </param> + <param> + <key>run_options</key> + <value>prompt</value> + </param> + <param> + <key>run</key> + <value>True</value> + </param> + <param> + <key>max_nouts</key> + <value>0</value> + </param> + <param> + <key>realtime_scheduling</key> + <value></value> + </param> + <param> + <key>_coordinate</key> + <value>(10, 10)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>pad_source</key> + <param> + <key>id</key> + <value>pad_source_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>label</key> + <value>TEST_PORT</value> + </param> + <param> + <key>type</key> + <value>message</value> + </param> + <param> + <key>vlen</key> + <value>1</value> + </param> + <param> + <key>optional</key> + <value>False</value> + </param> + <param> + <key>_coordinate</key> + <value>(234, 145)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>pad_source</key> + <param> + <key>id</key> + <value>pad_source_0_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>label</key> + <value>TEST_PORT2</value> + </param> + <param> + <key>type</key> + <value>message</value> + </param> + <param> + <key>vlen</key> + <value>1</value> + </param> + <param> + <key>optional</key> + <value>False</value> + </param> + <param> + <key>_coordinate</key> + <value>(167, 54)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>blocks_message_strobe</key> + <param> + <key>id</key> + <value>blocks_message_strobe_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>msg</key> + <value>pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(16,0x77))</value> + </param> + <param> + <key>period</key> + <value>200</value> + </param> + <param> + <key>_coordinate</key> + <value>(362, 81)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>pad_sink</key> + <param> + <key>id</key> + <value>pad_sink_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>label</key> + <value>TEST_PORT</value> + </param> + <param> + <key>type</key> + <value>message</value> + </param> + <param> + <key>vlen</key> + <value>1</value> + </param> + <param> + <key>optional</key> + <value>True</value> + </param> + <param> + <key>_coordinate</key> + <value>(618, 87)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>blocks_message_strobe</key> + <param> + <key>id</key> + <value>blocks_message_strobe_0_1</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>msg</key> + <value>pmt.intern("OUTPUT2")</value> + </param> + <param> + <key>period</key> + <value>100</value> + </param> + <param> + <key>_coordinate</key> + <value>(400, 156)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>pad_sink</key> + <param> + <key>id</key> + <value>pad_sink_0_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>label</key> + <value>TEST_PORT3</value> + </param> + <param> + <key>type</key> + <value>message</value> + </param> + <param> + <key>vlen</key> + <value>1</value> + </param> + <param> + <key>optional</key> + <value>True</value> + </param> + <param> + <key>_coordinate</key> + <value>(695, 172)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <connection> + <source_block_id>pad_source_0_0</source_block_id> + <sink_block_id>blocks_message_strobe_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> + <connection> + <source_block_id>pad_source_0</source_block_id> + <sink_block_id>blocks_message_strobe_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> + <connection> + <source_block_id>blocks_message_strobe_0</source_block_id> + <sink_block_id>pad_sink_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> + <connection> + <source_block_id>blocks_message_strobe_0_1</source_block_id> + <sink_block_id>pad_sink_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> + <connection> + <source_block_id>blocks_message_strobe_0_1</source_block_id> + <sink_block_id>pad_sink_0_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> +</flow_graph> diff --git a/gr-blocks/examples/msg_passing/hier/test_msg_hier_topblock.grc b/gr-blocks/examples/msg_passing/hier/test_msg_hier_topblock.grc new file mode 100644 index 0000000000..896e42b5e4 --- /dev/null +++ b/gr-blocks/examples/msg_passing/hier/test_msg_hier_topblock.grc @@ -0,0 +1,185 @@ +<?xml version='1.0' encoding='ASCII'?> +<flow_graph> + <timestamp>Mon Dec 10 19:56:42 2012</timestamp> + <block> + <key>options</key> + <param> + <key>id</key> + <value>test_msg_hier_topblock</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>title</key> + <value></value> + </param> + <param> + <key>author</key> + <value></value> + </param> + <param> + <key>description</key> + <value></value> + </param> + <param> + <key>window_size</key> + <value>1280, 1024</value> + </param> + <param> + <key>generate_options</key> + <value>no_gui</value> + </param> + <param> + <key>category</key> + <value>Custom</value> + </param> + <param> + <key>run_options</key> + <value>prompt</value> + </param> + <param> + <key>run</key> + <value>True</value> + </param> + <param> + <key>max_nouts</key> + <value>0</value> + </param> + <param> + <key>realtime_scheduling</key> + <value></value> + </param> + <param> + <key>_coordinate</key> + <value>(10, 10)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>blocks_message_strobe</key> + <param> + <key>id</key> + <value>blocks_message_strobe_0_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>msg</key> + <value>pmt.intern("UPDATED2")</value> + </param> + <param> + <key>period</key> + <value>3000</value> + </param> + <param> + <key>_coordinate</key> + <value>(51, 88)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>blocks_message_strobe</key> + <param> + <key>id</key> + <value>blocks_message_strobe_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>msg</key> + <value>pmt.intern("UPDATED")</value> + </param> + <param> + <key>period</key> + <value>2000</value> + </param> + <param> + <key>_coordinate</key> + <value>(211, 168)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>blocks_message_debug</key> + <param> + <key>id</key> + <value>blocks_message_debug_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>_coordinate</key> + <value>(758, 71)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>TEST_MSG_HIER</key> + <param> + <key>id</key> + <value>TEST_MSG_HIER_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>_coordinate</key> + <value>(402, 52)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <connection> + <source_block_id>TEST_MSG_HIER_0</source_block_id> + <sink_block_id>blocks_message_debug_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> + <connection> + <source_block_id>blocks_message_strobe_0</source_block_id> + <sink_block_id>TEST_MSG_HIER_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> + <connection> + <source_block_id>blocks_message_strobe_0_0</source_block_id> + <sink_block_id>TEST_MSG_HIER_0</sink_block_id> + <source_key>0</source_key> + <sink_key>1</sink_key> + </connection> + <connection> + <source_block_id>TEST_MSG_HIER_0</source_block_id> + <sink_block_id>blocks_message_debug_0</sink_block_id> + <source_key>0</source_key> + <sink_key>1</sink_key> + </connection> + <connection> + <source_block_id>TEST_MSG_HIER_0</source_block_id> + <sink_block_id>blocks_message_debug_0</sink_block_id> + <source_key>1</source_key> + <sink_key>0</sink_key> + </connection> +</flow_graph> diff --git a/gr-blocks/examples/msg_passing/strobe.grc b/gr-blocks/examples/msg_passing/strobe.grc new file mode 100644 index 0000000000..d9d4ce43cb --- /dev/null +++ b/gr-blocks/examples/msg_passing/strobe.grc @@ -0,0 +1,266 @@ +<?xml version='1.0' encoding='ASCII'?> +<flow_graph> + <timestamp>Thu Dec 6 11:33:08 2012</timestamp> + <block> + <key>variable</key> + <param> + <key>id</key> + <value>samp_rate</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>value</key> + <value>32000</value> + </param> + <param> + <key>_coordinate</key> + <value>(10, 170)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>gr_pdu_to_tagged_stream</key> + <param> + <key>id</key> + <value>gr_pdu_to_tagged_stream_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>type</key> + <value>byte</value> + </param> + <param> + <key>_coordinate</key> + <value>(443, 89)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>blocks_message_debug</key> + <param> + <key>id</key> + <value>blocks_message_debug_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>_coordinate</key> + <value>(1049, 176)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>gr_tagged_stream_to_pdu</key> + <param> + <key>id</key> + <value>gr_tagged_stream_to_pdu_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>type</key> + <value>byte</value> + </param> + <param> + <key>_coordinate</key> + <value>(870, 89)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>gr_kludge_copy</key> + <param> + <key>id</key> + <value>gr_kludge_copy_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>type</key> + <value>byte</value> + </param> + <param> + <key>num_ports</key> + <value>1</value> + </param> + <param> + <key>vlen</key> + <value>1</value> + </param> + <param> + <key>_coordinate</key> + <value>(686, 89)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>blocks_message_strobe</key> + <param> + <key>id</key> + <value>blocks_message_strobe_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>msg</key> + <value>pmt.intern("TEST")</value> + </param> + <param> + <key>period</key> + <value>1000</value> + </param> + <param> + <key>_coordinate</key> + <value>(423, 177)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>blocks_message_strobe</key> + <param> + <key>id</key> + <value>blocks_message_strobe_0_0</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>msg</key> + <value>pmt.cons( pmt.PMT_NIL, pmt.make_u8vector(512,0) )</value> + </param> + <param> + <key>period</key> + <value>750</value> + </param> + <param> + <key>_coordinate</key> + <value>(99, 85)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <block> + <key>options</key> + <param> + <key>id</key> + <value>strobe</value> + </param> + <param> + <key>_enabled</key> + <value>True</value> + </param> + <param> + <key>title</key> + <value></value> + </param> + <param> + <key>author</key> + <value></value> + </param> + <param> + <key>description</key> + <value></value> + </param> + <param> + <key>window_size</key> + <value>1280, 1024</value> + </param> + <param> + <key>generate_options</key> + <value>no_gui</value> + </param> + <param> + <key>category</key> + <value>Custom</value> + </param> + <param> + <key>run_options</key> + <value>prompt</value> + </param> + <param> + <key>run</key> + <value>True</value> + </param> + <param> + <key>max_nouts</key> + <value>0</value> + </param> + <param> + <key>realtime_scheduling</key> + <value></value> + </param> + <param> + <key>_coordinate</key> + <value>(10, 10)</value> + </param> + <param> + <key>_rotation</key> + <value>0</value> + </param> + </block> + <connection> + <source_block_id>blocks_message_strobe_0_0</source_block_id> + <sink_block_id>gr_pdu_to_tagged_stream_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> + <connection> + <source_block_id>blocks_message_strobe_0</source_block_id> + <sink_block_id>blocks_message_debug_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> + <connection> + <source_block_id>gr_tagged_stream_to_pdu_0</source_block_id> + <sink_block_id>blocks_message_debug_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> + <connection> + <source_block_id>gr_kludge_copy_0</source_block_id> + <sink_block_id>gr_tagged_stream_to_pdu_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> + <connection> + <source_block_id>gr_pdu_to_tagged_stream_0</source_block_id> + <sink_block_id>gr_kludge_copy_0</sink_block_id> + <source_key>0</source_key> + <sink_key>0</sink_key> + </connection> +</flow_graph> diff --git a/gr-blocks/examples/tags/CMakeLists.txt b/gr-blocks/examples/tags/CMakeLists.txt new file mode 100644 index 0000000000..142b5cde6c --- /dev/null +++ b/gr-blocks/examples/tags/CMakeLists.txt @@ -0,0 +1,27 @@ +# 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. + +include(GrPython) + +GR_PYTHON_INSTALL(PROGRAMS + test_file_tags.py + DESTINATION ${GR_PKG_DATA_DIR}/examples/tags + COMPONENT "blocks_python" +) + diff --git a/gr-blocks/examples/tags/test_file_tags.py b/gr-blocks/examples/tags/test_file_tags.py new file mode 100755 index 0000000000..1493864bd4 --- /dev/null +++ b/gr-blocks/examples/tags/test_file_tags.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python +# +# 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. +# + +from gnuradio import gr +from gnuradio import blocks +import sys + +try: + import scipy +except ImportError: + print "Error: Program requires scipy (see: www.scipy.org)." + sys.exit(1) + +def main(): + data = scipy.arange(0, 32000, 1).tolist() + trig = 100*[0,] + 100*[1,] + + src = gr.vector_source_s(data, True) + trigger = gr.vector_source_s(trig, True) + + thr = blocks.throttle(gr.sizeof_short, 10e3) + ann = gr.annotator_alltoall(1000000, gr.sizeof_short) + tagger = blocks..burst_tagger(gr.sizeof_short) + + fsnk = gr.tagged_file_sink(gr.sizeof_short, 1) + + tb = gr.top_block() + tb.connect(src, thr, (tagger, 0)) + tb.connect(trigger, (tagger, 1)) + tb.connect(tagger, fsnk) + + tb.run() + +if __name__ == "__main__": + main() + + diff --git a/gr-blocks/grc/blocks_block_tree.xml b/gr-blocks/grc/blocks_block_tree.xml index 40061dd663..6ab4398194 100644 --- a/gr-blocks/grc/blocks_block_tree.xml +++ b/gr-blocks/grc/blocks_block_tree.xml @@ -33,6 +33,7 @@ <block>blocks_file_source</block> <block>blocks_file_meta_source</block> <block>blocks_pdu_to_tagged_stream</block> + <block>blocks_random_pdu</block> <block>blocks_message_source</block> <block>blocks_message_burst_source</block> </cat> @@ -105,6 +106,7 @@ <block>blocks_streams_to_vector</block> <block>blocks_vector_to_stream</block> <block>blocks_vector_to_streams</block> + <block>blocks_stream_to_vector_decimator</block> <block>blocks_peak_detector_xb</block> <block>blocks_peak_detector2_fb</block> <block>blocks_regenerate_bb</block> diff --git a/gr-blocks/grc/blocks_random_pdu.xml b/gr-blocks/grc/blocks_random_pdu.xml new file mode 100644 index 0000000000..640e14de8a --- /dev/null +++ b/gr-blocks/grc/blocks_random_pdu.xml @@ -0,0 +1,35 @@ +<?xml version="1.0"?> +<!-- +################################################### +## Random PDU +################################################### + --> +<block> + <name>Random PDU Generator</name> + <key>blocks_random_pdu</key> + <import>from gnuradio import blocks</import> + <import>from gruel import pmt</import> + <make>blocks.random_pdu($minsize, $maxsize)</make> + <param> + <name>Min Bytes</name> + <key>minsize</key> + <value>50</value> + <type>int</type> + </param> + <param> + <name>Max Bytes</name> + <key>maxsize</key> + <value>2000</value> + <type>int</type> + </param> + <sink> + <name>generate</name> + <type>message</type> + <optional>1</optional> + </sink> + <source> + <name>pdus</name> + <type>message</type> + <optional>1</optional> + </source> +</block> diff --git a/gr-blocks/grc/blocks_stream_to_vector_decimator.xml b/gr-blocks/grc/blocks_stream_to_vector_decimator.xml new file mode 100644 index 0000000000..ca71cf17ff --- /dev/null +++ b/gr-blocks/grc/blocks_stream_to_vector_decimator.xml @@ -0,0 +1,77 @@ +<?xml version="1.0"?> +<!-- +################################################### +##Stream to Vector Decimator +################################################### + --> +<block> + <name>Stream to Vec Decim</name> + <key>blocks_stream_to_vector_decimator</key> + <import>from gnuradio import blocks</import> + <make>blocks.stream_to_vector_decimator( + item_size=$type.size, + sample_rate=$sample_rate, + vec_rate=$vec_rate, + vec_len=$vlen, +)</make> + <callback>set_sample_rate($sample_rate)</callback> + <callback>set_vec_rate($vec_rate)</callback> + <param> + <name>IO Type</name> + <key>type</key> + <type>enum</type> + <option> + <name>Complex</name> + <key>complex</key> + <opt>size:gr.sizeof_gr_complex</opt> + </option> + <option> + <name>Float</name> + <key>float</key> + <opt>size:gr.sizeof_float</opt> + </option> + <option> + <name>Int</name> + <key>int</key> + <opt>size:gr.sizeof_int</opt> + </option> + <option> + <name>Short</name> + <key>short</key> + <opt>size:gr.sizeof_short</opt> + </option> + <option> + <name>Byte</name> + <key>byte</key> + <opt>size:gr.sizeof_char</opt> + </option> + </param> + <param> + <name>Sample Rate</name> + <key>sample_rate</key> + <value>samp_rate</value> + <type>real</type> + </param> + <param> + <name>Vec Rate</name> + <key>vec_rate</key> + <value>30</value> + <type>real</type> + </param> + <param> + <name>Vec Length</name> + <key>vlen</key> + <value>1024</value> + <type>int</type> + </param> + <check>$vlen >= 1</check> + <sink> + <name>in</name> + <type>$type</type> + </sink> + <source> + <name>out</name> + <type>$type</type> + <vlen>$vlen</vlen> + </source> +</block> diff --git a/gr-blocks/include/blocks/CMakeLists.txt b/gr-blocks/include/blocks/CMakeLists.txt index 684639e07e..24451903d0 100644 --- a/gr-blocks/include/blocks/CMakeLists.txt +++ b/gr-blocks/include/blocks/CMakeLists.txt @@ -145,6 +145,7 @@ install(FILES pdu.h pdu_to_tagged_stream.h peak_detector2_fb.h + random_pdu.h regenerate_bb.h repeat.h rms_cf.h diff --git a/gr-blocks/include/blocks/packed_to_unpacked_XX.h.t b/gr-blocks/include/blocks/packed_to_unpacked_XX.h.t index 9ab8b8bdfc..c00a27527e 100644 --- a/gr-blocks/include/blocks/packed_to_unpacked_XX.h.t +++ b/gr-blocks/include/blocks/packed_to_unpacked_XX.h.t @@ -47,7 +47,7 @@ namespace gr { * processed. The right thing is done if bits_per_chunk is not a * power of two. * - * The combination of gr_packed_to_unpacked_XX_ followed by + * The combination of gr::blocks::packed_to_unpacked_XX_ followed by * gr_chunks_to_symbols_Xf or gr_chunks_to_symbols_Xc handles the * general case of mapping from a stream of bytes or shorts into * arbitrary float or complex symbols. diff --git a/gr-blocks/include/blocks/random_pdu.h b/gr-blocks/include/blocks/random_pdu.h new file mode 100644 index 0000000000..5a13f5eca6 --- /dev/null +++ b/gr-blocks/include/blocks/random_pdu.h @@ -0,0 +1,51 @@ +/* -*- 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_BLOCKS_RANDOM_PDU_H +#define INCLUDED_BLOCKS_RANDOM_PDU_H + +#include <blocks/api.h> +#include <gr_block.h> + +namespace gr { + namespace blocks { + + /*! + * \brief Sends a random PDU at intervals + * \ingroup source_blk + */ + class BLOCKS_API random_pdu : virtual public gr_block + { + public: + // gr::blocks::random_pdu::sptr + typedef boost::shared_ptr<random_pdu> sptr; + + /*! + * \brief Construct a random PDU generator + */ + static sptr make(int mintime, int maxtime); + }; + + } /* namespace blocks */ +} /* namespace gr */ + +#endif /* INCLUDED_BLOCKS_RANDOM_PDU_H */ diff --git a/gr-blocks/include/blocks/rms_ff.h b/gr-blocks/include/blocks/rms_ff.h index 19fb0016d4..b945096907 100644 --- a/gr-blocks/include/blocks/rms_ff.h +++ b/gr-blocks/include/blocks/rms_ff.h @@ -19,6 +19,7 @@ * the Free Software Foundation, Inc., 51 Franklin Street, * Boston, MA 02110-1301, USA. */ + #ifndef INCLUDED_BLOCKS_RMS_FF_H #define INCLUDED_BLOCKS_RMS_FF_H diff --git a/gr-blocks/include/blocks/socket_pdu.h b/gr-blocks/include/blocks/socket_pdu.h index 1a67f8358c..0ed64a2557 100644 --- a/gr-blocks/include/blocks/socket_pdu.h +++ b/gr-blocks/include/blocks/socket_pdu.h @@ -41,8 +41,10 @@ namespace gr { /*! * \brief Construct a SOCKET PDU interface - * \param dev Device name to create - * \param MTU Maximum Transmission Unit size + * \param type "TCP_SERVER", "TCP_CLIENT", "UDP_SERVER", or "UDP_CLIENT" + * \param addr network address to use + * \param port network port to use + * \param MTU maximum transmission unit */ static sptr make(std::string type, std::string addr, std::string port, int MTU=10000); }; diff --git a/gr-blocks/include/blocks/unpacked_to_packed_XX.h.t b/gr-blocks/include/blocks/unpacked_to_packed_XX.h.t index 749f0e00f9..d570785a68 100644 --- a/gr-blocks/include/blocks/unpacked_to_packed_XX.h.t +++ b/gr-blocks/include/blocks/unpacked_to_packed_XX.h.t @@ -46,7 +46,7 @@ namespace gr { * output bytes or shorts are filled with valid input bits. The * right thing is done if bits_per_chunk is not a power of two. * - * The combination of gr_packed_to_unpacked_XX followed by + * The combination of gr::blocks::packed_to_unpacked_XX followed by * gr_chunks_to_symbols_Xf or gr_chunks_to_symbols_Xc handles the * general case of mapping from a stream of bytes or shorts into * arbitrary float or complex symbols. diff --git a/gr-blocks/lib/CMakeLists.txt b/gr-blocks/lib/CMakeLists.txt index ac5e3056d8..60603ca31e 100644 --- a/gr-blocks/lib/CMakeLists.txt +++ b/gr-blocks/lib/CMakeLists.txt @@ -131,6 +131,11 @@ include_directories( link_directories(${Boost_LIBRARY_DIRS}) +if(ENABLE_GR_CTRLPORT) + ADD_DEFINITIONS(-DGR_CTRLPORT) + include_directories(${ICE_INCLUDE_DIR}) +endif(ENABLE_GR_CTRLPORT) + ######################################################################## # Setup library ######################################################################## @@ -185,6 +190,7 @@ list(APPEND gr_blocks_sources tag_debug_impl.cc pdu_to_tagged_stream_impl.cc peak_detector2_fb_impl.cc + random_pdu_impl.cc regenerate_bb_impl.cc repeat_impl.cc rms_cf_impl.cc diff --git a/gr-blocks/lib/burst_tagger_impl.cc b/gr-blocks/lib/burst_tagger_impl.cc index 5d0691bde6..31c535290d 100644 --- a/gr-blocks/lib/burst_tagger_impl.cc +++ b/gr-blocks/lib/burst_tagger_impl.cc @@ -47,13 +47,13 @@ namespace gr { std::stringstream str; str << name() << unique_id(); - d_true_key = pmt::pmt_string_to_symbol("burst"); + d_true_key = pmt::string_to_symbol("burst"); d_true_value = pmt::PMT_T; - d_false_key = pmt::pmt_string_to_symbol("burst"); + d_false_key = pmt::string_to_symbol("burst"); d_false_value = pmt::PMT_F; - d_id = pmt::pmt_string_to_symbol(str.str()); + d_id = pmt::string_to_symbol(str.str()); } burst_tagger_impl::~burst_tagger_impl() @@ -63,7 +63,7 @@ namespace gr { void burst_tagger_impl::set_true_tag(const std::string &key, bool value) { - d_true_key = pmt::pmt_string_to_symbol(key); + d_true_key = pmt::string_to_symbol(key); if(value == true) { d_true_value = pmt::PMT_T; } @@ -75,7 +75,7 @@ namespace gr { void burst_tagger_impl::set_false_tag (const std::string &key, bool value) { - d_false_key = pmt::pmt_string_to_symbol(key); + d_false_key = pmt::string_to_symbol(key); if(value == true) { d_false_value = pmt::PMT_T; } diff --git a/gr-blocks/lib/file_meta_sink_impl.cc b/gr-blocks/lib/file_meta_sink_impl.cc index b707bfac4e..d996e7a93e 100644 --- a/gr-blocks/lib/file_meta_sink_impl.cc +++ b/gr-blocks/lib/file_meta_sink_impl.cc @@ -100,34 +100,34 @@ namespace gr { if(!open(filename)) throw std::runtime_error("file_meta_sink: can't open file\n"); - pmt_t timestamp = pmt_make_tuple(pmt_from_uint64(0), - pmt_from_double(0)); + pmt::pmt_t timestamp = pmt::make_tuple(pmt::from_uint64(0), + pmt::from_double(0)); // handle extra dictionary - d_extra = pmt_make_dict(); + d_extra = pmt::make_dict(); if(extra_dict.size() > 0) { - pmt_t extras = pmt_deserialize_str(extra_dict); - pmt_t keys = pmt_dict_keys(extras); - pmt_t vals = pmt_dict_values(extras); - size_t nitems = pmt_length(keys); + pmt::pmt_t extras = pmt::deserialize_str(extra_dict); + pmt::pmt_t keys = pmt::dict_keys(extras); + pmt::pmt_t vals = pmt::dict_values(extras); + size_t nitems = pmt::length(keys); for(size_t i = 0; i < nitems; i++) { - d_extra = pmt_dict_add(d_extra, - pmt_nth(i, keys), - pmt_nth(i, vals)); + d_extra = pmt::dict_add(d_extra, + pmt::nth(i, keys), + pmt::nth(i, vals)); } } - d_extra_size = pmt_serialize_str(d_extra).size(); + d_extra_size = pmt::serialize_str(d_extra).size(); - d_header = pmt_make_dict(); - d_header = pmt_dict_add(d_header, mp("version"), mp(METADATA_VERSION)); - d_header = pmt_dict_add(d_header, mp("rx_rate"), mp(samp_rate)); - d_header = pmt_dict_add(d_header, mp("rx_time"), timestamp); - d_header = pmt_dict_add(d_header, mp("size"), pmt_from_long(d_itemsize)); - d_header = pmt_dict_add(d_header, mp("type"), pmt_from_long(type)); - d_header = pmt_dict_add(d_header, mp("cplx"), complex ? PMT_T : PMT_F); - d_header = pmt_dict_add(d_header, mp("strt"), pmt_from_uint64(METADATA_HEADER_SIZE+d_extra_size)); - d_header = pmt_dict_add(d_header, mp("bytes"), pmt_from_uint64(0)); + d_header = pmt::make_dict(); + d_header = pmt::dict_add(d_header, pmt::mp("version"), pmt::mp(METADATA_VERSION)); + d_header = pmt::dict_add(d_header, pmt::mp("rx_rate"), pmt::mp(samp_rate)); + d_header = pmt::dict_add(d_header, pmt::mp("rx_time"), timestamp); + d_header = pmt::dict_add(d_header, pmt::mp("size"), pmt::from_long(d_itemsize)); + d_header = pmt::dict_add(d_header, pmt::mp("type"), pmt::from_long(type)); + d_header = pmt::dict_add(d_header, pmt::mp("cplx"), complex ? pmt::PMT_T : pmt::PMT_F); + d_header = pmt::dict_add(d_header, pmt::mp("strt"), pmt::from_uint64(METADATA_HEADER_SIZE+d_extra_size)); + d_header = pmt::dict_add(d_header, mp("bytes"), pmt::from_uint64(0)); do_update(); @@ -240,10 +240,10 @@ namespace gr { } void - file_meta_sink_impl::write_header(FILE *fp, pmt_t header, pmt_t extra) + file_meta_sink_impl::write_header(FILE *fp, pmt::pmt_t header, pmt::pmt_t extra) { - std::string header_str = pmt_serialize_str(header); - std::string extra_str = pmt_serialize_str(extra); + std::string header_str = pmt::serialize_str(header); + std::string extra_str = pmt::serialize_str(extra); if((header_str.size() != METADATA_HEADER_SIZE) && (extra_str.size() != d_extra_size)) throw std::runtime_error("file_meta_sink: header or extras is wrong size.\n"); @@ -274,24 +274,24 @@ namespace gr { } void - file_meta_sink_impl::update_header(pmt_t key, pmt_t value) + file_meta_sink_impl::update_header(pmt::pmt_t key, pmt::pmt_t value) { // Special handling caveat to transform rate from radio source into // the rate at this sink. - if(pmt_eq(key, mp("rx_rate"))) { - d_samp_rate = pmt_to_double(value); - value = pmt_from_double(d_samp_rate*d_relative_rate); + if(pmt::eq(key, mp("rx_rate"))) { + d_samp_rate = pmt::to_double(value); + value = pmt::from_double(d_samp_rate*d_relative_rate); } // If the tag is not part of the standard header, we put it into the // extra data, which either updates the current dictionary or adds a // new item. - if(pmt_dict_has_key(d_header, key)) { - d_header = pmt_dict_add(d_header, key, value); + if(pmt::dict_has_key(d_header, key)) { + d_header = pmt::dict_add(d_header, key, value); } else { - d_extra = pmt_dict_add(d_extra, key, value); - d_extra_size = pmt_serialize_str(d_extra).size(); + d_extra = pmt::dict_add(d_extra, key, value); + d_extra_size = pmt::serialize_str(d_extra).size(); } } @@ -310,11 +310,11 @@ namespace gr { // Update the last header info with the number of samples this // block represents. - size_t hdrlen = pmt_to_uint64(pmt_dict_ref(d_header, mp("strt"), PMT_NIL)); + size_t hdrlen = pmt::to_uint64(pmt::dict_ref(d_header, mp("strt"), pmt::PMT_NIL)); size_t seg_size = d_itemsize*d_total_seg_size; - pmt_t s = pmt_from_uint64(seg_size); + pmt::pmt_t s = pmt::from_uint64(seg_size); update_header(mp("bytes"), s); - update_header(mp("strt"), pmt_from_uint64(METADATA_HEADER_SIZE+d_extra_size)); + update_header(mp("strt"), pmt::from_uint64(METADATA_HEADER_SIZE+d_extra_size)); fseek(d_fp, -seg_size-hdrlen, SEEK_CUR); write_header(d_fp, d_header, d_extra); fseek(d_fp, seg_size, SEEK_CUR); @@ -325,11 +325,11 @@ namespace gr { { // Update the last header info with the number of samples this // block represents. - size_t hdrlen = pmt_to_uint64(pmt_dict_ref(d_header, mp("strt"), PMT_NIL)); + size_t hdrlen = pmt::to_uint64(pmt::dict_ref(d_header, mp("strt"), pmt::PMT_NIL)); size_t seg_size = d_itemsize*d_total_seg_size; - pmt_t s = pmt_from_uint64(seg_size); + pmt::pmt_t s = pmt::from_uint64(seg_size); update_header(mp("bytes"), s); - update_header(mp("strt"), pmt_from_uint64(METADATA_HEADER_SIZE+d_extra_size)); + update_header(mp("strt"), pmt::from_uint64(METADATA_HEADER_SIZE+d_extra_size)); fseek(d_hdr_fp, -hdrlen, SEEK_CUR); write_header(d_hdr_fp, d_header, d_extra); } @@ -340,13 +340,13 @@ namespace gr { // New header, so set current size of chunk to 0 and start of chunk // based on current index + header size. //uint64_t loc = get_last_header_loc(); - pmt_t s = pmt_from_uint64(0); + pmt::pmt_t s = pmt::from_uint64(0); update_header(mp("bytes"), s); // If we have multiple tags on the same offset, this makes // sure we just overwrite the same header each time instead // of creating a new header per tag. - s = pmt_from_uint64(METADATA_HEADER_SIZE + d_extra_size); + s = pmt::from_uint64(METADATA_HEADER_SIZE + d_extra_size); update_header(mp("strt"), s); if(d_state == STATE_DETACHED) @@ -358,10 +358,10 @@ namespace gr { void file_meta_sink_impl::update_rx_time() { - pmt_t rx_time = pmt_string_to_symbol("rx_time"); - pmt_t r = pmt_dict_ref(d_header, rx_time, PMT_NIL); - uint64_t secs = pmt_to_uint64(pmt_tuple_ref(r, 0)); - double fracs = pmt_to_double(pmt_tuple_ref(r, 1)); + pmt::pmt_t rx_time = pmt::string_to_symbol("rx_time"); + pmt::pmt_t r = pmt::dict_ref(d_header, rx_time, pmt::PMT_NIL); + uint64_t secs = pmt::to_uint64(pmt::tuple_ref(r, 0)); + double fracs = pmt::to_double(pmt::tuple_ref(r, 1)); double diff = d_total_seg_size / (d_samp_rate*d_relative_rate); //std::cerr << "old secs: " << secs << std::endl; @@ -377,8 +377,8 @@ namespace gr { //std::cerr << "new secs: " << secs << std::endl; //std::cerr << "new fracs: " << fracs << std::endl << std::endl; - r = pmt_make_tuple(pmt_from_uint64(secs), pmt_from_double(fracs)); - d_header = pmt_dict_add(d_header, rx_time, r); + r = pmt::make_tuple(pmt::from_uint64(secs), pmt::from_double(fracs)); + d_header = pmt::dict_add(d_header, rx_time, r); } int diff --git a/gr-blocks/lib/file_meta_source_impl.cc b/gr-blocks/lib/file_meta_source_impl.cc index 42fdabb541..9d66193e53 100644 --- a/gr-blocks/lib/file_meta_source_impl.cc +++ b/gr-blocks/lib/file_meta_source_impl.cc @@ -95,7 +95,7 @@ namespace gr { do_update(); - pmt_t hdr = PMT_NIL, extras = PMT_NIL; + pmt::pmt_t hdr = pmt::PMT_NIL, extras = pmt::PMT_NIL; if(read_header(hdr, extras)) { parse_header(hdr, 0, d_tags); parse_extras(extras, 0, d_tags); @@ -125,7 +125,7 @@ namespace gr { } bool - file_meta_source_impl::read_header(pmt_t &hdr, pmt_t &extras) + file_meta_source_impl::read_header(pmt::pmt_t &hdr, pmt::pmt_t &extras) { // Select which file handle to read from. FILE *fp; @@ -156,14 +156,14 @@ namespace gr { // Convert to string or the char array gets confused by the \0 str.insert(0, hdr_buffer, METADATA_HEADER_SIZE); - hdr = pmt_deserialize_str(str); + hdr = pmt::deserialize_str(str); delete [] hdr_buffer; uint64_t seg_start, extra_len; - pmt_t r, dump; - if(pmt_dict_has_key(hdr, pmt_string_to_symbol("strt"))) { - r = pmt_dict_ref(hdr, pmt_string_to_symbol("strt"), dump); - seg_start = pmt_to_uint64(r); + pmt::pmt_t r, dump; + if(pmt::dict_has_key(hdr, pmt::string_to_symbol("strt"))) { + r = pmt::dict_ref(hdr, pmt::string_to_symbol("strt"), dump); + seg_start = pmt::to_uint64(r); extra_len = seg_start - METADATA_HEADER_SIZE; } @@ -188,7 +188,7 @@ namespace gr { str.clear(); str.insert(0, hdr_buffer, extra_len); - extras = pmt_deserialize_str(str); + extras = pmt::deserialize_str(str); delete [] hdr_buffer; } @@ -196,16 +196,16 @@ namespace gr { } void - file_meta_source_impl::parse_header(pmt_t hdr, uint64_t offset, + file_meta_source_impl::parse_header(pmt::pmt_t hdr, uint64_t offset, std::vector<gr_tag_t> &tags) { - pmt_t r, key; + pmt::pmt_t r, key; // GET SAMPLE RATE - key = pmt_string_to_symbol("rx_rate"); - if(pmt_dict_has_key(hdr, key)) { - r = pmt_dict_ref(hdr, key, PMT_NIL); - d_samp_rate = pmt_to_double(r); + key = pmt::string_to_symbol("rx_rate"); + if(pmt::dict_has_key(hdr, key)) { + r = pmt::dict_ref(hdr, key, pmt::PMT_NIL); + d_samp_rate = pmt::to_double(r); gr_tag_t t; t.offset = offset; @@ -219,9 +219,9 @@ namespace gr { } // GET TIME STAMP - key = pmt_string_to_symbol("rx_time"); - if(pmt_dict_has_key(hdr, key)) { - d_time_stamp = pmt_dict_ref(hdr, key, PMT_NIL); + key = pmt::string_to_symbol("rx_time"); + if(pmt::dict_has_key(hdr, key)) { + d_time_stamp = pmt::dict_ref(hdr, key, pmt::PMT_NIL); gr_tag_t t; t.offset = offset; @@ -235,16 +235,16 @@ namespace gr { } // GET ITEM SIZE OF DATA - if(pmt_dict_has_key(hdr, pmt_string_to_symbol("size"))) { - d_itemsize = pmt_to_long(pmt_dict_ref(hdr, pmt_string_to_symbol("size"), PMT_NIL)); + if(pmt::dict_has_key(hdr, pmt::string_to_symbol("size"))) { + d_itemsize = pmt::to_long(pmt::dict_ref(hdr, pmt::string_to_symbol("size"), pmt::PMT_NIL)); } else { throw std::runtime_error("file_meta_source: Could not extract item size.\n"); } // GET SEGMENT SIZE - if(pmt_dict_has_key(hdr, pmt_string_to_symbol("bytes"))) { - d_seg_size = pmt_to_uint64(pmt_dict_ref(hdr, pmt_string_to_symbol("bytes"), PMT_NIL)); + if(pmt::dict_has_key(hdr, pmt::string_to_symbol("bytes"))) { + d_seg_size = pmt::to_uint64(pmt::dict_ref(hdr, pmt::string_to_symbol("bytes"), pmt::PMT_NIL)); // Convert from bytes to items d_seg_size /= d_itemsize; @@ -255,16 +255,16 @@ namespace gr { } void - file_meta_source_impl::parse_extras(pmt_t extras, uint64_t offset, + file_meta_source_impl::parse_extras(pmt::pmt_t extras, uint64_t offset, std::vector<gr_tag_t> &tags) { - pmt_t item, key, val; + pmt::pmt_t item, key, val; - size_t nitems = pmt_length(extras); + size_t nitems = pmt::length(extras); for(size_t i = 0; i < nitems; i++) { - item = pmt_nth(i, extras); - key = pmt_car(item); - val = pmt_cdr(item); + item = pmt::nth(i, extras); + key = pmt::car(item); + val = pmt::cdr(item); gr_tag_t t; t.offset = offset; @@ -370,7 +370,7 @@ namespace gr { // We've reached the end of a segment; parse the next header and get // the new tags to send and set the next segment size. if(d_seg_size == 0) { - pmt_t hdr=PMT_NIL, extras=PMT_NIL; + pmt::pmt_t hdr=pmt::PMT_NIL, extras=pmt::PMT_NIL; if(read_header(hdr, extras)) { parse_header(hdr, nitems_written(0), d_tags); parse_extras(extras, nitems_written(0), d_tags); diff --git a/gr-blocks/lib/message_burst_source_impl.cc b/gr-blocks/lib/message_burst_source_impl.cc index f3c90eda31..5ac417f7a5 100644 --- a/gr-blocks/lib/message_burst_source_impl.cc +++ b/gr-blocks/lib/message_burst_source_impl.cc @@ -61,7 +61,7 @@ namespace gr { { std::stringstream id; id << name() << unique_id(); - d_me = pmt::pmt_string_to_symbol(id.str()); + d_me = pmt::string_to_symbol(id.str()); } message_burst_source_impl::message_burst_source_impl(size_t itemsize, gr_msg_queue_sptr msgq) @@ -73,7 +73,7 @@ namespace gr { { std::stringstream id; id << name() << unique_id(); - d_me = pmt::pmt_string_to_symbol(id.str()); + d_me = pmt::string_to_symbol(id.str()); } message_burst_source_impl::~message_burst_source_impl() @@ -112,8 +112,8 @@ namespace gr { //tag end of burst add_item_tag(0, //stream ID abs_sample_count+nn-1, //sample number - pmt::pmt_string_to_symbol("tx_eob"), - pmt::pmt_from_bool(1), + pmt::string_to_symbol("tx_eob"), + pmt::from_bool(1), d_me); //block src id } } @@ -133,8 +133,8 @@ namespace gr { //tag start of burst add_item_tag(0, //stream ID abs_sample_count+nn, //sample number - pmt::pmt_string_to_symbol("tx_sob"), - pmt::pmt_from_bool(1), + pmt::string_to_symbol("tx_sob"), + pmt::from_bool(1), d_me); //block src id if((d_msg->length() % d_itemsize) != 0) diff --git a/gr-blocks/lib/message_debug_impl.cc b/gr-blocks/lib/message_debug_impl.cc index d7b1e5db09..6455513d76 100644 --- a/gr-blocks/lib/message_debug_impl.cc +++ b/gr-blocks/lib/message_debug_impl.cc @@ -43,7 +43,7 @@ namespace gr { message_debug_impl::print(pmt::pmt_t msg) { std::cout << "******* MESSAGE DEBUG PRINT ********\n"; - pmt::pmt_print(msg); + pmt::print(msg); std::cout << "************************************\n"; } @@ -57,15 +57,15 @@ namespace gr { void message_debug_impl::print_pdu(pmt::pmt_t pdu) { - pmt::pmt_t meta = pmt::pmt_car(pdu); - pmt::pmt_t vector = pmt::pmt_cdr(pdu); + pmt::pmt_t meta = pmt::car(pdu); + pmt::pmt_t vector = pmt::cdr(pdu); std::cout << "* MESSAGE DEBUG PRINT PDU VERBOSE *\n"; - pmt::pmt_print(meta); - size_t len = pmt::pmt_length(vector); + pmt::print(meta); + size_t len = pmt::length(vector); std::cout << "pdu_length = " << len << std::endl; std::cout << "contents = " << std::endl; size_t offset(0); - const uint8_t* d = (const uint8_t*) pmt_uniform_vector_elements(vector, offset); + const uint8_t* d = (const uint8_t*) pmt::uniform_vector_elements(vector, offset); for(size_t i=0; i<len; i+=16){ printf("%04x: ", ((unsigned int)i)); for(size_t j=i; j<std::min(i+16,len); j++){ diff --git a/gr-blocks/lib/pdu.cc b/gr-blocks/lib/pdu.cc index 41a2d88c3a..ae4b17aecc 100644 --- a/gr-blocks/lib/pdu.cc +++ b/gr-blocks/lib/pdu.cc @@ -50,11 +50,11 @@ namespace gr { { switch(type) { case byte_t: - return pmt::pmt_is_u8vector(v); + return pmt::is_u8vector(v); case float_t: - return pmt::pmt_is_f32vector(v); + return pmt::is_f32vector(v); case complex_t: - return pmt::pmt_is_c32vector(v); + return pmt::is_c32vector(v); default: throw std::runtime_error("bad PDU type"); } @@ -65,11 +65,11 @@ namespace gr { { switch(type) { case byte_t: - return pmt::pmt_init_u8vector(items, buf); + return pmt::init_u8vector(items, buf); case float_t: - return pmt::pmt_init_f32vector(items, (const float *)buf); + return pmt::init_f32vector(items, (const float *)buf); case complex_t: - return pmt::pmt_init_c32vector(items, (const gr_complex *)buf); + return pmt::init_c32vector(items, (const gr_complex *)buf); default: throw std::runtime_error("bad PDU type"); } @@ -78,11 +78,11 @@ namespace gr { vector_type type_from_pmt(pmt::pmt_t vector) { - if(pmt_is_u8vector(vector)) + if(pmt::is_u8vector(vector)) return byte_t; - if(pmt_is_f32vector(vector)) + if(pmt::is_f32vector(vector)) return float_t; - if(pmt_is_c32vector(vector)) + if(pmt::is_c32vector(vector)) return complex_t; throw std::runtime_error("bad PDU type"); } diff --git a/gr-blocks/lib/pdu_to_tagged_stream_impl.cc b/gr-blocks/lib/pdu_to_tagged_stream_impl.cc index 80785b4781..1fc4857f2e 100644 --- a/gr-blocks/lib/pdu_to_tagged_stream_impl.cc +++ b/gr-blocks/lib/pdu_to_tagged_stream_impl.cc @@ -73,43 +73,43 @@ namespace gr { return nout; // make sure type is valid - if (!pmt::pmt_is_pair(msg)) // TODO: implement pdu::is_valid() + if (!pmt::is_pair(msg)) // TODO: implement pdu::is_valid() throw std::runtime_error("received a malformed pdu message"); // grab the components of the pdu message - pmt::pmt_t meta(pmt::pmt_car(msg)); - pmt::pmt_t vect(pmt::pmt_cdr(msg)); + pmt::pmt_t meta(pmt::car(msg)); + pmt::pmt_t vect(pmt::cdr(msg)); // compute offset for output tag uint64_t offset = nitems_written(0) + nout; // add a tag for pdu length - add_item_tag(0, offset, PDU_LENGTH_TAG, pmt::pmt_from_long(pmt::pmt_length(vect)), pmt::mp(alias())); + add_item_tag(0, offset, PDU_LENGTH_TAG, pmt::from_long(pmt::length(vect)), pmt::mp(alias())); // if we recieved metadata add it as tags - if (!pmt_eq(meta, pmt::PMT_NIL) ) { - pmt::pmt_t pair(pmt::pmt_dict_keys(meta)); + if (!pmt::eq(meta, pmt::PMT_NIL) ) { + pmt::pmt_t pair(pmt::dict_keys(meta)); - while (!pmt_eq(pair, pmt::PMT_NIL) ) { - pmt::pmt_t k(pmt::pmt_cdr(pair)); - pmt::pmt_t v(pmt::pmt_dict_ref(meta, k, pmt::PMT_NIL)); + while (!pmt::eq(pair, pmt::PMT_NIL) ) { + pmt::pmt_t k(pmt::cdr(pair)); + pmt::pmt_t v(pmt::dict_ref(meta, k, pmt::PMT_NIL)); add_item_tag(0, offset, k, v, pmt::mp(alias())); } } // copy vector output - size_t ncopy = std::min((size_t)noutput_items, (size_t)pmt::pmt_length(vect)); - size_t nsave = pmt::pmt_length(vect) - ncopy; + size_t ncopy = std::min((size_t)noutput_items, (size_t)pmt::length(vect)); + size_t nsave = pmt::length(vect) - ncopy; // copy output size_t io(0); nout += ncopy; - memcpy(out, pmt_uniform_vector_elements(vect,io), ncopy*d_itemsize); + memcpy(out, uniform_vector_elements(vect,io), ncopy*d_itemsize); // save leftover items if needed for next work call if (nsave > 0) { d_remain.resize(nsave*d_itemsize, 0); - memcpy(&d_remain[0], pmt_uniform_vector_elements(vect,ncopy), nsave*d_itemsize); + memcpy(&d_remain[0], uniform_vector_elements(vect,ncopy), nsave*d_itemsize); } } diff --git a/gr-blocks/lib/random_pdu_impl.cc b/gr-blocks/lib/random_pdu_impl.cc new file mode 100644 index 0000000000..0b194a0537 --- /dev/null +++ b/gr-blocks/lib/random_pdu_impl.cc @@ -0,0 +1,80 @@ +/* -*- 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. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "random_pdu_impl.h" +#include <gr_io_signature.h> +#include <blocks/pdu.h> + +namespace gr { + namespace blocks { + + random_pdu::sptr + random_pdu::make(int min_items, int max_items) + { + return gnuradio::get_initial_sptr(new random_pdu_impl(min_items, max_items)); + } + + random_pdu_impl::random_pdu_impl(int min_items, int max_items) + : gr_block("random_pdu", + gr_make_io_signature (0, 0, 0), + gr_make_io_signature (0, 0, 0)), + d_urange(min_items, max_items), + d_brange(0, 255), + d_rvar(d_rng, d_urange), + d_bvar(d_rng, d_brange) + { + message_port_register_out(PDU_PORT_ID); + message_port_register_in(pmt::mp("generate")); + set_msg_handler(pmt::mp("generate"), boost::bind(&random_pdu_impl::generate_pdu, this, _1)); + } + + bool + random_pdu_impl::start() + { + output_random(); + return true; + } + + void + random_pdu_impl::output_random() + { + // pick a random vector length + int len = d_rvar(); + + // fill it with random bytes + std::vector<unsigned char> vec; + for (int i=0; i<len; i++) + vec.push_back((unsigned char) d_bvar()); + + // send the vector + pmt::pmt_t vecpmt(pmt::make_blob(&vec[0], len)); + pmt::pmt_t pdu(pmt::cons(pmt::PMT_NIL, vecpmt)); + + message_port_pub(PDU_PORT_ID, pdu); + } + + } /* namespace blocks */ +}/* namespace gr */ diff --git a/gr-blocks/lib/random_pdu_impl.h b/gr-blocks/lib/random_pdu_impl.h new file mode 100644 index 0000000000..3197f740a0 --- /dev/null +++ b/gr-blocks/lib/random_pdu_impl.h @@ -0,0 +1,54 @@ +/* -*- 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_BLOCKS_SOCKET_PDU_IMPL_H +#define INCLUDED_BLOCKS_RANDOM_PDU_IMPL_H + +#include <blocks/random_pdu.h> +#include <boost/random.hpp> +#include <boost/generator_iterator.hpp> + +namespace gr { + namespace blocks { + + class random_pdu_impl : public random_pdu + { + private: + boost::mt19937 d_rng; + boost::uniform_int<> d_urange; + boost::uniform_int<> d_brange; + boost::variate_generator< boost::mt19937, boost::uniform_int<> > d_rvar; // pdu length + boost::variate_generator< boost::mt19937, boost::uniform_int<> > d_bvar; // pdu contents + + public: + random_pdu_impl(int min_items, int max_items); + + bool start(); + void output_random(); + void generate_pdu(pmt::pmt_t msg) { output_random(); } + void generate_pdu() { output_random(); } + }; + + } /* namespace blocks */ +} /* namespace gr */ + +#endif /* INCLUDED_BLOCKS_RANDOM_PDU_IMPL_H */ diff --git a/gr-blocks/lib/rms_cf_impl.cc b/gr-blocks/lib/rms_cf_impl.cc index d956b45f1a..9b2c031e10 100644 --- a/gr-blocks/lib/rms_cf_impl.cc +++ b/gr-blocks/lib/rms_cf_impl.cc @@ -38,12 +38,12 @@ namespace gr { (new rms_cf_impl(alpha)); } - rms_cf_impl::rms_cf_impl (double alpha) + rms_cf_impl::rms_cf_impl(double alpha) : gr_sync_block("rms_cf", gr_make_io_signature(1, 1, sizeof(gr_complex)), - gr_make_io_signature(1, 1, sizeof(float))), - d_iir(alpha) + gr_make_io_signature(1, 1, sizeof(float))) { + set_alpha(alpha); } rms_cf_impl::~rms_cf_impl() @@ -53,7 +53,9 @@ namespace gr { void rms_cf_impl::set_alpha(double alpha) { - d_iir.set_taps(alpha); + d_alpha = alpha; + d_beta = 1 - d_alpha; + d_avg = 0; } int @@ -66,8 +68,8 @@ namespace gr { for(int i = 0; i < noutput_items; i++) { double mag_sqrd = in[i].real()*in[i].real() + in[i].imag()*in[i].imag(); - double f = d_iir.filter(mag_sqrd); - out[i] = sqrt(f); + d_avg = d_beta*d_avg + d_alpha*mag_sqrd; + out[i] = sqrt(d_avg); } return noutput_items; diff --git a/gr-blocks/lib/rms_cf_impl.h b/gr-blocks/lib/rms_cf_impl.h index 438b8549db..316ab2f304 100644 --- a/gr-blocks/lib/rms_cf_impl.h +++ b/gr-blocks/lib/rms_cf_impl.h @@ -24,7 +24,6 @@ #define INCLUDED_BLOCKS_RMS_CF_IMPL_H #include <blocks/rms_cf.h> -#include <gr_single_pole_iir.h> namespace gr { namespace blocks { @@ -36,7 +35,7 @@ namespace gr { class rms_cf_impl : public rms_cf { private: - gr_single_pole_iir<double,double,double> d_iir; + double d_alpha, d_beta, d_avg; public: rms_cf_impl(double alpha = 0.0001); diff --git a/gr-blocks/lib/rms_ff_impl.cc b/gr-blocks/lib/rms_ff_impl.cc index 2b8cdc34e7..8e004ad61e 100644 --- a/gr-blocks/lib/rms_ff_impl.cc +++ b/gr-blocks/lib/rms_ff_impl.cc @@ -41,9 +41,9 @@ namespace gr { rms_ff_impl::rms_ff_impl(double alpha) : gr_sync_block("rms_ff", gr_make_io_signature(1, 1, sizeof(float)), - gr_make_io_signature(1, 1, sizeof(float))), - d_iir(alpha) + gr_make_io_signature(1, 1, sizeof(float))) { + set_alpha(alpha); } rms_ff_impl::~rms_ff_impl() @@ -53,7 +53,9 @@ namespace gr { void rms_ff_impl::set_alpha(double alpha) { - d_iir.set_taps(alpha); + d_alpha = alpha; + d_beta = 1 - d_alpha; + d_avg = 0; } int @@ -66,8 +68,8 @@ namespace gr { for(int i = 0; i < noutput_items; i++) { double mag_sqrd = in[i]*in[i]; - double f = d_iir.filter(mag_sqrd); - out[i] = sqrt(f); + d_avg = d_beta*d_avg + d_alpha*mag_sqrd; + out[i] = sqrt(d_avg); } return noutput_items; diff --git a/gr-blocks/lib/rms_ff_impl.h b/gr-blocks/lib/rms_ff_impl.h index 82ecbda52d..34d7d986c0 100644 --- a/gr-blocks/lib/rms_ff_impl.h +++ b/gr-blocks/lib/rms_ff_impl.h @@ -24,7 +24,6 @@ #define INCLUDED_BLOCKS_RMS_FF_IMPL_H #include <blocks/rms_ff.h> -#include <gr_single_pole_iir.h> namespace gr { namespace blocks { @@ -36,7 +35,7 @@ namespace gr { class rms_ff_impl : public rms_ff { private: - gr_single_pole_iir<double,double,double> d_iir; + double d_alpha, d_beta, d_avg; public: rms_ff_impl(double alpha = 0.0001); diff --git a/gr-blocks/lib/socket_pdu_impl.cc b/gr-blocks/lib/socket_pdu_impl.cc index 0a48c2b9f4..4ff5ce6eb9 100644 --- a/gr-blocks/lib/socket_pdu_impl.cc +++ b/gr-blocks/lib/socket_pdu_impl.cc @@ -27,7 +27,7 @@ #include "socket_pdu_impl.h" #include "tcp_connection.h" #include <gr_io_signature.h> -#include <gr_pdu.h> +#include <blocks/pdu.h> namespace gr { namespace blocks { @@ -112,8 +112,8 @@ namespace gr { socket_pdu_impl::handle_tcp_read(const boost::system::error_code& error, size_t bytes_transferred) { if (!error) { - pmt::pmt_t vector = pmt::pmt_init_u8vector(bytes_transferred, (const uint8_t *)&d_rxbuf[0]); - pmt::pmt_t pdu = pmt::pmt_cons(pmt::PMT_NIL, vector); + pmt::pmt_t vector = pmt::init_u8vector(bytes_transferred, (const uint8_t *)&d_rxbuf[0]); + pmt::pmt_t pdu = pmt::cons(pmt::PMT_NIL, vector); message_port_pub(PDU_PORT_ID, pdu); d_tcp_socket->async_read_some(boost::asio::buffer(d_rxbuf), @@ -138,7 +138,7 @@ namespace gr { void socket_pdu_impl::tcp_server_send(pmt::pmt_t msg) { - pmt::pmt_t vector = pmt::pmt_cdr(msg); + pmt::pmt_t vector = pmt::cdr(msg); for(size_t i = 0; i < d_tcp_connections.size(); i++) d_tcp_connections[i]->send(vector); } @@ -158,22 +158,22 @@ namespace gr { void socket_pdu_impl::tcp_client_send(pmt::pmt_t msg) { - pmt::pmt_t vector = pmt::pmt_cdr(msg); - size_t len = pmt::pmt_length(vector); + pmt::pmt_t vector = pmt::cdr(msg); + size_t len = pmt::length(vector); size_t offset(0); boost::array<char, 10000> txbuf; - memcpy(&txbuf[0], pmt::pmt_uniform_vector_elements(vector, offset), len); + memcpy(&txbuf[0], pmt::uniform_vector_elements(vector, offset), len); d_tcp_socket->send(boost::asio::buffer(txbuf,len)); } void socket_pdu_impl::udp_send(pmt::pmt_t msg) { - pmt::pmt_t vector = pmt::pmt_cdr(msg); - size_t len = pmt::pmt_length(vector); + pmt::pmt_t vector = pmt::cdr(msg); + size_t len = pmt::length(vector); size_t offset(0); boost::array<char, 10000> txbuf; - memcpy(&txbuf[0], pmt::pmt_uniform_vector_elements(vector, offset), len); + memcpy(&txbuf[0], pmt::uniform_vector_elements(vector, offset), len); if (d_udp_endpoint_other.address().to_string() != "0.0.0.0") d_udp_socket->send_to(boost::asio::buffer(txbuf,len), d_udp_endpoint_other); } @@ -182,8 +182,8 @@ namespace gr { socket_pdu_impl::handle_udp_read(const boost::system::error_code& error, size_t bytes_transferred) { if (!error) { - pmt::pmt_t vector = pmt::pmt_init_u8vector(bytes_transferred, (const uint8_t*)&d_rxbuf[0]); - pmt::pmt_t pdu = pmt::pmt_cons( pmt::PMT_NIL, vector); + pmt::pmt_t vector = pmt::init_u8vector(bytes_transferred, (const uint8_t*)&d_rxbuf[0]); + pmt::pmt_t pdu = pmt::cons( pmt::PMT_NIL, vector); message_port_pub(PDU_PORT_ID, pdu); diff --git a/gr-blocks/lib/stream_pdu_base.cc b/gr-blocks/lib/stream_pdu_base.cc index 21fbb5eabe..0c4e7e0863 100644 --- a/gr-blocks/lib/stream_pdu_base.cc +++ b/gr-blocks/lib/stream_pdu_base.cc @@ -87,8 +87,8 @@ namespace gr { if (result <= 0) throw std::runtime_error("stream_pdu_base, bad socket read!"); - pmt::pmt_t vector = pmt::pmt_init_u8vector(result, &d_rxbuf[0]); - pmt::pmt_t pdu = pmt::pmt_cons(pmt::PMT_NIL, vector); + pmt::pmt_t vector = pmt::init_u8vector(result, &d_rxbuf[0]); + pmt::pmt_t pdu = pmt::cons(pmt::PMT_NIL, vector); d_blk->message_port_pub(d_port, pdu); } @@ -114,12 +114,12 @@ namespace gr { void stream_pdu_base::send(pmt::pmt_t msg) { - pmt::pmt_t vector = pmt::pmt_cdr(msg); + pmt::pmt_t vector = pmt::cdr(msg); size_t offset(0); size_t itemsize(pdu::itemsize(pdu::type_from_pmt(vector))); - int len(pmt::pmt_length(vector)*itemsize); + int len(pmt::length(vector)*itemsize); - const int rv = write(d_fd, pmt::pmt_uniform_vector_elements(vector, offset), len); + const int rv = write(d_fd, pmt::uniform_vector_elements(vector, offset), len); if (rv != len) { std::cerr << boost::format("WARNING: stream_pdu_base::send(pdu) write failed! (d_fd=%d, len=%d, rv=%d)") % d_fd % len % rv << std::endl; diff --git a/gr-blocks/lib/tag_debug_impl.cc b/gr-blocks/lib/tag_debug_impl.cc index a216879637..c595d41db5 100644 --- a/gr-blocks/lib/tag_debug_impl.cc +++ b/gr-blocks/lib/tag_debug_impl.cc @@ -95,8 +95,8 @@ namespace gr { for(d_tags_itr = d_tags.begin(); d_tags_itr != d_tags.end(); d_tags_itr++) { sout << std::setw(10) << "Offset: " << d_tags_itr->offset << std::setw(10) << "Source: " - << (pmt::pmt_is_symbol(d_tags_itr->srcid) ? pmt::pmt_symbol_to_string(d_tags_itr->srcid) : "n/a") - << std::setw(10) << "Key: " << pmt::pmt_symbol_to_string(d_tags_itr->key) + << (pmt::is_symbol(d_tags_itr->srcid) ? pmt::symbol_to_string(d_tags_itr->srcid) : "n/a") + << std::setw(10) << "Key: " << pmt::symbol_to_string(d_tags_itr->key) << std::setw(10) << "Value: "; sout << d_tags_itr->value << std::endl; } diff --git a/gr-blocks/lib/tagged_stream_to_pdu_impl.cc b/gr-blocks/lib/tagged_stream_to_pdu_impl.cc index acd07292f4..fc5c8f6424 100644 --- a/gr-blocks/lib/tagged_stream_to_pdu_impl.cc +++ b/gr-blocks/lib/tagged_stream_to_pdu_impl.cc @@ -65,15 +65,15 @@ namespace gr { get_tags_in_range(d_tags, 0, abs_N, abs_N+1); for (d_tags_itr = d_tags.begin(); (d_tags_itr != d_tags.end()) && (!found_length_tag); d_tags_itr++) { - if (pmt::pmt_equal((*d_tags_itr).key, PDU_LENGTH_TAG )) { + if (pmt::eq((*d_tags_itr).key, PDU_LENGTH_TAG )) { if ((*d_tags_itr).offset != abs_N ) throw std::runtime_error("expected next pdu length tag on a different item..."); found_length_tag = true; - d_pdu_length = pmt::pmt_to_long((*d_tags_itr).value); + d_pdu_length = pmt::to_long((*d_tags_itr).value); d_pdu_remain = d_pdu_length; - d_pdu_meta = pmt::pmt_make_dict(); + d_pdu_meta = pmt::make_dict(); break; } // if have length tag } // iter over tags @@ -87,8 +87,8 @@ namespace gr { // copy any tags in this range into our meta object get_tags_in_range(d_tags, 0, abs_N, abs_N+ncopy); for (d_tags_itr = d_tags.begin(); d_tags_itr != d_tags.end(); d_tags_itr++) - if(!pmt_equal((*d_tags_itr).key, PDU_LENGTH_TAG )) - d_pdu_meta = pmt_dict_add(d_pdu_meta, (*d_tags_itr).key, (*d_tags_itr).value); + if(!pmt::eq((*d_tags_itr).key, PDU_LENGTH_TAG )) + d_pdu_meta = dict_add(d_pdu_meta, (*d_tags_itr).key, (*d_tags_itr).value); // copy samples for this vector into either a pmt or our save buffer if (ncopy == d_pdu_remain) { // we will send this pdu @@ -119,10 +119,10 @@ namespace gr { void tagged_stream_to_pdu_impl::send_message() { - if (pmt::pmt_length(d_pdu_vector) != d_pdu_length) + if (pmt::length(d_pdu_vector) != d_pdu_length) throw std::runtime_error("msg length not correct"); - pmt::pmt_t msg = pmt::pmt_cons(d_pdu_meta, d_pdu_vector); + pmt::pmt_t msg = pmt::cons(d_pdu_meta, d_pdu_vector); message_port_pub(PDU_PORT_ID, msg); d_pdu_meta = pmt::PMT_NIL; diff --git a/gr-blocks/lib/tcp_connection.cc b/gr-blocks/lib/tcp_connection.cc index 4ead6442d8..33bb6f10f1 100644 --- a/gr-blocks/lib/tcp_connection.cc +++ b/gr-blocks/lib/tcp_connection.cc @@ -26,9 +26,7 @@ #include "tcp_connection.h" #include <gr_basic_block.h> -#include <gr_pdu.h> -//#include <boost/asio.hpp> -//#include <boost/bind.hpp> +#include <blocks/pdu.h> namespace gr { namespace blocks { @@ -46,10 +44,10 @@ namespace gr { void tcp_connection::send(pmt::pmt_t vector) { - size_t len = pmt::pmt_length(vector); + size_t len = pmt::length(vector); size_t offset(0); boost::array<char, 10000> txbuf; - memcpy(&txbuf[0], pmt::pmt_uniform_vector_elements(vector, offset), len); + memcpy(&txbuf[0], pmt::uniform_vector_elements(vector, offset), len); boost::asio::async_write(d_socket, boost::asio::buffer(txbuf, len), boost::bind(&tcp_connection::handle_write, this, boost::asio::placeholders::error, @@ -70,8 +68,8 @@ namespace gr { tcp_connection::handle_read(const boost::system::error_code& error, size_t bytes_transferred) { if (!error) { - pmt::pmt_t vector = pmt::pmt_init_u8vector(bytes_transferred, (const uint8_t*)&d_buf[0]); - pmt::pmt_t pdu = pmt::pmt_cons( pmt::PMT_NIL, vector); + pmt::pmt_t vector = pmt::init_u8vector(bytes_transferred, (const uint8_t*)&d_buf[0]); + pmt::pmt_t pdu = pmt::cons( pmt::PMT_NIL, vector); d_block->message_port_pub(PDU_PORT_ID, pdu); diff --git a/gr-blocks/lib/throttle_impl.cc b/gr-blocks/lib/throttle_impl.cc index 49743e3f26..b1cfe4b3c8 100644 --- a/gr-blocks/lib/throttle_impl.cc +++ b/gr-blocks/lib/throttle_impl.cc @@ -93,5 +93,25 @@ namespace gr { return noutput_items; } + void + throttle_impl::setup_rpc() + { +#ifdef GR_CTRLPORT + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_get<throttle, double>( + alias(), "sample_rate", &throttle::sample_rate, + pmt::mp(0.0), pmt::mp(100.0e6), pmt::mp(0.0), + "Hz", "Sample Rate", RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); + + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_set<throttle, double>( + alias(), "sample_rate", &throttle::set_sample_rate, + pmt::mp(0.0), pmt::mp(100.0e6), pmt::mp(0.0), + "Hz", "Sample Rate", RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); +#endif /* GR_CTRLPORT */ + } + } /* namespace blocks */ } /* namespace gr */ diff --git a/gr-blocks/lib/throttle_impl.h b/gr-blocks/lib/throttle_impl.h index 86dbef2ac9..2f2cdf108b 100644 --- a/gr-blocks/lib/throttle_impl.h +++ b/gr-blocks/lib/throttle_impl.h @@ -40,6 +40,8 @@ namespace gr { throttle_impl(size_t itemsize, double samples_per_sec); ~throttle_impl(); + void setup_rpc(); + void set_sample_rate(double rate); double sample_rate() const; diff --git a/gr-blocks/python/CMakeLists.txt b/gr-blocks/python/CMakeLists.txt index cab0b956f7..841588799b 100644 --- a/gr-blocks/python/CMakeLists.txt +++ b/gr-blocks/python/CMakeLists.txt @@ -24,6 +24,7 @@ GR_PYTHON_INSTALL( FILES __init__.py parse_file_metadata.py + stream_to_vector_decimator.py DESTINATION ${GR_PYTHON_DIR}/gnuradio/blocks COMPONENT "blocks_python" ) diff --git a/gr-blocks/python/__init__.py b/gr-blocks/python/__init__.py index 6577d933e0..56d274918c 100644 --- a/gr-blocks/python/__init__.py +++ b/gr-blocks/python/__init__.py @@ -25,8 +25,9 @@ processing blocks common to many flowgraphs. ''' from blocks_swig import * +from stream_to_vector_decimator import * -#alias old gr_add_vXX and gr_multiply_vXX +#alias old add_vXX and multiply_vXX add_vcc = add_cc add_vff = add_ff add_vii = add_ii diff --git a/gr-blocks/python/parse_file_metadata.py b/gr-blocks/python/parse_file_metadata.py index c8ac2def94..eaa8025bbf 100644 --- a/gr-blocks/python/parse_file_metadata.py +++ b/gr-blocks/python/parse_file_metadata.py @@ -66,14 +66,14 @@ def parse_header(p, VERBOSE=False): info = dict() - if(pmt.pmt_is_dict(p) is False): + if(pmt.is_dict(p) is False): sys.stderr.write("Header is not a PMT dictionary: invalid or corrupt data file.\n") sys.exit(1) # GET FILE FORMAT VERSION NUMBER - if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("version"))): - r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("version"), dump) - version = pmt.pmt_to_long(r) + if(pmt.dict_has_key(p, pmt.string_to_symbol("version"))): + r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump) + version = pmt.to_long(r) if(VERBOSE): print "Version Number: {0}".format(version) else: @@ -81,9 +81,9 @@ def parse_header(p, VERBOSE=False): sys.exit(1) # EXTRACT SAMPLE RATE - if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("rx_rate"))): - r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("rx_rate"), dump) - samp_rate = pmt.pmt_to_double(r) + if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_rate"))): + r = pmt.dict_ref(p, pmt.string_to_symbol("rx_rate"), dump) + samp_rate = pmt.to_double(r) info["rx_rate"] = samp_rate if(VERBOSE): print "Sample Rate: {0:.2f} sps".format(samp_rate) @@ -92,12 +92,12 @@ def parse_header(p, VERBOSE=False): sys.exit(1) # EXTRACT TIME STAMP - if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("rx_time"))): - r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("rx_time"), dump) - pmt_secs = pmt.pmt_tuple_ref(r, 0) - pmt_fracs = pmt.pmt_tuple_ref(r, 1) - secs = float(pmt.pmt_to_uint64(pmt_secs)) - fracs = pmt.pmt_to_double(pmt_fracs) + if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_time"))): + r = pmt.dict_ref(p, pmt.string_to_symbol("rx_time"), dump) + secs = pmt.tuple_ref(r, 0) + fracs = pmt.tuple_ref(r, 1) + secs = float(pmt.to_uint64(secs)) + fracs = pmt.to_double(fracs) t = secs + fracs info["rx_time"] = t if(VERBOSE): @@ -107,9 +107,9 @@ def parse_header(p, VERBOSE=False): sys.exit(1) # EXTRACT ITEM SIZE - if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("size"))): - r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("size"), dump) - dsize = pmt.pmt_to_long(r) + if(pmt.dict_has_key(p, pmt.string_to_symbol("size"))): + r = pmt.dict_ref(p, pmt.string_to_symbol("size"), dump) + dsize = pmt.to_long(r) info["size"] = dsize if(VERBOSE): print "Item size: {0}".format(dsize) @@ -118,9 +118,9 @@ def parse_header(p, VERBOSE=False): sys.exit(1) # EXTRACT DATA TYPE - if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("type"))): - r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("type"), dump) - dtype = pmt.pmt_to_long(r) + if(pmt.dict_has_key(p, pmt.string_to_symbol("type"))): + r = pmt.dict_ref(p, pmt.string_to_symbol("type"), dump) + dtype = pmt.to_long(r) stype = ftype_to_string[dtype] info["type"] = stype if(VERBOSE): @@ -130,9 +130,9 @@ def parse_header(p, VERBOSE=False): sys.exit(1) # EXTRACT COMPLEX - if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("cplx"))): - r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("cplx"), dump) - cplx = pmt.pmt_to_bool(r) + if(pmt.dict_has_key(p, pmt.string_to_symbol("cplx"))): + r = pmt.dict_ref(p, pmt.string_to_symbol("cplx"), dump) + cplx = pmt.to_bool(r) info["cplx"] = cplx if(VERBOSE): print "Complex? {0}".format(cplx) @@ -141,9 +141,9 @@ def parse_header(p, VERBOSE=False): sys.exit(1) # EXTRACT WHERE CURRENT SEGMENT STARTS - if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("strt"))): - r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("strt"), dump) - seg_start = pmt.pmt_to_uint64(r) + if(pmt.dict_has_key(p, pmt.string_to_symbol("strt"))): + r = pmt.dict_ref(p, pmt.string_to_symbol("strt"), dump) + seg_start = pmt.to_uint64(r) info["hdr_len"] = seg_start info["extra_len"] = seg_start - HEADER_LENGTH info["has_extra"] = info["extra_len"] > 0 @@ -156,9 +156,9 @@ def parse_header(p, VERBOSE=False): sys.exit(1) # EXTRACT SIZE OF DATA - if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("bytes"))): - r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("bytes"), dump) - nbytes = pmt.pmt_to_uint64(r) + if(pmt.dict_has_key(p, pmt.string_to_symbol("bytes"))): + r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump) + nbytes = pmt.to_uint64(r) nitems = nbytes/dsize info["nitems"] = nitems @@ -175,19 +175,18 @@ def parse_header(p, VERBOSE=False): # IF THERE IS EXTRA DATA, PULL OUT THE DICTIONARY AND PARSE IT def parse_extra_dict(p, info, VERBOSE=False): - if(pmt.pmt_is_dict(p) is False): + if(pmt.is_dict(p) is False): sys.stderr.write("Extra header is not a PMT dictionary: invalid or corrupt data file.\n") sys.exit(1) - items = pmt.pmt_dict_items(p) - nitems = pmt.pmt_length(items) + items = pmt.dict_items(p) + nitems = pmt.length(items) for i in xrange(nitems): - item = pmt.pmt_nth(i, items) - key = pmt.pmt_symbol_to_string(pmt.pmt_car(item)) - val = pmt.pmt_cdr(item) + item = pmt.nth(i, items) + key = pmt.symbol_to_string(pmt.car(item)) + val = pmt.cdr(item) info[key] = val if(VERBOSE): - print "{0}: ".format(key) - pmt.pmt_print(val) + print "{0}: {1}".format(key, val) return info diff --git a/gr-blocks/python/qa_add_mult_v.py b/gr-blocks/python/qa_add_mult_v.py index d362cb8859..13cb71df2c 100755 --- a/gr-blocks/python/qa_add_mult_v.py +++ b/gr-blocks/python/qa_add_mult_v.py @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks class test_add_mult_v(gr_unittest.TestCase): @@ -34,10 +34,10 @@ class test_add_mult_v(gr_unittest.TestCase): def help_ss(self, size, src_data, exp_data, op): for s in zip(range (len (src_data)), src_data): src = gr.vector_source_s(s[1]) - srcv = gr.stream_to_vector(gr.sizeof_short, size) + srcv = blocks.stream_to_vector(gr.sizeof_short, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) - rhs = gr.vector_to_stream(gr.sizeof_short, size) + rhs = blocks.vector_to_stream(gr.sizeof_short, size) dst = gr.vector_sink_s() self.tb.connect(op, rhs, dst) self.tb.run() @@ -47,10 +47,10 @@ class test_add_mult_v(gr_unittest.TestCase): def help_ii(self, size, src_data, exp_data, op): for s in zip(range (len (src_data)), src_data): src = gr.vector_source_i(s[1]) - srcv = gr.stream_to_vector(gr.sizeof_int, size) + srcv = blocks.stream_to_vector(gr.sizeof_int, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) - rhs = gr.vector_to_stream(gr.sizeof_int, size) + rhs = blocks.vector_to_stream(gr.sizeof_int, size) dst = gr.vector_sink_i() self.tb.connect(op, rhs, dst) self.tb.run() @@ -60,10 +60,10 @@ class test_add_mult_v(gr_unittest.TestCase): def help_ff(self, size, src_data, exp_data, op): for s in zip(range (len (src_data)), src_data): src = gr.vector_source_f(s[1]) - srcv = gr.stream_to_vector(gr.sizeof_float, size) + srcv = blocks.stream_to_vector(gr.sizeof_float, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) - rhs = gr.vector_to_stream(gr.sizeof_float, size) + rhs = blocks.vector_to_stream(gr.sizeof_float, size) dst = gr.vector_sink_f() self.tb.connect(op, rhs, dst) self.tb.run() @@ -73,10 +73,10 @@ class test_add_mult_v(gr_unittest.TestCase): def help_cc(self, size, src_data, exp_data, op): for s in zip(range (len (src_data)), src_data): src = gr.vector_source_c(s[1]) - srcv = gr.stream_to_vector(gr.sizeof_gr_complex, size) + srcv = blocks.stream_to_vector(gr.sizeof_gr_complex, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) - rhs = gr.vector_to_stream(gr.sizeof_gr_complex, size) + rhs = blocks.vector_to_stream(gr.sizeof_gr_complex, size) dst = gr.vector_sink_c() self.tb.connect(op, rhs, dst) self.tb.run() @@ -85,8 +85,8 @@ class test_add_mult_v(gr_unittest.TestCase): def help_const_ss(self, src_data, exp_data, op): src = gr.vector_source_s(src_data) - srcv = gr.stream_to_vector(gr.sizeof_short, len(src_data)) - rhs = gr.vector_to_stream(gr.sizeof_short, len(src_data)) + srcv = blocks.stream_to_vector(gr.sizeof_short, len(src_data)) + rhs = blocks.vector_to_stream(gr.sizeof_short, len(src_data)) dst = gr.vector_sink_s() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() @@ -95,8 +95,8 @@ class test_add_mult_v(gr_unittest.TestCase): def help_const_ii(self, src_data, exp_data, op): src = gr.vector_source_i(src_data) - srcv = gr.stream_to_vector(gr.sizeof_int, len(src_data)) - rhs = gr.vector_to_stream(gr.sizeof_int, len(src_data)) + srcv = blocks.stream_to_vector(gr.sizeof_int, len(src_data)) + rhs = blocks.vector_to_stream(gr.sizeof_int, len(src_data)) dst = gr.vector_sink_i() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() @@ -105,8 +105,8 @@ class test_add_mult_v(gr_unittest.TestCase): def help_const_ff(self, src_data, exp_data, op): src = gr.vector_source_f(src_data) - srcv = gr.stream_to_vector(gr.sizeof_float, len(src_data)) - rhs = gr.vector_to_stream(gr.sizeof_float, len(src_data)) + srcv = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) + rhs = blocks.vector_to_stream(gr.sizeof_float, len(src_data)) dst = gr.vector_sink_f() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() @@ -115,8 +115,8 @@ class test_add_mult_v(gr_unittest.TestCase): def help_const_cc(self, src_data, exp_data, op): src = gr.vector_source_c(src_data) - srcv = gr.stream_to_vector(gr.sizeof_gr_complex, len(src_data)) - rhs = gr.vector_to_stream(gr.sizeof_gr_complex, len(src_data)) + srcv = blocks.stream_to_vector(gr.sizeof_gr_complex, len(src_data)) + rhs = blocks.vector_to_stream(gr.sizeof_gr_complex, len(src_data)) dst = gr.vector_sink_c() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() @@ -130,7 +130,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (2,) src3_data = (3,) expected_result = (6,) - op = blocks_swig.add_ss(1) + op = blocks.add_ss(1) self.help_ss(1, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vss_five(self): @@ -138,7 +138,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (6, 7, 8, 9, 10) src3_data = (11, 12, 13, 14, 15) expected_result = (18, 21, 24, 27, 30) - op = blocks_swig.add_ss(5) + op = blocks.add_ss(5) self.help_ss(5, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vii_one(self): @@ -146,7 +146,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (2,) src3_data = (3,) expected_result = (6,) - op = blocks_swig.add_ii(1) + op = blocks.add_ii(1) self.help_ii(1, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vii_five(self): @@ -154,7 +154,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (6, 7, 8, 9, 10) src3_data = (11, 12, 13, 14, 15) expected_result = (18, 21, 24, 27, 30) - op = blocks_swig.add_ii(5) + op = blocks.add_ii(5) self.help_ii(5, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vff_one(self): @@ -162,7 +162,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (2.0,) src3_data = (3.0,) expected_result = (6.0,) - op = blocks_swig.add_ff(1) + op = blocks.add_ff(1) self.help_ff(1, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vff_five(self): @@ -170,7 +170,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (6.0, 7.0, 8.0, 9.0, 10.0) src3_data = (11.0, 12.0, 13.0, 14.0, 15.0) expected_result = (18.0, 21.0, 24.0, 27.0, 30.0) - op = blocks_swig.add_ff(5) + op = blocks.add_ff(5) self.help_ff(5, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vcc_one(self): @@ -178,7 +178,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (3.0+4.0j,) src3_data = (5.0+6.0j,) expected_result = (9.0+12j,) - op = blocks_swig.add_cc(1) + op = blocks.add_cc(1) self.help_cc(1, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vcc_five(self): @@ -186,56 +186,56 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j) src3_data = (21.0+22.0j, 23.0+24.0j, 25.0+26.0j, 27.0+28.0j, 29.0+30.0j) expected_result = (33.0+36.0j, 39.0+42.0j, 45.0+48.0j, 51.0+54.0j, 57.0+60.0j) - op = blocks_swig.add_cc(5) + op = blocks.add_cc(5) self.help_cc(5, (src1_data, src2_data, src3_data), expected_result, op) # add_const_vXX def test_add_const_vss_one(self): src_data = (1,) - op = blocks_swig.add_const_vss((2,)) + op = blocks.add_const_vss((2,)) exp_data = (3,) self.help_const_ss(src_data, exp_data, op) def test_add_const_vss_five(self): src_data = (1, 2, 3, 4, 5) - op = blocks_swig.add_const_vss((6, 7, 8, 9, 10)) + op = blocks.add_const_vss((6, 7, 8, 9, 10)) exp_data = (7, 9, 11, 13, 15) self.help_const_ss(src_data, exp_data, op) def test_add_const_vii_one(self): src_data = (1,) - op = blocks_swig.add_const_vii((2,)) + op = blocks.add_const_vii((2,)) exp_data = (3,) self.help_const_ii(src_data, exp_data, op) def test_add_const_vii_five(self): src_data = (1, 2, 3, 4, 5) - op = blocks_swig.add_const_vii((6, 7, 8, 9, 10)) + op = blocks.add_const_vii((6, 7, 8, 9, 10)) exp_data = (7, 9, 11, 13, 15) self.help_const_ii(src_data, exp_data, op) def test_add_const_vff_one(self): src_data = (1.0,) - op = blocks_swig.add_const_vff((2.0,)) + op = blocks.add_const_vff((2.0,)) exp_data = (3.0,) self.help_const_ff(src_data, exp_data, op) def test_add_const_vff_five(self): src_data = (1.0, 2.0, 3.0, 4.0, 5.0) - op = blocks_swig.add_const_vff((6.0, 7.0, 8.0, 9.0, 10.0)) + op = blocks.add_const_vff((6.0, 7.0, 8.0, 9.0, 10.0)) exp_data = (7.0, 9.0, 11.0, 13.0, 15.0) self.help_const_ff(src_data, exp_data, op) def test_add_const_vcc_one(self): src_data = (1.0+2.0j,) - op = blocks_swig.add_const_vcc((2.0+3.0j,)) + op = blocks.add_const_vcc((2.0+3.0j,)) exp_data = (3.0+5.0j,) self.help_const_cc(src_data, exp_data, op) def test_add_const_vcc_five(self): src_data = (1.0+2.0j, 3.0+4.0j, 5.0+6.0j, 7.0+8.0j, 9.0+10.0j) - op = blocks_swig.add_const_vcc((11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j)) + op = blocks.add_const_vcc((11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j)) exp_data = (12.0+14.0j, 16.0+18.0j, 20.0+22.0j, 24.0+26.0j, 28.0+30.0j) self.help_const_cc(src_data, exp_data, op) @@ -246,7 +246,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (2,) src3_data = (3,) expected_result = (6,) - op = gr.multiply_vss(1) + op = blocks.multiply_ss(1) self.help_ss(1, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vss_five(self): @@ -254,7 +254,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (6, 7, 8, 9, 10) src3_data = (11, 12, 13, 14, 15) expected_result = (66, 168, 312, 504, 750) - op = gr.multiply_vss(5) + op = blocks.multiply_ss(5) self.help_ss(5, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vii_one(self): @@ -262,7 +262,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (2,) src3_data = (3,) expected_result = (6,) - op = gr.multiply_vii(1) + op = blocks.multiply_ii(1) self.help_ii(1, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vii_five(self): @@ -270,7 +270,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (6, 7, 8, 9, 10) src3_data = (11, 12, 13, 14, 15) expected_result = (66, 168, 312, 504, 750) - op = gr.multiply_vii(5) + op = blocks.multiply_ii(5) self.help_ii(5, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vff_one(self): @@ -278,7 +278,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (2.0,) src3_data = (3.0,) expected_result = (6.0,) - op = gr.multiply_vff(1) + op = blocks.multiply_ff(1) self.help_ff(1, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vff_five(self): @@ -286,7 +286,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (6.0, 7.0, 8.0, 9.0, 10.0) src3_data = (11.0, 12.0, 13.0, 14.0, 15.0) expected_result = (66.0, 168.0, 312.0, 504.0, 750.0) - op = gr.multiply_vff(5) + op = blocks.multiply_ff(5) self.help_ff(5, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vcc_one(self): @@ -294,7 +294,7 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (3.0+4.0j,) src3_data = (5.0+6.0j,) expected_result = (-85+20j,) - op = gr.multiply_vcc(1) + op = blocks.multiply_cc(1) self.help_cc(1, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vcc_five(self): @@ -302,56 +302,56 @@ class test_add_mult_v(gr_unittest.TestCase): src2_data = (11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j) src3_data = (21.0+22.0j, 23.0+24.0j, 25.0+26.0j, 27.0+28.0j, 29.0+30.0j) expected_result = (-1021.0+428.0j, -2647.0+1754.0j, -4945.0+3704.0j, -8011.0+6374.0j, -11941.0+9860.0j) - op = gr.multiply_vcc(5) + op = blocks.multiply_cc(5) self.help_cc(5, (src1_data, src2_data, src3_data), expected_result, op) # multiply_const_vXX def test_multiply_const_vss_one(self): src_data = (2,) - op = gr.multiply_const_vss((3,)) + op = blocks.multiply_const_vss((3,)) exp_data = (6,) self.help_const_ss(src_data, exp_data, op) def test_multiply_const_vss_five(self): src_data = (1, 2, 3, 4, 5) - op = gr.multiply_const_vss((6, 7, 8, 9, 10)) + op = blocks.multiply_const_vss((6, 7, 8, 9, 10)) exp_data = (6, 14, 24, 36, 50) self.help_const_ss(src_data, exp_data, op) def test_multiply_const_vii_one(self): src_data = (2,) - op = gr.multiply_const_vii((3,)) + op = blocks.multiply_const_vii((3,)) exp_data = (6,) self.help_const_ii(src_data, exp_data, op) def test_multiply_const_vii_five(self): src_data = (1, 2, 3, 4, 5) - op = gr.multiply_const_vii((6, 7, 8, 9, 10)) + op = blocks.multiply_const_vii((6, 7, 8, 9, 10)) exp_data = (6, 14, 24, 36, 50) self.help_const_ii(src_data, exp_data, op) def test_multiply_const_vff_one(self): src_data = (2.0,) - op = gr.multiply_const_vff((3.0,)) + op = blocks.multiply_const_vff((3.0,)) exp_data = (6.0,) self.help_const_ff(src_data, exp_data, op) def test_multiply_const_vff_five(self): src_data = (1.0, 2.0, 3.0, 4.0, 5.0) - op = gr.multiply_const_vff((6.0, 7.0, 8.0, 9.0, 10.0)) + op = blocks.multiply_const_vff((6.0, 7.0, 8.0, 9.0, 10.0)) exp_data = (6.0, 14.0, 24.0, 36.0, 50.0) self.help_const_ff(src_data, exp_data, op) def test_multiply_const_vcc_one(self): src_data = (1.0+2.0j,) - op = gr.multiply_const_vcc((2.0+3.0j,)) + op = blocks.multiply_const_vcc((2.0+3.0j,)) exp_data = (-4.0+7.0j,) self.help_const_cc(src_data, exp_data, op) def test_multiply_const_vcc_five(self): src_data = (1.0+2.0j, 3.0+4.0j, 5.0+6.0j, 7.0+8.0j, 9.0+10.0j) - op = gr.multiply_const_vcc((11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j)) + op = blocks.multiply_const_vcc((11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j)) exp_data = (-13.0+34.0j, -17.0+94.0j, -21.0+170.0j, -25.0+262.0j, -29.0+370.0j) self.help_const_cc(src_data, exp_data, op) diff --git a/gr-blocks/python/qa_bin_statistics.py b/gr-blocks/python/qa_bin_statistics.py index c1b3072530..666f7c0d68 100755 --- a/gr-blocks/python/qa_bin_statistics.py +++ b/gr-blocks/python/qa_bin_statistics.py @@ -27,9 +27,8 @@ import struct """ Note: There has been an issue with this block in the past, see Issue -#199. This looks like it might have fixed itself over the years. I am -leaving these tests disabled on our master branch for v3.6 for now, -though, just in case. TWR. +#199. This test is being enabled only on the 'next' branch for version +v3.7 for now. TWR """ class counter(gr.feval_dd): @@ -100,7 +99,7 @@ class test_bin_statistics(gr_unittest.TestCase): def tearDown(self): self.tb = None - def xtest_001(self): + def test_001(self): vlen = 4 tune = counter(1) tune_delay = 0 @@ -132,7 +131,7 @@ class test_bin_statistics(gr_unittest.TestCase): #print "m =", m.center_freq, m.data self.assertEqual(expected_results[vlen*i:vlen*i + vlen], m.data) - def xtest_002(self): + def test_002(self): vlen = 4 tune = counter(1) tune_delay = 1 @@ -162,7 +161,7 @@ class test_bin_statistics(gr_unittest.TestCase): - def xtest_003(self): + def test_003(self): vlen = 4 tune = counter3(foobar3, 1) tune_delay = 1 @@ -194,7 +193,7 @@ class test_bin_statistics(gr_unittest.TestCase): #print "foobar4: new_t =", new_t pass - def xtest_004(self): + def test_004(self): vlen = 4 tune = counter4(self, 1) tune_delay = 1 diff --git a/gr-blocks/python/qa_burst_tagger.py b/gr-blocks/python/qa_burst_tagger.py index 5e249cb8b9..dfe9ec6429 100644 --- a/gr-blocks/python/qa_burst_tagger.py +++ b/gr-blocks/python/qa_burst_tagger.py @@ -51,10 +51,10 @@ class test_burst_tagger(gr_unittest.TestCase): self.assertEqual(6, x[2].offset) self.assertEqual(8, x[3].offset) - self.assertEqual(True, pmt.pmt_to_bool(x[0].value)) - self.assertEqual(False, pmt.pmt_to_bool(x[1].value)) - self.assertEqual(True, pmt.pmt_to_bool(x[2].value)) - self.assertEqual(False, pmt.pmt_to_bool(x[3].value)) + self.assertEqual(True, pmt.to_bool(x[0].value)) + self.assertEqual(False, pmt.to_bool(x[1].value)) + self.assertEqual(True, pmt.to_bool(x[2].value)) + self.assertEqual(False, pmt.to_bool(x[3].value)) if __name__ == '__main__': gr_unittest.run(test_burst_tagger, "test_burst_tagger.xml") diff --git a/gr-blocks/python/qa_file_metadata.py b/gr-blocks/python/qa_file_metadata.py index c7826b1d3e..cf7a075f42 100644 --- a/gr-blocks/python/qa_file_metadata.py +++ b/gr-blocks/python/qa_file_metadata.py @@ -35,6 +35,7 @@ def sig_source_c(samp_rate, freq, amp, N): class test_file_metadata(gr_unittest.TestCase): def setUp(self): + os.environ['GR_CONF_CONTROLPORT_ON'] = 'False' self.tb = gr.top_block() def tearDown(self): @@ -46,11 +47,11 @@ class test_file_metadata(gr_unittest.TestCase): detached = False samp_rate = 200000 - key = pmt.pmt_intern("samp_rate") - val = pmt.pmt_from_double(samp_rate) - extras = pmt.pmt_make_dict() - extras = pmt.pmt_dict_add(extras, key, val) - extras_str = pmt.pmt_serialize_str(extras) + key = pmt.intern("samp_rate") + val = pmt.from_double(samp_rate) + extras = pmt.make_dict() + extras = pmt.dict_add(extras, key, val) + extras_str = pmt.serialize_str(extras) data = sig_source_c(samp_rate, 1000, 1, N) src = gr.vector_source_c(data) @@ -70,7 +71,7 @@ class test_file_metadata(gr_unittest.TestCase): self.assertFalse() try: - header = pmt.pmt_deserialize_str(header_str) + header = pmt.deserialize_str(header_str) except RuntimeError: self.assertFalse() @@ -82,21 +83,21 @@ class test_file_metadata(gr_unittest.TestCase): handle.close() try: - extra = pmt.pmt_deserialize_str(extra_str) + extra = pmt.deserialize_str(extra_str) except RuntimeError: self.assertFalse() extra_info = parse_file_metadata.parse_extra_dict(extra, info, False) self.assertEqual(info['rx_rate'], samp_rate) - self.assertEqual(pmt.pmt_to_double(extra_info['samp_rate']), samp_rate) + self.assertEqual(pmt.to_double(extra_info['samp_rate']), samp_rate) # Test file metadata source src.rewind() fsrc = blocks.file_meta_source(outfile, False) vsnk = gr.vector_sink_c() - tsnk = gr.tag_debug(gr.sizeof_gr_complex, "QA") + tsnk = blocks.tag_debug(gr.sizeof_gr_complex, "QA") ssnk = gr.vector_sink_c() self.tb.disconnect(src, fsnk) self.tb.connect(fsrc, vsnk) @@ -108,10 +109,10 @@ class test_file_metadata(gr_unittest.TestCase): # were generated and received correctly. tags = tsnk.current_tags() for t in tags: - if(pmt.pmt_eq(t.key, pmt.pmt_intern("samp_rate"))): - self.assertEqual(pmt.pmt_to_double(t.value), samp_rate) - elif(pmt.pmt_eq(t.key, pmt.pmt_intern("rx_rate"))): - self.assertEqual(pmt.pmt_to_double(t.value), samp_rate) + if(pmt.eq(t.key, pmt.intern("samp_rate"))): + self.assertEqual(pmt.to_double(t.value), samp_rate) + elif(pmt.eq(t.key, pmt.intern("rx_rate"))): + self.assertEqual(pmt.to_double(t.value), samp_rate) # Test that the data portion was extracted and received correctly. self.assertComplexTuplesAlmostEqual(vsnk.data(), ssnk.data(), 5) @@ -125,11 +126,11 @@ class test_file_metadata(gr_unittest.TestCase): detached = True samp_rate = 200000 - key = pmt.pmt_intern("samp_rate") - val = pmt.pmt_from_double(samp_rate) - extras = pmt.pmt_make_dict() - extras = pmt.pmt_dict_add(extras, key, val) - extras_str = pmt.pmt_serialize_str(extras) + key = pmt.intern("samp_rate") + val = pmt.from_double(samp_rate) + extras = pmt.make_dict() + extras = pmt.dict_add(extras, key, val) + extras_str = pmt.serialize_str(extras) data = sig_source_c(samp_rate, 1000, 1, N) src = gr.vector_source_c(data) @@ -150,7 +151,7 @@ class test_file_metadata(gr_unittest.TestCase): self.assertFalse() try: - header = pmt.pmt_deserialize_str(header_str) + header = pmt.deserialize_str(header_str) except RuntimeError: self.assertFalse() @@ -161,21 +162,21 @@ class test_file_metadata(gr_unittest.TestCase): handle.close() try: - extra = pmt.pmt_deserialize_str(extra_str) + extra = pmt.deserialize_str(extra_str) except RuntimeError: self.assertFalse() extra_info = parse_file_metadata.parse_extra_dict(extra, info, False) self.assertEqual(info['rx_rate'], samp_rate) - self.assertEqual(pmt.pmt_to_double(extra_info['samp_rate']), samp_rate) + self.assertEqual(pmt.to_double(extra_info['samp_rate']), samp_rate) # Test file metadata source src.rewind() fsrc = blocks.file_meta_source(outfile, False, detached, outfile_hdr) vsnk = gr.vector_sink_c() - tsnk = gr.tag_debug(gr.sizeof_gr_complex, "QA") + tsnk = blocks.tag_debug(gr.sizeof_gr_complex, "QA") ssnk = gr.vector_sink_c() self.tb.disconnect(src, fsnk) self.tb.connect(fsrc, vsnk) @@ -187,10 +188,10 @@ class test_file_metadata(gr_unittest.TestCase): # were generated and received correctly. tags = tsnk.current_tags() for t in tags: - if(pmt.pmt_eq(t.key, pmt.pmt_intern("samp_rate"))): - self.assertEqual(pmt.pmt_to_double(t.value), samp_rate) - elif(pmt.pmt_eq(t.key, pmt.pmt_intern("rx_rate"))): - self.assertEqual(pmt.pmt_to_double(t.value), samp_rate) + if(pmt.eq(t.key, pmt.intern("samp_rate"))): + self.assertEqual(pmt.to_double(t.value), samp_rate) + elif(pmt.eq(t.key, pmt.intern("rx_rate"))): + self.assertEqual(pmt.to_double(t.value), samp_rate) # Test that the data portion was extracted and received correctly. self.assertComplexTuplesAlmostEqual(vsnk.data(), ssnk.data(), 5) diff --git a/gr-blocks/python/qa_message.py b/gr-blocks/python/qa_message.py index 551fdd6259..a556f65cee 100755 --- a/gr-blocks/python/qa_message.py +++ b/gr-blocks/python/qa_message.py @@ -130,7 +130,7 @@ class test_message(gr_unittest.TestCase): self.assertEquals(tuple(map(ord, '0123456789')), dst.data()) def test_debug_401(self): - msg = pmt.pmt_intern("TESTING") + msg = pmt.intern("TESTING") src = blocks.message_strobe(msg, 500) snk = blocks.message_debug() @@ -142,7 +142,7 @@ class test_message(gr_unittest.TestCase): tb.wait() rec_msg = snk.get_message(0) - self.assertTrue(pmt.pmt_eqv(rec_msg, msg)) + self.assertTrue(pmt.eqv(rec_msg, msg)) if __name__ == '__main__': diff --git a/gr-blocks/python/qa_pdu.py b/gr-blocks/python/qa_pdu.py index dc50b7c330..d0c0093810 100755 --- a/gr-blocks/python/qa_pdu.py +++ b/gr-blocks/python/qa_pdu.py @@ -40,16 +40,16 @@ class test_pdu(gr_unittest.TestCase): src = blocks.pdu_to_tagged_stream(blocks.byte_t) snk3 = blocks.tagged_stream_to_pdu(blocks.byte_t) snk2 = gr.vector_sink_b() - snk = gr.tag_debug(1, "test") + snk = blocks.tag_debug(1, "test") snk.set_display(False) - dbg = gr.message_debug() + dbg = blocks.message_debug() # Test that the right number of ports exist. pi = snk3.message_ports_in() po = snk3.message_ports_out() - self.assertEqual(pmt.pmt_length(pi), 0) - self.assertEqual(pmt.pmt_length(po), 1) + self.assertEqual(pmt.length(pi), 0) + self.assertEqual(pmt.length(po), 1) time.sleep(0.1) self.tb.connect(src, snk) @@ -59,8 +59,8 @@ class test_pdu(gr_unittest.TestCase): self.tb.start() # make our reference and message pmts - port = pmt.pmt_intern("pdus") - msg = pmt.pmt_cons( pmt.PMT_NIL, pmt.pmt_make_u8vector(16, 0xFF)) + port = pmt.intern("pdus") + msg = pmt.cons( pmt.PMT_NIL, pmt.make_u8vector(16, 0xFF)) # post the message src.to_basic_block()._post(port, msg) # eww, what's that smell? @@ -76,13 +76,13 @@ class test_pdu(gr_unittest.TestCase): # Get the vector of data from the message sink # Convert the message PMT as a pair into its vector result_msg = dbg.get_message(0) - msg_vec = pmt.pmt_cdr(result_msg) - #pmt.pmt_print(msg_vec) + msg_vec = pmt.cdr(result_msg) + #pmt.print(msg_vec) # Convert the PMT vector into a Python list msg_data = [] for i in xrange(16): - msg_data.append(pmt.pmt_u8vector_ref(msg_vec, i)) + msg_data.append(pmt.u8vector_ref(msg_vec, i)) actual_data = 16*[0xFF,] self.assertEqual(actual_data, list(result_data)) diff --git a/gr-blocks/python/qa_pipe_fittings.py b/gr-blocks/python/qa_pipe_fittings.py index 321660d5ee..9894a5c211 100755 --- a/gr-blocks/python/qa_pipe_fittings.py +++ b/gr-blocks/python/qa_pipe_fittings.py @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks def calc_expected_result(src_data, n): assert (len(src_data) % n) == 0 @@ -51,7 +51,7 @@ class test_pipe_fittings(gr_unittest.TestCase): expected_results = calc_expected_result(src_data, n) #print "expected results: ", expected_results src = gr.vector_source_i(src_data) - op = gr.stream_to_streams(gr.sizeof_int, n) + op = blocks.stream_to_streams(gr.sizeof_int, n) self.tb.connect(src, op) dsts = [] @@ -75,8 +75,8 @@ class test_pipe_fittings(gr_unittest.TestCase): expected_results = src_data src = gr.vector_source_i(src_data) - op1 = gr.stream_to_streams(gr.sizeof_int, n) - op2 = gr.streams_to_stream(gr.sizeof_int, n) + op1 = blocks.stream_to_streams(gr.sizeof_int, n) + op2 = blocks.streams_to_stream(gr.sizeof_int, n) dst = gr.vector_sink_i() self.tb.connect(src, op1) @@ -97,9 +97,9 @@ class test_pipe_fittings(gr_unittest.TestCase): expected_results = src_data src = gr.vector_source_i(src_data) - op1 = gr.stream_to_streams(gr.sizeof_int, n) - op2 = gr.streams_to_vector(gr.sizeof_int, n) - op3 = gr.vector_to_stream(gr.sizeof_int, n) + op1 = blocks.stream_to_streams(gr.sizeof_int, n) + op2 = blocks.streams_to_vector(gr.sizeof_int, n) + op3 = blocks.vector_to_stream(gr.sizeof_int, n) dst = gr.vector_sink_i() self.tb.connect(src, op1) @@ -120,9 +120,9 @@ class test_pipe_fittings(gr_unittest.TestCase): expected_results = src_data src = gr.vector_source_i(src_data) - op1 = gr.stream_to_vector(gr.sizeof_int, n) - op2 = gr.vector_to_streams(gr.sizeof_int, n) - op3 = gr.streams_to_stream(gr.sizeof_int, n) + op1 = blocks.stream_to_vector(gr.sizeof_int, n) + op2 = blocks.vector_to_streams(gr.sizeof_int, n) + op3 = blocks.streams_to_stream(gr.sizeof_int, n) dst = gr.vector_sink_i() self.tb.connect(src, op1, op2) diff --git a/gr-blocks/python/qa_probe_signal.py b/gr-blocks/python/qa_probe_signal.py index a420df71e5..6d25a25087 100644 --- a/gr-blocks/python/qa_probe_signal.py +++ b/gr-blocks/python/qa_probe_signal.py @@ -20,7 +20,6 @@ # Boston, MA 02110-1301, USA. # -import time from gnuradio import gr, gr_unittest import blocks_swig as blocks diff --git a/gr-blocks/python/qa_stream_mux.py b/gr-blocks/python/qa_stream_mux.py index f21a9bbbc9..657bd3d63f 100755 --- a/gr-blocks/python/qa_stream_mux.py +++ b/gr-blocks/python/qa_stream_mux.py @@ -22,10 +22,12 @@ from gnuradio import gr, gr_unittest import blocks_swig +import os class test_stream_mux (gr_unittest.TestCase): def setUp (self): + os.environ['GR_CONF_CONTROLPORT_ON'] = 'False' self.tb = gr.top_block () def tearDown (self): diff --git a/gr-blocks/python/qa_stretch.py b/gr-blocks/python/qa_stretch.py index 013d878a8f..078b404dbf 100755 --- a/gr-blocks/python/qa_stretch.py +++ b/gr-blocks/python/qa_stretch.py @@ -43,9 +43,9 @@ class test_stretch(gr_unittest.TestCase): src0 = gr.vector_source_f(data0, False) src1 = gr.vector_source_f(data1, False) - inter = gr.streams_to_vector(gr.sizeof_float, 2) + inter = blocks.streams_to_vector(gr.sizeof_float, 2) op = blocks.stretch_ff(0.1, 2) - deinter = gr.vector_to_streams(gr.sizeof_float, 2) + deinter = blocks.vector_to_streams(gr.sizeof_float, 2) dst0 = gr.vector_sink_f() dst1 = gr.vector_sink_f() diff --git a/gr-blocks/python/stream_to_vector_decimator.py b/gr-blocks/python/stream_to_vector_decimator.py new file mode 100644 index 0000000000..c32ae6fce2 --- /dev/null +++ b/gr-blocks/python/stream_to_vector_decimator.py @@ -0,0 +1,106 @@ +# +# 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. +# + +from gnuradio import gr + +try: + from gnuradio import blocks +except ImportError: + import blocks_swig as blocks + +class stream_to_vector_decimator(gr.hier_block2): + """ + Convert the stream to a vector, decimate the vector stream to achieve the vector rate. + """ + + def __init__(self, item_size, sample_rate, vec_rate, vec_len): + """ + Create the block chain. + + Args: + item_size: the number of bytes per sample + sample_rate: the rate of incoming samples + vec_rate: the rate of outgoing vectors (same units as sample_rate) + vec_len: the length of the outgoing vectors in items + """ + self._vec_rate = vec_rate + self._vec_len = vec_len + self._sample_rate = sample_rate + + gr.hier_block2.__init__(self, "stream_to_vector_decimator", + gr.io_signature(1, 1, item_size), # Input signature + gr.io_signature(1, 1, item_size*vec_len)) # Output signature + + s2v = blocks.stream_to_vector(item_size, vec_len) + self.one_in_n = blocks.keep_one_in_n(item_size*vec_len, 1) + self._update_decimator() + self.connect(self, s2v, self.one_in_n, self) + + def set_sample_rate(self, sample_rate): + """ + Set the new sampling rate and update the decimator. + + Args: + sample_rate: the new rate + """ + self._sample_rate = sample_rate + self._update_decimator() + + def set_vec_rate(self, vec_rate): + """ + Set the new vector rate and update the decimator. + + Args: + vec_rate: the new rate + """ + self._vec_rate = vec_rate + self._update_decimator() + + def set_decimation(self, decim): + """ + Set the decimation parameter directly. + + Args: + decim: the new decimation + """ + self._decim = max(1, int(round(decim))) + self.one_in_n.set_n(self._decim) + + def _update_decimator(self): + self.set_decimation(self._sample_rate/self._vec_len/self._vec_rate) + + def decimation(self): + """ + Returns the actual decimation. + """ + return self._decim + + def sample_rate(self): + """ + Returns configured sample rate. + """ + return self._sample_rate + + def frame_rate(self): + """ + Returns actual frame rate + """ + return self._sample_rate/self._vec_len/self._decim diff --git a/gr-blocks/swig/blocks_swig.i b/gr-blocks/swig/blocks_swig.i index 1c0f49dfeb..52fd2b6422 100644 --- a/gr-blocks/swig/blocks_swig.i +++ b/gr-blocks/swig/blocks_swig.i @@ -143,6 +143,7 @@ #include "blocks/or_bb.h" #include "blocks/or_ss.h" #include "blocks/or_ii.h" +#include "blocks/random_pdu.h" #include "blocks/regenerate_bb.h" #include "blocks/repeat.h" #include "blocks/rms_cf.h" @@ -295,6 +296,7 @@ %include "blocks/peak_detector_ib.h" %include "blocks/peak_detector_sb.h" %include "blocks/peak_detector2_fb.h" +%include "blocks/random_pdu.h" %include "blocks/regenerate_bb.h" %include "blocks/repeat.h" %include "blocks/rms_cf.h" @@ -434,6 +436,7 @@ GR_SWIG_BLOCK_MAGIC2(blocks, pdu_to_tagged_stream); GR_SWIG_BLOCK_MAGIC2(blocks, or_bb); GR_SWIG_BLOCK_MAGIC2(blocks, or_ss); GR_SWIG_BLOCK_MAGIC2(blocks, or_ii); +GR_SWIG_BLOCK_MAGIC2(blocks, random_pdu); GR_SWIG_BLOCK_MAGIC2(blocks, probe_signal_b); GR_SWIG_BLOCK_MAGIC2(blocks, probe_signal_s); GR_SWIG_BLOCK_MAGIC2(blocks, probe_signal_i); |