Arduino 2.0 e o novo ESP32-C3 RISC-V

 

Olá queridos alunos!

Hoje eu tenho imenso prazer de falar sobre dois assuntos muito importantes. O primeiro é o Arduino 2.0, que a cada dia tem melhorado mais, no momento está numa versão Beta, mas está avançando bem e na minha opinião deu uma melhorada boa na interface. O outro assunto importantíssimo é o ESP 32 Risc–V.

Mas Fernando, o que é o Risk-V?

O RISC-V é um conjunto de instruções (ISA) baseado nos princípios RISC. Ao contrário da maioria dos outros designs do ISA, ele é fornecido sob uma licença de código aberto que não exige taxas de uso. O mercado tem se voltado muito para essa arquitetura!

O projeto começou em 2010 na Universidade da Califórnia, Berkeley, através de colaboradores voluntários não afiliados à universidade. Para dar estabilidade ao projeto e torná-lo atraente para usuários comerciais, uma Fundação RISC-V formal foi incorporada para possuir, manter e publicar a definição RISC-V.

Um dos intuitos desse post é mostrar que você que programa em Arduino IDE, não sentirá nenhuma diferença entre programar um ESP32 com núcleo Risc-V ou Tensilica.

Intenções dessa aula

1. Apresentar o ESP32-C3
2. Configurar o Arduino IDE 2.0
3. Instalar o Core Arduino 2.0 da Espressif
4. Medir o consumo de corrente
5. Comparar performance ESP32-C3 com ESP32 2 núcleos Tensilica LX6

Instalando Arduino 2.0

 https://github.com/arduino/arduino-ide

Primeiramente vamos instalar o Arduino 2.0. Recomendo instalar direto do GitHub nesse endereço acima. Essa versão apontada abaixo pela seta vermelha é um portable, não afeta nenhuma outra versão que tenha instalada em sua máquina, então você pode inclusive ter mais de uma instalação na mesma máquina. 

Após baixar o arquivo, basta abri-lo e você verá a tela abaixo, com os arquivos que estão compactados. Eu recomendo que você utilize o WinRar, ele é bem mais rápido que os demais programas de compactação.

Após abrir, extraia os arquivos para alguma pasta, no caso eu criei uma pasta temp2.0 e extraí os arquivos para dentro dela, mas você pode colocar o nome que achar melhor.

Feito isso, basta clicar no arquivo Arduino IDE.exe, e você verá a tela inicial do programa, conforme imagem abaixo:

Logo após, clique no ícone do chip, mostrado na figura abaixo, para abrir o Boards Manager, e coloque na busca: “esp32”, caso seja encontrado algo, aperte o botão “Uninstall”, isso é por que não podemos instalar o core do Arduino 2.0 em cima de uma biblioteca antiga.

 

Instalando o Core da Espressif 2.0 alpha

https://github.com/espressif/arduino-esp32

No link acima, você pode baixar o Core do Arduino 2.0, que está na versão Alpha, mas eu tenho compilado vários projetos com esse core, e tem funcionado muito bem.

Para instalar, copie o json abaixo:

 https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json

Em seguida, no Arduino IDE, vá em File > Preferences em seguida clique no botão abaixo:

Logo após, cole o json na caixa (conforme texto selecionado). Essa lista de URLs é onde ficam os links para cada placa

Agora, após apertar Ok, vá novamente no Boards Manager, digite novamente “esp32”, e dessa vez ele irá encontrar, clique em 2.0.0-alpha1 e depois clique em INSTALL.

Aguarde a instalação.

Após a instalação, precisamos escolher a placa, então vá até o dropdown mostrado na imagem abaixo e clique em “Select Other Board & Port”.

Em seguida, na janela que abrir, faça a busca pelo nome da placa, como no exemplo abaixo:

Selecione também a porta, no meu caso eu selecionei a COM10 após confirmar que ela está sendo utilizada, através do programa USBDeview.

Agora é só compilar!

Esse código fonte que tenho é bem simples, ele apenas identifica os SSIDs das redes locais e imprime, inclusive com a força do sinal.

Após compilar, tive a impressão de que o Arduino 2.0 compila mais rápido. 

 

Após a compilação, só ir em Tools > Serial Monitor, e como vocês podem observar abaixo, já está executando:

Observe que é totalmente transparente para você, você programa em C, e não precisa saber se é Risc-V ou Tensilica.

Diagrama do ESP32-C3

O ESP32-C3 tem Wifi e tem Bluetooth 5.0, é muito interessante. No diagrama abaixo você pode ver em detalhes todas as especificações:

Em termos de periféricos, ele é muito bom! Tem tudo o que é importante.

E como esse chip gasta menos energia? Tirando um core! Criaram um produto para gastar menos energia.

É um single core que roda a 160MHz. 384 KB de ROM e 400 KB de SRAM, está muito bom.

E você pode observar na imagem que ele tem tudo o que você precisa pra desenvolver um produto legal com ele.

Para quem está se perguntando se o 8266 vai acabar. Não, eu não acredito que ele vá acabar.

Observe na imagem abaixo, o comparativo entre as versões:

Mas por que usar Risc-V, Fernando?

Por que é open! Nunca me esqueço, quando eu quis usar um barramento da Texas, quando fui ver o valor da propriedade intelectual para começar a usar o barramento, eu assustei, tem que pagar royalties.

Comparando ESP32 Wroom com ESP32-C3

Observe na imagem acima, à direita temos o C3, módulo da Espressif, e o da esquerda é um Wrover. Observe que o C3 é um módulo bem compacto.

Vou deixar abaixo um link para que vocês possam comprar o Wroom no AliExpress, mas compensa comprar de quantidade grande, pois o frete é o mesmo para pequenas ou grandes quantidades.

https://s.click.aliexpress.com/e/_9QIRfG

Abaixo também o link para comprar o módulo C3:

https://s.click.aliexpress.com/e/_AX3MOq

Teste de Consumo de corrente

  #include "WiFi.h"
void setup()
{
    Serial.begin(115200);
    // Set WiFi to station mode and disconnect from an AP if it was previously connected
    WiFi.mode(WIFI_STA);
    WiFi.disconnect();
    delay(100);
    Serial.println("Setup done");
}
  

Teste de consumo de performance

  

  void loop()
{
    Serial.println("scan start");

    // WiFi.scanNetworks will return the number of networks found
    int n = WiFi.scanNetworks();
    Serial.println("scan done");
    if (n == 0) {
        Serial.println("no networks found");
    } else {
        Serial.print(n);
        Serial.println(" networks found");
        for (int i = 0; i < n; ++i) {
            // Print SSID and RSSI for each network found
            Serial.print(i + 1);
            Serial.print(": ");
            Serial.print(WiFi.SSID(i));
            Serial.print(" (");
            Serial.print(WiFi.RSSI(i));
            Serial.print(")");
            Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*");
            delay(10);
        }
    }
    Serial.println("");

    // Wait a bit before scanning again
    delay(5000);
}

  
  

  

  #define ITERACOES 1000000    // numero de iterações que serão realizadas
#define FLASH 100000            // iteração que o led começará a piscar a cada iteração
#define LED_BUILTIN 2
void setup() {
  //LED_BUILTIN é uma constante nativa que indica o pino que controla o LED interno
  pinMode(LED_BUILTIN, OUTPUT); //configura o pino que controla o LED interno como saida
  Serial.begin(9600);
}

  
  

  

  void loop() {

  //variaveis que serão utilizadas para o calculo do tempo de execução
  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)

  digitalWrite(LED_BUILTIN, LOW); //apaga o LED após a execução

  Serial.print("# numero de iterações = ");
  Serial.println(contador);
  Serial.print("Led piscou [ ");
  Serial.print(LEDcounter);
  Serial.println(" ] vezes");
  Serial.print("Tempo total: "); Serial.print(tempoTotal); Serial.println(" ms");
  Serial.println();Serial.println();

  delay(3000);
}

Teste de performance

Observe abaixo o resultado do teste de performance:

É uma diferença de performance grande, observe que o C3 atinge

mais que o dobro de velocidade do 8266, com muito mais periféricos, mais

recursos.

Bom, por hoje é isso queridos alunos.

Espero que tenham gostado, compartilhem com seus amigos, se inscrevam no meu canal e no blog.

Um forte abraço, do Fernando K!