summaryrefslogtreecommitdiff
path: root/gr-blocks/lib
diff options
context:
space:
mode:
Diffstat (limited to 'gr-blocks/lib')
-rw-r--r--gr-blocks/lib/file_meta_sink_impl.cc90
-rw-r--r--gr-blocks/lib/file_meta_source_impl.cc56
-rw-r--r--gr-blocks/lib/pdu.cc18
-rw-r--r--gr-blocks/lib/pdu_to_tagged_stream_impl.cc26
-rw-r--r--gr-blocks/lib/rms_cf_impl.cc14
-rw-r--r--gr-blocks/lib/rms_cf_impl.h3
-rw-r--r--gr-blocks/lib/rms_ff_impl.cc12
-rw-r--r--gr-blocks/lib/rms_ff_impl.h2
-rw-r--r--gr-blocks/lib/socket_pdu_impl.cc22
-rw-r--r--gr-blocks/lib/stream_pdu_base.cc10
-rw-r--r--gr-blocks/lib/tagged_stream_to_pdu_impl.cc14
-rw-r--r--gr-blocks/lib/tcp_connection.cc8
12 files changed, 139 insertions, 136 deletions
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/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/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..e0ea868c3b 100644
--- a/gr-blocks/lib/rms_ff_impl.h
+++ b/gr-blocks/lib/rms_ff_impl.h
@@ -36,7 +36,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..20338f9968 100644
--- a/gr-blocks/lib/socket_pdu_impl.cc
+++ b/gr-blocks/lib/socket_pdu_impl.cc
@@ -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 cc56b4ee65..ed3dfcde10 100644
--- a/gr-blocks/lib/stream_pdu_base.cc
+++ b/gr-blocks/lib/stream_pdu_base.cc
@@ -83,8 +83,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);
}
@@ -110,12 +110,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/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..f7af371250 100644
--- a/gr-blocks/lib/tcp_connection.cc
+++ b/gr-blocks/lib/tcp_connection.cc
@@ -46,10 +46,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 +70,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);
generated by cgit v1.2.3 (git 2.39.1) at 2025-03-28 15:20:40 +0000