Economizando bateria com repouso profundo: 20 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Você está interessado em usar uma bateria com o ESP32? Em caso afirmativo, estarei discutindo hoje algumas informações técnicas importantes sobre este assunto. Sabemos que este microcontrolador gasta muita energia ao transmitir informações. Consome cerca de 190 miliamperes. Neste vídeo, vou mostrar como conservar a energia do ESP32 com a função chamada "SLEEP PROFUNDO". Vamos configurar o chip para entrar neste modo, aprender as maneiras de sair desse modo e criar um exemplo mostrando três maneiras diferentes de despertar o ESP32.

É importante lembrar que o rádio gasta muita energia, ao invés do processador. A economia de energia é muito importante. Isso ocorre porque os terminais (os circuitos que enviam informações) geralmente são alimentados por bateria e devem durar até cinco anos. Existem alguns fabricantes que prometem até dez anos de duração, e isso é válido para baterias de alta qualidade que não usam tanto os Endpoints. Em todos os outros casos, aconselho você a usar o Deep Sleep para economizar energia do seu circuito.

Etapa 1: Introdução

O ESP32 tem um modo de economia de energia, chamado “Deep Sleep”. Nesse modo, as CPUs, a maioria da RAM e todos os periféricos com clock digital são desligados. As únicas partes do chip que ainda podem ser conectadas são o controlador RTC, os periféricos RTC (incluindo o coprocessador ULP) e as memórias RTC.

Temos várias maneiras de acordar o ESP32 durante o sono. As fontes de despertar podem ser configuradas a qualquer momento antes de entrar no modo Sono Profundo.

Etapa 2: maneiras de despertar o ESP32

Existem cinco maneiras de ativar o ESP32:

• Cronômetro

• Despertar externo (ext0)

• Despertar externo (ext1)

• Despertar do coprocessador ULP

• Touchpad

Etapa 3: cronômetro

O controlador RTC possui um temporizador embutido que pode ser usado para ativar o chip após um período de tempo predefinido. O tempo é especificado com precisão de microssegundos.

esp_deep_sleep_enable_timer_wakeup (uint64_t time_in_us)

time_in_us> é o tempo em microssegundos

Etapa 4: ativação externa (ext0)

O módulo RTC IO contém lógica para disparar o alarme quando um dos RTC GPIOs entra em um nível lógico predefinido. O RTC IO faz parte do domínio de potência dos periféricos RTC, portanto, os periféricos RTC serão mantidos ativos durante o Sono Profundo se essa fonte de ativação for solicitada.

esp_deep_sleep_enable_ext0_wakeup (gpio_num_t gpio_num, nível interno)

gpio_num> Número GPIO usado como fonte de ativação. Apenas GPIOs funcionais RTC podem ser usados: 0, 2, 4, 12-15, 25-27, 32-39.

nível> nível de entrada que irá disparar o alarme (0 = BAIXO, 1 = ALTO)

Etapa 5: ativação externa (ext1)

O controlador RTC contém lógica para acionar o despertador usando vários RTC GPIOs.

esp_deep_sleep_enable_ext1_wakeup (máscara uint64_t, modo esp_ext1_wakeup_mode_t)

máscara> máscara de bits de números GPIO que causarão a ativação. Apenas GPIOs habilitados para RTC podem ser usados neste bitmap: 0, 2, 4, 12-15, 25-27, 32-39.

modo> selecione a função lógica usada para determinar a condição de ativação:

• ESP_EXT1_WAKEUP_ALL_LOW: desperta quando todos os GPIOs selecionados estão em LOW

• ESP_EXT1_WAKEUP_ANY_HIGH: desperta quando qualquer um dos GPIOs selecionados são HIGH

Etapa 6: ativação do coprocessador ULP

O coprocessador ULP pode operar enquanto o chip está em Deep Sleep e pode ser usado para pesquisar sensores, monitorar ADC ou valores de sensor de toque capacitivo e ativar o chip quando um evento específico for detectado.

O coprocessador ULP faz parte do domínio de potência dos periféricos RTC e executa o programa armazenado na memória lenta RTC. Portanto, os periféricos RTC e a memória lenta RTC serão ativados durante o Sono Profundo se este modo de ativação for solicitado.

Etapa 7: Touchpad

O controlador RTC contém lógica para acionar o alarme usando os sensores de toque capacitivos. A definição do pino de toque, no entanto, é diferente. Devemos usar a interrupção de toque para cada um dos pinos desejados.

Depois de definir as interrupções, habilitamos o modo de despertar para usar os sensores.

// Configure o Touchpad como fonte de ativação esp_sleep_enable_touchpad_wakeup ();

Etapa 8: Entrando no Modo de Sono Profundo

Depois de definir um modo de despertar, um único comando para colocar o ESP32 no modo Sono Profundo (gastando 2,5 μA ou menos) é suficiente. Enfatizo aqui que esse gasto é proveniente do chip ESP e não da placa, pois esta última gasta mais.

esp_deep_sleep_start ();

A partir desse comando, o ESP32 adormece e não executa as próximas linhas de código, por exemplo.

Importante: Todas as configurações de ativação devem ser feitas antes de executar o comando acima.

Etapa 9: Aqui estão algumas informações mais importantes

A chamada abaixo retorna a causa da ativação do ESP32.

1: EXT0 2: EXT1 3: TEMPORIZADOR 4: TOUCHPAD 5: ULP

esp_sleep_get_wakeup_cause ();

Se configurarmos o wake up pelo touchpad, podemos recuperar qual GPIO que o toque ocorreu através do comando

esp_sleep_get_touchpad_wakeup_status ();

Sempre que o ESP32 é ativado, ele passa pela configuração novamente. Assim, todas as variáveis que não são definidas na memória RTC retornarão ao seu estado inicial.

Para manter as variáveis na memória mesmo depois de adormecer, use a declaração de variável no exemplo abaixo:

// RTC_DATA_ATTR aloca a variável na memória RTCRTC_DATA_ATTR int bootCount = 0;

Etapa 10: demonstração

O vídeo mostra o programa funcionando, de acordo com a imagem.

Etapa 11: WiFi NodeMCU-32S ESP-WROOM-32

Etapa 12: Montagem

Etapa 13: Programa

Faremos agora um programa onde configuraremos o ESP32 para entrar no modo Deep Sleep. Isso será ativado de três maneiras diferentes: uma para despertador externo (ext0), uma para o temporizador e uma para o touchpad. Eles não podem trabalhar juntos, então usaremos uma variável que será um contador para o número de vezes que o ESP32 deu a inicialização para configurar a forma de despertar.

Etapa 14: Biblioteca necessária

Para controlar o display OLED, precisamos de uma biblioteca externa. Para isso, faremos o download da biblioteca U8g2.

No IDE Arduino, vá para o menu Sketch >> Incluir Biblioteca >> Gerenciar Bibliotecas….

Etapa 15: Bibliotecas e variáveis

Incluímos a biblioteca para controlar a exibição OLED, bem como um construtor da instância do controlador de exibição. Além disso, alocamos a variável na memória RTC. Definimos a sensibilidade para aceitação de toque, o fator de conversão de microssegundos para segundos e o tempo que o ESP32 vai para o modo de hibernação (em segundos).

#include // biblioteca para controle do display oled

// construtor da instancia do driver do display // SDA = 21 e SCL = 22 U8X8_SSD1306_128X64_NONAME_SW_I2C display (SCL, SDA, U8X8_PIN_NONE); // RTC_DATA_ATTR aloca a variável na memória RTC RTC_DATA_ATTR int bootCount = 0; // sensibilidade para aceitação do toque #define Threshold 40 // fator de conversão de microsegundos para segundos #define uS_TO_S_FACTOR 1000000 // tempo que o ESP32 ficará em modo sleep (em segundos) #define TIME_TO_SLEEP 3

Etapa 16: Configuração

Na instalação, aumentamos o número de vezes que a inicialização ocorreu. Chamamos a função para imprimir o motivo da bota. Se o número de inicialização for PAR, configuramos o ESP32 para despertar por meio do botão (EXT0). Se for um múltiplo de 3, configuramos o ESP32 para despertar após um determinado tempo. Caso contrário, configuramos os pinos de toque capacitivos para ativar o ESP32. Finalmente, definimos o Touchpad como a fonte de ativação e forçamos o ESP32 a entrar no modo de hibernação.

void setup () {Serial.begin (115200); atraso (1000); // incremento ou número de vezes que o BOOT ocorreu ++ bootCount; configureDisplay (); // chama a função para imprimir o motivo do BOOT print_wakeup_reason (); // se o número de boot para PAR configuramos o ESP32 para despertar através do botão (EXT0) if (bootCount% 2 == 0) {esp_sleep_enable_ext0_wakeup (GPIO_NUM_39, 1); // 1 = Alto, 0 = Baixo} // se para multiplo de 3 configuramos o ESP32 para despertar depois de um tempo definido else if (bootCount% 3 == 0) {esp_sleep_enable_timer_wakeup (TIME_TO_SLEEP * uS_TO_S_FACTOR); } // caso contrario configuramos os pinos de touch capacitivo para despertar o ESP32 else {// Setup interrupt on Touch Pad 5 (GPIO12) touchAttachInterrupt (T5, callback, Threshold); // Configure o Touchpad como fonte de ativação esp_sleep_enable_touchpad_wakeup (); } Serial.println (“entrando em modo sleep ); esp_deep_sleep_start (); // força o ESP32 entrar em modo SLEEP}

Etapa 17: Loop, Callback e ConfigureDisplay

No Loop, não temos nada a fazer. Em seguida, interrompemos o retorno de chamada se tivermos algo a fazer quando a interrupção ocorrer. Com relação ao configureDisplay, inicializamos o display e configuramos alguns parâmetros. Imprimimos na tela o número de vezes que o Boot aconteceu.

// nada a se fazer no loopvoid loop () {} // callback das interrupções void callback () {// caso queira fazer algo ao ocorrer uma interrupção} void configureDisplay () {// inicializa o display e configura alguns parâmetros display. começar(); display.setPowerSave (0); // modo powerSave (0-Off? 1-On) display.setFont (u8x8_font_torussansbold8_u); // fonte usada // imprime no display os numero de vezes que aconteceu o BOOT display.drawString (0, 0, "BOOT NUM:"); display.drawString (0, 2, String (bootCount).c_str ()); display.drawString (0, 4, "MOTIVO:"); }

Etapa 18: Print_wakeup_reason (conhecendo a causa do despertar)

Aqui, temos a função de imprimir a causa do despertar do ESP32. Verifique o pino e imprima no visor.

// função para imprimir a causa do ESP32 despertarvoid print_wakeup_reason () {esp_sleep_wakeup_cause_t wakeup_reason; Razão da string = ""; wakeup_reason = esp_sleep_get_wakeup_cause (); // recupera a causa do despertar switch (wakeup_reason) {case 1: reason = "EXT0 RTC_IO BTN"; pausa; caso 2: razão = "EXT1 RTC_CNTL"; pausa; caso 3: motivo = "TIMER"; pausa; caso 4: razão = "TOUCHPAD"; pausa; caso 5: motivo = "PROGRAMA ULP"; pausa; padrão: motivo = "SEM CAUSA DS"; pausa; } Serial.println (motivo); display.clearLine (6); // apaga a linha 6 do display display.drawString (0, 6, reason.c_str ()); // imprime a causa do despertar no display // se despertou por TOUCHPAD, então vamos verificar em qual dos pinos ocorreu se (wakeup_reason == 4) {print_wakeup_touchpad (); // verifica o pino e imprime no display}}

Etapa 19: Print_wakeup_touchpad (conheça o GPIO Touch)

Agora, nesta etapa, temos a função de imprimir o pino que foi tocado. Recuperamos o GPIO que despertou o ESP32 e o imprimimos na tela.

// função para imprimir o pino que foi tocadovoid print_wakeup_touchpad () {touch_pad_t touchPin; touchPin = esp_sleep_get_touchpad_wakeup_status (); // recupera o GPIO que despertou o ESP32 String GPIO = ""; switch (touchPin) {case 0: GPIO = "4"; pausa; caso 1: GPIO = "0"; pausa; caso 2: GPIO = "2"; pausa; caso 3: GPIO = "15"; pausa; caso 4: GPIO = "13"; pausa; caso 5: GPIO = "12"; pausa; caso 6: GPIO = "14"; pausa; caso 7: GPIO = "27"; pausa; caso 8: GPIO = "33"; pausa; caso 9: GPIO = "32"; pausa; padrão: Serial.println ("Wakeup not by touchpad"); pausa; } Serial.println ("GPIO:" + GPIO); display.clearLine (7); // apaga uma linha 7 do display display.drawString (0, 7, "GPIO:"); display.drawString (6, 7, GPIO.c_str ()); // imprime o GPIO}

Etapa 20: Baixe os arquivos

PDF

EU NÃO