/// <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>
/// 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!");
}
}
}
}
