// Assigning a route to each destination node
public List <RoutingPacket> DSRRouteDiscovery(MobileNode destNode, SimulationEnvironment env)
{
RoutingPacket rPacket = new RoutingPacket();
List <RoutingPacket> routes = DSRDiscovery(destNode, env, rPacket);
if (knownRoutes.ContainsKey(destNode.GetNodeID()))
{
foreach (RoutingPacket r in routes)
{
bool exists = false;
foreach (RoutingPacket r2 in knownRoutes[destNode.GetNodeID()])
{
if (r2.RouteCompare(r))
{
exists = true;
break;
}
}
if (!exists)
{
knownRoutes[destNode.GetNodeID()].Add(r);
}
}
}
else
{
knownRoutes.Add(destNode.GetNodeID(), routes);
}
return(routes);
}
public List <RoutingPacket> RouteDiscoveryDSR(MobileNode destNode, SimulationEnvironment env)
{
Console.WriteLine("Performing Route Discovery from Node {0} to Node {1}.", nodeID, destNode.GetNodeID());
RoutingPacket rPacket = new RoutingPacket();
List <RoutingPacket> routes = DSRDicovery(destNode, env, rPacket);
if (knownRoutes.ContainsKey(destNode.GetNodeID()))
{
foreach (RoutingPacket r in routes)
{
bool exists = false;
foreach (RoutingPacket r2 in knownRoutes[destNode.GetNodeID()])
{
if (r2.RouteCompare(r))
{
exists = true;
break;
}
}
if (!exists)
{
knownRoutes[destNode.GetNodeID()].Add(r);
}
}
}
else
{
knownRoutes.Add(destNode.GetNodeID(), routes);
}
return(routes);
}
static void Main(string[] args)
{
SimulationEnvironment sTest = new SimulationEnvironment();
// Add Test Nodes
sTest.AddNode(new MobileNode(0, 0, 100));
sTest.AddNode(new MobileNode(100, 110, 100));
sTest.AddNode(new MobileNode(110, 100, 100));
sTest.AddNode(new MobileNode(198, 198, 100));
// Add Test Message
sTest.AddMessage(new Message(sTest.GetNodes()[0], sTest.GetNodes()[3]));
// Print Simulation Nodes
foreach (MobileNode node in sTest.GetNodes())
{
node.Print();
node.PrintNodesWithinRange(sTest);
Console.WriteLine();
}
// Send 1st message
sTest.SendMessageDSR(sTest.GetMessages()[0]);
// Print Nodes After Message
foreach (MobileNode node in sTest.GetNodes())
{
node.Print();
}
Console.ReadKey();
}
// Implement SADSR
public RoutingPacket SADSRRouteDiscovery(MobileNode destNode, SimulationEnvironment env)
{
// In this protocol, we want to get the route that has the best SDP
RoutingPacket rPacket = new RoutingPacket();
List <RoutingPacket> routes = DSRDiscovery(destNode, env, rPacket);
routes = CalcAltruisticSADSR(routes);
return(GetOptimalRouteSADSR(routes));
}
public void export(SimulationEnvironment sim)
{
// Append metrics to the end of the csv file
StringBuilder data = new StringBuilder();
string path = "D:\\data.csv";
data.AppendFormat("{0}, {1}, {2}", AEED(sim), PDR(sim), NRO(sim));
data.AppendLine();
File.AppendAllText(path, data.ToString());
}
public List <MobileNode> GetNodesWithinRange(SimulationEnvironment env)
{
List <MobileNode> nodes = new List <MobileNode>();
foreach (MobileNode node in env.GetNodes())
{
if (IsWithinRangeOf(node) && !node.Equals(this))
{
nodes.Add(node);
}
}
return(nodes);
}
private double AEED(SimulationEnvironment sim)
{
// Calculate the average time it takes for a data packet to get delivered
// Get the speed of each message in the simulate environment and calculate average speed
// Return calculated result
double total = 0;
foreach (Message msg in sim.GetMessages())
{
total += msg.GetMsgSpeed();
}
return(total / sim.GetMessages().Count);
}
public void PrintNodesWithinRange(SimulationEnvironment env)
{
foreach (MobileNode n in env.GetNodes())
{
if (!this.Equals(n))
{
if (IsWithinRangeOf(n))
{
Console.WriteLine("Node {0} is within range. Distance: {1}", n.GetNodeID(), GetDistance(n));
}
else
{
Console.WriteLine("Node {0} is not within range. Distance: {1}", n.GetNodeID(), GetDistance(n));
}
}
}
}
// Implement modified SA-DSR
public RoutingPacket MSADSRRouteDiscovery(MobileNode destNode, SimulationEnvironment env)
{
RoutingPacket optRoute = new RoutingPacket();
RoutingPacket rPacket = new RoutingPacket();
List <RoutingPacket> routes = DSRDiscovery(destNode, env, rPacket);
int minMisbehavedNodes = 999999;
routes = TwoAck(routes);
foreach (RoutingPacket r in routes)
{
if (minMisbehavedNodes >= r.GetMisbehavedNodes().Count)
{
minMisbehavedNodes = r.GetMisbehavedNodes().Count;
optRoute = r;
}
}
return(optRoute);
}
// Adding nodes to routes
private List <RoutingPacket> DSRDiscovery(MobileNode destNode, SimulationEnvironment env, RoutingPacket route)
{
List <RoutingPacket> routes = new List <RoutingPacket>();
if (knownRoutes.ContainsKey(destNode.GetNodeID()))
{
foreach (RoutingPacket r in knownRoutes[destNode.GetNodeID()])
{
RoutingPacket r2 = route.Copy();
r2.AddNodesToRoute(r.GetNodeRoute());
routes.Add(r2);
}
return(routes);
}
List <MobileNode> nodesWithinRange = GetNodesWithinRange(env);
if (nodesWithinRange.Count == 0 && !destNode.Equals(this))
{
return(null);
}
foreach (MobileNode node in nodesWithinRange)
{
if (!route.IsInRouteAlready(node))
{
if (node.Equals(destNode))
{
RoutingPacket rPacket = route.Copy();
rPacket.AddNodeToRoute(this);
rPacket.AddNodeToRoute(node);
routes.Add(rPacket);
}
else
{
RoutingPacket rPacket = route.Copy();
rPacket.AddNodeToRoute(this);
routes.AddRange(node.DSRDiscovery(destNode, env, rPacket));
}
}
}
return(routes);
}
private double PDR(SimulationEnvironment sim)
{
// Get information about the amount of packets received and sent
// Look at the packets sent and received and calculate the ratio
// Return calculated result
double sent = 0;
double received = 0;
foreach (MobileNode node in sim.GetNodes())
{
sent += node.getNumberOfSentPackets();
received += node.getNumberOfReceivedPackets();
}
if (received != 0)
{
return(sent / received);
}
return(received);
}
private double NRO(SimulationEnvironment sim)
{
// Calculate total control packets divided by the total packets received in the network
// Get the number of control and received packets
// Sum up all the control and received packets and divide them to obtain nro
// Return calculated result
double sent = 0;
double received = 0;
foreach (MobileNode node in sim.GetNodes())
{
sent += node.GetNumRPackets();
received += node.getNumberOfReceivedPackets();
}
if (received != 0)
{
return(sent / received);
}
return(received);
}
private List <RoutingPacket> DSRDicovery(MobileNode destNode, SimulationEnvironment env, RoutingPacket route)
{
List <RoutingPacket> routes = new List <RoutingPacket>();
if (knownRoutes.ContainsKey(destNode.GetNodeID()))
{
foreach (RoutingPacket r in knownRoutes[destNode.GetNodeID()])
{
RoutingPacket r2 = route.Copy();
r2.AddNodesToRoute(r.GetNodeRoute());
routes.Add(r2);
}
return(routes);
}
List <MobileNode> nodesWithinRange = GetNodesWithinRange(env);
if (nodesWithinRange.Count == 0 && !destNode.Equals(this))
{
return(null);
}
foreach (MobileNode node in nodesWithinRange)
{
// If node isn't in route yet...
if (!route.IsInRouteAlready(node))
{
// If node is the destination node...
if (node.Equals(destNode))
{
//Obtaining all possible routes
RoutingPacket rPacket = route.Copy();
rPacket.AddNodeToRoute(this); // Adding nodes to route
rPacket.AddNodeToRoute(node);
routes.Add(rPacket); // Adding all possible routes
Console.WriteLine("Sending RREQ from Node {0} to Node {1}.", nodeID, node.GetNodeID());
TransmitPacket();
node.ReceiveProcessPacket();
Console.WriteLine("Sending RREP from Node {0} to Node {1}.", node.GetNodeID(), nodeID);
node.TransmitPacket();
ReceiveProcessPacket();
}
else
{
RoutingPacket rPacket = route.Copy();
rPacket.AddNodeToRoute(this);
Console.WriteLine("Sending RREQ from Node {0} to Node {1}.", nodeID, node.GetNodeID());
TransmitPacket();
node.ReceiveProcessPacket();
routes.AddRange(node.DSRDicovery(destNode, env, rPacket)); // Recursive call
}
}
}
foreach (RoutingPacket r in routes)
{
if (r.GetNodeRoute().Contains(destNode))
{
List <MobileNode> rList = r.GetNodeRoute();
for (int i = 0; i < rList.Count; i++)
{
if (rList[i] == this && i != 0)
{
Console.WriteLine("Sending RREP from Node {0} to Node {1}.", nodeID, rList[i - 1].GetNodeID());
TransmitPacket();
rList[i - 1].GetNodeID();
}
}
}
}
return(routes);
}
static void Main(string[] args)
{
SimulationEnvironment sTest = new SimulationEnvironment();
sTest.GetNodes().Add(new MobileNode(0, 0, 100));
sTest.GetNodes().Add(new MobileNode(100, 110, 100));
sTest.GetNodes().Add(new MobileNode(110, 100, 100));
sTest.GetNodes().Add(new MobileNode(198, 198, 100));
sTest.GetMessages().Add(new Message(sTest.GetNodes()[0], sTest.GetNodes()[3]));
foreach (MobileNode node in sTest.GetNodes())
{
node.Print();
foreach (MobileNode n in sTest.GetNodes())
{
if (!node.Equals(n))
{
if (node.IsWithinRangeOf(n))
{
Console.WriteLine("Node {0} is within range. Distance: {1}", n.GetNodeID(), node.GetDistance(n));
}
else
{
Console.WriteLine("Node {0} is not within range. Distance: {1}", n.GetNodeID(), node.GetDistance(n));
}
}
}
Console.WriteLine();
}
sTest.GetMessages()[0].Print();
List <RoutingPacket> packets = sTest.GetNodes()[0].DSRRouteDiscovery(sTest.GetNodes()[3], sTest);
// Calling SA-DSR
RoutingPacket optRoute = sTest.GetNodes()[0].SADSRRouteDiscovery(sTest.GetNodes()[3], sTest);
// Calling Modified SA-DSR
RoutingPacket optRoute2 = sTest.GetNodes()[0].MSADSRRouteDiscovery(sTest.GetNodes()[3], sTest);
Console.WriteLine("{0} Routes Found.", packets.Count);
foreach (RoutingPacket route in packets)
{
Console.WriteLine("Route:");
Console.WriteLine("==============================");
foreach (MobileNode node in route.GetNodeRoute())
{
Console.Write("{0} ", node.GetNodeID());
}
Console.WriteLine();
Console.WriteLine("==============================");
}
// Testing SA-DSR
Console.Write("SA-DSR Optimal Route: ");
foreach (MobileNode node in optRoute.GetNodeRoute())
{
Console.Write("{0} ", node.GetNodeID());
}
Console.WriteLine();
Console.WriteLine("==============================");
// Testing modified SA-DSR
Console.Write("Modified SA-DSR Optimal Route: ");
foreach (MobileNode node in optRoute2.GetNodeRoute())
{
Console.Write("{0} ", node.GetNodeID());
}
Console.WriteLine();
Console.WriteLine("==============================");
sTest.GetNodes()[0].DSRSendMessage(sTest.GetMessages()[0], packets[0]);
Console.ReadKey();
SimulationEnvironment sim = new SimulationEnvironment();
sim.GenerateRandomNodes(15);
sim.GenerateRandomMessages(50);
Console.WriteLine("==============================================");
Console.WriteLine("Simulation Nodes");
Console.WriteLine("==============================================");
foreach (MobileNode node in sim.GetNodes())
{
node.Print();
foreach (MobileNode n in sim.GetNodes())
{
if (!node.Equals(n))
{
if (node.IsWithinRangeOf(n))
{
Console.WriteLine("Node {0} is within range. Distance: {1}", n.GetNodeID(), node.GetDistance(n));
}
else
{
Console.WriteLine("Node {0} is not within range. Distance: {1}", n.GetNodeID(), node.GetDistance(n));
}
}
}
Console.WriteLine();
}
Console.WriteLine();
Console.WriteLine("==============================================");
Console.WriteLine("Simulation Messages");
Console.WriteLine("==============================================");
foreach (Message message in sim.GetMessages())
{
message.Print();
}
foreach (MobileNode node in sTest.GetNodes())
{
node.printKnownRoutes();
}
// Export data here
DataExporter d = new DataExporter();
d.export(sTest);
Console.ReadKey();
}
private void BDD(SimulationEnvironment sim)
{
// This will be considered later
}
