Example #1
0
        // remoce a packet reception FSM from queue
        public EZStationPacketFSM removeIncompletePacket()
        {
            EZStationPacketFSM temp = null;

            if (IncompletePacketsNum > 0)
            {
                temp = IncompletePackets[IncompletePacketsNum - 1];
                IncompletePacketsNum--;
            }

            return(temp);
        }
Example #2
0
        // **************** handling the Incomplete Packets Queue **********************
        // insert new packet reception FSM
        public void InsertNewIncompletePacket(EZFrame frame)
        {
            int i;

            // shifting the queue to the right
            for (i = IncompletePacketsNum; i > 0; i--)
            {
                IncompletePackets[i] = IncompletePackets[i - 1];
            }
            // increasing number of Packets
            IncompletePacketsNum++;
            // adding new packet reception FSM
            IncompletePackets[0] = new EZStationPacketFSM(this, frame);
        }
Example #3
0
        // find a Packet Reception FSM using Sender node ID
        public EZStationPacketFSM findIncompletePacket(byte nodeID)
        {
            EZStationPacketFSM thepack = null;
            Boolean            found   = false;
            int i = 0;

            while ((!found) && (i < IncompletePacketsNum))
            {
                if (IncompletePackets[i].PacketSenderID == nodeID)
                {
                    found   = true;
                    thepack = IncompletePackets[i];
                }
                i++;
            }

            return(thepack);
        }
Example #4
0
        // handling internal state according to input and triggering appropriate actions
        public void transitionAction(EZFrame frame)
        {
            switch (state)
            {
            case stIdle:                               // not in process process of receiving or sending
                if (frame.Ftype == t_Ping)
                {                                      // received a ping frame. will acknowledge immediately...
                    sendAcknowledge(frame.SenderID);
                    state = stIdle;                    // state remains idle
                }
                else if (frame.Ftype == t_Acknowledge) // ignoring a random acknowledge
                {
                    state = stIdle;
                }
                else
                {     // any other type of frame
                    // now looking up the incomplete Packets Queue
                    EZStationPacketFSM incompletePack = findIncompletePacket(frame.SenderID);
                    if (incompletePack != null)
                    {
                        incompletePack.transitionAction(frame);
                    }
                    else
                    {    // adding a new incomplete pack
                        InsertNewIncompletePacket(frame);
                    }

                    state = stIdle;     // still idle
                }
                break;

            case stSending:     // in the process of sending a packet. still, handling the incoming

                if (frame.Ftype == t_Ping)
                {                                      // received a ping frame. will acknowledge immediately...
                    sendAcknowledge(frame.SenderID);
                    state = stSending;                 // state remains stSending
                }
                else if (frame.Ftype == t_Acknowledge) // ignoring a random acknowledge
                {
                    state = stSending;                 // keep on sending
                }
                else
                {     // any other type of frame
                    // now looking up the incomplete Packets Queue
                    EZStationPacketFSM incompletePack = findIncompletePacket(frame.SenderID);
                    if (incompletePack != null)
                    {
                        incompletePack.transitionAction(frame);
                    }
                    else
                    {    // adding a new incomplete pack
                        InsertNewIncompletePacket(frame);
                    }

                    state = stSending;     // still Sending
                }

                break;

            case stWaitingAcknowledge:     // expecting a frame reception acknowledgement
                if (frame.Ftype == t_Ping) // casual ping. immediate reply
                {
                    sendAcknowledge(frame.SenderID);
                    // state remains
                    state = stWaitingAcknowledge;
                }
                else if (frame.Ftype == t_Acknowledge)
                {         // received and acknowledge frame
                    if (frame.SenderID == PacketReceiverID)
                    {
                        // increasing number of sent frames
                        FramesSent++;
                        if (FramesSent == TotalFrames)
                        {        // all sent
                            PacketReceiverID = 0;
                            state            = stIdle;
                        }
                        else
                        {         // need to send more frames
                            state = stSending;
                            sendNextFrame();
                        }
                    }
                    else
                    {
                        state = stWaitingAcknowledge;
                    }
                }
                else
                {         // assigning frame to proper Incomplete Packet recipient
                    // any other type of frame
                    // now looking up the incomplete Packets Queue
                    EZStationPacketFSM incompletePack = findIncompletePacket(frame.SenderID);
                    if (incompletePack != null)
                    {
                        incompletePack.transitionAction(frame);
                    }
                    else
                    {        // adding a new incomplete pack
                        InsertNewIncompletePacket(frame);
                    }

                    state = stWaitingAcknowledge;         // still Waiting for acknowledge
                }
                break;
            } // end big state switch
        }