[8.3] STM32F7 - UDP Serwer

W tym przedstawię sposób konfiguracji STM32F7 oraz bibliotek LWIP tak aby uzyskać serwer UDP.

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

UDP:

UDP czyli User Datagram Protocol. Jest on stosowany w warstwie transportowej. Jako protokół bezpołączeniowy nie nawiązuje on połączenia ani nie śledzi sesji jak w przypadku TCP. Za to ruch generowany w sieci jest znacznie mniejszy niż w TCP. Dzięki temu, że proces transmisji niepotrzebnych danych jest zminimalizowany, osiąga się dużo szybsze prędkości niż w TCP. 

W związku z tym że usługa nie gwarantuje poprawności danych należałoby zastosować jakieś mechanizmy zapobiegania błędom. Tutaj z pomocą może przyjść odpowiednio zdefiniowany sposób komunikacji tzn. określone ramki wiadomości. Dodatkowo dobrym pomysłem jest zastosowanie CRC.

Program:

Podobnie jak w części dotyczącej Http należy do projektu dołączyć bibliotekę LWIP oraz ją uruchomić wraz z całą warstwą sprzętową oraz programową.

Poniżej funkcja odpowiedzialna za ustawienie podstawowej konfiguracji:

1. uint8_t serverUDPInit(void)
2. {
3.   /* Set operation status for default */
4.   uint8_t status = 0;
6.   /* check if server isn't initialized yet */
7.   if(UDP_CONN_INF.status == UDP_ST_NOINIT)
8.   {
9.     /* Set link status */
10.     EthLinkStatus = 0;
12.     /* Enable Ethernet and LWIP Stack */
13.     MX_LWIP_Init();
15.     /* Init NVIC */
16.     HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
17.     HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
19.     /* Set notification for user */
20.     udpUserNotification(&gnetif);
22.     /* Set status for initialization */
23.     UDP_CONN_INF.status = UDP_ST_NOCONNECT;
24.   }
25.   else if(UDP_CONN_INF.status == UDP_ST_NOCONNECT)
26.   {
27.       /* udp connection already initialized */
28.       status = 1;
29.   }
31.   return status;
32. }

Pierwsza z przedstawionych funkcji ma za zadanie przygotowanie połączenia. Oznacza to uruchomienie biblioteki LWIP, ustawienie przerwań, wywołanie informacji dla użytkownika oraz zmianę informacji o wykonanym połączeniu.

Ustanowienie połączenia:

1. UDP_SERVER_CONNECT_t serverUDPStart(void)
2. {
3.   UDP_SERVER_CONNECT_t status = UDP_SER_CON_STA_ERROR_2;
4.   err_t err;
6.   if(UDP_CONN_INF.status == UDP_ST_NOINIT)
7.   {
8.       return UDP_SER_CON_STA_INIT_ERR;
9.   }
11.   if(UDP_CONN_INF.status == UDP_ST_RUNNING)
12.   {
13.       return UDP_SER_CON_STA_RUNNING;
14.   }
15.   if(EthLinkStatus > 0)
16.   {
17.       return UDP_SER_CON_STA_NO_LINK;
18.   }
20.   /* Create new UDP pcb */
21.   upcb_server = udp_new();
23.   /* return pointer */
24.   if (upcb_server == NULL)
25.   {
26.       return UDP_SER_CON_STA_ERROR_1;
27.   }
29. #ifdef HOST_IP_0
30.   IP4_ADDR(&HostIPaddr, HOST_IP_0, HOST_IP_1, HOST_IP_2, HOST_IP_3 );
31. #endif
33.   IP4_ADDR(&OwnIPaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3 );
35.   /* Bind PCB to local IP address and port*/
36.   err = udp_bind(upcb_server, &OwnIPaddr, SERVER_UDP_PORT);
38.   if (err != ERR_OK)
39.   {
40.       return UDP_SER_CON_STA_ERROR_2;
41.   }
43.   /* Set callback for incoming UDP data */
44.   udp_recv(upcb_server, udpReceiveCallback, NULL);
46.   /* change status */
47.   status = UDP_SER_CON_STA_CONNECT_OK;
48.   UDP_CONN_INF.status = UDP_ST_RUNNING;
50.   return status;
51. }

Ta funkcja odpowiada za rozpoczęcie połączenia po UDP. Najpierw sprawdzany jest status. Jeśli połączenie nie zostało jeszcze wykonane to zostanie stworzony nowy obiekt pcb UDP, zawierający informacje o połączeniu. Następnie sprawdzana jest poprawność utworzonych danych. Gdy jest wporządku to następuje wpisanie adresów IP do dwóch struktur. Jedna przechowuje informacje z danymi dla klienta (czyli np. PC) a druga informacje o serwerze (czyli STM). Dalej przypisany jest adres IP oraz Port do struktury upcb_server. Funkcja udp_recv przypisuje funkcje udpReceiveCallback do odbierania danych od UDP w obsłudze zdarzenia.

Rozłączenie serwera:

1. void serverUDPDisconnect(void)
2. {
3.   if(UDP_CONN_INF.status==UDP_ST_RUNNING)
4.   {
5.     udp_remove(upcb_server);
6.     UDP_CONN_INF.status=UDP_ST_NOCONNECT;
7.   }
8. }

W tym przypadku sprawa jest prosta jeśli serwer jest połączony to następuje jego rozłączenie przez usunięcie struktury z informacją o połączeniu. Dzięki temu można dynamicznie wykorzystywać kilku klientów.

Wysłanie wiadomości:

1. uint8_t serverUDPSendString(uint8_t *ptr)
2. {
3.   uint8_t status = ERROR;
4.   struct pbuf *p;
5.   err_t err;
7.   /* if server is enable */
8.   if(UDP_CONN_INF.status == UDP_ST_RUNNING)
9.   {
10.     /* allocate buffer */
11.     p = pbuf_alloc(PBUF_TRANSPORT, strlen((uint8_t*)ptr), PBUF_POOL);
13.     /* if buffer is allocated */
14.     if (p == NULL)
15.     {
16.         status = 0;
17.         return status;
18.     }
20.     /* copy data */
21.     pbuf_take(p, (char*)ptr, strlen((char*)ptr));
23.     /* Send data to a specified address using UDP */
24.     err = udp_sendto(upcb_server, p, &HostIPaddr, CLIENT_USP_PORT);
26.     /* clear sending buffer */
27.     for(uint8_t loop = 0; loop < UDP_RECEIVE_MSG_SIZE; loop++)
28.     {
29.         UDP_CONN_INF.recBufer[loop] = 0;
30.     }
32.     /* free buffer */
33.     pbuf_free(p);
35.     if(err == ERR_OK)
36.     {
37.       status = SUCCESS;
38.     }
39.     else
40.     {
41.       /* remove a UDP pcb */
42.       udp_remove(upcb_server);
43.       UDP_CONN_INF.status=UDP_ST_NOCONNECT;
44.     }
45.   }
47.   return status;
48. }

Najpierw przeprowadzane są operacje na buforze.  Po ich wykonaniu wysyłany jest podany bufor za pomocą funkcji udp_sendto.

Sprawdzanie odpowiedzi od serwera:

1. UDP_RECEIVE_t serverUDPWorks(uint8_t *ptr)
2. {
3.   UDP_RECEIVE_t status = UDP_REVEICE_BUF_EMPTY;
4.   uint32_t i;
5.   uint8_t value;
7.   if(UDP_CONN_INF.status != UDP_ST_NOINIT)
8.   {
9.       /* Use when packet is ready to read from the interface */
10.       ethernetif_input(&gnetif);
12.       /* Handle timeout */
13.       sys_check_timeouts();
15.     /* check linki status */
16.     if(EthLinkStatus > 0)
17.     {
18.       if(UDP_CONN_INF.status == UDP_ST_RUNNING)
19.       {
20.           /* remove a UDP pcb */
21.           udp_remove(upcb_server);
22.           UDP_CONN_INF.status = UDP_ST_NOCONNECT;
23.       }
24.     }
25.   }
27.   if(UDP_CONN_INF.status != UDP_ST_RUNNING)
28.   {
29.       return UDP_SERVER_BUF_OFFLINE;
30.   }
32.   if(UDP_CONN_INF.recLength > 0)
33.   {
34.       status = UDP_RECEIVE_BUF_READY;
36.       /* copy buffer */
37.       i=0;
38.       value = UDP_CONN_INF.recBufer[i];
40.       while((value != 0) && (i < UDP_RECEIVE_MSG_SIZE-1))
41.       {
42.           value=UDP_CONN_INF.recBufer[i];
43.           ptr[i]=value;
44.           i++;
45.       }
47.       /* clear last character */
48.       ptr[i]=0x00;
50.       UDP_CONN_INF.recLength=0;
51.   }
53.   return status;
54. }

Ta funkcja wywoływana jest w pętli. Sprawdza ona czy zostały odebrane jakieś dane. Dodatkowo obsługuje time outy od usługi sieciowej.

Dane do serwera przychodzą w przerwaniu.Jego obsługa wygląda następująco:

1. static void udpReceiveCallback(void *arg, struct udp_pcb *upcb, struct pbuf *p, struct ip_addr *addr, u16_t port)
2. {
3.   uint16_t i;
4.   uint8_t value;
5.   uint8_t *ptr;
7.   ptr=(uint8_t*)p->payload;
9.   i=0;
11.   do
12.   {
13.     value = *ptr;
14.     UDP_CONN_INF.recBufer[i] = value;
15.     ptr++;
16.     i++;
17.   }while((value != 0) && (i < UDP_RECEIVE_MSG_SIZE-1));
19.   UDP_CONN_INF.recBufer[i]=0x00;
20.   UDP_CONN_INF.recLength = i;
22.   pbuf_free(p);
23. }

W tej funkcji dane kopiowane są z bufora z danymi odebranymi do bufora głównego.

Aby określić maksymalną wielkość znaków obsługiwanych przez lwip dla transmisji należy zmienić parametry w pliku pbuf.h:

1. /** Currently, the pbuf_custom code is only needed for one specific configuration
2.  * of IP_FRAG */
3. #define LWIP_SUPPORT_CUSTOM_PBUF (IP_FRAG && !IP_FRAG_USES_STATIC_BUF && !LWIP_NETIF_TX_SINGLE_PBUF)
5. #define PBUF_TRANSPORT_HLEN 150
6. #define PBUF_IP_HLEN        150

To ustawienie pozwala na przygotowanie odpowiedniej ilości miejsca na przychodzącą ramkę. W przypadku przesłania za dużej ramki, dane będą zapisywane poza zakresem.

Pętla główna odbierająca dane z przesyłająca je ponownie po UDP oraz po UARCie wygląda następująco

1.   uint8_t           buffer[UDP_RECEIVE_MSG_SIZE] = {0};
2.   UDP_RECEIVE_t     rx_check = UDP_REVEICE_BUF_EMPTY;
3.   uint32_t          aliveNotify = 0;
4.   /* ...
5.      ...
6.      ...
7.   */
8.   EnableUartUsart();
9.   Usart_Uart_SendString(USART1,"Enable USART", LF_CR);
10.   //------------------------------
11.   /* Enable UDP  */
12.   serverUDPInit();
13.   serverUDPStart();
14.   Usart_Uart_SendString(USART1,"Server Connect", LF_CR);
15.   /* USER CODE END 2 */
17.   /* Infinite loop */
18.   /* USER CODE BEGIN WHILE */
19.   while (1)
20.   {
21.   /* USER CODE END WHILE */
22.   /* USER CODE BEGIN 3 */
23.       for(uint8_t i=0; i<UDP_RECEIVE_MSG_SIZE; i++)
24.       {
25.           buffer[i] = 0;
26.       }
28.       rx_check = serverUDPWorks(buffer);
30.       if(rx_check == UDP_RECEIVE_BUF_READY)
31.       {
32.           serverUDPSendString(buffer);
33.           Usart_Uart_SendString(USART1, (uint8_t *)buffer, LF_CR);
34.           aliveNotify=0;
35.       }
37.       if(aliveNotify>1000000)
38.       {
39.           aliveNotify=0;
41.           /* send default msg */
42.           serverUDPSendString("UDP_alive_notify\r\n");
43.           Usart_Uart_SendString(USART1, "UDP_alive_notify\r\n", LF_CR);
44.       }
45.       else
46.       {
47.           aliveNotify++;
48.       }
49.   }

Bibliotekę można pobrać pod tym linkiem. W folderze STM32 a następnie STM32F7.