# Set the version information here

set(VERSION_INFO_MAJOR_VERSION 3)

set(VERSION_INFO_API_COMPAT 7)

include(GrVersion) #setup version info

# Append -O2 optimization flag for Debug builds (Not on MSVC since conflicts with RTC1 flag)

=================

Contributors

------------

The following list of people directly contributed code to this

release:

* Johnathan Corgan <johnathan@corganlabs.com>

* Ron Economos <w6rz@comcast.net>

* Sebastian Koslowski <koslowski@kit.edu>

## Major Development Areas

### GRC

.. autoblock:: gnuradio.blocks.tagged_stream_mux

.. autoblock:: gnuradio.blocks.tagged_stream_to_pdu

.. autoblock:: gnuradio.blocks.tags_strobe

.. autoblock:: gnuradio.blocks.threshold_ff

.. autoblock:: gnuradio.blocks.throttle

.. autoblock:: gnuradio.blocks.transcendental

:nosignatures:

gnuradio.blocks.socket_pdu

gnuradio.blocks.udp_sink

gnuradio.blocks.udp_source

#include <config.h>

#endif

#include <gnuradio/constants.h>

namespace gr {

const std::string

prefix()

{

return "@prefix@";

}

const std::string

sysconfdir()

{

return "@SYSCONFDIR@";

}

const std::string

prefsdir()

{

return "@GR_PREFSDIR@";

}

</cat>

<cat>

<name>Modulators</name>

<block>analog_frequency_modulator_fc</block>

<block>analog_phase_modulator_fc</block>

<block>analog_quadrature_demod_cf</block>

<block>

<name>CPFSK</name>

<key>analog_cpfsk_bc</key>

<import>from gnuradio import analog</import>

<make>analog.cpfsk_bc($k, $amplitude, $samples_per_symbol)</make>

<callback>set_amplitude($amplitude)</callback>

* \brief Perform continuous phase 2-level frequency shift keying modulation

* on an input stream of unpacked bits.

* \ingroup modulators_blk

*/

class ANALOG_API cpfsk_bc : virtual public sync_interpolator

{

sink::sptr

windows_sink_fcn(int sampling_rate,

const std::string &device_name,

{

return sink::sptr

}

static const double CHUNK_TIME = prefs::singleton()->get_double("audio_windows", "period_time", 0.1); // 100 ms (below 3ms distortion will likely occur regardless of number of buffers, will likely be a higher limit on slower machines)

return (default_device == "default" ? "WAVE_MAPPER" : default_device);

}

: sync_block("audio_windows_sink",

io_signature::make(1, 2, sizeof(float)),

io_signature::make(0, 0, 0)),

d_sampling_freq(sampling_freq),

d_device_name(device_name.empty() ? default_device_name() : device_name),

{

/* Initialize the WAVEFORMATEX for 16-bit, 44KHz, stereo */

wave_format.wFormatTag = WAVE_FORMAT_PCM;

}

}

if (!chosen_header) {

}

if (c++ > 10) {

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

printf("%d: %d\n", i, d_buffers[i]->dwFlags);

}

int d_fd;

LPWAVEHDR *d_buffers;

DWORD d_chunk_size;

HWAVEOUT d_h_waveout;

HANDLE d_wave_write_event;

protected:

int string_to_int(const std::string & s);

int open_waveout_device(void);

int write_waveout(LPWAVEHDR lp_wave_hdr);

public:

windows_sink(int sampling_freq,

~windows_sink();

int work(int noutput_items,

#include "audio_registry.h"

#include <windows_source.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdio.h>

#include <iostream>

#include <stdexcept>

namespace gr {

} /* namespace gr */

#ifndef INCLUDED_AUDIO_WINDOWS_SOURCE_H

#define INCLUDED_AUDIO_WINDOWS_SOURCE_H

#include <gnuradio/audio/source.h>

#include <string>

namespace gr {

namespace audio {

*/

class windows_source : public source

{

public:

windows_source(int sampling_freq,

gr_vector_void_star & output_items);

};

} /* namespace audio */

} /* namespace gr */

<block>blocks_add_const_vxx</block>

<block>blocks_divide_xx</block>

<block>blocks_multiply_xx</block>

<block>blocks_multiply_const_vxx</block>

<block>blocks_multiply_conjugate_cc</block>

<block>blocks_multiply_matrix_xx</block>

</cat>

<cat>

<name>Message Tools</name>

<block>blocks_message_strobe</block>

<block>blocks_message_strobe_random</block>

<block>blocks_message_debug</block>

<name>Networking Tools</name>

<block>blocks_tuntap_pdu</block>

<block>blocks_socket_pdu</block>

<block>blocks_udp_source</block>

<block>blocks_udp_sink</block>

</cat>

<block>

<name>Message Burst Source</name>

<key>blocks_message_burst_source</key>

<import>from gnuradio import blocks</import>

<make>blocks.message_burst_source($type.size*$vlen, $(id)_msgq_in)</make>

<param>

<block>

<name>Message Sink</name>

<key>blocks_message_sink</key>

<import>from gnuradio import blocks</import>

<make>blocks.message_sink($type.size*$vlen, $(id)_msgq_out, $dont_block)</make>

<param>

<block>

<name>Message Source</name>

<key>blocks_message_source</key>

<import>from gnuradio import blocks</import>

<make>blocks.message_source($type.size*$vlen, $(id)_msgq_in)</make>

<param>

<import>from gnuradio import blocks</import>

<import>import pmt</import>

<make>blocks.pdu_filter($k, $v, $invert)</make>

<param>

<name>Key</name>

<key>k</key>

<name>Invert Filter</name>

<key>invert</key>

<value>False</value>

<option>

<name>No</name>

<key>False</key>

<import>from gnuradio import blocks</import>

<import>import pmt</import>

<make>blocks.pdu_remove($k)</make>

<param>

<name>Key</name>

<key>k</key>

<import>from gnuradio import blocks</import>

<import>import pmt</import>

<make>blocks.pdu_set($k, $v)</make>

<param>

<name>Key</name>

<key>k</key>

tagged_stream_multiply_length.h

tagged_stream_to_pdu.h

tags_strobe.h

test_tag_variable_rate_ff.h

threshold_ff.h

throttle.h

/*!

* \brief Turn received messages into a stream and tag them for UHD to send.

*/

class BLOCKS_API message_burst_source : virtual public sync_block

{

/*!

* \brief Gather received items into messages and insert into msgq

*/

class BLOCKS_API message_sink : virtual public sync_block

{

/*!

* \brief Turn received messages into a stream

*/

class BLOCKS_API message_source : virtual public sync_block

{

* \brief Construct a PDU filter

*/

static sptr make(pmt::pmt_t k, pmt::pmt_t v, bool invert = false);

};

} /* namespace blocks */

* \brief Construct a PDU meta remove block

*/

static sptr make(pmt::pmt_t k);

};

} /* namespace blocks */

* \brief Construct a PDU meta set block

*/

static sptr make(pmt::pmt_t k, pmt::pmt_t v);

};

} /* namespace blocks */

throttle_impl.cc

transcendental_impl.cc

tcp_connection.cc

tuntap_pdu_impl.cc

tag_gate_impl.cc

tagged_stream_align_impl.cc

public:

pdu_filter_impl(pmt::pmt_t k, pmt::pmt_t v, bool invert);

void handle_msg(pmt::pmt_t msg);

};

} /* namespace blocks */

public:

pdu_remove_impl(pmt::pmt_t k);

void handle_msg(pmt::pmt_t msg);

};

} /* namespace blocks */

public:

pdu_set_impl(pmt::pmt_t k, pmt::pmt_t v);

void handle_msg(pmt::pmt_t msg);

};

} /* namespace blocks */

gr.io_signature(2, 2, gr.sizeof_char),

gr.io_signature(1, 1, gr.sizeof_float),

)

assert type in ('BER', 'SER')

self._max_samples = win_size

self._bits_per_symbol = bits_per_symbol

gr.io_signature(num_inputs, num_inputs, item_size),

gr.io_signature(num_outputs, num_outputs, item_size),

)

#terminator blocks for unused inputs and outputs

self.input_terminators = [blocks.null_sink(item_size) for i in range(num_inputs)]

self.output_terminators = [blocks.head(item_size, 0) for i in range(num_outputs)]

else: output_index = 0

selector.__init__(self, item_size, 1, 1, 0, output_index)

def set_open(self, open):

"""

Callback to set open state.

fd = _get_sock_fd(addr, port, server)

self.connect(blocks.file_descriptor_source(itemsize, fd), self)

class tcp_sink(gr.hier_block2):

def __init__(self, itemsize, addr, port, server=False):

#init hier block

)

fd = _get_sock_fd(addr, port, server)

self.connect(self, blocks.file_descriptor_sink(itemsize, fd))

#include "gnuradio/blocks/tagged_stream_multiply_length.h"

#include "gnuradio/blocks/tagged_stream_to_pdu.h"

#include "gnuradio/blocks/tags_strobe.h"

#include "gnuradio/blocks/test_tag_variable_rate_ff.h"

#include "gnuradio/blocks/threshold_ff.h"

#include "gnuradio/blocks/transcendental.h"

%include "gnuradio/blocks/tagged_stream_multiply_length.h"

%include "gnuradio/blocks/tagged_stream_to_pdu.h"

%include "gnuradio/blocks/tags_strobe.h"

%include "gnuradio/blocks/test_tag_variable_rate_ff.h"

%include "gnuradio/blocks/threshold_ff.h"

%include "gnuradio/blocks/transcendental.h"

GR_SWIG_BLOCK_MAGIC2(blocks, tagged_stream_multiply_length);

GR_SWIG_BLOCK_MAGIC2(blocks, tagged_stream_to_pdu);

GR_SWIG_BLOCK_MAGIC2(blocks, tags_strobe);

GR_SWIG_BLOCK_MAGIC2(blocks, test_tag_variable_rate_ff);

GR_SWIG_BLOCK_MAGIC2(blocks, threshold_ff);

GR_SWIG_BLOCK_MAGIC2(blocks, transcendental);

<cat>

<name>Modulators</name>

<block>digital_cpmmod_bc</block>

<block>digital_gfsk_mod</block>

<block>digital_gfsk_demod</block>

<block>digital_gmskmod_bc</block>

<block>digital_gmsk_mod</block>

<block>digital_gmsk_demod</block>

<block>digital_constellation_modulator</block>

<block>digital_constellation_receiver_cb</block>

<block>variable_constellation</block>

<block>digital_pfb_clock_sync_xxx</block>

<block>digital_pn_correlator_cc</block>

<block>digital_corr_est_cc</block>

</cat>

<cat>

<name>Waveform Generators</name>

<block>

<name>Correlate and Sync</name>

<key>digital_correlate_and_sync_cc</key>

<import>from gnuradio import digital</import>

<make>digital.correlate_and_sync_cc($symbols, $filter, $sps)</make>

<param>

<block>

<name>DPSK Demod</name>

<key>digital_dxpsk_demod</key>

<import>from gnuradio import digital</import>

<make>digital.$(type)_demod(

samples_per_symbol=$samples_per_symbol,

<block>

<name>DPSK Mod</name>

<key>digital_dxpsk_mod</key>

<import>from gnuradio import digital</import>

<make>digital.$(type)_mod(

samples_per_symbol=$samples_per_symbol,

<block>

<name>MPSK Receiver</name>

<key>digital_mpsk_receiver_cc</key>

<import>from gnuradio import digital;import cmath</import>

<make>digital.mpsk_receiver_cc($M, $theta, $w, $fmin, $fmax, $mu, $gain_mu, $omega, $gain_omega, $omega_relative_limit)</make>

<callback>set_loop_bandwidth($w)</callback>

<block>

<name>OFDM Demod</name>

<key>digital_ofdm_demod</key>

<import>from grc_gnuradio import blks2 as grc_blks2</import>

<import>from gnuradio import digital</import>

<make>grc_blks2.packet_demod_$(type.fcn)(digital.ofdm_demod(

<block>

<name>OFDM Frame Acquisition</name>

<key>digital_ofdm_frame_acquisition</key>

<import>from gnuradio import digital</import>

<make>digital.ofdm_frame_acquisition($occupied_carriers, $fft_length, $cplen, $known_symbol, $max_fft_shift_len)</make>

<param>

<block>

<name>OFDM Frame Sink</name>

<key>digital_ofdm_frame_sink</key>

<import>from gnuradio import digital</import>

<make>digital.ofdm_frame_sink($syms, $vals, $queue, $occ_tones, $ph_gain, $frq_gain)</make>

<param>

<block>

<name>OFDM Insert Preamble</name>

<key>digital_ofdm_insert_preamble</key>

<import>from gnuradio import digital</import>

<make>digital.ofdm_insert_preamble($fft_length, $preamble)</make>

<param>

<block>

<name>OFDM Mod</name>

<key>digital_ofdm_mod</key>

<import>from grc_gnuradio import blks2 as grc_blks2</import>

<import>from gnuradio import digital</import>

<make>grc_blks2.packet_mod_$(type.fcn)(digital.ofdm_mod(

<block>

<name>OFDM Sampler</name>

<key>digital_ofdm_sampler</key>

<import>from gnuradio import digital</import>

<make>digital.ofdm_sampler($fft_length, $symbol_length, $timeout)</make>

<param>

<block>

<name>OFDM Sync PN</name>

<key>digital_ofdm_sync_pn</key>

<import>from gnuradio import digital</import>

<make>digital.ofdm_sync_pn($fft_length, $cp_length, $logging)</make>

<param>

<block>

<name>PSK Demod</name>

<key>digital_psk_demod</key>

<import>from gnuradio import digital</import>

<make>digital.psk.psk_demod(

constellation_points=$constellation_points,

<block>

<name>PSK Mod</name>

<key>digital_psk_mod</key>

<import>from gnuradio import digital</import>

<make>digital.psk.psk_mod(

constellation_points=$constellation_points,

<block>

<name>QAM Demod</name>

<key>digital_qam_demod</key>

<import>from gnuradio import digital</import>

<make>digital.qam.qam_demod(

constellation_points=$constellation_points,

<block>

<name>QAM Mod</name>

<key>digital_qam_mod</key>

<import>from gnuradio import digital</import>

<make>digital.qam.qam_mod(

constellation_points=$constellation_points,

/*!

* \brief Correlate to a preamble and send time/phase sync info

*

* \details

* Input:

* \brief This block takes care of receiving M-PSK modulated

* signals through phase, frequency, and symbol synchronization.

* \ingroup synchronizers_blk

*

* \details

* It performs carrier frequency and phase locking as well as

* \brief take a vector of complex constellation points in from an

* FFT and performs a correlation and equalization.

* \ingroup ofdm_blk

*

* \details

* This block takes the output of an FFT of a received OFDM symbol

* 1's, packs them into packets, and sends to to a message queue

* sink.

* \ingroup ofdm_blk

*

* \details

* NOTE: The mod input parameter simply chooses a pre-defined

* \brief insert "pre-modulated" preamble symbols before each payload.

* \ingroup ofdm_blk

* \ingroup synchronizers_blk

*

* \details

* <pre>

* constellation points suitable for IFFT input to be used in an

* ofdm modulator.

* \ingroup ofdm_blk

*

* \details

* Abstract class must be subclassed with specific mapping.

/*!

* \brief does the rest of the OFDM stuff

* \ingroup ofdm_blk

*/

class DIGITAL_API ofdm_sampler : virtual public block

{

d_omega_rel(omega_rel), d_max_omega(0), d_min_omega(0),

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

{

d_interp = new gr::filter::mmse_fir_interpolator_cc();

d_dl_idx = 0;

/* -*- c++ -*- */

/*

* Copyright 2006-2008,2010,2011 Free Software Foundation, Inc.

* This file is part of GNU Radio

* GNU Radio is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 3, or (at your option)

* any later version.

* GNU Radio is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with GNU Radio; see the file COPYING. If not, write to

* the Free Software Foundation, Inc., 51 Franklin Street,

namespace gr {

namespace digital {

#define VERBOSE 0

#define M_TWOPI (2*M_PI)

#define MAX_NUM_SYMBOLS 1000

ofdm_frame_acquisition::sptr

ofdm_frame_acquisition::make(unsigned int occupied_carriers,

unsigned int cplen,

const std::vector<gr_complex> &known_symbol,

unsigned int max_fft_shift_len)

}

ofdm_frame_acquisition_impl::ofdm_frame_acquisition_impl(unsigned occupied_carriers,

unsigned int cplen,

const std::vector<gr_complex> &known_symbol,

unsigned int max_fft_shift_len)

d_coarse_freq(0),

d_phase_count(0)

{

d_symbol_phase_diff.resize(d_fft_length);

d_known_phase_diff.resize(d_occupied_carriers);

d_hestimate.resize(d_occupied_carriers);

for(i = 0; i < d_known_symbol.size()-2; i+=2) {

d_known_phase_diff[i] = norm(d_known_symbol[i] - d_known_symbol[i+2]);

}

d_phase_lut = new gr_complex[(2*d_freq_shift_len+1) * MAX_NUM_SYMBOLS];

for(i = 0; i <= 2*d_freq_shift_len; i++) {

for(j = 0; j < MAX_NUM_SYMBOLS; j++) {

ofdm_frame_acquisition_impl::correlate(const gr_complex *symbol, int zeros_on_left)

{

unsigned int i,j;

std::fill(d_symbol_phase_diff.begin(), d_symbol_phase_diff.end(), 0);

for(i = 0; i < d_fft_length-2; i++) {

d_symbol_phase_diff[i] = norm(symbol[i] - symbol[i+2]);

unsigned int i=0;

// Set first tap of equalizer

(coarse_freq_comp(d_coarse_freq,1)*symbol[zeros_on_left+d_coarse_freq]);

// set every even tap based on known symbol

// linearly interpolate between set carriers to set zero-filled carriers

// FIXME: is this the best way to set this?

for(i = 2; i < d_occupied_carriers; i+=2) {

(coarse_freq_comp(d_coarse_freq,1)*(symbol[i+zeros_on_left+d_coarse_freq]));

}

// with even number of carriers; last equalizer tap is wrong

for(i = 0; i < d_occupied_carriers; i++) {

gr_complex sym = coarse_freq_comp(d_coarse_freq,1)*symbol[i+zeros_on_left+d_coarse_freq];

gr_complex output = sym * d_hestimate[i];

sym .real(), sym.imag(),

d_known_symbol[i].real(), d_known_symbol[i].imag(),

d_hestimate[i].real(), d_hestimate[i].imag(),

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

char *signal_out = (char *) output_items[1];

int unoccupied_carriers = d_fft_length - d_occupied_carriers;

int zeros_on_left = (int)ceil(unoccupied_carriers/2.0);

out[i] = d_hestimate[i]*coarse_freq_comp(d_coarse_freq,d_phase_count)

*symbol[i+zeros_on_left+d_coarse_freq];

}

d_phase_count++;

if(d_phase_count == MAX_NUM_SYMBOLS) {

d_phase_count = 1;

/* -*- c++ -*- */

/*

* Copyright 2007,2008,2010-2012 Free Software Foundation, Inc.

* This file is part of GNU Radio

* GNU Radio is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 3, or (at your option)

* any later version.

* GNU Radio is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with GNU Radio; see the file COPYING. If not, write to

* the Free Software Foundation, Inc., 51 Franklin Street,

d_state = STATE_SYNC_SEARCH;

}

inline void

ofdm_frame_sink_impl::enter_have_sync()

{

d_packetlen_cnt = 0;

if(VERBOSE)

d_packetlen, d_packet_whitener_offset);

}

unsigned int min_index = 0;

float min_euclid_dist = norm(x - d_sym_position[0]);

float euclid_dist = 0;

for(unsigned int j = 1; j < table_size; j++){

euclid_dist = norm(x - d_sym_position[j]);

if(euclid_dist < min_euclid_dist){

d_nresid = 0;

d_resid = 0;

}

//while((d_byte_offset < 8) && (i < d_occupied_carriers)) {

while((d_byte_offset < 8) && (i < d_subcarrier_map.size())) {

//gr_complex sigrot = in[i]*carrier*d_dfe[i];

gr_complex sigrot = in[d_subcarrier_map[i]]*carrier*d_dfe[i];

if(d_derotated_output != NULL){

d_derotated_output[i] = sigrot;

}

char bits = slicer(sigrot);

gr_complex closest_sym = d_sym_position[bits];

accum_error += sigrot * conj(closest_sym);

// FIX THE FOLLOWING STATEMENT

if(norm(sigrot)> 0.001)

d_dfe[i] += d_eq_gain*(closest_sym/sigrot-d_dfe[i]);

i++;

if((8 - d_byte_offset) >= d_nbits) {

d_resid = bits >> (8-d_byte_offset);

d_byte_offset += (d_nbits - d_nresid);

}

// in[i-1].real(), in[i-1].imag(), bits, d_partial_byte, d_byte_offset, d_resid, d_nresid);

}

d_phase -= 2*M_PI;

if(d_phase <0)

d_phase += 2*M_PI;

//if(VERBOSE)

// std::cerr << angle << "\t" << d_freq << "\t" << d_phase << "\t" << std::endl;

return bytes_produced;

}

ofdm_frame_sink::sptr

const std::vector<char> &sym_value_out,

msg_queue::sptr target_queue,

int occupied_carriers,

phase_gain, freq_gain));

}

const std::vector<char> &sym_value_out,

msg_queue::sptr target_queue,

int occupied_carriers,

: sync_block("ofdm_frame_sink",

io_signature::make2(2, 2, sizeof(gr_complex)*occupied_carriers, sizeof(char)),

io_signature::make(1, 1, sizeof(gr_complex)*occupied_carriers)),

d_byte_offset(0), d_partial_byte(0),

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

d_phase_gain(phase_gain),d_freq_gain(freq_gain),

d_eq_gain(0.05)

{

std::string carriers = "FE7F";

// A bit hacky to fill out carriers to occupied_carriers length

while(diff > 7) {

carriers.insert(0, "f");

carriers.insert(carriers.length(), "f");

diff -= 8;

}

// if there's extras left to be processed

// divide remaining to put on either side of current map

// all of this is done to stick with the concept of a carrier map string that

int diff_right=0;

// dictionary to convert from integers to ascii hex representation

'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

if(diff > 0) {

char c[2] = {0,0};

diff_left = (int)ceil((float)diff/2.0f); // number of carriers to put on the left side

c[0] = abc[(1 << diff_left) - 1]; // convert to bits and move to ASCI integer

carriers.insert(0, c);

diff_right = diff - diff_left; // number of carriers to put on the right side

c[0] = abc[0xF^((1 << diff_right) - 1)]; // convert to bits and move to ASCI integer

carriers.insert(carriers.length(), c);

}

}

}

// make sure we stay in the limit currently imposed by the occupied_carriers

if(d_subcarrier_map.size() > (size_t)d_occupied_carriers) {

throw std::invalid_argument("ofdm_frame_sink_impl: subcarriers allocated exceeds size of occupied carriers");

fill(d_dfe.begin(), d_dfe.end(), gr_complex(1.0,0.0));

set_sym_value_out(sym_position, sym_value_out);

enter_search();

}

}

bool

const std::vector<char> &sym_value_out)

{

if(sym_position.size() != sym_value_out.size())

d_derotated_output = (gr_complex *)output_items[0];

else

d_derotated_output = NULL;

if(VERBOSE)

fprintf(stderr,">>> Entering state machine\n");

case STATE_SYNC_SEARCH: // Look for flag indicating beginning of pkt

if(VERBOSE)

fprintf(stderr,"SYNC Search, noutput=%d\n", noutput_items);

if(sig[0]) { // Found it, set up for header decode

enter_have_sync();

}

break;

case STATE_HAVE_SYNC:

// equalizer taps will screw with the PLL performance

bytes = demapper(&in[0], d_bytes_out);

if(VERBOSE) {

if(sig[0])

printf("ERROR -- Found SYNC in HAVE_SYNC\n");

while(j < bytes) {

d_header = (d_header << 8) | (d_bytes_out[j] & 0xFF);

j++;

if(++d_headerbytelen_cnt == HEADERBYTELEN) {

if(VERBOSE)

fprintf(stderr, "got header: 0x%08x\n", d_header);

// we have a full header, check to see if it has been received properly

if(header_ok()) {

enter_have_header();

if(VERBOSE)

printf("\nPacket Length: %d\n", d_packetlen);

while((j < bytes) && (d_packetlen_cnt < d_packetlen)) {

d_packet[d_packetlen_cnt++] = d_bytes_out[j++];

}

if(d_packetlen_cnt == d_packetlen) {

message::sptr msg =

message::make(0, d_packet_whitener_offset, 0, d_packetlen);

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

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

msg.reset(); // free it up

enter_search();

}

}

}

}

break;

case STATE_HAVE_HEADER:

bytes = demapper(&in[0], d_bytes_out);

printf("ERROR -- Found SYNC in HAVE_HEADER at %d, length of %d\n", d_packetlen_cnt, d_packetlen);

fprintf(stderr,"Packet Build\n");

}

j = 0;

while(j < bytes) {

d_packet[d_packetlen_cnt++] = d_bytes_out[j++];

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

// build a message

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

message::sptr msg =

message::make(0, d_packet_whitener_offset, 0, d_packetlen_cnt);

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

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

msg.reset(); // free it up

enter_search();

break;

}

}

break;

default:

assert(0);

} // switch

/* -*- c++ -*- */

/*

* Copyright 2007,2010-2012 Free Software Foundation, Inc.

* This file is part of GNU Radio

* GNU Radio is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 3, or (at your option)

* any later version.

* GNU Radio is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License along

* with this program; if not, write to the Free Software Foundation, Inc.,

* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

namespace gr {

namespace digital {

ofdm_insert_preamble::sptr

ofdm_insert_preamble::make(int fft_length,

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

d_pending_flag(0),

d_preamble(preamble)

{

// sanity check preamble symbols

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

if(d_preamble[i].size() != (size_t) d_fft_length)

else

ni++; // eat one input symbol

break;

case ST_PREAMBLE:

assert(!in_flag || in_flag[ni] & 0x1);

if(d_nsymbols_output >= (int) d_preamble.size()) {

d_nsymbols_output++;

}

break;

case ST_FIRST_PAYLOAD:

// copy first payload symbol from input to output

memcpy(&out_sym[no * d_fft_length],

ni++;

enter_payload();

break;

case ST_PAYLOAD:

if(in_flag && in_flag[ni] & 0x1) { // this is first symbol of a new payload

enter_preamble();

/* -*- c++ -*- */

/*

* Copyright 2006-2008,2010-2012 Free Software Foundation, Inc.

* This file is part of GNU Radio

* GNU Radio is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 3, or (at your option)

* any later version.

* GNU Radio is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with GNU Radio; see the file COPYING. If not, write to

* the Free Software Foundation, Inc., 51 Franklin Street,

ofdm_mapper_bcv::sptr

ofdm_mapper_bcv::make(const std::vector<gr_complex> &constellation,

unsigned int occupied_carriers,

unsigned int fft_length)

{

return gnuradio::get_initial_sptr

occupied_carriers, fft_length));

}

// Consumes 1 packet and produces as many OFDM symbols of

// fft_length to hold the full packet

ofdm_mapper_bcv_impl::ofdm_mapper_bcv_impl(const std::vector<gr_complex> &constellation,

unsigned int occupied_carriers,

unsigned int fft_length)

: sync_block("ofdm_mapper_bcv",

d_resid(0),

d_nresid(0)

{

if(!(d_occupied_carriers <= d_fft_length))

throw std::invalid_argument("ofdm_mapper_bcv_impl: occupied carriers must be <= fft_length");

std::string carriers = "FE7F";

// A bit hacky to fill out carriers to occupied_carriers length

while(diff > 7) {

carriers.insert(0, "f");

carriers.insert(carriers.length(), "f");

int diff_right=0;

// dictionary to convert from integers to ascii hex representation

'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

if(diff > 0) {

char c[2] = {0,0};

diff_left = (int)ceil((float)diff/2.0f); // number of carriers to put on the left side

c[0] = abc[(1 << diff_left) - 1]; // convert to bits and move to ASCI integer

carriers.insert(0, c);

diff_right = diff - diff_left; // number of carriers to put on the right side

c[0] = abc[0xF^((1 << diff_right) - 1)]; // convert to bits and move to ASCI integer

carriers.insert(carriers.length(), c);

}

// find out how many zeros to pad on the sides; the difference between the fft length and the subcarrier

unsigned int i,j,k;

for(i = 0; i < carriers.length(); i++) {

char c = carriers[i]; // get the current hex character from the string

for(j = 0; j < 4; j++) { // walk through all four bits

k = (strtol(&c, NULL, 16) >> (3-j)) & 0x1; // convert to int and extract next bit

d_subcarrier_map.push_back(4*(i+diff) + j); // use this subcarrier

}

}

if(d_subcarrier_map.size() > d_occupied_carriers) {

throw std::invalid_argument("ofdm_mapper_bcv_impl: subcarriers allocated exceeds size of occupied carriers");

}

d_nbits = (unsigned long)ceil(log10(float(d_constellation.size())) / log10(2.0));

}

gr_vector_void_star &output_items)

{

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

unsigned int i=0;

//printf("OFDM BPSK Mapper: ninput_items: %d noutput_items: %d\n", ninput_items[0], noutput_items);

if(d_eof) {

return -1;

}

if(!d_msg) {

d_msg = d_msgq->delete_head(); // block, waiting for a message

d_msg_offset = 0;

d_bit_offset = 0;

d_pending_flag = 1; // new packet, write start of packet flag

if((d_msg->length() == 0) && (d_msg->type() == 1)) {

d_msg.reset();

return -1; // We're done; no more messages coming.

char *out_flag = 0;

if(output_items.size() == 2)

out_flag = (char *) output_items[1];

// Build a single symbol:

// Initialize all bins to 0 to set unused carriers

memset(out, 0, d_fft_length*sizeof(gr_complex));

i = 0;

unsigned char bits = 0;

//while((d_msg_offset < d_msg->length()) && (i < d_occupied_carriers)) {

d_bit_offset += d_nresid;

d_nresid = 0;

d_resid = 0;

// bits, d_resid, d_nresid, d_bit_offset);

}

else {

// take the nbits number of bits at a time from the byte to add to the symbol

bits = ((1 << d_nbits)-1) & (d_msgbytes >> d_bit_offset);

d_bit_offset += d_nbits;

out[d_subcarrier_map[i]] = d_constellation[bits];

i++;

}

// saves d_nresid bits of this message where d_nresid < d_nbits

unsigned int extra = 8-d_bit_offset;

d_resid = ((1 << extra)-1) & (d_msgbytes >> d_bit_offset);

d_nresid = d_nbits - extra;

}

}

if(d_bit_offset == 8) {

d_bit_offset = 0;

d_msg_offset++;

/* -*- c++ -*- */

/*

* Copyright 2007,2008,2010-2012 Free Software Foundation, Inc.

* This file is part of GNU Radio

* GNU Radio is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 3, or (at your option)

* any later version.

* GNU Radio is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with GNU Radio; see the file COPYING. If not, write to

* the Free Software Foundation, Inc., 51 Franklin Street,

namespace gr {

namespace digital {

ofdm_sampler::sptr

unsigned int symbol_length,

unsigned int timeout)

{

(new ofdm_sampler_impl(fft_length, symbol_length, timeout));

}

unsigned int symbol_length,

unsigned int timeout)

: block("ofdm_sampler",

d_state(STATE_NO_SIG), d_timeout_max(timeout),

d_fft_length(fft_length), d_symbol_length(symbol_length)

{

set_relative_rate(1.0/(double) fft_length); // buffer allocator hint

}

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

char *outsig = (char*)output_items[1];

// process a few at a time as long as we always look out for the next preamble.

unsigned int index = d_fft_length; // start one fft length into the input so we can always look back this far

else

index++;

}

unsigned int i, pos, ret;

switch(d_state) {

case(STATE_PREAMBLE):

for(i = (index - d_fft_length + 1); i <= index; i++) {

*optr++ = iptr[i];

}

d_timeout = d_timeout_max; // tell the system to expect at least this many symbols for a frame

d_state = STATE_FRAME;

consume_each(index - d_fft_length + 1); // consume up to one fft_length away to keep the history

ret = 1;

break;

case(STATE_FRAME):

// use this state when we have processed a preamble and are getting the rest of the frames

//FIXME: we could also have a power squelch system here to enter STATE_NO_SIG if no power is received

#connect

self.connect(msg_source, self)

def send_pkt(self, payload):

"""

Wrap the payload in a packet and push onto the message queue.

#start thread

_packet_decoder_thread(msgq, callback)

##################################################

## Packet Mod for OFDM Mod and Packet Encoder

##################################################

#

# This file is part of GNU Radio

#

include(GrSwig)

set(GR_SWIG_INCLUDE_DIRS

)

if(ENABLE_GR_CTRLPORT)

list(APPEND GR_SWIG_FLAGS "-DGR_CTRLPORT")

endif(ENABLE_GR_CTRLPORT)

${CMAKE_CURRENT_SOURCE_DIR}/../include/gnuradio/digital

${CMAKE_CURRENT_BINARY_DIR}/../include/gnuradio/digital

)

)

A test Transport Stream for the example flow graph

(8 Msyms/s and 7/8 code rate) is available here:

<?xml version='1.0' encoding='utf-8'?>

<flow_graph>

<timestamp>Thu Feb 20 21:02:41 2014</timestamp>

<block>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>generate_options</key>

</param>

<param>

<key>hier_block_src_path</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>value</key>

</param>

</block>

<block>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

</block>

<block>

<param>

<key>comment</key>

<value></value>

</param>

<param>

<key>value</key>

</param>

<param>

<key>_enabled</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

<value>0</value>

</param>

<param>

<value></value>

</param>

<param>

<key>id</key>

<value>vga1_gain</value>

</param>

<param>

<key>label</key>

</param>

<param>

</param>

<param>

<value>-35</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

</block>

<block>

<param>

<key>comment</key>

<value></value>

</param>

<param>

<key>value</key>

<value>10</value>

</param>

<param>

<key>_enabled</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

</param>

<param>

</param>

<param>

<key>id</key>

</param>

<param>

<key>label</key>

</param>

<param>

</param>

<param>

<value>0</value>

</param>

<param>

</param>

<param>

<value>25</value>

</param>

<param>

</param>

</block>

<block>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

<value></value>

</param>

<param>

</param>

<param>

<key>comment</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

<param>

<key>_enabled</key>

</param>

<param>

<key>_coordinate</key>

</param>

<param>

<key>_rotation</key>

</param>

</block>

<block>

<param>

</param>

<param>

<key>average</key>

<value>True</value>

</param>

<param>

</param>

<param>

<key>alias</key>

<value></value>

</param>

<param>

<key>comment</key>

<value></value>

</param>

<param>

<key>affinity</key>

<value></value>

</param>

<param>

<key>_enabled</key>

</param>

<param>

<value>1024</value>

</param>

<param>

</param>

<param>

</param>

<param>

<key>_rotation</key>

<value>0</value>

</param>

<param>

</param>

<param>

<key>id</key>

</param>

<param>

<value></value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

<param>

<key>type</key>

<value>complex</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

<param>

<value>10</value>

</param>

</block>

<connection>

<source_block_id>blocks_file_source_0</source_block_id>

</connection>

<connection>

<source_block_id>fft_filter_xxx_0</source_block_id>

<source_key>0</source_key>

<sink_key>0</sink_key>

</connection>

<?xml version='1.0' encoding='utf-8'?>

<flow_graph>

<timestamp>Wed Sep 3 03:03:39 2014</timestamp>

<block>

</param>

<param>

<key>generate_options</key>

</param>

<param>

<key>hier_block_src_path</key>

</param>

<param>

<key>id</key>

</param>

<param>

<key>value</key>

</param>

</block>

<block>