#define INCLUDED_DIGITAL_ADDITIVE_SCRAMBLER_BB_H

#include <digital/api.h>

namespace gr {

namespace digital {

* processed, the shift register is reset to the seed value.

* This allows processing fixed length vectors of samples.

*/

{

public:

// gr::digital::additive_scrambler_bb::sptr

#ifndef INCLUDED_DIGITAL_API_H

#define INCLUDED_DIGITAL_API_H

#ifdef gnuradio_digital_EXPORTS

# define DIGITAL_API __GR_ATTR_EXPORT

#define INCLUDED_DIGITAL_BINARY_SLICER_FB_H

#include <digital/api.h>

namespace gr {

namespace digital {

* x < 0 --> 0

* x >= 0 --> 1

*/

{

public:

// gr::digital::binary_slicer_fb::sptr

#define @GUARD_NAME@

#include <digital/api.h>

namespace gr {

namespace digital {

* \sa gr::digital::chunks_to_symbols_sf, gr::digital::chunks_to_symbols_sc.

*/

{

public:

// gr::digital::@BASE_NAME@::sptr

#define INCLUDED_DIGITAL_CLOCK_RECOVERY_MM_CC_H

#include <digital/api.h>

namespace gr {

namespace digital {

* and Muller algorithm," Electronics Letters, Vol. 31, no. 13, 22

* June 1995, pp. 1032 - 1033.

*/

{

public:

// gr::digital::clock_recovery_mm_cc::sptr

#define INCLUDED_DIGITAL_CLOCK_RECOVERY_MM_FF_H

#include <digital/api.h>

namespace gr {

namespace digital {

* Estimation and Signal Processing" by Heinrich Meyr, Marc

* Moeneclaey, & Stefan Fechtel. ISBN 0-471-50275-8.

*/

{

public:

// gr::digital::clock_recovery_mm_ff::sptr

#define INCLUDED_DIGITAL_CMA_EQUALIZER_CC_H

#include <digital/api.h>

namespace gr {

namespace digital {

* Transactions on Communications, Vol. 28, No. 11, pp. 1867 -

* 1875, 1980.

*/

{

protected:

virtual gr_complex error(const gr_complex &out) = 0;

#include <digital/api.h>

#include <digital/metric_type.h>

#include <boost/enable_shared_from_this.hpp>

#include <vector>

namespace gr {

#include <digital/api.h>

#include <digital/constellation.h>

namespace gr {

namespace digital {

* object.

*/

class DIGITAL_API constellation_decoder_cb

{

public:

// gr::digital::constellation_decoder_cb::sptr

#include <digital/api.h>

#include <digital/constellation.h>

namespace gr {

namespace digital {

* the NCO are updated according to this error.

*/

class DIGITAL_API constellation_receiver_cb

{

public:

// gr::digital::constellation_receiver_cb::sptr

#define INCLUDED_DIGITAL_CORRELATE_ACCESS_CODE_BB_H

#include <digital/api.h>

#include <string>

namespace gr {

* the corresponding data bit is the first data bit following the

* access code. Otherwise the flag bit is 0.

*/

{

public:

// gr::digital::correlate_access_code_bb::sptr

#define INCLUDED_DIGITAL_CORRELATE_ACCESS_CODE_TAG_BB_H

#include <digital/api.h>

#include <string>

namespace gr {

* key name [tag_name], specified in the constructor. Used for

* searching an input data stream for preambles, etc.

*/

{

public:

// gr::digital::correlate_access_code_tag_bb::sptr

#define INCLUDED_DIGITAL_COSTAS_LOOP_CC_H

#include <digital/api.h>

namespace gr {

namespace digital {

* stream 2 is the normalized frequency of the loop

*/

class DIGITAL_API costas_loop_cc

virtual public blocks::control_loop

{

public:

#define INCLUDED_DIGITAL_CPMMOD_BC_H

#include <digital/api.h>

#include <analog/cpm.h>

namespace gr {

* The modulator will silently accept any other inputs, though.

* The output is the phase-modulated signal.

*/

{

public:

// gr::digital::cpmmod_bc::sptr

#include <digital/api.h>

#include <string>

namespace gr {

namespace digital {

#define INCLUDED_DIGITAL_CRC32_BB_H

#include <digital/api.h>

namespace gr {

namespace digital {

* Output: The same bytes as incoming, but trailing a CRC32 of the packet.

* The tag is re-set to the new length.

*/

{

public:

typedef boost::shared_ptr<crc32_bb> sptr;

#define INCLUDED_GR_DESCRAMBLER_BB_H

#include <digital/api.h>

namespace gr {

namespace digital {

* the LSB only of the input data stream, i.e., on an "unpacked

* binary" stream, and produces the same format on its output.

*/

{

public:

// gr::digital::descrambler_bb::sptr

#define INCLUDED_GR_DIFF_DECODER_BB_H

#include <digital/api.h>

namespace gr {

namespace digital {

* Uses current and previous symbols and the alphabet modulus to

* perform differential decoding.

*/

{

public:

// gr::digital::diff_decoder_bb::sptr

#define INCLUDED_GR_DIFF_ENCODER_BB_H

#include <digital/api.h>

namespace gr {

namespace digital {

* Uses current and previous symbols and the alphabet modulus to

* perform differential encoding.

*/

{

public:

// gr::digital::diff_encoder_bb::sptr

#define INCLUDED_GR_DIFF_PHASOR_CC_H

#include <digital/api.h>

namespace gr {

namespace digital {

*

* out[i] = in[i] * conj(in[i-1]);

*/

{

public:

// gr::digital::diff_phasor_cc::sptr

#define INCLUDED_DIGITAL_FLL_BAND_EDGE_CC_H

#include <digital/api.h>

namespace gr {

namespace digital {

* large.

*/

class DIGITAL_API fll_band_edge_cc

virtual public blocks::control_loop

{

public:

#define INCLUDED_GR_FRAMER_SINK_1_H

#include <digital/api.h>

namespace gr {

namespace digital {

* the corresponding bit is the the first bit of the packet. That

* is, this bit is the first one after the access code.

*/

{

public:

// gr::digital::framer_sink_1::sptr

*

* \param target_queue The message queue where frames go.

*/

};

} /* namespace digital */

#define INCLUDED_GR_GLFSR_SOURCE_B_H

#include <digital/api.h>

namespace gr {

namespace digital {

* \brief Galois LFSR pseudo-random source

* \ingroup waveform_generators_blk

*/

{

public:

// gr::digital::glfsr_source_b::sptr

#define INCLUDED_GR_GLFSR_SOURCE_F_H

#include <digital/api.h>

namespace gr {

namespace digital {

* \brief Galois LFSR pseudo-random source generating float outputs -1.0 - 1.0.

* \ingroup waveform_generators_blk

*/

{

public:

// gr::digital::glfsr_source_f::sptr

#define INCLUDED_DIGITAL_HEADER_PAYLOAD_DEMUX_H

#include <digital/api.h>

namespace gr {

namespace digital {

* A special case are tags on items that make up the guard interval. These are copied

* to the first item of the following symbol.

*/

{

public:

typedef boost::shared_ptr<header_payload_demux> sptr;

#define INCLUDED_DIGITAL_KURTOTIC_EQUALIZER_CC_H

#include <digital/api.h>

namespace gr {

namespace digital {

* Robotics and Vision, Vol. 3, Dec. 2004, pp. 2052 - 2057."

*/

class DIGITAL_API kurtotic_equalizer_cc :

{

protected:

virtual gr_complex error(const gr_complex &out) = 0;

#define INCLUDED_DIGITAL_LMS_DD_EQUALIZER_CC_H

#include <digital/api.h>

#include <digital/constellation.h>

namespace gr {

* Prentice Hall, 1996.

*/

class DIGITAL_API lms_dd_equalizer_cc :

{

protected:

virtual gr_complex error(const gr_complex &out) = 0;

#define INCLUDED_GR_MAP_BB_H

#include <digital/api.h>

namespace gr {

namespace digital {

*

* -> output[i] = map[input[i]]

*/

{

public:

// gr::digital::map_bb::sptr

#define INCLUDED_DIGITAL_MPSK_RECEIVER_CC_H

#include <digital/api.h>

namespace gr {

namespace digital {

* self-noise.

*

*/

{

public:

// gr::digital::mpsk_receiver_cc::sptr

#define INCLUDED_DIGITAL_MPSK_SNR_EST_H

#include <digital/api.h>

namespace gr {

namespace digital {

#include <digital/api.h>

#include <digital/mpsk_snr_est.h>

namespace gr {

namespace digital {

* amount of error should be assumed and/or estimated for real

* channel conditions.

*/

{

public:

// gr::digital::mpsk_snr_est_cc::sptr

#define INCLUDED_DIGITAL_OFDM_CARRIER_ALLOCATOR_CVC_H

#include <digital/api.h>

namespace gr {

namespace digital {

* \p fft_len-1 both identify the carrier below the DC carrier.

*

*/

{

public:

typedef boost::shared_ptr<ofdm_carrier_allocator_cvc> sptr;

#define INCLUDED_DIGITAL_OFDM_CHANEST_VCVC_H

#include <digital/api.h>

namespace gr {

namespace digital {

* Communications, IEEE Transactions on, 1997.

* [2] K.D. Kammeyer, "Nachrichtenuebertragung," Chapter. 16.3.2.

*/

{

public:

typedef boost::shared_ptr<ofdm_chanest_vcvc> sptr;

#define INCLUDED_DIGITAL_OFDM_CYCLIC_PREFIXER_H

#include <digital/api.h>

namespace gr {

namespace digital {

*

* The pulse shape is a raised cosine in the time domain.

*/

{

public:

typedef boost::shared_ptr<ofdm_cyclic_prefixer> sptr;

#define INCLUDED_DIGITAL_OFDM_EQUALIZER_BASE_H

#include <digital/api.h>

#include <boost/enable_shared_from_this.hpp>

namespace gr {

gr_complex *frame,

int n_sym,

const std::vector<gr_complex> &initial_taps = std::vector<gr_complex>(),

//! Return the current channel state

virtual void get_channel_state(std::vector<gr_complex> &taps) = 0;

int fft_len() { return d_fft_len; };

void equalize(gr_complex *frame,

int n_sym,

const std::vector<gr_complex> &initial_taps = std::vector<gr_complex>(),

/*

* \param fft_len FFT length

void equalize(gr_complex *frame,

int n_sym,

const std::vector<gr_complex> &initial_taps = std::vector<gr_complex>(),

/*

* \param fft_len FFT length

#define INCLUDED_DIGITAL_OFDM_FRAME_ACQUISITION_H

#include <digital/api.h>

#include <vector>

namespace gr {

* equalization on all subcarriers. This corrects for the phase

* and amplitude distortion caused by the channel.

*/

{

public:

// gr::digital::ofdm_frame_acquisition::sptr

#include <digital/api.h>

#include <digital/ofdm_equalizer_base.h>

namespace gr {

namespace digital {

* Input: a tagged series of OFDM symbols.

* Output: The same as the input, but equalized.

*/

{

public:

typedef boost::shared_ptr<ofdm_frame_equalizer_vcvc> sptr;

#define INCLUDED_DIGITAL_OFDM_FRAME_SINK_H

#include <digital/api.h>

namespace gr {

namespace digital {

* reference to an object to do the demapping and slicing for a

* given modulation type.

*/

{

public:

// gr::digital::ofdm_frame_sink::sptr

*/

static sptr make(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);

};

#define INCLUDED_DIGITAL_OFDM_INSERT_PREAMBLE_H

#include <digital/api.h>

#include <vector>

namespace gr {

* symbol is the first symbol, otherwise 0.

* </pre>

*/

{

public:

// gr::digital::ofdm_insert_preamble::sptr

#define INCLUDED_DIGITAL_OFDM_MAPPER_BCV_H

#include <digital/api.h>

namespace gr {

namespace digital {

* \details

* Abstract class must be subclassed with specific mapping.

*/

{

public:

// gr::digital::ofdm_mapper_bcv::sptr

unsigned occupied_carriers,

unsigned int fft_length);

};

} /* namespace digital */

#define INCLUDED_DIGITAL_OFDM_SAMPLER_H

#include <digital/api.h>

namespace gr {

namespace digital {

* \brief does the rest of the OFDM stuff

* \ingroup ofdm_blk

*/

{

public:

// gr::digital::ofdm_sampler::sptr

#define INCLUDED_DIGITAL_OFDM_SERIALIZER_VCC_H

#include <digital/api.h>

#include <digital/ofdm_carrier_allocator_cvc.h>

namespace gr {

* Input: Complex vectors of length \p fft_len

* Output: Complex scalars, in the same order as specified in occupied_carriers.

*/

{

public:

typedef boost::shared_ptr<ofdm_serializer_vcc> sptr;

#define INCLUDED_DIGITAL_OFDM_SYNC_SC_CFB_H

#include <digital/api.h>

namespace gr {

namespace digital {

* [1] Schmidl, T.M. and Cox, D.C., "Robust frequency and timing synchronization for OFDM",

* Communications, IEEE Transactions on, 1997.

*/

{

public:

typedef boost::shared_ptr<ofdm_sync_sc_cfb> sptr;

#ifndef INCLUDED_DIGITAL_PACKET_HEADER_DEFAULT_H

#define INCLUDED_DIGITAL_PACKET_HEADER_DEFAULT_H

#include <digital/api.h>

#include <boost/enable_shared_from_this.hpp>

virtual bool header_formatter(

long packet_len,

unsigned char *out,

);

/*!

*/

virtual bool header_parser(

const unsigned char *header,

static sptr make(

long header_len,

*/

bool header_parser(

const unsigned char *header,

/*!

* \param occupied_carriers See carrier allocator

#define INCLUDED_PACKET_HEADERGENERATOR_BB_H

#include <digital/api.h>

#include <digital/packet_header_default.h>

namespace gr {

* or a subclass thereof). If only a number of bits is specified, a

* default header is generated (see packet_header_default).

*/

{

public:

typedef boost::shared_ptr<packet_headergenerator_bb> sptr;

#define INCLUDED_DIGITAL_PACKET_HEADERPARSER_B_H

#include <digital/api.h>

#include <digital/packet_header_default.h>

namespace gr {

* If only a header length is given, this block uses the default header

* format.

*/

{

public:

typedef boost::shared_ptr<packet_headerparser_b> sptr;

#define INCLUDED_GR_PACKET_SINK_H

#include <digital/api.h>

namespace gr {

namespace digital {

* generally be replaced with a correlate access code and frame

* sink blocks.

*/

{

public:

// gr::digital::packet_sink::sptr

* \param threshold Number of bits that can be incorrect in the \p sync_vector.

*/

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

int threshold=-1);

//! return true if we detect carrier

#include <digital/api.h>

#include <filter/fir_filter.h>

namespace gr {

namespace digital {

* was added to better work with equalizers, which do a better job

* of modeling the channel if they have 2 samps/sym.

*/

{

public:

// gr::digital::pfb_clock_sync_ccf::sptr

#include <digital/api.h>

#include <filter/fir_filter.h>

namespace gr {

namespace digital {

* was added to better work with equalizers, which do a better job

* of modeling the channel if they have 2 samps/sym.

*/

{

public:

// gr::digital::pfb_clock_sync_fff::sptr

#define INCLUDED_GR_PN_CORRELATOR_CC_H

#include <digital/api.h>

namespace gr {

namespace digital {

* against reference PN code, one sample per PN code period. The

* PN sequence is generated using a GLFSR.

*/

{

public:

// gr::digital::pn_correlator_cc::sptr

#define INCLUDED_GR_PROBE_DENSITY_B_H

#include <digital/api.h>

namespace gr {

namespace digital {

* If you send this block a stream of unpacked bytes, it will tell

* you what the bit density is.

*/

{

public:

// gr::digital::probe_density_b::sptr

#include <digital/api.h>

#include <digital/mpsk_snr_est.h>

namespace gr {

namespace digital {

* conditions; some amount of error should be assumed and/or

* estimated for real channel conditions.

*/

{

public:

// gr::digital::probe_mpsk_snr_est_c::sptr

#define INCLUDED_GR_SCRAMBLER_BB_H

#include <digital/api.h>

namespace gr {

namespace digital {

* i.e., on an "unpacked binary" stream, and produces the same

* format on its output.

*/

{

public:

// gr::digital::scrambler_bb::sptr

#define INCLUDED_GR_SIMPLE_CORRELATOR_H

#include <digital/api.h>

namespace gr {

namespace digital {

* \ingroup packet_operators_blk

* \ingroup deprecated_blk

*/

{

public:

// gr::digital::simple_correlator::sptr

#define INCLUDED_GR_SIMPLE_FRAMER_H

#include <digital/api.h>

namespace gr {

namespace digital {

* frame is prepended with the GRSF_SYNC (defind in

* simple_framer_sync.h) and an 8-bit sequence number.

*/

{

public:

// gr::digital::simple_framer::sptr

#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)

""" Make sure the output of a CRC set is 4 bytes longer than the input. """

data = range(16)

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(len(data))

is the same as the input. """

data = (0, 1, 2, 3, 4, 5, 6, 7, 8)

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(len(data))

tag_name = "length"

pack_len = 8

packets = range(pack_len*2)

tag1.offset = 0

tag1.key = pmt.string_to_symbol(tag_name)

tag1.value = pmt.from_long(pack_len)

tag2.offset = pack_len

tag2.key = pmt.string_to_symbol(tag_name)

tag2.value = pmt.from_long(pack_len)

testtag1.offset = 1

testtag1.key = pmt.string_to_symbol("tag1")

testtag1.value = pmt.from_long(0)

testtag2.offset = pack_len

testtag2.key = pmt.string_to_symbol("tag2")

testtag2.value = pmt.from_long(0)

testtag3.offset = len(packets)-1

testtag3.key = pmt.string_to_symbol("tag3")

testtag3.value = pmt.from_long(0)

""" Corrupt the data and make sure it fails CRC test. """

data = (0, 1, 2, 3, 4, 5, 6, 7)

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(len(data))

""" Make sure tags on the CRC aren't lost. """

data = (0, 1, 2, 3, 4, 5, 6, 7, 8, 230, 166, 39, 8)

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(len(data))

testtag.offset = len(data)-1

testtag.key = pmt.string_to_symbol('tag1')

testtag.value = pmt.from_long(0)

expected_result = tuple(sync_word[0] + [1j, 0, 0, 1, 2, 3])

# ^ DC carrier

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(len(tx_symbols))

expected_result = (1j, 0, 1, 2, 3)

# ^ DC carrier

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(len(tx_symbols))

pilot_carriers = ((3,),)

expected_result = (1j, 0, 1, 0, 2, 3)

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(len(tx_symbols))

0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0, 0)

fft_len = 16

tag_name = "len"

tag1.offset = 0

tag1.key = pmt.string_to_symbol(tag_name)

tag1.value = pmt.from_long(len(tx_symbols))

tag2.offset = len(tx_symbols)

tag2.key = pmt.string_to_symbol(tag_name)

tag2.value = pmt.from_long(len(tx_symbols))

testtag1.offset = 0

testtag1.key = pmt.string_to_symbol('tag1')

testtag1.value = pmt.from_long(0)

testtag2.offset = 7 # On the 2nd OFDM symbol

testtag2.key = pmt.string_to_symbol('tag2')

testtag2.value = pmt.from_long(0)

testtag3.offset = len(tx_symbols)+1 # First OFDM symbol of packet 2

testtag3.key = pmt.string_to_symbol('tag3')

testtag3.value = pmt.from_long(0)

testtag4.offset = 2*len(tx_symbols)-1 # Last OFDM symbol of packet 2

testtag4.key = pmt.string_to_symbol('tag4')

testtag4.value = pmt.from_long(0)

tx_data = shift_tuple(sync_symbol1, carr_offset) + \

shift_tuple(sync_symbol2, carr_offset) + \

shift_tuple(data_symbol, carr_offset)

tag1.offset = 0

tag1.key = pmt.string_to_symbol("test_tag_1")

tag1.value = pmt.from_long(23)

tag2.offset = 2

tag2.key = pmt.string_to_symbol("test_tag_2")

tag2.value = pmt.from_long(42)

tag_name = "length"

expected_result = (7.0/2, 8, 1, 2, 3, 4, 5, 6, 7, 8, # 1.0/2

7.0/2+1.0/2, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1.0/2)

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(2)

tag2.offset = 1

tag2.key = pmt.string_to_symbol("random_tag")

tag2.value = pmt.from_long(42)

n_syms = 3

len_tag_key = "frame_len"

tx_data = (1,) * fft_len * n_syms

len_tag.offset = 0

len_tag.key = pmt.string_to_symbol(len_tag_key)

len_tag.value = pmt.from_long(n_syms)

chan_tag.offset = 0

chan_tag.key = pmt.string_to_symbol("ofdm_sync_chan_taps")

chan_tag.value = pmt.init_c32vector(fft_len, (1,) * fft_len)

idx2 = idx+2*fft_len

channel[idx2] = channel[idx2] * numpy.exp(1j * 0 * numpy.pi * (numpy.random.rand()-.5))

len_tag_key = "frame_len"

len_tag.offset = 0

len_tag.key = pmt.string_to_symbol(len_tag_key)

len_tag.value = pmt.from_long(4)

chan_tag.offset = 0

chan_tag.key = pmt.string_to_symbol("ofdm_sync_chan_taps")

chan_tag.value = pmt.init_c32vector(fft_len, channel[:fft_len])

idx2 = idx+2*fft_len

channel[idx2] = channel[idx2] * numpy.exp(1j * 0 * numpy.pi * (numpy.random.rand()-.5))

len_tag_key = "frame_len"

len_tag.offset = 0

len_tag.key = pmt.string_to_symbol(len_tag_key)

len_tag.value = pmt.from_long(4)

chan_tag.offset = 0

chan_tag.key = pmt.string_to_symbol("ofdm_sync_chan_taps")

chan_tag.value = pmt.init_c32vector(fft_len, channel[:fft_len])

occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),)

n_syms = len(tx_symbols)/fft_len

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(n_syms)

occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),)

n_syms = len(tx_symbols)/fft_len

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(n_syms)

offsettag.offset = 0

offsettag.key = pmt.string_to_symbol("ofdm_sync_carr_offset")

offsettag.value = pmt.from_long(carr_offset)

sync_word = (range(fft_len),)

tx_data = tuple([numpy.random.randint(0, 10) for x in range(4 * n_syms)])

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(len(tx_data))

tx_data = tuple([numpy.random.randint(0, 10) for x in range(4 * n_syms)])

#tx_data = (1,) * occupied_carriers[0] * n_syms

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(len(tx_data))

offsettag.offset = 0

offsettag.key = pmt.string_to_symbol("ofdm_sync_carr_offset")

offsettag.value = pmt.from_long(carr_offset)

occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),)

n_syms = len(tx_symbols)/fft_len

tag_name = "len"

tag.offset = 0

tag.key = pmt.string_to_symbol(tag_name)

tag.value = pmt.from_long(n_syms)

tag2.offset = 0

tag2.key = pmt.string_to_symbol("packet_len")

tag2.value = pmt.from_long(len(expected_result))

# 3 PDUs: | | |

data = (1, 2, 3, 4, 1, 2) + tuple(range(25))

tagname = "packet_len"

tag1.offset = 0

tag1.key = pmt.string_to_symbol(tagname)

tag1.value = pmt.from_long(4)

tag2.offset = 4

tag2.key = pmt.string_to_symbol(tagname)

tag2.value = pmt.from_long(2)

tag3.offset = 6

tag3.key = pmt.string_to_symbol(tagname)

tag3.value = pmt.from_long(25)

# 3 PDUs: | | | |

data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)

tagname = "packet_len"

tag1.offset = 0

tag1.key = pmt.string_to_symbol(tagname)

tag1.value = pmt.from_long(4)

tag2.offset = 4

tag2.key = pmt.string_to_symbol(tagname)

tag2.value = pmt.from_long(2)

tag3.offset = 6

tag3.key = pmt.string_to_symbol(tagname)

tag3.value = pmt.from_long(4)

# 3 PDUs: | | | |

data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)

tagname = "packet_len"

tag1.offset = 0

tag1.key = pmt.string_to_symbol(tagname)

tag1.value = pmt.from_long(4)

tag2.offset = 4

tag2.key = pmt.string_to_symbol(tagname)

tag2.value = pmt.from_long(2)

tag3.offset = 6

tag3.key = pmt.string_to_symbol(tagname)

tag3.value = pmt.from_long(4)

# 3 PDUs: | | | |

data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)

tagname = "packet_len"

tag1.offset = 0

tag1.key = pmt.string_to_symbol(tagname)

tag1.value = pmt.from_long(4)

tag2.offset = 4

tag2.key = pmt.string_to_symbol(tagname)

tag2.value = pmt.from_long(2)

tag3.offset = 6

tag3.key = pmt.string_to_symbol(tagname)

tag3.value = pmt.from_long(4)

tags = []

assert(len(offsets) == len(lengths))

for offset, length in zip(offsets, lengths):

tag.offset = offset/vlen

tag.key = pmt.string_to_symbol(tagname)

tag.value = pmt.from_long(length/vlen)

offset = 0

for packet in packets:

data.extend(packet)

tag.offset = offset/vlen

tag.key = pmt.string_to_symbol(lengthtagname)

tag.value = pmt.from_long(len(packet)/vlen)

%include "analog/cpm.h"

%{

%}

%{

#include "digital/additive_scrambler_bb.h"