source: proiecte/ptvs/src/vnsim/network/dsrc/WirelessPhy.java @ 31

/************************************************************************************
 * Copyright (C) 2008 by Politehnica University of Bucharest and Rutgers University
 * All rights reserved.
 * Refer to LICENSE for terms and conditions of use.
 ***********************************************************************************/
//Petroaca - Physical layer module
package vnsim.network.dsrc;


import java.util.List;

import java.util.List;

import vnsim.core.*;
import vnsim.core.events.*;
import vnsim.map.object.*;
import vnsim.map.utils.*;
import vnsim.network.propagation.*;




public class WirelessPhy
{
        private int stateMachine;
        
        private NoiseMonitor noiseMonitor;
        
//      the duration of a frame receive ; this time is taken from the crtTime in Engine.java 
        private int currentTime;
        
        //the Signal to Interference/Noise Ratio of the current frame
        private double SINR;
        
        //if the ratio of the strongest sgignal to teh sum of the others is less tahn this value then they collide
        private double cpThreshold=Globals.CP_THRESHOLD;
        
        //if a frame has a receievd power below this value then it is too weak to be received.
        private double csThreshold;
        
        //if a frame has a received power below this value then it can be received by phy but it is corrupted
        private double rxThreshold;
        
        private double txPower=Globals.TRANSMITTER_POWER;
        
        private int propagationType=Engine.propagationModel; 
        
        private double totalPower=0;
        
        private double maxPower=0;
        
        private double SINRThreshold=Globals.SINRThresholdBPSK;
        
        private int totalReceived;
        
        public WirelessPhy(int currentTime)
        {
                stateMachine=Globals.IDLE;
                
                noiseMonitor=new NoiseMonitor(fromDBmToW(Globals.ThermalNoise));
                this.SINRThreshold=Globals.SINRThresholdBPSK;
                
                this.csThreshold=Globals.CS_THRESHOLD_S;
                this.rxThreshold=Globals.RX_THRESHOLD_S;
                
                this.currentTime=currentTime;
                
                this.totalReceived=0;
        }
        
        public ReceiveEvent recvFromChannel(List<ReceiveEvent> receivedSignals,int currentTime)
        {
                //DsrcFrame frame=new DsrcFrame();
                int noSignals=0;
                
                
                //check stateMachine
                if(this.stateMachine==Globals.IDLE)
                {
                        
                        ReceiveEvent best=null;
                        
                        for(ReceiveEvent re : receivedSignals)
                        {
                                double receivedPower=0;
                                
                                Road r1 = (Road) Globals.map.roads.get(re.sender.getRoadIdx());
                                Point p1 = (Point) r1.points.get(re.sender.getPointIdx());
                                Road r2 = (Road) Globals.map.roads.get(re.receiver.getRoadIdx());
                                Point p2 = (Point) r2.points.get(re.receiver.getPointIdx());
                                
                                double R = GPSutil.distance(p1, p2);
                                
                                R*=1000;
                                
                                switch(this.propagationType)
                                {
                                case Globals.SHADOWING :receivedPower=Shadowing.getPr(fromDBmToW(this.txPower),R,true);
                                                                                break;
                                case Globals.TWO_RAY_GROUND:    receivedPower=TwoRay.getPr(fromDBmToW(this.txPower),R);
                                                                                        break;
                                case Globals.RICEAN: receivedPower=Engine.riceanModule.getPr(fromDBmToW(this.txPower),R,currentTime);
                                                                        break;  
                                }
                                
                                if(receivedPower>this.csThreshold)
                                {
                                        this.totalPower+=receivedPower;
                                        noSignals++;    
                                }
                                
                                if(receivedPower>this.maxPower)
                                {
                                        maxPower=receivedPower;
                                        best=re;
                                }
                                
                                if((re.getMessage())[0]==Globals.PROT_EMERGENCY)
                                        Globals.EMERGENCY_SENT++;
                        }
                        
                        
                        Globals.DSRC_PACKETS_TOTAL+=receivedSignals.size();
                        this.totalReceived+=noSignals;
                        Globals.DSRC_PACKETS_LOST_WEAK+=(receivedSignals.size()-noSignals);
                        
                        if(best==null)
                                return null;
                        
                        if(maxPower<this.csThreshold)
                        {
                                //weak signal
                                this.noiseMonitor.addInterference(totalPower);
                                return null;
                        }
                        else
                        {
                                this.noiseMonitor.addInterference(totalPower-maxPower);
                                
                                
                                
                                //can decode the preamble and phy header
                                        
                                
                                        
                                this.setSINR(maxPower);
                                
                                if(maxPower>this.rxThreshold)   
                                {
                                                
                                                //frame received ok
                                        
                                        this.stateMachine=Globals.RXing;
//                                              send frame to MAC
                                        Globals.DSRC_PACKETS_LOST_RX+=noSignals-1;
                                        return best;
                                }
                                else
                                {
                                        
                                                if(!this.checkCollision(maxPower))
                                                {
                                                        //collision 
                                                        Globals.DSRC_PACKETS_LOST_COLLISION+=noSignals;
                                                        this.noiseMonitor.addInterference(maxPower);
                                                        return null;
                                                }
                                                //tag frame as corrupted and send to mac
                                                Globals.DSRC_PACKETS_LOST_CORRUPTED+=noSignals-1;
                                                best.setSender(null);
                                                return best;
                                }
                        
                        }
                        
                }
                
                        //in transmit mode
                        Globals.DSRC_PACKETS_LOST_TX+=receivedSignals.size();
                        return null;
                
        }
        
        public byte[] sendToChannel(byte[] message,int currentTime)
        {
                
                //if(this.stateMachine==Globals.IDLE)
                //{
                        //PCLP frame formation - make a packet out of the received frame
                        //byte[] phyHeader=new byte[3];
                        //byte[] preamble=new byte[12];
                        //DsrcPacket packet=new DsrcPacket(preamble,phyHeader,new DsrcFrame());
                        
                        //DSSS modulation
                        
                        this.stateMachine=Globals.TXing;
                        return message;
                //}
                
                //return null;
                
        }
        
//      if the layer was transmitting or receiving a frame then after the duration of a frame it must return back to idle
        public void refreshFrameTime(int currentTime)
        {
                int ret;
                
                if(currentTime-this.currentTime>=Globals.WIRELESS_TRANSMISSION_FRAMES)
                {
                        this.stateMachine=Globals.IDLE;
                        this.noiseMonitor.refreshInterference();
                        this.totalPower=0;
                        this.maxPower=0;
                        
                        if(currentTime%4==0)
                                this.totalReceived=0;
                }
                
                this.currentTime=currentTime;
        }
        
        public NoiseMonitor getNoiseMonitor()
        {
                return this.noiseMonitor;
        }
        
        public DsrcPacket recvFromMac(DsrcFrame frame)
        {
                return null;
        }
        
//      calculates the SINR for the frame received
        public void setSINR(double receivedPower)
        {
                //this.SINR=10 * Math.log10(receivedPower/this.noiseMonitor.getInterference());
                this.SINR=receivedPower/this.noiseMonitor.getInterference();
        }
        
        public double getSINR()
        {
                return this.SINR;
        }
        
        
        //checks the ratio of the strongest signal to the rest to see if there is a collision
        public boolean checkCollision(double receivedPower)
        {
                if(receivedPower/(this.noiseMonitor.getInterference()-this.noiseMonitor.getThermalNoise())>this.cpThreshold)
                        return true;
                
                return false;
        }
        
//      checks if the IAndN level is above the SINRThreshold
        public boolean checkInterferenceAndNoiseLevel()
        {
                if(this.noiseMonitor.getInterference()>=this.SINRThreshold)
                        return false;
                
                return true;
        }
        
        public double fromDBmToW(double dbm)
        {
                return Math.pow(10, (dbm - 30) / 10);
        }
        
        public int getPropagation()
        {
                return this.propagationType;
        }
        
        public void setPropagation(int set)
        {
                this.propagationType=set;
        }
        
        public int getTotalReceivedPackets()
        {
                return this.totalReceived;
        }
        
}