Serial Port; Missing Packets after few hours

I am new to Visual C#. I have to receive a packet of 468 bytes every second from a embedded device serially. The header of the packet is 0xbf, 0x13, 0x97, 0x74. After check validating the packet header i am saving this packet , process it, and display it graphically. The problem is that i start losing packets after few hours. (Other software was logging the same data for the whole week and is working well).

The code is here...

private void DataRec(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)    
{
        rtTotBytes = comport.BytesToRead;
        rtTotBytesRead = comport.Read(rtSerBuff, 0, rtTotBytes);
        this.Invoke(new ComportDelegate(ComportDlgtCallback), rtSerBuff, rtTotBytesRead);
}

    //Delegate
    delegate void ComportDelegate(byte[] sBuff, int sByte);

    //Callback Function to Delegate
    private void ComportDlgtCallback(byte[] SerBuff, int TotBytes)
    {
        for (int k = 0; k < TotBytes; k++)
        {
            switch (rtState)
            {
                case 0:
                    if (SerBuff[k] == 0xbf) { rtState = 1; TempBuff[0] = 0xbf; }
                    else rtState = 0;
                    break;
                case 1:
开发者_C百科                    if (SerBuff[k] == 0x13) { rtState = 2; TempBuff[1] = 0x13; }
                    else rtState = 0;
                    break;
                case 2:
                    if (SerBuff[k] == 0x97) { rtState = 3; TempBuff[2] = 0x97; }
                    else rtState = 0;
                    break;
                case 3:
                    if (SerBuff[k] == 0x74) { rtState = 4; TempBuff[3] = 0x74; rtCnt = 4; }
                    else rtState = 0;
                    break;
                case 4:
                    if (rtCnt == 467)
                    {
                        TempBuff[rtCnt] = SerBuff[k];
                        TempBuff.CopyTo(PlotBuff, 0);
                        ProcessPacket(PlotBuff);
                        rtState = 0; rtCnt = 0;
                    }
                    else
                        TempBuff[rtCnt++] = SerBuff[k];
                    break;
            }
        }
    }

Another question: can the BytesToRead be zero if a DataReceivedEvent had occured? Do you have to check (BytesToRead>0) in DataRecievedEvent?

Serial port input data must be treated as a stream, and not series of packets. For example, when device sends 0xbf, 0x13, 0x97, 0x74 packet, DataRec function may be called once with the whole packet, or twice with 0xbf, 0x13 and 0x97, 0x74 packets, or 4 times with one byte, etc. The program must be flexible enough to handle input stream using some parser. Your current program doesn't do this, it can miss logical packets which are received in a several function calls. Another situation is possible, when several packets are received in one DataRec function call - your program is not ready also for such situation.

Edit.

Typical serial port input stream handling algorithm should look like this:

1. DataRec function adds received data to input queue and calls parser.

2. Input queue is some byte array, which contains the data already received, but not parsed yet. New data is added to the end, and parsed packets are removed from the beginning of this queue.

3. Parser reads the input queue, handles all recognized packets and removes them from the queue, leaving all unrecognized data for the next call.

I think a problem could be that you can't be sure that you receive a full package within the DataReceived event. It is possible that you just got the first half of the packet and half a second later the second half.

So you should implement another layer where you put the data into a buffer. The further proceeding depends on the data format.

If you receive additionally informations like an end mark or the length of the data you could check if the buffer already contains these informations. If yes advance this full package to your routine.

If you don't have this information you have to wait till you receive the next header and forward the data within your buffer till this new header.

Have you checked the memory usage of the program? Maybe you have a small interop class, memory or something which is not properly freed, adds up after a few hours and make the program run sluggish, causing it to lose data.

I'd use process explorer to check how memory and cpu use change after a few hours. Maybe check for hdd activity, too.
If this does not lead to results, use a full blown profiler like ANTS and try to run the program under the profiler to check for problems.

As Alex Farber points out, there's no guarantee that when your DataReceived handler is invoked, all the bytes are there.

If your buffers are always a fixed size, and at a low rate, you can use the Read function directly, rather than relying on the DataReceived event. Conceptually:

packetSize = 468;    
...initialization...
comport.ReadTimeout = 2000; //packets expected every 1000 milliseconds, so give it some slack

while (captureFlag) {
    comport.Read(rtSerBuff, 0, packetSize);
    ...do stuff...
}

This can be put into its own worker thread if you want.

Another approach would be to use the ReadLine method. You mention that the packets have a known starting signature. Do they also have a known ending signature that is guaranteed to not be repeated in the packet? If so, you can set the NewLine property to this ending signature and use ReadLine. Again, you can put this in a worker thread,