[12] STM32F7 - ESP8266 cz. 3. Konfiguracja komend TCP/IP, zebrany kod

W tym poście chciałbym przedstawić komendy dotyczące TCP/IP dla układu ESP. Na końcu tego postu znajduje się pełna biblioteka z opisanym w trzech częściach kodem.

Komendy dotyczące TCP/IP:

AT+CIPSTATUS - (format: AT+CIPSTATUS) - sprawdza status połączenia. Nie podaje się do niej żadnego parametru. Należy tylko obsłużyć zwracane przez nie wartości. Są one w formacie:

STATUS:

+CIPSTATUS:<link ID>, <type>, <remote IP>, <remote_port>, <local_port>,<tetype>

1. case Command_AT_CIPSTATUS:
2.     UART_SENDSTRING(ESP8266_USART, "AT+CIPSTATUS", CR_LF);
3. break;

• Parametry zwracane mogą przyjąć następującą formę:
• <stat>  - sprawdzenie statusu ESP
• 2 - ESP podłączone do punktu dostępowego i ma przydzielone IP
• 3 - stworzono połączenie w wersji TCP bądź UDP
• 4 - połączenie TCP bądź UDP zostało przerwane
• 5 - Nie udało się wykonać połączenia do AP
• <link ID>  - ilość połączenie od 0 do 4
• <type>  - typ połączenia TCP bądź UDP
• <remote IP>  - adress IP
• <remote port>  - numer portu hosta
• <local port>  - lokalny numer portu
• <tetype>  - tutaj można otrzymać dwa parametry 0 oznacza połączenie jako klient, 1 natomiast połączenie jako serwer

AT+CIPDOMAIN - (format: AT+CIPDOMAIN=<domain name>) - po podłączeniu do internetu może zostać wywołany DNS czyli system nazw domenowych. Oznacza to, że adres IP ESP będzie widoczny w sieci pod konkretną nazwą.

1. void Set_Dns(char *domain_name)
2. {
3.     sprintf(data, "AT+CIPDOMAIN=\"%s\"", &domain_name[0]);
4.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
5. }

AT+CIPSTART - (format: Poniżej) - komenda pozwalająca na ustanowienie połączenie w wersji TCP, UDP bądź SSL. Dopuszczalne paramety to:

Format ramki danych jest różny w zależności od sposobu połączenia oraz od ilości użytkowników:

Dla TCP IP pojedyncze połączenie:

AT+CIPSTART=<type>, <remote IP>, <remote port>, [TCP keep alive]

Dla TCP IP połączenie multi:

AT+CIPSTART=<link ID>,<type>, <remote IP>, <remote port>, [TCP keep alive]

Parametry dla połączenie TCP:

• <link ID>  - wykorzystywany tylko przy wielu połączeniach. Dla trybu jednopołączeniowego nie daje się tego parametru.
• <type>  - string "TCP" bądź "UDP". Wybór w jaki sposób zostanie ustanowione połączenie.
• <remote IP>  - adres IP podawany jako string
• <remote port>  - numer portu
• [<TCP keep alive>] - określa jaka jest długość życia TCP, jest to parametr opcjonalny. Domyślnie jest to wartość zero czyli nie jest niszczone. Można podać parametr 0 (dla wyłączenia opcji) bądź od 1 do 7200 sekund by określić czas.

1. /*
2.  * Establich TCP connection
3.  */
4. uint8_t Establish_TCP_Connection(uint8_t Connection_Type, uint8_t link_ID, uint8_t *remove_IP,
5.                                                 uint16_t remove_port, uint16_t keep_alive_time)
6. {
7.     char data[50];
9.     if(0 == Connection_Type)        //SingleConne
10.     {
11.         if(0 == keep_alive_time)
12.         {
13.             sprintf(data, "AT+CIPSTART=\"TCP\",\"%u.%u.%u.%u\",%u", remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
14.                                                                     remove_port);
15.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
16.             return 1;
17.         }
18.         else if((keep_alive_time != 0) && (keep_alive_time < 7200))
19.         {
20.             sprintf(data, "AT+CIPSTART=\"TCP\",\"%u.%u.%u.%u\",%u,%u", remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
21.                                                                     remove_port, keep_alive_time);
22.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
23.             return 1;
24.         }
25.     }
26.     else if(1 == Connection_Type)   //MultiConne
27.     {
28.         if(0 == keep_alive_time)
29.         {
30.             sprintf(data, "AT+CIPSTART=%u,\"TCP\",\"%u.%u.%u.%u\",%u", link_ID, remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
31.                                                                     remove_port);
32.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
33.             return 1;
34.         }
35.         else if(keep_alive_time != 0)
36.         {
37.             sprintf(data, "AT+CIPSTART=%u,\"TCP\",\"%u.%u.%u.%u\",%u,%u", link_ID,remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
38.                                                                     remove_port, keep_alive_time);
39.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
40.             return 1;
41.         }
42.     }
43.     return 0;
44. }

Dla UDP pojedyncze połączenie: 

AT+CIPSTART=<type>,<remote IP>,<remote port>,[<UDP local port>], [<UDP mode>]

Dla UDP połączenie multi:

AT+CIPSTART=<link ID>,<type>,<remote IP>,<remote port>, [<UDP local port>], [<UDP mode>]

Parametry połączeń UDP:

• <link ID>  - wykorzystywany tylko przy wielu połączeniach. Dla trybu jednopołączeniowego nie daje się tego parametru.
• <type>  - "UDP". Wybór w jaki sposób zostanie ustanowione połączenie.
• <remote IP>  - adres IP podawany jako string
• <remote port>  - numer portu
• [<UDP local port>] - port UDP układu ESP
• [<UDP mode>] - tryb działania UDP. Do wybory parametry od 0 do 2. Dla transmisji transparentnej wprowadza się wartość 0, jest ona także domyślnie ustawiana. Wartość 1 oznacza, że miejsce docelowej transmisji może się zmienić jeden raz. Dla wartości 2 miejsce może się zmieniać nieograniczoną ilość razy.

1. /*
2.  * UDP Transmission
3.  */
4. uint8_t Establish_UDP_Connection(uint8_t Connection_Type, uint8_t link_ID, uint8_t *remove_IP, uint16_t remove_port,
5.                                                             uint16_t Udp_local_port, uint8_t Udp_mode)
6. {
7.     char data[50];
9.     if(0 == Connection_Type)        //SingleConne
10.     {
11.         if(0 == Udp_local_port)
12.         {
13.             sprintf(data, "AT+CIPSTART=\"UDP\",\"%u.%u.%u.%u\",%u", remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
14.                                                                         remove_port);
15.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
16.             return 1;
17.         }
18.         else if(Udp_local_port != 0)
19.         {
20.             sprintf(data, "AT+CIPSTART=\"UDP\",\"%u.%u.%u.%u\",%u,%u,%u", remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
21.                                                                         remove_port, Udp_local_port, Udp_mode);
22.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
23.             return 1;
24.         }
26.     }
27.     else if(1 == Connection_Type)   //MultiConne
28.     {
29.         if(0 == Udp_local_port)
30.         {
31.             sprintf(data, "AT+CIPSTART=%u,\"UDP\",\"%u.%u.%u.%u\",%u", link_ID, remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
32.                                                                         remove_port);
33.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
34.             return 1;
35.         }
36.         else if(Udp_local_port != 0)
37.         {
38.             sprintf(data, "AT+CIPSTART=%u,\"UDP\",\"%u.%u.%u.%u\",%u,%u,%u", link_ID, remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
39.                                                                         remove_port, Udp_local_port, Udp_mode);
40.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
41.             return 1;
42.         }
43.     }
44.     return 0;
45. }

Parametr UDP local port musi zostać ustawione aby można było korzystać z UDP mode.

Ostatnim rodzajem połączenie jest połączenie SSL. jego parametry są takie same jak w przypadku TCP. Zmianie ulega jedynie parametr type, który zostaje zmieniony na SSL.

1. /*
2.  * SSL connection
3.  */
4. uint8_t Establish_SSL_Connection(uint8_t Connection_Type, uint8_t link_ID, uint8_t *remove_IP, uint16_t remove_port,
5.                                                             uint16_t keep_alive_time)
6. {
7.     char data[50];
9.     if(0 == Connection_Type)        //SingleConne
10.     {
11.         if(0 == keep_alive_time)
12.         {
13.             sprintf(data, "AT+CIPSTART=\"SSL\",\"%u.%u.%u.%u\",%u", remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
14.                                                                     remove_port);
15.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
16.             return 1;
17.         }
18.         else if((keep_alive_time != 0) && (keep_alive_time < 7200))
19.         {
20.             sprintf(data, "AT+CIPSTART=\"SSL\",\"%u.%u.%u.%u\",%u,%u", remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
21.                                                                     remove_port, keep_alive_time);
22.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
23.             return 1;
24.         }
25.     }
26.     else if(1 == Connection_Type)   //MultiConne
27.     {
28.         if(0 == keep_alive_time)
29.         {
30.             sprintf(data, "AT+CIPSTART=%u,\"SSL\",\"%u.%u.%u.%u\",%u", link_ID, remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
31.                                                                     remove_port);
32.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
33.             return 1;
34.         }
35.         else if(keep_alive_time != 0)
36.         {
37.             sprintf(data, "AT+CIPSTART=%u,\"SSL\",\"%u.%u.%u.%u\",%u,%u", link_ID,remove_IP[0], remove_IP[1], remove_IP[2], remove_IP[3],
38.                                                                     remove_port, keep_alive_time);
39.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
40.             return 1;
41.         }
42.     }
43.     return 0;
44. }

Nawiązanie połączenia poprzez protokół SSL musi zostać poprzedzone komendą CIPSSLSIZE, która służy do ustalenia wielkości bufora. 

Wysłanie tej komendy zwraca wartość OK bądź ERROR lub jeśli połączenie jest już ustanowione to ALREADY CONNECT. 

AT+CIPSSLSIZE - (format: AT+CIPSSLSIZE=<size>) - ustawia wielkość bufora dla SSL. Zakres to 2048 lub 4096.

1.         case Command_AT_CIPSSLSIZE:
2.             if(0 == param)
3.             {
4.                 UART_SENDSTRING(ESP8266_USART, "AT+CIPSSLSIZE=2048", CR_LF);
5.             }
6.             else if(1 == param)
7.             {
8.                 UART_SENDSTRING(ESP8266_USART, "AT+CIPSSLSIZE=4096", CR_LF);
9.             }
10.             break;

AT+CIPSEND - (format: AT+CIPSEND=<nr_klienta>,<dlugosc_wiadomosci>,[remote_IP],[remote Port]) - przesyłanie danych do klienta podłączonego do serwera postawionego na ESP. Przeslana zostanie wiadomość wtedy gdy po nadaniu komendy zostanie przesłany ciąg znaków o długości zdefiniowanej w ramce. Jeśli zostanie wprowadzony ciąg znaków o mniejszej długości to system przed wysłaniem ramki będzie czekał na jej zapełnienie.

Funkcja odpowiedzialna za przesyłanie wiadomości testowej:

1. //Send test data to client
2. case Command_AT_CIPSEND:
3.     UART_SENDSTRING(ESP8266_USART, "AT+CIPSEND=0,5", CR_LF);
4.     HAL_Delay(500);
5.     UART_SENDSTRING(ESP8266_USART, "HELLO", CR_LF);
6.     break;

W niej wykorzystałem opóźnienie, lepiej to zrobić na zasadzie oczekiwania na odpowiedź od ESP, gdy jest gotowy do przesyłania danych. Nastąpi to po wyświetleniu wiadomości "OK" Natomiast ta przedstawiona wyżej może posłużyć do szybkiego testu komunikacji z ESP.

Po wysłaniu danych oraz przesłaniu komendy otrzymuje się następującą odpowiedź od układu:

Funkcja odpowiedzialna za przesyłanie wiadomości testowej poprawiona o oczekiwanie na gotowość ESP:

1. uint8_t Send_Data_To_Ser_CIP_Send(uint8_t ID, uint16_t length,
2.         uint8_t ip_1_UDP, uint8_t ip_2_UDP, uint8_t ip_3_UDP, uint8_t ip_4_UDP, uint8_t port_UDP)
3. {
4.     char data[100] = {0};
6.     if(length <= 2048)
7.     {
8.         if((ip_1_UDP !=0 || ip_2_UDP !=0 || ip_3_UDP !=0 || ip_4_UDP!=0) && port_UDP != 0)
9.         {
10.             sprintf(data,"AT+CIPSEND=%d,%d,\"%d.%d.%d.%d\",%d", ID, length, ip_1_UDP, ip_2_UDP, ip_3_UDP, ip_4_UDP, port_UDP);
11.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
12.         }
13.         else if(0 == ID) //Pojedyncze po³¹czenie
14.         {
15.             sprintf(data,"AT+CIPSEND=%d", length);
16.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
17.         }
18.         else if(ID!=0)
19.         {
20.             sprintf(data,"AT+CIPSEND=%d,%d", ID,length);
21.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
22.         }
23.     }
24.     else
25.     {
26.         return Stat_Error;
27.     }
28.     return Stat_OK;
29. }

Tutaj zasada działania jest następująca. Najpierw przesyłana jest komenda CIPSEND z danymi dotyczącymi wielkości wiadomości oraz ustawienie flagi przesłania danych. Po tej informacji w pętli głównej, gdzie odbieram wszystkie informacje od ESP to oczekuje na odpowiedź OK. Po czym przesyłam dane oraz czyszczę wcześniej ustawioną flagę. Blok else przesyła dane gdy została ustawiona flaga wysłania zwykłych danych. 

AT+CIPSENDEX - (format: AT+CIPSENDEX=[link ID],<length>,[<remote IP>],[<remote port>]) - wysłanie danych. Dane są wysyłane do czasu osiągnięcia znaku "/0" bądź zapełnienia bufora podaną wielkością.

1. /*
2.  * Send data
3.  * AT+CIPSENDEX
4.  * transmission_type 0 - TCP 1 - UDP
5.  * link_id 0-4 for multi conn, 5 - sigle connection
6.  */
7. uint8_t Send_Dat_Ex(uint8_t transmission_type, uint8_t link_id, uint16_t length, char *remote_IP, uint16_t remote_port)
8. {
9.     char data[50] = {0};
11.     if(0 == transmission_type)                  //TCP
12.     {
13.         if(5 == link_id)                        //single connection
14.         {
15.             sprintf(data, "AT+CIPSENDEX=%u", length);
16.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
17.             return 1;
18.         }
19.         else if(link_id >= 0 && link_id < 5)    //multi connection
20.         {
21.             sprintf(data, "AT+CIPSENDEX=%u,%u", link_id, length);
22.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
23.             return 1;
24.         }
25.     }
26.     else if(1 == transmission_type)             //UDP
27.     {
28.         if(5 == link_id)                        //single connection
29.         {
30.             if(('x' == remote_IP[0]) && ('x' == remote_port[0]))
31.             {
32.                 sprintf(data, "AT+CIPSENDEX=%u", length);
33.             }
34.             else
35.             {
36.                 sprintf(data, "AT+CIPSENDEX=%u,\"%s\",%u", length, &remote_IP[0], remote_port);
37.             }
38.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
39.             return 1;
40.         }
41.         else if(link_id >= 0 && link_id < 5)    //multi connection
42.         {
43.             if(('x' == remote_IP[0]) && ('x' == remote_port[0]))
44.             {
45.                 sprintf(data, "AT+CIPSENDEX=%u,%u", link_id, length);
46.             }
47.             else
48.             {
49.                 sprintf(data, "AT+CIPSENDEX=%u,%u,\"%s\",%u", link_id, length, &remote_IP[0], remote_port);
50.             }
51.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
52.             return 1;
53.         }
54.     }
55.     return 0;
56. }

AT+CIPSENDBUF - (format: AT+CIPSENDBUF=<link_ID>,<length>) - wysłanie danych, można robić ciągle, bez potrzeby oczekiwania na odpowiedz.

1. /*
2.  * Check status of TCP-send-buffer
3.  * AT+CIPSENDBUF
4.  */
5. uint8_t Dat_Into_TCP_Send_Buffer(uint8_t link_ID, uint16_t length)
6. {
7.     if(link_ID == 5)    //Single Connection
8.     {
9.         sprintf(data, "AT+CIPSENDBUF=%u", length);
10.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
11.         return 1;
12.     }
13.     else if(link_ID >= 0 && link_ID < 5)
14.     {
15.         sprintf(data, "AT+CIPSENDBUF=%u,%u", link_ID, length);
16.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
17.         return 1;
18.     }
19.     return 0;
20. }

AT+CIPBUFSTATUS - (format: AT+CIPBUFSTATUS=<link ID>) - sprawdza status danych wysłanych przez TCP. Komendę można wysłać na dwa sposoby pierwszy z nich jest bezparametrowy i zwraca on następujące wartości:

• <następny segment ID> - będzie pobrany z komendy CIPSENDBUF;
• <wysłany segment ID> - jaki segment został ostatnio wysłany;
• <wysłany segment poprawnie ID> - numer ostatniego segmentu, który został wysłany poprawnie;
• <pozostały rozmiar bufora> - ile danych zostało jeszcze do wysłania;
• <numer w kolejce> - ile danych zostało jeszcze do przesłania.

Drugi sposób jest stosowany dla wielu połączeń, wtedy jako parametr link ID podawany jest numer połączenia.

1. /*
2.  * Check status of TCP-send-buffer
3.  * AT+CIPBUFSTATUS
4.  */
5. uint8_t Check_TCP_Send_Buffer(uint8_t Sing_Multi, uint8_t link_ID)
6. {
7.     if(0 == Sing_Multi)
8.     {
9.         UART_SENDSTRING(ESP8266_USART, "AT+CIPBUFSTATUS", CR_LF);
10.         return 1;
11.     }
12.     else if(1 == Sing_Multi)
13.     {
14.         sprintf(data, "AT+CIPBUFSTATUS=%u", link_ID);
15.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
16.         return 1;
17.     }
18.     return 0;
19. }

AT+CIPCHECKSEQ - (format: AT+CIPCHECKSEQ=<link ID>,<segment ID>) - komenda sprawdza czy dany segment został wysłany poprawnie. Jako parametry podawany jest numer połączenia oraz dane uzyskane przez CIPSENDBUF. W odpowiedzi otrzymuje się te parametry oraz status czy udało się przesłać je poprawnie.

1. /*
2.  * Check if a specific segment was sent successfully
3.  * AT+CIPCHECKSEQ
4.  */
5. uint8_t Check_Sent_Seg(uint8_t Sing_Multi, uint8_t link_ID, uint32_t seg_ID)
6. {
7.     if(0 == Sing_Multi)
8.     {
9.         sprintf(data, "AT+CIPCHECKSEQ=%lu", seg_ID);
10.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
11.         return 1;
12.     }
13.     else if(1 == Sing_Multi)
14.     {
15.         sprintf(data, "AT+CIPCHECKSEQ=%u,%lu", link_ID, seg_ID);
16.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
17.         return 1;
18.     }
19.     return 0;
20. }

AT+CIPBUFRESET - (format: AT+CIPBUFRESET | AT+CIPBUFRESET=<link ID>) - komenda resetująca segment ID ustawiony z poprzedniej komendy. Wartość ID dla trybu wielu połączeń mieści się w zakresie od 0 do 4. Dla pojedynczego połączenie parametr jest pomijany. Komenda może być stosowana tylko z komenda AT+CIPSENDBUF.

1. uint8_t Reset_Seg_ID(uint8_t Sing_Multi, uint8_t link_ID)
2. {
3.     if(0 == Sing_Multi) //single connection
4.     {
5.         UART_SENDSTRING(ESP8266_USART, "AT+CIPBUFRESET", CR_LF);
6.         return 1;
7.     }
8.     else if(1 == Sing_Multi) //multiconnection
9.     {
10.         if((link_ID >= 0) || (link_ID < 5))
11.         {
12.             sprintf(data, "AT+CIPBUFRESET=%u", link_ID);
13.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
14.             return 1;
15.         }
16.     }
17.     return 0;
18. }

AT+CIPCLOSE - (format: AT+CIPCLOSE=<link ID>) - zamknięcie połączeń TCP, UDP, SSL. Parametr przyjmuje wartości od 0 do 5. Wartość najwyższa zamyka wszystkie połączenia. W trybie serwera nie przynosi ona żadnego efektu. Zwracana wartość to OK lub ERROR.

1.         case Command_AT_CIPCLOSE:
2.             UART_SENDSTRING(ESP8266_USART, "AT+CIP", CR_LF);
3.         break;

AT+CIFSR - (format: AT+CIFSR) - wyświetla adres IP. Jeśli został nadany to wyświetli IP urządzenia oraz IP jakie zostało przydzielone przez sieć. Dodatkowo wyświetlany jest MAC. Funkcja obsługująca: 

1.         case Command_AT_CIPCLOSE:
2.             sprintf(dane, "AT+CIPCLOSE=%u", param);
3.             UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
4.         break;

AT+CIPMUX - (format: AT+CIPMUX=[0-1]) - ta komenda pozwala na włączenie bądź wyłączenie trybu wielu połączeń. Po wprowadzeniu wartości zero możliwe jest tylko jedno połączenie, po podaniu jedynki dopuszczalne są maksymalnie cztery połączenia. 

1.         //Enable/Disable multiple connections AT+CIPMUX = mode
2.         //0 - single connection | 1 - Multiple connections(MAX 4)
3.         //Response: +CIPMUX: mode OK
4.         case Command_AT_CIPMUX:
5.             if(0 == param)      {   UART_SENDSTRING(ESP8266_USART, "AT+CIPMUX=0", CR_LF);   }
6.             else if(1 == param) {   UART_SENDSTRING(ESP8266_USART, "AT+CIPMUX=1", CR_LF);   }
7.         break;

AT+CIPSERVER - (format: AT+CIPSERVER=[1,0],[port]) - Stworzenie serwera. Parametr pierwszy włącza (1) lub wyłącza (0) serwer. Drugi parametr jest opcjonalny podawany w nim jest numer portu.

1. void Command_Cipserver(uint8_t mode, uint16_t port)
2. {
3.     char data[50] = {0};
5.     if(port != 0)
6.     {
7.         sprintf(data, "AT+CIPSERVER=%u,%u", mode, port);
8.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
9.     }
10.     else
11.     {
12.         if(0 == mode)       {       UART_SENDSTRING(ESP8266_USART, "AT+CIPSERVER=0", CR_LF);    }
13.         else if(1 == mode)  {       UART_SENDSTRING(ESP8266_USART, "AT+CIPSERVER=1", CR_LF);    }
14.     }
15. }

AT+CIPMODE - (format: AT+CIPMODE=[0...1]) - komenda ta ustawia tryb odbierania danych. Dla wartości 0 przychodzą one w formacie "+IPD, kanał, ilość bajtów". Jeśli zostanie wprowadzona wartość 1 to dane będą wysyłane bezpośrednio na port szeregowy. Drugi tryb pracy może zostać uruchomiony tylko dla trybu TCP jednopołączeniowego bądź dla UDP. 

1.         //Set transfer mode 0 - Normal mode | 1 - unvarnish transmission mode
2.         //Response: +CWMODE: mode OK
3.         case Command_AT_CIPMODE:
4.             if(0==param)        {   UART_SENDSTRING(ESP8266_USART, "AT+CIPMODE=0", CR_LF);  }
5.             else if(1==param)   {   UART_SENDSTRING(ESP8266_USART, "AT+CIPMODE=1", CR_LF);  }
6.         break;

Jeśli połączenie zostanie zerwane to układ wyśle wiadomość składającą się z linkID oraz słowa CLOSED. Ponowne połączenie nie nastąpi automatycznie. 

AT+SAVETRANSLINK - (format: AT+SAVETRANSLINK=<mode>,<IP>,<port>,[<type>],[tcp keep alive]) - zapisuje dane do linku w pamięci flash.

1. /*
2.  * Save transparent transmission link to flash
3.  * AT+SAVETRANSLINK =<mode>, <remote IP or domain name>, <remote port>[, <type>][, <TCP keep alive>]
4.  * AT+SAVETRANSLINK =<mode>, <remote IP>, <remote port>[, <type>][,<UDP local port>]
5.  */
6. uint8_t Save_Trans_Trans_Link(uint8_t mode, char *remote_IP, uint16_t port, char *type, uint16_t TCP_or_UDP_param)
7. {
8.     char data[50] = {0};
10.     if(0 == mode)                   //0 - normal mode
11.     {
12.         if('x' == type[0])
13.         {
14.             sprintf(data, "AT+SAVETRANSLINK=0,\"%s\",%u", &remote_IP[0], port);
15.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
16.             return 1;
17.         }
18.         else
19.         {
20.             if(0 == TCP_or_UDP_param)
21.             {
22.                 sprintf(data, "AT+SAVETRANSLINK=0,\"%s\",%u,\"%s\",0", &remote_IP[0], port, &type[0]);
23.                 UART_SENDSTRING(ESP8266_USART, data, CR_LF);
24.                 return 1;
25.             }
26.             else if((TCP_or_UDP_param > 0) && (TCP_or_UDP_param < 7201))
27.             {
28.                 sprintf(data, "AT+SAVETRANSLINK=0,\"%s\",%u,\"%s\",%u", &remote_IP[0], port, &type[0], TCP_or_UDP_param);
29.                 UART_SENDSTRING(ESP8266_USART, data, CR_LF);
30.                 return 1;
31.             }
32.         }
33.     }
34.     else if(1 == mode)              //1 - UART_wifi passthrough mode
35.     {
36.         if('x' == type[0])
37.         {
38.             sprintf(data, "AT+SAVETRANSLINK=0,\"%s\",%u", &remote_IP[0], port);
39.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
40.             return 1;
41.         }
42.         else
43.         {
44.             if(0 == TCP_or_UDP_param)
45.             {
46.                 sprintf(data, "AT+SAVETRANSLINK=0,\"%s\",%u,\"%s\",0", &remote_IP[0], port, &type[0]);
47.                 UART_SENDSTRING(ESP8266_USART, data, CR_LF);
48.                 return 1;
49.             }
50.             else if((TCP_or_UDP_param > 0) && (TCP_or_UDP_param < 7201))
51.             {
52.                 sprintf(data, "AT+SAVETRANSLINK=0,\"%s\",%u,\"%s\",%u", &remote_IP[0], port, &type[0], TCP_or_UDP_param);
53.                 UART_SENDSTRING(ESP8266_USART, data, CR_LF);
54.                 return 1;
55.             }
56.         }
57.     }
58.     return 0;
59. }

AT+CIPSTO - (format: AT+CIPSTO=<time>) - ustawia czas oczekiwania dla serwera.

1.         case Command_AT_CIPSTO:
2.             sprintf(dane, "AT+CIPSTO=%u", data);
3.             UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
4.         break;

AT+PING - (format: AT+PING=<IP>) - sprawdzanie czasu odpowiedzi od układu. Jako parametr podaje się adres IP lub nazwę domeny.

1. /*
2.  * Function Ping
3.  * AT+PING=<IP>
4.  */
5. uint8_t Ping(uint8_t type, char *IP, char *Name)
6. {
7.     char data[50] = {0};
9.     if(0 == type)
10.     {
11.         if('x' != Name[0])
12.         {
13.             return 0;
14.         }
16.         sprintf(data, "AT+PING=\"%u.%u.%u.%u\"", IP[0], IP[1], IP[2],  IP[3]);
17.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
18.         return 1;
19.     }
20.     else if(1 == type)
21.     {
22.         sprintf(data, "AT+PING=\"%s\"", &Name[0]);
23.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
24.         return 1;
25.     }
27.     return 0;
28. }

AT+CIUPDATE - (format: AT+CIUPDATE) - uaktualnienie oprogramowania AT w układzie przez sieć wifi. Jej wywołanie w przypadku poprawnej pracy będzie skutkowało wypisaniem na ekranie czterech komunikatów. Pierwszy informuje o znalezieniu serwera, drugi o poprawnym połączeniu do niego, czwarty o znalezieniu poprawnego oprogramowania. Ostatni natomiast oznacza, że aktualizacja się rozpoczęła. Po wykonaniu trzeba wywołać funkcję Restore.

1.        case Command_AT_CIUPDATE:
2.             UART_SENDSTRING(ESP8266_USART, "AT+CIUPDATE", CR_LF);
3.             break;

AT+CIPDINFO - (format: AT+CIPINFO=<mode>) - wyświetla IP oraz port razem z odpowiedzią odebrania danych +IDP.

1.         case Command_AT_CIPDINFO:
2.             if(0 == param)      {   UART_SENDSTRING(ESP8266_USART, "AT+CIPDINFO=0", CR_LF); }
3.             else if(1 == param) {   UART_SENDSTRING(ESP8266_USART, "AT+CIPDINFO=1", CR_LF); }
4.             break;

Poniżej znajduje się funkcja wspólna dla komend sprawdzających stany poszczególnych elementów:

1. //----------------------------------------------------------------------------------------------
2. /*
3.  * Functions to prepare most of commands
4.  */
5. void Send_Command(Command_To_Send command, uint8_t param, uint16_t data)
6. {
7.     char dane[100] = {0};
9.     switch(command)
10.     {
11.         //----------------------------------------------------
12.         //Check communication
13.         //Response: OK
14.         //TESTOWANE OK
15.         case Command_AT:
16.             UART_SENDSTRING(ESP8266_USART, "AT", CR_LF);
17.         break;
18.         //----------------------------------------------------
19.         //Reset ESP
20.         //Response: OK
21.         //TESTOWANE OK
22.         case Command_AT_RST:
23.             UART_SENDSTRING(ESP8266_USART, "AT+RST", CR_LF);
24.         break;
25.         //----------------------------------------------------
26.         //Enable/Disable multiple connections AT+CIPMUX = mode
27.         //0 - single connection | 1 - Multiple connections(MAX 4)
28.         //Response: +CIPMUX: mode OK
29.         case Command_AT_CIPMUX:
30.             if(0 == param)      {   UART_SENDSTRING(ESP8266_USART, "AT+CIPMUX=0", CR_LF);   }
31.             else if(1 == param) {   UART_SENDSTRING(ESP8266_USART, "AT+CIPMUX=1", CR_LF);   }
32.         break;
33.         //----------------------------------------------------
34.         case Command_AT_CIPCLOSE:
35.             sprintf(dane, "AT+CIPCLOSE=%u", param);
36.             UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
37.         break;
38.         //----------------------------------------------------
39.         //Send data to client
40.         case Command_AT_CIPSEND:
41.             //Podstawowe przeslanie danych
42.             UART_SENDSTRING(ESP8266_USART, "AT+CIPSEND=0,5", CR_LF);
43.         break;
44.         //----------------------------------------------------
45.         //Enter deep sleep mode, (AT+GSLP=time), time in ms
46.         //Hardware has to support deep-sleep wake up (Reset pin has to be High)
47.         //TESTOWANE OK, Uk³ad wchodzi w stan uœpienia
48.         case Command_AT_GSLP:
49.             if(data != 0)
50.             {
51.                 sprintf(dane, "AT+GSLP=%u", data);
52.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
53.             }
54.         break;
55.         //----------------------------------------------------
56.         //Enable/Disable Echo, two commands ATE0 (Disable), ATE1 (Enable)
57.         //Response:OK
58.         case Command_AT_ATE:
59.             if(0 == param)      {   UART_SENDSTRING(ESP8266_USART, "ATE0", CR_LF);  }
60.             else if(1 == param) {   UART_SENDSTRING(ESP8266_USART, "ATE1", CR_LF);  }
61.         break;
62.         //----------------------------------------------------
63.         //Wifi Mode, station, AP, station + AP
64.         //Response: +CWMODE: mode OK
65.         case Command_AT_CWMODE:
66.             if(Wifi_Mode_Station == param || Wifi_Mode_Ap == param || Wifi_Mode_Ap_Station == param)
67.             {
68.                 sprintf(dane, "AT+CWMODE=%u", param);
69.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
70.             }
71.         break;
72.         case Command_AT_CWMODE_CUR:
73.             if(Wifi_Mode_Station == param || Wifi_Mode_Ap == param || Wifi_Mode_Ap_Station == param)
74.             {
75.                 sprintf(dane, "AT+CWMODE_CUR=%u", param);
76.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
77.             }
78.         break;
79.         case Command_AT_CWMODE_DEF:
80.             if(Wifi_Mode_Station == param || Wifi_Mode_Ap == param || Wifi_Mode_Ap_Station == param)
81.             {
82.                 sprintf(dane, "AT+CWMODE_DEF=%u", param);
83.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
84.             }
85.         break;
86.         //----------------------------------------------------
87.         //Get local IP address
88.         //Response: +CWMODE: mode OK
89.         case Command_AT_CIFSR:
90.                 UART_SENDSTRING(ESP8266_USART, "AT+CIFSR", CR_LF);
91.         break;
92.         //----------------------------------------------------
93.         //Set transfer mode 0 - Normal mode | 1 - unvarnish transmission mode
94.         //Response: +CWMODE: mode OK
95.         case Command_AT_CIPMODE:
96.             if(0==param)        {   UART_SENDSTRING(ESP8266_USART, "AT+CIPMODE=0", CR_LF);  }
97.             else if(1==param)   {   UART_SENDSTRING(ESP8266_USART, "AT+CIPMODE=1", CR_LF);  }
98.         break;
99.         //----------------------------------------------------
100.         //Set server timeout
101.         //
102.         case Command_AT_CIPSTO:
103.             sprintf(dane, "AT+CIPSTO=%u", data);
104.             UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
105.         break;
106.         //----------------------------------------------------
107.         //Factory reset, clear data in flash memmory
108.         //Response: Module reset
109.         case Command_AT_RESTORE:
110.             UART_SENDSTRING(ESP8266_USART, "AT+RESTORE", CR_LF);
111.         break;
112.         //----------------------------------------------------
113.         //Set EPS into sleep mode,
114.         //Response: OK
115.         case Command_AT_SLEEP:
116.             if(Wifi_Mode_Disable == param || Wifi_Mode_Light == param || Wifi_Mode_Modem == param)
117.             {
118.                 sprintf(dane, "AT+SLEEP=%u", param);
119.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
120.             }
121.             break;
122.         //----------------------------------------------------
123.         //Set value of RF TX power, not precise
124.         //Param: 0 to 82
125.         //Response: OK
126.         case Command_AT_RFPower:
127.             if((param >= 0) || (param <= 82))
128.             {
129.                 sprintf(dane, "AT+SLEEP=%u", param);
130.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
131.             }
132.             break;
133.         //----------------------------------------------------
134.         case Command_AT_RFVDD:
135.             if((data >= 1900) || (data <= 3300))
136.             {
137.                 sprintf(dane, "AT+RFVDD=%u", data);
138.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
139.             }
140.             break;
141.         //----------------------------------------------------
142.         case Command_AT_CIOBAUD:
143.             if(data != 0)
144.             {
145.                 sprintf(dane, "AT+CIOBAUD=%u", data);
146.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
147.             }
148.             break;
149.         //----------------------------------------------------
150.         case Command_AT_CWLAPOPT:
151.             if(data < 128 && ((0 == param) || (1 == param)))
152.             {
153.                 sprintf(dane, "AT+CWLAPOPT=%u,%u", param, data);
154.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
155.             }
156.             break;
157.         //----------------------------------------------------
158.         //Disconnect from AP
159.         //Response: OK
160.         case Command_AT_CWQAP:
161.             UART_SENDSTRING(ESP8266_USART, "AT+CWQAP", CR_LF);
162.             break;
163.         //----------------------------------------------------
164.         //Auto connect to AP
165.         //Response: OK
166.         case Command_AT_CWAUTOCONN:
167.             if(0 == param)
168.             {
169.                 UART_SENDSTRING(ESP8266_USART, "AT+CWAUTOCONN=0", CR_LF);
170.             }
171.             else if(1 == param)
172.             {
173.                 UART_SENDSTRING(ESP8266_USART, "AT+CWAUTOCONN=1", CR_LF);
174.             }
175.             break;
176.         //----------------------------------------------------
177.         case Command_AT_CWSTARTSMART:
178.             if(1 == param)      {   UART_SENDSTRING(ESP8266_USART, "AT+CWSTARTSMART=1", CR_LF); }
179.             else if(2 == param) {   UART_SENDSTRING(ESP8266_USART, "AT+CWSTARTSMART=2", CR_LF); }
180.             else if(3 == param) {   UART_SENDSTRING(ESP8266_USART, "AT+CWSTARTSMART=3", CR_LF); }
181.             break;
182.         //----------------------------------------------------
183.         case Command_AT_CWSTOPSMART:
184.             UART_SENDSTRING(ESP8266_USART, "AT+CWSTOPSMART", CR_LF);
185.             break;
186.         //----------------------------------------------------
187.         case Command_AT_CIPSTATUS:
188.             UART_SENDSTRING(ESP8266_USART, "AT+CIPSTATUS", CR_LF);
189.             break;
190.         //----------------------------------------------------
191.         case Command_AT_CIPSSLSIZE:
192.             if(0 == param)
193.             {
194.                 UART_SENDSTRING(ESP8266_USART, "AT+CIPSSLSIZE=2048", CR_LF);
195.             }
196.             else if(1 == param)
197.             {
198.                 UART_SENDSTRING(ESP8266_USART, "AT+CIPSSLSIZE=4096", CR_LF);
199.             }
200.             break;
201.         //----------------------------------------------------
202.         case Command_AT_CWSTOPDISCOVER:
203.             UART_SENDSTRING(ESP8266_USART, "AT+CWSTOPDISCOVER", CR_LF);
204.             break;
205.         //----------------------------------------------------
206.         case Command_AT_WPS:
207.             if(0 == param)      {   UART_SENDSTRING(ESP8266_USART, "AT+WPS=0", CR_LF);  }
208.             else if(1 == param) {   UART_SENDSTRING(ESP8266_USART, "AT+WPS=1", CR_LF);  }
209.             break;
210.         //----------------------------------------------------
211.         case Command_AT_CIPCLOSE:
212.             if((param >= 0) && (param <= 5))
213.             {
214.                 sprintf(dane, "AT+CIPCLOSE=%u", param, data);
215.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
216.             }
217.             break;
218.         //----------------------------------------------------
219.         case Command_AT_CIUPDATE:
220.             UART_SENDSTRING(ESP8266_USART, "AT+CIUPDATE", CR_LF);
221.             break;
222.         //----------------------------------------------------
223.         case Command_AT_CIPDINFO:
224.             if(0 == param)      {   UART_SENDSTRING(ESP8266_USART, "AT+CIPDINFO=0", CR_LF); }
225.             else if(1 == param) {   UART_SENDSTRING(ESP8266_USART, "AT+CIPDINFO=1", CR_LF); }
226.             break;
227.         default:
228.         break;
229.     }
230. }
231. //------------------------------------------------------------------------------------------------------------
232. /*
233.  * Function sending checking command to ESP8266
234.  * Command format: AT+Command?
235.  */
236. void Send_Command_Check(Command_To_Check command)
237. {
238.     switch(command)
239.     {
240.         //----------------------------------------------------
241.         case Check_CIOBAUD:
242.             UART_SENDSTRING(ESP8266_USART, "AT+CIOBAUD?", CR_LF);
243.         break;
244.         //----------------------------------------------------
245.         case Check_AT_CWMODE:
246.             UART_SENDSTRING(ESP8266_USART, "AT+CWMODE?", CR_LF);
247.         break;
248.         //----------------------------------------------------
249.         case Check_AT_CIPMODE:
250.             UART_SENDSTRING(ESP8266_USART, "AT+CIPMODE?", CR_LF);
251.         break;
252.         //----------------------------------------------------
253.         case Check_AT_CIPMUX:
254.             UART_SENDSTRING(ESP8266_USART, "AT+CIPMUX?", CR_LF);
255.         break;
256.         //----------------------------------------------------
257.         case Check_AT_GMR:
258.             UART_SENDSTRING(ESP8266_USART, "AT+GMR", CR_LF);
259.         break;
260.         //----------------------------------------------------
261.         case Check_AT_CWLAP:
262.             UART_SENDSTRING(ESP8266_USART, "AT+CWLAP", CR_LF);
263.         break;
264.         //----------------------------------------------------
265.         case Check_AT_CWJAP:
266.             UART_SENDSTRING(ESP8266_USART, "AT+CWJAP?", CR_LF);
267.         break;
268.         //----------------------------------------------------
269.         case Check_AT_CIPSTA:
270.             UART_SENDSTRING(ESP8266_USART, "AT+CIPSTA?", CR_LF);
271.         break;
272.         //----------------------------------------------------
273.         case Check_AT_CIPSTAMAC:
274.             UART_SENDSTRING(ESP8266_USART, "AT+CIPSTAMAC?", CR_LF);
275.         break;
276.         //----------------------------------------------------
277.         case Check_AT_CIFSR:
278.             UART_SENDSTRING(ESP8266_USART, "AT+CIFSR", CR_LF);
279.         break;
280.         //----------------------------------------------------
281.         case Check_AT_CWSAP:
282.             UART_SENDSTRING(ESP8266_USART, "AT+CWSAP?", CR_LF);
283.             break;
284.         //----------------------------------------------------
285.         case Check_AT_CWLIF:
286.             UART_SENDSTRING(ESP8266_USART, "AT+CWLIF", CR_LF);
287.             break;
288.         //----------------------------------------------------
289.         case Check_AT_CWDHCP:
290.             UART_SENDSTRING(ESP8266_USART, "AT+CWDHCP?", CR_LF);
291.             break;
292.         //----------------------------------------------------
293.         case Check_AT_CIPAP:
294.             UART_SENDSTRING(ESP8266_USART, "AT+CIPAP?", CR_LF);
295.             break;
296.         //----------------------------------------------------
297.         case Command_AT_CWLAP:
298.             UART_SENDSTRING(ESP8266_USART, "AT+CWLAP", CR_LF);
299.             break;
300.         //----------------------------------------------------
301.         default:
302.         break;
303.     }
304. }

Obsługa pakietów odbieranych jest przeze mnie rozwiązana w pętli głównej, gdzie odbierane są dane od UART7 i wypisane poprzez USART1. Tam w momencie odebrania danych porównywane są one z przygotowanymi formatami odpowiedzi. W zależności od niej podejmowane są dalsze czynności: 

1. if (USART_Get_Data(UART7, rx_buf, sizeof(rx_buf)))
2. {
3.     UART_SENDSTRING(USART1,rx_buf,CR_LF);
4.     if(rx_buf[0] == 'O' && rx_buf[1] == 'K')
5.     {
6.         UART_SENDSTRING(USART1,"Odpowiedz OK",CR_LF);
7.         if(1 == ESP_Flag.ESP_Send_Test_Message_Flag)
8.         {
9.             UART_SENDSTRING(ESP8266_USART,"Hello",CR_LF);
10.             ESP_Flag.ESP_Send_Test_Message_Flag = 0;
11.         }
12.     }
13.     else if(rx_buf[0] == 'E' && rx_buf[1] == 'R' && rx_buf[2] == 'R' && rx_buf[3] == 'O' && rx_buf[4] == 'R')
14.     {
15.     }
16.     //...
17.     //...
18. }

Bibliotekę można pobrać pod tym linkiem.

 Poniżej przedstawiam jeszcze schemat wykonania połączenia z Wifi tak aby układ działał jako serwer TCP. Połączenie z nim można wykonać np. poprzez program Herkules. 

Po uruchomieniu modułu należy przejść przez następujące:

• AT+CWMODE=1 - ustawienie trybu pracy, musi być skonfigurowane jako klient 
• AT+CIPMODE=0 - ustawienie trybu odbieranych danych na format +IPD
• AT+CIPMUX=1 - tryb pracy na wielu połączeniach
• AT+CWLAP - wyświetlenie dostępnych sieci wifi
• AT+CWJAP="nazwa","hasło" - połączenie z wybraną siecią wifi 
• AT+CIFSR - sprawdzenie adresy IP oraz MAC ESP
• AT+CIPSERVER=1,1001 - postawienie serwera na porcie 1001, jeśli serwet dla stron HTTP to port 80. 

Ja cały projekt wykonałem dodatkowo z obsługą dotyku oraz wyświetlacza. Dzięki czemu wszystkie komendy można było wprowadzać bezpośrednio z płytki. Przyciski wykonałem za pomocą biblioteki STemWin. Dane odebrane były wyświetlane na wyświetlaczu oraz przekazywane na USART1. Pozwoliło to znacząco ułatwić proces obsługi poprzez wykorzystanie wyświetlacza z klawiaturą, dodatkowo na USARCIE można było porównać otrzymaną odpowiedź. 

Funkcje obsługujące ustawiane tryby można wykonać za pomocą wysłania komendy, po czym sprawdzana jest odpowiedź jeśli wszystko przeszło poprawnie to wysyłana jest kolejna wiadomość do ESP. Można to zrobić za pomocą ustawiania flagi poprawnego odebrania danych. Gdzie następnie sprawdzana jest jej wartość.