modem/modem_OFDM1.hpp

/*
 * Copyright 2011-2013, Per Zetterberg
 *
 * This program 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 of the License, or
 * (at your option) any later version.
 *
 * This program 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, see <http://www.gnu.org/licenses/>.
 */

/* This code should implement, more or less, the same functions as 
 * 
 * mod_OFDM1.m and demod_OFDM1.m
 *
 *
 */

#include <itpp/itcomm.h>
#include <complex>

 
using namespace std;
using namespace itpp;

#ifndef MODEM_OFDM1_H
#define MODEM_OFDM1_H

class OFDM1 {

public:

  static const uint32_t rightmost_carrier=19;
  static const uint32_t leftmost_carrier=61;
  static const uint32_t Nfft=80;
  static const uint32_t pilot_carrier1=10;
  static const uint32_t pilot_carrier2=71;
  static const uint32_t Nfft_sync=65536; // Frequency offsets with 25e6/Nfft_sync spacing.
  static const uint32_t gap=3;
  

  ivec known_symbol_pos;
  ivec interferers_known_pos;
  uint32_t Ns;//, nof_symbols_storage;
  complex<double> pilot_symbol;
  //uint32_t storage_ix;
  ivec ix, ix_all, ix_sub;
  cvec debug1;
  cvec debug2;
  uint32_t length_ix, length_ix_all;
  int pilot_carrier1_sub, pilot_carrier2_sub;
  int rightmost_carrier_sub, leftmost_carrier_sub;
  //cvec ConstellationStorage; //(length_ix*nof_symbols_storage);
  cvec train;
  cvec h;
  cvec pulse_shape;
  int pulse_shape_delay;
  bool do_use_pilot_carriers, do_prepend_training;
  uint32_t Np;
  ivec d_reorder;
  double pilot_power_factor;
  cmat he; // Channel estimate of desired signal stream
  cmat hi[10]; // Channel estimate of at most 10 interfering signal streams
  cmat x[100]; // Max 100 OFDM symbols
  cmat x_c;
  bool estimate_SINR; // If you want the receiver to estimate it's own SINR.
  double SINR; // Here's the result.
  int noise_estimation_start_ix, noise_estimation_stop_ix; // Defines where
                                   // in the buffer samples can be taken for
                                   // additive noise estimation.

  //OFDM1(bool use_pilot_carriers, bool prepend_training,uint32_t prefix_length);

  OFDM1(void);


  uint32_t Nfftr(void){return Nfft;};

  uint32_t number_of_modulation_symbols(void);

  uint32_t waveform_length(void);

  uint32_t prefix_length(void) { return Np; };
  
  ivec start_of_known_symbol(void);
  
  void init_multi_antenna(uint32_t no_ant, int32_t buffer_size, ivec &interferer_pos);

  void pilot_pattern(cvec &burst, cvec precoder);

  void insert_pilot(cvec &waveform, uint32_t symbol_number, uint32_t offset,
cvec precoder);
 
  
void modulate(cvec &waveform,const cvec &symbols_in,  
               const uint32_t offset,double &rms_power,const cvec &precoder);

  void estimate_channel(cvec waveform,double  &noise_variance_normalized,cvec &h, uint32_t start_sample);  

  void estimate_channel(cvec waveform,double  &noise_variance_normalized,
                      cvec &h, uint32_t start_sample, double &noise_variance);

  void demodulate(const cvec &waveform,cvec &symbols_out, uint32_t start_sample,
           const cvec &h, double &rms_signal);


  void demodulate_multi_antenna(const cmat &waveform,vec &soft_bit, uint32_t start_sample, int modulation_order);


  void extract_multi_antenna(const cmat &waveform,uint32_t start_sample);
 

  void extract_multi_antenna(const cmat &waveform,
                             uint32_t start_sample, cvec &symbols_out); 

  /* \brief Synchronize against synchronization sequence (i.e. the
sequence which is pre-pended if prepend_training=true when calling init),
and simultaneosly search for frequency offset. The function is only
implemented based for using a single antenna.
    \param waveform Received samples.
    \param start_pos Estimated start position.
    \param f_offset Estimated frequency offset.
*/
  void synchronize(cvec &waveform, uint32_t &start_pos,double &f_offset);

  /* \brief Synchronize against synchronization sequence (i.e. the
sequence which is pre-pended if prepend_training=true when calling init),
and simultaneosly search for frequency offset. The function is only
implemented based for using a single antenna.
    \param waveform Received samples.
    \param start_pos Estimated start position.
*/
  void synchronize(cvec &waveform, uint32_t &start_pos);

  void init(bool use_pilot_carriers, bool prepend_training,uint32_t prefix_length,uint32_t Ns, ivec known_pos, ivec re_order);

  void interleave_symbols(cvec &symbol, int index);

  void de_interleave_symbols(cvec &symbol, int index);

  void pz_init_fft(void){
    double a;
    Wfft.set_size(Nfft,Nfft);
    Wifft.set_size(Nfft,Nfft);

    for (uint32_t i1=0;i1<Nfft;i1++) {
      for (uint32_t i2=0;i2<Nfft;i2++) {
        a=-2*pi;
        a=a*i1;
        a=a*i2;
        a=a/Nfft;
        Wfft(i1,i2)=polar(1.0,a);
        a=2*pi;
        a=a*i2;
        a=a*i1;
        a=a/Nfft;
        Wifft(i1,i2)=polar((1.0/Nfft),a);
      };
    };  

  };

  void pz_fft(const cvec &in,cvec &out) { out=Wfft*in; };

  void pz_ifft(const cvec &in,cvec &out) { out=Wifft*in; };

  cmat Wfft;
  cmat Wifft;

  imat symbol_interleave_matrix;
  imat symbol_de_interleave_matrix;
  

};

#endif