[33.2] STM32F4 - ENC28J60 - Przysyłanie danych z serwera UDP do klienta

W tym poście chciałbym przedstawić projekt układu wysyłającego dane z serwera UDP do klienta. Przesyłane będą informacje o z dwóch czujników DS18B20, dwóch przetworników analogowo cyfrowych.

[Źródło: http://www.st.com/en/evaluation-tools/stm32f4discovery.html]

Ten projekt jest kontynuacją wcześniejszego posta odnośnie serwera UDP. Dane od układu do klienta będą wysyłane po odebraniu zapytania od aplikacji. Będzie ona cyklicznie przesyłała zapytania do serwera. Po wysłaniu odbierze ona potrzebne dane które przedstawi na wykresie oraz w tabeli. Dane przyporządkowane będą do czasu systemowego komputera.

Cube Mx:

Na samym początku dorzucę kilka rzeczy do STM'a w programie CubeMx.

Pierwszą rzeczą jest przetwornik ADC. Wybrałem dwa wolne czyli ADC1 IN1 podłączone do PA1 oraz ADC2 IN0 pod pinem PA0.

Następnym elementem są czujniki temperatury. Tutaj wystarczy uruchomić jeden pin jako wyjście.

Program STM:

Wykorzystam program przedstawiony we wcześniejszym poście. Do niego zostanie dodana obsługa termometrów oraz kanałów ADC. Po otrzymaniu odpowiedniej komendy od klienta dane zostaną przesłane w następującej formie:

ST:T1:<temperatura>;T2:<temperatura>;ADC1:<wartość z ADC>;ADC2:<wartość z ADC>;<Obliczone CRC>;

Obliczanie CRC odbywa się z całej ramki danych. Jest ona przekazywana do funkcji, która zwraca obliczoną wartość na jednym bajcie:

1. static uint8_t crcCalculate(uint8_t const message[], int nBytes)
2. {
3.     uint8_t i = 0;
4.     uint8_t j = 0;
5.     uint8_t crc = 0;
7.       for (i = 0; i < nBytes; i++)
8.       {
9.         crc ^= message[i];
10.         for (j = 0; j < 8; j++)
11.         {
12.           if ((crc & 1)>0)
13.           {
14.             crc ^= 0xA5;
15.           }
16.           crc >>= 1;
17.         }
18.       }
19.       return crc;
20. }

W moim przypadku przesyłane będą jedynie dane z czujników, dlatego nie będę kodował ramki danych. Jeśli chciało by się zaimplementować np. sterowanie przekaźnikami czy zmianę parametrów urządzenia bądź przesyłane dane nie mogły by być odczytywane przez osoby postronne, to należy ramkę danych zakodować. Z prostszych metod mogło by to być np. XOR z odpowiednim kluczem, czy Szyfr Cezara.

Przygotowanie ramki danych:

1. static void udpReplayCheckFrame(enc28j60_frame_t *frame, uint16_t length, char *arrayReceive)
2. {
3.     extern uint16_t ADC_Val[2];
4.     extern float glob_tempDataDs[2];
5.     extern char glob_tempSign[2];
6.     uint8_t calculateCrc = 0;
8.     uint16_t port=0;
9.     char buffer[60];
10.     char bufferToSend[70];
12.     ip_frame_t *ip_frame = (void*)(frame->dataBuffer);
13.     udp_frame_t *udp_frame = (void*)(ip_frame->dataBuffer);
15.     /* check receive frame */
16.     if(strcmp(arrayReceive, "SendData\r\n") != 0)
17.     {
18.         /* Error different strings */
19.         free(ip_frame);
20.         free(udp_frame);
22.         return;
23.     }
25.     /* If frame ok then prepare frame to send */
26.     port = udp_frame->destiPort;
27.     udp_frame->destiPort = udp_frame->sourcePort;
28.     udp_frame->sourcePort = port;
29.     udp_frame->packLength = 0;
31.     /* prepase buffer */
32.     sprintf(buffer,"ST:T1:%c%.2f;T2:%c%.2f;ADC1:%u;ADC2:%u",        glob_tempSign[0],
33.                                                                     glob_tempDataDs[0],
34.                                                                     glob_tempSign[1],
35.                                                                     glob_tempDataDs[1],
36.                                                                     ADC_Val[0],
37.                                                                     ADC_Val[1]);
39.     /* calculate CRC */
40.     calculateCrc = crcCalculate((uint8_t*)buffer, strlen(buffer));
42.     sprintf(bufferToSend,"%s;%u;\r\n", buffer, calculateCrc);
44.     strcpy((char*)udp_frame->dataBuffer,bufferToSend);
45.     length = strlen((char*)udp_frame->dataBuffer) + sizeof(udp_frame_t);
47. #ifdef DEBUG_UDP_FIL
48.     sprintf(buffer,"Calculate CRC: %u\r\n", calculateCrc);
49.     HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen(buffer),0x1000);
50. #endif
52.     udp_frame->packLength = CONVERT_16BIT(length);
53.     udp_frame->contSum=0;
54.     udp_frame->contSum=checksum((uint8_t*)udp_frame-8, length+8, Prot_UPD);
56.     ipSendData(frame, length+sizeof(ip_frame_t));
58.     free(ip_frame);
59.     free(udp_frame);
61. #ifdef DEBUG_UDP_FIL
62.     HAL_UART_Transmit(&huart2,(uint8_t*)"\r\nDATASEND\r\n",12,0x1000);
63. #endif
64. }

Ramka danych przygotowywana jest w funkcji odbierającej dane. Tam następuje podjęcie decyzji o przesyłaniu danych. Przygotowanie ramki sprawdzenie odpowiedzi itp. wykonywane jest w jednej funkcji. Program odpowiada na przesłanie komendy SendData\r\n. Inne przesłane komendy będą ignorowane.

Obliczenia dla DS18B20 jak i dla ADC wykonywane są ciągiem w pętli głównej. Gdzie przekazywane są do zmiennych globalnych a z nich podawane do funkcji przesyłających dane.

Konwersja dla dwóch kanałów ADC:

1. uint16_t ADC_Val[2] = { 0 };
3. void adcConversionADC1()
4. {
6.     float vsense;
7.     char buffer[50];
8.     const float V25 = 0.76;
9.     const float SupplyVoltage = 3.0;
10.     const float ADCResolution = 4095.0;
12.     HAL_ADC_Start(&hadc1);
14.     if (HAL_ADC_PollForConversion(&hadc1, 20) == HAL_OK)
15.     {
16.         ADC_Val[0] = HAL_ADC_GetValue(&hadc1);
17.         vsense = (SupplyVoltage*ADC_Val[0])/ADCResolution;// Przeliczenie wartosci zmierzonej na napiecie
19.         sprintf((char*)buffer,"ADC Value0: %u; Vsense: %f\r\n", ADC_Val[0], vsense);
20.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
21.     }
22. }
24. void adcConversionADC2()
25. {
26.     float temp;
27.     float vsense;
28.     char buffer[50];
29.     const float V25 = 0.76;
30.     const float SupplyVoltage = 3.0;
31.     const float ADCResolution = 4095.0;
33.     HAL_ADC_Start(&hadc2);
35.     if (HAL_ADC_PollForConversion(&hadc2, 20) == HAL_OK)
36.     {
37.         ADC_Val[1] = HAL_ADC_GetValue(&hadc2);
38.         vsense = (SupplyVoltage*ADC_Val[1])/ADCResolution;// Przeliczenie wartosci zmierzonej na napiecie
39.         temp = ((vsense-V25)/SupplyVoltage)+25;// Obliczenie temperatury
41.         sprintf((char*)buffer,"ADC Value2: %u; Vsense: %f\r\n", ADC_Val[1], vsense);
42.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
43.     }
44. }

Pobranie temperatury z dwóch kanałów:

1. float glob_tempDataDs[2] = {0.0};
2. char glob_tempSign[2];
4. void ds18b20ReadTempFromDev(void)
5. {
6.     uint8_t buffer[60];
7.     uint8_t i;
8.     uint8_t device[DS18B20_CONNECTED_DEV];
9.     uint16_t readDataRaw;
10.     float tempValue;
11.     char sign;
13.     for(i=1;i<=ds18b20_data.Dev_Cnt;i++)
14.     {
15.         ds18b20DevConTemp(NO_SKIP_ROM, i);
16.     }
18.     for(i=1;i<=ds18b20_data.Dev_Cnt;i++)
19.     {
20.         ds18b20ReadScratchpad(NO_SKIP_ROM, device, i);
22.         sprintf((char*)buffer,"READ SCTARCHPAD %d: %02X %02X %02X %02X %02X %02X %02X %02X; ",
23.                 i, device[0], device[1], device[2], device[3], device[4], device[5], device[6], device[7]);
25.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
26.         readDataRaw = ((uint16_t)device[1]<<8)|device[0];
28.         if(ds18b20ReadSign(readDataRaw))    {   sign='-';   }
29.         else                                {   sign='+';   }
31.         tempValue = ds18b20GetTemp(readDataRaw);
33.         /* Write temperature value into global value, to get it quick from it */
35.         if(i == 1)
36.         {
37.             glob_tempDataDs[0] = tempValue;
38.             glob_tempSign[0] = sign;
39.         }
40.         else if(i == 2)
41.         {
42.             glob_tempDataDs[1] = tempValue;
43.             glob_tempSign[1] = sign;
44.         }
45.         sprintf((char*)buffer,"RegVal: 0x%04X - %c%.2f\r\n", readDataRaw, sign, tempValue);
46.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
48.     }
49. }

Główna funkcja programu wygląda następująco:

1. int main(void)
2. {
3.   /* USER CODE BEGIN 1 */
4.   /* USER CODE END 1 */
6.   /* MCU Configuration----------------------------------------------------------*/
8.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
9.   HAL_Init();
11.   /* USER CODE BEGIN Init */
13.   /* USER CODE END Init */
15.   /* Configure the system clock */
16.   SystemClock_Config();
18.   /* USER CODE BEGIN SysInit */
20.   /* USER CODE END SysInit */
22.   /* Initialize all configured peripherals */
23.   MX_GPIO_Init();
24.   MX_SPI1_Init();
25.   MX_USART2_UART_Init();
26.   MX_TIM2_Init();
27.   MX_ADC1_Init();
28.   MX_ADC2_Init();
30.   /* USER CODE BEGIN 2 */
31.   netInitialize();
32.   ds18b20InitReadData();
33.   HAL_TIM_Base_Start_IT(&htim2);
35.   HAL_ADC_MspInit(&hadc1);
36.   HAL_ADC_MspInit(&hadc2);
37.   /* USER CODE END 2 */
39.   /* Infinite loop */
40.   /* USER CODE BEGIN WHILE */
41.   while (1)
42.   {
43.   /* USER CODE END WHILE */
45.   /* USER CODE BEGIN 3 */
46.       ds18b20ReadTempFromDev();
47.       HAL_Delay(500);
48.       ds18b20AlarmSearch();
49.       HAL_Delay(250);
51.       adcConversionADC1();
52.       HAL_Delay(10);
53.       adcConversionADC2();
54.   }
55.   /* USER CODE END 3 */
57. }

Program w C#:

Poniżej przedstawię szybki program w C#, którego zadaniem będzie działanie jako klient UDP i przesyłanie zapytań o dane do serwera. Po przesłaniu zapytania dane zostaną odebrane i zapisane w pliku tekstowym, wyświetlone w tabeli oraz przedstawione na wykresie.

Okno główne aplikacji prezentuje się następująco:

Tutaj wysyłanie jak i odbieranie danych odbywa się w tle. Dane co 1 sekundę są przesyłane po ich wysłaniu następuje oczekiwanie na otrzymanie odpowiedzi.

W oknie programu znajdują się dwa pola tekstowe do wprowadzania danych odnośnie IP oraz portu. Przycisk Get Data przesyła dane do STM'a po czym czeka na odbiór. Przycisk Stop przerywa wysyłanie żądania do płytki. W polu listBox wyświetlane są odebrane dane. Poniżej znajdują się dwa wykresy na górnym przedstawiona jest temperatura a na dolnym wartości z ADC.

Odebrana ramka danych przed wyświetleniem sprawdza CRC, jeśli jest ono błędne to ramka zostaje odrzucona.

Cały projekt z programem dla STM'a jak i dla C# można pobrać z dysku google pod tym linkiem.