Пример #1
0
        /// <summary>
        /// Sucht die Position des ersten gültigen M3S-Frames in einem übergebenen Buffer
        /// </summary>
        /// <param name="rBuffer">Buffer, der durchsucht werden soll</param>
        /// <returns>Position des ersten gültigen M3S-Frames (-1 wenn nichts gefunden wurde)</returns>
        int GetFirstValidFramePosition(ThreadsafeReceiveBuffer rBuffer, out M3SProtocol oProtocol)
        {
            oProtocol = M3SProtocol.Invalid;

            if (!rBuffer.DataAvailable)                                                                         // Buffer Empty
            {
                return(-1);
            }
            if (rBuffer.DataPtr < protocol.MinimumFrameLength)              // not enough Data available
            {
                return(-1);
            }

            int upperBound = -1;

            for (int start = 0; start <= rBuffer.DataPtr - protocol.MinimumFrameLength; start++)
            {
                if (han.ExtractProtocol(rBuffer.ReadByte(start)) == M3SProtocol.Acknowledge)
                {
                    if (protocol.IsFrame(rBuffer.readBytes(start, start + 4)))
                    {
                        oProtocol = M3SProtocol.Acknowledge;
                        return(start);
                    }
                }


                upperBound = rBuffer.ReadByte(start + protocol.UpperBoundPosition);                    // Ausgelesenes Upperbound aus angenommener Bitposition..
                byte[] frameToTest = rBuffer.readBytes(start, start + upperBound + protocol.Overhead); // Zu testendes Frame

                if (protocol.IsFrame(frameToTest))
                {
                    oProtocol = han.ExtractProtocol(frameToTest[0]);
                    return(start);
                }
            }



            return(-1);
        }
Пример #2
0
        private void recBuffer_ByteReceived(object sender, EventArgs e)
        {
            int err;

            while (recBuffer.DataPtr > protocol.MinimumFrameLength)            // während im Buffer entsprechen dda
            {
                somethingToSend = false;
                bool ackResult = false;
                // immer von vorne her anschaun


                if (state == DevComSlaveState.NotReady)
                {
                    for (int i = 0; i < resetFrame.Length && i < recBuffer.DataPtr; i++)
                    {
                        if (recBuffer.ReadByte(i) != resetFrame[i])               // If it doesnt match frame
                        {
                            recBuffer.FreeBytes(0, i);                            // Remove Bytes incl. faulty byte
                            recBuffer.Flush();
                            break;
                        }

                        if (i == resetFrame.GetUpperBound(0))                        // got here without error => reset gotten
                        {
                            recBuffer.FreeBytes(0, i);
                            recBuffer.Flush();
                            reset();
                        }
                    }
                }
                else
                {
                    for (int bufferIdx = protocol.MinimumFrameLength - 1; bufferIdx < recBuffer.DataPtr; bufferIdx++)
                    {
                        byte[] possFrame = recBuffer.readBytes(0, bufferIdx);

                        if (protocol.IsFrame(possFrame))
                        {
                            // Do something with the frame
                            IM3S_Dataframe frame = protocol.CreateFrameByBytestream(possFrame, out err);

                            if (err != 0)
                            {
                                if (debugmode)
                                {
                                    stdOut.Error("Could not convert Bytestream to valid M3S-Dataframe: " + TBLConvert.BytesToHexString(possFrame));
                                }
                            }
                            else
                            {
                                switch (frame.Protocol)
                                {
                                case M3SProtocol.CommandBroadcast:
                                    if (frame.MulticastAddress == 0 || frame.MulticastAddress == mcAddr)
                                    {
                                        ackResult = processFrame(frame, out err);
                                    }
                                    break;

                                case M3SProtocol.DataTransfer:
                                    if (frame.SlaveAddress == slaveAddr)
                                    {
                                        ackResult = processFrame(frame, out err);
                                    }
                                    break;

                                case M3SProtocol.Command:
                                    if (frame.SlaveAddress == slaveAddr)
                                    {
                                        ackResult = processFrame(frame, out err);
                                    }
                                    break;

                                case M3SProtocol.BroadCast:
                                    if (frame.MulticastAddress == 0 || frame.MulticastAddress == mcAddr)
                                    {
                                        ackResult = processFrame(frame, out err);
                                    }
                                    break;
                                }
                                if (frame.NeedsAcknowledgement && !ackAlreadySent)
                                {
                                    hwInterface.WriteData(protocol.GetAcknowledgeFrame(ackResult, possFrame).GetDataframe());
                                    somethingToSend = true;
                                }
                            }

                            // remove the frame
                            recBuffer.FreeBytes(0, bufferIdx);
                            recBuffer.Flush();
                        }
                    }
                }


                if (!somethingToSend)
                {
                    // Only for TCP clients
                    try
                    {
                        DevComTcpServer serv = hwInterface as DevComTcpServer;                         // if castable, its a server

                        serv.RemainListening();
                    }
                    catch
                    {
                        // do nothing instead
                    }
                }
            }
        }