[12] STM32F7 - ESP8266 cz. 2. Konfiguracja komend Wifi

Ten post będzie rozwinięciem poprzedniego dotyczącego mikrokontrolera ESP8266

Komendy Wifi

AT+CWMODE - (format: AT+CWMODE=[1..3]) - ustawienie trybu pracy Wifi. Do wyboru jest tryb klienta (1 ang. station mode), tryb dostępu (2 - ang. access point), czyli tworzona jest własne urządzenie do którego można się połączyć poprzez sieć wifi oraz połączenie obu trybów (3).

1.         case Command_AT_CWMODE:
2.             if(Wifi_Mode_Station == param || Wifi_Mode_Ap == param || Wifi_Mode_Ap_Station == param)
3.             {
4.                 sprintf(dane, "AT+CWMODE=%u", param);
5.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
6.             }
7.         break;

AT+CWMODE_CUR - (format: AT+CWMODE_CUR=[1..3]) - nie zapisuje zmian do pamięci flash.

1.         case Command_AT_CWMODE_CUR:
2.             if(Wifi_Mode_Station == param || Wifi_Mode_Ap == param || Wifi_Mode_Ap_Station == param)
3.             {
4.                 sprintf(dane, "AT+CWMODE_CUR=%u", param);
5.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
6.             }
7.         break;

AT+CWMODE_DEF - (format: AT+CWMODE_DEF=[1..3]) - zmiany wprowadzane do pamięci flash.

1.         case Command_AT_CWMODE_DEF:
2.             if(Wifi_Mode_Station == param || Wifi_Mode_Ap == param || Wifi_Mode_Ap_Station == param)
3.             {
4.                 sprintf(dane, "AT+CWMODE_DEF=%u", param);
5.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
6.             }
7.         break;

AT+CWJAP - (format: AT+CWJAP="nazwa_sieci","hasło") - komenda pozwala na podłączenie urządzenia do sieci wifi. Ta funkcja jest u mnie zdefiniowana w osobnej funkcji.

1. /*
2.  * Function CWJAP, make connection with Wifi network
3.  */
4. void Wifi_Connect(char *wifi_name, char *wifi_password)
5. {
6.     char data[100] = {0};
8.     sprintf(data,"AT+CWJAP=\"%s\",\"%s\"", &wifi_name[0], &wifi_password[0]);
9.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
10. }

AT+CWJAP_CUR - (format: AT+CWJAP_CUR="nazwa_sieci","hasło") - nie zapisuje zmian do pamięci flash.

1. void Wifi_Connect_Cur(char *wifi_name, char *wifi_password)
2. {
3.     char data[100] = {0};
5.     sprintf(data,"AT+CWJAP_CUR=\"%s\",\"%s\"", &wifi_name[0], &wifi_password[0]);
6.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
7. }

AT+CWJAP_DEF - (format: AT+CWJAP_DEF="nazwa_sieci","hasło") - zmiany zapisywane do pamięci flash.

1. void Wifi_Connect_Def(char *wifi_name, char *wifi_password)
2. {
3.     char data[100] = {0};
5.     sprintf(data,"AT+CWJAP_DEF=\"%s\",\"%s\"", &wifi_name[0], &wifi_password[0]);
6.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
7. }

AT+CWLAPOPT - (format: AT+CWLAPOPT=<sort_enable>,<mask>) - ustawienie konfiguracji dla komendy CWLAP.

Pierwszy parametr określa włączenie sortowania. Jeśli zostanie podana wartość 1 to dane będą wyświetlane zgodnie z , jeśli zostanie podane 0 to nie będę wyświetlane zgodnie z . Drugi parametr określa ile danych ma się pojawić w komendzie. Decyduje się o tym poprzez wybór odpowiedniego bitu:

• bit 0: - Wyświetlanie 
• bit 1: - Wyświetlanie 
• bit 2: - Wyświetlanie 
• bit 3: - Wyświetlanie 
• bit 4: - Wyświetlanie 
• bit 5: - Wyświetlanie 
• bit 6: - Wyświetlanie 

1.         case Command_AT_CWLAPOPT:
2.             if(data < 128 && ((0 == param) || (1 == param)))
3.             {
4.                 sprintf(dane, "AT+CWLAPOPT=%u,%u", param, data);
5.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
6.             }
7.             break;

AT+CWLAP - (format: AT+CWLAP=<ssid>, [mad], [ch]) - pozwala ono na sprawdzenie dostępnych SSID oraz MAC dla wszystkich lub wybranego kanału. Jako parametry podaje się nazwę lub dla dokładniejszego wyszukiwania adres mac oraz kanał.

1. uint8_t AP_List(char *ssid, char *mac, uint16_t channel)
2. {
3.     char data[50];
5.     if(0 == channel)
6.     {
7.         sprintf(data, "AT+CWLAP=\"%s\"", &ssid[0]);
8.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
9.         return 1;
10.     }
11.     else
12.     {
13.         sprintf(data, "AT+CWLAP=\"%s\",\"%s\",%u", &ssid[0],&mac[0],channel);
14.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
15.         return 1;
16.     }
17.     return 0;
18. }

Wywołanie komendy bezparametrowej (AT+CWLAP) wypisze listę wszystkich dostępnych punktów dostępu do ESP8266.

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

Komenda w odpowiedzi prześle następujące dane:

• wypisany zostanie standard szyfrowania
• ssid albo AP
• siła sygnału
• adres mac
• offset częstotliwości dla AP podawany w kHz
• kalibracja offsetu

AT+CWQAP - (format: AT+CWQAP) - rozłączenie z AP.

1.         //Disconnect from AP
2.         //Response: OK
3.         case Command_AT_CWQAP:
4.             UART_SENDSTRING(ESP8266_USART, "AT+CWQAP", CR_LF);
5.             break;

AT+CWSAP - (format: AT+CWSAP=ssid, pwd, chl, enc, [max conn],[ssid hidden

• nazwa ESP, w jaki sposób będzie on widoczny podczas podłączania się do niego;
• hasło jakie należy podać przed podłączeniem;
• numer kanału;
• rodzaj szyfrowania. Do wyboru Open (0), WPA_PSK (2), WPA2_PSK (3), WPA_WPA2_PSK (4);
• maksymalna liczba urządzeń jaka może zostać podłączona do ESP, od 1 do 4.
• nadawienie SSID w trybie brodcastu. Parametr 0 włącza tą opcje, parametr 1 wyłącza.

W dokumentacji zalecają używanie wersji CUR oraz DEF w zależności od tego na jaki okres czasu chce się ustawić odpowiednie parametry.

Wysłanie zapytania tzn. komendy AT+CWSAP? pozwala na uzyskanie w odpowiedzi takich informacji jak:

Nazwę SSID, pwd, chl, enc, max conn oraz ssid hidden. Całą ramkę odpowiedzi poprzedzi nazwa CWSAP.

AT+CWSAP_CUR - (format: AT+CWSAP_CUR=ssid,pwd,chl,enc,[max conn],[ssid hidden) - ustawienie tymczasowe, zmiany nie są wpisywane do pamięci flash.

AT+CWSAP_DEF - (format: AT+CWSAP_CUR=ssid,pwd,chl,enc,[max conn],[ssid hidden)- ustawienie stałe, zmiany wprowadzone do pamięci flash.

1. /*
2. * Configurate of softAP mode
3. * Format AT+CWSAP=,,,,[],[]
4. */
5. uint8_t Config_SoftAP(char *ssid, char *pwd, uint8_t chl, uint8_t ecn, uint8_t max_conn ,SSID_Hidden_e ssid_hidden)
6. {
7.     char data[50];
8.     if((ssid_hidden == Ssid_Hidden_None) && (max_conn == 0)) {
9.         sprintf(data, "AT+CWSAP=\"%s\",\"%s\",%u,%u", &ssid[0], &pwd[0], chl, ecn);
10.     }
11.     else if(ssid_hidden == Ssid_Hidden_None) {
12.         sprintf(data, "AT+CWSAP=\"%s\",\"%s\",%u,%u,%u", &ssid[0], &pwd[0], chl, ecn, max_conn);
13.     }
14.     else if((max_conn != 0) && (ssid_hidden != Ssid_Hidden_None)) {
15.         sprintf(data, "AT+CWSAP=\"%s\",\"%s\",%u,%u,%u,%u", &ssid[0], &pwd[0], chl, ecn, max_conn, ssid_hidden);
16.     }
17.     else {
18.         return Stat_Error;
19.     }
20.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
21.     return Stat_OK;
22. }
24. uint8_t Config_SoftAP_DEF(char *ssid, char *pwd, uint8_t chl, uint8_t ecn, uint8_t max_conn ,SSID_Hidden_e ssid_hidden)
25. {
26.     char data[50];
27.     if((ssid_hidden == Ssid_Hidden_None) && (max_conn == 0)) {
28.         sprintf(data, "AT+CWSAP_DEF=\"%s\",\"%s\",%u,%u", &ssid[0], &pwd[0], chl, ecn);
29.     }
30.     else if(ssid_hidden == Ssid_Hidden_None) {
31.         sprintf(data, "AT+CWSAP_DEF=\"%s\",\"%s\",%u,%u,%u", &ssid[0], &pwd[0], chl, ecn, max_conn);
32.     }
33.     else if((max_conn != 0) && (ssid_hidden != Ssid_Hidden_None)){
34.         sprintf(data, "AT+CWSAP_DEF=\"%s\",\"%s\",%u,%u,%u,%u", &ssid[0], &pwd[0], chl, ecn, max_conn, ssid_hidden);
35.     }
36.     else {
37.         return Stat_Error;
38.     }
40.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
41.     return Stat_OK;
42. }
44. uint8_t Config_SoftAP_CUR(char *ssid, char *pwd, uint8_t chl, uint8_t ecn, uint8_t max_conn ,SSID_Hidden_e ssid_hidden)
45. {
46.     char data[50];
47.     if((ssid_hidden == Ssid_Hidden_None) && (max_conn == 0)) {
48.         sprintf(data, "AT+CWSAP_CUR=\"%s\",\"%s\",%u,%u", &ssid[0], &pwd[0], chl, ecn);
49.     }
50.     else if(ssid_hidden == Ssid_Hidden_None) {
51.         sprintf(data, "AT+CWSAP_CUR=\"%s\",\"%s\",%u,%u,%u", &ssid[0], &pwd[0], chl, ecn, max_conn);
52.     }
53.     else if((max_conn != 0) && (ssid_hidden != Ssid_Hidden_None)) {
54.         sprintf(data, "AT+CWSAP_CUR=\"%s\",\"%s\",%u,%u,%u,%u", &ssid[0], &pwd[0], chl, ecn, max_conn, ssid_hidden);
55.     }
56.     else {
57.         return Stat_Error;
58.     }
59.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
60.     return Stat_OK;
61. }

AT+CWLIF - (format: AT+CWLIF) - komenda zwracająca. Służy do sprawdzenia jakie urządzenia są podłączone do ESP. W odpowiedzi zwraca ich IP oraz MAC. Może być wykorzystywana tylko gdy DHCP jest włączone. Nie można przy użyciu tej komendy pobrać statycznego IP. Nie przyjmuje ona żadnych parametrów:

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

AT+CWDHCP - (format: AT+CWDHCP=<mode>,<en>) - komenda służy do włączania lub wyłączania. Pierwszy parametr służy do wybrania trybu pracy. Wartość 0 oznacza tryb klienta, 1 pozwala na skonfigurowanie jako urządzenie osobne do którego można się podłączyć. Ostatnia wartość czyli 2 wykorzystuje oba te tryby. Drugi parametr włącza (1) lub wyłącza (0) DHCP.

Trzeba pamiętać, że ta komenda dotyczy innych komend odpowiedzialnych za ustawienia IP. W przypadku włączenia DHCP IP statyczne zostanie wyłączone i odwrotnie. Jak się można domyślić ustawienie będzie takie jak ostatnia wprowadzona konfiguracja.

AT+CWDHCP_CUR - (format: AT+CWDHCP_CUR=<mode>,<en>) - zapisanie wartości tymczasowej, nie zapisywana w pamięci flash.

AT+CWDHCP_DEF - (format: AT+CWDHCP_DEF=<mode>,<en>) - zapisanie wartości do pamięci flash.

1. uint8_t Config_DHCP(uint8_t command, uint8_t mode, uint8_t en)
2. {
3.     char data[50] = {0};
5.     if((0 == mode || 1 == mode || 2 == mode) && (0 == en || 1 == en))
6.     {
7.         if(0 == command)
8.         {
9.             sprintf(data, "AT+CWDHCP=%u,%u", mode, en);
10.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
11.             return Stat_OK;
12.         }
13.         else if(1 == command)
14.         {
15.             sprintf(data, "AT+CWDHCP_CUR=%u,%u", mode, en);
16.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
17.             return Stat_OK;
18.         }
19.         else if(2 == command)
20.         {
21.             sprintf(data, "AT+CWDHCP_DEF=%u,%u", mode, en);
22.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
23.             return Stat_OK;
24.         }
25.     }
26.     return Stat_Error;
27. }

AT+CWDHCPS_CUR - (format: AT+CWDHCPS_CUR=<lease time>,<start ip>,<end ip>)) - ustawia adres IP dla klienta z przygotowanego zakresu. Dane nie będą przechowywane w pamięci flash.

Parametry:

• wartość 0 wyłącza te ustawiania, używany jest domyślny zakres. Wpisanie 1 włącza zdeklarowany w następnych parametrach zasięg.
• czas przez jaki dany zakres będzie zarezerwowany. Jest on podawany w minutach w przedziale od 1 do 2880.
• początkowy adres IP
• końcowy adres IP

AT+CWDHCPS_DEF - (format: AT+CWDHCPS_CUR=<lease time>,<start ip>,<end ip>) - wprowadzone zmiany zostaną zapisane w pamięci flash. Pierwsza długa instrucja if sprawdza czy zostanie przeprowadzone automatyczne podłączenie do AP.

1. /*
2.  * Set the IP address allocated by ESP8266 soft-AP DHCP
3.  * Format AT+CWDHCPS_CUR | AT+CWDHCPS_CUR=<enable>, <lease time>, <start IP>, <end IP>
4.  */
5. uint8_t Set_IP_Address_Range(uint8_t command, uint8_t enable, uint8_t lease_time, uint8_t *statr_IP, uint8_t *end_IP)
6. {
7.     char data[50]={0};
9.     if(((0 == enable) || (1 == enable)) && ((lease_time>0) && (lease_time<2880)))
10.     {
11.         if(0 == command)
12.         {
13.             sprintf(data, "AT+CWDHCPS_CUR=%u,%u,\"%u.%u.%u.%u\",\"%u.%u.%u.%u\"", enable, lease_time,
14.                     statr_IP[0], statr_IP[1], statr_IP[2], statr_IP[3], end_IP[0], end_IP[1], end_IP[2], end_IP[3]);
15.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
16.         }
17.         else if(1 == command)
18.         {
19.             sprintf(data, "AT+CWDHCPS_DEF=%u,%u,\"%u.%u.%u.%u\",\"%u.%u.%u.%u\"", enable, lease_time,
20.                 statr_IP[0], statr_IP[1], statr_IP[2], statr_IP[3], end_IP[0], end_IP[1], end_IP[2], end_IP[3]);
21.             UART_SENDSTRING(ESP8266_USART, data, CR_LF);
22.         }
23.     }
24.     return Stat_Error;
25. }

1.         //Auto connect to AP
2.         //Response: OK
3.         case Command_AT_CWAUTOCONN:
4.             if(0 == param)
5.             {
6.                 UART_SENDSTRING(ESP8266_USART, "AT+CWAUTOCONN=0", CR_LF);
7.             }
8.             else if(1 == param)
9.             {
10.                 UART_SENDSTRING(ESP8266_USART, "AT+CWAUTOCONN=1", CR_LF);
11.             }
12.             break;

AT+CIPAPMAC - (format: AT+CIPAPMAC =<mac>) - ustawienie adresu MAC. Adresy urządzeń muszą się między sobą różnić. Dodatkowo pierwszy bit w pierwszym bajcie nie może być wartości 1.

AT+CIPAPMAC_CUR - (format: AT+CIPAPMAC_CUR=<mac>) - nie wprowadza zmian w pamięci flash.

AT+CIPAPMAC_DEF - (format: AT+CIPAPMAC_DEF=<mac>) - wpisuje zmiany do pamięci flash.

1. /*
2.  * Format AT+CIPAPMAC="MAC"
3.  */
4. void Set_Mac_Data(uint8_t *ESP8266_MAC, uint8_t choose)
5. {
6.     char data[50];
8.     if(1 == choose)
9.     {
10.         sprintf(data, "AT+CIPAPMAC=\"%u:%u:%u:%u:%u:%u\"", ESP8266_MAC[0], ESP8266_MAC[1], ESP8266_MAC[2], ESP8266_MAC[3],
11.                                                             ESP8266_MAC[4], ESP8266_MAC[5]);
12.     }
13. #if  Init_Cur_Commands == 1
14.     else if(2 == choose)
15.     {
16.         sprintf(data, "AT+CIPAPMAC_CUR=\"%u:%u:%u:%u:%u:%u\"", ESP8266_MAC[0], ESP8266_MAC[1], ESP8266_MAC[2], ESP8266_MAC[3],
17.                                                             ESP8266_MAC[4], ESP8266_MAC[5]);
18.     }
19. #endif
20. #if  Init_Def_Commands == 1
21.     else if(3 == choose)
22.     {
23.         sprintf(data, "AT+CIPAPMAC_DEF=\"%u:%u:%u:%u:%u:%u\"", ESP8266_MAC[0], ESP8266_MAC[1], ESP8266_MAC[2], ESP8266_MAC[3],
24.                                                             ESP8266_MAC[4], ESP8266_MAC[5]);
25.     }
26. #endif
27.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
28. }

AT+CIPSTA - (format: AT+CIPSTA=<IP>,[gateway],[netmask]) - ustawienie parametrów statycznego IP, maski sieci oraz bramy domyślnej. Parametry gateway oraz netmask są opcjonalne i nie muszą zostać podane.

1. void Set_IP_Data(uint8_t *ESP8266_IP, uint8_t *ESP8266_NetMask, uint8_t *ESP8266_Gateway, uint8_t check)
2. {
3.     char data[50];
5.     if(1 == check)              //Set only IP
6.     {
7.         sprintf(data, "AT+CIPSTA=\"%u.%u.%u.%u\"", ESP8266_IP[0], ESP8266_IP[1], ESP8266_IP[2], ESP8266_IP[3]);
8.     }
9.     else if(2 == check)         //Set all param
10.     {
11.         sprintf(data, "AT+CIPSTA=\"%u.%u.%u.%u\",\"%u.%u.%u.%u\",\"%u.%u.%u.%u\"", ESP8266_IP[0], ESP8266_IP[1], ESP8266_IP[2], ESP8266_IP[3],
12.                 ESP8266_NetMask[0], ESP8266_NetMask[1], ESP8266_NetMask[2], ESP8266_NetMask[3],
13.                 ESP8266_Gateway[0], ESP8266_Gateway[1], ESP8266_Gateway[2], ESP8266_Gateway[3]);
14.     }
16.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
17. }
19. void Set_IP_Data_CUR(uint8_t *ESP8266_IP, uint8_t *ESP8266_NetMask, uint8_t *ESP8266_Gateway, uint8_t check)
20. {
21.     char data[50];
23.     if(1 == check)              //Set only IP
24.     {
25.         sprintf(data, "AT+CIPSTA_CUR=\"%u.%u.%u.%u\"", ESP8266_IP[0], ESP8266_IP[1], ESP8266_IP[2], ESP8266_IP[3]);
26.     }
27.     else if(2 == check)         //Set all param
28.     {
29.         sprintf(data, "AT+CIPSTA_CUR=\"%u.%u.%u.%u\",\"%u.%u.%u.%u\",\"%u.%u.%u.%u\"", ESP8266_IP[0], ESP8266_IP[1], ESP8266_IP[2], ESP8266_IP[3],
30.                 ESP8266_NetMask[0], ESP8266_NetMask[1], ESP8266_NetMask[2], ESP8266_NetMask[3],
31.                 ESP8266_Gateway[0], ESP8266_Gateway[1], ESP8266_Gateway[2], ESP8266_Gateway[3]);
32.     }
34.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
35. }
37. void Set_IP_Data_DEF(uint8_t *ESP8266_IP, uint8_t *ESP8266_NetMask, uint8_t *ESP8266_Gateway, uint8_t check)
38. {
39.     char data[50];
41.     if(1 == check)              //Set only IP
42.     {
43.         sprintf(data, "AT+CIPSTA_DEF=\"%u.%u.%u.%u\"", ESP8266_IP[0], ESP8266_IP[1], ESP8266_IP[2], ESP8266_IP[3]);
44.     }
45.     else if(2 == check)         //Set all param
46.     {
47.         sprintf(data, "AT+CIPSTA_DEF=\"%u.%u.%u.%u\",\"%u.%u.%u.%u\",\"%u.%u.%u.%u\"", ESP8266_IP[0], ESP8266_IP[1], ESP8266_IP[2], ESP8266_IP[3],
48.                 ESP8266_NetMask[0], ESP8266_NetMask[1], ESP8266_NetMask[2], ESP8266_NetMask[3],
49.                 ESP8266_Gateway[0], ESP8266_Gateway[1], ESP8266_Gateway[2], ESP8266_Gateway[3]);
50.     }
52.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
53. }

Komenda AT+CIPSTA ma wpływ na ustawienia z komendy AT+CWDHCP. Jeśli DHCP jest włączone to statyczne IP nie jest przyjmowane i odwrotnie.

AT+CIPSTA_CUR - (format: AT+CIPSTA_CUR=<IP>,[gateway],[netmask]) - ustawienie danych, nie zapisywane w pamięci flash:

AT+CIPSTA_DEF - (format: AT+CIPSTA_DEF=<IP>,[gateway],[netmask])) - ustawienie danych, zapisuje zmiany w pamięci flash:

AT+CIPAP - (format: AT+CIPAP=<IP>,[<gateway>],[<netmask>]) - komenda ma taką samą składnię co funckje AT+CIPSTA. Służy natomiast do ustawiania adresu IP dla urządzenia osobnego, nie będącego w trybie klienta.

AT+CIPAP_DEF - (format: AT+CIPAP_DEF=<IP>,[<gateway>],[<netmask>]) - ustawienie z zapisem danych do pamięci flash.

1. //===================================================================================================================================
2. /*
3.  * Format AT+CIPAP="IP",["GATEWAY"],["NETMASK"]
4.  * check: 1 AT+CIPAP
5.  *        2 AT+CIPAP
6.  *        3 AT+CIPAP_CUR
7.  *        4 AT+CIPAP_CUR
8.  *        5 AT+CIPAP_DEF
9.  *        6 AT+CIPAP_DEF
10.  */
11. uint8_t Set_Soft_IP_Data(uint8_t *ESP8266_IP, uint8_t *ESP8266_NetMask, uint8_t *ESP8266_Gateway, uint8_t check)
12. {
13.     char data[50];
15.     if(1 == check)              //Set only IP
16.     {
17.         sprintf(data, "AT+CIPAP=\"%u.%u.%u.%u\"", ESP8266_IP[0], ESP8266_IP[1], ESP8266_IP[2], ESP8266_IP[3]);
18.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
19.         return Stat_OK;
20.     }
21.     else if(2 == check)         //Set all param
22.     {
23.         sprintf(data, "AT+CIPAP=\"%u.%u.%u.%u\",\"%u.%u.%u.%u\",\"%u.%u.%u.%u\"",
24.                 ESP8266_IP[0],      ESP8266_IP[1],      ESP8266_IP[2],      ESP8266_IP[3],
25.                 ESP8266_NetMask[0], ESP8266_NetMask[1], ESP8266_NetMask[2], ESP8266_NetMask[3],
26.                 ESP8266_Gateway[0], ESP8266_Gateway[1], ESP8266_Gateway[2], ESP8266_Gateway[3]);
27.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
28.         return Stat_OK;
29.     }
30. #if  Init_Cur_Commands == 1
31.     else if(3 == check)             //Set only IP
32.     {
33.         sprintf(data, "AT+CIPAP_CUR=\"%u.%u.%u.%u\"", ESP8266_IP[0], ESP8266_IP[1], ESP8266_IP[2], ESP8266_IP[3]);
34.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
35.         return Stat_OK;
36.     }
37.     else if(4 == check)         //Set all param
38.     {
39.         sprintf(data, "AT+CIPAP_CUR=\"%u.%u.%u.%u\",\"%u.%u.%u.%u\",\"%u.%u.%u.%u\"",
40.                 ESP8266_IP[0],      ESP8266_IP[1],      ESP8266_IP[2],      ESP8266_IP[3],
41.                 ESP8266_NetMask[0], ESP8266_NetMask[1], ESP8266_NetMask[2], ESP8266_NetMask[3],
42.                 ESP8266_Gateway[0], ESP8266_Gateway[1], ESP8266_Gateway[2], ESP8266_Gateway[3]);
43.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
44.         return Stat_OK;
45.     }
46. #endif
47. #if  Init_Def_Commands == 1
48.     else if(5 == check)             //Set only IP
49.     {
50.         sprintf(data, "AT+CIPAP_DEF=\"%u.%u.%u.%u\"", ESP8266_IP[0], ESP8266_IP[1], ESP8266_IP[2], ESP8266_IP[3]);
51.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
52.         return Stat_OK;
53.     }
54.     else if(6 == check)         //Set all param
55.     {
56.         sprintf(data, "AT+CIPAP_DEF=\"%u.%u.%u.%u\",\"%u.%u.%u.%u\",\"%u.%u.%u.%u\"",
57.                 ESP8266_IP[0],      ESP8266_IP[1],      ESP8266_IP[2],      ESP8266_IP[3],
58.                 ESP8266_NetMask[0], ESP8266_NetMask[1], ESP8266_NetMask[2], ESP8266_NetMask[3],
59.                 ESP8266_Gateway[0], ESP8266_Gateway[1], ESP8266_Gateway[2], ESP8266_Gateway[3]);
60.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
61.         return Stat_OK;
62.     }
63. #endif
64.     return Stat_Error;
65. }

AT+CWSTARTSMART - (format: AT+CWSTARTSMART=[1..3]) - jest to tzw. Smart Config. Jest on dopuszczalny tylko w trybie stacjonarnym. Pozwala on na ustawienie odpowiedniego protokołu dostępu do urządzenia.

Parametrem może być wartość od 1 do 3 gdzie: 1 oznacza ESP-TOUCH, 2 to AirKiss 3 natomiast to ESP-Touch + AirKiss

Dzięki nim można dokonać połączenie z dedykowanymi programami.

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

AT+CWSTOPSMART - (format: AT+CWSTOPSMART) - wymagane po użyciu komendy StartSmart. Pozwala na zwolnienie zajętej pamięci przez tą operację. Należy stosować zanim zostaną wywołane inne komendy AT.

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

AT+CWSTARTDISCOVER - (format: AT+CWSTARTDISCOVER=<WeChat number>,<dev_type>,<time>) - rozpoczyna działanie trybu w którym ESP może zostać znalezione za pomocą aplikacji WeChat.

Parametry to:

• numer nadawany przez WeChat
• typ urządzenia dostępny od WeChat
• jest to definicja interwału czasowego po jakim jest wysyłany pakiet danych do aplikacji

1. /*
2.  * Start the mode that ESP8266 can be found by WeChat
3.  * AT+CWSTARTDISCOVER
4.  */
5. uint8_t WeChat_Start_Discover(char *WeChat_number, char *dec_number, uint16_t time)
6. {
7.     char data[50];
9.     if(0 == time)
10.     {
11.         sprintf(data, "AT+CWSTARTDISCOVER=\"%s\",\"%s\",0", &WeChat_number[0], &dec_number[0]);
12.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
13.         return 1;
14.     }
15.     else if(time < 86400)
16.     {
17.         sprintf(data, "AT+CWSTARTDISCOVER=\"%s\",\"%s\",%u", &WeChat_number[0], &dec_number[0], time);
18.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
19.         return 1;
20.     }
21.     return 0;
22. }

AT+CWSTOPDISCOVER - (format: AT+CWSTOPDISCOVER) - zatrzymuje działanie trybu StartDiscover.

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

AT+WPS - (format: AT+WPS) - ustawia funkcje WPS. Nie wspiera WEP. Jako parametr podaje się albo 0 albo 1.

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

AT+MDNS - (format AT+MDNS=<enable>,<hostname>,<server_name>,<server_port>) - ustawia funkcje MDNS. W nazwach nie należy stosować kropek albo nazw jak http.

1. /*
2.  * Set MDNS function
3.  * AT+MDNS
4.  */
5. uint8_t MDNS_Function(uint8_t enable, char *hostname, char *server_name, uint16_t server_port)
6. {
7.     uint8_t length = 0;
8.     char data[50];
10.     while (&hostname[length] != '\0')
11.     {
12.         if(&hostname[length] == '.') { return 0; }
13.         length++;
14.     }
16.     length = 0;
18.     while (&server_name[length] != '\0')
19.     {
20.         if(&server_name[length] == '.') { return 0; }
21.         length++;
22.     }
24.     if(0 == enable)
25.     {
26.         sprintf(data, "AT+MDNS=0,\"%s\",\"%s\",%u", &hostname[0], &server_name[0], server_port);
27.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
28.         return 1;
29.     }
30.     else if(1 == enable)
31.     {
32.         sprintf(data, "AT+MDNS=1,\"%s\",\"%s\",%u", &hostname[0], &server_name[0], server_port);
33.         UART_SENDSTRING(ESP8266_USART, data, CR_LF);
34.         return 1;
35.     }
36.     return 0;
37. }

Następna część będzie zawierała komendy do TCP.