bpsk.cc

/*
 * Copyright (c) 2007 Regents of the SIGNET lab, University of Padova.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University of Padova (SIGNET lab) nor the 
 *    names of its contributors may be used to endorse or promote products 
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include"bpsk.h"

#include<rng.h>
#include<iostream>

static class MPhy_BpskClass : public TclClass {
public:
  MPhy_BpskClass() : TclClass("Module/MPhy/BPSK") {}
  TclObject* create(int, const char*const*) {
    return (new MPhy_Bpsk);
  }
} class_MPhy_Bpsk;


bool MPhy_Bpsk::initialized = false;
int MPhy_Bpsk::modid = -1;



MPhy_Bpsk::MPhy_Bpsk()
  : PktRx(0), txPending(false)
{
  if (!initialized) 
    {
      modid = MPhy::registerModulationType(BPSK_MODNAME);
      initialized = true;
    }
  bind("AcquisitionThreshold_dB_", &AcquisitionThreshold_dB_);
}



int MPhy_Bpsk::getModulationType(Packet*)
{
  assert(initialized);
  return modid;
}


double  MPhy_Bpsk::getTxDuration(Packet* p)
{
  hdr_cmn* ch = HDR_CMN(p);
  hdr_MPhy* ph = HDR_MPHY(p);
  
  // for BPSK the bandwidth is B = 2/T, 
  // where T is the symbol duration.
  // Here B is pre-determined by the Spectral Mask,
  // so we can calculate the bitrate R = 1/T = B/2

  double bitrate = ph->srcSpectralMask->getBandwidth() / 2.0 ;
  double txduration = (ch->size() * 8.0 / bitrate);
  if (txduration <=0)
    {
      cerr << " ch->size(): " << ch->size()
           << " bitrate: " << bitrate 
           << std::endl;
    }
  assert(txduration > 0);
  
  if (debug_)
    cerr << showpoint << NOW << " " <<  __PRETTY_FUNCTION__ 
         << " packet size: " << ch->size() 
         << " tx duration: " << txduration 
         << endl;
  
  return (txduration);
} 


void MPhy_Bpsk::startTx(Packet* p)
{
  // we abort any ongoing rx activity
  PktRx = 0;
  txPending = true;
  sendDown(p);

}


void MPhy_Bpsk::endTx(Packet* p)
{
  txPending = false;
  // Notify the MAC
  Phy2MacEndTx(p);
}



void MPhy_Bpsk::startRx(Packet* p)
{
  hdr_MPhy* ph = HDR_MPHY(p);

  /* ideal synchronization */


  if ( (PktRx == 0) && (txPending == false) )
    {
      // The receiver is is not synchronized on any transmission
      // so we can sync on this packet

      double snr_dB = 10*log10(ph->Pr / ph->Pn);

      //std::cerr << "snr_dB: " << snr_dB << " AcquisitionThreshold_dB_: " << AcquisitionThreshold_dB_ ;

      if(snr_dB > AcquisitionThreshold_dB_)
        {
          //std::cerr << " above threshold "<< std::endl;
          if (ph->modulationType == modid)
            {
              // This is a BPSK packet so we sync on it
              PktRx = p;
              
              // Notify the MAC
              Phy2MacStartRx(p);
              return;
            }    
        }
      else
        {
          //std::cerr << " below threshold "<< std::endl;
        }
    }

}


void MPhy_Bpsk::endRx(Packet* p)
{

  if (PktRx != 0)
    {
                
      hdr_cmn* ch = HDR_CMN(p);
      hdr_cmn* rxch = HDR_CMN(PktRx);
        
        
      // NOT RELIABLE!!! packets sometimes have uid == 0!!!             
      //      if ( ch->uid()  == rxch->uid() )
      if (PktRx == p)
        {  
          // We had synchronized onto this packet so we now try to see if
          // it has been received correctly

          double per_ni; // packet error rate due to noise and/or interference
          double per_n;  // packet error rate due to noise only 
        
          hdr_MPhy* ph = HDR_MPHY(p);
        
          int nbits = ch->size()*8;
          per_n = getPER(ph->Pr/ph->Pn, nbits);
          per_ni = getPER(ph->Pr/(ph->Pn + ph->Pi), nbits);


          double x = RNG::defaultrng()->uniform_double();
          bool error_ni = x <= per_ni;
          bool error_n = x <= per_n;
        
          ch->error() = error_ni || error_n ;
                        
//        if (error_ni)
//          {
//            drop(p,1,MPHY_DROP_ERROR_INTERFERENCE);
//          }
//        else if (error_n)
//          {
//            drop(p,1,MPHY_DROP_ERROR_NOISE);
//          }
//        else          
//          {
//            sendUp(p);
//          }

          // always send up; the PHY is not responsible for discarding erroneous packets
          sendUp(p);

        
          PktRx = 0; // We can now sync onto another packet
        }
      else
        {
          // We synchronized on another packet, so we are
          // not attempting to receive this transmission
          Packet::free(p);
        }
    }
  else
    {
      // We did not synchronize on any packet, so we are
      // not attempting to receive this transmission
      Packet::free(p);
    }
        
}


double MPhy_Bpsk::getPER(double snr, int nbits)
{
  double ber = 0.5*erfc(sqrt(snr));  
  double per = 1-pow(1 - ber, nbits );
  return per;
}

---