C# - Klasa obsługująca port szeregowy

W tym poście przedstawię opis klasy obsługującej połączenie szeregowe przez port COM.

[Źródło: https://docs.microsoft.com/en-us/dotnet/]

Opis Funkcji:

Pierwsza funkcja publiczna odpowiada za inicjalizowanie nowego wystąpienia klasy SerialPort.

1. public void pub_comPortInitialization()
2. {
3.     ComPort = new SerialPort();
4. }

Następnie funkcja mająca za zadanie wyszukanie podłączonych portów COM:

1. public string[] pub_getSerialPortName()
2. {
3.     string[] enableComPorts = new string[30];
4.     byte i = 0;
6.     foreach (String s in SerialPort.GetPortNames())
7.     {
8.         enableComPorts[i] = s;
9. 
   

     i++;

10.     }
11.     return enableComPorts;
12. }

Zamknięcie otwartego portu COM:

1. public void pub_comPortClose()
2. {
3.     if (ComPort.IsOpen)
4.     {
5.         ComPort.Close();
6.     }
7. }

Odczytanie długości wiadomości:

1. public int pub_readMsgLength()
2. {
3.     int readBytes = ComPort.BytesToRead;
4.     return readBytes;
5. }

Odczytanie wiadomości o podanej długości:

1. public byte[] pub_receiveData(int readBytes)
2. {
3.     byte[] buffer = new byte[readBytes];        /* New buffer with received data */
4.     ComPort.Read(buffer, 0, readBytes);         /* Read number of bytes */
6.     return buffer;
7. }

Funkcje przesyłająca dane przez otwarty port COM:

1. public bool pub_comPortSendData(byte[] toSend)
2. {
3.     return comPortSendData(toSend);
4. }

1. private bool comPortSendData(byte[] dataToSend)
2. {
3.     try
4.     {
5.         ComPort.Write(dataToSend, 0, dataToSend.Length);
6.     }
7.     catch
8.     {
9.         return false;
10.     }
11.     return true;
12. }

Funkcja publiczna wywołuje funkcje prywatną, która w przypadku błędu podczas przesyłania zwraca wartość false.

W przypadku gdy chcę przesłać część tablicy z danymi wykorzystuje zmodyfikowaną funkcję do której podaje się ilość danych do wysłania:

1. public bool pub_comPortSendData(byte[] toSend, byte dataLength)
2. {
3.     return comPortSendData(toSend, dataLength);
4. }
5. 
   
6. private bool comPortSendData(byte[] dataToSend, byte dataLength)
7. {
8.     try
9.     {
10.         ComPort.Write(dataToSend, 0, dataLength);
11.     }
12.     catch
13.     {
14.         return false;
15.     }
16.     return true;
17. }

Przesłanie ciągu znaków:

1. private bool comPortSendData(string dataToSend)
2. {
3.    char[] charTable = dataToSend.ToCharArray();
5.    try
6.    {
7.         ComPort.Write(charTable, 0, dataToSend.Length);
8.    }
9.    catch
10.    {
11.        return false;
12.    }
13.    return true;
14. }
16. public bool pub_comPortSendData(string toSend)
17. {
18.    return comPortSendData(toSend);
19. }

Wykonanie połączenia z podanymi parametrami:

1. public byte pub_connectSerialPort(string portName, string baudRate, string dataBits,
2.                                   string parity, string stopBits)
3. {
4.     byte status = 0;
6.     status = connectSerialPort(portName, baudRate, dataBits,
7.                        parity, stopBits);
9.     return status;
10. }

1. private byte connectSerialPort()
2. {
3.     if (ComPort.IsOpen)
4.     {
5.         ComPort.Close();
6.         return 2; /* Com port was open, now we close it */
7.     }
8.     else
9.     {
10.         try
11.         {
12.             ComPort.PortName = connectPortName;
13.             ComPort.BaudRate = connectBaudRate;
14.             ComPort.DataBits = connectDataBits;
15.             ComPort.Parity = connectParity;
16.             ComPort.StopBits = connectStopBits;
17.             ComPort.Open();
18.             return 1; /* Ok*/
19.         }
20.         catch
21.         {
22.             return 0; /* Error */
23.         }
24.     }
25. }

Jako argumenty pobieram wartości tekstowe ponieważ wyciągam je bezpośrednio z kontrolek Combo Box w aplikacji.

Można się połączyć poprzez edycję wcześniejszą edycję danych z informacjami o połączeniu, które zostały zdefiniowane w klasie:

1. public static System.IO.Ports.SerialPort ComPort;
2. private string connectPortName = "";
3. private Int32 connectBaudRate = 115200;
4. private byte connectDataBits = 8;
5. private Parity connectParity = Parity.None;
6. private StopBits connectStopBits = StopBits.One;
8. public string ap_connectPortName
9. {
10.     get { return this.connectPortName; }
11.     set { this.connectPortName = value; }
12. }
14. public Int32 ap_connectBaudRate
15. {
16.     get { return this.connectBaudRate; }
17.     set { this.connectBaudRate = value; }
18. }
20. public byte ap_connectDataBits
21. {
22.     get { return this.connectDataBits; }
23.     set { this.connectDataBits = value; }
24. }
26. public Parity ap_connectParity
27. {
28.     get { return this.connectParity; }
29.     set { this.connectParity = value; }
30. }
32. public StopBits ap_connectStopBits
33. {
34.     get { return this.connectStopBits; }
35.     set { this.connectStopBits = value; }
36. }
38. public byte pub_connectSerialPort()
39. {
40.     byte status = 0;
41.     status = connectSerialPort();
42.     return status;
43. }
45. private byte connectSerialPort()
46. {
47.     if (ComPort.IsOpen)
48.     {
49.         ComPort.Close();
50.         return 2; /* Com port was open, now we close it */
51.     }
52.     else
53.     {
54.         try
55.         {
56.             ComPort.PortName = ap_connectPortName;
57.             ComPort.BaudRate = ap_connectBaudRate;
58.             ComPort.DataBits = ap_connectDataBits;
59.             ComPort.Parity = ap_connectParity;
60.             ComPort.StopBits = ap_connectStopBits;
61.             ComPort.Open();
62.             return 1; /* Ok*/
63.          }
64.          catch
65.          {
66.             return 0; /* Error */
67.          }
68.    }
69. }

Cały kod można pobrać z dysku Google pod tym linkiem.