private void RecivePacket(Sensor Reciver, Packet packt)
{
if (Reciver == null) // packet is recived.
{
counter.SuccessedDeliverdPacket(packt);
counter.DisplayRefreshAtReceivingPacket(packt.Source);
}
else
{
packt.Path += ">" + Reciver.ID;
packt.ReTransmissionTry = 0;
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
Reciver.AddSinkRecordInHighTierNode(packt.ReportSinkPosition); // keep track of the sink position
if (packt.Hops <= packt.TimeToLive)
{
if (packt.PacketDirection == PacketDirection.Up)
{
Packet upPlacket = GeneragtePacket(Reciver, packt.ReportSinkPosition, PacketDirection.Up);
SendPacket(Reciver, upPlacket);
}
else
{
// down:
Packet downPlacket = GeneragtePacket(Reciver, packt.ReportSinkPosition, PacketDirection.Down);
SendPacket(Reciver, downPlacket);
}
}
}
}
private void RecivePacket(Sensor Reciver, Packet packt)
{
packt.Path += ">" + Reciver.ID;
if (loopMechan.isLoop(packt))
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.Loop);
}
else
{
packt.ReTransmissionTry = 0;
if (Reciver.RingNodesRule.isRingNode) // packet is recived.
{
packt.Destination = Reciver;
counter.SuccessedDeliverdPacket(packt);
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
counter.DisplayRefreshAtReceivingPacket(Reciver);
// share:
ShareSinkPositionIntheHighTier xma = new ShareSinkPositionIntheHighTier(Reciver, packt.ReportSinkPosition);
}
else
{
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
if (packt.Hops <= packt.TimeToLive)
{
SendPacket(Reciver, packt);
}
else
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.TimeToLive);
}
}
}
}
private void RecivePacket(Sensor Reciver, Packet packt)
{
packt.Path += ">" + Reciver.ID;
if (loopMechan.isLoop(packt))
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.Loop);
}
else
{
packt.ReTransmissionTry = 0;
if (Reciver == packt.Destination)
{
counter.SuccessedDeliverdPacket(packt);
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
Reciver.Ellipse_nodeTypeIndicator.Fill = Brushes.LightSlateGray; // mark
Reciver.IsHightierNode = true;
counter.DisplayRefreshAtReceivingPacket(Reciver);
}
else
{
if (packt.Hops <= packt.TimeToLive)
{
// compute the overhead:
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
SendPacket(Reciver, packt);
}
else
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.TimeToLive);
}
}
}
}
private void RecivePacket(Sensor Reciver, Packet packt)
{
packt.Path += ">" + Reciver.ID;
packt.ReTransmissionTry = 0;
if (Reciver.ID == packt.Destination.ID) // packet is recived.
{
counter.SuccessedDeliverdPacket(packt);
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
counter.DisplayRefreshAtReceivingPacket(Reciver);
}
else
{
// compute the overhead:
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
if (packt.Hops <= packt.TimeToLive)
{
SendPacket(Reciver, packt);
}
else
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.TimeToLive);
}
}
}
/// <summary>
/// hand the packet to my sink.
/// </summary>
/// <param name="agent"></param>
/// <param name="packt"></param>
public void HandOffToTheSinkOrRecovry(Sensor agent, Packet packt)
{
// check how many sinks are there in my record
if (agent != null)
{
if (packt.SinksAgentsList != null)
{
// my sinks recored in the packet:
List <SinksAgentsRow> MysinksInPpaket = GetMySinksFromPacket(agent.ID, packt.SinksAgentsList); // my sinks in the packet.
List <SinksAgentsRow> MyCurrentSinks = agent.GetSinksAgentsList; //my sinks that currently within my range.
List <int> SinksIDsRequiredRecovery = new List <int>(); // sinks that required recovery. those sinks which are in the packet but not within my range anymore.
for (int i = 0; i < MysinksInPpaket.Count; i++)
{
SinksAgentsRow sinkInPacket = MysinksInPpaket[i];
// check if sink still within the range of the agent
bool stillWithinMyRange = StillWithinMyRange(sinkInPacket, MyCurrentSinks); // check if sink x still within my range
if (stillWithinMyRange)
{
// I am an agent for more than one sink
// here we should increase the PID, otherwise the number of delivered packets will be more than the generated packets.
Packet pck = Duplicate(packt, agent, true); // duplicate and increase the PID
Sink sink = sinkInPacket.Sink;
pck.Path += "> Sink: " + sink.ID;
counter.SuccessedDeliverdPacket(pck);
counter.DisplayRefreshAtReceivingPacket(agent);
}
else
{
// sinkInPacket.Sink is out of agent range.
SinksIDsRequiredRecovery.Add(sinkInPacket.Sink.ID);
}
}
// recovery: SinksIDsRequiredRecovery
if (SinksIDsRequiredRecovery.Count > 0)
{
packt.SinkIDsNeedsRecovery = SinksIDsRequiredRecovery;
new RecoveryMessage(agent, packt);
}
}
else
{
// drop the packet.
// i dont know when it should be null.
Console.Write(">>>>No agents. MergedPathsMessages->HandOffToTheSinkOrRecovry->packt.SinksAgentsList==null");
counter.DropPacket(packt, agent, PacketDropedReasons.Unknow);
}
}
else
{
// drop the packet
Console.Write(">>>>HandOffToTheSinkOrRecovry->agent = null");
counter.DropPacket(packt, agent, PacketDropedReasons.Unknow);
}
}
private void RecivePacket(Sensor Reciver, Packet packt)
{
packt.Path += ">" + Reciver.ID;
if (loopMechan.isLoop(packt))
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.Loop);
}
else
{
packt.ReTransmissionTry = 0;
if (Reciver.IsHightierNode) // packet is recived.
{
packt.Destination = Reciver;
counter.SuccessedDeliverdPacket(packt);
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
counter.DisplayRefreshAtReceivingPacket(Reciver);
// response to the source:
if (packt.SinkIDsNeedsRecovery == null) // nomal
{
new ResonseSinkPositionMessage(Reciver, packt.Source);
}
else
{
// recovery packet.
new ResonseSinkPositionMessage(Reciver, packt.Source, packt.SinkIDsNeedsRecovery);
}
if (Reciver.ReachedBatterThresh)
{
RingNodeChange rch = new RingNodeChange();
rch.ChangeRingNode(Reciver.RingNodesRule);
}
}
else
{
// compute the overhead:
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
if (packt.Hops <= packt.TimeToLive)
{
SendPacket(Reciver, packt);
}
else
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.TimeToLive);
}
}
}
}
private void RecivePacket(Sensor Reciver, Packet packt)
{
if (Reciver == null) // packet is recived.
{
counter.SuccessedDeliverdPacket(packt);
counter.DisplayRefreshAtReceivingPacket(packt.Source);
}
else
{
packt.Path += ">" + Reciver.ID;
packt.ReTransmissionTry = 0;
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
Reciver.AddSinkRecordInHighTierNode(packt.ReportSinkPosition); // keep track of the sink position
SendPacket(Reciver, packt);
}
}
/// <summary>
/// hand the packet to my sink.
/// </summary>
/// <param name="agent"></param>
/// <param name="packt"></param>
private void HandOffToTheSinkOrRecovry(Sensor agent, Packet packt)
{
// check how many sinks are there in my record
if (agent != null)
{
if (packt.SinksAgentsList != null)
{
// the sinks in the packet:
List <SinksAgentsRow> MyinpacketSinks = GetMySinksFromPacket(agent, packt); // The sinks the agent has record of
// the sinks within my range.
List <SinksAgentsRow> inAgentList = agent.GetSinksAgentsList;
List <int> SinksIDsRequiredRecovery = new List <int>(); // the sinks that required recovery.
foreach (SinksAgentsRow rowInpacket in MyinpacketSinks)
{
// check if sink still within the range of the agent
bool isFound = Find(rowInpacket, inAgentList);
if (isFound)
{
//
Sink sink = rowInpacket.Sink;
packt.Path += "> Sink: " + sink.ID;
counter.SuccessedDeliverdPacket(packt);
}
else
{ // the sinks is not within my range:
// change packet destination:
// keep this for recovery.
SinksIDsRequiredRecovery.Add(rowInpacket.Sink.ID);
}
}
// recovery: SinksIDsRequiredRecovery
if (SinksIDsRequiredRecovery.Count > 0)
{
packt.SinkIDsNeedsRecovery = SinksIDsRequiredRecovery;
new RecoveryMessage(agent, packt);
}
}
else
{
// i dont know when it should be null.
counter.DropPacket(packt, agent, PacketDropedReasons.InformationError);
Console.Write("MergedPathsMessages->HandOffToTheSinkOrRecovry->packt.SinksAgentsList==null");
}
}
}
/// <summary>
/// the hightierNode should response to the lowtiernode.
/// here the respnse should contain all sinks.
/// </summary>
/// <param name="hightierNode"></param>
/// <param name="sourceNode"></param>
public ResonseSinkPositionMessage(Sensor hightierNode, Sensor sourceNode)
{
counter = new NetworkOverheadCounter();
// the hightierNode=lowtiernode --> means that the high tier node itself has data to send.
if (hightierNode.ID == sourceNode.ID)
{
// here high tier has data to send.
Packet responspacket = GeneragtePacket(hightierNode, hightierNode, null, true); // fack.
counter.SuccessedDeliverdPacket(responspacket); // count it as delivered
PreparDataTransmission(hightierNode, responspacket);
}
else
{
Packet responspacket = GeneragtePacket(hightierNode, sourceNode, null, true);
SendPacket(hightierNode, responspacket);
}
}
private void RecivePacket(Sensor Reciver, Packet packt)
{
packt.Path += ">" + Reciver.ID;
if (new LoopMechanizimAvoidance(packt).isLoop)
{
// drop the packet:
counter.DropPacket(packt, Reciver, PacketDropedReasons.Loop);
}
else
{
packt.ReTransmissionTry = 0;
if (Reciver.IsHightierNode) // packet is recived.
{
packt.Destination = Reciver;
counter.SuccessedDeliverdPacket(packt);
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
counter.DisplayRefreshAtReceivingPacket(Reciver);
// response to the source:
if (packt.SinkIDsNeedsRecovery == null) // nomal
{
new ResonseSinkPositionMessage(Reciver, packt.Source);
}
else
{
// recovery packet.
// we can also save the record
new ResonseSinkPositionMessage(Reciver, packt.Source, packt.SinkIDsNeedsRecovery);
}
}
else
{
// compute the overhead:
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
if (packt.Hops <= packt.TimeToLive)
{
SendPacket(Reciver, packt);
}
else
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.TimeToLive);
}
}
}
}
/// <summary>
/// obtian location for the sinks with IDs listed in SinkIDs.
/// this is used in the recovery mechansim.
/// when the agent node did not found its sinks.
/// </summary>
/// <param name="AgentNode"> the node that make the request.</param>
/// <param name="SinkIDs"></param>
public ObtainSinkFreshPositionMessage(Sensor AgentNode, List <int> SinkIDs)
{
counter = new NetworkOverheadCounter();
// the high tier node has data.
if (AgentNode.IsHightierNode)
{
Packet pack = GeneragtePacket(AgentNode, true); // fack packet.
pack.SinkIDsNeedsRecovery = SinkIDs; // not all sinks. this is for data recovery only.
counter.SuccessedDeliverdPacket(pack); // count it as delivered
new ResonseSinkPositionMessage(AgentNode, AgentNode, SinkIDs); // recovery.
}
else
{
AgentNode.Ellipse_nodeTypeIndicator.Fill = Brushes.Yellow;
Packet ObtainSinkPositionPacket = GeneragtePacket(AgentNode, true);
ObtainSinkPositionPacket.SinkIDsNeedsRecovery = SinkIDs; // not all sinks. this is for data recovery only.
SendPacket(AgentNode, ObtainSinkPositionPacket);
}
}
/// <summary>
/// obtian the position for all sinks.
/// </summary>
/// <param name="sensor"></param>
public ObtainSinkFreshPositionMessage(Sensor sensor)
{
counter = new NetworkOverheadCounter();
// the high tier node has data.
if (sensor.IsHightierNode)
{
Packet pack = GeneragtePacket(sensor, true);
pack.SinkIDsNeedsRecovery = null;
counter.SuccessedDeliverdPacket(pack); // count it as delivered
new ResonseSinkPositionMessage(sensor, sensor);
}
else
{
sensor.Ellipse_nodeTypeIndicator.Fill = Brushes.Yellow;
Packet ObtainSinkPositionPacket = GeneragtePacket(sensor, true);
ObtainSinkPositionPacket.SinkIDsNeedsRecovery = null;
SendPacket(sensor, ObtainSinkPositionPacket);
}
}
private void RecivePacket(Sensor Reciver, Packet packt)
{
packt.Path += ">" + Reciver.ID;
if (LoopMechan.isLoop(packt))
{
// drop the packet:
counter.DropPacket(packt, Reciver, PacketDropedReasons.Loop);
}
else
{
packt.ReTransmissionTry = 0;
if (Reciver.CenterLocation == packt.Destination) // packet is recived.
{
if (packt.SinksAgentsList.Count == 0)
{
Console.WriteLine("SinksAgentsList.Count == 0 " + "Source " + packt.Source.ID);
}
counter.SuccessedDeliverdPacket(packt);
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
counter.DisplayRefreshAtReceivingPacket(Reciver);
Reciver.Ellipse_nodeTypeIndicator.Fill = Brushes.Transparent;
PreparDataTransmission(Reciver, packt); // the merge path
}
else
{
// compute the overhead:
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
if (packt.Hops <= packt.TimeToLive)
{
SendPacket(Reciver, packt);
}
else
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.TimeToLive);
}
}
}
}
private void RecivePacket(Sensor Reciver, Packet packt)
{
packt.Path += ">" + Reciver.ID;
if (loopMechan.isLoop(packt))
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.Loop);
}
else
{
packt.ReTransmissionTry = 0;
if (Reciver.IsHightierNode)
{
if (Reciver.AlreadyRecievedAgentInfo(packt.ReportSinkPosition)) // packet is recived.
{
// Console.WriteLine("****Success ANPIS : " + Reciver.ID);
counter.SuccessedDeliverdPacket(packt);
counter.DisplayRefreshAtReceivingPacket(packt.Source);
}
else
{
Reciver.AddSinkRecordInHighTierNode(packt.ReportSinkPosition); // keep track of the sink position
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
SendPacket(Reciver, packt);
}
}
else
{
if (packt.Hops <= packt.TimeToLive)
{
SendPacket(Reciver, packt);
}
else
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.TimeToLive);
}
}
}
}
/// <summary>
/// obtian the position for all sinks.
/// </summary>
/// <param name="sourceNode"></param>
public ObtainSinkFreshPositionMessage(Sensor sourceNode)
{
counter = new NetworkOverheadCounter();
// the high tier node has data.
if (sourceNode.RingNodesRule.isRingNode)
{
//Directly send data to the access nodes that u have
//No need to send a query request and wait for response
Packet pack = GeneratePacket(sourceNode, true);
pack.SinkIDsNeedsRecovery = null;
counter.SuccessedDeliverdPacket(pack); // considere the obtian packet as delivred.
new ResonseSinkPositionMessage(sourceNode, sourceNode);
}
else
{
//Regular sensor node disseminating data start with QReq
sourceNode.Ellipse_nodeTypeIndicator.Fill = Brushes.Yellow;
Packet QReq = GeneratePacket(sourceNode, true);
QReq.SinkIDsNeedsRecovery = null;
SendPacket(sourceNode, QReq);
}
}
private void RecivePacket(Sensor Reciver, Packet packt)
{
packt.Path += ">" + Reciver.ID;
if (new LoopMechanizimAvoidance(packt).isLoop)
{
// drop the packet:
counter.DropPacket(packt, Reciver, PacketDropedReasons.Loop);
}
else
{
packt.ReTransmissionTry = 0;
if (Reciver.ID == packt.Destination.ID) // packet is recived.
{
counter.SuccessedDeliverdPacket(packt);
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
counter.DisplayRefreshAtReceivingPacket(Reciver);
Reciver.Ellipse_nodeTypeIndicator.Fill = Brushes.Transparent;
PreparDataTransmission(Reciver, packt); // the merge path
}
else
{
// compute the overhead:
counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver);
if (packt.Hops <= packt.TimeToLive)
{
SendPacket(Reciver, packt);
}
else
{
counter.DropPacket(packt, Reciver, PacketDropedReasons.TimeToLive);
}
}
}
}