/// <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>
/// this counts the energy consumption, the delay and the hops.
/// </summary>
/// <param name="packt"></param>
/// <param name="enCon"></param>
/// <param name="sender"></param>
/// <param name="Reciver"></param>
public void ComputeOverhead(Packet packt, EnergyConsumption enCon, Sensor sender, Sensor Reciver)
{
if (enCon == EnergyConsumption.Transmit)
{
// calculate the energy
double Distance_M = Operations.DistanceBetweenTwoSensors(sender, Reciver);
double UsedEnergy_Nanojoule = EnergyModel.Transmit(packt.PacketLength, Distance_M);
double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule);
sender.ResidualEnergy = sender.ResidualEnergy - UsedEnergy_joule;
PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule;
packt.UsedEnergy_Joule += UsedEnergy_joule;
packt.Hops += 1;
double delay = DelayModel.DelayModel.Delay(sender, Reciver, packt);
packt.Delay += delay;
PublicParamerters.TotalDelayMs += delay;
PublicParamerters.TotalRoutingDistance += Distance_M;
PublicParamerters.TotalNumberOfHops += 1;
switch (packt.PacketType)
{
case PacketType.Data:
PublicParamerters.EnergyConsumedForDataPackets += UsedEnergy_joule; // data packets.
break;
default:
PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule; // other packets.
break;
}
}
else if (enCon == EnergyConsumption.Recive)
{
if (Reciver != null)
{
double UsedEnergy_Nanojoule = EnergyModel.Receive(packt.PacketLength);
double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule);
Reciver.ResidualEnergy = Reciver.ResidualEnergy - UsedEnergy_joule;
packt.UsedEnergy_Joule += UsedEnergy_joule;
PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule;
switch (packt.PacketType)
{
case PacketType.Data:
PublicParamerters.EnergyConsumedForDataPackets += UsedEnergy_joule; // data packets.
break;
default:
PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule; // other packets.
break;
}
}
}
}
/// <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>
/// this counts the energy consumption, the delay and the hops.
/// </summary>
/// <param name="packt"></param>
/// <param name="enCon"></param>
/// <param name="sender"></param>
/// <param name="Reciver"></param>
public void ComputeOverhead(Packet packt, EnergyConsumption enCon, Sensor sender, Sensor Reciver)
{
if (enCon == EnergyConsumption.Transmit)
{
// calculate the energy
double Distance_M = Operations.DistanceBetweenTwoSensors(sender, Reciver);
double UsedEnergy_Nanojoule = EnergyModel.Transmit(packt.PacketLength, Distance_M);
double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule);
sender.ResidualEnergy = sender.ResidualEnergy - UsedEnergy_joule;
PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule;
packt.UsedEnergy_Joule += UsedEnergy_joule;
// packt.RoutingDistance += Distance_M;
packt.Hops += 1;
double delay = DelayModel.DelayModel.Delay(sender, Reciver, packt);
packt.Delay += delay;
PublicParamerters.TotalDelayMs += delay;
PublicParamerters.TotalNumberOfHops += 1;
PublicParamerters.TotalRoutingDistance += Distance_M;
if (Settings.Default.SaveRoutingLog)
{
RoutingLog log = new RoutingLog();
log.PacketType = packt.PacketType;
log.IsSend = true;
log.NodeID = sender.ID;
log.Operation = "To:" + Reciver.ID;
log.Time = DateTime.Now;
log.Distance_M = Distance_M;
log.UsedEnergy_Nanojoule = UsedEnergy_Nanojoule;
log.RemaimBatteryEnergy_Joule = sender.ResidualEnergy;
log.PID = packt.PID;
sender.Logs.Add(log);
}
switch (packt.PacketType)
{
case PacketType.Data:
PublicParamerters.EnergyConsumedForDataPackets += UsedEnergy_joule; // data packets.
break;
default:
PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule; // other packets.
break;
}
}
else if (enCon == EnergyConsumption.Recive)
{
if (Reciver != null)
{
double UsedEnergy_Nanojoule = EnergyModel.Receive(packt.PacketLength);
double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule);
Reciver.ResidualEnergy = Reciver.ResidualEnergy - UsedEnergy_joule;
packt.UsedEnergy_Joule += UsedEnergy_joule;
PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule;
switch (packt.PacketType)
{
case PacketType.Data:
PublicParamerters.EnergyConsumedForDataPackets += UsedEnergy_joule; // data packets.
break;
default:
PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule; // other packets.
break;
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="packt"></param>
/// <param name="enCon"></param>
/// <param name="Reciver"></param>
public void ComputeOverhead(Packet packt, EnergyConsumption enCon, Sensor Reciver)
{
if (enCon == EnergyConsumption.Transmit)
{
if (ID != PublicParamerters.SinkNode.ID)
{
// calculate the energy
double Distance_M = Operations.DistanceBetweenTwoSensors(this, Reciver);
double UsedEnergy_Nanojoule = EnergyModel.Transmit(packt.PacketLength, Distance_M);
double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule);
ResidualEnergy = this.ResidualEnergy - UsedEnergy_joule;
PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule;
packt.UsedEnergy_Joule += UsedEnergy_joule;
packt.RoutingDistance += Distance_M;
packt.Hops += 1;
double delay = DelayModel.DelayModel.Delay(this, Reciver);
packt.Delay += delay;
PublicParamerters.TotalDelayMs += delay;
if (Settings.Default.SaveRoutingLog)
{
RoutingLog log = new RoutingLog();
log.PacketType = PacketType.Data;
log.IsSend = true;
log.NodeID = this.ID;
log.Operation = "To:" + Reciver.ID;
log.Time = DateTime.Now;
log.Distance_M = Distance_M;
log.UsedEnergy_Nanojoule = UsedEnergy_Nanojoule;
log.RemaimBatteryEnergy_Joule = ResidualEnergy;
log.PID = packt.PID;
this.Logs.Add(log);
}
// for control packet.
if (packt.PacketType == PacketType.Control)
{
// just to remember how much energy is consumed here.
PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule;
}
}
if (Settings.Default.ShowRoutingPaths)
{
OpenChanel(Reciver.ID, packt.PID);
}
}
else if (enCon == EnergyConsumption.Recive)
{
double UsedEnergy_Nanojoule = EnergyModel.Receive(packt.PacketLength);
double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule);
ResidualEnergy = ResidualEnergy - UsedEnergy_joule;
packt.UsedEnergy_Joule += UsedEnergy_joule;
PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule;
if (packt.PacketType == PacketType.Control)
{
// just to remember how much energy is consumed here.
PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule;
}
}
}