Programação em blocos no Arduino: pisque um LED com blocos e C++ lado a lado

Na programação em blocos com Arduino, o primeiro programa é quase sempre o mesmo: piscar um LED. Neste texto fazemos isso do começo ao fim. Ligamos um LED ao pino 9 com um resistor de 220 Ω, lemos um por um os blocos do projeto LED piscante no app BlueGrays e vemos, lado a lado, em qual linha do código C++ carregado na placa cada bloco se transforma. Você também vai mudar um único número, o 100 do bloco “aguardar 100 ms”, para controlar a velocidade com que o LED pisca.

Não vamos parar em um LED. Vamos ampliar a mesma lógica, passo a passo, até chegar a programas que piscam dois LEDs alternadamente, funcionam como um semáforo e piscam como as luzes de uma viatura de polícia. Depois você verá a mesma ideia no ESP32 e no Raspberry Pi Pico com MicroPython. No final há uma tabela com os erros que quase todo iniciante comete pelo menos uma vez. Todos os projetos deste texto são grátis no app BlueGrays, com blocos e código, e você pode ver todos os projetos com blocos por plataforma na página programação em blocos.

Do que você precisa?

O circuito: ligando o LED ao pino 9

Um LED tem duas pernas, e a posição dele importa. A perna longa é o ânodo (+) e a perna curta é o cátodo (-); do lado do cátodo, o corpo de plástico tem uma borda reta. A corrente só passa do ânodo para o cátodo, então, se você colocar o LED invertido, nada acontece. Ligue o pino 9 do Arduino a uma ponta do resistor de 220 Ω e a outra ponta do resistor à perna longa do LED. Depois leve a perna curta ao GND. O resistor limita a corrente: tire dos 5 V os cerca de 2 V de que um LED vermelho precisa e sobram 3 V sobre o resistor; 3 V / 220 Ω dá cerca de 14 mA. É uma corrente confortável para o LED e segura para o pino do Arduino. Você pode conferir o valor para a cor do seu LED com a calculadora de resistor para LED. Como um LED funciona está em o que é um LED, e como as fileiras da protoboard são ligadas por dentro, em o que é uma protoboard.

Seu primeiro programa em blocos: LED piscante

Com o circuito pronto, vamos ao programa. Abra o projeto LED piscante no app BlueGrays e ative Ver em blocos na seção de código para ver os blocos abaixo. São sete blocos no total, divididos em dois grandes grupos: configuração (uma vez) em cima e repetir para sempre embaixo. Os blocos aparecem no idioma do app: em português, um deles diz “escrever ALTO no pino”; em inglês, o mesmo bloco diz “write HIGH to pin”.

Os blocos dentro de configuração (uma vez) rodam uma única vez, quando a placa é ligada ou quando você aperta o reset. Aqui há um único bloco: “configurar pino 9 como SAÍDA”. Os pinos digitais do Arduino podem ser entradas ou saídas. Como vamos acionar um LED, estamos dizendo à placa: “vou mandar energia para fora por este pino”. O grupo repetir para sempre começa quando a configuração termina e roda de cima para baixo, de novo e de novo, enquanto a placa estiver ligada. Seus quatro blocos acendem o LED, esperam 100 milissegundos, apagam o LED e esperam mais 100 milissegundos. Depois do último bloco, o programa volta ao topo e o LED acende de novo. O que chamamos de piscar são apenas esses quatro passos se repetindo cinco vezes por segundo.

Bloco → linha de C++: no que cada bloco se transforma?

1// Led Yakma (proje 1): D9'daki LED 100 ms yanar, 100 ms söner
2// LED Blink (project 1): the LED on D9 is on for 100 ms, off for 100 ms
3void setup() {
4  pinMode(9,OUTPUT);     // LED pini çıkış / LED pin as output
5}
6
7void loop() {
8  digitalWrite(9,HIGH);  // LED'i yak / turn the LED on
9  delay(100);            // 100 ms bekle (1000 ms = 1 s) / wait 100 ms (1000 ms = 1 s)
10  digitalWrite(9,LOW);   // LED'i söndür / turn the LED off
11  delay(100);            // 100 ms bekle / wait 100 ms
12}
13

Coloque a tabela ao lado do código e você vê o que os blocos resolvem por você. O formato dos grupos configuração e repetir para sempre corresponde às chaves das funções void setup() e void loop(): o grupo em que um bloco está decide dentro de qual par de chaves a linha dele é escrita. Com blocos, você não precisa pensar no ponto e vírgula no fim de cada instrução, em maiúsculas e minúsculas (pinMode, digitalWrite) nem em parênteses. Mas, quando você começa a editar o código por conta própria na Arduino IDE, isso passa a importar; um único ponto e vírgula esquecido já basta para dar erro de compilação. Esse é o verdadeiro benefício dos blocos: primeiro você acerta a lógica do programa, depois aprende como essa mesma lógica é escrita em código.

O que acontece se você mudar o “aguardar 100 ms”?

O tempo de espera é em milissegundos (ms), e 1000 ms equivalem a um segundo. Os dois blocos de espera do projeto estão em 100 ms, então o LED fica aceso por 0,1 segundo e apagado por 0,1 segundo. Um ciclo completo leva 200 ms, ou seja, o LED pisca cinco vezes por segundo. Aumente o número nos dois blocos e o LED fica mais lento; diminua e ele fica mais rápido. Abaixo de certo ponto, seu olho já não consegue separar as piscadas e o LED parece aceso o tempo todo. A tabela mostra o que você vai ver ao mudar as duas esperas:

Ampliando o programa: dois LEDs, um semáforo, luzes de polícia

Depois que você sabe piscar um LED, não precisa de nada novo para controlar vários; basta repetir os mesmos três blocos com pinos diferentes. No projeto Dois LEDs piscando alternadamente, dois pinos viram saída na configuração: 8 e 9. Dentro de repetir para sempre vêm “escrever ALTO no pino 8” e “escrever BAIXO no pino 9”, depois “aguardar 200 ms”. Em seguida, escreve-se o contrário e o programa espera 200 ms de novo. O truque é que os dois blocos de escrita rodam um logo após o outro, sem espera entre eles, então os dois LEDs parecem trocar no mesmo instante. O bloco de espera decide quanto tempo dura cada estado.

O projeto Semáforo leva a mesma ideia a três LEDs: vermelho no D2, amarelo no D3, verde no D4. O grupo repetir para sempre tem quatro fases, e cada uma segue o mesmo padrão: um bloco escrever ALTO ou escrever BAIXO para cada um dos três LEDs e, depois, um bloco de espera. Os blocos de escrita decidem qual LED fica aceso, e o bloco de espera decide por quanto tempo. Mais blocos não deixam o programa mais difícil, só mais longo. (No Brasil, o amarelo só aparece entre o verde e o vermelho; para imitar isso, basta remover a fase 2.) Uma versão mais próxima de um cruzamento real, com botão de pedestre, está no texto semáforo com Arduino.

1// Trafik Lambası (proje 3) / Traffic Light (project 3)
2void setup() {
3  pinMode(2,OUTPUT);    // Kırmızı / Red
4  pinMode(3,OUTPUT);    // Sarı / Yellow
5  pinMode(4,OUTPUT);    // Yeşil / Green
6}
7
8void loop() {
9  // Kırmızı yanar, 2 s bekle / Red on, wait 2 s
10  digitalWrite(2,HIGH);
11  digitalWrite(3,LOW);
12  digitalWrite(4,LOW);
13  delay(2000);
14  // Sarı yanar, 0,3 s bekle / Yellow on, wait 0.3 s
15  digitalWrite(2,LOW);
16  digitalWrite(3,HIGH);
17  digitalWrite(4,LOW);
18  delay(300);
19  // Yeşil yanar, 2 s bekle / Green on, wait 2 s
20  digitalWrite(2,LOW);
21  digitalWrite(3,LOW);
22  digitalWrite(4,HIGH);
23  delay(2000);
24  // Sarı yanar, sonra başa (kırmızıya) dön / Yellow on, then back to red
25  digitalWrite(2,LOW);
26  digitalWrite(3,HIGH);
27  digitalWrite(4,LOW);
28  delay(300);
29}
30

O projeto Luzes de polícia com LEDs apresenta dois novos tipos de bloco. O primeiro é o grupo variáveis globais (no topo), com o bloco “declarar inteiro (int) delayTime = 60” dentro. Essa é a linha int delayTime = 60; do código, e ela dá um nome ao tempo de cada piscada. Como os blocos de espera usam delayTime em vez de um número, você muda a velocidade editando só o 60, e não quatro blocos separados. O segundo é o bloco verde “repetir 3 vezes”; ele roda três vezes os quatro blocos que estão dentro dele e vira o laço for(int i=0;i<3;i++) em C++.

Vamos às contas: em cada piscada, o LED vermelho fica aceso por 60 ms e apagado por 60 ms, então uma piscada leva 120 ms. Três piscadas somam 360 ms, e o mesmo vale para o LED azul. Um ciclo completo leva cerca de 0,7 segundo. Coloque delayTime em 30 e as luzes piscam duas vezes mais rápido; coloque em 120 e elas ficam mais lentas. Variáveis e laços são o tema da parte 4 da série, em que explicamos tudo em detalhes no texto “repetir para sempre”, contagem e blocos de array. O projeto Sequencial de LEDs, que faz a luz correr por uma fileira de LEDs, é o próximo passo no mesmo caminho.

A mesma ideia no ESP32 e no Raspberry Pi Pico

No ESP32, os blocos são quase idênticos aos do Arduino, porque o ESP32 também é programado em C++ com a Arduino IDE. No projeto LED piscando com ESP32, o LED fica no GPIO 5 e os blocos de espera estão em 500 ms. As linhas de código também são as mesmas: pinMode(5, OUTPUT); digitalWrite(5, HIGH); delay(500);. As únicas diferenças são o número do pino, o fato de os pinos do ESP32 fornecerem 3,3 V e a escolha de uma placa ESP32 na Arduino IDE. Tudo o que você aprende no Uno vale direto para o ESP32.

Nos projetos com Raspberry Pi Pico, os blocos viram código MicroPython e os nomes dos blocos mudam um pouco. No projeto Raspberry Pi Pico: controle de LED externo, o LED fica no GP14. O bloco “pino led : GP LED_PIN, SAÍDA” corresponde a led = Pin(LED_PIN, Pin.OUT), “ligar (on) pino led” corresponde a led.on(), “aguardar 0.5 segundos” corresponde a time.sleep(0.5), e repetir para sempre corresponde ao laço while True:. Repare que, no MicroPython, a espera é em segundos, não em milissegundos; o delay(500) do Arduino vira time.sleep(0.5). Se quiser testar sem nenhuma fiação, o projeto Piscar o LED integrado do Raspberry Pi Pico acende o LED do GP25, na própria placa; no Pico W, o LED integrado é acessado pelo nome “LED” em vez de GP25.

1# Pico harici LED (proje 8163), seri port satırları çıkarıldı
2# Pico external LED (project 8163), serial print lines removed
3from machine import Pin
4import time
5
6LED_PIN = 14                    # GP14, herhangi bir boş GPIO / any free GPIO
7led = Pin(LED_PIN, Pin.OUT)     # pini çıkış yap / set the pin as output
8
9while True:                     # sürekli tekrarla / loop forever
10    led.on()                    # LED'i yak / turn the LED on
11    time.sleep(0.5)             # 0,5 saniye bekle / wait 0.5 s
12    led.off()                   # LED'i söndür / turn the LED off
13    time.sleep(0.5)
14

Erros comuns e como corrigir

Passo a passo no app: dos blocos à placa

1. No app BlueGrays, abra o projeto LED piscante, que tem o selo Blocos na lista de projetos. Você também pode usar o filtro para mostrar só os projetos com blocos.
2. Seguindo o esquema do circuito, coloque o LED, o resistor de 220 Ω e dois fios na protoboard.
3. Na seção de código, ative Ver em blocos. Os blocos aparecem no lugar do código; toque na imagem para abri-la em tela cheia.
4. Vá para a aba Entenda os blocos. O programa é explicado passo a passo, e cada passo mostra só os próprios blocos e o que eles fazem.
5. Desative a chave para voltar ao código real, copie-o e cole na Arduino IDE. Os blocos não são carregados direto na placa; o que vai para ela é sempre este código.
6. Na Arduino IDE, selecione Arduino Uno como placa, escolha a porta certa e clique em Carregar. Se você ainda não instalou a IDE, o texto como instalar a Arduino IDE mostra o passo a passo.
7. Quando o LED estiver piscando, mude as duas linhas delay(100) para delay(1000), carregue de novo e veja a diferença com seus próprios olhos.

Neste texto, o LED sempre piscou no mesmo ritmo; o programa nunca ouviu o mundo lá fora. O próximo passo é deixar a placa tomar decisões: a parte 3 da série, o botão e o bloco “se”, mostra um programa que acende o LED quando você aperta um botão e como o bloco “se” vira if/else em C++.

No app BlueGrays, você pode ver LED piscante, Dois LEDs piscando alternadamente, Semáforo, Luzes de polícia com LEDs e os projetos de LED para ESP32 e Pico com esquema do circuito e código, passar para a versão em blocos do mesmo programa com Ver em blocos e ler o que cada passo faz em Entenda os blocos.