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]

kit robotica educacional com Arduino ESP ou Microbit

O que é o ULP e como funciona?

Ultra Low Power coprocessor (ULP) - ESP32
Figura 1 - Coprocessador

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

Figura 2 - Download do Core.

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.

Figura 3 - Copiando os arquivos do ULP pra 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.

Figura 4 - Component.mk.

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
Figura 5 - Trecho adicionado ao 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".

Figura 6 - Abrindo o diretório.

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).

Figura 7 - Habilitando o ULP.

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".

Ultra Low Power coprocessor (ULP) - ESP32
Figura 8 - Arquivo do ULP.

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.

Ultra Low Power coprocessor (ULP) - ESP32
GIF - Blink.

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

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.