source: proiecte/ptvs/src/vnsim/network/RadioDev.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.
 ***********************************************************************************/
package vnsim.network;


import java.io.Serializable;
import java.util.List;

import vnsim.applications.adaptiveTL.WirelessTrafficLight;
import vnsim.core.Communicator;
import vnsim.core.events.*;
import vnsim.map.object.*;
import vnsim.map.utils.*;





public class RadioDev implements Serializable{
        
        /** <code>serialVersionUID</code> */
        private static final long serialVersionUID = -5883719321862303634L;

        public static final long LIGHT_SPEED = 299792458; // m/s
        
        public static final long FREQUENCY = 2400000000L; //Hz

        public static final double LAMBDA = (double)LIGHT_SPEED/FREQUENCY;
        
        private Communicator communicator;
        
        // height of the antenna in m
        private double antennaHeight;

        // radio device sensitivity in DBm (decibel referenced to 1 mW power)
        public double sensitivity;
        
        public double rxThreshold;

        public double rxThreshold_W;
        
        public double snrThreshold;
        
        // transmission power in DBm
        public double txPower;
        
        // antenna gain in DBm
        public double gain;
        
        public int lastTxTime = 0;
        
        public RadioDev(Communicator c){
                communicator = c;
                
                antennaHeight = 1.5; // m
                
                sensitivity = -91.0; //DBm
                
                snrThreshold = 9.1;
                
                rxThreshold = -81.0; // DBm
                rxThreshold_W = convertDBmToW(rxThreshold);
                
                txPower = 15; //DBm
                //30 + 10 * Math.log10(0.1);
                
                gain = 0; // DBm
        }
        
        public ReceiveEvent receive(List<ReceiveEvent> receivedSignals){
                
                if (Globals.engine.crtTime == communicator.getRadio().lastTxTime){
                        // ignore all signals, receiver radio in transmit mode
                        return null;
                }

                int capturableSignals = 0;
                ReceiveEvent max = null;
                double maxrxpower = -1000;
                double maxrxpower_W = 0;
                double totalPower = 0;
                double totalPower_W = 0;
                
                for (ReceiveEvent re : receivedSignals){
                        RadioDev txradio = re.sender.getRadio();
                        
                        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(communicator.getRoadIdx());
                        Point p2 = (Point) r2.points.get(communicator.getPointIdx());
                        double distance = GPSutil.distance(p1, p2);
                        
                        double pl = pathloss(re.sender, communicator, distance);
                        double rxpower = txradio.getTxPower() - pl;
                        double rxpower_W = convertDBmToW(rxpower);
                        
                        totalPower += rxpower;
                        totalPower_W += rxpower_W;
                        
                        if (rxpower > maxrxpower){
                                maxrxpower = rxpower;
                                maxrxpower_W = rxpower_W;
                                max = re;
                        }
                        
//                      if (distance > 0.7)
//                              System.out.println("DIST="+distance+"; RXPOWER="+rxpower+"; THR="+rxThreshold);

                        if (rxpower >= this.rxThreshold){
                                capturableSignals ++;
                                
                                
                                
                                if (distance > Globals.maxRange )
                                        Globals.maxRange = distance;

                        }
                }
                Globals.packets += capturableSignals;
                double noise_W = totalPower_W - convertDBmToW(maxrxpower);
                if (capturableSignals > 1){
                        int i = 0;
                        i++;
                }               
                if (maxrxpower_W >= this.rxThreshold_W && 
                                maxrxpower_W >= noise_W * this.snrThreshold){
                        Globals.lost += capturableSignals - 1;
                        return  max;
                }
                
                if (capturableSignals == 1){
                        Globals.interfered ++ ;
                }
                
                if (capturableSignals > 0){
                        // collision
                        Globals.collided += capturableSignals;
                        return null;
                }
                
                // only weak signals
                return null;
        }
        
        // Two ray pathloss 
        public static double pathloss(Communicator s, Communicator d, double distance){
                RadioDev tx = s.getRadio();
                RadioDev rx = d.getRadio();
                
                distance *= 1000;
                if (distance < 1)
                        return 0;
                
                double pathloss = -(tx.getGain() + rx.getGain());
                double freeSpace = (4.0 * Math.PI * distance) / LAMBDA;
                double planeEarth = (distance * distance) / (tx.antennaHeight * rx.antennaHeight);

                if (planeEarth > freeSpace){
                        pathloss += 20.0 * Math.log10(planeEarth);
                }else{
                        pathloss += 20.0 * Math.log10(freeSpace);
                }
            
                return pathloss;
        }
        /**
         * 
         * @param dbm power value in DBm
         * @return power in mW
         */
        public static double convertDBmToW(double dbm){
                return Math.pow(10, (dbm - 30) / 10);
        }
        
        /**
         * 
         * @param w power in watts
         * @return value in DBm
         */
        public static double convertWToDBm(double w){
                return 30 + Math.log10(w);
        }

        public double getGain() {
                return gain;
        }

        public void setGain(double gain) {
                this.gain = gain;
        }

        public double getSensitivity() {
                return sensitivity;
        }

        public void setSensitivity(double sensitivity) {
                this.sensitivity = sensitivity;
        }

        public double getTxPower() {
                return txPower;
        }

        public void setTxPower(double txPower) {
                this.txPower = txPower;
        }
        
        public void setRadioTxMode(){
                lastTxTime = Globals.engine.crtTime;
        }
}