/// <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; } } }