Multiprocessamento com ESP32

As vezes é necessário que façamos o uso de sistemas multicores para as mais diversas finalidades, como por exemplo, fazer verificações de dados pela Serial, I2C ou sensores, enquanto o outro processador (Core) faz uma outra atividade em que não possa ser interrompida ou seja indesejado esse tipo de ação. Aprenderemos o que é multiprocessamento e usaremos o incrível ESP32 que tem ao todo três cores, para criar dois LOOP(), permitindo que você rode dois códigos ao mesmo tempo!

Lembrando: O terceiro core do ESP32 é um ULP, que é apenas programado em Assembly. Também é possível programa-lo para as mais diversas finalidades. Será mostrado apenas a programação do core principal.

Para conhecer mais sobre o ESP32 você pode conferir nosso tutorial: Conhecendo o ESP32

[toc]

Computação paralela – Multiprocessamento

Computação paralela é um assunto extremamente complicado, porem podemos simplificar de um método prático:

Você tem um supermercado com um caixa e em horários de pico, o caixa não é rápido suficiente para atender os clientes, então é necessário contratar outro funcionário que fique em outro caixa, fazendo assim que a velocidade de espera seja até 50% menor. (será atendido o dobro de clientes em relação a apenas um caixa)

Um sistema computacional paralelo, permite realizar diversos cálculos (tarefas, algoritmos, etc) simultaneamente. Há diversas maneiras de se paralelizar um código que é normalmente escrito em sequência: em bit, instrução, de dado ou de tarefa. O método mais simples é por exemplo dividir um FOR() pela metade a atribuir cada metade em cores diferentes, diminuindo o tempo de execução em até 50%. Apesar de parecer ser extremamente útil, há inúmeros problemas relacionados, como condição de corrida: o acesso simultâneo da mesma variável pode gerar erros em cálculos ou se o próprio calculo for dependentes de outros resultados, a paralelização disto é inconveniente, uma vez que utilizar semáforos para sincronizar as tarefas (exclusão mutua), pode ser mais lento que o simples código em sequencial. A questão à se pensar com uso de semáforos para sincronia de processos, deve ser analisada com o grau de granulação, uma vez que o uso excessivo de semáforos, pode deixar o processo mais lento que o código sequencial (single core).

---

Mãos à obra

Componentes necessários

• 1x ESP32
• Arduino IDE

Código do projeto

int tempo;//Variavel que armazena o tempo.

void setup()
{
	Serial.begin(115200);//Inicia a comunicaçao serial
	pinMode(2, OUTPUT);//Define o led Onboard como saída


	Serial.printf("\nsetup() em core: %d", xPortGetCoreID());//Mostra no monitor em qual core o setup() foi chamado
	xTaskCreatePinnedToCore(loop2, "loop2", 8192, NULL, 1, NULL, 0);//Cria a tarefa "loop2()" com prioridade 1, atribuída ao core 0
	delay(1);
}

void loop()//O loop() sempre será atribuído ao core 1 automaticamente pelo sistema, com prioridade 1
{
	Serial.printf("\n Tempo corrido: %d", tempo++);
	delay(1000);//Mantem o processador 1 em estado ocioso por 1seg
}

void loop2(void*z)//Atribuímos o loop2 ao core 0, com prioridade 1
{
	Serial.printf("\nloop2() em core: %d", xPortGetCoreID());//Mostra no monitor em qual core o loop2() foi chamado
	while (1)//Pisca o led infinitamente
	{
		digitalWrite(2, !digitalRead(2));
		delay(100);
	}
}

Colocando para funcionar

Podemos observar tanto no Serial Monitor quanto no ESP32, o funcionamento esperado do código. Enquanto o core 1 faz a contagem do tempo e espera 1seg para repetir a mensagem (o que o deixa em IDLE [travado]), o core 0 pisca o led, mostrando que um não interfere no outro.

---

Entendendo a fundo

Software

-Função xTaskCreatePinnedToCore()

xTaskCreatePinnedToCore(loop2, "loop2", 8192, NULL, 1, NULL, 0);

Esta função cria uma tarefa e atribuí a um especifico processador. O FreeRTOS pode definir automaticamente em qual core a tarefa será rodada, para isto, use xTaskCreate() (Mais informações no site FreeRTOS).

Neste caso, criamos a tarefa loop2, com “tamanho” de 8192 Bytes (words), nenhum parâmetro, prioridade 1 e atribuída ao core 0.

Vamos esclarecer os parâmetros em ordem (da esquerda à direita):

xTaskCreatePinnedToCore(pxTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask, xCoreID)

pxTaskCode: Ponteiro para a tarefa, apenas o nome da tarefa.   loop2.

pcName: O nome (String) da tarefa (entre aspas), é usado para facilitar o debug.   “loop2”.

usStackDepth: O tamanho de Stack reservada à tarefa, mais informações clique aqui.   8192.

pvParameters: O valor a ser passado para a tarefa no momento de criação. Nossa tarefa não precisa de parâmetros, então:   NULL.

uxPriority: A prioridade da tarefa. É comum se usar 1 para tarefas simples, já que funções de delay (IDLE) tem prioridade 0.   1.

Se duas tarefas com mesma prioridade estiverem na fila, a primeira da fila irá ser executada e depois a próxima. Caso uma tarefa com prioridade 1 esteja na fila, porém uma tarefa com prioridade 2 também, será executado a tarefa com prioridade 2 e depois as outras.

pxCreatedTask: Valor opcional caso seja necessário manipulação das tarefas (Handle).   NULL.

xCoreID: Atribuí a tarefa a um core especifico.   0.

Observações:

• Se você por exemplo criar dois loops, ao chamar uma subrotina (função), ela será executada no core em que foi chamada.
• Caso você não crie uma tarefa “infinita”, será necessário deletar a tarefa com xTaskDelete().
• No caso do loop2() criado, é necessário o uso de pelo menos delay(1) dentro do loop, para que o Task Watchdog não seja ativado. Há maneiras de contornar isso, mas precisa fazer alterações no BootLoader.

-Função xPortGetCoreID()

xPortGetCoreID()

Esta função retorna o core em que a tarefa esta sendo executada.

---

Fechamento

A computação paralela se mostra útil quando necessário alto poder computacional ou monitoramento de itens específicos. Este assunto é gigantesco, complicado e intrigante, foi mostrado apenas o básico sobre o assunto; se você quer se aprofundar mais, veja os PDFs que foram citados no começo.

Dúvidas? Sugestões? Críticas? Comente abaixo!