#endif

#include "additive_scrambler_bb_impl.h"

namespace gr {

namespace digital {

int seed,

int len,

int count)

d_lfsr(mask, seed, len),

d_count(count),

d_bits(0), d_len(len), d_seed(seed)

#endif

#include "binary_slicer_fb_impl.h"

namespace gr {

namespace digital {

}

binary_slicer_fb_impl::binary_slicer_fb_impl()

{

}

unsigned char *out = (unsigned char *)output_items[0];

for(int i = 0; i < noutput_items; i++) {

}

return noutput_items;

#endif

#include "@NAME@.h"

#include <assert.h>

namespace gr {

}

@IMPL_NAME@::@IMPL_NAME@(const std::vector<@O_TYPE@> &symbol_table, const int D)

D),

d_D(D), d_symbol_table(symbol_table)

{

#endif

#include "clock_recovery_mm_cc_impl.h"

#include <stdexcept>

#include <iostream>

clock_recovery_mm_cc_impl::clock_recovery_mm_cc_impl(float omega, float gain_omega,

float mu, float gain_mu,

float omega_relative_limit)

d_mu(mu), d_omega(omega), d_gain_omega(gain_omega),

d_omega_relative_limit(omega_relative_limit),

d_gain_mu(gain_mu), d_last_sample(0), d_interp(new filter::mmse_fir_interpolator_cc()),

d_p_2T(0), d_p_1T(0), d_p_0T(0), d_c_2T(0), d_c_1T(0), d_c_0T(0)

{

if(omega <= 0.0)

out[oo++] = d_p_0T;

// limit mm_val

d_omega = d_omega + d_gain_omega * mm_val;

d_mu = d_mu + d_omega + d_gain_mu * mm_val;

ii += (int)floor(d_mu);

out[oo++] = d_p_0T;

// limit mm_val

d_omega = d_omega + d_gain_omega * mm_val;

d_mu = d_mu + d_omega + d_gain_mu * mm_val;

ii += (int)floor(d_mu);

#endif

#include "clock_recovery_mm_ff_impl.h"

#include <stdexcept>

namespace gr {

clock_recovery_mm_ff_impl::clock_recovery_mm_ff_impl(float omega, float gain_omega,

float mu, float gain_mu,

float omega_relative_limit)

d_mu(mu), d_gain_mu(gain_mu), d_gain_omega(gain_omega),

d_omega_relative_limit(omega_relative_limit),

d_last_sample(0), d_interp(new filter::mmse_fir_interpolator_ff())

d_last_sample = out[oo];

d_omega = d_omega + d_gain_omega * mm_val;

d_mu = d_mu + d_omega + d_gain_mu * mm_val;

ii += (int)floor(d_mu);

#endif

#include "cma_equalizer_cc_impl.h"

namespace gr {

namespace digital {

cma_equalizer_cc_impl::cma_equalizer_cc_impl(int num_taps, float modulus,

float mu, int sps)

sps),

fir_filter_ccc(sps, std::vector<gr_complex>(num_taps, gr_complex(0,0))),

d_new_taps(num_taps, gr_complex(0,0)),

cma_equalizer_cc_impl::error(const gr_complex &out)

{

gr_complex error = out*(norm(out) - d_modulus);

return gr_complex(re, im);

}

#include <digital/cma_equalizer_cc.h>

#include <filter/fir_filter.h>

#include <stdexcept>

namespace gr {

#include "config.h"

#endif

#include <digital/constellation.h>

#include <math.h>

#include <iostream>

#include <stdlib.h>

#endif

#include "constellation_decoder_cb_impl.h"

namespace gr {

namespace digital {

constellation_decoder_cb_impl::

constellation_decoder_cb_impl(constellation_sptr constellation)

d_constellation(constellation),

d_dim(constellation->dimensionality())

{

#endif

#include "constellation_receiver_cb_impl.h"

#include <stdexcept>

namespace gr {

static std::vector<int> iosig(ios, ios+sizeof(ios)/sizeof(int));

constellation_receiver_cb_impl::constellation_receiver_cb_impl(constellation_sptr constellation,

float loop_bw, float fmin, float fmax)

blocks::control_loop(loop_bw, fmax, fmin),

d_constellation(constellation),

d_current_const_point(0)

#define INCLUDED_DIGITAL_CONSTELLATION_RECEIVER_CB_IMPL_H

#include <digital/constellation_receiver_cb.h>

namespace gr {

namespace digital {

#endif

#include "correlate_access_code_bb_impl.h"

#include <stdexcept>

#include <cstdio>

correlate_access_code_bb_impl::correlate_access_code_bb_impl(

const std::string &access_code, int threshold)

d_data_reg(0), d_flag_reg(0), d_flag_bit(0), d_mask(0),

d_threshold(threshold)

{

#endif

#include "correlate_access_code_tag_bb_impl.h"

#include <stdexcept>

#include <cstdio>

#include <iostream>

correlate_access_code_tag_bb_impl::correlate_access_code_tag_bb_impl(

const std::string &access_code, int threshold, const std::string &tag_name)

d_data_reg(0), d_mask(0),

d_threshold(threshold), d_len(0)

{

#endif

#include "costas_loop_cc_impl.h"

namespace gr {

namespace digital {

}

costas_loop_cc_impl::costas_loop_cc_impl(float loop_bw, int order)

blocks::control_loop(loop_bw, 1.0, -1.0),

d_order(order), d_phase_detector(NULL)

{

optr[i] = iptr[i] * nco_out;

error = (*this.*d_phase_detector)(optr[i]);

advance_loop(error);

phase_wrap();

optr[i] = iptr[i] * nco_out;

error = (*this.*d_phase_detector)(optr[i]);

advance_loop(error);

phase_wrap();

#endif

#include "cpmmod_bc_impl.h"

namespace gr {

namespace digital {

analog::cpm::cpm_type type, float h,

int samples_per_sym,

int L, double beta)

d_type(type), d_index(h), d_sps(samples_per_sym), d_length(L), d_beta(beta),

d_taps(analog::cpm::phase_response(type, samples_per_sym, L, beta)),

d_char_to_float(blocks::char_to_float::make()),

#define INCLUDED_DIGITAL_CPMMOD_BC_IMPL_H

#include <digital/cpmmod_bc.h>

#include <analog/frequency_modulator_fc.h>

#include <filter/interp_fir_filter_fff.h>

#include "config.h"

#endif

#include "crc32_bb_impl.h"

#include <digital/crc32.h>

}

crc32_bb_impl::crc32_bb_impl(bool check, const std::string& lengthtagname)

lengthtagname),

d_check(check)

{

memcpy((void *) (out + packet_length), &crc, 4); // FIXME big-endian/little-endian, this might be wrong

}

get_tags_in_range(tags, 0, nitems_read(0), nitems_read(0)+packet_length);

for (size_t i = 0; i < tags.size(); i++) {

tags[i].offset -= nitems_read(0);

#endif

#include "descrambler_bb_impl.h"

namespace gr {

namespace digital {

}

descrambler_bb_impl::descrambler_bb_impl(int mask, int seed, int len)

d_lfsr(mask, seed, len)

{

}

#endif

#include "diff_decoder_bb_impl.h"

namespace gr {

namespace digital {

}

diff_decoder_bb_impl::diff_decoder_bb_impl(unsigned int modulus)

d_modulus(modulus)

{

set_history(2); // need to look at two inputs

#define INCLUDED_GR_DIFF_DECODER_BB_IMPL_H

#include <digital/diff_decoder_bb.h>

namespace gr {

namespace digital {

#endif

#include "diff_encoder_bb_impl.h"

namespace gr {

namespace digital {

}

diff_encoder_bb_impl::diff_encoder_bb_impl(unsigned int modulus)

d_last_out(0), d_modulus(modulus)

{

}

#endif

#include "diff_phasor_cc_impl.h"

namespace gr {

namespace digital {

}

diff_phasor_cc_impl::diff_phasor_cc_impl()

{

set_history(2);

}

#define INCLUDED_GR_DIFF_PHASOR_CC_IMPL_H

#include <digital/diff_phasor_cc.h>

namespace gr {

namespace digital {

#endif

#include "fll_band_edge_cc_impl.h"

#include <cstdio>

namespace gr {

static std::vector<int> iosig(ios, ios+sizeof(ios)/sizeof(int));

fll_band_edge_cc_impl::fll_band_edge_cc_impl(float samps_per_sym, float rolloff,

int filter_size, float bandwidth)

blocks::control_loop(bandwidth, M_TWOPI*(2.0/samps_per_sym),

-M_TWOPI*(2.0/samps_per_sym)),

d_updated(false)

#define INCLUDED_DIGITAL_FLL_BAND_EDGE_CC_IMPL_H

#include <digital/fll_band_edge_cc.h>

#include <filter/fir_filter.h>

namespace gr {

#endif

#include "framer_sink_1_impl.h"

#include <cstdio>

#include <string>

}

framer_sink_1::sptr

{

return gnuradio::get_initial_sptr

(new framer_sink_1_impl(target_queue));

}

d_target_queue(target_queue)

{

enter_search();

if(d_packetlen == 0) { // check for zero-length payload

// build a zero-length message

// NOTE: passing header field as arg1 is not scalable

d_target_queue->insert_tail(msg); // send it

msg.reset(); // free it up

if(d_packetlen_cnt == d_packetlen) { // packet is filled

// build a message

// NOTE: passing header field as arg1 is not scalable

memcpy(msg->msg(), d_packet, d_packetlen_cnt);

d_target_queue->insert_tail(msg); // send it

static const int MAX_PKT_LEN = 4096;

static const int HEADERBITLEN = 32;

protected:

void enter_search();

}

public:

~framer_sink_1_impl();

int work(int noutput_items,

#endif

#include "glfsr_source_b_impl.h"

#include <stdexcept>

namespace gr {

glfsr_source_b_impl::glfsr_source_b_impl(int degree, bool repeat,

int mask, int seed)

d_repeat(repeat), d_index(0)

{

if(degree < 1 || degree > 32)

#endif

#include "glfsr_source_f_impl.h"

#include <stdexcept>

namespace gr {

glfsr_source_f_impl::glfsr_source_f_impl(int degree, bool repeat,

int mask, int seed)

d_repeat(repeat), d_index(0)

{

if(degree < 1 || degree > 32)

#endif

#include <climits>

#include "header_payload_demux_impl.h"

namespace gr {

const std::string &trigger_tag_key,

bool output_symbols,

size_t itemsize

d_header_len(header_len),

d_items_per_symbol(items_per_symbol),

d_gi(guard_interval),

}

}

if (d_uses_trigger_tag) {

get_tags_in_range(tags, 0, nitems_read(0), nitems_read(0)+noutput_items);

uint64_t min_offset = ULLONG_MAX;

int tag_index = -1;

void

header_payload_demux_impl::copy_symbol(const unsigned char *&in, unsigned char *&out, int port, int &nread, int &nproduced)

{

memcpy((void *) out,

(void *) (in + d_gi * d_itemsize),

d_itemsize * d_items_per_symbol

#endif

#include "kurtotic_equalizer_cc_impl.h"

#include <volk/volk.h>

namespace gr {

}

kurtotic_equalizer_cc_impl::kurtotic_equalizer_cc_impl(int num_taps, float mu)

1),

filter::kernel::fir_filter_ccc(1, std::vector<gr_complex>(num_taps, gr_complex(0,0)))

{

#include <digital/kurtotic_equalizer_cc.h>

#include <filter/fir_filter.h>

#include <stdexcept>

namespace gr {

(sign(d_u) * (nrm*cnj - 2.0f*d_p*cnj - conj(d_q)*out) -

abs(d_u)*cnj);

return gr_complex(re, im);

}

#endif

#include "lms_dd_equalizer_cc_impl.h"

#include <volk/volk.h>

namespace gr {

lms_dd_equalizer_cc_impl::lms_dd_equalizer_cc_impl(int num_taps, float mu,

int sps,

constellation_sptr cnst)

sps),

fir_filter_ccc(sps, std::vector<gr_complex>(num_taps, gr_complex(0,0))),

d_new_taps(num_taps, gr_complex(0,0)),

#endif

#include "map_bb_impl.h"

namespace gr {

namespace digital {

}

map_bb_impl::map_bb_impl(const std::vector<int> &map)

{

set_map(map);

}

#define INCLUDED_GR_MAP_BB_IMPL_H

#include <digital/map_bb.h>

namespace gr {

namespace digital {

#endif

#include "mpsk_receiver_cc_impl.h"

#include <stdexcept>

namespace gr {

float mu, float gain_mu,

float omega, float gain_omega,

float omega_rel)

blocks::control_loop(loop_bw, fmax, fmin),

d_M(M), d_theta(theta),

d_current_const_point(0),

float mpsk_receiver_cc_impl::phase_error_detector_generic(gr_complex sample) const

{

return -arg(sample*conj(d_constellation[d_current_const_point]));

}

unsigned int

mpsk_receiver_cc_impl::decision_bpsk(gr_complex sample) const

{

//return gr_binary_slicer(sample.real()) ^ 1;

}

{

unsigned int index;

return index;

}

y = (d_p_0T - d_p_2T) * conj(d_c_1T);

u = y - x;

mm_error = u.real(); // the error signal is in the real part

d_omega = d_omega + d_gain_omega * mm_error; // update omega based on loop error

d_mu += d_omega + d_gain_mu * mm_error; // update mu based on loop error

#define INCLUDED_DIGITAL_MPSK_RECEIVER_CC_IMPL_H

#include <digital/mpsk_receiver_cc.h>

#include <fstream>

#include <filter/mmse_fir_interpolator_cc.h>

#endif

#include "mpsk_snr_est_cc_impl.h"

#include <cstdio>

namespace gr {

mpsk_snr_est_cc_impl::mpsk_snr_est_cc_impl(snr_est_type_t type,

int tag_nsamples,

double alpha)

{

d_snr_est = NULL;

#include <digital/api.h>

#include <digital/mpsk_snr_est_cc.h>

namespace gr {

namespace digital {

#include "config.h"

#endif

#include "ofdm_carrier_allocator_cvc_impl.h"

namespace gr {

const std::vector<std::vector<gr_complex> > &sync_words,

const std::string &len_tag_key,

const bool output_is_shifted

d_fft_len(fft_len),

d_occupied_carriers(occupied_carriers),

d_pilot_carriers(pilot_carriers),

{

const gr_complex *in = (const gr_complex *) input_items[0];

gr_complex *out = (gr_complex *) output_items[0];

memset((void *) out, 0x00, sizeof(gr_complex) * d_fft_len * noutput_items);

// Copy Sync word

#include "config.h"

#endif

#include "ofdm_chanest_vcvc_impl.h"

namespace gr {

}

ofdm_chanest_vcvc_impl::ofdm_chanest_vcvc_impl(const std::vector<gr_complex> &sync_symbol1, const std::vector<gr_complex> &sync_symbol2, int n_data_symbols, int eq_noise_red_len, int max_carr_offset, bool force_one_sync_symbol)

d_fft_len(sync_symbol1.size()),

d_n_data_syms(n_data_symbols),

d_n_sync_syms(1),

in += framesize * d_fft_len;

out += d_n_data_syms * d_fft_len;

this->get_tags_in_range(tags, 0,

this->nitems_read(0)+i*framesize,

this->nitems_read(0)+(i+1)*framesize);

#include "config.h"

#endif

#include "ofdm_cyclic_prefixer_impl.h"

namespace gr {

ofdm_cyclic_prefixer_impl::ofdm_cyclic_prefixer_impl(size_t input_size, size_t output_size, int rolloff_len, const std::string &len_tag_key)

len_tag_key),

d_fft_len(input_size),

d_output_size(output_size),

}

d_delay_line.assign(d_delay_line.size(), 0);

}

get_tags_in_range(

tags, 0,

nitems_read(0), nitems_read(0)+symbols_to_read

ofdm_equalizer_simpledfe::equalize(gr_complex *frame,

int n_sym,

const std::vector<gr_complex> &initial_taps,

{

if (!initial_taps.empty()) {

d_channel_state = initial_taps;

ofdm_equalizer_static::equalize(gr_complex *frame,

int n_sym,

const std::vector<gr_complex> &initial_taps,

{

d_channel_state = initial_taps;

#endif

#include "ofdm_frame_acquisition_impl.h"

#include <cstdio>

namespace gr {

unsigned int cplen,

const std::vector<gr_complex> &known_symbol,

unsigned int max_fft_shift_len)

d_occupied_carriers(occupied_carriers),

d_fft_length(fft_length),

d_cplen(cplen),

#include "config.h"

#endif

#include "ofdm_frame_equalizer_vcvc_impl.h"

namespace gr {

const std::string &len_tag_key,

bool propagate_channel_state,

int fixed_frame_len

len_tag_key),

d_fft_len(equalizer->fft_len()),

d_eq(equalizer),

frame_len = ninput_items[0];

}

get_tags_in_range(tags, 0, nitems_read(0), nitems_read(0)+1);

for (unsigned i = 0; i < tags.size(); i++) {

if (pmt::symbol_to_string(tags[i].key) == "ofdm_sync_chan_taps") {

protected:

// These aren't really necessary, so let's override them with nuthin'

void update_length_tags(int n_produced, int n_ports) {};

public:

#endif

#include "ofdm_frame_sink_impl.h"

#include <cmath>

#include <cstdio>

#include <stdexcept>

ofdm_frame_sink::sptr

ofdm_frame_sink::make(const std::vector<gr_complex> &sym_position,

const std::vector<char> &sym_value_out,

int occupied_carriers,

float phase_gain, float freq_gain)

{

ofdm_frame_sink_impl::ofdm_frame_sink_impl(const std::vector<gr_complex> &sym_position,

const std::vector<char> &sym_value_out,

int occupied_carriers,

float phase_gain, float freq_gain)

d_target_queue(target_queue), d_occupied_carriers(occupied_carriers),

d_byte_offset(0), d_partial_byte(0),

d_resid(0), d_nresid(0),d_phase(0),d_freq(0),

}

if(d_packetlen_cnt == d_packetlen) {

memcpy(msg->msg(), d_packet, d_packetlen_cnt);

d_target_queue->insert_tail(msg); // send it

msg.reset(); // free it up

if (d_packetlen_cnt == d_packetlen){ // packet is filled

// build a message

// NOTE: passing header field as arg1 is not scalable

memcpy(msg->msg(), d_packet, d_packetlen_cnt);

d_target_queue->insert_tail(msg); // send it

static const int MAX_PKT_LEN = 4096;

static const int HEADERBYTELEN = 4;

state_t d_state;

unsigned int d_header; // header bits

int d_headerbytelen_cnt; // how many so far

public:

ofdm_frame_sink_impl(const std::vector<gr_complex> &sym_position,

const std::vector<char> &sym_value_out,

int occupied_tones,

float phase_gain=0.25, float freq_gain=0.25*0.25/4);

~ofdm_frame_sink_impl();

#endif

#include "ofdm_insert_preamble_impl.h"

#include <stdexcept>

#include <iostream>

#include <string>

ofdm_insert_preamble_impl::ofdm_insert_preamble_impl(int fft_length,

const std::vector<std::vector<gr_complex> > &preamble)

sizeof(gr_complex)*fft_length,

sizeof(char)),

sizeof(gr_complex)*fft_length,

sizeof(char))),

d_fft_length(fft_length),

#endif

#include "ofdm_mapper_bcv_impl.h"

#include <stdexcept>

#include <string>

unsigned int msgq_limit,

unsigned int occupied_carriers,

unsigned int fft_length)

d_constellation(constellation),

d_occupied_carriers(occupied_carriers),

d_fft_length(fft_length),

d_bit_offset(0),

#define INCLUDED_DIGITAL_OFDM_MAPPER_BCV_IMPL_H

#include <digital/ofdm_mapper_bcv.h>

#include <vector>

namespace gr {

{

private:

std::vector<gr_complex> d_constellation;

unsigned int d_occupied_carriers;

unsigned int d_fft_length;

unsigned int fft_length);

~ofdm_mapper_bcv_impl(void);

int work(int noutput_items,

gr_vector_const_void_star &input_items,

#endif

#include "ofdm_sampler_impl.h"

#include <cstdio>

namespace gr {

ofdm_sampler_impl::ofdm_sampler_impl(unsigned int fft_length,

unsigned int symbol_length,

unsigned int timeout)

d_state(STATE_NO_SIG), d_timeout_max(timeout),

d_fft_length(fft_length), d_symbol_length(symbol_length)

{

#define INCLUDED_DIGITAL_OFDM_SAMPLER_IMPL_H

#include <digital/ofdm_sampler.h>

namespace gr {

namespace digital {

#include "config.h"

#endif

#include "ofdm_serializer_vcc_impl.h"

namespace gr {

const std::string &packet_len_tag_key,

int symbols_skipped,

bool input_is_shifted)

len_tag_key),

d_fft_len(fft_len),

d_occupied_carriers(occupied_carriers),

long packet_length = 0; // Output frame

int carr_offset = 0;

// Packet mode

if (!d_length_tag_key_str.empty()) {

get_tags_in_range(tags, 0, nitems_read(0), nitems_read(0)+1);

#include "config.h"

#endif

#include "ofdm_sync_sc_cfb_impl.h"

#include <filter/fir_filter_ccf.h>

#include <filter/fir_filter_fff.h>

}

ofdm_sync_sc_cfb_impl::ofdm_sync_sc_cfb_impl(int fft_len, int cp_len)

#ifndef SYNC_ADD_DEBUG_OUTPUT

#else

#endif

{

std::vector<float> ma_taps(fft_len/2, 1.0);

bool packet_header_default::header_formatter(

long packet_len,

unsigned char *out,

)

{

packet_len &= 0x0FFF;

bool packet_header_default::header_parser(

const unsigned char *in,

{

unsigned header_len = 0;

unsigned header_num = 0;

int k = 0; // Position in "in"

for (int i = 0; i < 12 && k < d_header_len; i += d_bits_per_byte, k++) {

bool packet_header_ofdm::header_parser(

const unsigned char *in,

{

if (!packet_header_default::header_parser(in, tags)) {

return false;

frame_len++;

i += d_occupied_carriers[k].size();

}

tag.key = d_frame_len_tag_key;

tag.value = pmt::from_long(frame_len);

tags.push_back(tag);

#endif

#include <boost/format.hpp>

#include "packet_headergenerator_bb_impl.h"

namespace gr {

const gr::digital::packet_header_default::sptr &header_formatter,

const std::string &len_tag_key

)

len_tag_key),

d_formatter(header_formatter)

{

);

~packet_headergenerator_bb_impl();

int calculate_output_stream_length(const gr_vector_int &ninput_items) { return d_formatter->header_len(); };

int work(int noutput_items,

#endif

#include <boost/format.hpp>

#include "packet_headerparser_b_impl.h"

#define msg_port_id pmt::mp("header_data")

}

packet_headerparser_b_impl::packet_headerparser_b_impl(const gr::digital::packet_header_default::sptr &header_formatter)

d_header_formatter(header_formatter)

{

message_port_register_out(msg_port_id);

return 0;

}

if (!d_header_formatter->header_parser(in, tags)) {

GR_LOG_INFO(d_logger, boost::format("Detected an invalid packet at item %1%") % nitems_read(0));

message_port_pub(msg_port_id, pmt::PMT_F);

#endif

#include "packet_sink_impl.h"

#include <cstdio>

#include <errno.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdexcept>

#include <string.h>

namespace gr {

packet_sink::sptr

packet_sink::make(const std::vector<unsigned char>& sync_vector,

{

return gnuradio::get_initial_sptr

(new packet_sink_impl(sync_vector, target_queue, threshold));

}

packet_sink_impl::packet_sink_impl(const std::vector<unsigned char>& sync_vector,

d_target_queue(target_queue), d_threshold(threshold == -1 ? DEFAULT_THRESHOLD : threshold)

{

d_sync_vector = 0;

if(d_packetlen_cnt == d_packetlen) { // packet is filled

// build a message

memcpy(msg->msg(), d_packet, d_packetlen_cnt);

d_target_queue->insert_tail(msg); // send it

static const int MAX_PKT_LEN = 4096;

static const int HEADERBITLEN = 32;

unsigned long long d_sync_vector; // access code to locate start of packet

unsigned int d_threshold; // how many bits may be wrong in sync vector

unsigned long long d_shift_reg; // used to look for sync_vector

unsigned int d_header; // header bits

unsigned char d_packet[MAX_PKT_LEN]; // assembled payload

unsigned char d_packet_byte; // byte being assembled

public:

packet_sink_impl(const std::vector<unsigned char>& sync_vector,

int threshold=-1);

~packet_sink_impl();

#include <cmath>

#include "pfb_clock_sync_ccf_impl.h"

namespace gr {

namespace digital {

float init_phase,

float max_rate_deviation,

int osps)

d_updated(false), d_nfilters(filter_size),

d_max_dev(max_rate_deviation),

d_osps(osps), d_error(0), d_out_idx(0)

d_k = d_k + d_alpha*d_error;

// Keep our rate within a good range

i+=d_osps;

count += (int)floor(d_sps);

#include <cmath>

#include "pfb_clock_sync_fff_impl.h"

namespace gr {

namespace digital {

float init_phase,

float max_rate_deviation,

int osps)

d_updated(false), d_nfilters(filter_size),

d_max_dev(max_rate_deviation),

d_osps(osps), d_error(0), d_out_idx(0)

d_k = d_k + d_alpha*d_error;

// Keep our rate within a good range

i+=d_osps;

count += (int)floor(d_sps);

#endif

#include "pn_correlator_cc_impl.h"

namespace gr {

namespace digital {

pn_correlator_cc_impl::pn_correlator_cc_impl(int degree,

int mask,

int seed)

(unsigned int)((1ULL << degree)-1)) // PN code length

{

d_len = (unsigned int)((1ULL << degree)-1);

#endif

#include "probe_density_b_impl.h"

#include <iostream>

namespace gr {

}

probe_density_b_impl::probe_density_b_impl(double alpha)

{

set_alpha(alpha);

d_density = 1.0;

#endif

#include "probe_mpsk_snr_est_c_impl.h"

#include <cstdio>

namespace gr {

probe_mpsk_snr_est_c_impl::probe_mpsk_snr_est_c_impl(snr_est_type_t type,

int msg_nsamples,

double alpha)

{

d_snr_est = NULL;

#endif

#include "scrambler_bb_impl.h"

namespace gr {

namespace digital {

}

scrambler_bb_impl::scrambler_bb_impl(int mask, int seed, int len)

d_lfsr(mask, seed, len)

{

}

#define INCLUDED_GR_SCRAMBLER_BB_IMPL_H

#include <digital/scrambler_bb.h>

#include <digital/lfsr.h>

namespace gr {

#include "simple_correlator_impl.h"

#include <digital/simple_framer_sync.h>

#include <assert.h>

#include <stdexcept>

#include <string.h>

}

simple_correlator_impl::simple_correlator_impl(int payload_bytesize)

d_payload_bytesize(payload_bytesize),

d_state(ST_LOOKING), d_osi(0),

d_bblen((payload_bytesize + GRSF_PAYLOAD_OVERHEAD) * GRSF_BITS_PER_BYTE),

#include "simple_framer_impl.h"

#include <digital/simple_framer_sync.h>

#include <assert.h>

#include <string>

}

simple_framer_impl::simple_framer_impl(int payload_bytesize)

d_seqno (0), d_payload_bytesize (payload_bytesize),

d_input_block_size (payload_bytesize),

d_output_block_size (payload_bytesize + GRSF_OVERHEAD)