Conhecendo o Arduino Zero. hoje vou te apresentar essa plaquinha poderosa oficial da Arduino, que conta com um processador ARM Cortex M0+. Foi o primeiro deste modelo a entrar numa placa oficial do Arduino.

Antes dele somente o Arduino DUE tinha processador ARM (um Cortex-M3). Lá nos idos de 2014, antes do lançamento oficial do Zero eu fui um dos beta testers, inscrevi uma ideia e fui selecionado para ganhar uma plaquinha (da foto abaixo).

Tanto era um teste beta que minha placa veio com jumpe wires na porta serial dos pinos 0 e 1. O Arduino Zero não é e nunca foi muito popular, jamais vai substituir o Arduino UNO por exemplo.

Isto porque ele não tem um diferencial grande que justifique sua adoção. Isso na plataforma Arduino, porque no “mundo real” a família de Cortex M0+ é muito usada devido ao seu baixo consumo de energia. Eles são inclusive os substitutos diretos das famílias 8bit.

Especificações técnicas

Em termos de especificações técnicas, ela tem bastante coisa diferente do Arduino UNO por exemplo. A começar que ela funciona em 3,3V. Se você colocar 5V ela queima mesmo.

Outro ponto interessante é que ela possui duas portas USB, uma conectada diretamente ao seu chip principal (ATSAMD21G18) e outra conectada do chip EDBG. Este é um segundo chip na placa que serve para debug, ele está conectado diretamente ao SAMD21 e pode inclusive gravar seu firmware.

O EDBG faz que que possamos programar o Arduino Zero também através do ATMEL Studio, além da IDE do Arduino. Outra coisa interessante desta placa é que possui saída analógica 10bit. Isso significa que ela pode “gerar uma tensão” CC no pino A0.

Quase todos os pinos (exceto pino quatro) podem ser programados como interrupção. Ela possui 256kB de memória Flash, contra os 32kB do Arduino UNO. Isso significa mais espaço para armazenar nosso código.

Apesar de não possuir memória EEPROM, esta pode ser emulada em até 16kB.

O que dá pra fazer de legal com essa placa?

Segundo o próprio site do Arduino, a proposta do Zero é “ser uma plataforma para projetos inovadores em ioT, vestíveis, automação e robótica”.

Você pode usar os modos de baixo consumo, criar um medidor de frequência de áudio, testar a programação dela via ATMEL Studio. Com a capacidade desta placa dá também para fazer bastante experimentos envolvendo física, como este sistema pêndulo-hélice com PID.

Você pode até programa-lo em Python, através do circuitPython da Adafruit.

Programando com a IDE do Arduino

Primeiro vamos ver como gravar o firmware no ATSAMD21; este passo não é necessário, já que a placa já vem gravada. Mas quero mostrar como funciona. Baixe a IDE do Arduino mais atualizada (eu baixei a versão 2.3.2).

Conecte o Arduino Zero via USB DEBUG ao computador. Visto isso, é necessário baixar os arquivos de configuração para a IDE reconhecer o Arduino Zero. Vá em “Ferramentas > Placa > Gerenciador de placas” e digite “Zero”. Instale a “Arduino SAMD boards by Arduino.

Agora vá em “Ferramentas > Placa” e selecione “Arduino Zero programming port”. Em “Ferramentas > Programador” selecione “Atmel EDBG”. Agora clique em “Ferrramentas > Gravar bootloader”.

Piscando um led com BlinkWithoutDelay

A maioria dos sketch que funcionam no Arduino UNO vão funcionar no Zero, essa é a beleza do ecossistema Arduino.

Vamos fazer o famoso pisca LED com o sketch BlinkWithoutDelay que vem com a IDE do Arduino, em “Arquivo > Exemplos > 02. Digital > BlinkWithoutDelay”.

Aqui você pode tanto conectar o cabo USB na porta DEBUG como na nativa. Eu prefiro trabalhar na nativa para não ter nenhum risco de mexer no chip de debug.

// constants won't change. Used here to set a pin number:
const int ledPin =  LED_BUILTIN;// the number of the LED pin

// Variables will change:
int ledState = LOW;             // ledState used to set the LED

// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0;        // will store last time LED was updated

// constants won't change:
const long interval = 100;           // interval at which to blink (milliseconds)

void setup() {
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the difference
  // between the current time and last time you blinked the LED is bigger than
  // the interval at which you want to blink the LED.
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;

    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW) {
      ledState = HIGH;
    } else {
      ledState = LOW;
    }

    // set the LED with the ledState of the variable:
    digitalWrite(ledPin, ledState);
  }
}

Eu coloquei o tempo para 100ms (0,1s). Observe o LED ‘L’ onboard amarelo no gif abaixo.

Testando a saída analógica

Outro recurso legal do Arduino Zero é uma saída analógica, coisa que o UNO não tinha. Bolei um sketch que sobe e desce o valor da tensão no pino A0. Estou conectando um LED neste pino para visualização.

// constants won't change. Used here to set a pin number:
const int ledPin =  LED_BUILTIN;// the number of the LED pin

// Variables will change:
int ledState = LOW;             // ledState used to set the LED
int valor = 0;

// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0;        // will store last time LED was updated

// constants won't change:
const long interval = 50;           // interval at which to blink (milliseconds)

void setup() {
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the difference
  // between the current time and last time you blinked the LED is bigger than
  // the interval at which you want to blink the LED.
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;

    if(valor <= 1020){
      valor= valor + 10;
      analogWrite(A0, valor);
    }else{
      valor= 0;
    }
    
    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW) {
      ledState = HIGH;
    } else {
      ledState = LOW;
    }

    // set the LED with the ledState of the variable:
    digitalWrite(ledPin, ledState);
  }
}

O segredo todo está nas linhas abaixo. A cada ver que eu entrar na função principal (cada 50ms) eu adiciono 10 no valor da saída analógica, que vai de 0 a 1023.

if(valor <= 1020){
      valor= valor + 10;
      analogWrite(A0, valor);
    }else{
      valor= 0;
    }

Ao passar de 1020 eu jogo zero na variável para começar denovo. Observe o LED verde ligando aos poucos, de forma analógica entre 0 e 1020 inteiros.

O que mais tem de importante

Apesar de o Arduino Zero não ter “pego” muito, a própria Adafruit tem bastante placas que utilizam o ATSAMD21. Dá pra achar bastante placas baseadas nele no Aliexpress também. E o mais legal é que ele roda microPython, o que é ótimo para iniciantes.

Mesmo com o advento do RISC-V os ARM Cortex ainda tem muito futuro pela frente, ainda mais com seu baixo consumo. A própria Arduino mantém o ATSAMD21 vivo na sua linha MKR, principalmente com adição de chip Wi-Fi e GPS.