Comandos do Arduino: 36 cartões, C++ e MicroPython lado a lado

O jeito mais confiável de aprender os comandos do Arduino não é decorar uma lista longa, e sim passar por eles em ordem, cada um com um exemplo pequeno e um projeto real. O app BlueGrays tem um Guia de código exatamente para isso na seção Lições da aba Aprender: 18 cartões na trilha Arduino C++, de pinMode a tone, e 18 cartões na trilha MicroPython, de import a I2C, 36 cartões no total. Todo cartão segue o mesmo formato: Para que serve?, Por quê?, Sintaxe, Exemplo (com as abas Blocos, Arduino e MicroPython), Erro comum, Dica, Ver nos projetos e um Miniteste de duas perguntas. A ordem também é fixa: primeiro os pinos (pinMode, digitalWrite, digitalRead, analogRead, analogWrite), depois o tempo (delay, millis), em seguida variáveis, condições, laços e funções e, por fim, Serial, map, random e tone. Se você usa um Raspberry Pi Pico, aprende as mesmas ideias na trilha MicroPython com Pin, Pin.value, time.sleep, ADC.read_u16 e PWM.

Este post é um mapa do guia. Primeiro você vai ver o que tem dentro de um cartão e, depois, os 18 cartões de cada trilha na ordem real do app, com o equivalente na outra linguagem. Em seguida vêm três exemplos curtos que colocam lado a lado as versões em C++ e em MicroPython do mesmo programa, como funcionam o miniteste e o acompanhamento do progresso, uma ordem de aprendizado de 4 semanas, uma rotina diária de 20 minutos e os 8 erros mais comuns com esses comandos. Se você procura uma explicação detalhada de cada comando, o post Lista de comandos do Arduino com exemplos dedica uma seção a cada um; este post trata da ordem para aprendê-los e de como praticar.

Onde fica o Guia de código e como ele funciona?

Você abre o guia pela aba Aprender, na parte inferior: na seção Lições, no topo, toque no bloco Guia de código. Quando o guia abre, você vê duas abas no topo: Arduino C++ e MicroPython; o app lembra qual trilha você abriu por último. Abaixo das abas há um contador O que você aprendeu e uma linha Próximo cartão, para você nunca precisar procurar onde parou. Os cartões são agrupados por tema: Pinos, Tempo, Variáveis, Condições, Laços, Funções, Porta serial, Matemática e Som; a trilha MicroPython acrescenta Estrutura básica e Tratamento de erros. O Guia de código é grátis: você não precisa do Premium para ler os cartões, ver os exemplos ou resolver os minitestes. Os cartões estão disponíveis em 10 idiomas, então você lê as explicações no idioma em que usa o app.

O que tem dentro de um cartão?

Todo cartão usa o mesmo esqueleto, então, a partir do terceiro cartão, você já sabe exatamente onde olhar. A tabela abaixo mostra as seções usando o 7º cartão da trilha Arduino, millis; a coluna da direita é um resumo curto do que o cartão realmente diz. A própria ordem das seções é uma ordem de aprendizado: primeiro você ouve numa frase o que o comando faz, depois entende por que precisa dele com uma comparação do dia a dia, vê como ele é escrito, lê um exemplo que funciona, conhece a armadilha mais comum e se testa com duas perguntas.

A seção Exemplo abre na trilha do próprio cartão: num cartão de Arduino, a aba Arduino vem primeiro; num cartão de MicroPython, a aba MicroPython. Mas a outra aba está sempre lá também, e isso transforma o guia num dicionário. No cartão Pino de saída: Pin(15, Pin.OUT) da trilha MicroPython, por exemplo, a aba Arduino traz um código que faz o mesmo trabalho com pinMode e digitalWrite, e os comentários dizem qual linha corresponde a quê (como a linha que faz o papel de led.toggle()). Quase todo cartão tem também uma terceira aba, Blocos, que mostra o programa de exemplo em blocos. Se você está passando do Arduino para o Pico, o método mais rápido é este: abra um cartão que você já conhece, troque de aba e compare os dois programas linha por linha.

Trilha Arduino C++: 18 cartões e seus equivalentes em MicroPython

A tabela abaixo é a ordem real da trilha Arduino no app; a última coluna mostra como o mesmo trabalho é feito em MicroPython num Raspberry Pi Pico. Os números dos pinos são os mesmos dos exemplos dos cartões: para um LED, 13 ou 9 no Uno e GP15 no Pico; para um botão, 2 no Uno e GP14 no Pico; para leitura analógica, A0 no Uno e GP26 no Pico. Os cinco primeiros cartões cobrem os pinos, o 6 e o 7 cobrem o tempo, do 8 ao 14 vêm os fundamentos de programação e os quatro últimos cobrem a porta serial, a mudança de escala, os números aleatórios e o som. A ordem é proposital: primeiro você aprende como a placa toca o mundo lá fora e, depois, controla esses toques com variáveis, condições e laços.

Trilha MicroPython: 18 cartões e seus equivalentes em Arduino

A trilha MicroPython foi escrita pensando no Raspberry Pi Pico; os exemplos dos cartões são programas curtos que você pode rodar num Pico, por exemplo com o Thonny. A ordem é um pouco diferente da trilha Arduino, porque em Python você precisa primeiro se acostumar às regras da própria linguagem: adicionar módulos com import, imprimir com print e a regra da indentação e dos dois-pontos. A aba Arduino de cada cartão de MicroPython também traz a versão em C++ do mesmo programa, então, se você já conhece Arduino, pode ler a tabela da direita para a esquerda. Se é a primeira vez que você usa um Pico, o post O que é o Raspberry Pi Pico é uma boa preparação para a instalação e os pinos.

O mesmo programa em duas linguagens: 3 exemplos lado a lado

O primeiro exemplo é o “olá, mundo” de toda linguagem: piscar o LED da placa a cada meio segundo. No Uno, o LED integrado está ligado ao pino 13, então você não precisa montar nenhum circuito. O Pico é um pouco diferente: no Pico comum, o LED da placa fica no GP25, mas no Pico W o LED está ligado ao chip sem fio e Pin(25) não o acende. Por isso, escrever Pin("LED", Pin.OUT) em MicroPython é mais seguro; nas versões atuais do MicroPython, esse nome encontra o LED da placa tanto no Pico quanto no Pico W. Se o firmware da sua placa não reconhecer o nome “LED”, instale um MicroPython atual no Pico. O projeto grátis Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W) explica justamente essa diferença.

1// Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the built-in LED
2void setup() {
3  pinMode(13, OUTPUT);     // Uno'da dahili LED 13. pinde / built-in LED is on pin 13 on the Uno
4}
5
6void loop() {
7  digitalWrite(13, HIGH);  // LED yanar / LED on
8  delay(500);              // 500 ms bekle / wait 500 ms
9  digitalWrite(13, LOW);   // LED söner / LED off
10  delay(500);              // 500 ms bekle / wait 500 ms
11}

1# Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)  # Pico ve Pico W'de dahili LED / onboard LED on Pico and Pico W
6# Pin(25, Pin.OUT) yalnız düz Pico'da çalışır / Pin(25, Pin.OUT) works only on the plain Pico
7
8while True:                # Arduino'daki loop() gibi / like loop() in Arduino
9    led.on()               # LED yanar / LED on
10    time.sleep_ms(500)     # 500 ms bekle / wait 500 ms
11    led.off()              # LED söner / LED off
12    time.sleep_ms(500)     # 500 ms bekle / wait 500 ms

O segundo exemplo acrescenta uma entrada: o LED fica aceso enquanto o botão está pressionado. O botão vai entre o pino 2 e o GND no Uno, e entre o GP14 e o GND no Pico. No Uno, usamos de novo o LED integrado do pino 13; no Pico, ligue um LED externo ao GP15 por um resistor de 220 Ω (a ferramenta Resistor para LED calcula esse valor para o seu LED). As duas linguagens ativam o resistor de pull-up interno: INPUT_PULLUP no Arduino, Pin.PULL_UP no MicroPython. Com essa ligação, a lógica fica invertida: pressionar o botão puxa o pino para o GND, então o Arduino lê LOW e o Pico lê 0. A pausa de 20 ms no final não resolve totalmente o repique mecânico do botão, mas reduz as oscilações muito curtas. Os detalhes da ligação do botão estão no post Como ligar um botão no Arduino.

1// Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2const int BUTTON_PIN = 2;  // buton: 2. pin ile GND arasında / button between pin 2 and GND
3const int LED_PIN = 13;    // dahili LED / built-in LED
4
5void setup() {
6  pinMode(BUTTON_PIN, INPUT_PULLUP);  // iç pull-up direnci açık / internal pull-up on
7  pinMode(LED_PIN, OUTPUT);
8}
9
10void loop() {
11  if (digitalRead(BUTTON_PIN) == LOW) {  // basılıyken LOW okunur / reads LOW while pressed
12    digitalWrite(LED_PIN, HIGH);
13  } else {
14    digitalWrite(LED_PIN, LOW);
15  }
16  delay(20);  // kısa bekleme / short pause
17}

1# Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2from machine import Pin
3import time
4
5button = Pin(14, Pin.IN, Pin.PULL_UP)  # buton: GP14 ile GND arasında / button between GP14 and GND
6led = Pin(15, Pin.OUT)                 # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7
8while True:
9    if button.value() == 0:            # basılıyken 0 okunur / reads 0 while pressed
10        led.value(1)
11    else:
12        led.value(0)
13    time.sleep_ms(20)                  # kısa bekleme / short pause

O terceiro exemplo mostra a diferença mais importante entre as duas linguagens: as faixas de números. O pino do meio do potenciômetro vai no A0 no Uno e no GP26 no Pico; os pinos das pontas vão no 5V e no GND no Uno, e no 3V3 (OUT) e no GND no Pico. O LED vai no pino 9 (marcado com ~) no Uno e no GP15 no Pico, cada um com um resistor de 220 Ω. No Arduino, analogRead retorna 0–1023, mas analogWrite espera 0–255, por isso map(raw, 0, 1023, 0, 255) fica no meio. No Pico, tanto read_u16 quanto duty_u16 usam 0–65535, então você pode passar a leitura direto para o PWM. Você vê como o PWM funciona no post O que é PWM e como acompanhar os valores ao vivo no guia do Monitor Serial.

1// Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2const int POT_PIN = A0;  // potansiyometrenin orta ucu / potentiometer wiper
3const int LED_PIN = 9;   // ~ işaretli PWM pini / PWM pin marked with ~
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7  Serial.begin(9600);
8}
9
10void loop() {
11  int raw = analogRead(POT_PIN);               // 0-1023
12  int brightness = map(raw, 0, 1023, 0, 255);  // 0-255 aralığına ölçekle / scale to 0-255
13  analogWrite(LED_PIN, brightness);
14  Serial.println(raw);                         // Seri Monitör'de izle / watch in the Serial Monitor
15  delay(50);
16}

1# Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2from machine import Pin, ADC, PWM
3import time
4
5pot = ADC(26)            # GP26 = ADC0, orta uç / wiper on GP26 (ADC0)
6led = PWM(Pin(15))       # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7led.freq(1000)           # saniyede 1000 aç-kapa / 1000 cycles per second
8
9while True:
10    raw = pot.read_u16()     # 0-65535
11    led.duty_u16(raw)        # aynı aralık, ölçekleme gerekmez / same range, no scaling needed
12    print(raw)               # Thonny kabuğunda izle / watch in the Thonny shell
13    time.sleep_ms(50)

Miniteste, “Concluir” e seu progresso em Meu nível

• Miniteste: todo cartão termina com duas perguntas, e o título mostra Miniteste · 1 / 2. Quando você toca numa opção, recebe na hora Correta. ou Incorreta. com uma explicação curta; você continua com Próxima pergunta.
• Pontuação: quando as duas perguntas terminam, você vê uma pontuação como 2 / 2 corretas. O cartão não pode ser concluído sem o teste; no lugar do botão aparece Resolva o miniteste para concluir este cartão.
• Concluir: depois do teste, aparece o botão Concluir e avançar (no último cartão de uma trilha, é só Concluir). Ao tocar nele, o cartão fica salvo como aprendido na sua conta, uma breve comemoração mostra seu progresso, como Muito bem! 5 / 18 cartões, e o próximo cartão se abre.
• Selo e contador: os cartões que você aprendeu mostram a marca Aprendido na lista, e o contador O que você aprendeu no topo do guia aumenta. Quando você termina todos os cartões de uma trilha, aparece Você aprendeu todos os cartões desta trilha.
• Meu nível: na tela Meu nível da seção Aprender, sob o título Guia de código e a nota Cartões que você já estudou, há duas barras separadas: Arduino C++ x/18 e MicroPython x/18. Essas barras contam só os cartões do guia de código.
• Uma regra honesta para você mesmo: o app não bloqueia você depois de uma resposta errada; o botão Concluir aparece assim que o teste termina. Então, antes de tocar nele, confira se você consegue explicar em voz alta por que as duas respostas estão corretas; se não conseguir, volte à seção Exemplo e leia o código linha por linha mais uma vez.

Ver nos projetos: encontrando o comando em código de verdade

O último passo para aprender um comando é reconhecê-lo num projeto que funciona, escrito por outra pessoa. A seção Ver nos projetos de um cartão mostra alguns projetos selecionados, com uma frase embaixo dizendo quantos projetos usam o comando no código; o link Todos abre a lista completa. A lista vai do mais fácil ao mais difícil e pode ser filtrada com Todos, Grátis e Premium. O millis, por exemplo, aparece no código de mais de 50 projetos: a lista começa com o grátis Controle de LED com botão no ESP32 (alternância), segue com projetos de Pico para iniciantes como Piano de botões com Raspberry Pi Pico (5 botões + buzzer + gravador de melodias) e Sensor de estacionamento com Raspberry Pi Pico (HC-SR04 + 3 LEDs + buzzer) e sobe até projetos intermediários como Raspberry Pi Pico: semáforo com 4 modos selecionados por botão (máquina de estados, GP11-13 + GP4), que combinam um botão com temporização. Nossa sugestão: abra um projeto grátis da lista, encontre o comando no código, mude um valor e preveja o resultado antes. Para ver o que cada linha do código faz, a aba Entenda o código do projeto é o próximo passo natural.

Ordem de aprendizado recomendada: um plano de 4 semanas

Vamos supor que você tenha uns 20 minutos por dia, 5 dias por semana. Para terminar uma trilha em 4 semanas, um cartão na maioria dos dias basta; nos outros dias, em vez de um cartão novo, você revisa e trabalha num projeto. Se você tem um Arduino, siga só a coluna do Arduino; se tem um Pico, a coluna do MicroPython. Se tem os dois, termine primeiro a trilha Arduino e passe para o MicroPython no segundo mês; os conceitos são os mesmos, então a segunda trilha vai bem mais rápido. Todos os projetos da tabela são grátis no BlueGrays. Se quiser um plano mais amplo, o roteiro de 30 dias do post App para aprender Arduino combina bem com esta tabela; se você dá aulas com o Pico, o plano de aula de Raspberry Pi Pico distribui os cartões de MicroPython em 6 semanas de aulas.

Uma rotina diária de 20 minutos

1. 3 minutos, aquecimento: resolva as Perguntas do dia na seção Aprender ou refaça o miniteste de ontem. O objetivo é conferir se você ainda lembra hoje do comando de ontem.
2. 5 minutos, cartão novo: leia as seções Para que serve?, Por quê? e Sintaxe. Copie a sintaxe à mão no papel; escrevendo, fica mais difícil seus olhos pularem parênteses e pontos e vírgulas.
3. 3 minutos, exemplo: explique o exemplo para si mesmo linha por linha e depois troque de aba. Num cartão de Arduino, olhe a aba MicroPython; num cartão de MicroPython, a aba Arduino, e compare as linhas que fazem o mesmo trabalho nos dois programas.
4. 2 minutos, miniteste: responda às duas perguntas e leia a explicação das que errou. Dê mais uma olhada nas caixas Erro comum e Dica nesse momento.
5. 6 minutos, projeto: abra um projeto grátis e fácil da lista Ver nos projetos, encontre o comando no código e mude um único valor: um tempo de espera, um número de pino ou um limite. Se o seu circuito estiver pronto, carregue na placa; se não, preveja o resultado e confira com Entenda o código.
6. 1 minuto, anotação: escreva uma linha no caderno: o nome do comando, o significado dele numa frase e o equivalente na outra linguagem. No fim das quatro semanas, essa página é o seu próprio dicionário de comandos.

8 erros comuns com esses comandos

A aba Blocos: entender um comando vendo-o

A aba Blocos permite ver o que um comando faz sem escrever código, principalmente nos primeiros cartões de uma trilha. Na imagem acima, pinMode vira o bloco “configurar pino 9 como SAÍDA”, digitalWrite vira “escrever ALTO no pino 9” e delay vira “aguardar 100 ms”; no cartão pinMode, uma nota abaixo da visualização em blocos também lista as opções do menu suspenso: SAÍDA, ENTRADA e ENTRADA (PULLUP). Os blocos aparecem no idioma do app e servem para leitura: no app você não arrasta blocos para escrever um programa, e a placa sempre recebe o código de verdade. O jeito sugerido de usá-los: primeiro preveja o que o programa vai fazer na aba Blocos, depois troque para a aba Arduino e descubra qual linha é cada bloco. Nos projetos que têm visualização em blocos, o botão Ver em blocos na página do projeto permite fazer a mesma comparação com um projeto inteiro; o básico está no post O que é programação em blocos.

Resumindo, você não precisa de uma lista longa para aprender os comandos do Arduino: bastam a ordem certa, um exemplo pequeno que funcione para cada comando, uma verificação de duas perguntas e um projeto real que use o comando. Se você começar hoje pelo cartão pinMode, em quatro semanas terá terminado os 18 cartões e visto com os próprios olhos cada comando em pelo menos um projeto; quando passar para o Pico, vai percorrer os mesmos conceitos na trilha MicroPython bem mais rápido. Se quiser experimentar os cartões e os projetos dentro deles, instale o BlueGrays no celular e abra o primeiro cartão na seção Aprender.