CODEWITHSUNDEEP
c#serial-port
Stephen Itschner
Stephen Itschner

Reputation: 13

Multiple SerialPort returns in real-time

I have made a data logging application in C#. It connects to 4 USB sensors with the SerialPort class. I have the data received event threshold triggered on every byte. When data is received, the program checks to see if that byte is the end of the line. If it isn't, the input is added to a buffer. If it is a line end, the program adds a timestamp and writes the data and timestamp to a file (each input source gets a dedicated file).

Issues arise when using more than one COM port inputs. What I see in the output files is:

Any of the 4 Files:

...
timestamp1 value1
timestamp2 value2
timestamp3 value3
value4
value5
value6
timestamp7 value7
...

So, what it looks like is the computer isn't fast enough to get to all 4 interrupts before the next values arrive. I have good reason to believe that this is the culprit because sometimes I'll see output like this:

...
timestamp value
timestamp value
value
val
timestamp ue
timestamp value
...

It might be due to the fact that I changed the processor affinity to run only on Core 2. I did this because the timestamps I'm using are counted with processor cycles, so I can't have multiple time references depending on which core is running. I've put some of the code snippets below; any suggestions that might help with the dropped timestamps would be greatly appreciated!

    public mainLoggerIO()
    {
        //bind to one cpu
        Process proc = Process.GetCurrentProcess();
        long AffinityMask = (long)proc.ProcessorAffinity;
        AffinityMask &= 0x0002; //use only the 2nd processor
        proc.ProcessorAffinity = (IntPtr)AffinityMask;

        //prevent any other threads from using core 2
        Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
        Thread.CurrentThread.Priority = ThreadPriority.Highest;

        long frequency = Stopwatch.Frequency;
        Console.WriteLine("  Timer frequency in ticks per second = {0}",
            frequency);
        long nanosecPerTick = (1000L * 1000L * 1000L) / frequency;
        Console.WriteLine("  Timer is accurate within {0} nanoseconds",
            nanosecPerTick);

        if (Stopwatch.IsHighResolution)
            MessageBox.Show("High Resolution Timer Available");
        else
            MessageBox.Show("No High Resolution Timer Available on this Machine");

        InitializeComponent();
    }

And so on. Each data return interrupt looks like this: 

    private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
    {
        //serialPort1.DataReceived = serialPort1_DataReceived;
        rawPort1Data = "";
        rawPort1Data = serialPort1.ReadExisting();
        this.Invoke((MethodInvoker)delegate { returnTextPort1(); });
    }

The method returnTextPort#() is:

    private void returnTextPort1()
    {
        if (string.Compare(saveFileName, "") == 0)//no savefile specified
            return;
        bufferedString += rawPort1Data;
        if(bufferedString.Contains('\r')){
            long timeStamp = DateTime.Now.Ticks;
            textBox2.AppendText(nicknames[0] + " " + timeStamp / 10000 + ", " + rawPort1Data);
            //write to file
            using (System.IO.StreamWriter file = new System.IO.StreamWriter(@saveFileName, true))
            {
                 file.WriteLine(nicknames[0] + " " + timeStamp / 10000 + ", " + rawPort1Data);//in Ms
            }
            bufferedString = "";
        }

    }

Upvotes: 1

Views: 1369

Answers (1)

Ian Mercer
Ian Mercer

Reputation: 39277

A cleaner approach would be to use a ConcurrentQueue<T> between the data received event handler and a separate Thread that will deal with the resulting data. That way the event handler can return immediately AND instead of modifying rawPort1 data in a totally non-thread-safe manner you could move to a thread-safe solution.

Create a Thread that reads from the concurrent queue, writes to the file and Invokes the UI changes. Note that writing to the file should NOT be on the UI thread.

Your ConcurrentQueue<T> can capture in the class T that you will implement: the port number, the data received and the timestamp at which it was received.

Note also that DateTime.Now is rarely ever the right answer, for most locations it jumps by an hour twice every year when daylight savings time starts or ends, instead of DateTime.UtcNow. Note however that neither has the accuracy you seem to be trying to obtain with your StopWatch code.

You should not need to manipulate processes or thread priorities to do this: the serial port has a buffer, you'll not miss data provided you handle it efficiently.

Upvotes: 1

Related Questions