git.gag.com Git - debian/gnuradio/blob - gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.cc

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2006 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GNU Radio
   6  *
   7  * GNU Radio is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2, or (at your option)
  10  * any later version.
  11  *
  12  * GNU Radio is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Radio; see the file COPYING.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <gr_ofdm_bpsk_mapper.h>
  28 #include <gr_io_signature.h>
  29 #include <vector>
  30
  31 gr_ofdm_bpsk_mapper_sptr
  32 gr_make_ofdm_bpsk_mapper (unsigned int mtu, unsigned int occupied_carriers, unsigned int vlen,
  33                           std::vector<gr_complex> known_symbol1, std::vector<gr_complex> known_symbol2)
  34 {
  35   return gr_ofdm_bpsk_mapper_sptr (new gr_ofdm_bpsk_mapper (mtu, occupied_carriers, vlen,
  36                                                             known_symbol1, known_symbol2));
  37 }
  38
  39 gr_ofdm_bpsk_mapper::gr_ofdm_bpsk_mapper (unsigned int mtu, unsigned int occupied_carriers, unsigned int vlen,
  40                                           std::vector<gr_complex> known_symbol1,
  41                                           std::vector<gr_complex> known_symbol2)
  42   : gr_block ("ofdm_bpsk_mapper",
  43               gr_make_io_signature (1, 1, 2*sizeof(int) + sizeof(unsigned char)*mtu),
  44               gr_make_io_signature (1, 1, sizeof(gr_complex)*vlen)),
  45     d_mtu(mtu),
  46     d_occupied_carriers(occupied_carriers),
  47     d_vlen(vlen),
  48     d_packet_offset(0),
  49     d_bit_offset(0),
  50     d_header_sent(0),
  51     d_known_symbol1(known_symbol1),
  52     d_known_symbol2(known_symbol2)
  53
  54 {
  55   assert(d_occupied_carriers < d_vlen);
  56   assert(d_occupied_carriers == d_known_symbol1.size());
  57   assert(d_occupied_carriers == d_known_symbol2.size());
  58 }
  59
  60 gr_ofdm_bpsk_mapper::~gr_ofdm_bpsk_mapper(void)
  61 {
  62 }
  63
  64 void
  65 gr_ofdm_bpsk_mapper::forecast (int noutput_items, gr_vector_int &ninput_items_required)
  66 {
  67   unsigned ninputs = ninput_items_required.size ();
  68   for (unsigned i = 0; i < ninputs; i++)
  69     ninput_items_required[i] = 1;
  70 }
  71
  72 int
  73 gr_ofdm_bpsk_mapper::general_work(int noutput_items,
  74                                   gr_vector_int &ninput_items,
  75                                   gr_vector_const_void_star &input_items,
  76                                   gr_vector_void_star &output_items)
  77 {
  78   const gr_frame *in = (const gr_frame *) input_items[0];
  79   gr_complex *out = (gr_complex *)output_items[0];
  80
  81   unsigned int i=0;
  82   unsigned int num_symbols = 0, pkt_length;
  83
  84   //printf("OFDM BPSK Mapper:  ninput_items: %d   noutput_items: %d\n", ninput_items[0], noutput_items);
  85
  86   pkt_length = in[0].length;
  87
  88   std::vector<gr_complex>::iterator ks_itr;
  89   if(d_header_sent == 0) {
  90      ks_itr = d_known_symbol1.begin();
  91   }
  92   else if(d_header_sent == 1) {
  93     ks_itr = d_known_symbol2.begin();
  94   }
  95
  96   if(d_header_sent < 2) {
  97     //  Add training symbols here
  98     for(i=0; i < (ceil((d_vlen - d_occupied_carriers)/2.0)); i++) {
  99       out[i] = gr_complex(0,0);
 100     }
 101     for(;i<d_vlen - ceil((d_vlen-d_occupied_carriers)/2.0);i++) {
 102       //out[i] = gr_complex(1,0);
 103       out[i] = *(ks_itr++);
 104     }
 105     for(; i < d_vlen; i++) {
 106       out[i] = gr_complex(0,0);
 107     }
 108
 109     num_symbols = 1;
 110     out += d_vlen;
 111     d_header_sent++;
 112   }
 113
 114   unsigned int unoccupied_carriers = d_vlen - d_occupied_carriers;
 115   unsigned int zeros_on_left = (unsigned)ceil(unoccupied_carriers/2.0);
 116   unsigned int zeros_on_right = unoccupied_carriers - zeros_on_left;
 117
 118   while(num_symbols < (unsigned)noutput_items) {
 119
 120     // stick in unused carriers
 121     for(i = d_vlen-zeros_on_right; i < d_vlen; i++) {
 122       out[i] = gr_complex(0,0);
 123     }
 124
 125     for(i=0; i < zeros_on_left; i++) {
 126       out[i] = gr_complex(0,0);
 127     }
 128
 129     while((d_packet_offset < pkt_length) && (i < d_vlen-zeros_on_right)) {
 130       unsigned char bit = (in[0].data[d_packet_offset] >> (d_bit_offset++)) & 0x01;
 131       out[i++] = gr_complex(-1+2*(bit));
 132       if(d_bit_offset == 8) {
 133         d_bit_offset = 0;
 134         d_packet_offset++;
 135       }
 136     }
 137
 138     // Ran out of data to put in symbols
 139     if(d_packet_offset == pkt_length) {
 140       while(i < d_vlen-zeros_on_right) {
 141         out[i++] = gr_complex(0,0);
 142       }
 143
 144       d_packet_offset = 0;
 145       assert(d_bit_offset == 0);
 146       num_symbols++;
 147       d_header_sent = 0;
 148       consume_each(1);
 149       return num_symbols;
 150     }
 151
 152     // Ran out of space in symbol
 153     out += d_vlen;
 154     num_symbols++;
 155   }
 156   consume_each(0);
 157   return num_symbols;
 158 }
 159