modulator.h

Go to the documentation of this file.

/***************************************************************************
                          modulator.h  -  description
                             -------------------
    begin                : Mon Jun 10 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 MODULATOR_HEADER
#define MODULATOR_HEADER

#include <iostream>
#include <fstream>
#include <complex>
#include <vector>
#include <cmath>

#include <simthetic/signals.h>
#include <simthetic/misc.h>
#include <simthetic/phbib.h>
#include <simthetic/basicdevice.h>

#include "bitmapping.h"
#include "modulationschemes.h"
#include "modulationmodes.h"


namespace simthlib
{

using simth::Complex;

class Modulator;
class Demodulator;


std::ostream& operator<<(std::ostream &os, const Modulator& mod);

class AdachiDemodulator;


class Modulator : public simth::Device
{
    friend class AdachiDemodulator;
  private:

    //mapping
    MappingScheme* usedMapping;

    //the number of dummy symbols added in the last modulation of a bit sequence
    //obsolete: int dummyBits;

  protected:

    virtual int getBitsPerSymbol() const = 0;

    virtual Complex getComplSymbol(int symbolIndex) const = 0;

    int getSymbolIndex(int dataValue) const
      {return usedMapping->getSymbolIndex(dataValue);}


    //modIndSeq helpIndexSeq; //hier werden die aus der Bitsequenz gemappten
    //Symbolindizes reingeschrieben


    //Initialisierung des Modulationsschemas
    /* Initialises the modulator with a particular constellation
    diagram (e.g. PSK constellation diagram).

    */
    //void set_ConstellationDiagram(ConstellationDiagram* ConstellationDiagramPtr);
    //void set_mapping(MappingScheme* mappingPtr);




    //die Modulationsindizes (helpIndexSeq) mit einer neuen
    //Bitfolge neu initialisieren Dazu werden die eingehenden Bits
    //der Modulationswertigkeit entsprechend in Bloecke aufgeteilt
    //und diese mithilfe von ConstellationDiagram entsprechende
    //Symbolindizes zugewiesen und in helpIndexSeq geschrieben

    //Zugriff auf helpIndexSeq
    //int num_mappedModIndexes() const {return mappedModIndexes.size();}

    //void set_mappedModIndexes(int index, int newValue);

    //int  get_mappedModIndexes(int index) const;



    void bitSeq2IndexSeq(const simth::BitSeq& newBitSeq, simth::ModIndSeq* indexSeq);

    //Transforming of the integer representation into the corresponding
    //complex values of the constellation diagram
    void indexSeq2complSymbolSeq(const simth::ModIndSeq &modIndexes, simth::ModSeq* complSym);

    int indexLength(int bitLen) const;

  public:

    Modulator(int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl, 
          std::auto_ptr<MappingScheme> mapp);

    virtual ~Modulator() = 0;

    virtual void updateInputLengths();


    virtual void modulate(const simth::BitSeq& bits, simth::ModSeq* modSymbols)=0;


    virtual int getNumStates() const = 0;

    /* Returns the number of dummy bits which has been added to the last
    modulated bit sequence.

     */
    //virtual int numDummys() const {return d;}

    virtual void process();

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

    virtual void startOfSimulation();

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

    virtual const ConstellationDiagram* constellation() const = 0;
};





class AbsModulator : public Modulator
{
  private:

  protected:

  public:
    AbsModulator(int deviceID, simth::DeviceSystemIntf* system,
         const simth::PropertyList& pl, 
         std::auto_ptr<MappingScheme> mapp)
        : Modulator(deviceID, system, pl, mapp) {};

    virtual ~AbsModulator() = 0;

    virtual void updateOutputLengths();

    virtual void modulate(const simth::BitSeq&, simth::ModSeq *modulatedSeq);
};



class QamModulator : public AbsModulator
{

  private:
    //modulation
    QamConstellationDiagram* usedConstellationDiagram;


    virtual int getBitsPerSymbol() const
      {return usedConstellationDiagram->getBitsPerSymbol();}


    virtual Complex getComplSymbol(int symbolIndex) const
      {return usedConstellationDiagram->getComplSymbol(symbolIndex);}

    void scaleConstellation(Complex scale){usedConstellationDiagram->scaleConstellation(scale);};

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

    virtual ~QamModulator();

    virtual int getNumStates() const {return usedConstellationDiagram->getNumStates();}

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

    const ConstellationDiagram* constellation() const 
      {return usedConstellationDiagram;}
};





class PskModulator : public AbsModulator
{
  private:

    //modulation
    PskConstellationDiagram* usedConstellationDiagram;


    virtual int getBitsPerSymbol() const
      {return usedConstellationDiagram->getBitsPerSymbol();}


    virtual Complex getComplSymbol(int symbolIndex) const
      {return usedConstellationDiagram->getComplSymbol(symbolIndex);}


    void scaleConstellation(Complex scale){usedConstellationDiagram->scaleConstellation(scale);};


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

    virtual ~PskModulator();

    virtual void startOfSimulation();

    virtual int getNumStates() const {return usedConstellationDiagram->getNumStates();}

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

    const ConstellationDiagram* constellation() const 
      {return usedConstellationDiagram;}
};






class ApskModulator : public AbsModulator
{
  private:

    //modulation
    ApskConstellationDiagram* usedConstellationDiagram;


    virtual int getBitsPerSymbol() const
      {return usedConstellationDiagram->getBitsPerSymbol();}


    virtual Complex getComplSymbol(int symbolIndex) const
      {return usedConstellationDiagram->getComplSymbol(symbolIndex);}


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

    ApskModulator(int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl, 
          int bitsPerAmpl,int bitsPerPhase,
          double amplFactor, double amplAddend=0.0,
                  map_type mappMode = GRAY);


    virtual ~ApskModulator();

    virtual void startOfSimulation();

    virtual int getNumStates() const {return usedConstellationDiagram->getNumStates();}

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

    const ConstellationDiagram* constellation() const 
      {return usedConstellationDiagram;}
};



class DiffModulator : public Modulator
{
  private:


  protected:

    //hier werden die Indizes der differenziell codierten und
    //zu uebertragenden Mod-Symbole reingeschrieben
    //simth::ModIndSeq helpDiffIndexSeq;


    //Zugriff auf diffsimth::ModSeq:
    //        int get_diffsimth::ModSeq(int index) const;
    //        void set_diffsimth::ModSeq(int index,int value);
    //        int size_diffsimth::ModSeq() const {return diffsimth::ModSeq.size();}
    //        void resize_diffsimth::ModSeq(int newSize);

    //      diff_type diffMode;

    void ModSingle(const simth::ModIndSeq &mis, simth::ModSeq* &sym){};

    void ModCross(const simth::ModIndSeq &mis, simth::ModSeq* &sym){};

    virtual void diffCoding(const simth::ModIndSeq& absSeq, simth::ModIndSeq* diffSeq);

    virtual int diffOperation(int refIndex, int informationIndex) const = 0;


  public:

    DiffModulator(int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl,
          std::auto_ptr<MappingScheme> mapp)
        : Modulator(deviceID, system, pl, mapp) {};

    virtual ~DiffModulator() = 0;

    virtual void updateOutputLengths();

    virtual void modulate(const simth::BitSeq&, simth::ModSeq *);
};



class DiffSubSeqModulator : public DiffModulator
{
  private:

    int subSeqLen;

  protected:


    virtual void diffCoding(const simth::ModIndSeq& absSeq, simth::ModIndSeq* diffSeq);

    virtual int diffOperation(int smybolIndex1, int symbolIndex2) const = 0;


  public:

    DiffSubSeqModulator(int deviceID, simth::DeviceSystemIntf* system,
            const simth::PropertyList& pl,
            std::auto_ptr<MappingScheme> mapp,
            int subSeqLength);


    virtual ~DiffSubSeqModulator() = 0;
    virtual void print(std::ostream &os) const;
};


class DaskModulator : public DiffSubSeqModulator
{

  private:
    //modulation
    ApskConstellationDiagram* usedConstellationDiagram;


    virtual int getBitsPerSymbol() const
      {return usedConstellationDiagram->getBitsPerSymbol();}


    virtual Complex getComplSymbol(int symbolIndex) const
      {return usedConstellationDiagram->getComplSymbol(symbolIndex);}


    virtual int diffOperation(int symbolIndex1, int symbolIndex2) const
      { return  (symbolIndex1 + symbolIndex2) % getNumStates();}

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

    virtual ~DaskModulator();

    int getNumStates() const {return usedConstellationDiagram->getNumStates();}

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

    const ConstellationDiagram* constellation() const 
      {return usedConstellationDiagram;}
};





class DpskModulator : public DiffSubSeqModulator
{

  private:
    //modulation
    PskConstellationDiagram* usedConstellationDiagram;


    virtual int getBitsPerSymbol() const
      {return usedConstellationDiagram->getBitsPerSymbol();}


    virtual Complex getComplSymbol(int symbolIndex) const
      {return usedConstellationDiagram->getComplSymbol(symbolIndex);}


    virtual int diffOperation(int symbolIndex1, int symbolIndex2) const
      { return  (symbolIndex1 + symbolIndex2) % getNumStates();}

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

    virtual ~DpskModulator();

    virtual void startOfSimulation();

    int getNumStates() const {return usedConstellationDiagram->getNumStates();}

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

    const ConstellationDiagram* constellation() const 
      {return usedConstellationDiagram;}
};

class DapskModulator : public DiffSubSeqModulator
{
  private:
    //modulation
    ApskConstellationDiagram* usedConstellationDiagram;


    virtual int getBitsPerSymbol() const
      {return usedConstellationDiagram->getBitsPerSymbol();}


    virtual Complex getComplSymbol(int symbolIndex) const
      {return usedConstellationDiagram->getComplSymbol(symbolIndex);}


    int getNumAmplitudeBits() const
      {return usedConstellationDiagram->bitsPerAmpl();}

    int getNumPhaseBits() const
      {return usedConstellationDiagram->bitsPerPhase();}

    int getNumAmplitudes() const
      {return 1<<(usedConstellationDiagram->bitsPerAmpl());}


    int getNumPhases() const
      {return 1<<(usedConstellationDiagram->bitsPerPhase());}


    virtual int diffOperation(int symbolIndex1, int symbolIndex2) const;

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


    DapskModulator(int deviceID, simth::DeviceSystemIntf* system,
           const simth::PropertyList& pl, 
           int bitsPerAmpl,int bitsPerPhase, double amplFactor, 
           double amplAddend,
                   int subSeqLen, map_type mappMode = GRAY);


    virtual ~DapskModulator();

    virtual void startOfSimulation();

    int getNumStates() const {return usedConstellationDiagram->getNumStates();}

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

    const ConstellationDiagram* constellation() const 
      {return usedConstellationDiagram;}
};



}

#endif // MODULATOR_HEADER

---