[8,0] STM32F7 - LWIP, FreeRtos, Echo Serwer

W tym poście chciałbym przedstawić sposób konfiguracji oraz połączenia mikrokontrolera STM32F7 w konfiguracji echo serwer z komputerem.

Biblioteka LWIP (ang. lightweight IP)[1]:

Jest to biblioteka dzięki krórej w dosyć łatwy sposób można wykonać różne sposoby komunikacji sieciowej. Zawarto w niej protokoły IP, TCP, UDP, ICMP, ARP. W jej skład dodatkowo wchodzą takie moduły jak DHCP, DNS, AutoIP, SNMP, IGMP, SLIP, PPO. 

Jeśli chodzi o jej zaprogramowanie to do dyspozycji są trzy sposoby. Pierwszy z nich jest to interfejs surowy bez systemu operacyjnego, czyli podstawowy interfejs biblioteki. Drugi dotyczy jest to tzw interfejs sekwencyjny, który jest obsługiwane w trybie otwórz - czytaj - pisz - zamknij. Powoduje on, że wywołania tego systemu są blokujące, wobec czego musi on działać w wątkach. Dlatego często wykorzystuje się system operacyjny tzn. FreeRtos. Te dwa sposoby są właściwie najczęściej spotykane. Trzeci i ostatni z nich dotyczy interfejsu gniazd, czyli obudowywany jest interfejs sekwencyjny, który ma być zgodny z interfejsem gniazd stosownym w normalnych komputerach.

Z biblioteką LWIP oraz FreeRtos można przygotować takie programy jak np. serwer Web oparty na netconn API, serwer Web oparty na soketach, czy aplikacje TCP,UDP.

Tworzenie projektu CubeMx:

Generowanie projektu jest bardzo proste. Całość należy rozpocząć standardowo od nowego projektu gdzie wybieram płytkę discovery F7 z układem STM32F746NGHx. Następnie czyszczę przypisane piny do układu, tak aby uzyskać czysty mikrokontroler. 

Pierwszym elementem do włączenia jest RCC z kwarcem zewnętrznym:

W związku z tym, że ten projekt będzie wykorzystywał FreeRtos to należy zmienić timer ,odpowiedzialny podstawę czasu, z Systicka na jakikolwiek inny.

Teraz kolej na konfigurację Ethernetu z ustawieniami RMII (ang. reduced media-independent interface).

Kolejnym krokiem jest włączenie FreeRtos oraz LWIP:

Następnym etapem jest konfiguracja zegara:

No i na samym końcu zostało skonfigurowanie bibliotek LWIP oraz konfiguracja ETH. FreeRtos'a nie konfiguruje ponieważ potrzebne będzie tylko DefaultTask, w związku z czym nie ma potrzeby aby dodawać więcej. 

Dla Lwip należy wprowadzić IP, maskę oraz bramę domyślną.

Po tych operacjach można już wygenerować kod, trzeba jeszcze zwiększyć pamięć stosu oraz sterty dla systemu operacyjnego:

Kod Programu:

Teraz przejdę do obsługi programu.

Biblioteka wygenerowała wątek tzw. DefaultTaks. W nim będą realizowane wszystkie inicjalizacje.

1.   //Biblioteki do dołączenia
2.   /* USER CODE BEGIN Includes */
3.   #include "lwip/opt.h"
4.   #include "lwip/arch.h"
5.   #include "lwip/api.h"
6.   #include <string.h>
7.   /* USER CODE END Includes */
9.   /* Create the thread(s) */
10.   /* definition and creation of defaultTask */
11.   osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128);
12.   defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
14.   /* USER CODE BEGIN RTOS_THREADS */
15.   /* add threads, ... */
16.   /* USER CODE END RTOS_THREADS */
18.   /* USER CODE BEGIN RTOS_QUEUES */
19.   /* add queues, ... */
20.   /* USER CODE END RTOS_QUEUES */
23.   /* Start scheduler */
24.   osKernelStart();
26. ......
27. ......
28. ......
30. /* StartDefaultTask function */
31. void StartDefaultTask(void const * argument)
32. {
33.    MX_LWIP_Reset();
34.   /* init code for LWIP */
35.   MX_LWIP_Init();
37.   /* USER CODE BEGIN 5 */
38.   Echo_TCP();
39.   /* USER CODE END 5 */
40. }

Funckja MX_LWIP_Init() inicjalizuje bibliotekę, przypisuje adresy itp. Taki zestaw jest minimalny do poprawnej pracy biblioteki jak i stosu, który potem można odpowiednio rozwijać w dodatkowych funkcjach.

MX_LWIP_Reset() jest funkcją dodaną. Czyści dane dotyczące IP, maski oraz bramy domyślnej:

1. void MX_LWIP_Reset( void )
2. {
3.     ipaddr.addr = 0;
4.     netmask.addr = 0;
5.     gw.addr = 0;
6. }

Poniżej funkcja włączająca bibliotekę wygenerowana przez CubeMx:

1. void MX_LWIP_Init(void)
2. {
3.   /* IP addresses initialization */
4.   IP_ADDRESS[0] = 160;
5.   IP_ADDRESS[1] = 252;
6.   IP_ADDRESS[2] = 100;
7.   IP_ADDRESS[3] = 10;
8.   NETMASK_ADDRESS[0] = 255;
9.   NETMASK_ADDRESS[1] = 255;
10.   NETMASK_ADDRESS[2] = 255;
11.   NETMASK_ADDRESS[3] = 0;
12.   GATEWAY_ADDRESS[0] = 169;
13.   GATEWAY_ADDRESS[1] = 252;
14.   GATEWAY_ADDRESS[2] = 100;
15.   GATEWAY_ADDRESS[3] = 1;
17.   /* Initilialize the LwIP stack with RTOS */
18.   tcpip_init( NULL, NULL );
20.   /* IP addresses initialization without DHCP (IPv4) */
21.   IP4_ADDR(&ipaddr, IP_ADDRESS[0], IP_ADDRESS[1], IP_ADDRESS[2], IP_ADDRESS[3]);
22.   IP4_ADDR(&netmask, NETMASK_ADDRESS[0], NETMASK_ADDRESS[1] , NETMASK_ADDRESS[2], NETMASK_ADDRESS[3]);
23.   IP4_ADDR(&gw, GATEWAY_ADDRESS[0], GATEWAY_ADDRESS[1], GATEWAY_ADDRESS[2], GATEWAY_ADDRESS[3]);
25.   /* add the network interface (IPv4/IPv6) with RTOS */
26.   netif_add(&gnetif, &ipaddr, &netmask, &gw, NULL, &ethernetif_init, &tcpip_input);
28.   /* Registers the default network interface */
29.   netif_set_default(&gnetif);
31.   if (netif_is_link_up(&gnetif))
32.   {
33.     /* When the netif is fully configured this function must be called */
34.     netif_set_up(&gnetif);
35.   }
36.   else
37.   {
38.     /* When the netif link is down this function must be called */
39.     netif_set_down(&gnetif);
40.   }
42. /* USER CODE BEGIN 3 */
44. /* USER CODE END 3 */
45. }

Implementacji można dokonać na dwa sposoby, pierwszy z nich może być wykonany na porcie 80 opartych o netconn API. Wszystkie operacje podobnie jak następne zostały oparte o przykłady udostępnione przez ST dla F4.

1. static void Echo_TCP(void)
2. {
3.     struct netconn *connection, *newconnection;
4.     err_t err, accept_err;
5.     struct netbuf* buffer;
6.     void* data;
7.     u16_t len;
8.     err_t recv_err;
10.     //Makro tworzące nową strukturę oraz inuicjalizyjące ją nowymi wartościami.
11.     connection = netconn_new(NETCONN_TCP);
13.     if (connection != NULL)
14.     {
15.         err = netconn_bind(connection, NULL, 80);       //Przypisz połączenie do portu 80
17.         if (err == ERR_OK)
18.         {
19.             netconn_listen(connection);                 //Połączenie zamienione na tryb słuchania
21.             while (1)
22.             {
23.                 //Funkcja oczekujaca na polaczenie od klienta
24.                 accept_err = netconn_accept(connection, &newconnection);
26.                 //Obsluga polaczenia
27.                 if (accept_err == ERR_OK)
28.                 {
29.                     while ((recv_err = netconn_recv(newconnection, &buffer)) == ERR_OK)
30.                     {
31.                         do
32.                         {
33.                            netbuf_data(buffer, &data, &len);
34.                            netconn_write(newconnection, data, len, NETCONN_COPY);
35.                         }
36.                         while (netbuf_next(buffer) >= 0);
38.                        netbuf_delete(buffer);
39.                     }
41.                     //Zamknij polaczenie
42.                     netconn_close(newconnection);
43.                     netconn_delete(newconnection);
44.                 }
45.             }
46.         }
47.         else { netconn_delete(newconnection); }  //Nie udalo się nawiazac polaczenia
48.     }
49. }

Na początku wykorzystywane jest makro netconn_new, które tworzy nowe połączenie z układem. Następnie sprawdzane jest jego status, czy udało się nawiązać połączenie. Makro netconn_listen ustawia ustawia serwer TCP w tryb nasłuchiwania. Dalej w pętli while następuje wejście do funkcji blokującej netconn_accpet, która oczekuje na połączenie od klienta. Gdy połączenie zostaje zaakceptowane następuje oczekiwanie na przesłanie danych. Dane zostają odebrane i wprowadzone do bufora. Funkcja netconn_write przesyła te dane ponownie do układu. Całość znajduje się w pętli do while, która przechodzi dalej dopiero gdy dane zostaną przesłane. Po ich transmisji buffor zostaje zwolniony. Na samym końcu połączenie zostaje zamknięta oraz bufor zostaje opróżniony.

Drugi sposób działania z wykorzystaniem netconn będzie polegał na cyklicznym przesyłaniu danych. Taki sposób można wykorzystać np. do zbierania danych z kilku czujników. Dzięki wprowadzeniu danych w odpowiednio przygotowaną ramkę dane można odpowiednio obrobić w dedykowanym programie.

Przykładowy format ramki danych [DAT1;DAT2;...DATN], tak przygotowane informacje, jak wspomniałem wcześniej, można łatwo rozdzielić i przygotować, czy to poprzez wysyłanie informacji w kodach ASCII czy zapisane szesnastkowo. W tym przypadku całą procedurę obsługi zawarłem w StartDefaultTask.

1. void StartDefaultTask(void const * argument)
2. {
3.   struct netconn *conn, *newconn;
4.   err_t err, accept_err;
6.   char buffer[50] = {0};
7.   uint8_t zmienna1 = 0x01;
8.   uint8_t zmienna2 = 0x02;
9.   uint8_t zmienna3 = 0x03;
10.   uint8_t zmienna4 = 0x04;
11.   uint8_t zmienna5 = 0x05;
13.   MX_LWIP_Reset();
15.   /* init code for LWIP */
16.   MX_LWIP_Init();
18.   conn = netconn_new(NETCONN_TCP);
20.   if (conn != NULL)
21.   {
22.       err = netconn_bind(conn, NULL, 80);                   //Podłączenie
23.       if (err == ERR_OK)
24.       {
25.           netconn_listen(conn);                         //Przejscie w tryb nasłuchiwania
26.           accept_err = netconn_accept(conn, &newconn);  //Akceptacja połączenia
27.       }
28.   }
30.   /* USER CODE BEGIN 5 */
31.   /* Infinite loop */
32.   for(;;)
33.   {
34.       if(accept_err == ERR_OK)
35.       {
36.           memset(buffer, sizeof(buffer), 0x00);
37.           sprintf(buffer, "[%x;%x;%x;%x;%x]", zmienna1++, zmienna2++, zmienna3++, zmienna4++, zmienna5++);
38.           netconn_write(newconn, (const unsigned char*)buffer, strlen(buffer), NETCONN_COPY);
39.           osDelay(10000);
40.       }
41.   }
42.   /* USER CODE END 5 */
43. }

Druga wersja oparta o TCP wypuszczony dla STM32F4 z lekką modyfikacją. Działa ona także dla wersji bez FreeRtos. Funkcje zawarte w tym przykładzie są implementacjami tych które zostały zdefiniowane w bibliotece LWIP.

1. /* StartDefaultTask function */
2. void StartDefaultTask(void const * argument)
3. {
4.   MX_LWIP_Reset();
5.   /* init code for LWIP */
6.   MX_LWIP_Init();
7.   tcp_echoserver_init();
8.   /* USER CODE BEGIN 5 */
9.   /* Infinite loop */
10.   for(;;)
11.   {
12.      ethernetif_input(&gnetif);
13.      osDelay(1);
14.   }
15.   /* USER CODE END 5 */
16. }

Poniżej procedura uruchomienia nowego serwera TCP:

1. //Inicjalizacja echoserwera
2. //Do stworzenia polaczenia tcp_new | tcp_bind | tcp_listen | tcp_accept | tcp_accepted | tcp_connect
3. void tcp_echoserver_init(void)
4. {
5.   //Stworzenie nowego tcp pcb (protocol control block)
6.   tcp_echoserver_pcb = tcp_new();
8.   if (tcp_echoserver_pcb != NULL)
9.   {
10.     err_t err;          //Zmienna przechowująca informacje o stanie inicjalizacji
12.     //Przypisanie TCP PCB do lokalnego adresu IP oraz portu
13.     //1001 zwykly port     //7 echo port
14.     err = tcp_bind(tcp_echoserver_pcb, IP_ADDR_ANY, 1001);
15.     if (err == ERR_OK)
16.     {
17.       //Rozpoczecie nasluchiwania dla klientow TCP
18.       //Wykonywanie psywnego otwarcia.
19.       tcp_echoserver_pcb = tcp_listen(tcp_echoserver_pcb);
20.      
21.       //Rejestrowanie funkcji zwrotnej, króra obsługuje faktyczne otwieranie
22.       //połączenia
23.       tcp_accept(tcp_echoserver_pcb, tcp_echoserver_accept);
24.     }
25.     else
26.     {
27.       //Przenosi element do MEMP_TCP_PCB następnie zwalnia tcp_echoserver_pcb
28.       memp_free(MEMP_TCP_PCB, tcp_echoserver_pcb);
29.     }
30.   }
31. }

Pomiędzy wywołaniami funkcji tcp_listen oraz tcp_accept. Serwer nie może odebrać połączenia.

Dane są odbierane i przesyłane, za to odpowiedzialne jest funkcja tcp_echoserwer_send:

1. static void tcp_echoserver_send(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es)
2. {
3.   struct pbuf *ptr;
4.   char data[40] = {0};
5.   char buffereth[100] = {0};
6.   uint8_t i = 0;
8.   err_t wr_err = ERR_OK;
10.   while ((wr_err == ERR_OK) &&
11.          (es->p != NULL) &&
12.          (es->p->len <= tcp_sndbuf(tpcb)))
13.   {
15.     ptr = es->p;
17.     wr_err = tcp_write(tpcb, ptr->payload, ptr->len, 1);
19.     if (wr_err == ERR_OK)
20.     {
21.       u16_t plen;
22.       u8_t freed;
24.       plen = ptr->len;
26.       es->p = ptr->next;
28.       if(es->p != NULL)
29.       {
30.         pbuf_ref(es->p);
31.       }
33.       do
34.       {
35.         freed = pbuf_free(ptr);
36.       }
37.       while(freed == 0);
39.      tcp_recved(tpcb, plen);
40.    }
41.    else if(wr_err == ERR_MEM)
42.    {
43.      es->p = ptr;
44.    }
45.    else
46.    {
47.      /* other problem ?? */
48.    }
49.   }
50. }

W przypadku tak zdefiniowanego serwera w bardzo łatwy sposób można odbierać dane i przesyłać własne, dzięki temu można uzyskać komunikację dwustronną. Poprzez wysyłanie odpowiedniej komendy mikrokontroler będzie na nie reagował. Dodatkowo w bardzo prosty sposób można przygotować dedykowany do urządzenia program, np. w C# lub C++.

Poniżej funkcja odbierająca dane i reagująca na komendy CHECK oraz END. Pierwsza odsyła zmodyfikowaną odpowiedź, druga natomiast zamyka połączenie z serwerem.

Całość projektu można ściągnąć pod tym linkiem.

Bibliografia:

[1] Peczarski M. - Mikrokontrolery STM32 w sieci Ethernet w przykładach
[2] LwiP TCP/IP stack demonstation for stm32f4x7