- - digital_ofdm_mod

- - digital_ofdm_demod

- - digital_ofdm_frame_acquisition

- - digital_ofdm_frame_sink

- - digital_ofdm_insert_preamble

- - digital_ofdm_sampler

- - digital_ofdm_sync_pn

- - digital_ofdm_sync_sc_cfb

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

-/*

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

- *

- * This file is part of GNU Radio

- *

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

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

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

- * any later version.

- *

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

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

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

- * GNU General Public License for more details.

- *

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

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

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

- * Boston, MA 02110-1301, USA.

- */

-

-#ifdef HAVE_CONFIG_H

-#include "config.h"

-#endif

-

-#include "ofdm_frame_acquisition_impl.h"

-#include <gnuradio/expj.h>

-#include <gnuradio/io_signature.h>

-#include <gnuradio/math.h>

-#include <cstdio>

-

-namespace gr {

-namespace digital {

-

-#define VERBOSE 0

-#define MAX_NUM_SYMBOLS 1000

-

-ofdm_frame_acquisition::sptr

-ofdm_frame_acquisition::make(unsigned int occupied_carriers,

- unsigned int fft_length,

- unsigned int cplen,

- const std::vector<gr_complex>& known_symbol,

- unsigned int max_fft_shift_len)

-{

- return gnuradio::get_initial_sptr(new ofdm_frame_acquisition_impl(

- occupied_carriers, fft_length, cplen, known_symbol, max_fft_shift_len));

-}

-

-ofdm_frame_acquisition_impl::ofdm_frame_acquisition_impl(

- unsigned occupied_carriers,

- unsigned int fft_length,

- unsigned int cplen,

- const std::vector<gr_complex>& known_symbol,

- unsigned int max_fft_shift_len)

- : block("ofdm_frame_acquisition",

- io_signature::make2(

- 2, 2, sizeof(gr_complex) * fft_length, sizeof(char) * fft_length),

- io_signature::make2(

- 2, 2, sizeof(gr_complex) * occupied_carriers, sizeof(char))),

- d_occupied_carriers(occupied_carriers),

- d_fft_length(fft_length),

- d_cplen(cplen),

- d_freq_shift_len(max_fft_shift_len),

- d_known_symbol(known_symbol),

- d_coarse_freq(0),

- d_phase_count(0)

-{

- GR_LOG_WARN(d_logger,

- "The gr::digital::ofdm_frame_acquisition block has been deprecated.");

-

- d_symbol_phase_diff.resize(d_fft_length);

- d_known_phase_diff.resize(d_occupied_carriers);

- d_hestimate.resize(d_occupied_carriers);

-

- unsigned int i = 0, j = 0;

-

- std::fill(d_known_phase_diff.begin(), d_known_phase_diff.end(), 0);

- 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++) {

- d_phase_lut[j + i * MAX_NUM_SYMBOLS] = gr_expj(

- -GR_M_TWOPI * d_cplen / d_fft_length * (i - d_freq_shift_len) * j);

- }

- }

-}

-

-ofdm_frame_acquisition_impl::~ofdm_frame_acquisition_impl() { delete[] d_phase_lut; }

-

-void ofdm_frame_acquisition_impl::forecast(int noutput_items,

- gr_vector_int& ninput_items_required)

-{

- unsigned ninputs = ninput_items_required.size();

- for (unsigned i = 0; i < ninputs; i++)

- ninput_items_required[i] = 1;

-}

-

-gr_complex ofdm_frame_acquisition_impl::coarse_freq_comp(int freq_delta, int symbol_count)

-{

- // return gr_complex(cos(-GR_M_TWOPI*freq_delta*d_cplen/d_fft_length*symbol_count),

- // sin(-GR_M_TWOPI*freq_delta*d_cplen/d_fft_length*symbol_count));

-

- return gr_expj(-GR_M_TWOPI * freq_delta * d_cplen / d_fft_length * symbol_count);

-

- // return d_phase_lut[MAX_NUM_SYMBOLS * (d_freq_shift_len + freq_delta) +

- // symbol_count];

-}

-

-void 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]);

- }

-

- // sweep through all possible/allowed frequency offsets and select the best

- int index = 0;

- float max = 0, sum = 0;

- for (i = zeros_on_left - d_freq_shift_len; i < zeros_on_left + d_freq_shift_len;

- i++) {

- sum = 0;

- for (j = 0; j < d_occupied_carriers; j++) {

- sum += (d_known_phase_diff[j] * d_symbol_phase_diff[i + j]);

- }

- if (sum > max) {

- max = sum;

- index = i;

- }

- }

-

- // set the coarse frequency offset relative to the edge of the occupied tones

- d_coarse_freq = index - zeros_on_left;

-}

-

-void ofdm_frame_acquisition_impl::calculate_equalizer(const gr_complex* symbol,

- int zeros_on_left)

-{

- unsigned int i = 0;

-

- // Set first tap of equalizer

- d_hestimate[0] = d_known_symbol[0] / (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) {

- d_hestimate[i] =

- d_known_symbol[i] / (coarse_freq_comp(d_coarse_freq, 1) *

- (symbol[i + zeros_on_left + d_coarse_freq]));

- d_hestimate[i - 1] = (d_hestimate[i] + d_hestimate[i - 2]) / gr_complex(2.0, 0.0);

- }

-

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

- if (!(d_occupied_carriers & 1)) {

- d_hestimate[d_occupied_carriers - 1] = d_hestimate[d_occupied_carriers - 2];

- }

-

- if (VERBOSE) {

- fprintf(stderr, "Equalizer setting:\n");

- 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];

- fprintf(stderr,

- "sym: %+.4f + j%+.4f ks: %+.4f + j%+.4f eq: %+.4f + j%+.4f ==> "

- "%+.4f + j%+.4f\n",

- sym.real(),

- sym.imag(),

- d_known_symbol[i].real(),

- d_known_symbol[i].imag(),

- d_hestimate[i].real(),

- d_hestimate[i].imag(),

- output.real(),

- output.imag());

- }

- fprintf(stderr, "\n");

- }

-}

-

-int ofdm_frame_acquisition_impl::general_work(int noutput_items,

- gr_vector_int& ninput_items,

- gr_vector_const_void_star& input_items,

- gr_vector_void_star& output_items)

-{

- const gr_complex* symbol = (const gr_complex*)input_items[0];

- const char* signal_in = (const char*)input_items[1];

-

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

-

- if (signal_in[0]) {

- d_phase_count = 1;

- correlate(symbol, zeros_on_left);

- calculate_equalizer(symbol, zeros_on_left);

- signal_out[0] = 1;

- } else {

- signal_out[0] = 0;

- }

-

- for (unsigned int i = 0; i < d_occupied_carriers; i++) {

- 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;

- }

-

- consume_each(1);

- return 1;

-}

-

-} /* namespace digital */

-} /* namespace gr */

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

-/*

- * Copyright 2006,2007,2011,2012 Free Software Foundation, Inc.

- *

- * This file is part of GNU Radio

- *

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

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

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

- * any later version.

- *

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

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

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

- * GNU General Public License for more details.

- *

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

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

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

- * Boston, MA 02110-1301, USA.

- */

-

-#ifndef INCLUDED_DIGITAL_OFDM_FRAME_ACQUISITION_IMPL_H

-#define INCLUDED_DIGITAL_OFDM_FRAME_ACQUISITION_IMPL_H

-

-#include <gnuradio/digital/ofdm_frame_acquisition.h>

-

-namespace gr {

-namespace digital {

-

-class ofdm_frame_acquisition_impl : public ofdm_frame_acquisition

-{

-private:

- unsigned char slicer(gr_complex x);

- void correlate(const gr_complex* symbol, int zeros_on_left);

- void calculate_equalizer(const gr_complex* symbol, int zeros_on_left);

- gr_complex coarse_freq_comp(int freq_delta, int count);

-

- unsigned int d_occupied_carriers; // !< \brief number of subcarriers with data

- unsigned int d_fft_length; // !< \brief length of FFT vector

- unsigned int d_cplen; // !< \brief length of cyclic prefix in samples

- unsigned int d_freq_shift_len; // !< \brief number of surrounding bins to look at for

- // correlation

- std::vector<gr_complex> d_known_symbol; // !< \brief known symbols at start of frame

- std::vector<float>

- d_known_phase_diff; // !< \brief factor used in correlation from known symbol

- std::vector<float>

- d_symbol_phase_diff; // !< \brief factor used in correlation from received symbol

- std::vector<gr_complex> d_hestimate; // !< channel estimate

- int d_coarse_freq; // !< \brief search distance in number of bins

- unsigned int d_phase_count; // !< \brief accumulator for coarse freq correction

- float d_snr_est; // !< an estimation of the signal to noise ratio

-

- gr_complex* d_phase_lut; // !< look-up table for coarse frequency compensation

-

- void forecast(int noutput_items, gr_vector_int& ninput_items_required);

-

-public:

- ofdm_frame_acquisition_impl(unsigned int occupied_carriers,

- unsigned int fft_length,

- unsigned int cplen,

- const std::vector<gr_complex>& known_symbol,

- unsigned int max_fft_shift_len = 4);

- ~ofdm_frame_acquisition_impl();

-

- /*!

- * \brief Return an estimate of the SNR of the channel

- */

- float snr() { return d_snr_est; }

-

- int general_work(int noutput_items,

- gr_vector_int& ninput_items,

- gr_vector_const_void_star& input_items,

- gr_vector_void_star& output_items);

-};

-

-} /* namespace digital */

-} /* namespace gr */

-

-#endif /* INCLUDED_DIGITAL_OFDM_FRAME_ACQUISITION_IMPL_H */

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

-/*

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

- *

- * This file is part of GNU Radio

- *

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

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

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

- * any later version.

- *

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

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

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

- * GNU General Public License for more details.

- *

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

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

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

- * Boston, MA 02110-1301, USA.

- */

-

-#ifdef HAVE_CONFIG_H

-#include "config.h"

-#endif

-

-#include "ofdm_frame_sink_impl.h"

-#include <gnuradio/expj.h>

-#include <gnuradio/io_signature.h>

-#include <gnuradio/math.h>

-#include <cmath>

-#include <cstdio>

-#include <iostream>

-#include <stdexcept>

-#include <string>

-

-namespace gr {

-namespace digital {

-

-#define VERBOSE 0

-

-inline void ofdm_frame_sink_impl::enter_search()

-{

- if (VERBOSE)

- fprintf(stderr, "@ enter_search\n");

-

- d_state = STATE_SYNC_SEARCH;

-}

-

-inline void ofdm_frame_sink_impl::enter_have_sync()

-{

- if (VERBOSE)

- fprintf(stderr, "@ enter_have_sync\n");

-

- d_state = STATE_HAVE_SYNC;

-

- // clear state of demapper

- d_byte_offset = 0;

- d_partial_byte = 0;

-

- d_header = 0;

- d_headerbytelen_cnt = 0;

-

- // Resetting PLL

- d_freq = 0.0;

- d_phase = 0.0;

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

-}

-

-inline void ofdm_frame_sink_impl::enter_have_header()

-{

- d_state = STATE_HAVE_HEADER;

-

- // header consists of two 16-bit shorts in network byte order

- // payload length is lower 12 bits

- // whitener offset is upper 4 bits

- d_packetlen = (d_header >> 16) & 0x0fff;

- d_packet_whitener_offset = (d_header >> 28) & 0x000f;

- d_packetlen_cnt = 0;

-

- if (VERBOSE)

- fprintf(stderr,

- "@ enter_have_header (payload_len = %d) (offset = %d)\n",

- d_packetlen,

- d_packet_whitener_offset);

-}

-

-char ofdm_frame_sink_impl::slicer(const gr_complex x)

-{

- unsigned int table_size = d_sym_value_out.size();

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

- min_euclid_dist = euclid_dist;

- min_index = j;

- }

- }

- return d_sym_value_out[min_index];

-}

-

-unsigned int ofdm_frame_sink_impl::demapper(const gr_complex* in, char* out)

-{

- unsigned int i = 0, bytes_produced = 0;

- gr_complex carrier;

-

- carrier = gr_expj(d_phase);

-

- gr_complex accum_error = 0.0;

- // while(i < d_occupied_carriers) {

- while (i < d_subcarrier_map.size()) {

- if (d_nresid > 0) {

- d_partial_byte |= d_resid;

- d_byte_offset += d_nresid;

- 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_partial_byte |= bits << (d_byte_offset);

- d_byte_offset += d_nbits;

- } else {

- d_nresid = d_nbits - (8 - d_byte_offset);

- int mask = ((1 << (8 - d_byte_offset)) - 1);

- d_partial_byte |= (bits & mask) << d_byte_offset;

- d_resid = bits >> (8 - d_byte_offset);

- d_byte_offset += (d_nbits - d_nresid);

- }

- // printf("demod symbol: %.4f + j%.4f bits: %x partial_byte: %x

- // byte_offset: %d resid: %x nresid: %d\n",

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

- // d_resid, d_nresid);

- }

-

- if (d_byte_offset == 8) {

- // printf("demod byte: %x \n\n", d_partial_byte);

- out[bytes_produced++] = d_partial_byte;

- d_byte_offset = 0;

- d_partial_byte = 0;

- }

- }

- // std::cerr << "accum_error " << accum_error << std::endl;

-

- float angle = arg(accum_error);

-

- d_freq = d_freq - d_freq_gain * angle;

- d_phase = d_phase + d_freq - d_phase_gain * angle;

- if (d_phase >= 2 * GR_M_PI)

- d_phase -= 2 * GR_M_PI;

- if (d_phase < 0)

- d_phase += 2 * GR_M_PI;

-

- // if(VERBOSE)

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

-

- return bytes_produced;

-}

-

-

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

- const std::vector<char>& sym_value_out,

- msg_queue::sptr target_queue,

- int occupied_carriers,

- float phase_gain,

- float freq_gain)

-{

- return gnuradio::get_initial_sptr(new ofdm_frame_sink_impl(sym_position,

- sym_value_out,

- target_queue,

- occupied_carriers,

- phase_gain,

- freq_gain));

-}

-

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

- const std::vector<char>& sym_value_out,

- msg_queue::sptr target_queue,

- int occupied_carriers,

- float phase_gain,

- float freq_gain)

- : 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_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),

- d_phase_gain(phase_gain),

- d_freq_gain(freq_gain),

- d_eq_gain(0.05)

-{

- GR_LOG_WARN(d_logger, "The gr::digital::ofdm_frame_sync block has been deprecated.");

-

- std::string carriers = "FE7F";

-

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

- int diff = (d_occupied_carriers - 4 * 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

- // can be later passed by the user, even though it'd be cleaner to just do this

- // on the carrier map itself

- int diff_left = 0;

- int diff_right = 0;

-

- // dictionary to convert from integers to ascii hex representation

- char abc[16] = { '0', '1', '2', '3', '4', '5', '6', '7',

- '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);

- }

-

- // It seemed like such a good idea at the time...

- // because we are only dealing with the occupied_carriers

- // at this point, the diff_left in the following compensates

- // for any offset from the 0th carrier introduced

- int i;

- unsigned int j, k;

- for (i = 0; i < (d_occupied_carriers / 4) + diff_left; i++) {

- char c = carriers[i];

- for (j = 0; j < 4; j++) {

- k = (strtol(&c, NULL, 16) >> (3 - j)) & 0x1;

- if (k) {

- d_subcarrier_map.push_back(4 * i + j - diff_left);

- }

- }

- }

-

- // 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");

- }

-

- d_bytes_out = new char[d_occupied_carriers];

- d_dfe.resize(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();

-}

-

-ofdm_frame_sink_impl::~ofdm_frame_sink_impl() { delete[] d_bytes_out; }

-

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

- const std::vector<char>& sym_value_out)

-{

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

- return false;

-

- if (sym_position.size() < 1)

- return false;

-

- d_sym_position = sym_position;

- d_sym_value_out = sym_value_out;

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

-

- return true;

-}

-

-int ofdm_frame_sink_impl::work(int noutput_items,

- gr_vector_const_void_star& input_items,

- gr_vector_void_star& output_items)

-{

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

- const char* sig = (const char*)input_items[1];

- unsigned int j = 0;

- unsigned int bytes = 0;

-

- // If the output is connected, send it the derotated symbols

- if (output_items.size() >= 1)

- d_derotated_output = (gr_complex*)output_items[0];

- else

- d_derotated_output = NULL;

-

- if (VERBOSE)

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

-

- switch (d_state) {

- 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:

- // only demod after getting the preamble signal; otherwise, the

- // 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");

- fprintf(stderr,

- "Header Search bitcnt=%d, header=0x%08x\n",

- d_headerbytelen_cnt,

- d_header);

- }

-

- j = 0;

- 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();

- }

- } else {

- enter_search(); // bad header

- }

- }

- }

- break;

-

- case STATE_HAVE_HEADER:

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

-

- if (VERBOSE) {

- if (sig[0])

- 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

-

- return 1;

-}

-

-} /* namespace digital */

-} /* namespace gr */

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

-/*

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

- *

- * This file is part of GNU Radio

- *

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

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

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

- * any later version.

- *

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

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

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

- * GNU General Public License for more details.

- *

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

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

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

- * Boston, MA 02110-1301, USA.

- */

-

-#ifndef INCLUDED_DIGITAL_OFDM_FRAME_SINK_IMPL_H

-#define INCLUDED_DIGITAL_OFDM_FRAME_SINK_IMPL_H

-

-#include <gnuradio/digital/ofdm_frame_sink.h>

-

-namespace gr {

-namespace digital {

-

-class ofdm_frame_sink_impl : public ofdm_frame_sink

-{

-private:

- enum state_t { STATE_SYNC_SEARCH, STATE_HAVE_SYNC, STATE_HAVE_HEADER };

-

- static constexpr int MAX_PKT_LEN = 4096;

- static constexpr int HEADERBYTELEN = 4;

-

- msg_queue::sptr d_target_queue; // where to send the packet when received

- state_t d_state;

- unsigned int d_header; // header bits

- int d_headerbytelen_cnt; // how many so far

-

- char* d_bytes_out; // hold the current bytes produced by the demapper

-

- int d_occupied_carriers;

- unsigned int d_byte_offset;

- unsigned int d_partial_byte;

-

- char d_packet[MAX_PKT_LEN]; // assembled payload

- int d_packetlen; // length of packet

- int d_packet_whitener_offset; // offset into whitener string to use

- int d_packetlen_cnt; // how many so far

-

- gr_complex*

- d_derotated_output; // Pointer to output stream to send deroated symbols out

-

- std::vector<gr_complex> d_sym_position;

- std::vector<char> d_sym_value_out;

- std::vector<gr_complex> d_dfe;

- unsigned int d_nbits;

-

- char d_resid;

- unsigned int d_nresid;

- float d_phase;

- float d_freq;

- float d_phase_gain;

- float d_freq_gain;

- float d_eq_gain;

-

- std::vector<int> d_subcarrier_map;

-

-protected:

- void enter_search();

- void enter_have_sync();

- void enter_have_header();

-

- bool header_ok()

- {

- // confirm that two copies of header info are identical

- return ((d_header >> 16) ^ (d_header & 0xffff)) == 0;

- }

-

- char slicer(const gr_complex x);

- unsigned int demapper(const gr_complex* in, char* out);

-

- bool set_sym_value_out(const std::vector<gr_complex>& sym_position,

- const std::vector<char>& sym_value_out);

-

-public:

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

- const std::vector<char>& sym_value_out,

- msg_queue::sptr target_queue,

- int occupied_tones,

- float phase_gain = 0.25,

- float freq_gain = 0.25 * 0.25 / 4);

- ~ofdm_frame_sink_impl();

-

- int work(int noutput_items,

- gr_vector_const_void_star& input_items,

- gr_vector_void_star& output_items);

-};

-

-} /* namespace digital */

-} /* namespace gr */

-

-#endif /* INCLUDED_GR_OFDM_FRAME_SINK_IMPL_H */

-/* -*- 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.

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-

-#include "ofdm_insert_preamble_impl.h"

-#include <gnuradio/io_signature.h>

-#include <iostream>

-#include <stdexcept>

-#include <string>

-

-namespace gr {

-namespace digital {

-

-ofdm_insert_preamble::sptr

-ofdm_insert_preamble::make(int fft_length,

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

-{

- return gnuradio::get_initial_sptr(

- new ofdm_insert_preamble_impl(fft_length, preamble));

-}

-

-ofdm_insert_preamble_impl::ofdm_insert_preamble_impl(

- int fft_length, const std::vector<std::vector<gr_complex>>& preamble)

- : block("ofdm_insert_preamble",

- io_signature::make2(1, 2, sizeof(gr_complex) * fft_length, sizeof(char)),

- io_signature::make2(1, 2, sizeof(gr_complex) * fft_length, sizeof(char))),

- d_fft_length(fft_length),

- d_state(ST_IDLE),

- d_nsymbols_output(0),

- d_pending_flag(0),

- d_preamble(preamble)

-{

- GR_LOG_WARN(d_logger,

- "The gr::digital::ofdm_insert_preamble block has been deprecated.");

-

- // sanity check preamble symbols

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

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

- throw std::invalid_argument(

- "ofdm_insert_preamble_impl: invalid length for preamble symbol");

- }

-

- enter_idle();

-}

-

-

-ofdm_insert_preamble_impl::~ofdm_insert_preamble_impl() {}

-

-void ofdm_insert_preamble_impl::forecast(int noutput_items,

- gr_vector_int& ninput_items_required)

-{

- ninput_items_required[0] = noutput_items;

-}

-

-int ofdm_insert_preamble_impl::general_work(int noutput_items,

- gr_vector_int& ninput_items_v,

- gr_vector_const_void_star& input_items,

- gr_vector_void_star& output_items)

-{

- int ninput_items = ninput_items_v.size() == 2

- ? std::min(ninput_items_v[0], ninput_items_v[1])

- : ninput_items_v[0];

-

- const gr_complex* in_sym = (const gr_complex*)input_items[0];

- const unsigned char* in_flag = 0;

-

- if (input_items.size() == 2)

- in_flag = (const unsigned char*)input_items[1];

-

- gr_complex* out_sym = (gr_complex*)output_items[0];

- unsigned char* out_flag = 0;

- if (output_items.size() == 2)

- out_flag = (unsigned char*)output_items[1];

-

- int no = 0; // number items output

- int ni = 0; // number items read from input

-

-#define write_out_flag() \

- do { \

- if (out_flag) \

- out_flag[no] = d_pending_flag; \

- d_pending_flag = 0; \

- } while (0)

-

- while (no < noutput_items && ni < ninput_items) {

- switch (d_state) {

- case ST_IDLE:

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

- enter_preamble();

- 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()) {

- // we've output all the preamble

- enter_first_payload();

- } else {

- memcpy(&out_sym[no * d_fft_length],

- &d_preamble[d_nsymbols_output][0],

- d_fft_length * sizeof(gr_complex));

-

- write_out_flag();

- no++;

- d_nsymbols_output++;

- }

- break;

-

- case ST_FIRST_PAYLOAD:

- // copy first payload symbol from input to output

- memcpy(&out_sym[no * d_fft_length],

- &in_sym[ni * d_fft_length],

- d_fft_length * sizeof(gr_complex));

-

- write_out_flag();

- no++;

- ni++;

- enter_payload();

- break;

-

- case ST_PAYLOAD:

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

- enter_preamble();

- break;

- }

-

- // copy a symbol from input to output

- memcpy(&out_sym[no * d_fft_length],

- &in_sym[ni * d_fft_length],

- d_fft_length * sizeof(gr_complex));

-

- write_out_flag();

- no++;

- ni++;

- break;

-

- default:

- std::cerr

- << "ofdm_insert_preamble_impl: (can't happen) invalid state, resetting\n";

- enter_idle();

- }

- }

-

- consume_each(ni);

- return no;

-}

-

-void ofdm_insert_preamble_impl::enter_idle()

-{

- d_state = ST_IDLE;

- d_nsymbols_output = 0;

- d_pending_flag = 0;

-}

-

-void ofdm_insert_preamble_impl::enter_preamble()

-{

- d_state = ST_PREAMBLE;

- d_nsymbols_output = 0;

- d_pending_flag = 1;

-}

-

-void ofdm_insert_preamble_impl::enter_first_payload() { d_state = ST_FIRST_PAYLOAD; }

-

-void ofdm_insert_preamble_impl::enter_payload() { d_state = ST_PAYLOAD; }

-

-} /* namespace digital */

-} /* namespace gr */

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

-/*

- * Copyright 2007,2011,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.

- */

-

-#ifndef INCLUDED_DIGITAL_OFDM_INSERT_PREAMBLE_IMPL_H

-#define INCLUDED_DIGITAL_OFDM_INSERT_PREAMBLE_IMPL_H

-

-#include <gnuradio/digital/ofdm_insert_preamble.h>

-

-namespace gr {

-namespace digital {

-

-class ofdm_insert_preamble_impl : public ofdm_insert_preamble

-{

-private:

- enum state_t { ST_IDLE, ST_PREAMBLE, ST_FIRST_PAYLOAD, ST_PAYLOAD };

-

- int d_fft_length;

- state_t d_state;

- int d_nsymbols_output;

- int d_pending_flag;

- const std::vector<std::vector<gr_complex>> d_preamble;

-

- void enter_idle();

- void enter_first_payload();

- void enter_payload();

-

-public:

- ofdm_insert_preamble_impl(int fft_length,

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

- ~ofdm_insert_preamble_impl();

-

- void enter_preamble();

-

- int general_work(int noutput_items,

- gr_vector_int& ninput_items,

- gr_vector_const_void_star& input_items,

- gr_vector_void_star& output_items);

- void forecast(int noutput_items, gr_vector_int& ninput_items_required);

-};

-

-} /* namespace digital */

-} /* namespace gr */

-

-#endif /* INCLUDED_DIGITAL_OFDM_INSERT_PREAMBLE_IMPL_H */

-/* -*- 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,

- * Boston, MA 02110-1301, USA.

- */

-

-#ifdef HAVE_CONFIG_H

-#include "config.h"

-#endif

-

-#include "ofdm_mapper_bcv_impl.h"

-#include <gnuradio/io_signature.h>

-#include <stdexcept>

-#include <string>

-

-namespace gr {

-namespace digital {

-

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

- unsigned int msgq_limit,

- unsigned int occupied_carriers,

- unsigned int fft_length)

-{

- return gnuradio::get_initial_sptr(new ofdm_mapper_bcv_impl(

- constellation, msgq_limit, 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 msgq_limit,

- unsigned int occupied_carriers,

- unsigned int fft_length)

- : sync_block(

- "ofdm_mapper_bcv",

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

- io_signature::make2(1, 2, sizeof(gr_complex) * fft_length, sizeof(char))),

- d_constellation(constellation),

- d_msgq(msg_queue::make(msgq_limit)),

- d_msg_offset(0),

- d_eof(false),

- d_occupied_carriers(occupied_carriers),

- d_fft_length(fft_length),

- d_bit_offset(0),

- d_pending_flag(0),

- d_resid(0),

- d_nresid(0)

-{

- GR_LOG_WARN(d_logger, "The gr::digital::ofdm_mapper_bcv block has been deprecated.");

-

- if (!(d_occupied_carriers <= d_fft_length))

- throw std::invalid_argument(

- "ofdm_mapper_bcv_impl: occupied carriers must be <= fft_length");

-

- // this is not the final form of this solution since we still

- // use the occupied_tones concept, which would get us into

- // trouble if the number of carriers we seek is greater than the

- // occupied carriers.

- // Eventually, we will get rid of the occupied_carriers concept.

- std::string carriers = "FE7F";

-

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

- int diff = (d_occupied_carriers - 4 * 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 can be

- // later passed by the user, even though it'd be cleaner to just

- // do this on the carrier map itself

- int diff_left = 0;

- int diff_right = 0;

-

- // dictionary to convert from integers to ascii hex representation

- char abc[16] = { '0', '1', '2', '3', '4', '5', '6', '7',

- '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 mapping size in chunks of four. This is the number to pack on

- // the left and this number plus any residual nulls (if odd) will be packed on the

- // right.

- diff = (d_fft_length / 4 - carriers.length()) / 2;

-

- 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

- if (k) { // if bit is a 1,

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

- }

- }

- }

-

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

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

-}

-

-ofdm_mapper_bcv_impl::~ofdm_mapper_bcv_impl() {}

-

-int ofdm_mapper_bcv_impl::randsym() { return (rand() % d_constellation.size()); }

-

-int ofdm_mapper_bcv_impl::work(int noutput_items,

- gr_vector_const_void_star& input_items,

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

- while ((d_msg_offset < d_msg->length()) && (i < d_subcarrier_map.size())) {

-

- // need new data to process

- if (d_bit_offset == 0) {

- d_msgbytes = d_msg->msg()[d_msg_offset];

- // printf("mod message byte: %x\n", d_msgbytes);

- }

-

- if (d_nresid > 0) {

- // take the residual bits, fill out nbits with info from the new byte, and put

- // them in the symbol

- d_resid |= (((1 << d_nresid) - 1) & d_msgbytes) << (d_nbits - d_nresid);

- bits = d_resid;

-

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

- i++;

-

- d_bit_offset += d_nresid;

- d_nresid = 0;

- d_resid = 0;

- // printf("mod bit(r): %x resid: %x nresid: %d bit_offset: %d\n",

- // bits, d_resid, d_nresid, d_bit_offset);

- } else {

- if ((8 - d_bit_offset) >= d_nbits) { // test to make sure we can fit nbits

- // 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++;

- } else { // if we can't fit nbits, store them for the next

- // 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_bit_offset += extra;

- d_nresid = d_nbits - extra;

- }

- }

-

- if (d_bit_offset == 8) {

- d_bit_offset = 0;

- d_msg_offset++;

- }

- }

-

- // Ran out of data to put in symbol

- if (d_msg_offset == d_msg->length()) {

- if (d_nresid > 0) {

- d_resid |= 0x00;

- bits = d_resid;

- d_nresid = 0;

- d_resid = 0;

- }

-

- // while(i < d_occupied_carriers) { // finish filling out the symbol

- while (i < d_subcarrier_map.size()) { // finish filling out the symbol

- out[d_subcarrier_map[i]] = d_constellation[randsym()];

- i++;

- }

-

- if (d_msg->type() == 1) // type == 1 sets EOF

- d_eof = true;

- d_msg.reset(); // finished packet, free message

- assert(d_bit_offset == 0);

- }

-

- if (out_flag)

- out_flag[0] = d_pending_flag;

- d_pending_flag = 0;

-

- return 1; // produced symbol

-}

-

-} /* namespace digital */

-} /* namespace gr */

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

-/*

- * Copyright 2006,2007,2011,2012 Free Software Foundation, Inc.

- *

- * This file is part of GNU Radio

- *

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

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

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

- * any later version.

- *

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

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

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

- * GNU General Public License for more details.

- *

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

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

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

- * Boston, MA 02110-1301, USA.

- */

-

-#ifndef INCLUDED_DIGITAL_OFDM_MAPPER_BCV_IMPL_H

-#define INCLUDED_DIGITAL_OFDM_MAPPER_BCV_IMPL_H

-

-#include <gnuradio/digital/ofdm_mapper_bcv.h>

-#include <gnuradio/message.h>

-#include <vector>

-

-namespace gr {

-namespace digital {

-

-class ofdm_mapper_bcv_impl : public ofdm_mapper_bcv

-{

-private:

- std::vector<gr_complex> d_constellation;

- msg_queue::sptr d_msgq;

- message::sptr d_msg;

- unsigned d_msg_offset;

- bool d_eof;

-

- unsigned int d_occupied_carriers;

- unsigned int d_fft_length;

- unsigned int d_bit_offset;

- int d_pending_flag;

-

- unsigned long d_nbits;

- unsigned char d_msgbytes;

-

- unsigned char d_resid;

- unsigned int d_nresid;

-

- std::vector<int> d_subcarrier_map;

-

- int randsym();

-

-public:

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

- unsigned msgq_limit,

- unsigned occupied_carriers,

- unsigned int fft_length);

- ~ofdm_mapper_bcv_impl(void);

-

- msg_queue::sptr msgq() const { return d_msgq; }

-

- int work(int noutput_items,

- gr_vector_const_void_star& input_items,

- gr_vector_void_star& output_items);

-};

-

-} /* namespace digital */

-} /* namespace gr */

-

-#endif /* INCLUDED_DIGITAL_OFDM_MAPPER_BCV_IMPL_H */

-/* -*- 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,

- * Boston, MA 02110-1301, USA.

- */

-

-#ifdef HAVE_CONFIG_H

-#include "config.h"

-#endif

-

-#include "ofdm_sampler_impl.h"

-#include <gnuradio/expj.h>

-#include <gnuradio/io_signature.h>

-#include <cstdio>

-

-namespace gr {

-namespace digital {

-

-ofdm_sampler::sptr ofdm_sampler::make(unsigned int fft_length,

- unsigned int symbol_length,

- unsigned int timeout)

-{

- return gnuradio::get_initial_sptr(

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

-}

-

-ofdm_sampler_impl::ofdm_sampler_impl(unsigned int fft_length,

- unsigned int symbol_length,

- unsigned int timeout)

- : block("ofdm_sampler",

- io_signature::make2(2, 2, sizeof(gr_complex), sizeof(char)),

- io_signature::make2(

- 2, 2, sizeof(gr_complex) * fft_length, sizeof(char) * fft_length)),

- d_state(STATE_NO_SIG),

- d_timeout_max(timeout),

- d_fft_length(fft_length),

- d_symbol_length(symbol_length)

-{

- GR_LOG_WARN(d_logger, "The gr::digital::ofdm_sampler block has been deprecated.");

-

- set_relative_rate(1, (uint64_t)fft_length); // buffer allocator hint

-}

-

-ofdm_sampler_impl::~ofdm_sampler_impl() {}

-

-void ofdm_sampler_impl::forecast(int noutput_items, gr_vector_int& ninput_items_required)

-{

- // FIXME do we need more

- // int nreqd = (noutput_items-1) * d_symbol_length + d_fft_length;

- int nreqd = d_symbol_length + d_fft_length;

- unsigned ninputs = ninput_items_required.size();

- for (unsigned i = 0; i < ninputs; i++)

- ninput_items_required[i] = nreqd;

-}

-

-int ofdm_sampler_impl::general_work(int noutput_items,

- gr_vector_int& ninput_items,

- gr_vector_const_void_star& input_items,

- gr_vector_void_star& output_items)

-{

- const gr_complex* iptr = (const gr_complex*)input_items[0];

- const char* trigger = (const char*)input_items[1];

-

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

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

-

- // FIXME: we only process a single OFDM symbol at a time; after the preamble, we can

- // 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

-

- outsig[0] = 0; // set output to no signal by default

-

- // Search for a preamble trigger signal during the next symbol length

- while ((d_state != STATE_PREAMBLE) && (index <= (d_symbol_length + d_fft_length))) {

- if (trigger[index]) {

- outsig[0] = 1; // tell the next block there is a preamble coming

- d_state = STATE_PREAMBLE;

- } else

- index++;

- }

-

- unsigned int i, pos, ret;

- switch (d_state) {

- case (STATE_PREAMBLE):

- // When we found a preamble trigger, get it and set the symbol boundary here

- 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

-

- // skip over fft length history and cyclic prefix

- pos = d_symbol_length; // keeps track of where we are in the input buffer

- while (pos < d_symbol_length + d_fft_length) {

- *optr++ = iptr[pos++];

- }

-

- if (d_timeout-- == 0) {

- printf("TIMEOUT\n");

- d_state = STATE_NO_SIG;

- }

-

- consume_each(

- d_symbol_length); // jump up by 1 fft length and the cyclic prefix length

- ret = 1;

- break;

-

- case (STATE_NO_SIG):

- default:

- consume_each(index - d_fft_length); // consume everything we've gone through so

- // far leaving the fft length history

- ret = 0;

- break;

- }

-

- return ret;

-}

-

-} /* namespace digital */

-} /* namespace gr */

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

-/*

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

- *

- * This file is part of GNU Radio

- *

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

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

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

- * any later version.

- *

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

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

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

- * GNU General Public License for more details.

- *

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

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

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

- * Boston, MA 02110-1301, USA.

- */

-

-#ifndef INCLUDED_DIGITAL_OFDM_SAMPLER_IMPL_H

-#define INCLUDED_DIGITAL_OFDM_SAMPLER_IMPL_H

-

-#include <gnuradio/digital/ofdm_sampler.h>

-#include <gnuradio/sync_block.h>

-

-namespace gr {

-namespace digital {

-

-class ofdm_sampler_impl : public ofdm_sampler

-{

-private:

- enum state_t { STATE_NO_SIG, STATE_PREAMBLE, STATE_FRAME };

-

- state_t d_state;

- unsigned int d_timeout_max;

- unsigned int d_timeout;

- unsigned int d_fft_length;

- unsigned int d_symbol_length;

-

-public:

- ofdm_sampler_impl(unsigned int fft_length,

- unsigned int symbol_length,

- unsigned int timeout = 1000);

- ~ofdm_sampler_impl();

-

- void forecast(int noutput_items, gr_vector_int& ninput_items_required);

-

- int general_work(int noutput_items,

- gr_vector_int& ninput_items,

- gr_vector_const_void_star& input_items,

- gr_vector_void_star& output_items);

-};

-

-} /* namespace digital */

-} /* namespace gr */

-

-#endif /* INCLUDED_DIGITAL_OFDM_SAMPLER_IMPL_H */

- ofdm.py

- ofdm_packet_utils.py

- ofdm_receiver.py

- ofdm_sync_fixed.py

- ofdm_sync_ml.py

- ofdm_sync_pnac.py

- ofdm_sync_pn.py

-from .ofdm import *

-from .ofdm_receiver import *

-from .ofdm_sync_fixed import *

-from .ofdm_sync_ml import *

-from .ofdm_sync_pnac import *

-from .ofdm_sync_pn import *

-from . import ofdm_packet_utils

-#!/usr/bin/env python

-#

-# Copyright 2006-2008,2013 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

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

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

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

-# any later version.

-#

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

-# but WITHOUT ANY WARRANTY; without even the implied warranty of

-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-# GNU General Public License for more details.

-#

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

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

-# the Free Software Foundation, Inc., 51 Franklin Street,

-# Boston, MA 02110-1301, USA.

-#

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import division

-from __future__ import unicode_literals

-

-import math

-from gnuradio import gr, fft

-from gnuradio import blocks

-from . import digital_swig as digital

-from . import ofdm_packet_utils

-from .ofdm_receiver import ofdm_receiver

-import threading

-from . import psk, qam

-

-# /////////////////////////////////////////////////////////////////////////////

-# mod/demod with packets as i/o

-# /////////////////////////////////////////////////////////////////////////////

-

-class ofdm_mod(gr.hier_block2):

- """

- Modulates an OFDM stream. Based on the options fft_length, occupied_tones, and

- cp_length, this block creates OFDM symbols using a specified modulation option.

-

- Send packets by calling send_pkt

- """

- def __init__(self, options, msgq_limit=2, pad_for_usrp=True):

- """

- Hierarchical block for sending packets

-

- Packets to be sent are enqueued by calling send_pkt.

- The output is the complex modulated signal at baseband.

-

- Args:

- options: pass modulation options from higher layers (fft length, occupied tones, etc.)

- msgq_limit: maximum number of messages in message queue (int)

- pad_for_usrp: If true, packets are padded such that they end up a multiple of 128 samples

- """

-

- gr.hier_block2.__init__(self, "ofdm_mod",

- gr.io_signature(0, 0, 0), # Input signature

- gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature

-

- self._pad_for_usrp = pad_for_usrp

- self._modulation = options.modulation

- self._fft_length = options.fft_length

- self._occupied_tones = options.occupied_tones

- self._cp_length = options.cp_length

-

- win = [] #[1 for i in range(self._fft_length)]

-

- # Use freq domain to get doubled-up known symbol for correlation in time domain

- zeros_on_left = int(math.ceil((self._fft_length - self._occupied_tones) / 2.0))

- ksfreq = known_symbols_4512_3[0:self._occupied_tones]

- for i in range(len(ksfreq)):

- if((zeros_on_left + i) & 1):

- ksfreq[i] = 0

-

- # hard-coded known symbols

- preambles = (ksfreq,)

-

- padded_preambles = list()

- for pre in preambles:

- padded = self._fft_length*[0,]

- padded[zeros_on_left : zeros_on_left + self._occupied_tones] = pre

- padded_preambles.append(padded)

-

- symbol_length = options.fft_length + options.cp_length

-

- mods = {"bpsk": 2, "qpsk": 4, "8psk": 8, "qam8": 8, "qam16": 16, "qam64": 64, "qam256": 256}

- arity = mods[self._modulation]

-

- rot = 1

- if self._modulation == "qpsk":

- rot = (0.707+0.707j)

-

- # FIXME: pass the constellation objects instead of just the points

- if(self._modulation.find("psk") >= 0):

- constel = psk.psk_constellation(arity)

- rotated_const = [pt * rot for pt in constel.points()]

- elif(self._modulation.find("qam") >= 0):

- constel = qam.qam_constellation(arity)

- rotated_const = [pt * rot for pt in constel.points()]

- #print(rotated_const)

- self._pkt_input = digital.ofdm_mapper_bcv(rotated_const,

- msgq_limit,

- options.occupied_tones,

- options.fft_length)

-

- self.preambles = digital.ofdm_insert_preamble(self._fft_length,

- padded_preambles)

- self.ifft = fft.fft_vcc(self._fft_length, False, win, True)

- self.cp_adder = digital.ofdm_cyclic_prefixer(self._fft_length,

- symbol_length)

- self.scale = blocks.multiply_const_cc(1.0 / math.sqrt(self._fft_length))

-

- self.connect((self._pkt_input, 0), (self.preambles, 0))

- self.connect((self._pkt_input, 1), (self.preambles, 1))

- self.connect(self.preambles, self.ifft, self.cp_adder, self.scale, self)

-

- if options.verbose:

- self._print_verbage()

-

- if options.log:

- self.connect(self._pkt_input, blocks.file_sink(gr.sizeof_gr_complex*options.fft_length,

- "ofdm_mapper_c.dat"))

- self.connect(self.preambles, blocks.file_sink(gr.sizeof_gr_complex*options.fft_length,

- "ofdm_preambles.dat"))

- self.connect(self.ifft, blocks.file_sink(gr.sizeof_gr_complex*options.fft_length,

- "ofdm_ifft_c.dat"))

- self.connect(self.cp_adder, blocks.file_sink(gr.sizeof_gr_complex,

- "ofdm_cp_adder_c.dat"))

-

- def send_pkt(self, payload='', eof=False):

- """

- Send the payload.

-

- Args:

- payload: data to send (string)

- """

- if eof:

- msg = gr.message(1) # tell self._pkt_input we're not sending any more packets

- else:

- # print("original_payload =", string_to_hex_list(payload))

- pkt = ofdm_packet_utils.make_packet(payload, 1, 1,

- self._pad_for_usrp,

- whitening=True)

-

- #print("pkt =", string_to_hex_list(pkt))

- msg = gr.message_from_string(pkt)

- self._pkt_input.msgq().insert_tail(msg)

-

- @staticmethod

- def add_options(normal, expert):

- """

- Adds OFDM-specific options to the Options Parser

- """

- normal.add_option("-m", "--modulation", type="string", default="bpsk",

- help="set modulation type (bpsk, qpsk, 8psk, qam{16,64}) [default=%default]")

- expert.add_option("", "--fft-length", type="intx", default=512,

- help="set the number of FFT bins [default=%default]")

- expert.add_option("", "--occupied-tones", type="intx", default=200,

- help="set the number of occupied FFT bins [default=%default]")

- expert.add_option("", "--cp-length", type="intx", default=128,

- help="set the number of bits in the cyclic prefix [default=%default]")

-

- def _print_verbage(self):

- """

- Prints information about the OFDM modulator

- """

- print("\nOFDM Modulator:")

- print("Modulation Type: %s" % (self._modulation))

- print("FFT length: %3d" % (self._fft_length))

- print("Occupied Tones: %3d" % (self._occupied_tones))

- print("CP length: %3d" % (self._cp_length))

-

-

-class ofdm_demod(gr.hier_block2):

- """

- Demodulates a received OFDM stream. Based on the options fft_length, occupied_tones, and

- cp_length, this block performs synchronization, FFT, and demodulation of incoming OFDM

- symbols and passes packets up the a higher layer.

-

- The input is complex baseband. When packets are demodulated, they are passed to the

- app via the callback.

- """

-

- def __init__(self, options, callback=None):

- """

- Hierarchical block for demodulating and deframing packets.

-

- The input is the complex modulated signal at baseband.

- Demodulated packets are sent to the handler.

-

- Args:

- options: pass modulation options from higher layers (fft length, occupied tones, etc.)

- callback: function of two args: ok, payload (ok: bool; payload: string)

- """

- gr.hier_block2.__init__(self, "ofdm_demod",

- gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature

- gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature

-

-

- self._rcvd_pktq = gr.msg_queue() # holds packets from the PHY

-

- self._modulation = options.modulation

- self._fft_length = options.fft_length

- self._occupied_tones = options.occupied_tones

- self._cp_length = options.cp_length

- self._snr = options.snr

-

- # Use freq domain to get doubled-up known symbol for correlation in time domain

- zeros_on_left = int(math.ceil((self._fft_length - self._occupied_tones) / 2.0))

- ksfreq = known_symbols_4512_3[0:self._occupied_tones]

- for i in range(len(ksfreq)):

- if((zeros_on_left + i) & 1):

- ksfreq[i] = 0

-

- # hard-coded known symbols

- preambles = (ksfreq,)

-

- symbol_length = self._fft_length + self._cp_length

- self.ofdm_recv = ofdm_receiver(self._fft_length,

- self._cp_length,

- self._occupied_tones,

- self._snr, preambles,

- options.log)

-

- mods = {"bpsk": 2, "qpsk": 4, "8psk": 8, "qam8": 8, "qam16": 16, "qam64": 64, "qam256": 256}

- arity = mods[self._modulation]

-

- rot = 1

- if self._modulation == "qpsk":

- rot = (0.707+0.707j)

-

- # FIXME: pass the constellation objects instead of just the points

- if(self._modulation.find("psk") >= 0):

- constel = psk.psk_constellation(arity)

- rotated_const = [pt * rot for pt in constel.points()]

- elif(self._modulation.find("qam") >= 0):

- constel = qam.qam_constellation(arity)

- rotated_const = [pt * rot for pt in constel.points()]

- #print(rotated_const)

-

- phgain = 0.25

- frgain = phgain*phgain / 4.0

- self.ofdm_demod = digital.ofdm_frame_sink(rotated_const, list(range(arity)),

- self._rcvd_pktq,

- self._occupied_tones,

- phgain, frgain)

-

- self.connect(self, self.ofdm_recv)

- self.connect((self.ofdm_recv, 0), (self.ofdm_demod, 0))

- self.connect((self.ofdm_recv, 1), (self.ofdm_demod, 1))

-

- # added output signature to work around bug, though it might not be a bad

- # thing to export, anyway

- self.connect(self.ofdm_recv.chan_filt, self)

-

- if options.log:

- self.connect(self.ofdm_demod,

- blocks.file_sink(gr.sizeof_gr_complex*self._occupied_tones,

- "ofdm_frame_sink_c.dat"))

- else:

- self.connect(self.ofdm_demod,

- blocks.null_sink(gr.sizeof_gr_complex*self._occupied_tones))

-

- if options.verbose:

- self._print_verbage()

-

- self._watcher = _queue_watcher_thread(self._rcvd_pktq, callback)

-

- @staticmethod

- def add_options(normal, expert):

- """

- Adds OFDM-specific options to the Options Parser

- """

- normal.add_option("-m", "--modulation", type="string", default="bpsk",

- help="set modulation type (bpsk or qpsk) [default=%default]")

- expert.add_option("", "--fft-length", type="intx", default=512,

- help="set the number of FFT bins [default=%default]")

- expert.add_option("", "--occupied-tones", type="intx", default=200,

- help="set the number of occupied FFT bins [default=%default]")

- expert.add_option("", "--cp-length", type="intx", default=128,

- help="set the number of bits in the cyclic prefix [default=%default]")

- expert.add_option("", "--snr", type="float", default=30.0,

- help="SNR estimate [default=%default]")

-

- def _print_verbage(self):

- """

- Prints information about the OFDM demodulator

- """

- print("\nOFDM Demodulator:")

- print("Modulation Type: %s" % (self._modulation))

- print("FFT length: %3d" % (self._fft_length))

- print("Occupied Tones: %3d" % (self._occupied_tones))

- print("CP length: %3d" % (self._cp_length))

-

-

-

-class _queue_watcher_thread(threading.Thread):

- def __init__(self, rcvd_pktq, callback):

- threading.Thread.__init__(self)

- self.setDaemon(1)

- self.rcvd_pktq = rcvd_pktq

- self.callback = callback

- self.keep_running = True

- self.start()

-

-

- def run(self):

- while self.keep_running:

- msg = self.rcvd_pktq.delete_head()

- ok, payload = ofdm_packet_utils.unmake_packet(msg.to_string())

- if self.callback:

- self.callback(ok, payload)

-

-# Generating known symbols with:

-# i = [2*random.randint(0,1)-1 for i in range(4512)]

-

-known_symbols_4512_3 = [-1, -1, 1, -1, 1, 1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, 1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, -1, 1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, 1, -1, -1, 1, 1, 1, -1, 1, -1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, 1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, -1, 1, -1, -1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, 1, -1, -1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, -1, 1, -1, -1, 1, -1, -1, -1, -1, 1, 1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, -1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, -1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, 1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, -1, -1, 1, 1, -1, 1, 1, 1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 1, 1, 1, -1, -1, 1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1, -1, -1, -1, -1, -1, 1, -1, 1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, -1, 1, -1, -1, -1, -1, -1, 1, 1, 1, -1, 1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, -1, -1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, -1, 1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, -1, -1, 1, -1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, 1, 1, -1, 1, -1, -1, 1, 1, -1, 1, 1, 1, -1, -1, 1, -1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, 1, 1, -1, 1, -1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1, -1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, -1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1, 1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, -1, -1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, -1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, -1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, -1, -1, -1, -1, -1, 1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, 1, -1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1, -1, 1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, -1, -1, 1, -1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1, 1, -1, -1, -1, -1, -1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, -1, -1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, -1, -1, -1, 1, 1, 1, -1, -1, 1, -1, 1, 1, -1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, -1, -1, 1, -1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, -1, 1, -1, -1, 1, 1, 1, -1, 1, -1, 1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, -1, 1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, 1, -1, -1, 1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, 1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, -1, 1, -1, 1, 1, -1, -1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, 1, 1, 1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, 1, -1, -1, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, 1, -1, 1, -1, 1, 1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, 1, -1, -1, 1, 1, -1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, -1, 1, -1, -1, 1, -1, 1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, -1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, 1, 1, 1, 1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1, -1, -1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, -1, 1, 1, -1, 1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, -1, -1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, -1, 1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1, -1, 1, -1, 1, -1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1]

-#

-# Copyright 2007 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

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

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

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

-# any later version.

-#

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

-# but WITHOUT ANY WARRANTY; without even the implied warranty of

-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-# GNU General Public License for more details.

-#

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

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

-# the Free Software Foundation, Inc., 51 Franklin Street,

-# Boston, MA 02110-1301, USA.

-#

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import division

-from __future__ import unicode_literals

-

-import struct

-import numpy

-from gnuradio import gru

-from . import crc

-

-def conv_packed_binary_string_to_1_0_string(s):

- """

- '\xAF' --> '10101111'

- """

- r = []

- for ch in s:

- x = ord(ch)

- for i in range(7,-1,-1):

- t = (x >> i) & 0x1

- r.append(t)

-

- return ''.join([chr(x + ord('0')) for x in r])

-

-def conv_1_0_string_to_packed_binary_string(s):

- """

- '10101111' -> ('\xAF', False)

-

- Basically the inverse of conv_packed_binary_string_to_1_0_string,

- but also returns a flag indicating if we had to pad with leading zeros

- to get to a multiple of 8.

- """

- if not is_1_0_string(s):

- raise ValueError("Input must be a string containing only 0's and 1's")

-

- # pad to multiple of 8

- padded = False

- rem = len(s) % 8

- if rem != 0:

- npad = 8 - rem

- s = '0' * npad + s

- padded = True

-

- assert len(s) % 8 == 0

-

- r = []

- i = 0

- while i < len(s):

- t = 0

- for j in range(8):

- t = (t << 1) | (ord(s[i + j]) - ord('0'))

- r.append(chr(t))

- i += 8

- return (''.join(r), padded)

-

-

-def is_1_0_string(s):

- if not isinstance(s, str):

- return False

- for ch in s:

- if not ch in ('0', '1'):

- return False

- return True

-

-def string_to_hex_list(s):

- return [hex(ord(x)) for x in s]

-

-

-def whiten(s, o):

- sa = numpy.fromstring(s, numpy.uint8)

- z = sa ^ random_mask_vec8[o:len(sa)+o]

- return z.tostring()

-

-def dewhiten(s, o):

- return whiten(s, o) # self inverse

-

-

-def make_header(payload_len, whitener_offset=0):

- # Upper nibble is offset, lower 12 bits is len

- val = ((whitener_offset & 0xf) << 12) | (payload_len & 0x0fff)

- #print("offset =", whitener_offset, " len =", payload_len, " val=", val)

- return struct.pack('!HH', val, val)

-

-def make_packet(payload, samples_per_symbol, bits_per_symbol,

- pad_for_usrp=True, whitener_offset=0, whitening=True):

- """

- Build a packet, given access code, payload, and whitener offset

-

- Args:

- payload: packet payload, len [0, 4096]

- samples_per_symbol: samples per symbol (needed for padding calculation) (int)

- bits_per_symbol: (needed for padding calculation) (int)

- whitener_offset: offset into whitener string to use [0-16)

- whitening: Turn whitener on or off (bool)

-

- Packet will have access code at the beginning, followed by length, payload

- and finally CRC-32.

- """

-

- if not whitener_offset >=0 and whitener_offset < 16:

- raise ValueError("whitener_offset must be between 0 and 15, inclusive (%i)" % (whitener_offset,))

-

- payload_with_crc = crc.gen_and_append_crc32(payload)

- #print("outbound crc =", string_to_hex_list(payload_with_crc[-4:]))

-

- L = len(payload_with_crc)

- MAXLEN = len(random_mask_tuple)

- if L > MAXLEN:

- raise ValueError("len(payload) must be in [0, %d]" % (MAXLEN,))

-

- pkt_hd = make_header(L, whitener_offset)

- pkt_dt = ''.join((payload_with_crc, '\x55'))

- packet_length = len(pkt_hd) + len(pkt_dt)

-

- if pad_for_usrp:

- usrp_packing = _npadding_bytes(packet_length, samples_per_symbol, bits_per_symbol) * '\x55'

- pkt_dt = pkt_dt + usrp_packing

-

- if(whitening):

- pkt = pkt_hd + whiten(pkt_dt, whitener_offset)

- else:

- pkt = pkt_hd + pkt_dt

-

- #print("make_packet: len(pkt) =", len(pkt))

-

- return pkt

-

-def _npadding_bytes(pkt_byte_len, samples_per_symbol, bits_per_symbol):

- """

- Generate sufficient padding such that each packet ultimately ends

- up being a multiple of 512 bytes when sent across the USB. We

- send 4-byte samples across the USB (16-bit I and 16-bit Q), thus

- we want to pad so that after modulation the resulting packet

- is a multiple of 128 samples.

-

- Args:

- ptk_byte_len: len in bytes of packet, not including padding.

- samples_per_symbol: samples per bit (1 bit / symbolwidth GMSK) (int)

- bits_per_symbol: bits per symbol (log2(modulation order)) (int)

-

- Returns:

- number of bytes of padding to append.

- """

- modulus = 128

- byte_modulus = gru.lcm(modulus / 8, samples_per_symbol) * bits_per_symbol / samples_per_symbol

- r = pkt_byte_len % byte_modulus

- if r == 0:

- return 0

- return byte_modulus - r

-

-

-def unmake_packet(whitened_payload_with_crc, whitener_offset=0, dewhitening=1):

- """

- Return (ok, payload)

-

- Args:

- whitened_payload_with_crc: string

- whitener_offset: offset into whitener string to use [0-16)

- dewhitening: Turn whitener on or off (bool)

- """

-

- if dewhitening:

- payload_with_crc = dewhiten(whitened_payload_with_crc, whitener_offset)

- else:

- payload_with_crc = whitened_payload_with_crc

-

- ok, payload = crc.check_crc32(payload_with_crc)

-

- if 0:

- print("payload_with_crc =", string_to_hex_list(payload_with_crc))

- print("ok = %r, len(payload) = %d" % (ok, len(payload)))

- print("payload =", string_to_hex_list(payload))

-

- return ok, payload

-

-

-# FYI, this PN code is the output of a 15-bit LFSR

-random_mask_tuple = (

- 255, 63, 0, 16, 0, 12, 0, 5, 192, 3, 16, 1, 204, 0, 85, 192,

- 63, 16, 16, 12, 12, 5, 197, 195, 19, 17, 205, 204, 85, 149, 255, 47,

- 0, 28, 0, 9, 192, 6, 208, 2, 220, 1, 153, 192, 106, 208, 47, 28,

- 28, 9, 201, 198, 214, 210, 222, 221, 152, 89, 170, 186, 255, 51, 0, 21,

- 192, 15, 16, 4, 12, 3, 69, 193, 243, 16, 69, 204, 51, 21, 213, 207,

- 31, 20, 8, 15, 70, 132, 50, 227, 85, 137, 255, 38, 192, 26, 208, 11,

- 28, 7, 73, 194, 182, 209, 182, 220, 118, 217, 230, 218, 202, 219, 23, 27,

- 78, 139, 116, 103, 103, 106, 170, 175, 63, 60, 16, 17, 204, 12, 85, 197,

- 255, 19, 0, 13, 192, 5, 144, 3, 44, 1, 221, 192, 89, 144, 58, 236,

- 19, 13, 205, 197, 149, 147, 47, 45, 220, 29, 153, 201, 170, 214, 255, 30,

- 192, 8, 80, 6, 188, 2, 241, 193, 132, 80, 99, 124, 41, 225, 222, 200,

- 88, 86, 186, 190, 243, 48, 69, 212, 51, 31, 85, 200, 63, 22, 144, 14,

- 236, 4, 77, 195, 117, 145, 231, 44, 74, 157, 247, 41, 134, 158, 226, 232,

- 73, 142, 182, 228, 118, 203, 102, 215, 106, 222, 175, 24, 124, 10, 161, 199,

- 56, 82, 146, 189, 173, 177, 189, 180, 113, 183, 100, 118, 171, 102, 255, 106,

- 192, 47, 16, 28, 12, 9, 197, 198, 211, 18, 221, 205, 153, 149, 170, 239,

- 63, 12, 16, 5, 204, 3, 21, 193, 207, 16, 84, 12, 63, 69, 208, 51,

- 28, 21, 201, 207, 22, 212, 14, 223, 68, 88, 51, 122, 149, 227, 47, 9,

- 220, 6, 217, 194, 218, 209, 155, 28, 107, 73, 239, 118, 204, 38, 213, 218,

- 223, 27, 24, 11, 74, 135, 119, 34, 166, 153, 186, 234, 243, 15, 5, 196,

- 3, 19, 65, 205, 240, 85, 132, 63, 35, 80, 25, 252, 10, 193, 199, 16,

- 82, 140, 61, 165, 209, 187, 28, 115, 73, 229, 246, 203, 6, 215, 66, 222,

- 177, 152, 116, 106, 167, 111, 58, 172, 19, 61, 205, 209, 149, 156, 111, 41,

- 236, 30, 205, 200, 85, 150, 191, 46, 240, 28, 68, 9, 243, 70, 197, 242,

- 211, 5, 157, 195, 41, 145, 222, 236, 88, 77, 250, 181, 131, 55, 33, 214,

- 152, 94, 234, 184, 79, 50, 180, 21, 183, 79, 54, 180, 22, 247, 78, 198,

- 180, 82, 247, 125, 134, 161, 162, 248, 121, 130, 162, 225, 185, 136, 114, 230,

- 165, 138, 251, 39, 3, 90, 129, 251, 32, 67, 88, 49, 250, 148, 67, 47,

- 113, 220, 36, 89, 219, 122, 219, 99, 27, 105, 203, 110, 215, 108, 94, 173,

- 248, 125, 130, 161, 161, 184, 120, 114, 162, 165, 185, 187, 50, 243, 85, 133,

- 255, 35, 0, 25, 192, 10, 208, 7, 28, 2, 137, 193, 166, 208, 122, 220,

- 35, 25, 217, 202, 218, 215, 27, 30, 139, 72, 103, 118, 170, 166, 255, 58,

- 192, 19, 16, 13, 204, 5, 149, 195, 47, 17, 220, 12, 89, 197, 250, 211,

- 3, 29, 193, 201, 144, 86, 236, 62, 205, 208, 85, 156, 63, 41, 208, 30,

- 220, 8, 89, 198, 186, 210, 243, 29, 133, 201, 163, 22, 249, 206, 194, 212,

- 81, 159, 124, 104, 33, 238, 152, 76, 106, 181, 239, 55, 12, 22, 133, 206,

- 227, 20, 73, 207, 118, 212, 38, 223, 90, 216, 59, 26, 147, 75, 45, 247,

- 93, 134, 185, 162, 242, 249, 133, 130, 227, 33, 137, 216, 102, 218, 170, 219,

- 63, 27, 80, 11, 124, 7, 97, 194, 168, 81, 190, 188, 112, 113, 228, 36,

- 75, 91, 119, 123, 102, 163, 106, 249, 239, 2, 204, 1, 149, 192, 111, 16,

- 44, 12, 29, 197, 201, 147, 22, 237, 206, 205, 148, 85, 175, 127, 60, 32,

- 17, 216, 12, 90, 133, 251, 35, 3, 89, 193, 250, 208, 67, 28, 49, 201,

- 212, 86, 223, 126, 216, 32, 90, 152, 59, 42, 147, 95, 45, 248, 29, 130,

- 137, 161, 166, 248, 122, 194, 163, 17, 185, 204, 114, 213, 229, 159, 11, 40,

- 7, 94, 130, 184, 97, 178, 168, 117, 190, 167, 48, 122, 148, 35, 47, 89,

- 220, 58, 217, 211, 26, 221, 203, 25, 151, 74, 238, 183, 12, 118, 133, 230,

- 227, 10, 201, 199, 22, 210, 142, 221, 164, 89, 187, 122, 243, 99, 5, 233,

- 195, 14, 209, 196, 92, 83, 121, 253, 226, 193, 137, 144, 102, 236, 42, 205,

- 223, 21, 152, 15, 42, 132, 31, 35, 72, 25, 246, 138, 198, 231, 18, 202,

- 141, 151, 37, 174, 155, 60, 107, 81, 239, 124, 76, 33, 245, 216, 71, 26,

- 178, 139, 53, 167, 87, 58, 190, 147, 48, 109, 212, 45, 159, 93, 168, 57,

- 190, 146, 240, 109, 132, 45, 163, 93, 185, 249, 178, 194, 245, 145, 135, 44,

- 98, 157, 233, 169, 142, 254, 228, 64, 75, 112, 55, 100, 22, 171, 78, 255,

- 116, 64, 39, 112, 26, 164, 11, 59, 71, 83, 114, 189, 229, 177, 139, 52,

- 103, 87, 106, 190, 175, 48, 124, 20, 33, 207, 88, 84, 58, 191, 83, 48,

- 61, 212, 17, 159, 76, 104, 53, 238, 151, 12, 110, 133, 236, 99, 13, 233,

- 197, 142, 211, 36, 93, 219, 121, 155, 98, 235, 105, 143, 110, 228, 44, 75,

- 93, 247, 121, 134, 162, 226, 249, 137, 130, 230, 225, 138, 200, 103, 22, 170,

- 142, 255, 36, 64, 27, 112, 11, 100, 7, 107, 66, 175, 113, 188, 36, 113,

- 219, 100, 91, 107, 123, 111, 99, 108, 41, 237, 222, 205, 152, 85, 170, 191,

- 63, 48, 16, 20, 12, 15, 69, 196, 51, 19, 85, 205, 255, 21, 128, 15,

- 32, 4, 24, 3, 74, 129, 247, 32, 70, 152, 50, 234, 149, 143, 47, 36,

- 28, 27, 73, 203, 118, 215, 102, 222, 170, 216, 127, 26, 160, 11, 56, 7,

- 82, 130, 189, 161, 177, 184, 116, 114, 167, 101, 186, 171, 51, 63, 85, 208,

- 63, 28, 16, 9, 204, 6, 213, 194, 223, 17, 152, 12, 106, 133, 239, 35,

- 12, 25, 197, 202, 211, 23, 29, 206, 137, 148, 102, 239, 106, 204, 47, 21,

- 220, 15, 25, 196, 10, 211, 71, 29, 242, 137, 133, 166, 227, 58, 201, 211,

- 22, 221, 206, 217, 148, 90, 239, 123, 12, 35, 69, 217, 243, 26, 197, 203,

- 19, 23, 77, 206, 181, 148, 119, 47, 102, 156, 42, 233, 223, 14, 216, 4,

- 90, 131, 123, 33, 227, 88, 73, 250, 182, 195, 54, 209, 214, 220, 94, 217,

- 248, 90, 194, 187, 17, 179, 76, 117, 245, 231, 7, 10, 130, 135, 33, 162,

- 152, 121, 170, 162, 255, 57, 128, 18, 224, 13, 136, 5, 166, 131, 58, 225,

- 211, 8, 93, 198, 185, 146, 242, 237, 133, 141, 163, 37, 185, 219, 50, 219,

- 85, 155, 127, 43, 96, 31, 104, 8, 46, 134, 156, 98, 233, 233, 142, 206,

- 228, 84, 75, 127, 119, 96, 38, 168, 26, 254, 139, 0, 103, 64, 42, 176,

- 31, 52, 8, 23, 70, 142, 178, 228, 117, 139, 103, 39, 106, 154, 175, 43,

- 60, 31, 81, 200, 60, 86, 145, 254, 236, 64, 77, 240, 53, 132, 23, 35,

- 78, 153, 244, 106, 199, 111, 18, 172, 13, 189, 197, 177, 147, 52, 109, 215,

- 109, 158, 173, 168, 125, 190, 161, 176, 120, 116, 34, 167, 89, 186, 186, 243,

- 51, 5, 213, 195, 31, 17, 200, 12, 86, 133, 254, 227, 0, 73, 192, 54,

- 208, 22, 220, 14, 217, 196, 90, 211, 123, 29, 227, 73, 137, 246, 230, 198,

- 202, 210, 215, 29, 158, 137, 168, 102, 254, 170, 192, 127, 16, 32, 12, 24,

- 5, 202, 131, 23, 33, 206, 152, 84, 106, 191, 111, 48, 44, 20, 29, 207,

- 73, 148, 54, 239, 86, 204, 62, 213, 208, 95, 28, 56, 9, 210, 134, 221,

- 162, 217, 185, 154, 242, 235, 5, 143, 67, 36, 49, 219, 84, 91, 127, 123,

- 96, 35, 104, 25, 238, 138, 204, 103, 21, 234, 143, 15, 36, 4, 27, 67,

- 75, 113, 247, 100, 70, 171, 114, 255, 101, 128, 43, 32, 31, 88, 8, 58,

- 134, 147, 34, 237, 217, 141, 154, 229, 171, 11, 63, 71, 80, 50, 188, 21,

- 177, 207, 52, 84, 23, 127, 78, 160, 52, 120, 23, 98, 142, 169, 164, 126,

- 251, 96, 67, 104, 49, 238, 148, 76, 111, 117, 236, 39, 13, 218, 133, 155,

- 35, 43, 89, 223, 122, 216, 35, 26, 153, 203, 42, 215, 95, 30, 184, 8,

- 114, 134, 165, 162, 251, 57, 131, 82, 225, 253, 136, 65, 166, 176, 122, 244,

- 35, 7, 89, 194, 186, 209, 179, 28, 117, 201, 231, 22, 202, 142, 215, 36,

- 94, 155, 120, 107, 98, 175, 105, 188, 46, 241, 220, 68, 89, 243, 122, 197,

- 227, 19, 9, 205, 198, 213, 146, 223, 45, 152, 29, 170, 137, 191, 38, 240,

- 26, 196, 11, 19, 71, 77, 242, 181, 133, 183, 35, 54, 153, 214, 234, 222,

- 207, 24, 84, 10, 191, 71, 48, 50, 148, 21, 175, 79, 60, 52, 17, 215,

- 76, 94, 181, 248, 119, 2, 166, 129, 186, 224, 115, 8, 37, 198, 155, 18,

- 235, 77, 143, 117, 164, 39, 59, 90, 147, 123, 45, 227, 93, 137, 249, 166,

- 194, 250, 209, 131, 28, 97, 201, 232, 86, 206, 190, 212, 112, 95, 100, 56,

- 43, 82, 159, 125, 168, 33, 190, 152, 112, 106, 164, 47, 59, 92, 19, 121,

- 205, 226, 213, 137, 159, 38, 232, 26, 206, 139, 20, 103, 79, 106, 180, 47,

- 55, 92, 22, 185, 206, 242, 212, 69, 159, 115, 40, 37, 222, 155, 24, 107,

- 74, 175, 119, 60, 38, 145, 218, 236, 91, 13, 251, 69, 131, 115, 33, 229,

- 216, 75, 26, 183, 75, 54, 183, 86, 246, 190, 198, 240, 82, 196, 61, 147,

- 81, 173, 252, 125, 129, 225, 160, 72, 120, 54, 162, 150, 249, 174, 194, 252,

- 81, 129, 252, 96, 65, 232, 48, 78, 148, 52, 111, 87, 108, 62, 173, 208,

- 125, 156, 33, 169, 216, 126, 218, 160, 91, 56, 59, 82, 147, 125, 173, 225,

- 189, 136, 113, 166, 164, 122, 251, 99, 3, 105, 193, 238, 208, 76, 92, 53,

- 249, 215, 2, 222, 129, 152, 96, 106, 168, 47, 62, 156, 16, 105, 204, 46,

- 213, 220, 95, 25, 248, 10, 194, 135, 17, 162, 140, 121, 165, 226, 251, 9,

- 131, 70, 225, 242, 200, 69, 150, 179, 46, 245, 220, 71, 25, 242, 138, 197,

- 167, 19, 58, 141, 211, 37, 157, 219, 41, 155, 94, 235, 120, 79, 98, 180,

- 41, 183, 94, 246, 184, 70, 242, 178, 197, 181, 147, 55, 45, 214, 157, 158,

- 233, 168, 78, 254, 180, 64, 119, 112, 38, 164, 26, 251, 75, 3, 119, 65,

- 230, 176, 74, 244, 55, 7, 86, 130, 190, 225, 176, 72, 116, 54, 167, 86,

- 250, 190, 195, 48, 81, 212, 60, 95, 81, 248, 60, 66, 145, 241, 172, 68,

- 125, 243, 97, 133, 232, 99, 14, 169, 196, 126, 211, 96, 93, 232, 57, 142,

- 146, 228, 109, 139, 109, 167, 109, 186, 173, 179, 61, 181, 209, 183, 28, 118,

- 137, 230, 230, 202, 202, 215, 23, 30, 142, 136, 100, 102, 171, 106, 255, 111,

- 0, 44, 0, 29, 192, 9, 144, 6, 236, 2, 205, 193, 149, 144, 111, 44,

- 44, 29, 221, 201, 153, 150, 234, 238, 207, 12, 84, 5, 255, 67, 0, 49,

- 192, 20, 80, 15, 124, 4, 33, 195, 88, 81, 250, 188, 67, 49, 241, 212,

- 68, 95, 115, 120, 37, 226, 155, 9, 171, 70, 255, 114, 192, 37, 144, 27,

- 44, 11, 93, 199, 121, 146, 162, 237, 185, 141, 178, 229, 181, 139, 55, 39,

- 86, 154, 190, 235, 48, 79, 84, 52, 63, 87, 80, 62, 188, 16, 113, 204,

- 36, 85, 219, 127, 27, 96, 11, 104, 7, 110, 130, 172, 97, 189, 232, 113,

- 142, 164, 100, 123, 107, 99, 111, 105, 236, 46, 205, 220, 85, 153, 255, 42,

- 192, 31, 16, 8, 12, 6, 133, 194, 227, 17, 137, 204, 102, 213, 234, 223,

- 15, 24, 4, 10, 131, 71, 33, 242, 152, 69, 170, 179, 63, 53, 208, 23,

- 28, 14, 137, 196, 102, 211, 106, 221, 239, 25, 140, 10, 229, 199, 11, 18,

- 135, 77, 162, 181, 185, 183, 50, 246, 149, 134, 239, 34, 204, 25, 149, 202,

- 239, 23, 12, 14, 133, 196, 99, 19, 105, 205, 238, 213, 140, 95, 37, 248,

- 27, 2, 139, 65, 167, 112, 122, 164, 35, 59, 89, 211, 122, 221, 227, 25,

- 137, 202, 230, 215, 10, 222, 135, 24, 98, 138, 169, 167, 62, 250, 144, 67,

- 44, 49, 221, 212, 89, 159, 122, 232, 35, 14, 153, 196, 106, 211, 111, 29,

- 236, 9, 141, 198, 229, 146, 203, 45, 151, 93, 174, 185, 188, 114, 241, 229,

- 132, 75, 35, 119, 89, 230, 186, 202, 243, 23, 5, 206, 131, 20, 97, 207,

- 104, 84, 46, 191, 92, 112, 57, 228, 18, 203, 77, 151, 117, 174, 167, 60,

- 122, 145, 227, 44, 73, 221, 246, 217, 134, 218, 226, 219, 9, 155, 70, 235,

- 114, 207, 101, 148, 43, 47, 95, 92, 56, 57, 210, 146, 221, 173, 153, 189,

- 170, 241, 191, 4, 112, 3, 100, 1, 235, 64, 79, 112, 52, 36, 23, 91,

- 78, 187, 116, 115, 103, 101, 234, 171, 15, 63, 68, 16, 51, 76, 21, 245,

- 207, 7, 20, 2, 143, 65, 164, 48, 123, 84, 35, 127, 89, 224, 58, 200,

- 19, 22, 141, 206, 229, 148, 75, 47, 119, 92, 38, 185, 218, 242, 219, 5,

- 155, 67, 43, 113, 223, 100, 88, 43, 122, 159, 99, 40, 41, 222, 158, 216,

- 104, 90, 174, 187, 60, 115, 81, 229, 252, 75, 1, 247, 64, 70, 176, 50,

- 244, 21, 135, 79, 34, 180, 25, 183, 74, 246, 183, 6, 246, 130, 198, 225,

- 146, 200, 109, 150, 173, 174, 253, 188, 65, 177, 240, 116, 68, 39, 115, 90,

- 165, 251, 59, 3, 83, 65, 253, 240, 65, 132, 48, 99, 84, 41, 255, 94,

- 192, 56, 80, 18, 188, 13, 177, 197, 180, 83, 55, 125, 214, 161, 158, 248,

- 104, 66, 174, 177, 188, 116, 113, 231, 100, 74, 171, 119, 63, 102, 144, 42,

- 236, 31, 13, 200, 5, 150, 131, 46, 225, 220, 72, 89, 246, 186, 198, 243,

- 18, 197, 205, 147, 21, 173, 207, 61, 148, 17, 175, 76, 124, 53, 225, 215,

- 8, 94, 134, 184, 98, 242, 169, 133, 190, 227, 48, 73, 212, 54, 223, 86,

- 216, 62, 218, 144, 91, 44, 59, 93, 211, 121, 157, 226, 233, 137, 142, 230,

- 228, 74, 203, 119, 23, 102, 142, 170, 228, 127, 11, 96, 7, 104, 2, 174,

- 129, 188, 96, 113, 232, 36, 78, 155, 116, 107, 103, 111, 106, 172, 47, 61,

- 220, 17, 153, 204, 106, 213, 239, 31, 12, 8, 5, 198, 131, 18, 225, 205,

- 136, 85, 166, 191, 58, 240, 19, 4, 13, 195, 69, 145, 243, 44, 69, 221,

- 243, 25, 133, 202, 227, 23, 9, 206, 134, 212, 98, 223, 105, 152, 46, 234,

- 156, 79, 41, 244, 30, 199, 72, 82, 182, 189, 182, 241, 182, 196, 118, 211,

- 102, 221, 234, 217, 143, 26, 228, 11, 11, 71, 71, 114, 178, 165, 181, 187,

- 55, 51, 86, 149, 254, 239, 0, 76, 0, 53, 192, 23, 16, 14, 140, 4,

- 101, 195, 107, 17, 239, 76, 76, 53, 245, 215, 7, 30, 130, 136, 97, 166,

- 168, 122, 254, 163, 0, 121, 192, 34, 208, 25, 156, 10, 233, 199, 14, 210,

- 132, 93, 163, 121, 185, 226, 242, 201, 133, 150, 227, 46, 201, 220, 86, 217,

- 254, 218, 192, 91, 16, 59, 76, 19, 117, 205, 231, 21, 138, 143, 39, 36,

- 26, 155, 75, 43, 119, 95, 102, 184, 42, 242, 159, 5, 168, 3, 62, 129,

- 208, 96, 92, 40, 57, 222, 146, 216, 109, 154, 173, 171, 61, 191, 81, 176,

- 60, 116, 17, 231, 76, 74, 181, 247, 55, 6, 150, 130, 238, 225, 140, 72,

- 101, 246, 171, 6, 255, 66, 192, 49, 144, 20, 108, 15, 109, 196, 45, 147,

- 93, 173, 249, 189, 130, 241, 161, 132, 120, 99, 98, 169, 233, 190, 206, 240,

- 84, 68, 63, 115, 80, 37, 252, 27, 1, 203, 64, 87, 112, 62, 164, 16,

- 123, 76, 35, 117, 217, 231, 26, 202, 139, 23, 39, 78, 154, 180, 107, 55,

- 111, 86, 172, 62, 253, 208, 65, 156, 48, 105, 212, 46, 223, 92, 88, 57,

- 250, 146, 195, 45, 145, 221, 172, 89, 189, 250, 241, 131, 4, 97, 195, 104,

- 81, 238, 188, 76, 113, 245, 228, 71, 11, 114, 135, 101, 162, 171, 57, 191,

- 82, 240, 61, 132, 17, 163, 76, 121, 245, 226, 199, 9, 146, 134, 237, 162,

- 205, 185, 149, 178, 239, 53, 140, 23, 37, 206, 155, 20, 107, 79, 111, 116,

- 44, 39, 93, 218, 185, 155, 50, 235, 85, 143, 127, 36, 32, 27, 88, 11,

- 122, 135, 99, 34, 169, 217, 190, 218, 240, 91, 4, 59, 67, 83, 113, 253,

- 228, 65, 139, 112, 103, 100, 42, 171, 95, 63, 120, 16, 34, 140, 25, 165,

- 202, 251, 23, 3, 78, 129, 244, 96, 71, 104, 50, 174, 149, 188, 111, 49,

- 236, 20, 77, 207, 117, 148, 39, 47, 90, 156, 59, 41, 211, 94, 221, 248,

- 89, 130, 186, 225, 179, 8, 117, 198, 167, 18, 250, 141, 131, 37, 161, 219,

- 56, 91, 82, 187, 125, 179, 97, 181, 232, 119, 14, 166, 132, 122, 227, 99,

- 9, 233, 198, 206, 210, 212, 93, 159, 121, 168, 34, 254, 153, 128, 106, 224,

- 47, 8, 28, 6, 137, 194, 230, 209, 138, 220, 103, 25, 234, 138, 207, 39,

- 20, 26, 143, 75, 36, 55, 91, 86, 187, 126, 243, 96, 69, 232, 51, 14,

- 149, 196, 111, 19, 108, 13, 237, 197, 141, 147, 37, 173, 219, 61, 155, 81,

- 171, 124, 127, 97, 224, 40, 72, 30, 182, 136, 118, 230, 166, 202, 250, 215,

- 3, 30, 129, 200, 96, 86, 168, 62, 254, 144, 64, 108, 48, 45, 212, 29,

- 159, 73, 168, 54, 254, 150, 192, 110, 208, 44, 92, 29, 249, 201, 130, 214,

- 225, 158, 200, 104, 86, 174, 190, 252, 112, 65, 228, 48, 75, 84, 55, 127,

- 86, 160, 62, 248, 16, 66, 140, 49, 165, 212, 123, 31, 99, 72, 41, 246,

- 158, 198, 232, 82, 206, 189, 148, 113, 175, 100, 124, 43, 97, 223, 104, 88,

- 46, 186, 156, 115, 41, 229, 222, 203, 24, 87, 74, 190, 183, 48, 118, 148,

- 38, 239, 90, 204, 59, 21, 211, 79, 29, 244, 9, 135, 70, 226, 178, 201,

- 181, 150, 247, 46, 198, 156, 82, 233, 253, 142, 193, 164, 80, 123, 124, 35,

- 97, 217, 232, 90, 206, 187, 20, 115, 79, 101, 244, 43, 7, 95, 66, 184,

- 49, 178, 148, 117, 175, 103, 60, 42, 145, 223, 44, 88, 29, 250, 137, 131,

- 38, 225, 218, 200, 91, 22, 187, 78, 243, 116, 69, 231, 115, 10, 165, 199,

- 59, 18, 147, 77, 173, 245, 189, 135, 49, 162, 148, 121, 175, 98, 252, 41,

- 129, 222, 224, 88, 72, 58, 182, 147, 54, 237, 214, 205, 158, 213, 168, 95,

- 62, 184, 16, 114, 140, 37, 165, 219, 59, 27, 83, 75, 125, 247, 97, 134,

- 168, 98, 254, 169, 128, 126, 224, 32, 72, 24, 54, 138, 150, 231, 46, 202,

- 156, 87, 41, 254, 158, 192, 104, 80, 46, 188, 28, 113, 201, 228, 86, 203,

- 126, 215, 96, 94, 168, 56, 126, 146, 160, 109, 184, 45, 178, 157, 181, 169,

- 183, 62, 246, 144, 70, 236, 50, 205, 213, 149, 159, 47, 40, 28, 30, 137,

- 200, 102, 214, 170, 222, 255, 24, 64, 10, 176, 7, 52, 2, 151, 65, 174,

- 176, 124, 116, 33, 231, 88, 74, 186, 183, 51, 54, 149, 214, 239, 30, 204,

- 8, 85, 198, 191, 18, 240, 13, 132, 5, 163, 67, 57, 241, 210, 196, 93,

- 147, 121, 173, 226, 253, 137, 129, 166, 224, 122, 200, 35, 22, 153, 206, 234,

- 212, 79, 31, 116, 8, 39, 70, 154, 178, 235, 53, 143, 87, 36, 62, 155,

- 80, 107, 124, 47, 97, 220, 40, 89, 222, 186, 216, 115, 26, 165, 203, 59,

- 23, 83, 78, 189, 244, 113, 135, 100, 98, 171, 105, 191, 110, 240, 44, 68,

- 29, 243, 73, 133, 246, 227, 6, 201, 194, 214, 209, 158, 220, 104, 89, 238,

- 186, 204, 115, 21, 229, 207, 11, 20, 7, 79, 66, 180, 49, 183, 84, 118,

- 191, 102, 240, 42, 196, 31, 19, 72, 13, 246, 133, 134, 227, 34, 201, 217,

- 150, 218, 238, 219, 12, 91, 69, 251, 115, 3, 101, 193, 235, 16, 79, 76,

- 52, 53, 215, 87, 30, 190, 136, 112, 102, 164, 42, 251, 95, 3, 120, 1,

- 226, 128, 73, 160, 54, 248, 22, 194, 142, 209, 164, 92, 123, 121, 227, 98,

- 201, 233, 150, 206, 238, 212, 76, 95, 117, 248, 39, 2, 154, 129, 171, 32,

- 127, 88, 32, 58, 152, 19, 42, 141, 223, 37, 152, 27, 42, 139, 95, 39,

- 120, 26, 162, 139, 57, 167, 82, 250, 189, 131, 49, 161, 212, 120, 95, 98,

- 184, 41, 178, 158, 245, 168, 71, 62, 178, 144, 117, 172, 39, 61, 218, 145,

- 155, 44, 107, 93, 239, 121, 140, 34, 229, 217, 139, 26, 231, 75, 10, 183,

- 71, 54, 178, 150, 245, 174, 199, 60, 82, 145, 253, 172, 65, 189, 240, 113,

- 132, 36, 99, 91, 105, 251, 110, 195, 108, 81, 237, 252, 77, 129, 245, 160,

- 71, 56, 50, 146, 149, 173, 175, 61, 188, 17, 177, 204, 116, 85, 231, 127,

- 10, 160, 7, 56, 2, 146, 129, 173, 160, 125, 184, 33, 178, 152, 117, 170,

- 167, 63, 58, 144, 19, 44, 13, 221, 197, 153, 147, 42, 237, 223, 13, 152,

- 5, 170, 131, 63, 33, 208, 24, 92, 10, 185, 199, 50, 210, 149, 157, 175,

- 41, 188, 30, 241, 200, 68, 86, 179, 126, 245, 224, 71, 8, 50, 134, 149,

- 162, 239, 57, 140, 18, 229, 205, 139, 21, 167, 79, 58, 180, 19, 55, 77,

- 214, 181, 158, 247, 40, 70, 158, 178, 232, 117, 142, 167, 36, 122, 155, 99,

- 43, 105, 223, 110, 216, 44, 90, 157, 251, 41, 131, 94, 225, 248, 72, 66,

- 182, 177, 182, 244, 118, 199, 102, 210, 170, 221, 191, 25, 176, 10, 244, 7,

- 7, 66, 130, 177, 161, 180, 120, 119, 98, 166, 169, 186, 254, 243, 0, 69,

- 192, 51, 16, 21, 204, 15, 21, 196, 15, 19, 68, 13, 243, 69, 133, 243,

- 35, 5, 217, 195, 26, 209, 203, 28, 87, 73, 254, 182, 192, 118, 208, 38,

- 220, 26, 217, 203, 26, 215, 75, 30, 183, 72, 118, 182, 166, 246, 250, 198,

- 195, 18, 209, 205, 156, 85, 169, 255, 62, 192, 16, 80, 12, 60, 5, 209,

- 195, 28, 81, 201, 252, 86, 193, 254, 208, 64, 92, 48, 57, 212, 18, 223,

- 77, 152, 53, 170, 151, 63, 46, 144, 28, 108, 9, 237, 198, 205, 146, 213,

- 173, 159, 61, 168, 17, 190, 140, 112, 101, 228, 43, 11, 95, 71, 120, 50,

- 162, 149, 185, 175, 50, 252, 21, 129, 207, 32, 84, 24, 63, 74, 144, 55,

- 44, 22, 157, 206, 233, 148, 78, 239, 116, 76, 39, 117, 218, 167, 27, 58,

- 139, 83, 39, 125, 218, 161, 155, 56, 107, 82, 175, 125, 188, 33, 177, 216,

- 116, 90, 167, 123, 58, 163, 83, 57, 253, 210, 193, 157, 144, 105, 172, 46,

- 253, 220, 65, 153, 240, 106, 196, 47, 19, 92, 13, 249, 197, 130, 211, 33,

- 157, 216, 105, 154, 174, 235, 60, 79, 81, 244, 60, 71, 81, 242, 188, 69,

- 177, 243, 52, 69, 215, 115, 30, 165, 200, 123, 22, 163, 78, 249, 244, 66,

- 199, 113, 146, 164, 109, 187, 109, 179, 109, 181, 237, 183, 13, 182, 133, 182,

- 227, 54, 201, 214, 214, 222, 222, 216, 88, 90, 186, 187, 51, 51, 255, 63 )

-

-random_mask_vec8 = numpy.array(random_mask_tuple, numpy.uint8)

-#!/usr/bin/env python

-#

-# Copyright 2006-2008 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

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

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

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

-# any later version.

-#

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

-# but WITHOUT ANY WARRANTY; without even the implied warranty of

-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-# GNU General Public License for more details.

-#

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

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

-# the Free Software Foundation, Inc., 51 Franklin Street,

-# Boston, MA 02110-1301, USA.

-#

-

-from __future__ import absolute_import

-from __future__ import division

-from __future__ import unicode_literals

-

-import math

-from numpy import fft

-from gnuradio import fft as gr_fft

-from gnuradio import gr

-from gnuradio import analog

-from gnuradio import blocks

-from gnuradio import filter

-

-from . import digital_swig as digital

-from .ofdm_sync_pn import ofdm_sync_pn

-from .ofdm_sync_fixed import ofdm_sync_fixed

-from .ofdm_sync_pnac import ofdm_sync_pnac

-from .ofdm_sync_ml import ofdm_sync_ml

-

-

-class ofdm_receiver(gr.hier_block2):

- """

- Performs receiver synchronization on OFDM symbols.

-

- The receiver performs channel filtering as well as symbol, frequency, and phase synchronization.

- The synchronization routines are available in three flavors: preamble correlator (Schmidl and Cox),

- modified preamble correlator with autocorrelation (not yet working), and cyclic prefix correlator

- (Van de Beeks).

- """

-

- def __init__(self, fft_length, cp_length, occupied_tones, snr, ks, logging=False):

- """

- Hierarchical block for receiving OFDM symbols.

-

- The input is the complex modulated signal at baseband.

- Synchronized packets are sent back to the demodulator.

-

- Args:

- fft_length: total number of subcarriers (int)

- cp_length: length of cyclic prefix as specified in subcarriers (<= fft_length) (int)

- occupied_tones: number of subcarriers used for data (int)

- snr: estimated signal to noise ratio used to guide cyclic prefix synchronizer (float)

- ks: known symbols used as preambles to each packet (list of lists)

- logging: turn file logging on or off (bool)

- """

-

- gr.hier_block2.__init__(self, "ofdm_receiver",

- gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature

- gr.io_signature2(2, 2, gr.sizeof_gr_complex*occupied_tones, gr.sizeof_char)) # Output signature

-

- bw = (float(occupied_tones) / float(fft_length)) / 2.0

- tb = bw*0.08

- chan_coeffs = filter.firdes.low_pass (1.0, # gain

- 1.0, # sampling rate

- bw+tb, # midpoint of trans. band

- tb, # width of trans. band

- filter.firdes.WIN_HAMMING) # filter type

- self.chan_filt = filter.fft_filter_ccc(1, chan_coeffs)

-

- win = [1 for i in range(fft_length)]

-

- zeros_on_left = int(math.ceil((fft_length - occupied_tones) / 2.0))

- ks0 = fft_length*[0,]

- ks0[zeros_on_left : zeros_on_left + occupied_tones] = ks[0]

-

- ks0 = fft.ifftshift(ks0)

- ks0time = fft.ifft(ks0)

- # ADD SCALING FACTOR

- ks0time = ks0time.tolist()

-

- SYNC = "pn"

- if SYNC == "ml":

- nco_sensitivity = -1.0 / fft_length # correct for fine frequency

- self.ofdm_sync = ofdm_sync_ml(fft_length,

- cp_length,

- snr,

- ks0time,

- logging)

- elif SYNC == "pn":

- nco_sensitivity = -2.0 / fft_length # correct for fine frequency

- self.ofdm_sync = ofdm_sync_pn(fft_length,

- cp_length,

- logging)

- elif SYNC == "pnac":

- nco_sensitivity = -2.0 / fft_length # correct for fine frequency

- self.ofdm_sync = ofdm_sync_pnac(fft_length,

- cp_length,

- ks0time,

- logging)

- # for testing only; do not user over the air

- # remove filter and filter delay for this

- elif SYNC == "fixed":

- self.chan_filt = blocks.multiply_const_cc(1.0)

- nsymbols = 18 # enter the number of symbols per packet

- freq_offset = 0.0 # if you use a frequency offset, enter it here

- nco_sensitivity = -2.0 / fft_length # correct for fine frequency

- self.ofdm_sync = ofdm_sync_fixed(fft_length,

- cp_length,

- nsymbols,

- freq_offset,

- logging)

-

- # Set up blocks

-

- self.nco = analog.frequency_modulator_fc(nco_sensitivity) # generate a signal proportional to frequency error of sync block

- self.sigmix = blocks.multiply_cc()

- self.sampler = digital.ofdm_sampler(fft_length, fft_length+cp_length)

- self.fft_demod = gr_fft.fft_vcc(fft_length, True, win, True)

- self.ofdm_frame_acq = digital.ofdm_frame_acquisition(occupied_tones,

- fft_length,

- cp_length, ks[0])

-

- self.connect(self, self.chan_filt) # filter the input channel

- self.connect(self.chan_filt, self.ofdm_sync) # into the synchronization alg.

- self.connect((self.ofdm_sync,0), self.nco, (self.sigmix,1)) # use sync freq. offset output to derotate input signal

- self.connect(self.chan_filt, (self.sigmix,0)) # signal to be derotated

- self.connect(self.sigmix, (self.sampler,0)) # sample off timing signal detected in sync alg

- self.connect((self.ofdm_sync,1), (self.sampler,1)) # timing signal to sample at

-

- self.connect((self.sampler,0), self.fft_demod) # send derotated sampled signal to FFT

- self.connect(self.fft_demod, (self.ofdm_frame_acq,0)) # find frame start and equalize signal

- self.connect((self.sampler,1), (self.ofdm_frame_acq,1)) # send timing signal to signal frame start

- self.connect((self.ofdm_frame_acq,0), (self,0)) # finished with fine/coarse freq correction,

- self.connect((self.ofdm_frame_acq,1), (self,1)) # frame and symbol timing, and equalization

-

- if logging:

- self.connect(self.chan_filt, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-chan_filt_c.dat"))

- self.connect(self.fft_demod, blocks.file_sink(gr.sizeof_gr_complex*fft_length, "ofdm_receiver-fft_out_c.dat"))

- self.connect(self.ofdm_frame_acq,

- blocks.file_sink(gr.sizeof_gr_complex*occupied_tones, "ofdm_receiver-frame_acq_c.dat"))

- self.connect((self.ofdm_frame_acq,1), blocks.file_sink(1, "ofdm_receiver-found_corr_b.dat"))

- self.connect(self.sampler, blocks.file_sink(gr.sizeof_gr_complex*fft_length, "ofdm_receiver-sampler_c.dat"))

- self.connect(self.sigmix, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-sigmix_c.dat"))

- self.connect(self.nco, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-nco_c.dat"))

-#!/usr/bin/env python

-#

-# Copyright 2007,2013 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

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

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

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

-# any later version.

-#

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

-# but WITHOUT ANY WARRANTY; without even the implied warranty of

-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-# GNU General Public License for more details.

-#

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

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

-# the Free Software Foundation, Inc., 51 Franklin Street,

-# Boston, MA 02110-1301, USA.

-#

-

-from __future__ import unicode_literals

-import math

-from gnuradio import gr

-from gnuradio import blocks

-

-class ofdm_sync_fixed(gr.hier_block2):

- def __init__(self, fft_length, cp_length, nsymbols, freq_offset, logging=False):

-

- gr.hier_block2.__init__(self, "ofdm_sync_fixed",

- gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature

- gr.io_signature2(2, 2, gr.sizeof_float, gr.sizeof_char)) # Output signature

-

- # Use a fixed trigger point instead of sync block

- symbol_length = fft_length + cp_length

- pkt_length = nsymbols*symbol_length

- data = (pkt_length)*[0,]

- data[(symbol_length)-1] = 1

- self.peak_trigger = blocks.vector_source_b(data, True)

-

- # Use a pre-defined frequency offset

- foffset = (pkt_length)*[math.pi*freq_offset,]

- self.frequency_offset = blocks.vector_source_f(foffset, True)

-

- self.connect(self, blocks.null_sink(gr.sizeof_gr_complex))

- self.connect(self.frequency_offset, (self,0))

- self.connect(self.peak_trigger, (self,1))

-

- if logging:

- self.connect(self.peak_trigger, blocks.file_sink(gr.sizeof_char, "ofdm_sync_fixed-peaks_b.dat"))

-

-#!/usr/bin/env python

-#

-# Copyright 2007,2008 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

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

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

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

-# any later version.

-#

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

-# but WITHOUT ANY WARRANTY; without even the implied warranty of

-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-# GNU General Public License for more details.

-#

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

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

-# the Free Software Foundation, Inc., 51 Franklin Street,

-# Boston, MA 02110-1301, USA.

-#

-

-from __future__ import division

-from __future__ import unicode_literals

-

-

-from gnuradio import gr, blocks, filter

-

-

-class ofdm_sync_ml(gr.hier_block2):

- def __init__(self, fft_length, cp_length, snr, kstime, logging):

- ''' Maximum Likelihood OFDM synchronizer:

- J. van de Beek, M. Sandell, and P. O. Borjesson, "ML Estimation

- of Time and Frequency Offset in OFDM Systems," IEEE Trans.

- Signal Processing, vol. 45, no. 7, pp. 1800-1805, 1997.

- '''

-

- gr.hier_block2.__init__(self, "ofdm_sync_ml",

- gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature

- gr.io_signature2(2, 2, gr.sizeof_float, gr.sizeof_char)) # Output signature

-

- self.input = blocks.add_const_cc(0)

-

- SNR = 10.0**(snr / 10.0)

- rho = SNR / (SNR + 1.0)

- symbol_length = fft_length + cp_length

-

- # ML Sync

-

- # Energy Detection from ML Sync

-

- self.connect(self, self.input)

-

- # Create a delay line

- self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length)

- self.connect(self.input, self.delay)

-

- # magnitude squared blocks

- self.magsqrd1 = blocks.complex_to_mag_squared()

- self.magsqrd2 = blocks.complex_to_mag_squared()

- self.adder = blocks.add_ff()

-

- moving_sum_taps = [rho / 2 for i in range(cp_length)]

- self.moving_sum_filter = filter.fir_filter_fff(1,moving_sum_taps)

-

- self.connect(self.input,self.magsqrd1)

- self.connect(self.delay,self.magsqrd2)

- self.connect(self.magsqrd1,(self.adder,0))

- self.connect(self.magsqrd2,(self.adder,1))

- self.connect(self.adder,self.moving_sum_filter)

-

-

- # Correlation from ML Sync

- self.conjg = blocks.conjugate_cc();

- self.mixer = blocks.multiply_cc();

-

- movingsum2_taps = [1.0 for i in range(cp_length)]

- self.movingsum2 = filter.fir_filter_ccf(1,movingsum2_taps)

-

- # Correlator data handler

- self.c2mag = blocks.complex_to_mag()

- self.angle = blocks.complex_to_arg()

- self.connect(self.input,(self.mixer,1))

- self.connect(self.delay,self.conjg,(self.mixer,0))

- self.connect(self.mixer,self.movingsum2,self.c2mag)

- self.connect(self.movingsum2,self.angle)

-

- # ML Sync output arg, need to find maximum point of this

- self.diff = blocks.sub_ff()

- self.connect(self.c2mag,(self.diff,0))

- self.connect(self.moving_sum_filter,(self.diff,1))

-

- #ML measurements input to sampler block and detect

- self.f2c = blocks.float_to_complex()

- self.pk_detect = blocks.peak_detector_fb(0.2, 0.25, 30, 0.0005)

- self.sample_and_hold = blocks.sample_and_hold_ff()

-

- # use the sync loop values to set the sampler and the NCO

- # self.diff = theta

- # self.angle = epsilon

-

- self.connect(self.diff, self.pk_detect)

-

- # The DPLL corrects for timing differences between CP correlations

- use_dpll = 0

- if use_dpll:

- self.dpll = gr.dpll_bb(float(symbol_length),0.01)

- self.connect(self.pk_detect, self.dpll)

- self.connect(self.dpll, (self.sample_and_hold,1))

- else:

- self.connect(self.pk_detect, (self.sample_and_hold,1))

-

- self.connect(self.angle, (self.sample_and_hold,0))

-

- ################################

- # correlate against known symbol

- # This gives us the same timing signal as the PN sync block only on the preamble

- # we don't use the signal generated from the CP correlation because we don't want

- # to readjust the timing in the middle of the packet or we ruin the equalizer settings.

- kstime = [k.conjugate() for k in kstime]

- kstime.reverse()

- self.kscorr = filter.fir_filter_ccc(1, kstime)

- self.corrmag = blocks.complex_to_mag_squared()

- self.div = blocks.divide_ff()

-

- # The output signature of the correlation has a few spikes because the rest of the

- # system uses the repeated preamble symbol. It needs to work that generically if

- # anyone wants to use this against a WiMAX-like signal since it, too, repeats.

- # The output theta of the correlator above is multiplied with this correlation to

- # identify the proper peak and remove other products in this cross-correlation

- self.threshold_factor = 0.1

- self.slice = blocks.threshold_ff(self.threshold_factor, self.threshold_factor, 0)

- self.f2b = blocks.float_to_char()

- self.b2f = blocks.char_to_float()

- self.mul = blocks.multiply_ff()

-

- # Normalize the power of the corr output by the energy. This is not really needed

- # and could be removed for performance, but it makes for a cleaner signal.

- # if this is removed, the threshold value needs adjustment.

- self.connect(self.input, self.kscorr, self.corrmag, (self.div,0))

- self.connect(self.moving_sum_filter, (self.div,1))

-

- self.connect(self.div, (self.mul,0))

- self.connect(self.pk_detect, self.b2f, (self.mul,1))

- self.connect(self.mul, self.slice)

-

- # Set output signals

- # Output 0: fine frequency correction value

- # Output 1: timing signal

- self.connect(self.sample_and_hold, (self,0))

- self.connect(self.slice, self.f2b, (self,1))

-

-

- if logging:

- self.connect(self.moving_sum_filter, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-energy_f.dat"))

- self.connect(self.diff, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-theta_f.dat"))

- self.connect(self.angle, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-epsilon_f.dat"))

- self.connect(self.corrmag, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-corrmag_f.dat"))

- self.connect(self.kscorr, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_sync_ml-kscorr_c.dat"))

- self.connect(self.div, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-div_f.dat"))

- self.connect(self.mul, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-mul_f.dat"))

- self.connect(self.slice, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-slice_f.dat"))

- self.connect(self.pk_detect, blocks.file_sink(gr.sizeof_char, "ofdm_sync_ml-peaks_b.dat"))

- if use_dpll:

- self.connect(self.dpll, blocks.file_sink(gr.sizeof_char, "ofdm_sync_ml-dpll_b.dat"))

-

- self.connect(self.sample_and_hold, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-sample_and_hold_f.dat"))

- self.connect(self.input, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_sync_ml-input_c.dat"))

-

-#!/usr/bin/env python

-#

-# Copyright 2007,2008 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

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

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

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

-# any later version.

-#

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

-# but WITHOUT ANY WARRANTY; without even the implied warranty of

-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-# GNU General Public License for more details.

-#

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

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

-# the Free Software Foundation, Inc., 51 Franklin Street,

-# Boston, MA 02110-1301, USA.

-#

-

-from __future__ import division

-from __future__ import unicode_literals

-

-

-from gnuradio import gr, blocks, filter

-

-

-class ofdm_sync_pn(gr.hier_block2):

- def __init__(self, fft_length, cp_length, logging=False):

- """

- OFDM synchronization using PN Correlation:

- T. M. Schmidl and D. C. Cox, "Robust Frequency and Timing

- Synchronization for OFDM," IEEE Trans. Communications, vol. 45,

- no. 12, 1997.

- """

-

- gr.hier_block2.__init__(self, "ofdm_sync_pn",

- gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature

- gr.io_signature2(2, 2, gr.sizeof_float, gr.sizeof_char)) # Output signature

-

- self.input = blocks.add_const_cc(0)

-

- # PN Sync

-

- # Create a delay line

- self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length / 2)

-

- # Correlation from ML Sync

- self.conjg = blocks.conjugate_cc();

- self.corr = blocks.multiply_cc();

-

- # Create a moving sum filter for the corr output

- self.moving_sum_filter = filter.fir_filter_ccf(1, [1.0] * (fft_length//2))

-

- # Create a moving sum filter for the input

- self.inputmag2 = blocks.complex_to_mag_squared()

- self.inputmovingsum = filter.fir_filter_fff(1, [1.0] * (fft_length//2))

-

- self.square = blocks.multiply_ff()

- self.normalize = blocks.divide_ff()

-

- # Get magnitude (peaks) and angle (phase/freq error)

- self.c2mag = blocks.complex_to_mag_squared()

- self.angle = blocks.complex_to_arg()

-

- self.sample_and_hold = blocks.sample_and_hold_ff()

-

- #ML measurements input to sampler block and detect

- self.sub1 = blocks.add_const_ff(-1)

- self.pk_detect = blocks.peak_detector_fb(0.20, 0.20, 30, 0.001)

-

- self.connect(self, self.input)

-

- # Calculate the frequency offset from the correlation of the preamble

- self.connect(self.input, self.delay)

- self.connect(self.input, (self.corr,0))

- self.connect(self.delay, self.conjg)

- self.connect(self.conjg, (self.corr,1))

- self.connect(self.corr, self.moving_sum_filter)

- self.connect(self.moving_sum_filter, self.c2mag)

- self.connect(self.moving_sum_filter, self.angle)

- self.connect(self.angle, (self.sample_and_hold,0))

-

- # Get the power of the input signal to normalize the output of the correlation

- self.connect(self.input, self.inputmag2, self.inputmovingsum)

- self.connect(self.inputmovingsum, (self.square,0))

- self.connect(self.inputmovingsum, (self.square,1))

- self.connect(self.square, (self.normalize,1))

- self.connect(self.c2mag, (self.normalize,0))

-

- # Create a moving sum filter for the corr output

- matched_filter_taps = [1.0 / cp_length for i in range(cp_length)]

- self.matched_filter = filter.fir_filter_fff(1,matched_filter_taps)

- self.connect(self.normalize, self.matched_filter)

-

- self.connect(self.matched_filter, self.sub1, self.pk_detect)

- #self.connect(self.matched_filter, self.pk_detect)

- self.connect(self.pk_detect, (self.sample_and_hold,1))

-

- # Set output signals

- # Output 0: fine frequency correction value

- # Output 1: timing signal

- self.connect(self.sample_and_hold, (self,0))

- self.connect(self.pk_detect, (self,1))

-

- if logging:

- self.connect(self.matched_filter, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-mf_f.dat"))

- self.connect(self.normalize, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-theta_f.dat"))

- self.connect(self.angle, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-epsilon_f.dat"))

- self.connect(self.pk_detect, blocks.file_sink(gr.sizeof_char, "ofdm_sync_pn-peaks_b.dat"))

- self.connect(self.sample_and_hold, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-sample_and_hold_f.dat"))

- self.connect(self.input, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_sync_pn-input_c.dat"))

-#!/usr/bin/env python

-#

-# Copyright 2007 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

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

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

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

-# any later version.

-#

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

-# but WITHOUT ANY WARRANTY; without even the implied warranty of

-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-# GNU General Public License for more details.

-#

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

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

-# the Free Software Foundation, Inc., 51 Franklin Street,

-# Boston, MA 02110-1301, USA.

-#

-

-from __future__ import division

-from __future__ import unicode_literals

-

-

-from gnuradio import gr, blocks, filter

-

-

-class ofdm_sync_pnac(gr.hier_block2):

- def __init__(self, fft_length, cp_length, kstime, logging=False):

- """

- OFDM synchronization using PN Correlation and initial cross-correlation:

- F. Tufvesson, O. Edfors, and M. Faulkner, "Time and Frequency Synchronization for OFDM using

- PN-Sequency Preambles," IEEE Proc. VTC, 1999, pp. 2203-2207.

-

- This implementation is meant to be a more robust version of the Schmidl and Cox receiver design.

- By correlating against the preamble and using that as the input to the time-delayed correlation,

- this circuit produces a very clean timing signal at the end of the preamble. The timing is

- more accurate and does not have the problem associated with determining the timing from the

- plateau structure in the Schmidl and Cox.

-

- This implementation appears to require that the signal is received with a normalized power or signal

- scaling factor to reduce ambiguities introduced from partial correlation of the cyclic prefix and

- the peak detection. A better peak detection block might fix this.

-

- Also, the cross-correlation falls apart as the frequency offset gets larger and completely fails

- when an integer offset is introduced. Another thing to look at.

- """

-

- gr.hier_block2.__init__(self, "ofdm_sync_pnac",

- gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature

- gr.io_signature2(2, 2, gr.sizeof_float, gr.sizeof_char)) # Output signature

-

- self.input = blocks.add_const_cc(0)

-

- symbol_length = fft_length + cp_length

-

- # PN Sync with cross-correlation input

-

- # cross-correlate with the known symbol

- kstime = [k.conjugate() for k in kstime[0:fft_length//2]]

- kstime.reverse()

- self.crosscorr_filter = filter.fir_filter_ccc(1, kstime)

-

- # Create a delay line

- self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length / 2)

-

- # Correlation from ML Sync

- self.conjg = blocks.conjugate_cc();

- self.corr = blocks.multiply_cc();

-

- # Create a moving sum filter for the input

- self.mag = blocks.complex_to_mag_squared()

- self.power = filter.fir_filter_fff(1, [1.0] * int(fft_length))

-

- # Get magnitude (peaks) and angle (phase/freq error)

- self.c2mag = blocks.complex_to_mag_squared()

- self.angle = blocks.complex_to_arg()

- self.compare = blocks.sub_ff()

-

- self.sample_and_hold = blocks.sample_and_hold_ff()

-

- #ML measurements input to sampler block and detect

- self.threshold = blocks.threshold_ff(0,0,0) # threshold detection might need to be tweaked

- self.peaks = blocks.float_to_char()

-

- self.connect(self, self.input)

-

- # Cross-correlate input signal with known preamble

- self.connect(self.input, self.crosscorr_filter)

-

- # use the output of the cross-correlation as input time-shifted correlation

- self.connect(self.crosscorr_filter, self.delay)

- self.connect(self.crosscorr_filter, (self.corr,0))

- self.connect(self.delay, self.conjg)

- self.connect(self.conjg, (self.corr,1))

- self.connect(self.corr, self.c2mag)

- self.connect(self.corr, self.angle)

- self.connect(self.angle, (self.sample_and_hold,0))

-

- # Get the power of the input signal to compare against the correlation

- self.connect(self.crosscorr_filter, self.mag, self.power)

-

- # Compare the power to the correlator output to determine timing peak

- # When the peak occurs, it peaks above zero, so the thresholder detects this

- self.connect(self.c2mag, (self.compare,0))

- self.connect(self.power, (self.compare,1))

- self.connect(self.compare, self.threshold)

- self.connect(self.threshold, self.peaks, (self.sample_and_hold,1))

-

- # Set output signals

- # Output 0: fine frequency correction value

- # Output 1: timing signal

- self.connect(self.sample_and_hold, (self,0))

- self.connect(self.peaks, (self,1))

-

- if logging:

- self.connect(self.compare, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-compare_f.dat"))

- self.connect(self.c2mag, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-theta_f.dat"))

- self.connect(self.power, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-inputpower_f.dat"))

- self.connect(self.angle, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-epsilon_f.dat"))

- self.connect(self.threshold, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-threshold_f.dat"))

- self.connect(self.peaks, blocks.file_sink(gr.sizeof_char, "ofdm_sync_pnac-peaks_b.dat"))

- self.connect(self.sample_and_hold, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-sample_and_hold_f.dat"))

- self.connect(self.input, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_sync_pnac-input_c.dat"))

- self.connect(header_descrambler, blocks.file_sink(1, 'post-hdr-demod.dat'))

- self.connect(crc, blocks.file_sink(1, 'post-payload-crc.dat'))