[12] STM32F7 - ESP8266 cz.1 Konfiguracja USART-u oraz podstawowe komendy

Poniżej chciałbym przedstawić kod obsługujący ESP8266 po komendach AT na płytce STM32F7 Discovery. Dane przesyłane są przez UART, ja wybrałem UART7. Testowanie układu odbyło się na module ESP-WROOM-02.

Rys. 1. Układ ESP-WROOM-02 [elty]

Jeśli projekt był wygenerowany wcześniej przy użyciu CubeMx z wybraną opcją dla płytki discovery, to należy pamiętać, że cube automatycznie przypisuje te piny (PF7 oraz PF6) jako piny analogowe. Dlatego należy albo wyłączyć te ustawienia bezpośrednio w kodzie, bądź w środowisku graficznym, lub, trochę mniej elegancko, dodać inicjalizacje tych pinów po włączeniu wszystkich GPIO.

Pełną listę komend wraz z ich zastosowaniem można znaleźć w tym dokumencie.

Na testowanym przeze mnie module nie wszystkie komendy działały. Całość będę jeszcze testował na zmienionej wersji oprogramowania, bądź jeśli to nie przyniesie efektu to na nowym układzie.

Konfiguracja UARTu:

Tą część postu poświęcę na opisanie konfiguracji dwóch układów USART1 oraz UART7. USART1 jest podłączony do konwertera umieszczonego na płytce discovery, co oznacza, że aby wykonać połączenie należy tylko podłączyć kabel USB do komputera. Oczywiście po wcześniejszym skonfigurowaniu. Ja będę go wykorzystywał do przesyłania wyświetlania danych odebranych od ESP. UART7 natomiast będzie podłączony do układu ESP.

Ustawienie UART'a:

1. void INIT_UART7(void)
2. {
3.     GPIO_InitTypeDef gpio_init_structure;
4.     __HAL_RCC_GPIOF_CLK_ENABLE();
5.     __HAL_RCC_UART7_CLK_ENABLE();
6.     __HAL_RCC_UART7_FORCE_RESET();
7.     __HAL_RCC_UART7_RELEASE_RESET();
8.     gpio_init_structure.Pin = USART7_TX2;
9.     gpio_init_structure.Mode = GPIO_MODE_AF_PP;
10.     gpio_init_structure.Speed = GPIO_SPEED_FAST;
11.     gpio_init_structure.Pull = GPIO_PULLUP;
12.     gpio_init_structure.Alternate = GPIO_AF8_UART7;
13.     HAL_GPIO_Init(USART7_GPIOF, &gpio_init_structure);
14.     // GPIO RX
15.     gpio_init_structure.Pin = USART7_RX2;
16.     gpio_init_structure.Mode = GPIO_MODE_AF_PP;
17.     gpio_init_structure.Pull = GPIO_PULLUP;
18.     gpio_init_structure.Alternate = GPIO_AF8_UART7;
19.     HAL_GPIO_Init(USART7_GPIOF, &gpio_init_structure);
20.     UART_Handle7.Instance = UART7;
21.     UART_Handle7.Init.BaudRate = USART7_BAUD;
22.     UART_Handle7.Init.WordLength = UART_WORDLENGTH_8B;
23.     UART_Handle7.Init.StopBits = UART_STOPBITS_1;
24.     UART_Handle7.Init.Parity = UART_PARITY_NONE;
25.     UART_Handle7.Init.HwFlowCtl = UART_HWCONTROL_NONE;
26.     UART_Handle7.Init.Mode = UART_MODE_TX_RX;
27.     UART_Handle7.Init.OverSampling = UART_OVERSAMPLING_8;
28.     UART_Handle7.Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED;
29.     UART_Handle7.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
30.     HAL_UART_Init(&UART_Handle7);
31.     HAL_NVIC_DisableIRQ(UART7_IRQn);
32.     HAL_NVIC_SetPriority(UART7_IRQn, 0, 1);
33.     HAL_NVIC_EnableIRQ(UART7_IRQn);
34.     HAL_NVIC_ClearPendingIRQ(UART7_IRQn);
35.     __HAL_UART_ENABLE_IT(&UART_Handle7, UART_IT_RXNE);
36.     UART7->CR1 |= USART_CR1_RXNEIE;
37. }

Funkcja wysyłająca pojedynczy bajt danych:

1. uint8_t UART_SENDBYTE(USART_TypeDef* USARTx, uint8_t data)
2. {
3.     if(USARTx == USART1) { HAL_UART_Transmit(&UART_Handle1, &data, 1, UART_TX_TIMEOUT); return 1; }
4.     else if(USARTx == USART2){ HAL_UART_Transmit(&UART_Handle2, &data, 1, UART_TX_TIMEOUT); return 1; }
5.     else if(USARTx == USART3){ HAL_UART_Transmit(&UART_Handle3, &data, 1, UART_TX_TIMEOUT); return 1; }
6.     else if(USARTx == UART4) { HAL_UART_Transmit(&UART_Handle4, &data, 1, UART_TX_TIMEOUT); return 1; }
7.     else if(USARTx == UART5) { HAL_UART_Transmit(&UART_Handle5, &data, 1, UART_TX_TIMEOUT); return 1; }
8.     else if(USARTx == USART6){ HAL_UART_Transmit(&UART_Handle6, &data, 1, UART_TX_TIMEOUT); return 1; }
9.     else if(USARTx == UART7) { HAL_UART_Transmit(&UART_Handle7, &data, 1, UART_TX_TIMEOUT); return 1; }
10.     else if(USARTx == UART8) { HAL_UART_Transmit(&UART_Handle8, &data, 1, UART_TX_TIMEOUT); return 1; }
11.     return 0;
12. }

Wywołanie funkcji następuje poprzez podanie w parametrze wykorzystywanego UARTu, po czym dane są wysyłane wykorzystując funkcje z biblioteki HAL'a. Można też wykorzystać drugi sposób przesyłania pojedynczego znaku określony na rejestrach. W tym przypaku przygotowana została funkcja z parametrami static inline w celu szybszego wywoływania. Można ją zdefiniować bezpośrednio w bibliotece dla USARTu:

1. static inline void USART_PUT_CHAR(USART_TypeDef* USARTx, volatile char c)
2. {
3.     if ((USARTx->CR1 & USART_CR1_UE))
4.     {
5.         while (!((USARTx)->ISR & USART_FLAG_TXE)); //Czekaj az bufor bedzie oprozniony
6.         ((USARTx)->TDR = ((uint16_t)(c & 0x01FF))); //wyslij dane
7.         while (!((USARTx)->ISR & USART_FLAG_TXE)); //czekaj na gotowosc bufor oprozniany
8.     }
9. }

Wysyłanie ciągu znaków odbywa się w następujący sposób:

1.     void UART_SENDSTRING(USART_TypeDef* USARTx, char *ptr, UART_BYTEEND_t last_char)
2.     {
3.       uint16_t length = 0;
4.       while (ptr[length] != '\0') { length++; }   //Sprawdzanie ilości danych
5.       //Wyslanie calego stringa
6.       if(USARTx == USART1) { HAL_UART_Transmit(&UART_Handle1, (uint8_t*)(ptr), length, UART_TX_TIMEOUT); }
7.       else if(USARTx == USART2) { HAL_UART_Transmit(&UART_Handle2, (uint8_t*)(ptr), length, UART_TX_TIMEOUT); }
8.       else if(USARTx == USART3) { HAL_UART_Transmit(&UART_Handle3, (uint8_t*)(ptr), length, UART_TX_TIMEOUT); }
9.       else if(USARTx == UART4) { HAL_UART_Transmit(&UART_Handle4, (uint8_t*)(ptr), length, UART_TX_TIMEOUT); }
10.       else if(USARTx == UART5) { HAL_UART_Transmit(&UART_Handle5, (uint8_t*)(ptr), length, UART_TX_TIMEOUT); }
11.       else if(USARTx == USART6) { HAL_UART_Transmit(&UART_Handle6, (uint8_t*)(ptr), length, UART_TX_TIMEOUT); }
12.       else if(USARTx == UART7) { HAL_UART_Transmit(&UART_Handle7, (uint8_t*)(ptr), length, UART_TX_TIMEOUT); }
13.       else if(USARTx == UART8) { HAL_UART_Transmit(&UART_Handle8, (uint8_t*)(ptr), length, UART_TX_TIMEOUT); }
14.       //Wyslanie ostatniej linii
15.       if(last_char==LF_CR)
16.       {
17.           UART_SENDBYTE(USARTx, d_LINEFEED);
18.           UART_SENDBYTE(USARTx, d_CARIAGERETURN);
19.       }
20.       else if(last_char==CR_LF)
21.       {
22.           UART_SENDBYTE(USARTx, d_CARIAGERETURN);
23.           UART_SENDBYTE(USARTx, d_LINEFEED);
24.       }
25.       else if(last_char==LF_)
26.       {
27.           UART_SENDBYTE(USARTx, d_LINEFEED);
28.       }
29.       else if(last_char==CR_)
30.       {
31.           UART_SENDBYTE(USARTx, d_CARIAGERETURN);
32.       }
33.     }

Najpierw sprawdzana jest wielkość podanego stringa. Następnie w zależności od podanego USARTu obsługiwany jest odpowiedni handler. Na samym końcu wybierany jest bajt kończący transmisje.

Teraz przesyłanie ciągu znaków w oparciu o funkcje przygotowaną na rejestrach:

1.     void UART_SEND_STRING(USART_TypeDef* USARTx, char *ptr, UART_BYTEEND_t last_char)
2.     {
3.       uint16_t length = 0;
4.       //Sprawdzanie wielkosci danych
5.       while (ptr[length] != '\0')
6.       {
7.           USART_PUT_CHAR(USARTx, &ptr[length]); length++;
8.       }
9.       if(last_char==LF_CR)
10.       {
11.           USART_PUT_CHAR(USARTx, (char)d_LINEFEED);
12.           USART_PUT_CHAR(USARTx, (char)d_CARIAGERETURN);
13.       }
14.       else if(last_char==CR_LF)
15.       {
16.           USART_PUT_CHAR(USARTx, (char)d_CARIAGERETURN);
17.           USART_PUT_CHAR(USARTx, (char)d_LINEFEED);
18.       }
19.       else if(last_char==LF_)
20.       {
21.           USART_PUT_CHAR(USARTx, (char)d_LINEFEED);
22.       }
23.       else if(last_char==CR_)
24.       {
25.           USART_PUT_CHAR(USARTx, (char)d_CARIAGERETURN);
26.       }
27.     }

Jeśli połączenie będzie wykonywane przez konwerter UART-USB oraz program komunikacyjny np. Terminal to jego ustawiania muszą wyglądać następująco:

Prędkość transmisji 115200, 8 bitów danych, bez bitu parzystości, jeden bit stopu. Dla transmisji musi być zaznaczona opcja CR=CR+LF, oraz sam checkbox CR musi zostać zaznaczony. Pozwoli to na wysłanie znaków \r\n do układu ESP.

Funkcje obsługujące ESP:

Poniżej przejdę przez wszystkie zaimplementowane funkcje. Przedstawiony będzie opis oraz struktura komendy wraz z fragmentem kodu, który jest odpowiedzialny za jej implementację.

Funkcje podzieliłem głównie na takie, które uzyskują tylko informacje od układu. Druga grupa natomiast wpływa na ustawienia. Sama druga grupa komend została podzielona na komendy podstawowe, komendy wifi oraz komendy TCP-IP.

Pierwsza grupa sprawdza ustawienia, większość z nich jeszcze będzie powtórzona w części ustawiającej tryby pracy dlatego tutaj przedstawię tylko opis komend które pojawią się jeden raz.

Komenda musi być zakończona znakiem powrotu karetki (\r) po czym musi pojawić się znak przejścia do nowej linii (\n).

Na samym początku przedstawienie funkcje odpowiedzialną za przesyłanie komend przygotowanych przez użytkownika, nie zdefiniowanych w bibliotece.

1.     /*
2.      * Send custom command or data to server
3.      */
4.     void Send_Data_To_Server(char *ptr)
5.     {
6.         UART_SENDSTRING(ESP8266_USART, (ptr), CR_LF);
7.     }
8.     //Wywołanie    Send_Custom_Command("AT+RST");

Zawiera ono odwołanie do funkcji przesyłającej dane po UART.

Komendy podstawowe:

AT+CIOBAUD - (format: AT+CIOBAUD=<param>) - ustawienie prędkości transmisji. Ta komenda nie jest obsługiwana przez wykorzystywany przezemnie moduł.

1. case Command_AT_CIOBAUD:
2. if(data != 0)
3. {
4.     sprintf(dane, "AT+CIOBAUD=%u", data);
5.     UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
6. }
7. break;

AT - (format: AT) - Sprawdzenie komunikacji z modułem. Jeśli komunikacja jest wporządku, to w odpowiedzi wysyłana jest odpowiedź OK.

1.             //Check communication
2.             //Response: OK
3.             case Command_AT:
4.                 UART_SENDSTRING(ESP8266_USART, "AT", CR_LF);
5.             break;

AT+RST - (format: AT+RST) - reset modułu.

1.             //Reset ESP
2.             //Response: OK
3.             case Command_AT_RST:
4.                 UART_SENDSTRING(ESP8266_USART, "AT+RST", CR_LF);
5.             break;

Po resecie moduł przesyła następujące informacje:

AT+GMR - (format: AT+GMR) - Wyświetlenie wersji oprogramowania.

W odpowiedzi wysyłane są następujące dane:

Odpowiedź składa się z informacji na temat wersji komend AT, informacji o SDK oraz kiedy nastąpiła ostatnia kompilacja.

AT+GSLP - (format: AT+GSLP=<time>) - wejście w tryb głębokiego uśpienia. Jako parametr podawany jest czas uśpienia w ms. Moduł zostanie wybudzony po określonym czasie. Aby działało to poprawnie należy połączyć XPDC_DCDC z EXT_RSTB za pomocą rezystora 0 ohm. Dodatkowo pin od resetu musi być ustawiony w stan wysoki.

1.         case Command_AT_GSLP:
2.             if(data != 0)
3.             {
4.                 sprintf(dane, "AT+GSLP=%u", data);
5.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
6.             }
7.         break;

ATE - (format ATE0 lub ATE1) - Włączenie (ATE1) bądź wyłączenie(ATE0) echa. Przy włączonym będzie on odbierał wszystko co mu wyślemy i przesyłał to ponownie, bez włączonego w odpowiedzi będą wysyłane tylko wiadomości od ESP.

1.         //Enable/Disable Echo, two commands ATE0 (Disable), ATE1 (Enable)
2.         //Response:OK
3.         case Command_AT_ATE:
4.             if(0 == param)      {   UART_SENDSTRING(ESP8266_USART, "ATE0", CR_LF);  }
5.             else if(1 == param) {   UART_SENDSTRING(ESP8266_USART, "ATE1", CR_LF);  }
6.         break;

AT+RESTORE - (format: AT+RESTORE) - resetowanie wszystkich parametrów jakie są zapisane w pamięci flash. Moduł przechodzi w tryb ustawień fabrycznych.

1.         //Factory reset, clear data in flash memmory
2.         //Response: Module reset
3.         case Command_AT_RESTORE:
4.             UART_SENDSTRING(ESP8266_USART, "AT+RESTORE", CR_LF);
5.         break;

AT+UART - (format: AT+UART=[baudrate],[databits],[stopbits],[parity],[flowcontrol]) - komenda ta służy do ustawienia prędkości transmisji dla ESP. Dopuszczalne parametry to:

• Baudrate - od 110 do 115200*40(4.608 Mega)
• Databits - bity danych parametr od 5 do 8. Wartość 5 odpowiada 5 bitom danych itd.
• StopBits - bity stopu. Dopuszczalne parametry to 1 (1 bit stopu), 2(1,5 bit) oraz 3(2 bit stopu).
• Parity - bity parzystości. Parametr 0(bez bitów stopu), 1(Odd), 2(Even)
• FlowControl - kontrola przepływu danych. Parametr 0(wyłączone), 1(włączony RTS), 2(włączony CTS) oraz 3(włączony RTS oraz CTS).

Dane przesłane przez tą komendę będą przechowywane w pamięci Flash. Kontrola przepływu danych musi być wspierana przez połączenia sprzętowe. Pin MTCK to UART CTS, MTDO to RTS.

Poniżej funkcja przesyłająca odpowiednie parametry:

1. typedef enum{
2.     Wifi_Mode_Disable   = 0,
3.     Wifi_Mode_Light,
4.     Wifi_Mode_Modem
5. }Wifi_Sleep_Mode;
7. //----------------------------------------------------------------------------------------------
9. typedef enum{
10.     Wifi_Mode_Station       = 1,
11.     Wifi_Mode_Ap            = 2,
12.     Wifi_Mode_Ap_Station    = 3
13. }Wifi_Mode_CWMODE;
15. //----------------------------------------------------------------------------------------------
17. typedef enum{
18.     Wifi_Baudrate_4800 = 4800,
19.     Wifi_Baudrate_9600 = 9600,
20.     Wifi_Baudrate_14400 = 14400,
21.     Wifi_Baudrate_19200 = 19200,
22.     Wifi_Baudrate_38400 = 38400,
23.     Wifi_Baudrate_115200 = 115200
24. }UART_Wifi_Config_Baudrate_e;
26. //----------------------------------------------------------------------------------------------
28. typedef enum{
29.     Wifi_DataBits_5 = 5,
30.     Wifi_DataBits_6,
31.     Wifi_DataBits_7,
32.     Wifi_DataBits_8
33. }UART_Wifi_Config_DataBits_e;
35. //----------------------------------------------------------------------------------------------
37. typedef enum{
38.     Wifi_StopBit_1 = 1,
39.     Wifi_StopBit_1_5,
40.     Wifi_StopBit_2
41. }UART_Wifi_Config_StopBits_e;
43. //----------------------------------------------------------------------------------------------
45. typedef enum{
46.     Wifi_Parity_None = 0,
47.     Wifi_Parity_Odd,
48.     Wifi_Parity_Even
49. }UART_Wifi_Config_Parity_e;
51. //----------------------------------------------------------------------------------------------
53. typedef enum{
54.     Wifi_FlowControl_Off = 0,
55.     Wifi_FlowControl_RTS,
56.     Wifi_FlowControl_CTS,
57.     Wifi_FlowControl_Both
58. }UART_Wifi_Config_Flow_Control_e;
60. //----------------------------------------------------------------------------------------------
62. typedef struct{
63.     UART_Wifi_Config_Baudrate_e         Wifi_Baudrate;
64.     UART_Wifi_Config_DataBits_e         Wifi_DataBits;
65.     UART_Wifi_Config_StopBits_e         Wifi_StopBits;
66.     UART_Wifi_Config_Parity_e           Wifi_Parity;
67.     UART_Wifi_Config_Flow_Control_e     Wifi_FlowControl;
68. }UART_Wifi_Config_t;
70. void Set_Uart_Baudrate(UART_Wifi_Config_t *Wifi_Uart_Configuration)
71. {
72.     char data[50] = {0};
74.     sprintf(data, "AT+UART=%d,%d,%d,%d,%d",
75.             Wifi_Uart_Configuration->Wifi_Baudrate, Wifi_Uart_Configuration->Wifi_DataBits, Wifi_Uart_Configuration->Wifi_StopBits
76.             , Wifi_Uart_Configuration->Wifi_Parity, Wifi_Uart_Configuration->Wifi_FlowControl);
78.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
79. }
81. void Set_Uart_Structure(UART_Wifi_Config_t *Wifi_Uart_Configuration, UART_Wifi_Config_Baudrate_e Baudrate,
82.                         UART_Wifi_Config_DataBits_e DataBits, UART_Wifi_Config_StopBits_e StopBits,
83.                         UART_Wifi_Config_Parity_e Parity, UART_Wifi_Config_Flow_Control_e FlowControl)
84. {
85.     Wifi_Uart_Configuration->Wifi_Baudrate      = Baudrate;
86.     Wifi_Uart_Configuration->Wifi_DataBits      = DataBits;
87.     Wifi_Uart_Configuration->Wifi_StopBits      = StopBits;
88.     Wifi_Uart_Configuration->Wifi_Parity        = Parity;
89.     Wifi_Uart_Configuration->Wifi_FlowControl   = FlowControl;
90. }

Parametry zdefiniowałem w osobnej strukturze, która pobiera dane z typów wyliczeniowych. Dzięki temu mam kontrolę nad podawanym parametrem.

Po takim ustawieniu należy pamiętać o zmianie konfiguracji UART-u dla STM-a. W nim najpierw wyłączam zegary po czym zmieniam konfigurację UARTa i ponownie go włączam.

AT+UART_CUR - (format: AT+UART_CUR=[baudrate],[databits],[stopbits],[parity],[flowcontrol]) - działa ona na tej samej zasadzie co AT+UART różnica natomiast polega na tym, że nie wprowadza ona zmian danych do pamięci flash. Zmiany są zachowywane do resetu urządzenia.

1. void Set_Uart_Baudrate_Current(UART_Wifi_Config_t *Wifi_Uart_Configuration)
2. {
3.     char data[50] = {0};
5.     sprintf(data, "AT+UART_CUR=%d,%d,%d,%d,%d",
6.             Wifi_Uart_Configuration->Wifi_Baudrate, Wifi_Uart_Configuration->Wifi_DataBits, Wifi_Uart_Configuration->Wifi_StopBits
7.             , Wifi_Uart_Configuration->Wifi_Parity, Wifi_Uart_Configuration->Wifi_FlowControl);
9.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
10. }

AT+UART_DEF - (format: AT+UART_DEF=[baudrate],[databits],[stopbits],[parity],[flowcontrol]) - działa na takiej samej zasadzie co AT+UART.

1. void Set_Uart_Baudrate_Default(UART_Wifi_Config_t *Wifi_Uart_Configuration)
2. {
3.     char data[50] = {0};
5.     sprintf(data, "AT+UART_DEF=%d,%d,%d,%d,%d",
6.             Wifi_Uart_Configuration->Wifi_Baudrate, Wifi_Uart_Configuration->Wifi_DataBits, Wifi_Uart_Configuration->Wifi_StopBits
7.             , Wifi_Uart_Configuration->Wifi_Parity, Wifi_Uart_Configuration->Wifi_FlowControl);
9.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
10. }

AT+SLEEP - (format: AT+SLEEP=[0..2]) - ustawienie trybu uśpienia. Możliwy do użytku tylko w trybie klienta. Do wyboru są opcje 0(tryb wyłączony), 1(light-sleep mode) oraz 2(modem sleep mode). Domyślnie producent ustawia urządzenie w tryb 2.

1.         //Set EPS into sleep mode,
2.         //Response: OK
3.         case Command_AT_SLEEP:
4.             if(Wifi_Mode_Disable == param || Wifi_Mode_Light == param || Wifi_Mode_Modem == param)
5.             {
6.                 sprintf(dane, "AT+SLEEP=%u", param);
7.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
8.             }
9.             break;

AT+WAKEUPGPIO - (format: AT+WAKEUPGPIO=[enable],[trigger_GPIO],[trigger_level],[awake_GPIO],[awake_level]) - służy do ustalenia który pin ma wybudzać ESP. Działa z trybem light-sleep. Należy pamiętać, że parametry trigger_GPIO oraz awake_GPIO muszą się od siebie różnić. Nie można podać tego samego pinu. Wartości awake_GPIO oraz awake_level są parametrami opcjonalnymi.

Parametry:

• enable - wprowadzenie 0 powoduje że nie można wybudzić układu, wartość 1 włącza tryb wybudzenia.
• trigger_gpio - pin GPIO, który będzie powodował wybudzenie.
• trigger_level - wybranie poziomu wybudzenia, podanie 0 stan niski, podanie 1 stan wysoki
• awake_gpio - pin który jest odpowiednio ustawiany po wybudzeniu
• awake_level - poziom na jaki ma być pin ustawiony. Wartość 0 odpowiada stanu niskiemu, 1 to stan wysoki.

1. typedef enum{
2.     Gpio_WakeUp_Pin_0 = 0,
3.     Gpio_WakeUp_Pin_1 = 1,
4.     Gpio_WakeUp_Pin_2 = 2,
5.     Gpio_WakeUp_Pin_3 = 3,
6.     Gpio_WakeUp_Pin_4 = 4,
7.     Gpio_WakeUp_Pin_5 = 5,
8.     Gpio_WakeUp_Pin_12 = 12,
9.     Gpio_WakeUp_Pin_13 = 13,
10.     Gpio_WakeUp_Pin_14 = 14,
11.     Gpio_WakeUp_Pin_15 = 15
12. }ESP8266_Gpio_WakeUp_Pin_e;
14. /*
15.  * Set WakeUp Gpio
16.  */
17. uint8_t ESP8266_WakeUpGpio(uint8_t Enable, ESP8266_Gpio_WakeUp_Pin_e Pin,
18.                         uint8_t Trigger_Level, ESP8266_Gpio_WakeUp_Pin_e Pin_awake, uint8_t Awake_level )
19. {
20.     char data[30] = {0};
22.     if(Pin == Pin_awake)                                {   return Stat_Error;  }
23.     else if(Enable != 0 || Enable != 1)                 {   return Stat_Error;  }
24.     else if(Trigger_Level != 0 || Trigger_Level != 1)   {   return Stat_Error;  }
25.     else if(Awake_level != 0 || Awake_level != 1)       {   return Stat_Error;  }
27.     sprintf(data, "AT+WAKEUPGPIO=%u,%d,%u,%d,%u", Enable, Pin, Trigger_Level, Pin_awake, Awake_level);
28.     UART_SENDSTRING(ESP8266_USART, data, CR_LF);
29.     return Stat_OK;
30. }

Powyższa funkcja najpierw sprawdza poprawność podanych danych, następnie przygotowuje bufor i przesyła go do układu.

AT+RFPOWER - (format: AT+RFPOWER=[TX_Power]) - ustawienie wzmocnienia dla RF TX. Parametr TX power może przyjmować dane pomiędzy 0 a 82. Pojedyncza wartość oznacza zmianę o 0.25dBm.

1.         //Set value of RF TX power, not precise
2.         //Param: 0 to 82
3.         //Response: OK
4.         case Command_AT_RFPower:
5.             if((param >= 0) || (param <= 82))
6.             {
7.                 sprintf(dane, "AT+SLEEP=%u", param);
8.                 UART_SENDSTRING(ESP8266_USART, dane, CR_LF);
9.             }
10.             break;

Pozostałe komendy zostaną udostępnione w następnych postach.