transmitter.h

Go to the documentation of this file.

/***************************************************************************
                          transmitter.h  -  description
                             -------------------
    begin                : Mit Mai 22 2002
    copyright            : (C) 2002 by Peter Haase
    email                : mail@p-haase.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef TRANSMITTER_HEADER
#define TRANSMITTER_HEADER

#include <fstream>
#include <string>
#include <exception>

#include "signals.h"
#include "fft.h"
#include "channel.h"
#include "misc.h"

#include "basicdevice.h"
#include "interfaces.h"
#include "modulator.h"


namespace simthlib
{

class Transmitter;

std::ostream& operator<<(std::ostream &os, const Transmitter &tr);






class Transmitter : public simth::Device
{
  public:
    Transmitter(int deviceID, simth::DeviceSystemIntf* system, 
        const simth::PropertyList& pl);

    virtual void  makeSignal(const simth::ModSeq& modSeq, 
                 simth::TimeSignal* outSignal) = 0;

    /* Returns the number of dummy symbols added to the last
    transmitted modulation sequence.
     */
    //virtual int numDummys() const {return 0;}

    virtual void process();

    virtual void print(std::ostream &os) const;


    static void init(const std::string fileName, simth::Device** dev,
             simth::DeviceSystemIntf* sysPtr, int ID,
                     const std::string& regionQualifier = "");

};



namespace ofdm
{

   enum FillUpScheme {TIME, TIME_SNAKE, FREQ, FREQ_SNAKE};

  ofdm::FillUpScheme string_to_diffscheme(const std::string &s);

  void initFillUpScheme(FillUpScheme mode,
            int numOfdmSymbols, 
            int numCarrier, simth::checkedVector<int>* vec);

  std::pair<int,int> index2position(int index,int numCarrier);

  int position2index(int timePos, int carrierPos, int numCarrier);
  
}


class OfdmTransmitter : public Transmitter
{
  private:
    const int oversampling;      // oversampling rate by IDFT (IFFT)
    const int num_carr;          // number of subcarriers
    const double carr_dist;      // subcarrier spacing
    const int space;             // sampling space = 1 !
    double delta_t;
    const int num_guard;         // length of guard interval

    ofdm::FillUpScheme diffDecodingScheme_;

    //can be used to scramble the input bits to provide differential
    //decoding for different schemes,
    //e.g. differential decoding in frequency direction
    simth::checkedVector<int> ofdmIndex2origIndex_;


    simth::Array<Complex> ofdmVector;
    FastFourierTrans fft;

    virtual void fillOfdmSymbol(const simth::ModSeq& modulationSymbols, int blockNumber);


  protected:

    virtual double deltaT() const;

    int numCarrier() const {return num_carr;}
    int symbolsPerOfdm() const {return num_carr;}
    int samplesPerOfdmSymbol() const {return num_carr * oversampling + num_guard;}
    int samplesPerSymbol() const {return oversampling;}
    int numGuard() const {return num_guard;}
    double carrierDistance() const {return carr_dist;}


    void initScramblingVector(ofdm::FillUpScheme mode,simth::checkedVector<int>* vec) const;

    void initOfdm2origVector( );

    ofdm::FillUpScheme diffDecodingScheme() const {return diffDecodingScheme_;}

    int ofdmIndex2origIndex(int ofdmIndex) const;


    std::pair<int, int> index2position(int ofdmIndex) const;

    int position2index(int timePos, int freqPos) const;


    void addGuard(const simth::Array<Complex> &inArray, simth::Array<Complex>* outArray) const;

    void IFFT(const simth::Array<Complex> &freqArray, simth::Array<Complex>* timeArray) const;

    void transmitOfdmSymbol(simth::TimeSignal* timeSig,int currBlockNumber) const;

    double oneOverTimeDistance() const;

    int computeNumGuardSamples(double guardTime) const;

    void invariante() const;

    int numTimeSamples(int numModSymbols) const;

  public:
    OfdmTransmitter(int deviceID, simth::DeviceSystemIntf* system, 
            const simth::PropertyList& pl,
            int oversampling, int carrier, 
            double guardTime, double dist);

    OfdmTransmitter(int deviceID, simth::DeviceSystemIntf* system, 
            const simth::PropertyList& pl);

    virtual ~OfdmTransmitter(){};

    // Transforms a sequence of complex values to samples of a signal
    virtual void makeSignal(const simth::ModSeq& modSeq, simth::TimeSignal* outSignal);

    virtual void updateInputLengths();
    virtual void updateOutputLengths();


    //virtual int numDummys() const {return dummySymbols;}
    virtual void print(std::ostream &os) const;
};




inline void OfdmTransmitter::invariante() const
{
  if(DEBUG) {
    if(oversampling <= 0) {
      throw std::logic_error("inline OfdmTransmitter::invariante() : error 1");
    }
    if(num_carr <= 0) {
      throw std::logic_error("inline OfdmTransmitter::invariante() : error 2");
    }
    if(int(ofdmVector.size()) != num_carr) {
      throw std::logic_error("inline OfdmTransmitter::invariante() : error 3");
    }
    if(num_guard <= 0) {
      throw std::logic_error("inline OfdmTransmitter::invariante() : error 4");
    }
    if(carr_dist <= 0) {
      throw std::logic_error("inline OfdmTransmitter::invariante() : error 5");
    }

  }
}


inline
std::pair<int,int> OfdmTransmitter::index2position(int index) const
{
  return ofdm::index2position(index,numCarrier());
}


inline
int OfdmTransmitter::position2index(int timePos, int carrierPos) const
{
  return ofdm::position2index(timePos,carrierPos,numCarrier());
}


inline
int OfdmTransmitter::ofdmIndex2origIndex(int ofdmIndex) const
{
#if DEBUG != 0
  if(unsigned(ofdmIndex) >= ofdmIndex2origIndex_.size()) {
    throw std::logic_error("int OfdmTransmitter::ofdmIndex2origIndex(int ofdmIndex) const : "
                           "ofdmIndex >= ofdmIndex2origIndex_.size()");
  }
#endif
  return ofdmIndex2origIndex_[ofdmIndex];
}


inline void OfdmTransmitter::IFFT(const simth::Array<Complex> &inArray, simth::Array<Complex>* outArray) const
{
  fft.IFFT(inArray, outArray, space, oversampling);
}


inline double OfdmTransmitter::deltaT() const
{
  invariante();
  return delta_t;
}


class SingleCarrierTransmitter : public Transmitter
{

  public:
    SingleCarrierTransmitter(int deviceID, simth::DeviceSystemIntf* system, 
                 const simth::PropertyList& pl);

    virtual ~SingleCarrierTransmitter(){};

    virtual void makeSignal(const simth::ModSeq& modSeq, 
                simth::TimeSignal* outSignal);

    virtual void updateInputLengths();
    virtual void updateOutputLengths();

    virtual void print(std::ostream &os) const;


  protected:

    double modulationSymbolDistance() const {return modulationSymbolDistance_;}

    int samplesBetweenModulationSymbols() const {return samplesBetweenModulationSymbols_;}

    double deltaT() const {return transmitPulse.rAttributes().deltaT();}

    int numSamplesOfPulse() const {return transmitPulse.size();}

    int numTimeSamples(int numModSymbols) const;
  private:

    const double modulationSymbolDistance_;
    int samplesBetweenModulationSymbols_;

    simth::TimeSignal::storage_type transmitPulse;
};


}

#endif

---