SpeedTest: Arduinos – ESP32/8266s – STM32

Qual microcontrolador é mais rápido entre os arduinos, os ESPs e os STM32? Isso é o que nós vamos ver hoje, neste vídeo, no qual eu faço um teste de velocidade, o SpeedTest, com diversos dispositivos executando uma mesma série de comandos. Acompanhe e veja o resultado!

Nosso principal objetivo será mostrar o tempo que cada um dos microcontroladores que nós escolhemos gasta para executar uma série de comandos, ou seja, um programa simples. Portanto, faremos um programa que executará um milhão de iterações e, a partir da iteração 100 mil, executaremos comandos para que o led interno pisque.

Achei na internet outros testes de velocidade com microcontroladores, inclusive do Chester Lowrey, que produziu essa tabela abaixo, que deixo aqui para você observar.

Então, resolvi fazer o meu próprio teste e este é baseado em um programa comum: entra em loop de repetição, faz um monte de comparações no loop, executa um digitalwrite, esse tipo de coisas simples, que já fizemos um milhão de vezes.

Este teste, portanto, não tem nenhum caráter científico e nem quero com ele denegrir o desempenho de nenhum microcontrolador, mas, simplesmente mostrar a magnitude de processamento que tem cada modelo.

Fizemos um milhão de iterações e, comparando, meu resultado deu parecido em alguns aspectos com o que foi constatado pelo Chester. Por exemplo, o ESP32, por core, se mostrou 60 vezes mais rápido que o Arduino Uno. No caso do Chester, ele fez um Divide Float, ou seja, uma operação de ponto flutuante e deu 83.462 milissegundos para o Arduino Uno contra 1.398ms do ESP. Se você divide um pelo outro, vai dar 59,7 vezes que o ESP é mais rápido que o Arduino Uno. Por outro lado, tem características que dá quase igual, um para o outro. Por exemplo, outros parâmetros variam de 10 a 170 vezes a velocidade na comparação entre esses dois microcontroladores.

Microcontroladores que utilizamos:

Arduino Uno
Arduino Nano Atmega 328p
Arduino Leonardo Pro Micro
Arduino Mega ADK
Arduino Mega 2560
Arduino Due
STM32F103C8T6
STM32 Maple Mini
ESP12 ESP8266
ESP32 NodeS

Resultados

Diferentes arquiteturas rodando o mesmo código: Arduino IDE “GCC”.

ATMega328

ARM M3 STM32F103

ESP32

Temos aqui os diagramas do ATMega328, o ARM M3 STM32F103 e o ESP32. Eles são microcontroladores diferentes. Sendo assim, não temos nada de científico aqui porque a arquitetura dos chips são diferentes. Mas, nós escrevemos um código fonte que compila em todos microcontoladores e roda em um mesmo compilador: o GCC.

Código fonte

Fizemos diversos testes e chegamos a um programa que fosse o mais simples possível e que pudesse ser representado em qualquer microcontrolador. Então, neste código fonte fiz um for de 1 milhão. Também acendo um led. Ou seja, quando dá 100 mil, ele entra no alternador.

  unsigned long inicio, tempoTotal;
  unsigned long contador = ITERACOES;
  long int LEDcounter = 0; //contador de piscadas do LED
  boolean alternador = false; //controlador para alternar a ativação do LED
  
  digitalWrite(LED_BUILTIN, LOW); //desliga o LED

  long int i;
  
  inicio = millis();//guarda o tempo de inicio da execução do algoritmo
  
  //iterações
  for ( i = 0; i < contador; i++) {
    //verifica se o LED ja deve começar a piscar
    if (i+1 > FLASH) 
    {
      LEDcounter++;
      if (alternador) {
        digitalWrite(LED_BUILTIN, HIGH);
        alternador = false;
      } else {
        digitalWrite(LED_BUILTIN, LOW);
        alternador = true;
      }
    }
  }
   
  tempoTotal = millis() - inicio; //calcula o tempo gasto na execução do algortimo (resultado em ms)

Arduinos – ESP32/8266s – STM32

Pessoal, então, como fizemos o teste? Rodamos um milhão de vezes o Loop e analisamos quantos milissegundos cada microcontrolador leva para tal ação. Nossa tabela acima mostra que o Arduino Uno levou 4.920 milissegundos, enquanto o ESP32 precisou apenas de 164ms.

Mas, qual o problema de fazer uma tabela utilizando milissegundos? Milissegundo é inversamente proporcional à performance. Então, eu normatizei, ou seja, criei um índice: peguei 10 mil e dividi por T (tempo em milissegundo). Esse índice é o indicado pelas barras vermelhas da tabela. Significa que, quanto maior a barra, maior a performance.

No teste tivemos algumas surpresas. Eu acreditava que o Arduino Due era o mais poderoso dos microcontroladores em função da quantidade de IOs que possui. Ele é um Mega! Um ARM Cortex-M3! Mas, seu índice ficou bem baixo da minha expectativa, com pouca diferença em relação ao Arduino Uno.

Outra surpresa é em relação ao desempenho do STM32. O STM32F103C8T6 e o STM32 Maple Mini tiveram índices bem acima do Arduino Due. Em questão de valores, ainda melhor. Enquanto o Arduino Due custa em média R$ 130,00, o STM32 F103C8T6 fica na faixa dos R$ 14,00, e tem mais IOs do que o Arduino Nano.

No caso do Arduino Mega, um espanto: o índice foi de 1,38, o mais baixo da lista. Também me surpreendi negativamente com o ESP8266. Eu achava que ele era muito mais rápido por conta do Clock, que vai de 80 a 160 MHz. Então, fiquei decepcionado com o índice dele, de 6,83, porque esperava mais.

Agora, o melhor desempenho foi do ESP32, que tem dois Cores.

Destaque do teste

Os destaques do teste, na minha análise, são os STM32.

O mais rápido

O campeão, na nossa avaliação, portanto, é o ESP32. Ele tem o melhor desempenho no que diz respeito à velocidade para executar o programa que criamos especificamente para esse teste. E isso não quer dizer que seja porque ele é dual core, porque usamos na avaliação um core somente. Mais sobre a programação deste microcontrolador em um próximo vídeo.

Faça download dos arquivos:

INO

PDF