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; 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 (packt.Destination.ID == Reciver.ID) { counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver); counter.DisplayRefreshAtReceivingPacket(Reciver); HandOffToTheSinkOrRecovry(Reciver, packt); } else { counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver); counter.DisplayRefreshAtReceivingPacket(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) // 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) { 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); } } } }
private void SendPacket(Sensor sender, Packet pck) { if (pck.PacketType == PacketType.ShareSinkPosition) { Sensor destination; if (pck.PacketDirection == PacketDirection.Right) { destination = sender.RingNodesRule.AntiClockWiseNeighbor; } else { destination = sender.RingNodesRule.ClockWiseNeighbor; } if (destination != null) { if (!Operations.isInMyComunicationRange(sender, destination)) { pck.Destination = destination; SendANPISWithRelay(sender, pck); return; } if (destination.CurrentSensorState == SensorState.Active) { counter.ComputeOverhead(pck, EnergyConsumption.Transmit, sender, destination); counter.Animate(sender, destination, pck); RecivePacket(destination, pck); } else { // wait: counter.SaveToQueue(sender, pck); } } else { //Drop the packet something went wrong counter.DropPacket(pck, sender, PacketDropedReasons.RingNodesError); } } }
public void SendPacket(Sensor sender, Packet pck) { if (pck.PacketType == PacketType.Data) { // neext hope: Sensor Reciver = SelectNextHop(sender, pck); if (Reciver != null) { // overhead: counter.ComputeOverhead(pck, EnergyConsumption.Transmit, sender, Reciver); counter.Animate(sender, Reciver, pck); //: RecivePacket(Reciver, pck); } else { counter.DropPacket(pck, sender, PacketDropedReasons.Loop); } } }
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); } } } }
// try. private void DeliveerPacketsInQueuTimer_Tick(object sender, EventArgs e) { Packet waitingpacket = WaitingPacketsQueue.Dequeue(); waitingpacket.ReTransmissionTry++; if (waitingpacket.ReTransmissionTry <= Settings.Default.ReTransmissionAttemps) { // Console.WriteLine(waitingpacket.PID + ">>>" + waitingpacket.ReTransmissionTry); switch (waitingpacket.PacketType) { case PacketType.ReportSinkPosition: new ReportSinkPositionMessage().HandelInQueuPacket(this, waitingpacket); break; case PacketType.ShareSinkPosition: new ShareSinkPositionIntheHighTier().HandelInQueuPacket(this, waitingpacket); break; case PacketType.ObtainSinkPosition: new ObtainSinkFreshPositionMessage().HandelInQueuPacket(this, waitingpacket); break; case PacketType.ResponseSinkPosition: new ResonseSinkPositionMessage().HandelInQueuPacket(this, waitingpacket); break; case PacketType.Data: new MergedPathsMessages().HandelInQueuPacket(this, waitingpacket); break; } } else { // the packet should be droped here: counter.DropPacket(waitingpacket, this, PacketDropedReasons.WaitingTime); } if (WaitingPacketsQueue.Count == 0) { if (Settings.Default.ShowRadar) { Myradar.StopRadio(); } QueuTimer.Stop(); MainWindow.Dispatcher.Invoke(() => Ellipse_indicator.Fill = Brushes.Transparent); MainWindow.Dispatcher.Invoke(() => Ellipse_indicator.Visibility = Visibility.Hidden); // dont have data any mode than sleep: SwichToSleep(); } }
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); } } } }
private void RecivePacket(Sensor Reciver, Packet packt) { if (LoopMechan.isLoop(packt)) { counter.DropPacket(packt, Reciver, PacketDropedReasons.Loop); } else { // flooooding. if (Reciver.IsHightierNode == false) { // Recivece the packe and send it. counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver); Reciver.IsHightierNode = true; // let each node send once. counter.DisplayRefreshAtReceivingPacket(Reciver); SendPacket(Reciver, packt); } } }
private void RecivePacket(Sensor Reciver, Packet packt) { // string cluster = packt.Branch.Cluster.MembersString; packt.Path += ">" + Reciver.ID; // if Reciver is an agent, then reciev the packet and remove the Reciver from the cluster // reFindBranches if the cluster still have more members. if (new LoopMechanizimAvoidance(packt).isLoop) { // drop the packet: packt.IsLooped = true; counter.DropPacket(packt, Reciver, PacketDropedReasons.Loop); } else { // not loop: packt.ReTransmissionTry = 0; if (Operations.FindInAlist(Reciver, packt.Branch.Cluster.Members) != null) { // Reciver is an agent: counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver); counter.DisplayRefreshAtReceivingPacket(Reciver); // when the packet arrived to Reciver and holds more clustreds. this case reclustring process should be performed. if (packt.Branch.Cluster.Members.Count > 0) { packt.Branch.Cluster.Members.Remove(Reciver); List <Branch> Branches = FindBranches.GetBranches(packt.Branch.Cluster.Members, Reciver.CenterLocation, PublicParamerters.MainWindow.Canvas_SensingFeild, Settings.Default.MaxClusteringThreshold); if (Branches.Count > 0) { MergedPathsMessages merged = new MergedPathsMessages(Reciver, Branches, packt); } } HandOffToTheSinkOrRecovry(Reciver, packt); } else { double dis1 = Operations.DistanceBetweenTwoPoints(Reciver.CenterLocation, packt.Branch.EndPoint); double dis2 = Operations.DistanceBetweenTwoPoints(Reciver.CenterLocation, packt.Branch.Cluster.Centeriod); double disThre = PublicParamerters.CommunicationRangeRadius; if ((dis1 < disThre) && (packt.Branch.Cluster.Members.Count > 1)) { double clusteringThreshould = 0; if (dis2 <= disThre) { clusteringThreshould = Settings.Default.MinClusteringThreshold; } else { clusteringThreshould = Settings.Default.MaxClusteringThreshold; } counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver); List <Branch> Branches = FindBranches.GetBranches(packt.Branch.Cluster.Members, Reciver.CenterLocation, PublicParamerters.MainWindow.Canvas_SensingFeild, clusteringThreshould); if (Branches.Count > 1) { MergedPathsMessages merged = new MergedPathsMessages(Reciver, Branches, packt); } else { counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver); packt.Branch = Branches[0]; // the branch is not changed. only the end coordinat of the branch is changed. SendPacket(Reciver, packt); } } else { counter.ComputeOverhead(packt, EnergyConsumption.Recive, null, Reciver); if (packt.Hops <= packt.TimeToLive) { SendPacket(Reciver, packt); } else { counter.DropPacket(packt, Reciver, PacketDropedReasons.TimeToLive); // since we did not count PID during the generation, thuse we should add here: PublicParamerters.NumberofGeneratedPackets += 1; packt.PID = PublicParamerters.NumberofGeneratedPackets; counter.IncreasePacketsCounter(Reciver, PacketType.Data); // } } } } }
/// <summary> /// preAgent send an obtian packet to ask for the new agent of the sink. /// </summary> /// <param name="preAgent"></param> /// <param name="SinksIDsRequiredRecovery"></param> public RecoveryMessage(Sensor preAgent, Packet packet) { // preAgent: if it has no record, then we obtian the sink position first. // if the preAgent did not sent an obtian message to the hightier node if (preAgent.RecoveryRow == null) { // obtian the recovery. obtian the sink location. Console.WriteLine("RecoveryMessage. >>>>Trying to recover the packet. Source ID=" + packet.Source.ID + " PID=" + packet.PID + " Path " + packet.Path); new ObtainSinkFreshPositionMessage(preAgent, packet.SinkIDsNeedsRecovery); } else { // it has record. no need to resend an obtian: but you should wait. if (!preAgent.RecoveryRow.IsExpired) { // not expired List <Sensor> NewAents = new List <Sensor>(); // new agent for the recovery. foreach (SinksAgentsRow newAgentRow in preAgent.RecoveryRow.RecoveryAgentList) { if (newAgentRow.AgentNode.ID != preAgent.ID) { bool isFound = Operations.FindInAlistbool(newAgentRow.AgentNode, NewAents); if (!isFound) { packet.Destination = newAgentRow.AgentNode; NewAents.Add(newAgentRow.AgentNode); } } } // if we found the new agent. if (NewAents.Count > 0) { Console.WriteLine("RecoveryMessage. Source ID=" + packet.Source.ID + " PID=" + packet.PID + " Path " + packet.Path); List <Branch> Branches = FindBranches.GetBranches(NewAents, preAgent.CenterLocation, PublicParamerters.MainWindow.Canvas_SensingFeild, Settings.Default.MaxClusteringThreshold); packet.SinksAgentsList = preAgent.RecoveryRow.RecoveryAgentList; new MergedPathsMessages(preAgent, Branches, packet); } else { if (preAgent.RecoveryRow.ObtainPacketsRetry >= 3) { // in case no new agent is found. Console.WriteLine("RecoveryMessage. No agent is found during the recovery.Source ID = " + packet.Source.ID + " PID = " + packet.PID + " Path " + packet.Path); NetworkOverheadCounter counter = new NetworkOverheadCounter(); // counter.DropPacket(packet, preAgent, PacketDropedReasons.RecoveryNoNewAgentFound); counter.SaveToQueue(preAgent, packet); } else { Console.WriteLine("RecoveryMessage. Recovery period is expired. Old Agent is sending new obtain packet!" + " Path " + packet.Path); new ObtainSinkFreshPositionMessage(preAgent, packet.SinkIDsNeedsRecovery); // obtain } } } else { // resent the obtian packet. 2 times. if (preAgent.RecoveryRow.ObtainPacketsRetry <= 3) { Console.WriteLine("RecoveryMessage. Recovery period is expired. Old Agent is sending new obtain packet!" + " Path " + packet.Path); new ObtainSinkFreshPositionMessage(preAgent, packet.SinkIDsNeedsRecovery); // obtain } else { Console.WriteLine("RecoveryMessage. Recovery period is expired. we tryied to re-sent the obtian packet for three times and faild. The packet will be droped." + " Path " + packet.Path); // drop the packet: NetworkOverheadCounter counter = new NetworkOverheadCounter(); counter.DropPacket(packet, preAgent, PacketDropedReasons.RecoveryPeriodExpired); preAgent.RecoveryRow = null; } } } }
/// <summary> /// preAgent: the packet will arrived to this agent. This agent did not know the location of the new agent for the SinksIDsRequiredRecovery. /// </summary> /// <param name="preAgent"></param> /// <param name="SinksIDsRequiredRecovery"></param> public RecoveryMessage(Sensor preAgent, Packet packet) { // preAgent: if it has no record, then we obtian the sink position first. // if the preAgent did not sent an obtian message to the hightier node if (preAgent.RecoveryRow == null) { // obtian the recovery. obtian the sink location. new ObtainSinkFreshPositionMessage(preAgent, packet.SinkIDsNeedsRecovery); // } else { // it has record. no need to resend an obtian: but you should wait. if (!preAgent.RecoveryRow.IsExpired) { // not expired List <Sensor> NewAents = new List <Sensor>(); // new agent for the recovery. foreach (SinksAgentsRow row in preAgent.RecoveryRow.RecoveryAgentList) // get the agents { if (row.AgentNode.ID != preAgent.ID) // no the same agent. the new one should had diffrent ID { bool isFound = Operations.FindInAlistbool(row.AgentNode, NewAents); // no repeatation if (!isFound) { packet.Destination = row.AgentNode; // update the packet destination. NewAents.Add(row.AgentNode); } } } if (NewAents.Count > 0) { Console.WriteLine("RecoveryMessage. Source ID=" + packet.Source.ID + " PID=" + packet.PID + " Path " + packet.Path); packet.SinksAgentsList = preAgent.RecoveryRow.RecoveryAgentList; if (packet.Hops <= packet.TimeToLive) { new DataPacketMessages(preAgent, packet); } else { NetworkOverheadCounter counter = new NetworkOverheadCounter(); counter.DropPacket(packet, preAgent, PacketDropedReasons.Loop); } } else { if (preAgent.RecoveryRow.ObtainPacketsRetry >= 3) { // in case no new agent is found. Console.WriteLine("RecoveryMessage. No agent is found during the recovery.Source ID = " + packet.Source.ID + " PID = " + packet.PID + " Path " + packet.Path); NetworkOverheadCounter counter = new NetworkOverheadCounter(); counter.DropPacket(packet, preAgent, PacketDropedReasons.RecoveryNoNewAgentFound); } else { Console.WriteLine("RecoveryMessage. Recovery period is expired. Old Agent is sending new obtain packet!" + " Path " + packet.Path); new ObtainSinkFreshPositionMessage(preAgent, packet.SinkIDsNeedsRecovery); // obtain } } } else { // resent the obtian packet. 2 times. if (preAgent.RecoveryRow.ObtainPacketsRetry <= 3) { Console.WriteLine("RecoveryMessage. Recovery period is expired. Old Agent is sending new obtain packet!" + " Path " + packet.Path); new ObtainSinkFreshPositionMessage(preAgent, packet.SinkIDsNeedsRecovery); // obtain } else { Console.WriteLine("RecoveryMessage. Recovery period is expired. we tryied to re-sent the obtian packet for three times and faild. The packet will be droped." + " Path " + packet.Path); // drop the packet: NetworkOverheadCounter counter = new NetworkOverheadCounter(); counter.DropPacket(packet, preAgent, PacketDropedReasons.RecoveryPeriodExpired); preAgent.RecoveryRow = null; } } } }