Added ofdm_frame_sink2. Like ofdm_frame_sink but uses constellation object.

6 files changed, 537 insertions, 2 deletions

diff --git a/gnuradio-core/src/lib/general/Makefile.am b/gnuradio-core/src/lib/general/Makefile.am
index fad2536bf..e5ea49640 100644
--- a/gnuradio-core/src/lib/general/Makefile.am
+++ b/gnuradio-core/src/lib/general/Makefile.am
@@ -113,6 +113,7 @@ libgeneral_la_SOURCES = 		\
         gr_ofdm_demapper_vcb.cc         \
         gr_ofdm_mapper_bcv.cc           \
 	gr_ofdm_frame_sink.cc		\
+	gr_ofdm_frame_sink2.cc		\
 	gr_ofdm_insert_preamble.cc	\
         gr_ofdm_sampler.cc              \
 	gr_pa_2x2_phase_combiner.cc	\
@@ -276,6 +277,7 @@ grinclude_HEADERS = 			\
         gr_ofdm_demapper_vcb.h          \
         gr_ofdm_mapper_bcv.h            \
         gr_ofdm_frame_sink.h		\
+        gr_ofdm_frame_sink2.h		\
 	gr_ofdm_insert_preamble.h	\
 	gr_ofdm_sampler.h               \
 	gr_pa_2x2_phase_combiner.h	\
@@ -441,6 +443,7 @@ swiginclude_HEADERS =			\
         gr_ofdm_demapper_vcb.i          \
         gr_ofdm_mapper_bcv.i            \
         gr_ofdm_frame_sink.i		\
+        gr_ofdm_frame_sink2.i		\
 	gr_ofdm_insert_preamble.i	\
 	gr_ofdm_sampler.i               \
 	gr_pa_2x2_phase_combiner.i	\
diff --git a/gnuradio-core/src/lib/general/general.i b/gnuradio-core/src/lib/general/general.i
index 7e845cb21..aa7d95ff2 100644
--- a/gnuradio-core/src/lib/general/general.i
+++ b/gnuradio-core/src/lib/general/general.i
@@ -99,6 +99,7 @@
 #include <gr_ofdm_cyclic_prefixer.h>
 #include <gr_ofdm_mapper_bcv.h>
 #include <gr_ofdm_frame_sink.h>
+#include <gr_ofdm_frame_sink2.h>
 #include <gr_ofdm_insert_preamble.h>
 #include <gr_ofdm_sampler.h>
 #include <gr_regenerate_bb.h>
@@ -226,6 +227,7 @@
 %include "gr_ofdm_cyclic_prefixer.i"
 %include "gr_ofdm_mapper_bcv.i"
 %include "gr_ofdm_frame_sink.i"
+%include "gr_ofdm_frame_sink2.i"
 %include "gr_ofdm_insert_preamble.i"
 %include "gr_ofdm_sampler.i"
 %include "gr_regenerate_bb.i"
diff --git a/gnuradio-core/src/lib/general/gr_ofdm_frame_sink2.cc b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink2.cc
new file mode 100644
index 000000000..8d104e7be
--- /dev/null
+++ b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink2.cc
@@ -0,0 +1,371 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007,2008,2010 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 <gr_ofdm_frame_sink2.h>
+#include <gr_io_signature.h>
+#include <gr_expj.h>
+#include <gr_math.h>
+#include <math.h>
+#include <cstdio>
+#include <stdexcept>
+#include <iostream>
+#include <string.h>
+#include <gr_constellation.h>
+
+#define VERBOSE 0
+
+inline void
+gr_ofdm_frame_sink2::enter_search()
+{
+  if (VERBOSE)
+    fprintf(stderr, "@ enter_search\n");
+
+  d_state = STATE_SYNC_SEARCH;
+
+}
+    
+inline void
+gr_ofdm_frame_sink2::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
+gr_ofdm_frame_sink2::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);
+}
+
+
+unsigned int gr_ofdm_frame_sink2::demapper(const gr_complex *in,
+					  unsigned 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;
+      }
+      
+      unsigned char bits = d_constell->decision_maker(sigrot);
+
+      gr_complex closest_sym = d_constell->points()[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*M_PI) d_phase -= 2*M_PI;
+  if (d_phase <0) d_phase += 2*M_PI;
+    
+  //if(VERBOSE)
+  //  std::cerr << angle << "\t" << d_freq << "\t" << d_phase << "\t" << std::endl;
+  
+  return bytes_produced;
+}
+
+
+gr_ofdm_frame_sink2_sptr
+gr_make_ofdm_frame_sink2(gr_constellation_sptr constell,
+			gr_msg_queue_sptr target_queue, unsigned int occupied_carriers,
+			float phase_gain, float freq_gain)
+{
+  return gnuradio::get_initial_sptr(new gr_ofdm_frame_sink2(constell,
+							target_queue, occupied_carriers,
+							phase_gain, freq_gain));
+}
+
+
+gr_ofdm_frame_sink2::gr_ofdm_frame_sink2(gr_constellation_sptr constell,
+				       gr_msg_queue_sptr target_queue, unsigned int occupied_carriers,
+				       float phase_gain, float freq_gain)
+  : gr_sync_block ("ofdm_frame_sink2",
+		   gr_make_io_signature2 (2, 2, sizeof(gr_complex)*occupied_carriers, sizeof(char)),
+		   gr_make_io_signature (1, 1, sizeof(gr_complex)*occupied_carriers)),
+    d_constell(constell),
+    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)
+{
+  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
+  unsigned int i,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() > d_occupied_carriers) {
+    throw std::invalid_argument("gr_ofdm_mapper_bcv: subcarriers allocated exceeds size of occupied carriers");
+  }
+
+  d_bytes_out = new unsigned char[d_occupied_carriers];
+  d_dfe.resize(occupied_carriers);
+  fill(d_dfe.begin(), d_dfe.end(), gr_complex(1.0,0.0));
+
+  d_nbits = d_constell->bits_per_symbol();
+
+  enter_search();
+}
+
+gr_ofdm_frame_sink2::~gr_ofdm_frame_sink2 ()
+{
+  delete [] d_bytes_out;
+}
+
+
+int
+gr_ofdm_frame_sink2::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) {
+	    gr_message_sptr msg =
+	      gr_make_message(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
+	gr_message_sptr msg =
+	  gr_make_message(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;
+}
diff --git a/gnuradio-core/src/lib/general/gr_ofdm_frame_sink2.h b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink2.h
new file mode 100644
index 000000000..647ce7958
--- /dev/null
+++ b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink2.h
@@ -0,0 +1,120 @@
+/* -*- c++ -*- */
+/*
+ * 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.
+ */
+
+#ifndef INCLUDED_GR_OFDM_FRAME_SINK2_H
+#define INCLUDED_GR_OFDM_FRAME_SINK2_H
+
+#include <gr_sync_block.h>
+#include <gr_msg_queue.h>
+#include <gr_constellation.h>
+
+class gr_ofdm_frame_sink2;
+typedef boost::shared_ptr<gr_ofdm_frame_sink2> gr_ofdm_frame_sink2_sptr;
+
+gr_ofdm_frame_sink2_sptr 
+gr_make_ofdm_frame_sink2 (gr_constellation_sptr constell,
+			 gr_msg_queue_sptr target_queue, unsigned int occupied_tones,
+			 float phase_gain=0.25, float freq_gain=0.25*0.25/4.0);
+
+/*!
+ * \brief Takes an OFDM symbol in, demaps it into bits of 0's and 1's, packs
+ * them into packets, and sends to to a message queue sink.
+ * \ingroup sink_blk
+ * \ingroup ofdm_blk
+ *
+ * NOTE: The mod input parameter simply chooses a pre-defined demapper/slicer. Eventually,
+ * we want to be able to pass in a reference to an object to do the demapping and slicing
+ * for a given modulation type.
+ */
+class gr_ofdm_frame_sink2 : public gr_sync_block
+{
+  friend gr_ofdm_frame_sink2_sptr 
+  gr_make_ofdm_frame_sink2 (gr_constellation_sptr constell, 
+			   gr_msg_queue_sptr target_queue, unsigned int occupied_tones,
+			   float phase_gain, float freq_gain);
+
+ private:
+  enum state_t {STATE_SYNC_SEARCH, STATE_HAVE_SYNC, STATE_HAVE_HEADER};
+
+  static const int MAX_PKT_LEN    = 4096;
+  static const int HEADERBYTELEN   = 4;
+
+  gr_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
+
+  unsigned char      *d_bytes_out;              // hold the current bytes produced by the demapper    
+
+  unsigned int       d_occupied_carriers;
+  unsigned int       d_byte_offset;
+  unsigned int       d_partial_byte;
+
+  unsigned 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
+
+  gr_constellation_sptr      d_constell;
+  std::vector<gr_complex>    d_dfe;
+  unsigned int d_nbits;
+
+  unsigned 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:
+  gr_ofdm_frame_sink2(gr_constellation_sptr constell,
+		     gr_msg_queue_sptr target_queue, unsigned int occupied_tones,
+		     float phase_gain, float freq_gain);
+
+  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;
+  }
+  
+  unsigned char slicer(const gr_complex x);
+  unsigned int demapper(const gr_complex *in,
+			unsigned char *out);
+
+ public:
+  ~gr_ofdm_frame_sink2();
+
+  int work(int noutput_items,
+	   gr_vector_const_void_star &input_items,
+	   gr_vector_void_star &output_items);
+};
+
+#endif /* INCLUDED_GR_OFDM_FRAME_SINK2_H */
diff --git a/gnuradio-core/src/lib/general/gr_ofdm_frame_sink2.i b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink2.i
new file mode 100644
index 000000000..24d4b32bd
--- /dev/null
+++ b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink2.i
@@ -0,0 +1,39 @@
+/* -*- c++ -*- */
+/*
+ * 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.
+ */
+
+GR_SWIG_BLOCK_MAGIC(gr,ofdm_frame_sink2);
+
+gr_ofdm_frame_sink2_sptr 
+gr_make_ofdm_frame_sink2(gr_constellation_sptr constell,
+			gr_msg_queue_sptr target_queue, unsigned int occupied_tones,
+			float phase_gain=0.25, float freq_gain=0.25*0.25/4);
+
+class gr_ofdm_frame_sink2 : public gr_sync_block
+{
+ protected:
+  gr_ofdm_frame_sink2(gr_constellation_sptr constell,
+		     gr_msg_queue_sptr target_queue, unsigned int occupied_tones,
+		     float phase_gain, float freq_gain);
+
+ public:
+  ~gr_ofdm_frame_sink2();
+};
diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/ofdm.py b/gnuradio-core/src/python/gnuradio/blks2impl/ofdm.py
index 7e01e67b4..997df0bdf 100644
--- a/gnuradio-core/src/python/gnuradio/blks2impl/ofdm.py
+++ b/gnuradio-core/src/python/gnuradio/blks2impl/ofdm.py
@@ -216,11 +216,11 @@ class ofdm_demod(gr.hier_block2):
                                        self._occupied_tones, self._snr, preambles,
                                        options.log)
 
-        constell = modulation_utils2.type_1_constellations()[self._modulation](arity).points()
+        constell = modulation_utils2.type_1_constellations()[self._modulation](arity)
 
         phgain = 0.25
         frgain = phgain*phgain / 4.0
-        self.ofdm_demod = gr.ofdm_frame_sink(constell, range(arity),
+        self.ofdm_demod = gr.ofdm_frame_sink2(constell.base(),
                                              self._rcvd_pktq,
                                              self._occupied_tones,
                                              phgain, frgain)