/// <summary>
/// send data
/// </summary>
public void SendData(Sensor FromSensor, Sensor ToSensor, Datapacket datap)
{
// Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
// {
if (ToSensor != null || FromSensor != null)
{
if (ToSensor.ID != FromSensor.ID)
{
if (FromSensor.ResidualEnergy > 0)
{
SensorRoutingLog log = new SensorRoutingLog();
log.IsSend = true;
log.NodeID = this.ID;
log.Operation = "To:" + ToSensor.ID;
log.Time = DateTime.Now;
log.Distance_M = Operations.DistanceBetweenTwoSensors(FromSensor, ToSensor);
log.UsedEnergy_Nanojoule = EnergyModel.Transmit(RoutingDataLength, log.Distance_M);
//
// set the remain battery Energy:
double remainEnergy = ResidualEnergy - log.UsedEnergy_Joule;
FromSensor.ResidualEnergy = remainEnergy;
log.RemaimBatteryEnergy_Joule = ResidualEnergy;
log.PID = datap.PacektSequentID;
//
log.DirectionDistCnt = datap.DirectionDistCnt;
log.EnergyDistCnt = datap.EnergyDistCnt;
log.PrepDistanceDistCnt = datap.PrepDistanceDistCnt;
log.TransDistanceDistCnt = datap.TransDistanceDistCnt;
log.RoutingZoneWidthCnt = datap.RoutingZoneWidthCnt;
// add the path:457430817
datap.UsedEnergy_Joule += log.UsedEnergy_Joule;
//
if (Settings.Default.KeepLogs)
{
log.RelaySequence = datap.Hops + 1;
log.ForwardingRandomNumber = datap.ForwardingRandomNumber;
FromSensor.Logs.Add(log); // keep logs for each node.
MainWindow.Canvas_SensingFeild.Children.Add(datap); // add the lines to the boad.
}
// ToSensor ReceiveData
ToSensor.ReceiveData(FromSensor, ToSensor, datap);
}
else
{
PublicParamerters.IsNetworkDied = true;
this.Ellipse_Communication_range.Fill = Brushes.Brown; // die out node. // MessageBox.Show("DeadNODE!");
}
}
}
else
{
}
// });
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="Reciver"></param>
/// <param name="datap"></param>
public void SendData(Sensor sender, Sensor Reciver, Datapacket datap)
{
if (Reciver != null || sender != null)
{
if (Reciver.ID != sender.ID)
{
if (sender.ResidualEnergy > 0)
{
sender.SwichToActive();
Reciver.SwichToActive();
SensorRoutingLog log = new SensorRoutingLog();
log.IsSend = true;
log.NodeID = this.ID;
log.Operation = "To:" + Reciver.ID;
log.Time = DateTime.Now;
log.Distance_M = Operations.DistanceBetweenTwoSensors(sender, Reciver);
log.UsedEnergy_Nanojoule = EnergyModel.Transmit(RoutingDataLength, log.Distance_M);
//
// set the remain battery Energy:
double remainEnergy = ResidualEnergy - log.UsedEnergy_Joule;
sender.ResidualEnergy = remainEnergy;
log.RemaimBatteryEnergy_Joule = ResidualEnergy;
log.PID = datap.PacektSequentID;
//
// add the path:457430817
datap.UsedEnergy_Joule += log.UsedEnergy_Joule;
PublicParamerters.TotalEnergyConsumptionJoule += log.UsedEnergy_Joule;
//
if (Settings.Default.KeepLogs)
{
log.RelaySequence = datap.Hops + 1;
sender.Logs.Add(log); // keep logs for each node.
}
else
{
Dispose();
}
if (Settings.Default.DrawPacketsLines)
{
MainWindow.Canvas_SensingFeild.Children.Add(datap); // add the lines to the boad.
}
// ToSensor ReceiveData
Reciver.ReceiveData(sender, Reciver, datap);
}
else
{
Ellipse_Sensing_range.Fill = Brushes.Brown; // die out node. // MessageBox.Show("DeadNODE!");
}
}
}
else
{
}
}
/// <summary>
///
/// </summary>
public void GeneratePacketAndSent()
{
List <RoutingMetric> Forwarders = MyForwardersShortedList;
if (Forwarders != null)
{
ForwardersCoordination coordDinator = new ForwardersCoordination();
RoutingMetric nextHop = coordDinator.SelectedForwarder(this, this);
if (nextHop != null)
{
NumberofPacketsGeneratedByMe++;
PublicParamerters.NumberofGeneratedPackets++;// public
Datapacket datap = new Datapacket(this, nextHop.PotentialForwarder);
datap.SourceNode = this;
datap.SourceNodeID = ID;
datap.Path = this.ID.ToString();
datap.DistanceFromSourceToSink = Operations.DistanceBetweenTwoSensors(PublicParamerters.SinkNode, this);
datap.PacektSequentID = PublicParamerters.NumberofGeneratedPackets;
datap.MaxHops = ComputeMaxHops;
this.SwichToActive();
SendData(this, nextHop.PotentialForwarder, datap);// send the data:
this.lbl_Sensing_ID.Foreground = Brushes.Red;
if (Settings.Default.KeepLogs)
{
// HistoricalRelativityRows.AddRange(Forwarders);
}
else
{
Dispose();
}
}
else
{
// has no forwarders then let him try:
PublicParamerters.NumberofGeneratedPackets++; // public
NumberofPacketsGeneratedByMe++;
Datapacket datap = new Datapacket(); // packet with no sender.
datap.SourceNode = this;
datap.MaxHops = ComputeMaxHops;
datap.SourceNodeID = ID;
datap.Path = this.ID.ToString();
datap.DistanceFromSourceToSink = Operations.DistanceBetweenTwoSensors(PublicParamerters.SinkNode, this);
datap.PacektSequentID = PublicParamerters.NumberofGeneratedPackets;
SwichToActive();
this.lbl_Sensing_ID.Foreground = Brushes.Red;
RelayThePacket(this, datap);
}
}
else
{
if (ID != PublicParamerters.SinkNode.ID)
{
MessageBox.Show("Node:" + ID + "Has No Forwarders");
}
}
}
public void GeneratePacekts()
{
PublicParamerters.PackeTSequenceID += 1;
Datapacket datap = new Datapacket();
datap.SourceNode = this;
datap.SourceNodeID = ID;
datap.Path = this.ID.ToString(); // start
datap.Distance = Operations.DistanceBetweenTwoSensors(PublicParamerters.SinkNode, this);
datap.PacektSequentID = PublicParamerters.PackeTSequenceID; // PID
NumberofPacketsGeneratedByMe += 1;
SendPacekt(this, datap);
}
/// <summary>
/// generate and sent
/// </summary>
/// <returns></returns>
public void GeneratePacketAndSent(bool isRandom, double EnergyDistCnt, double TransDistanceDistCnt, double DirectionDistCnt, double PrepDistanceDistCnt)
{
PublicParamerters.PackeTSequenceID++;
DistributionsComputations relatives = new DistributionsComputations();
List <RoutingRandomVariable> RelativityRows = relatives.ComputeDistributions(this, PublicParamerters.SinkNode, this, EnergyDistCnt, TransDistanceDistCnt, DirectionDistCnt, PrepDistanceDistCnt);
if (RelativityRows != null)
{
SeletNextHopRandomlly randomGenrator = new SeletNextHopRandomlly();
RoutingRandomVariable nextHop = randomGenrator.SelectNextHop(RelativityRows);
if (nextHop != null)
{
if (RelativityRows.Count > 0)
{
Datapacket datap = new Datapacket(this, nextHop.NextHopNode);
datap.ForwardingRandomNumber = randomGenrator.RandomeNumber;
datap.SourceNode = this;
datap.SourceNodeID = ID;
datap.Path = this.ID.ToString(); // start
datap.Distance = Operations.DistanceBetweenTwoSensors(PublicParamerters.SinkNode, this);
datap.IsRandomControls = isRandom;
datap.EnergyDistCnt = EnergyDistCnt;
datap.TransDistanceDistCnt = TransDistanceDistCnt;
datap.DirectionDistCnt = DirectionDistCnt;
datap.PrepDistanceDistCnt = PrepDistanceDistCnt;
datap.RoutingZoneWidthCnt = Settings.Default.ZoneWidthCnt;
NumberofPacketsGeneratedByMe++;
datap.RoutingProbabilityForPath = nextHop.RoutingVariableProb;
datap.PacektSequentID = PublicParamerters.PackeTSequenceID;
SendData(this, nextHop.NextHopNode, datap);// send the data:
if (Settings.Default.ShowRoutigZone)
{
DrawMyZone();
}
}
this.lbl_Sensing_ID.Foreground = Brushes.Red;
// this.lbl_Sensing_ID.FontWeight = FontWeights.Bold;
//: historial record:
if (Settings.Default.KeepLogs)
{
HistoricalRelativityRows.AddRange(RelativityRows);
}
}
}
}
/// <summary>
/// check if the packet is within the WaitingList of RelayNode.
/// </summary>
/// <param name="RelayNode"></param>
/// <param name="datap"></param>
/// <returns></returns>
public bool IsThisPacketInTheWaitingList(Sensor RelayNode, Datapacket datap)
{
List <Datapacket> COPY = new List <Datapacket>();
COPY.AddRange(RelayNode.WaitingList);
foreach (Datapacket pack in COPY)
{
if (pack.PacektSequentID == datap.PacektSequentID)
{
return(true);
}
}
return(false);
}
public void RelayThePacket(Sensor RelayNode, Datapacket datap)
{
List <RoutingMetric> GetMyForw = MyForwardersShortedList;
ForwardersCoordination coordinator = new ForwardersCoordination();
RoutingMetric nextHop = coordinator.SelectedForwarder(RelayNode, datap.SourceNode);
if (nextHop != null) // not the sink
{
// no loop:
Datapacket forwardPacket;
forwardPacket = new Datapacket(RelayNode, nextHop.PotentialForwarder);
forwardPacket.MaxHops = datap.MaxHops;
forwardPacket.PacketWaitingTimes = datap.PacketWaitingTimes;
forwardPacket.SourceNodeID = datap.SourceNodeID;
forwardPacket.DistanceFromSourceToSink = datap.DistanceFromSourceToSink;
forwardPacket.RoutingDistance = datap.RoutingDistance;
forwardPacket.Path = datap.Path;
forwardPacket.Hops = datap.Hops;
forwardPacket.UsedEnergy_Joule = datap.UsedEnergy_Joule;
forwardPacket.Delay = datap.Delay;
forwardPacket.SourceNode = datap.SourceNode;
forwardPacket.PacektSequentID = datap.PacektSequentID;
if (IsThisPacketInTheWaitingList(RelayNode, datap))
{
WaitingList.Remove(datap);
}
RelayNode.SendData(RelayNode, nextHop.PotentialForwarder, forwardPacket);
}
else
{
// wait:
// waiting time.
// the either all the nodes are sleep
if (GetMyForw.Count > 0)
{
datap.PacketWaitingTimes = datap.PacketWaitingTimes + 1;
if (!IsThisPacketInTheWaitingList(RelayNode, datap))
{
WaitingList.Add(datap);
}
RelayNode.DeliveerPacketsInQueuTimer.Start();
}
else
{
// MessageBox.Show("This Node has no forwarders!");
}
}
}
/// <summary>
/// send data
/// </summary>
public void SendPacekt(Sensor Sender, Datapacket datap)
{
// set sender and reciver.// each hop.
Sensor RecieverSensor = Sender.TreeBasedParentSensor;
datap.Sender = Sender;
datap.Reciver = RecieverSensor;
if (RecieverSensor != null)
{
if (RecieverSensor.ID != this.ID) // this is the sender.
{
if (ResidualEnergy > 0)
{
this.Ellipse_Sensing_range.Fill = Brushes.Red;
SensorRoutingLog log = new SensorRoutingLog();
log.IsSend = true;
log.NodeID = this.ID;
log.Operation = "Send Data To:" + RecieverSensor.ID;
log.Time = DateTime.Now;
log.Distance_M = Operations.DistanceBetweenTwoSensors(Sender, RecieverSensor);
log.UsedEnergy_Nanojoule = EnergyModel.Transmit(PublicParamerters.RoutingDataLength, log.Distance_M);
// set the remain battery Energy:
double remainEnergy = ResidualEnergy - log.UsedEnergy_Joule;
ResidualEnergy = remainEnergy;
log.RemaimBatteryEnergy_Joule = ResidualEnergy;
log.PID = datap.PacektSequentID;
RoutingOperationsLog.Add(log);
log.RelaySequence = datap.Hops;
datap.UsedEnergy_Joule += log.UsedEnergy_Joule;
// send:
RecieverSensor.ReceivePacekt(Sender, datap);
}
else
{
this.Ellipse_Sensing_range.Fill = Brushes.Brown; // die out node.
// MessageBox.Show("DeadNODE!");
}
}
}
}
/// <summary>
/// reciev data
/// </summary>
public void ReceivePacekt(Sensor SenderSensor, Datapacket datap)
{
if (SenderSensor != null)
{
if (SenderSensor.ID != this.ID)
{
if (ResidualEnergy > 0)
{
SensorRoutingLog log = new SensorRoutingLog();
log.IsReceive = true;
log.NodeID = this.ID;
log.Operation = "Receive Data From:" + SenderSensor.ID;
log.Time = DateTime.Now;
log.Distance_M = Operations.DistanceBetweenTwoSensors(this, SenderSensor);
log.UsedEnergy_Nanojoule = EnergyModel.Receive(PublicParamerters.RoutingDataLength);
// set the remain battery Energy:
double remainEnergy = ResidualEnergy - log.UsedEnergy_Joule;
ResidualEnergy = remainEnergy;
log.RemaimBatteryEnergy_Joule = ResidualEnergy;
if (PublicParamerters.SaveNetworkRecords)
{
this.RoutingOperationsLog.Add(log);
}
datap.UsedEnergy_Joule += log.UsedEnergy_Joule;
// routing distance:
datap.Path += ">" + datap.Reciver.ID;
datap.RoutingDistance += log.Distance_M;
datap.Hops += 1;
datap.UsedEnergy_Joule += log.UsedEnergy_Joule;
datap.Delay += DelayModel.DelayModel.Delay(datap.Sender, datap.Reciver);
log.RelaySequence = datap.Hops;
log.PID = datap.PacektSequentID;
// Fowrward: colone
Datapacket forwardPacket = new Datapacket();
forwardPacket.SourceNodeID = datap.SourceNodeID;
forwardPacket.Distance = datap.Distance;
forwardPacket.RoutingDistance = datap.RoutingDistance;
forwardPacket.Path = datap.Path;
forwardPacket.Hops = datap.Hops;
forwardPacket.UsedEnergy_Joule = datap.UsedEnergy_Joule;
forwardPacket.Delay = datap.Delay;
forwardPacket.SourceNode = datap.SourceNode;
forwardPacket.PacektSequentID = datap.PacektSequentID;
Sensor RelayNode = datap.Reciver;
if (RelayNode.ID == PublicParamerters.SinkNode.ID)
{
PublicParamerters.SinkNode.PacketsList.Add(datap);
}
else
{
// FORWARD:
RelayNode.SendPacekt(datap.Reciver, forwardPacket);
}
}
else
{
this.Ellipse_Sensing_range.Fill = Brushes.Brown; // die out node
// MessageBox.Show("DeadNODE!");
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="reciver"></param>
/// <param name="datap"></param>
public void ReceiveData(Sensor sender, Sensor reciver, Datapacket datap)
{
if (reciver != null || sender != null)
{
if (reciver.ID != PublicParamerters.SinkNode.ID)
{
if (reciver.ID != sender.ID)
{
if (reciver.ResidualEnergy > 0)
{
SensorRoutingLog log = new SensorRoutingLog();
log.IsReceive = true;
log.NodeID = this.ID;
log.Operation = "From:" + sender.ID;
log.Time = DateTime.Now;
log.Distance_M = Operations.DistanceBetweenTwoSensors(reciver, sender);
log.UsedEnergy_Nanojoule = EnergyModel.Receive(RoutingDataLength);
log.PID = datap.PacektSequentID;
// set the remain battery Energy:
if (reciver.ID != PublicParamerters.SinkNode.ID)
{
double remainEnergy = ResidualEnergy - log.UsedEnergy_Joule;
reciver.ResidualEnergy = remainEnergy;
log.RemaimBatteryEnergy_Joule = ResidualEnergy;
PublicParamerters.TotalEnergyConsumptionJoule += log.UsedEnergy_Joule;
}
// routing distance:
datap.Path += ">" + reciver.ID;
datap.RoutingDistance += log.Distance_M;
datap.Hops += 1;
datap.UsedEnergy_Joule += log.UsedEnergy_Joule;
datap.Delay += DelayModel.DelayModel.Delay(sender, reciver);
if (Settings.Default.KeepLogs)
{
reciver.Logs.Add(log); // keep logs for each node.
}
else
{
Dispose();
}
if (datap.Hops > datap.MaxHops)
{
datap.IsDelivered = false;
PublicParamerters.SinkNode.PacketsList.Add(datap);
PublicParamerters.NumberofDropedPacket += 1;
}
else
{
// relay:
RelayThePacket(reciver, datap);// relay the packet:
}
}
else
{
if (Settings.Default.StopeWhenFirstNodeDeid)
{
MainWindow.TimerCounter.Stop();
MainWindow.RandomSelectSourceNodesTimer.Stop();
MainWindow.stopSimlationWhen = PublicParamerters.SimulationTime;
/*ExpReport win = new ExpReport(MainWindow);
* win.Show();*/
MainWindow.top_menu.IsEnabled = true;
}
}
}
else
{
MessageBox.Show("Error, The sender and reciver are the same!");
}
}
else
{
// recive the packet by the sink:
SensorRoutingLog log = new SensorRoutingLog();
log.IsReceive = true;
log.NodeID = this.ID;
log.Operation = "From:" + sender.ID;
log.Time = DateTime.Now;
log.Distance_M = Operations.DistanceBetweenTwoSensors(reciver, sender);
log.UsedEnergy_Nanojoule = EnergyModel.Receive(RoutingDataLength);
log.PID = datap.PacektSequentID;
// set the remain battery Energy:
if (reciver.ID != PublicParamerters.SinkNode.ID)
{
double remainEnergy = ResidualEnergy - log.UsedEnergy_Joule;
reciver.ResidualEnergy = remainEnergy;
log.RemaimBatteryEnergy_Joule = ResidualEnergy;
PublicParamerters.TotalEnergyConsumptionJoule += log.UsedEnergy_Joule;
}
// routing distance:
datap.Path += ">" + reciver.ID;
datap.RoutingDistance += log.Distance_M;
datap.Hops += 1;
datap.UsedEnergy_Joule += log.UsedEnergy_Joule;
datap.Delay += DelayModel.DelayModel.Delay(sender, reciver);
datap.IsDelivered = true;
if (Settings.Default.KeepLogs)
{
datap.IsDelivered = true;
PublicParamerters.NumberofDeliveredPacket += 1;
PublicParamerters.SinkNode.PacketsList.Add(datap);
PublicParamerters.RoutingDistanceEffeciency += datap.RoutingDistanceEfficiency;
PublicParamerters.TotalNumberOfHope += datap.Hops;
PublicParamerters.TransmissionDistanceEff += datap.TransDistanceEfficiency;
PublicParamerters.TotalWaitingTime += datap.PacketWaitingTimes;
}
else
{
PublicParamerters.NumberofDeliveredPacket += 1;
PublicParamerters.RoutingDistanceEffeciency += datap.RoutingDistanceEfficiency;
PublicParamerters.TotalNumberOfHope += datap.Hops;
PublicParamerters.TransmissionDistanceEff += datap.TransDistanceEfficiency;
PublicParamerters.TotalWaitingTime += datap.PacketWaitingTimes;
Dispose();
}
}
}
else
{
MessageBox.Show("Error. Reciver or Sender is Null.");
}
}
/// <summary>
///
/// </summary>
/// <param name="FromSensor"></param>
/// <param name="ToSensor"></param>
/// <param name="datap"></param>
public void ReceiveData(Sensor FromSensor, Sensor ToSensor, Datapacket datap)
{
if (ToSensor != null || FromSensor != null)
{
if (ToSensor.ID != FromSensor.ID)
{
if (ToSensor.ResidualEnergy > 0)
{
SensorRoutingLog log = new SensorRoutingLog();
log.IsReceive = true;
log.NodeID = this.ID;
log.Operation = "From:" + FromSensor.ID;
log.Time = DateTime.Now;
log.Distance_M = Operations.DistanceBetweenTwoSensors(ToSensor, FromSensor);
log.UsedEnergy_Nanojoule = EnergyModel.Receive(RoutingDataLength);
log.PID = datap.PacektSequentID;
// set the remain battery Energy:
if (ToSensor.ID != PublicParamerters.SinkNode.ID)
{
double remainEnergy = ResidualEnergy - log.UsedEnergy_Joule;
ToSensor.ResidualEnergy = remainEnergy;
log.RemaimBatteryEnergy_Joule = ResidualEnergy;
}
// routing distance:
datap.Path += ">" + ToSensor.ID;
datap.RoutingDistance += log.Distance_M;
datap.Hops += 1;
datap.UsedEnergy_Joule += log.UsedEnergy_Joule;
datap.Delay += DelayModel.DelayModel.Delay(FromSensor, ToSensor);
// random：
if (datap.IsRandomControls)
{
// forward: with random random controls:
// calculate adil relatives:
Sensor RelayNode = ToSensor;
DistributionsComputations relatives = new DistributionsComputations();
List <double> Controls = RandomControls.Generate4Controls();
List <RoutingRandomVariable> RelativityRows = relatives.ComputeDistributions(datap.SourceNode, PublicParamerters.SinkNode, RelayNode, Controls[0], Controls[1], Controls[2], Controls[3]);
SeletNextHopRandomlly randomGenrator = new SeletNextHopRandomlly();
RoutingRandomVariable nextHop = randomGenrator.SelectNextHop(RelativityRows);
if (nextHop != null) // not the sink
{
//: historial record:
if (Settings.Default.KeepLogs)
{
// log.ForwardingRandomNumber = datap.ForwardingRandomNumber;
ToSensor.Logs.Add(log); // add the log
HistoricalRelativityRows.AddRange(RelativityRows); // add the log
}
// forward:
Datapacket forwardPacket;
if (RelativityRows.Count > 0)
{
Sensor NextHopNode = nextHop.NextHopNode;
forwardPacket = new Datapacket(RelayNode, NextHopNode);
forwardPacket.ForwardingRandomNumber = randomGenrator.RandomeNumber;
forwardPacket.SourceNodeID = datap.SourceNodeID;
forwardPacket.Distance = datap.Distance;
forwardPacket.RoutingDistance = datap.RoutingDistance;
forwardPacket.Path = datap.Path;
forwardPacket.Hops = datap.Hops;
forwardPacket.UsedEnergy_Joule = datap.UsedEnergy_Joule;
forwardPacket.Delay = datap.Delay;
forwardPacket.SourceNode = datap.SourceNode;
forwardPacket.IsRandomControls = true;
forwardPacket.RoutingZoneWidthCnt = datap.RoutingZoneWidthCnt;
forwardPacket.EnergyDistCnt = Controls[0];
forwardPacket.TransDistanceDistCnt = Controls[1];
forwardPacket.DirectionDistCnt = Controls[2];
forwardPacket.PrepDistanceDistCnt = Controls[3];
forwardPacket.RoutingProbabilityForPath = datap.RoutingProbabilityForPath * nextHop.RoutingVariableProb;
forwardPacket.PacektSequentID = datap.PacektSequentID;
RelayNode.SendData(RelayNode, NextHopNode, forwardPacket);
}
}
else // this sink:
{
if (RelayNode.ID == PublicParamerters.SinkNode.ID)
{
RelayNode.PacketsList.Add(datap);
}
}
}
else
{
// forward: without random controls:
// calculate adil relatives:
Sensor RelayNode = ToSensor;
DistributionsComputations relatives = new DistributionsComputations();
List <RoutingRandomVariable> RelativityRows = relatives.ComputeDistributions(datap.SourceNode, PublicParamerters.SinkNode, RelayNode, Settings.Default.EnergyDistCnt, Settings.Default.TransDistanceDistCnt, Settings.Default.DirectionDistCnt, Settings.Default.PrepDistanceDistCnt);
SeletNextHopRandomlly randomGenrator = new SeletNextHopRandomlly();
RoutingRandomVariable nextHop = randomGenrator.SelectNextHop(RelativityRows);
if (nextHop != null) // not the sink
{
//: historial record:
if (Settings.Default.KeepLogs)
{
// log.ForwardingRandomNumber = datap.ForwardingRandomNumber;
ToSensor.Logs.Add(log); // add the log
HistoricalRelativityRows.AddRange(RelativityRows); // add the log
}
// forward:
Datapacket forwardPacket;
if (RelativityRows.Count > 0)
{
Sensor NextHopNode = nextHop.NextHopNode;
forwardPacket = new Datapacket(RelayNode, NextHopNode);
forwardPacket.ForwardingRandomNumber = randomGenrator.RandomeNumber;
forwardPacket.SourceNodeID = datap.SourceNodeID;
forwardPacket.Distance = datap.Distance;
forwardPacket.RoutingDistance = datap.RoutingDistance;
forwardPacket.Path = datap.Path;
forwardPacket.Hops = datap.Hops;
forwardPacket.UsedEnergy_Joule = datap.UsedEnergy_Joule;
forwardPacket.Delay = datap.Delay;
forwardPacket.SourceNode = datap.SourceNode;
forwardPacket.RoutingZoneWidthCnt = datap.RoutingZoneWidthCnt;
forwardPacket.IsRandomControls = false;
forwardPacket.PrepDistanceDistCnt = datap.PrepDistanceDistCnt;
forwardPacket.TransDistanceDistCnt = datap.TransDistanceDistCnt;
forwardPacket.EnergyDistCnt = datap.EnergyDistCnt;
forwardPacket.DirectionDistCnt = datap.DirectionDistCnt;
forwardPacket.RoutingProbabilityForPath = datap.RoutingProbabilityForPath * nextHop.RoutingVariableProb;
forwardPacket.PacektSequentID = datap.PacektSequentID;
RelayNode.SendData(RelayNode, NextHopNode, forwardPacket);
}
}
else // this sink:
{
if (RelayNode.ID == PublicParamerters.SinkNode.ID)
{
RelayNode.PacketsList.Add(datap);
}
}
}
}
else
{
this.Ellipse_Communication_range.Fill = Brushes.Brown;// die out node
// MessageBox.Show("DeadNODE!");
}
}
}
}
