C# - Program komunikacyjny po Usarcie wersja V1.1

Tym razem chciałem przedstawić trochę zmienioną wersję programu komunikacyjnego po porcie COM.

Zmianie  uległ sposób wprowadzania danych oraz zostało dodane rysowanie wykresów dla procesora oraz dla portu COM. Usunąłem też dodatkowe zakładki, będą one dodawane w kolejnych wersjach programu.

Wykres danych od USART-u:

Tutaj w pierwszej kolejności został przygotowany program testowy dla Arduino Uno. Prezentuje się on następująco:

1. int data = 0;
3. void setup()
4. {                
5.   pinMode(13, OUTPUT);    
6.   Serial.begin(115200);
7.   while (!Serial) { ; }
8.   Serial.println("Start_Dat_Proto_Chart");
9. }
11. void loop()
12. {
13.   for(data=0;data<300;data++)
14.   {
15.     Serial.print('[');
16.     Serial.print(data);
17.     Serial.print(';');
18.     Serial.print(data+10);
19.     Serial.print(';');
20.     Serial.print(data+20);
21.     Serial.print(';');
22.     Serial.print(data+30);
23.     Serial.println(']');
24.     delay(1000);
25.   }
26. }

Jego zadaniem jest przesyłanie danych od 0 do 255 co 1 sekundę w odpowiednio przygotowanej ramce. Otwarcie następuje po wysłaniu znaku nawiasu "[", po tym znaku następuje przesłanie pierwszych danych, dalej po przecinku następne porcje danych są dodawane. Odzielenie poszczególnych znaków następuje przy wykorzystaniu znaku ";".

Teraz czas na opisanie programu od strony Visual Studio.

Okno programu prezentuje się następująco:

Tym razem dane wysyłane i odbierane od mikrokontrolera będą wypisywane w oknie tekstowym po lewej stronie. Wykres znajdujący się z prawej strony posłuży do rysowania wykresu, tych samych danych jakie będą wyświetlane w formie tekstowej.

Zasada odbierania danych jest identyczna co w poprzednim poście dotyczącym komunikacji poprzez UART. Różnica polega na wyłuskiwaniu pojedynczych danych z pakietu, i łączenia ich w całość.

Przykładowa ramka danych wygląda następująco:

[dane1,dane2,dane3,dane4]

Pobrane informacje są zamieniane na wartość int, która po zamianie rysuje wykres na ekranie. Maksymalnie można wyrysować jednocześnie cztery wykresy. Ilość danych wybiera się poprzez wykorzystanie checkboxa na dole ekranu. Dane do układu interpretowane są z wartości dziesiętnych wpisanych w kodzie ASCII. Funkcja obsługująca bufor wygląda następująco:

1.         private void Check_Received_dat()
2.         {
3.             byte j=1;
4.             byte i=0;
6.             char[] chars = new char[10];
7.             string datConverted;
9.             char[] chars2 = new char[100];
10.             chars2 = data2.ToCharArray();
12.             richTextBoxTerminal.AppendText(data2);
14.             if (chars2[0] == '[')
15.             {
16.                 i = 0; j = 1;
18.                 while (chars2[j] != ';')
19.                 {
20.                     chars[i] = chars2[j];
21.                     i++;
22.                     j++;
23.                 }
25.                 datConverted = string.Join("", chars);
26.                 int dat = int.Parse(datConverted);
28.                 if (checkBoxSeries1.Checked == true)
29.                 {
30.                     chart1.Series["Series1"].Points.AddY(dat);
31.                 }
33.                 j++;
34.                 i = 0;
35.                 Array.Clear(chars, 0, 10);
36.                
37.                 if(chars2[j] == ']')
38.                 {
39.                     return;
40.                 }
41.                
42.                 //=============================================
44.                 while (chars2[j] != ';')
45.                 {
46.                     chars[i] = chars2[j];
47.                     i++;
48.                     j++;
49.                 }
51.                 datConverted = string.Join("", chars);
52.                 dat = int.Parse(datConverted);
54.                 if (checkBoxSeries2.Checked == true)
55.                 {
56.                     chart1.Series["Series2"].Points.AddY(dat);
57.                 }
59.                 j++;
60.                 i = 0;
61.                 Array.Clear(chars, 0, 10);
63.                 if (chars2[j] == ']')
64.                 {
65.                     return;
66.                 }
68.                 //=============================================
70.                 while (chars2[j] != ';')
71.                 {
72.                     chars[i] = chars2[j];
73.                     i++;
74.                     j++;
75.                 }
77.                 datConverted = string.Join("", chars);
78.                 dat = int.Parse(datConverted);
80.                 if (checkBoxSeries3.Checked == true)
81.                 {
82.                     chart1.Series["Series3"].Points.AddY(dat);
83.                 }
85.                 j++;
86.                 i = 0;
87.                 Array.Clear(chars, 0, 10);
88.                
89.                 if (chars2[j] == ']')
90.                 {
91.                     return;
92.                 }
94.                 //=============================================
96.                 while (chars2[j] != ']')
97.                 {
98.                     chars[i] = chars2[j];
99.                     i++;
100.                     j++;
101.                 }
103.                 datConverted = string.Join("", chars);
104.                 dat = int.Parse(datConverted);
106.                 if (checkBoxSeries4.Checked == true)
107.                 {
108.                     chart1.Series["Series4"].Points.AddY(dat);
109.                 }
110.                 Array.Clear(chars, 0, 10);
111.             }
112.         }

W tej funkcji wypisywane są dane standardowo w oknie, po czym sprawdzany jest format bufora danych. Dalej pobrane dane są dzielone na poszczególne linie wykresu, po czym następuje konwersja na typ int. Kolejnym krokiem jest podanie danych

Wyczyszczenie przycisku następuje po kliknięciu mniejszego przycisku "Wyczyść". Przy zdarzeniu wywoływana jest następująca funkcja.

1.         private void buttonWyczyscSend_Click(object sender, EventArgs e)
2.         {
3.             chart1.Series["Series1"].Points.Clear();
4.             chart1.Series["Series2"].Points.Clear();
5.             chart1.Series["Series3"].Points.Clear();
6.             chart1.Series["Series4"].Points.Clear();
7.         }

Wykres użycia procesora:

Działa on osobno, nie współpracuje z zakładką dotyczącą portu COM. Działa ona osobno:

Cała kontrolka składa się z dwóch przycisków oraz okna z wykresem:

W głównej części programu zdefiniowany jest nowy wątek, wraz z tablicą przechowującą wyniki pomiarów.

1.         private Thread CPU_Use_Thread;
2.         private double[] cpuArray = new double[500];

Do obsługi zdarzenia oraz rysowania tego wykresu wykorzystałem następujące funkcje 

1.         #region CPU_Use_Draw_Chart
2.         //----------------------------------------------------------------------
3.         //Obsługa danych dla wykresu wykorzystania procesora
5.         private void getPerformanceCounters()
6.         {
7.             var cpuperfCounter = new PerformanceCounter("Processor Information", "% Processor Time", "_Total");
9.             while (true)
10.             {
11.                 cpuArray[cpuArray.Length - 1] = Math.Round(cpuperfCounter.NextValue(), 0);
13.                 Array.Copy(cpuArray, 1, cpuArray, 0, cpuArray.Length - 1);
15.                 if (ChartCpu_Use.IsHandleCreated)
16.                 {
17.                     this.Invoke((MethodInvoker)delegate { UpdateCpuChart(); });
18.                 }
19.             }
20.         }
22.         private void UpdateCpuChart()
23.         {
24.             ChartCpu_Use.Series["Series1"].Points.Clear();
26.             for (int i = 0; i < cpuArray.Length - 1; i++)
27.             {
28.                 ChartCpu_Use.Series["Series1"].Points.AddY(cpuArray[i]);
29.             }
30.         }
32.         private void button4_Click(object sender, EventArgs e)
33.         {
34.             CPU_Use_Thread = new Thread(new ThreadStart(this.getPerformanceCounters));
35.             CPU_Use_Thread.IsBackground = true;
36.             CPU_Use_Thread.Start();
37.         }
39.         private void button5_Click(object sender, EventArgs e)
40.         {
41.             CPU_Use_Thread.Abort();
42.         }
43.         //----------------------------------------------------------------------
44.         #endregion

Program zmieniony można pobrać pod tym linkiem.