CODEWITHSUNDEEP
c#multithreadingeventsserial-port
KansaiRobot
KansaiRobot

Reputation: 9912

Two ways to implement an application invoving serial communication

I am in the process of writing an application, that involves serial communication with a device among other things. (in C#). I have seen some sample code, in concrete two examples.

In the first example, the code is based on a Background control which has a while loop that checks if there is data read from the serial port (another control) and when it does do some processing 

 private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{  serialPort1.Open();
 while (backgroundWorker1.CancellationPending == false)
     {        
       if (serialPort1.BytesToRead >= 240)
        {
         serialPort1.Read(RDATA, 0, 240);
         //Some other process

        }
     }
 serialPort1.Close();
}

The second example is quite different. This involves delegates and events. In this case the serial port (created in code) has an event "DataReceived". To this we add an event handler

ComPort.DataReceived += 
              new System.IO.Ports.SerialDataReceivedEventHandler(port_DataReceived_1);

and then the port_DataReceived_1 function is defined, in which the input data is read 

    private void port_DataReceived_1(object sender, SerialDataReceivedEventArgs e)
 {
   InputData = ComPort.ReadExisting();
   if (InputData != String.Empty)
      {
       this.BeginInvoke(new SetTextCallback(SetText), new object[] { InputData });
       }
 }

private void SetText(string text)
 {
   this.rtbIncoming.Text += text;
  }

Anyway, I can see two different styles of coding serial communication here. On one hand we have a constant polling (through while) that would block the rest of the program if it weren't on another thread. It is done in a different thread though. On the other hand we have interruptions in which the processing is done only when an event happens and not the rest of the time. It is all done on the main thread though.

My question is which of these ways would be preferable. I am imaging that the first method, even if it is on a different thread takes a lot of resources of the computer, maybe even taking the load of the CPU to 100% or something. I am more inclined to do the second one but then again it is all in one thread. Any recommendations, advice on this?

(My application will involve not only serial communication but maybe processing on the data received, perhaps even machine learning)

Upvotes: -1

Views: 610

Answers (1)

Nathan Baulch
Nathan Baulch

Reputation: 20683

You should definitely go with the second option, which is likely handled by an I/O Completion Port thread. If you're writing a WinForms application then you'll need to make sure to check the InvokeRequired flag and perform any UI manipulation on the main thread by passing a delegate to the Invoke method.

Upvotes: 2

Related Questions