//********************************************************************* public void SendData(SimulatorPacket pack) { Key _Pk = new Key(pack.PacketBand, pack.PacketChannel, pack.Destination); try { if (pack != null) { if (pack.GetType() == typeof(Connect)) { _ConnectCounter++; if (_ConnectCounter == 36000) { _ConnectCounter = 0; } } else if (pack.GetType() == typeof(ConnectionACK)) { _ConnectAckCounter++; if (_ConnectAckCounter == 36000) { _ConnectAckCounter = 0; } } ArrayList LocalPackets = null; if (_packets.ContainsKey(_Pk)) { LocalPackets = (ArrayList)_packets[_Pk]; if (LocalPackets == null) { LocalPackets = new ArrayList(); } LocalPackets.Add(pack); _packets[_Pk] = LocalPackets; } else { LocalPackets = new ArrayList(); LocalPackets.Add(pack); _packets.Add(_Pk, LocalPackets); } } Thread newThread = new Thread(() => ThreadableSendData(_Pk, pack)); newThread.Start(); } catch (Exception ex) { AddToLog("[SendData] Exception:" + ex.Message); } }
//===================================================================== //[MethodImpl(MethodImplOptions.Synchronized)] /// <summary> /// Function for parse received packet /// </summary> /// <param name="pack">SimulatorPacket</param> public override void ParseReceivedPacket(SimulatorPacket pack) { Type pt = pack.GetType(); if (pt == typeof(Connect)) { ConnectRoutine(pack.Source); } else if (pt == typeof(Disconnect)) { DisonnectRoutine(pack.Source); } else if (pt == typeof(KeepAlive)) { var newThread = new Thread(() => UpdateSTAKeepAliveInfoOnReceive(pack.Source)); newThread.Start(); } else if (pt == typeof(Data)) { DataRoutine((Data)pack); } else if (pt == typeof(DataAck)) { DataAckRoutine((DataAck)pack); } else { OtherPacketsRoutine(pack); } }
//********************************************************************* public void SendData(SimulatorPacket pack) { CheckScanConditionOnSend(); int Rate = pack.getTransmitRate(); int sleep = (int)(600 / Rate); lock (RfSync) { try{ RF_STATUS = RFStatus.Tx; short OperateChannel = this.getOperateChannel(); int try_counter = 0; while (!Medium.Registration(this.Freq, OperateChannel, this.x, this.y, sleep)) { Thread.Sleep(new TimeSpan(randomWait.Next(20, 50))); if (try_counter++ > 200) { return; } } this.MACLastTrnsmitRate = pack.getTransmitRate(); Medium.SendData(pack); } catch (Exception ex) { AddToLog("SendData:[" + this.GetType() + "] " + ex.Message); MessageBox.Show("SendData :" + ex.Message); } RF_STATUS = RFStatus.None; } if (pack.GetType() == typeof(Data)) { _DataSent++; } }
//********************************************************************* public static void SendData(SimulatorPacket pack) { Key _Pk = new Key(pack.PacketFrequency, pack.PacketChannel, pack.Destination); try { Type packet_type = null; if (pack != null) { packet_type = pack.GetType(); if (packet_type == typeof(Connect)) { _ConnectCounter++; if (_ConnectCounter == 36000) { _ConnectCounter = 0; } } else if (packet_type == typeof(ConnectionACK)) { _ConnectAckCounter++; if (_ConnectAckCounter == 36000) { _ConnectAckCounter = 0; } } ArrayList LocalPackets = null; if (_packets.ContainsKey(_Pk)) { LocalPackets = (ArrayList)_packets[_Pk]; if (LocalPackets == null) { LocalPackets = new ArrayList(); } LocalPackets.Add(pack); _packets[_Pk] = LocalPackets; } else { LocalPackets = new ArrayList(); LocalPackets.Add(pack); _packets.Add(_Pk, LocalPackets); } // Thread newThread = new Thread(() => ThreadableSendData(_Pk, pack)); // newThread.Name = "ThreadableSendData "; //newThread.Start(); ThreadPool.QueueUserWorkItem(new WaitCallback((s) => ThreadableSendData(_Pk, pack))); } } catch (Exception ex) { if (DebugLogEnabled) { AddToLog("[SendData] Exception:" + ex.Message); } } }
//===================================================================== /// <summary> /// This function work with all others packets which don't have special Routines /// </summary> /// <param name="pack">Simulator Packet </param> private void OtherPacketsRoutine(SimulatorPacket pack) { // Generic Packet retransmitter // This code will create new packet by him type var instance = (SimulatorPacket)Activator.CreateInstance(pack.GetType(), pack); instance.X = this.x; instance.Y = this.y; instance.Destination = pack.Reciver; SendData(instance); }
//********************************************************************* /* public void SendData(SimulatorPacket PacketToSend) * { * //Random ran = new Random((int)DateTime.Now.Ticks); * SpinWait.SpinUntil(RF_Ready); * SpinWait.SpinUntil(tryToRegister); * lock (RF_STATUS) * { * * // Now scanning process running * if (_scanning) * { * SpinWait.SpinUntil(() => { return (bool)!_scanning; }); * } * RF_STATUS = "TX"; * _MEDIUM.SendData(PacketToSend); * RF_STATUS = "NONE"; * } * * if (PacketToSend.GetType() == typeof(Data)) * { * _DataSent++; * } * }*/ //********************************************************************* public void SendData(SimulatorPacket PacketToSend) { //Random ran = new Random((int)DateTime.Now.Ticks); SpinWait.SpinUntil(RF_Ready); // while(RF_STATUS != "NONE") // Thread.Sleep(ran.Next(1, 3)); RF_STATUS = "TX"; int trys = 0; while (!_MEDIUM.Registration(this.getOperateBand(), this.getOperateChannel(), this.x, this.y)) { RF_STATUS = "NONE"; Thread.Sleep(new TimeSpan(20)); //Thread.Sleep(ran.Next(1, 3)); if (trys > 10) { Thread.Sleep(2); trys = 0; } trys++; SpinWait.SpinUntil(RF_Ready); //while (RF_STATUS != "NONE") // Thread.Sleep(ran.Next(1, 3)); RF_STATUS = "TX"; } // Now scanning process running if (_scanning) { SpinWait.SpinUntil(() => { return((bool)!_scanning); }); } _MEDIUM.SendData(PacketToSend); //Thread.Sleep(1); RF_STATUS = "NONE"; Thread.Sleep(2); if (PacketToSend.GetType() == typeof(Data)) { _DataSent++; } }
//===================================================================== /// <summary> /// Function for Listen And Receive Packets /// </summary> /// <param name="sender">Value for know info about received packets</param> /// <param name="args">Not used - needed by event</param> public void Listen(object sender, EventArgs args) { //while (_Enabled) //{ //SpinWait.SpinUntil(checkIfHaveDataReceive); //SpinWait.SpinUntil(RF_Ready); if (((SimulatorPacket)sender).PacketChannel != this.getOperateChannel()) { return; } if (((SimulatorPacket)sender).PacketFrequency != this.Freq) { return; } double dist = GetSTADist(((SimulatorPacket)sender).X, ((SimulatorPacket)sender).Y, this.x, this.y); if (dist > Medium.ReceiveDistance) { return; } string desinationOfReceivedPacket = ((SimulatorPacket)sender).Destination; if ((this.GetType() == typeof(STA) && desinationOfReceivedPacket.Equals("FF:FF:FF:FF:FF:FF")) || desinationOfReceivedPacket.Equals(this.getMACAddress())) { double t = GetNoiseRSSI(((SimulatorPacket)sender).Source); if (sender.GetType() == typeof(Data)) { if (!MissPacket(t, ((SimulatorPacket)sender).getTransmitRate())) { _badPackets++; return; } } //SpinWait.SpinUntil(ListenCondition);//,1); prev_guid = new Guid(); SimulatorPacket pack = null; lock (RfSync) { RF_STATUS = RFStatus.Rx; pack = Medium.ReceiveData(this); RF_STATUS = RFStatus.None; } if (pack == null) { } else //if (pack != null )//&& (prev_guid != pack.GuidD || pack.IsRetransmit)) { // Only if we have received packet before // but flag Rentransmit is UP if (prev_guid == pack.GuidD) { pack.IsReceivedRetransmit = true; } if (pack.GetType() != typeof(Beacon)) { prev_guid = pack.GuidD; } AllReceivedPackets += 1; //Thread newThread = new Thread(() => ParseReceivedPacket(pack),1); //newThread.Name = "ParseReceivedPacket of " + this.getMACAddress(); //newThread.Start(); ThreadPool.QueueUserWorkItem(new WaitCallback((s) => ParseReceivedPacket(pack))); } } }