- Requisitos
- Diagrama de Circuito do Modo Sleep ESP32
- Visão geral dos modos de dormir no ESP32
- Programação ESP32 para modo de sono profundo
- Testando ESP32 no modo Deep Sleep
ESP32 é um dos mais populares módulos de microcontrolador baseado em Wi-Fi e é uma escolha popular em muitos aplicativos portáteis de IoT. É um controlador poderoso que suporta Programação Dual Core e também possui suporte embutido de Bluetooth Low Energy (BLE), tornando-o uma boa escolha para aplicativos portáteis como dispositivos iBeacon, Rastreadores GPS, etc. No entanto, em aplicativos alimentados por bateria como estes, a principal preocupação é o backup de bateria. Este backup de bateria pode ser aumentado por um controle mais inteligente sobre a unidade do microcontrolador, como se fosse possível programar o ESP32 no modo de espera durante a condição ideal para aumentar o backup de bateria do dispositivo.
Neste projeto, verificaremos o consumo atual da unidade de microcontrolador ESP32, amplamente popular, com Wi-Fi e Bluetooth no modo de trabalho normal e no modo de suspensão profunda. Além disso, testaremos a diferença e verificaremos como colocar o ESP32 no modo de hibernação. Você também pode verificar o artigo sobre como minimizar o consumo de energia em microcontroladores para obter outras dicas que podem ser usadas para tornar seu projeto muito mais eficiente em termos de energia. Além disso, se você estiver interessado no modo de suspensão de outros microcontroladores, pode verificar o modo Arduino Sleep e o modo ESP8266 NodeMCU Sleep também.
Requisitos
Para fazer isso, usaremos o Devkit V4.0 baseado em ESP32 da Espressif que tem ponte USB para UART, bem como outras pinagens ESP32 para fácil conexão. A programação será feita com o IDE Arduino. Se você for completamente novo, para começar a usar o ESP32 usando o Arduino, leia o artigo vinculado antes de continuar.
Os requisitos deste projeto são os seguintes-
- Ele entrará no modo de hibernação ao pressionar um botão.
- Ele vai acordar do modo de hibernação pressionando outro botão.
- Para detectar o estado do ESP32, um LED piscará com um tempo de ativação de 1000 milissegundos. Durante o modo de hibernação, ele será desligado.
Portanto, componentes adicionais necessários
- LED - 1 pc
- Botão de pressão (interruptor tátil) - 2 peças
- Resistores de 4,7k - 2 pcs
- Resistor 680R - 1 pc
- Tábua de pão
- Fio de engate
- Adaptador de 5 V ou fonte de alimentação
- Um cabo micro USB
- Arduino IDE com interface de programação ESP32 em um PC ou laptop.
Diagrama de Circuito do Modo Sleep ESP32
O esquema para colocar o ESP32 para dormir com o botão de pressão é mostrado abaixo.
O esquema é muito simples. Possui dois botões. O botão de suspensão colocará o ESP32 no modo de suspensão profunda e outra chave será usada para acordar o ESP32 do modo de suspensão. Ambos os botões são conectados nos PINOS 16 e 33. Ambos os botões são configurados como ativos baixos quando pressionados, portanto, um pull-up adicional é fornecido. No entanto, para detectar se o ESP 32 está no modo de suspensão ou no modo de condição de trabalho normal, o LED é conectado ao Pino 4 de IO.
Visão geral dos modos de dormir no ESP32
Existem muitos modos de energia diferentes para ESP32, nomeadamente modo ativo, modo de hibernação do modem, modo de suspensão leve, modo de suspensão profunda e modo de hibernação.
Durante a condição normal de trabalho, o ESP32 funciona no modo ativo. Durante o modo ativo ESP32, a CPU, hardware WiFi / BT, memória RTC e periféricos RTC, coprocessadores ULP, todos são ativados e funcionam dependendo da carga de trabalho. No entanto, em diferentes modos de energia, um ou mais periféricos estão desligados. Para verificar as diferentes operações do modo de energia, siga a tabela abaixo-
|
Hardware |
Modo Ativo |
Modo de repouso do modem |
Modo de suspensão leve |
Modo de sono profundo |
Hibernação |
|
CPU |
EM |
EM |
PAUSA |
FORA |
FORA |
|
WiFi / BT |
EM |
FORA |
FORA |
FORA |
FORA |
|
Periféricos RTC e RTC |
EM |
EM |
EM |
EM |
FORA |
|
Processador ULP-Co |
EM |
EM |
EM |
LIGADO DESLIGADO |
FORA |
Como podemos ver na tabela acima, no modo de hibernação profunda ESP32, muitas vezes chamado de padrão monitorado do sensor ULP - a CPU, WiFi / BT, memória RTC e periféricos, coprocessadores ULP, todos estão desligados. Apenas a memória RTC e os periféricos RTC estão ligados.
Durante a situação de despertar, o ESP32 precisa ser notificado por uma fonte de despertar que despertará o ESP32 do modo de hibernação. No entanto, como os periféricos RTC estão ligados, o ESP32 pode ser ativado por GPIOs habilitados para RTC. Existem outras opções também. Ele pode ser ativado por meio de pinos de interrupção de ativação externos ou usando um temporizador para ativar o ESP32. Neste projeto, estamos usando ext0 wakeup no pino 33.
Programação ESP32 para modo de sono profundo
O programa completo pode ser encontrado no final desta página. Ele foi escrito para o IDE do Arduino e pode, portanto, ser facilmente adaptado aos seus requisitos. A explicação do código é a seguinte.
No início do código, // Cria uma variável PushButton PushBnt pushBtn = {GPIO_NUM_16, 0, false}; // define Led Pin uint8_t led_pin = GPIO_NUM_4; // define o pino de ativação uint8_t wakeUp_pin = GPIO_NUM_33;
As três linhas acima definem o pino de ativação, o pino do LED e o pino do modo de suspensão.
void setup () { // coloque seu código de configuração aqui, para ser executado uma vez: // defina a porta serial em 115200 Serial.begin (115200); atraso (1000); // define o pino pushButton como entrada com pullUp pinMode interno (pushBtn.pin, INPUT_PULLUP); // define o manipulador de interrupção com o pino pushButton no modo Falling attachInterrupt (pushBtn.pin, isr_handle, FALLING); // define o pino do Led como saída pinMode (led_pin, OUTPUT); // cria uma tarefa que será executada na função blinkLed (), com prioridade 1 e executada no núcleo 0 xTaskCreate ( blinkLed, / * Função da tarefa. * / "blinkLed", / * nome da tarefa. * / 1024 * 2, / * Tamanho da pilha da tarefa * / NULL, / * parâmetro da tarefa * / 5, / * prioridade da tarefa * / & taskBlinkled); / * Identificador de tarefa para controlar a tarefa criada * / delay (500); // Configure o Pin 33 como fonte de ativação ext0 com nível lógico BAIXO esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0); }
Acima, a interrupção é definida para um modo descendente pelo trecho de código
attachInterrupt (pushBtn.pin, isr_handle, FALLING);
Portanto, sempre que a chave for pressionada, o nível lógico será alterado da lógica 1 (3,3 V) para a lógica 0 (0 V). A tensão do pino do botão cairá e o ESP32 identificará que o interruptor foi pressionado. Também existe uma tarefa criada para piscar o LED.
xTaskCreate ( blinkLed, / * Função da tarefa. * / "blinkLed", / * nome da tarefa. * / 1024 * 2, / * Tamanho da pilha da tarefa * / NULL, / * parâmetro da tarefa * / 5, / * prioridade da tarefa * / & taskBlinkled); / * Identificador de tarefa para controlar a tarefa criada * / delay (500);
O pino 33 também é configurado usando o fragmento de código abaixo como uma fonte de ativação externa identificada como ext0.
esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0);
Em seguida, no loop while-
void loop () { // coloque seu código principal aqui, para executar repetidamente: if (pushBtn.pressed) { Serial.printf ("PushButton (% d) Pressed \ n", pushBtn.pin); Serial.printf ("Suspender a tarefa 'blinkLed' \ n"); // Suspender a tarefa blinkLed vTaskSuspend (taskBlinkled); digitalWrite (led_pin, LOW); Serial.printf ("Indo dormir….. \ n", pushBtn.pin); pushBtn.pressed = false; // Vá dormir agora esp_deep_sleep_start (); } esp_sleep_wakeup_cause_t wakeupReason; wakeupReason = esp_sleep_get_wakeup_cause (); switch (wakeupReason) { case ESP_SLEEP_WAKEUP_EXT0: Serial.println ("usando sinal externo ext0 para WakeUp From sleep"); pausa; case ESP_SLEEP_WAKEUP_EXT1: Serial.println ("usando sinal externo ext1 para WakeUp From sleep"); pausa; case ESP_SLEEP_WAKEUP_TIMER: Serial.println ("usando o sinal do temporizador para acordar do sono"); pausa; case ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println ("usando o sinal do TouchPad para acordar do modo de espera"); pausa; case ESP_SLEEP_WAKEUP_ULP: Serial.println ("usando sinal ULP para WakeUp From sleep"); pausa; padrão: break; Serial.printf ("Retomar a tarefa 'blinkLed' \ n"); // reinicie o blinkLed Task vTaskResume (taskBlinkled); } }
O loop while verifica constantemente se o botão sleep está pressionado ou não. Se o botão for pressionado, ele irá parar ou suspender a tarefa de piscar do LED e executar a função de início de sono profundo do esp-
esp_deep_sleep_start ();
Nesta situação, se o botão de interrupção externa ext0 for pressionado, ele irá imediatamente acordar do modo de hibernação e retomar a tarefa de piscar do led.
Por último, a função de piscar do LED pode ser vista nos trechos abaixo, ele piscará o LED por 1000 ms segundos.
void blinkLed (void * param) { while (1) { static uint32_t pin_val = 0; // alternar o valor do pino pin_val ^ = 1; digitalWrite (led_pin, pin_val); Serial.printf ("Led -----------------% s \ n", pin_val? "On": "Off"); / * Basta alternar o LED a cada 1000 ms ou 1 segundo * / vTaskDelay (1000 / portTICK_PERIOD_MS); } taskBlinkled = NULL; vTaskDelete (NULL); }
Testando ESP32 no modo Deep Sleep
O circuito é construído em uma placa de ensaio e um multímetro da edição Metravi XB é usado para medir a corrente. A corrente consumida pelo circuito no modo ativo é quase 58 mA, mas no modo hibernação, a corrente é quase 4,10 mA. A imagem abaixo mostra o consumo de corrente do modo ativo ESP32 -
No modo de sono profundo, o consumo de corrente é registrado e caiu para cerca de 3,95 mA, a imagem abaixo mostra o consumo de corrente do modo de sono profundo ESP32-
No entanto, no modo de suspensão profunda, o consumo atual do ESP32 é de quase 150 uA. Mas o consumo de corrente registrado para esta placa ESP32 Devkit é quase 4,10 mA. Isso se deve ao CP2102 e ao Regulador Linear. Esses dois estão conectados à linha de alimentação de 5V. Também há um LED de energia conectado na linha de energia que está consumindo quase 2mA de corrente.
Portanto, pode ser facilmente identificado que o ESP32 consome uma quantidade muito baixa de energia no modo de espera profunda, o que é muito útil para operações alimentadas por bateria. Para mais informações sobre como funcionou, confira o vídeo no link abaixo. Se você tiver alguma dúvida, deixe-as na seção de comentários abaixo ou use nossos Fóruns para outras questões técnicas.