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.

Lendo sensores analógicos em Deep Sleep com 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

Instalando a ESP IDF no Windows – ESP32