Ultra Low Power coprocessor (ULP) - ESP32
Ultra Low Power coprocessor
Neste tutorial, você irá aprender a instalar e usar o incrível ULP do ESP32, uma ferramenta extremamente poderosa e útil em projetos portáteis onde se faz o uso de baterias. Para programar o ULP, você vai precisar dos seguintes itens que não serão ensinados aqui:
- Conhecimento em Assembly e registradores.
- ESP-IDF instalada.
Deixaremos todas referencias sobre esses itens e os do tutorial ,como por exemplo, instalação do ULP, ao fim do tutorial.
[toc]
O que é o ULP e como funciona?
O ULP é um coprocessador que podemos utilizar no ESP32 como um terceiro processador, entretanto, este foi projetado para uso em Deep Sleep, visto que seu consumo é extremamente baixo (150uA). Com ele, podemos fazer por exemplo, leituras de sensores ADC e a partir disso, acordar o MCU para tomar alguma decisão mais complexa, como enviar o dado para um banco de dados. Também é possível utilizar I2C e manipular os GPIO do RTC Domain.
Este pequeno processador acessa a região da memória chamada RTC_SLOW_MEM (8kB), onde é armazenado seu código ASM e também variáveis globais que são compartilhadas entre todos processadores. Com essas variáveis, podemos fazer a comunicação entre o ULP e os processadores principais (Main Core). Lembre-se que essas variáveis são mantidas entre os Deep Sleep's, então podemos guardar valores nessa região para usar após o Wake-UP.
O ULP contém 4 registradores de 16bit para uso geral (R0, R1, R2, R3) e mais um registrador de 8bit especifico para contagens (STAGE_CNT), como em loops com FOR(). Para programa-lo ,utilizamos a linguagem Assembly, uma linguagem de baixo nível extremamente rápida, eficiente e econômica em termos de memória, mas não em linhas (hehehe).
Principais aplicações do ULP
- Monitorar sensores digitais ou analógicos em Deep Sleep ocasionando um aumento gigantesco no tempo de duração de uma bateria.
- Ajudar no processamento principal, caso necessário um poder de processamento maior.
- Efetuar tarefas secundárias, como manipulação de GPIO's, sensores, criação de ISR's e etc, enquanto o Main Core faz uma tarefa pesada ou Time Sensitive.
Mãos a obra - Piscando um LED com o ULP em Assembly com um ESP32
Instalando o Core do ULP na ESP-IDF
Antes de sair usando o ULP loucamente, precisamos instalar os arquivos do Core (arquivos do sistema) para que o ULP funcione e seja compilado corretamente pelo Assembler da IDF (GNU) e após a instalação, precisamos ativa-lo e atribuir uma memória (ao mesmo), no "menuconfig".Para realizar estes procedimentos, siga os passos a seguir:
Se você ainda não tem a ESP-IDF instalada, instale-a antes de prosseguir: https://portal.vidadesilicio.com.br/instalando-esp-idf-no-windows-esp32/
1-) Baixe o .ZIP que contem os arquivos já prontos para serem colocados na IDF: https://github.com/espressif/binutils-esp32ulp/wiki
2-) Abra o .ZIP, acesse a pasta "esp32ulp-elf-binutils" e dentro dessa haverá outras tres pastas, copie-as para dentro do diretório "\msys32\mingw32\" da sua IDF.
Já instalamos os arquivos, agora precisamos adicionar algumas linhas ao "component.mk" da pasta do seu projeto. Você precisa fazer os passos abaixo para todos projetos que pretende usar o ULP.
Você deve usar os diretórios do seu projeto.
3-) Abra o arquivo "component.mk" que se encontra na pasta "main" do seu projeto com o bloco de notas ou similar.
4-) Adicione o seguinte trecho ao arquivo:
ULP_APP_NAME ?= ulp_$(COMPONENT_NAME) ULP_S_SOURCES = $(COMPONENT_PATH)/ulp/ulp.S ULP_EXP_DEP_OBJECTS := main.o include $(IDF_PATH)/components/ulp/component_ulp_common.mk
5-) Abra o mingw32, vá ao diretório do seu projeto e use o "make menuconfig" para habilitar o ULP. No nosso caso, para ir ao diretório do projeto com o mingw32 é "cd /esp32/esp32".
Vá em "component config > esp32 specific" e habilite-o. Ao habilitar, aparecerá uma opção de configurar a memória reservada ao ULP, deixaremos o padrão por enquanto (512B).
Salve e saia do "menuconfig".
6-) Na pasta "main" do seu projeto, crie uma pasta "ulp" e dentro dessa, crie um arquivo "ulp.S".
Nota: você pode criar e editar (programar) o arquivo "ulp.S" com o bloco de notas caso não tenha uma IDE como Visual Studio (usada no tutorial).
Esses nomes precisam ser iguais ao trecho adicionado no "componente.mk".
Após a criação desse arquivo, podemos finalmente programar o incrível ULP. Esse arquivo é onde iremos programar o Assembly à ele.
Haverão dois códigos, um para o Main Core (main.c ou main.cpp) e outro pro ULP (ulp.S). O que faremos é basicamente atribuir o código Assembly ao trecho da memória RTC_SLOW_MEM e liga-lo. Após isso, o ESP32 entrará em Deep Sleep enquanto o ULP piscará um LED para mostrar funcionamento. Não se esqueça de ler o "Entendendo a fundo" que há explicações sobre o código Assembly e o funcionamento do ULP.
Estamos usando a ESP-IDF com Arduino component, isso nos permite usar tanto as bibliotecas do Arduino quanto da IDF. Se você usar a IDF sem o Arduino component, o código ficará praticamente igual, mudando apenas alguns detalhes como a alteração de extern "C" void app_main() para void app_main() , em caso de dúvidas, comente!
Componentes necessários
- 1x - ESP32 (Usaremos o NodeMCU32).
- 1x - LED (Usaremos o LED Onboard).
Código do projeto
main.cpp
#include <C:/msys32/ESP32/ESP32/components/arduino/cores/esp32/Arduino.h>
#include <C:/msys32/ESP32/esp-idf/components/driver/include/driver/rtc_io.h>
#include <C:/msys32/ESP32/esp-idf/components/ulp/ulp.c>
#include <C:/msys32/ESP32/ESP32/build/main/ulp_main.h>
//Pode ser preciso arrumar os diretorios das bibliotecas
extern const uint8_t ulp_main_bin_start[] asm("_binary_ulp_main_bin_start");
extern const uint8_t ulp_main_bin_end[] asm("_binary_ulp_main_bin_end");
void ulp();
extern "C" void app_main()
{
initArduino();//Inicia algumas configuracoes do Arduino Core, se voce nao usa Arduino component, apague essa linha
ulp();//carrega e inicia o ULP
ESP.deepSleep(1800000000);//entra em deep sleep
}
void ulp()
{
rtc_gpio_init(GPIO_NUM_2);//inicia o GPIO2 no RTC DOMAIN
rtc_gpio_set_direction(GPIO_NUM_2, RTC_GPIO_MODE_OUTPUT_ONLY);//Define o GPIO2 como saida
ulp_load_binary(0, ulp_main_bin_start, (ulp_main_bin_end - ulp_main_bin_start) / sizeof(uint32_t));//Carrega o binario do codigo assembly na memoria
ulp_run((&ulp_main - RTC_SLOW_MEM) / sizeof(uint32_t));//Inicia o ULP
}
ulp.S
#include "soc/soc_ulp.h" #include "soc/rtc_io_reg.h" #include "soc/sens_reg.h" #include "soc/rtc_cntl_reg.h" .bss//Variaveis sao declaradas dentro da secao .bss .text//O codigo é feito dentro da secao .text .global main main://O codigo e iniciado aqui, equivale ao void setup() jump loop//Isso nao e necessario, mas foi colocado para organizacao loop: WRITE_RTC_REG(RTC_GPIO_OUT_W1TS_REG, RTC_GPIO_OUT_DATA_W1TS_S+12, 1, 1)//GPIO2 HIGH stage_rst 1: stage_inc 1 wait 32000 jumps 1b, 125, lt//delay 500ms WRITE_RTC_REG(RTC_GPIO_OUT_W1TC_REG, RTC_GPIO_OUT_DATA_W1TC_S+12, 1, 1)//GPIO2 LOW stage_rst 1: stage_inc 1 wait 32000 jumps 1b, 125, lt//delay 500ms jump loop//volta ao inicio do loop
Colocando para funcionar
Após programar, basta dar upload para o ESP32 pelo próprio mingw32 e a mágica irá acontecer.
Entendendo a fundo
ULP
Apesar de termos apresentado apenas uma ideia sobre o ULP, devemos entender que este é muito mais complexo que isso devido ao fato de ter como aplicação alvo o Deep sleep.
Algumas características do ULP:
- Clock (pode ser alterado e calibrado): 8.5MHz ±7%.
- Memória: RTC_SLOW_MEM com 8kB.
- Timer de Wake-UP (pode ser desativado): 150kHz.
- 4 Registradores de 16bit (R0-R3).
- 1 Registrador de 8bit (STAGE_CNT).
- Funciona tanto nos modos de operações normais até Deep sleep.
- Capacidade de fazer leituras de sensores analógicos/digitais externos, I2C e vários outros itens.
Funcionamento e dicas do ULP
O ULP é um coprocessador FSM (Finite state machine) que podemos usar para praticamente qualquer objetivo, entretanto é preciso tomar alguns cuidados como o timer de Wake-UP. Esse timer que vem por padrão ativado, serve para acordar o ULP periodicamente após encontrar o comando HALT no código Assembly. No nosso exemplo não foi usado HALT para encerrar o código do ULP pois usamos ele em um loop infinito. Se você não tomar cuidado esse comando e esquecer o timer ativado (é possível desativa-lo para garantir o funcionamento em certos casos), provavelmente o ULP não irá funcionar da forma que você espera.
Após o binário ser carregado e o ULP iniciado pelo código principal, o ULP irá iniciar a execução do código na label "main" que foi definida no ulp_run() , a partir desse ponto, será executado linha após linha até encontrar o comando HALT ou cair em um loop infinito como mostrado nesse tutorial.
Ao usar o comando WAKE o ESP32 irá acordar e executar todo o código novamente do começo, isso pode gerar problemas com o ulp_run() uma vez que o ULP já esta em execução e será reiniciado, para isso você deve adicionar uma condicional de Wake-UP que verifica o motivo do ESP32 ter acordado e caso não tenha sido pelo ULP, deve ter sido queda de energia ou similares, logo, precisamos inicia-lo novamente.
Toda explicação de funcionamento do ULP, comandos do Assembly, registradores e etc, estão na referencia técnica do ESP32 que se encontra no fim do tutorial.
Software
ulp.S
-Macro WRITE_RTC_REG()
WRITE_RTC_REG(RTC_GPIO_OUT_W1TC_REG, RTC_GPIO_OUT_DATA_W1TC_S+12, 1, 1)//GPIO2 LOW
Essa macro escreve um valor no registrador, sendo bem parecido com o tutorial que já fizemos sobre: Manipulando os registradores do ESP32, Porem, é usado os registrador do RTC Domain, por isso ativamos os pino 12 do RTC, que equivale ao GPIO2.
-Delay em Assembly
stage_rst 1: stage_inc 1 wait 32000 jumps 1b, 125, lt//delay 500ms
O blink faz com que o LED fique 500ms acesso e 500ms apagado, mas como que isso foi feito? Foi usado os ciclos do clock do ULP que é por padrão 8.5MHz ±7%, vamos arredondar para 8MHz ou seja, a cada 1 segundo, o clock irá oscilar 8 milhões de vezes. Pensando nisso, podemos calcular a quantidade de ciclos necessário para efetuar um delay.
Para fazer o delay, iremos usar 3 itens que nos ajudarão a "pular" ciclos do clock, fazendo com que o processador fique em espera:
- NOP (No Operation): pula 1 ciclo do clock.
- WAIT X: equivale a usar vários NOP's, limite de 65535.
- Registrador: guardará um valor auxiliar na contagem.
Veja os passos para efetuar o delay de 500ms no Assembly do ULP com o registrador STAGE_CNT:
1-) Segundos * clock = ciclos para pular
0.5 * 8000000 = 4000000
2-) Cada WAIT pode conter no máximo 65535, que não é nem perto do que precisamos (4000000), logo, vamos utilizar uma variável (registrador) auxiliar que irá se comportar igual ao FOR(). Será usado WAIT 32000, mas você pode escolher qualquer um desde que esteja dentro dos limites.
ciclos para pular / wait = total de operações do loop
4000000 / 32000 = 125 operações
Agora, basta fazer um FOR() em Assembly para que se assemelhe a isso:
for (int i = 0; i < 125; i++)
{
//blabla
}
Usaremos o registrador STAGE_CNT que é indicado para contagens:
stage_rst//Reseta o registrador (STAGE_CNT = 0) 1: stage_inc 1//Incrementa o registrador em +1 (STAGE_CNT++) wait 32000//Equivale a 32000 NOP's jumps 1b, 125, lt//Pula para label "1before" enquanto o registrador for menor que 125
Considerações finais
Infelizmente pelo ESP32 ainda não "cair em uso" aqui no Brasil, só encontramos informações de fora e principalmente no Datasheet. Espero que com esse "ponta pé inicial" mais pessoas comecem a postar materiais sobre ULP, uma vez que as aplicações para esse pequeno campeão que não encontramos em qualquer lugar são gigantescas e muito importantes em projetos portáteis, onde permite o processamento de informações enquanto todo o resto do microcontrolador permanece em Sleep para economia da bateria. Bons estudos e aproveite essa ferramenta extraordinária.
Se você já conseguiu usar o ULP, veja este tutorial para leitura de sensores analógicos ou digitais em Deep Sleep com o ULP no ESP32.
https://portal.vidadesilicio.com.br/lendo-sensores-analogicos-deep-sleep-ulp-esp32/
Referencias
https://esp-idf.readthedocs.io/en/v3.0-rc1/api-guides/ulp.html
https://esp-idf.readthedocs.io/en/v3.0-rc1/api-guides/ulp_instruction_set.html
http://espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf
https://portal.vidadesilicio.com.br/instalando-esp-idf-no-windows-esp32/
Comunicação Wireless TCP com ESP (Parte 2)
Comunicação Wireless TCP com ESP
Daremos inicio a segunda parte do nosso material sobre comunicações Wireless. No tutorial anterior, foi abordado sobre o protocolo UDP, que não é orientado à conexão. Desta vez, vamos aprender sobre o protocolo TCP, este por sua vez, é orientado à conexão, que nos garante a entrega de mensagens, ordenação do recebimento/envio, etc. O código aqui apresentado irá funcionar tanto para ESP8266 quanto para o ESP32, já que a diferença é mínima e funciona da mesma forma.
[toc]
Protocolo TCP
TCP (Transmission Control Protocol) é um protocolo para transmissão de dados voltado à conexão, ou seja, permite que as maquinas se comuniquem e gerenciem o estado atual da conexão com seus clientes e servidores. Uma característica importante do TCP é seu gerenciamento do status da rede e os dados, com isto, podemos saber se o dado enviado foi realmente entregue ao destinatário, também garante a entrega ordenada das informações sem que haja colisões e perdas inperceptíveis. Muitas aplicações usam o TCP para efetuar suas comunicações, sendo amplamente usado em todo tipo de situação, ao contrario do UDP que por não ser orientado à conexão, pode gerar erros em nossos sistemas.
Mãos à obra
Componentes necessários
- 1x ESP8266(Usaremos NodeMCU 8266) ou 1x ESP32.
- Aplicativo TCP Client no celular.
Obs: Você pode usar qualquer aplicativo ou programa para transmitir os pacotes TCP. Nós usaremos o primeiro encontrado na Play Store para ser fácil de vocês encontrarem caso queiram usar também. Link do TCP Client na Play Store
Código do projeto
#ifdef ESP8266//Se estiver usando ESP8266, automáticamente irá adicionar as bibliotecas do ESP8266.
#include <ESP8266WiFi.h>
#include <WiFiServer.h>
#elif defined ESP32//Se estiver usando ESP32, fara a mesma operaçao.
#include <WiFi.h>
#endif
WiFiServer sv(555);//Cria o objeto servidor na porta 555
WiFiClient cl;//Cria o objeto cliente.
void setup()
{
Serial.begin(115200);//Habilita a comm serial.
WiFi.mode(WIFI_AP);//Define o WiFi como Acess_Point.
WiFi.softAP("NodeMCU", "");//Cria a rede de Acess_Point.
sv.begin();//Inicia o servidor TCP na porta declarada no começo.
}
void loop()
{
tcp();//Funçao que gerencia os pacotes e clientes TCP.
}
void tcp()
{
if (cl.connected())//Detecta se há clientes conectados no servidor.
{
if (cl.available() > 0)//Verifica se o cliente conectado tem dados para serem lidos.
{
String req = "";
while (cl.available() > 0)//Armazena cada Byte (letra/char) na String para formar a mensagem recebida.
{
char z = cl.read();
req += z;
}
//Mostra a mensagem recebida do cliente no Serial Monitor.
Serial.print("\nUm cliente enviou uma mensagem");
Serial.print("\n...IP do cliente: ");
Serial.print(cl.remoteIP());
Serial.print("\n...IP do servidor: ");
Serial.print(WiFi.softAPIP());
Serial.print("\n...Mensagem do cliente: " + req + "\n");
//Envia uma resposta para o cliente
cl.print("\nO servidor recebeu sua mensagem");
cl.print("\n...Seu IP: ");
cl.print(cl.remoteIP());
cl.print("\n...IP do Servidor: ");
cl.print(WiFi.softAPIP());
cl.print("\n...Sua mensagem: " + req + "\n");
}
}
else//Se nao houver cliente conectado,
{
cl = sv.available();//Disponabiliza o servidor para o cliente se conectar.
delay(1);
}
}
Colando para funcionar
Devo lembrar que o IP padrão do ESP em modo Acess_Point é 192.168.4.1
1-) Precisamos nos conectar na rede WiFi criada pelo micro controlador.
2-) Logo, iremos adicionar o servidor com seu IP e PORTA no aplicativo. Lembre-se que você pode usar qualquer aplicativo ou programa de computador para isso.
3-) Após incluir os dados do servidor no aplicativo, podemos conectar-se e enviar os dados.
Obs: Também há dados disponíveis no Serial monitor, que o micro controlador escreveu, olhe como ficou.
Entendendo a fundo
Software
-Função WiFiClient::connected()
if (cl.connected())//Detecta se há clientes conectados no servidor.
{
}
Esta função retorna se há cliente conectado em nosso servidor. Também irá retornar que há clientes até que todos dados sejam lidos do buffer, se não, continuará aparecendo clientes conectados até que todos dados sejam lidos.
-Função WiFiClient::available()
if (cl.available() > 0)//Verifica se o cliente conectado tem dados para serem lidos.
{
}
Esta função, retorna a quantidade de bytes disponiveis para a leitura no buffer do cliente. Pode ser usada para detectar se há dados, e também para efetuar a leitura byte a byte do buffer, afim de montar a String final.
-Função WiFiClient::print()
cl.print();
Usada para enviar a String para o cliente. Há várias maneiras de mandar uma informação para o cliente, desde write(), printf() até print() e println().
-Função WiFiServer::available()
cl = sv.available();//Disponabiliza o servidor para o cliente se conectar.
Esta função, obtem um cliente que esta conectado ao servidor e tem dados disponiveis para a leitura. Pode ser entendida a grosso modo que diz ao cliente que há um servidor disponivel para enviar dados.
Desafio
O desafio desta vez, é tentar conectar multiplos clientes ao mesmo tempo em seu servidor. Este código não permite isto, então faça alterações e estude sobre as bibliotecas usadas para permitir multiplas conexões!
Fechamento
Neste tutorial, você aprendeu a efetuar uma troca simples de mensagens entre o Cliente (nosso celular) e o Servidor (ESP), pode ser usada de mesma forma para comunicação entre dois micro controladores. Na parte 3 deste material, aplicaremos as aulas passadas em um aplicativo em Android ou PC para se comunicar com nosso ESP8266/32. Não se esqueça de comentar sobre duvidas, elogios e criticas! Também aceitamos sugestões sobre a terceira parte deste material.