In C#, receiving COM port (serial port) messages usually involves usingclass, and process and format conversion of the received byte data. The following is a basic process that describes how to receive and convert COM port messages in C#:
Step 1: Reference namespace
First, make sure your project references the namespace required to handle serial communication:
using ;
Step 2: Set up the SerialPort object
createSerialPortObject and set the configuration parameters of the serial port (such as baud rate, data bit, stop bit, etc.):
SerialPort mySerialPort = new SerialPort("COM1");
= 9600;
= ;
= ;
= 8;
= ;
// Set the read and write timeout = 500;
= 500;
Step 3: Open the serial port
();
Step 4: Receive data
You can useDataReceivedEvents to process the received data. When the serial port receives data, this event will be triggered:
+= new SerialDataReceivedEventHandler(DataReceivedHandler);
Implement event handling functionsDataReceivedHandlerTo read the data and process it:
private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
{
SerialPort sp = (SerialPort)sender;
byte[] buffer = new byte[];
(buffer, 0, );
// TODO: Here you add your data processing and format conversion logic string formattedData = ConvertToDesiredFormat(buffer);
// Process the converted data ProcessData(formattedData);
}
Step 5: Convert the format
Create a functionConvertToDesiredFormatTo convert the received byte data into the format you need. The implementation here depends on your specific needs:
private static string ConvertToDesiredFormat(byte[] data)
{
// Example: Convert byte data to ASCII string return (data);
// Note: If the data is in a specific protocol format, you need to parse and convert the data according to the protocol}
Step 6: Close the serial port
When the data processing is completed, remember to close the serial port to free up resources:
();
Things to note
- Make sure you have the appropriate permissions to access the COM port.
- The above code snippet is a simplified example. In practical applications, you may need to process and verify data according to specific communication protocols (such as calculating checksums, processing data frames, etc.).
- If you may have read and write conflicts or other thread safety issues during communication, consider using locks (e.g.
lockstatement) to synchronously access the serial port resources.
After the configuration is completed, the program can listen to the specified COM port and process and convert the data when it is received. Remember to fully test your code before actually deploying to make sure it can handle the actual communication scenario reliably.
Knowledge Supplement
When you need to program and manipulate hardware, you will encounter such a problem: you receive data sent by the hardware through the serial port, or send commands of a certain format to the hardware through the serial port. On the C# platform, it can be implemented through the SerialPort class under the namespace.
The following is a simple example. First, get the serial port list associated with this machine, then get the COM port configured in the configuration file, check whether it is in the serial port list of the machine. If it is in the list, the serial port object is further instantiated and the serial port object is specified to enable monitoring. The example code is as follows:
using ;
namespace SerialTest
{
public class SerialTest
{
#region Serial Monitoring
private SerialPort serialPort = null;
/// <summary>
/// Turn on serial monitoring /// </summary>
private void StartSerialPortMonitor()
{
List<string> comList = GetComlist(false); //First get the serial port list associated with this machine if ( == 0)
{
("Prompt message", "The current device does not have a serial port!");
(0); //Exit the application completely }
else
{
string targetCOMPort = ["COMPort"].ToString();
//Judge whether the target serial port exists in the serial port list if (!(targetCOMPort))
{
("Prompt message", "The current device does not have a configured serial port!");
(0); //Exit the application completely }
serialPort = new SerialPort();
//Set parameters = ["COMPort"].ToString(); //Communication port = (["BaudRate"].ToString()); //Serial baud rate = 8; // Standard data bit length for each byte = ; //Set the standard number of stop bits per byte = ; //Set parity check protocol = 3000; //Unit milliseconds = 3000; //Unit milliseconds //Serial port control member variable, literally means receiving byte threshold, //The serial port object will trigger the event handling function after receiving data of this length. //It is usually set to 1 = 1;
+= new SerialDataReceivedEventHandler(CommDataReceived); //Set data reception event (listening)
try
{
(); //Open the serial port }
catch (Exception ex)
{
("Prompt message", "Serial port failed to open! Specific reasons:" + );
(0); //Exit the application completely }
}
}
/// <summary>
/// Serial port data processing function /// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void CommDataReceived(Object sender, SerialDataReceivedEventArgs e)
{
try
{
//The byte length to be read is int len = ;
Byte[] readBuffer = new Byte[len];
(readBuffer, 0, len); //Read the data into the cache //Processing data in readBuffer and customizing the processing process string msg = (readBuffer, 0, len); //Get the in-store product number ("Received Information", msg);
}
catch(Exception ex)
{
("Prompt message", "Receive return message exception! Specific reasons:" + );
}
}
/// <summary>
/// Close the serial port /// </summary>
private void Stop()
{
();
}
/// <summary>
/// Get the list of serial ports of the machine /// </summary>
/// <param name="isUseReg"></param>
/// <returns></returns>
private List<string> GetComlist(bool isUseReg)
{
List<string> list = new List<string>();
try
{
if (isUseReg)
{
RegistryKey RootKey = ;
RegistryKey Comkey = (@"HARDWARE\DEVICEMAP\SERIALCOMM");
String[] ComNames = ();
foreach (String ComNamekey in ComNames)
{
string TemS = (ComNamekey).ToString();
(TemS);
}
}
else
{
foreach (string com in ()) //Automatically get the serial port name (com);
}
}
catch
{
("Prompt message", "Serial port check exception!");
(0); //Exit the application completely }
return list;
}
#endregion Serial Monitoring }
}This is the end of this article about the detailed explanation of how C# implements monitoring serial port data. For more related contents of C# monitoring serial port data, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!