[8.1] STM32F7 - Ethernet, bez RTOS

Ten przykład chciałbym poświęcić na konfigurację STM32, w wersji bez RTOS, jako serwer ethernet.

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

Programowanie[link]:

Tutaj chciałbym opisać dokładniej sposoby inicjalizacji biblioteki LWIP w wersji RAW, czyli bez systemu. Program przygotowałem w oparciu o pliki udostępnione przez ST. Które opierają się na przykładzie przygotowanym przez autora LWIP.

Na samym początku należy uruchomić bibliotekę wygenerowaną przez Cube lub skopiowaną w odpowiedniej wersji. Wykonuje się to poleceniem:

MX_LWIP_Init();

W pętli głównej lub w przerwaniach od timera należy wywoływać funkcje resetującą wszystkie zmienne zawierające informacje o czasie trwania operacji.

sys_check_timeouts();

Proces stawiania połączenia należy rozpocząć od wywołania funkcji tcp_new aby stworzyło nowy blok z danymi dla TCP.

Aby stworzyć nowe połączenie należy wywołać funkcje:

1. struct tcp_pcb * tcp_new(void)
2. tcp new();

Domyślnie będzie ona zawierała wartość NULL, i taką samą utrzyma jeśli proces tworzenia się nie powiedzie.

Następnie należy wywołać funkcje przypisującą adress IP oraz Port:

1. err_t tcp_bind(struct tcp_pcb * pcb, struct ip_addr * ipaddr, u16_t port)
2. tcp_bind(tcp_echoserver_pcb, IP_ADDR_ANY, 1001);

Jeśli port zostanie podany jako 0 to przypisanie nastąpi do wolnego portu. Aby ją wywołać to połączenie musi być ciągle zamknięte. Ja wykorzystuje zwykły port, można równie dobrze wykorzystać port 7 który jest przypisany jako echo. Funkcja zwróci wartość ERR_OK jeśli proces przejdzie prawidłowo lub ERR_USE, gdy port jest już wykorzystywany.

Poniżej funkcja inicjalizująca echoserver.

1. /*
2.  * @brief: Init echo server
3.  * @param: none
4.  * @ret: none
5.  */
6. void tcp_echoserver_init(void)
7. {
8.   /* Create new connection control block */
9.   tcp_echoserver_pcb = tcp_new();
11.   if (tcp_echoserver_pcb != NULL)
12.   {
13.     if (tcp_bind(tcp_echoserver_pcb, IP_ADDR_ANY, 1001) == ERR_OK)
14.     {
15.       tcp_echoserver_pcb = tcp_listen(tcp_echoserver_pcb);
16.       tcp_accept(tcp_echoserver_pcb, tcp_echoserver_accept);
17.     }
18.     else /* tcp_bind return with ERR_USE, port is already used */
19.     {
20.       /* Set selected element free, clear all settings for it */
21.       memp_free(MEMP_TCP_PCB, tcp_echoserver_pcb);
22.     }
23.   }
24. }

Po wywołaniu funkcji tcp_bind należy wywołać funkcje tcp_listen, która czeka na akceptacje połączenia. Zwraca ona nowy blok kontrolny dla zainicjalizowanego połączenia. Porzuca ona wcześniejszy i uruchamia nowy, który potrzebuje mniejszej ilości pamięci. Po jej wywołaniu należy wywołać tcp_accept. W przeciwnym wypadku stworzenie połączenia zostanie przerwane. Jeśli połączenia nie uda się nawiązać, to następuje wyczyszczenie przydzielonej pamięci.

1. static err_t tcp_echoserver_accept(void *arg, struct tcp_pcb *newpcb, err_t err)
2. {
3.   err_t ret_err;
4.   struct tcp_echoserver_struct *es;
6.   /* Unused arguments to prevent warnings */
7.   (void)arg;
8.   (void)err;
10.   /* Set priority for new connection */
11.   tcp_setprio(newpcb, TCP_PRIO_MIN);
13.   /* allocate structure with info about tcp connection */
14.   es = (struct tcp_echoserver_struct *)mem_malloc(sizeof(struct tcp_echoserver_struct));
16.   if (es != NULL)
17.   {
18.     es->state = ES_ACCEPTED;
19.     es->pcb = newpcb;
20.     es->retries = 0;
21.     es->p = NULL;
23.     /* Pass structure data do new connection */
24.     tcp_arg(newpcb, es);
26.     /* prepare to receive data */
27.     tcp_recv(newpcb, tcp_echoserver_recv);
29.     /* if error ocure then tha t callback will be */
30.     tcp_err(newpcb, tcp_echoserver_error);
32.     /* waits for connection */
33.     tcp_poll(newpcb, tcp_echoserver_poll, 0);
35.     ret_err = ERR_OK;
36.   }
37.   else
38.   {
39.     /* Close connection */
40.     tcp_echoserver_connection_close(newpcb, es);
41.     /* return error */
42.     ret_err = ERR_MEM;
43.   }
44.   return ret_err;
45. }

Funkcja odbierająca dane:

1. static err_t tcp_echoserver_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
2. {
3.   struct tcp_echoserver_struct *es;
4.   err_t ret_err;
6.   LWIP_ASSERT("arg != NULL",arg != NULL);
8.   es = (struct tcp_echoserver_struct *)arg;
10.   /* If buffer is empty */
11.   if (p == NULL)
12.   {
13.     /* Close connection */
14.     es->state = ES_CLOSING;
15.     if(es->p == NULL)
16.     {
17.        /* Close connection */
18.        tcp_echoserver_connection_close(tpcb, es);
19.     }
20.     else
21.     {
22.       /* Callback function used when data was received */
23.       tcp_sent(tpcb, tcp_echoserver_sent);
25.       /* Send data back to server */
26.       tcp_echoserver_send(tpcb, es);
27.     }
28.     ret_err = ERR_OK;
29.   }
30.   else if(err != ERR_OK)
31.   {
32.     /* Error occure, clear buffer  */
33.     if (p != NULL)
34.     {
35.       es->p = NULL;
36.       pbuf_free(p);
37.     }
38.     ret_err = err;
39.   }
40.   else if(es->state == ES_ACCEPTED)
41.   {
42.     /* connection accept, first data received, chunk in p->payload */
43.     es->state = ES_RECEIVED;
45.     /* write data to structuce*/
46.     es->p = p;
48.     tcp_sent(tpcb, tcp_echoserver_sent);
50.     /* Send data */
51.     tcp_echoserver_send(tpcb, es);
53.     ret_err = ERR_OK;
54.   }
55.   else if (es->state == ES_RECEIVED)
56.   {
57.     /* All data received */
58.     if(es->p == NULL)
59.     {
60.       es->p = p;
62.       tcp_echoserver_send(tpcb, es);
63.     }
64.     else
65.     {
66.       struct pbuf *ptr;
68.       /* chain two to the end of what we recv'ed previously */
69.       ptr = es->p;
70.       pbuf_chain(ptr,p);
71.     }
72.     ret_err = ERR_OK;
73.   }
74.   else if(es->state == ES_CLOSING)
75.   {
76.     //odd case, remote side closing twice, free all trash data
77.     tcp_recved(tpcb, p->tot_len);
78.     es->p = NULL;
79.     pbuf_free(p);
80.     ret_err = ERR_OK;
81.   }
82.   else
83.   {
84.     //unkown es->state, trash data
85.     tcp_recved(tpcb, p->tot_len);
86.     es->p = NULL;
87.     pbuf_free(p);
88.     ret_err = ERR_OK;
89.   }
90.   return ret_err;
91. }

Obsługa błędu odbywa się przy użyciu następującej funkcji:

1. static void tcp_echoserver_error(void *arg, err_t err)
2. {
3.   struct tcp_echoserver_struct *es;
5.   (void)err;
7.   es = (struct tcp_echoserver_struct *)arg;
8.   if (es != NULL)
9.   {
10.     /* free structure */
11.     mem_free(es);
12.   }
13. }

Funkcja odpowiedzialna za oczekiwanie na przesłanie danych:

1. static err_t tcp_echoserver_poll(void *arg, struct tcp_pcb *tpcb)
2. {
3.   err_t ret_err;
4.   struct tcp_echoserver_struct *es;
6.   es = (struct tcp_echoserver_struct *)arg;
7.   if (es != NULL)
8.   {
9.     if (es->p != NULL)
10.     {
11.       tcp_sent(tpcb, tcp_echoserver_sent);
12.       /* There is data in pbuf, chain try to send it */
13.       tcp_echoserver_send(tpcb, es);
14.     }
15.     else
16.     {
17.        /* No data in chain */
18.       if(es->state == ES_CLOSING)
19.       {
20.         /* Close connection */
21.         tcp_echoserver_connection_close(tpcb, es);
22.       }
23.     }
24.     ret_err = ERR_OK;
25.   }
26.   else
27.   {
28.     /* Aborts the connection by sending a RST (reset) segment to the remote host */
29.     tcp_abort(tpcb);
30.     ret_err = ERR_ABRT;
31.   }
32.   return ret_err;
33. }

Sprawdzanie dostępności danych:

1. static err_t tcp_echoserver_sent(void *arg, struct tcp_pcb *tpcb, u16_t len)
2. {
3.   struct tcp_echoserver_struct *es;
5.   (void)len;
7.   es = (struct tcp_echoserver_struct *)arg;
8.   es->retries = 0;
10.   if(es->p != NULL)
11.   {
12.     /* data still in buffer */
13.     tcp_sent(tpcb, tcp_echoserver_sent);
14.     tcp_echoserver_send(tpcb, es);
15.   }
16.   else
17.   {
18.     /* No data to send close connection */
19.     if(es->state == ES_CLOSING)
20.     {
21.       tcp_echoserver_connection_close(tpcb, es);
22.     }
23.   }
24.   return ERR_OK;
25. }

Przesłanie danych:

1. #define USART_COPY 1
2. static void tcp_echoserver_send(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es)
3. {
4.   struct pbuf *ptr;
5.  
6. #if USART_COPY == 1
7.   char dane[256] = {0};
8.   char buffer[256] = {0};
9. #endif
10.  
11.   err_t wr_err = ERR_OK;
12.  
13.   /* tcp_sndbuf - returns number of bytes in space that is avaliable in output queue */
14.   while ((wr_err == ERR_OK) && (es->p != NULL) && (es->p->len <= tcp_sndbuf(tpcb)))
15.   {
16.     /* get pointer on pbuf from es structure */
17.     ptr = es->p;
18.  
19. #if USART_COPY == 1
20.     sprintf(dane, "%s",(char *)ptr->payload);
21.     for(uint8_t i = 0; i<ptr->len; i++)
22.     {
23.         buffer[i] = dane[i];
24.     }
25.  
26.     /* Close connection */
27.     if(buffer[0] == 'E' && buffer[1] == 'N' && buffer[2] == 'D') {
28.         tcp_echoserver_connection_close(tpcb, es);
29.     }
30.     else{
31.         Usart_Uart_SendString(USART1, buffer, LF_CR);
32.     }
33. #endif
34.  
35.     //wr_err = tcp_write(tpcb, buffereth, strlen(buffereth), 1);
36.     wr_err = tcp_write(tpcb, ptr->payload, ptr->len, 1);
37.  
38.     /* Clear data */
39.     memset(dane, 0x00, sizeof(dane));
40.  
41.     if (wr_err == ERR_OK)
42.     {
43.       u16_t plen;
44.       u8_t freed;
45.  
46.       plen = ptr->len;
47.  
48.       /* continue with next pbuf in chain (if any) */
49.       es->p = ptr->next;
50.  
51.       if(es->p != NULL)
52.       {
53.         /* increment reference count for es->p */
54.         pbuf_ref(es->p);
55.       }
56.  
57.       /* chop first pbuf from chain */
58.       do
59.       {
60.         /* try hard to free pbuf */
61.         freed = pbuf_free(ptr);
62.       }
63.       while(freed == 0);
64.      /* we can read more data now */
65.      tcp_recved(tpcb, plen);
66.    }
67.    else if(wr_err == ERR_MEM)
68.    {
69.      /* we are low on memory, try later / harder, defer to poll */
70.      es->p = ptr;
71.    }
72.    else { }
73.   }
74. }

Czyszczenie zmiennych, zamknięcie połączenia:

1. static void tcp_echoserver_connection_close(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es)
2. {
3.   //remove all callbacks
4.   tcp_arg(tpcb, NULL);
5.   tcp_sent(tpcb, NULL);
6.   tcp_recv(tpcb, NULL);
7.   tcp_err(tpcb, NULL);
8.   tcp_poll(tpcb, NULL, 0);
9.  
10.   /* free structure */
11.   if (es != NULL)
12.   {
13.     mem_free(es);
14.   }
15.  
16.   /* Connection close */
17.   tcp_close(tpcb);
18. }

W głównej części programu należy wywołać tylko:

1. //...
2. //...
3. //...
4. MX_LWIP_Init();
5. tcp_echoserver_init();
6. while(1)
7. {
8.     ethernetif_input(&gnetif);
9.     sys_check_timeouts();
10. }

Funkcje inicjalizującą bibliotekę LWIP należy wywołać tylko jeden raz, ponowne wywołania zawiesi układ.

Pliki do projektu można pobrać pod tym linkiem. Po wygenerowaniu projektu przez Cube Mx należy podmienić biblioteki i dodać pliki których brakuje.