Laços e variáveis na programação em blocos: laço for e vetores no Arduino

Laços e variáveis na programação em blocos são as duas peças que transformam um programa de “faça isto uma vez” em “continue fazendo isto, e de um jeito inteligente”. Um laço executa os mesmos blocos de novo e de novo, e uma variável guarda um número na memória enquanto essas repetições acontecem. Nos blocos do BlueGrays eles aparecem como “repetir para sempre”, “contar com i”, “variáveis globais (no topo)” e “definir … como …”; no código Arduino que vai para a placa, os equivalentes são loop(), o laço for, uma variável int e uma linha de atribuição.

Nesta parte vamos ler os blocos de quatro projetos grátis lado a lado com o código C++ real: Sequencial de LEDs, que acende seis LEDs um depois do outro; Sequencial de LEDs com velocidade ajustável, que pega a velocidade de um potenciômetro; Efeito Knight Rider com LEDs, que leva a luz de uma ponta à outra e de volta; e a versão dele com potenciômetro, Efeito Knight Rider com LEDs e velocidade ajustável. Os quatro usam o mesmo circuito: seis LEDs nos pinos D2–D7 e um potenciômetro no A0. No final você vai escrever o seu próprio exemplo de contador e conhecer os três erros que os iniciantes mais cometem: contar uma vez a mais ou a menos, passar do fim de um vetor e esperas longas que deixam os botões cegos.

O bloco “repetir para sempre” e o loop(): por que a placa nunca para?

Um programa no computador fecha quando termina o seu trabalho; um programa no Arduino, não. A placa não tem sistema operacional, e o processador não tem mais nada para fazer. Por isso todo projeto em blocos tem o mesmo esqueleto: o que está dentro de “configuração (uma vez)” roda uma única vez quando a placa é ligada ou quando o botão de reset é pressionado, e o que está dentro de “repetir para sempre” se repete de cima para baixo, sem parar. Do lado do C++, essas são as funções setup() e loop(). Quando a última linha do loop() termina, a placa volta direto para a primeira linha; um loop() curto e sem nenhuma espera pode rodar dezenas de milhares de vezes por segundo. As únicas formas de parar a placa são cortar a alimentação ou carregar um novo programa. Essa repetição sem fim não é um defeito, é o próprio projeto: ler um botão, acompanhar um sensor e piscar um LED são feitos de novo a cada volta, e assim a placa continua reagindo ao que muda ao redor dela.

Variáveis na programação em blocos: variáveis globais e o bloco declarar

Uma variável é uma caixinha onde você coloca um número e que você chama pelo nome. Nos blocos, as variáveis são criadas dentro do bloco roxo “variáveis globais (no topo)”. O bloco “declarar inteiro (int) potValue = 0” dentro dele vira a linha int potValue no código: int é o tipo, potValue é o nome e 0 é o valor inicial. O “no topo” importa: essas linhas ficam bem no começo do arquivo, fora de setup() e de loop(). Uma variável global declarada assim pode ser vista de qualquer parte do programa e não perde o valor cada vez que o loop() recomeça. No Arduino Uno, um int ocupa 2 bytes e guarda números inteiros de -32768 a 32767, mais do que suficiente para a faixa de 0–1023 do analogRead() e para números de pino. Talvez você note que os blocos do Sequencial de LEDs com velocidade ajustável dizem potValue = 0, enquanto o código diz só int potValue;. As duas formas dão o mesmo resultado: em C++, uma variável global sem valor inicial começa em zero.

O bloco que muda uma variável depois é o “definir … como …”. O bloco “definir potValue como ler analógico A0” vira potValue = analogRead(A0); no código. O sinal = aqui não é a igualdade da matemática; ele quer dizer “calcule o valor da direita e coloque na caixa da esquerda”. Uma comparação que pergunta se dois valores são iguais é escrita com == em C++, como vimos com o bloco “se” na parte anterior da série. Quando o bloco definir roda, o valor antigo da caixa é apagado e o novo é escrito. Todo bloco que lê a variável passa a usar esse novo valor: “aguardar potValue ms” espera tantos milissegundos quanto potValue guardar naquele momento.

O laço de contagem: o bloco “contar com i” e o laço for do Arduino

Para repetir algo um número fixo de vezes, você usa o bloco verde “contar com i de 0 até 5 em passos de 1”. Ele cria um contador chamado i, coloca 0 nele, executa os blocos de dentro, depois soma 1 a i e executa tudo de novo, e continua assim até i passar de 5. O equivalente no Arduino é a linha for (int i = 0; i < 6; i++). Dentro dos parênteses há três partes separadas por ponto e vírgula: o início (int i = 0), a condição para continuar (i < 6) e o passo feito depois de cada repetição (i++, que quer dizer somar um a i). O mais importante a perceber: o valor final do bloco está incluído. “De 0 até 5” significa 0, 1, 2, 3, 4 e 5, então o laço roda 6 vezes, não 5, e cada um dos seis LEDs ganha uma repetição. Por isso o código diz i < 6, que tem o mesmo significado de i <= 5. O padrão “comece do zero e continue enquanto for menor que o número de itens” é muito comum no código Arduino, porque o 6 diz diretamente quantos LEDs existem.

O bloco de vetor: “vetor 2 3 4 5 6 7” e ledPins[i]

Em vez de declarar seis variáveis separadas para seis LEDs, você pode guardar todos numa única lista. Quando o bloco roxo “vetor 2 3 4 5 6 7” é encaixado em “declarar inteiro (int) ledPins = …”, ele vira a linha int ledPins[] = {2, 3, 4, 5, 6, 7}; no código. Os colchetes dizem que é um vetor (array), e as chaves guardam os valores dele. Você chega a um elemento pelo número da posição, o índice, e em C++ o índice começa em 0: o primeiro elemento é ledPins[0] e o último é ledPins[5]. Nos blocos isso é feito por “elemento i de ledPins”, que vira ledPins[i]. Como o laço de contagem também começa em 0, os dois se encaixam perfeitamente: a cada repetição, i dá o próximo índice e ledPins[i] dá o número de pino guardado ali. Outra vantagem dos vetores: para mudar a ordem dos LEDs, basta trocar os números da lista de lugar, sem mexer no laço. Para saber mais sobre vetores, veja vetores (arrays) no Arduino.

Sequencial de LEDs: blocos e C++ linha por linha

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2
3void setup() {
4  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
5  for(int i = 0; i < 6; i++) {
6    pinMode(ledPins[i], OUTPUT);
7  }
8}
9
10void loop() {
11  // Her LED'i sırayla 150 ms yak / Light each LED in turn for 150 ms
12  for(int i = 0; i < 6; i++) {
13    digitalWrite(ledPins[i], HIGH);
14    delay(150);
15    digitalWrite(ledPins[i], LOW);
16  }
17}

Pense no programa como uma linha do tempo. Quando a placa inicia, o laço da configuração transforma os seis pinos em saídas, um por um, de 0 a 5, e isso nunca mais acontece. Então começa o repetir para sempre: o laço de contagem dentro dele acende o LED do D2, espera 150 ms, apaga, e depois faz o mesmo com D3, D4, D5, D6 e D7. Uma volta leva 6 × 150 = 900 ms. Quando o último LED apaga, o loop() termina, a placa volta direto para o começo e a luz recomeça no D2; como não há intervalo entre as voltas, a luz parece correr sem parar. Para mudar a velocidade, você só troca um número, o 150: escreva 50 e a luz corre três vezes mais rápido, escreva 500 e ela passeia devagar. Tornar essa velocidade fixa ajustável com um botão giratório nos leva ao próximo projeto.

Sequencial de LEDs com velocidade ajustável: o valor do potenciômetro vira o tempo de espera

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2int potValue;                         // Pot değeri = bekleme (ms) / Pot value = delay (ms)
3
4void setup() {
5  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
6  for(int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for(int i = 0; i < 6; i++) {
13    potValue = analogRead(A0);        // Hızı oku (0-1023) / Read the speed (0-1023)
14    digitalWrite(ledPins[i], HIGH);
15    delay(potValue);                  // Pot değeri kadar ms bekle / Wait as many ms as the pot value
16    digitalWrite(ledPins[i], LOW);
17  }
18}

A única diferença em relação ao Sequencial de LEDs são dois blocos novos. “declarar inteiro (int) potValue = 0” foi adicionado às variáveis globais, e o laço de contagem começa com um bloco “definir potValue como ler analógico A0”. analogRead(A0) transforma a tensão no pino do meio do potenciômetro em um número de 0 a 1023; esse número vai direto para “aguardar potValue ms”, ou seja, para a linha delay(potValue). Gire o potenciômetro até uma ponta e cada LED fica aceso por cerca de um segundo (1023 ms), então uma volta leva uns 6 segundos; gire até a outra ponta e a espera cai para 0, e os LEDs trocam tão rápido que parecem todos acesos fracos ao mesmo tempo. Ler o potenciômetro dentro do laço, antes de cada LED, é uma escolha proposital: o próximo LED já usa a nova velocidade assim que você gira o botão, sem esperar a volta terminar. Você descobre como um potenciômetro funciona em o que é um potenciômetro.

Knight Rider: dois laços contando para a frente e para trás

No efeito Knight Rider (da série “A Super Máquina”), a luz vai de uma ponta à outra e volta. Os blocos do Efeito Knight Rider com LEDs têm dois laços de contagem, um embaixo do outro, dentro de repetir para sempre. O primeiro é o já conhecido “contar com i de 0 até 5 em passos de 1” e leva a luz do D2 ao D7. O segundo é “contar com i de 4 até 1 em passos de 1”: como o início é maior que o fim, o bloco conta para trás, e i vale 4, 3, 2, 1. No código, essa é a linha for(int i = 4; i > 0; i--); i-- subtrai um de i. Por que de 4 até 1, e não de 5 até 0? Porque ledPins[5] (D7) já está aceso no fim da ida, e ledPins[0] (D2), no começo da próxima. Pular as pontas na volta evita que os LEDs das extremidades acendam duas vezes seguidas, e o vaivém fica suave. Uma ida e volta são 6 + 4 = 10 passos de 100 ms, 1 segundo no total. O Efeito Knight Rider com LEDs e velocidade ajustável usa os mesmos dois laços; ele só acrescenta um bloco “definir potValue como ler analógico A0” no início de cada um e usa “aguardar potValue ms” no lugar de 100 ms. Para mais padrões, dê uma olhada em efeito Super Máquina e LED sequencial no Arduino.

Seu próprio exemplo de contador: um contador de voltas e a porta serial

Agora vamos escrever um pequeno exemplo que junta tudo: cada vez que o Sequencial de LEDs termina uma volta, um contador aumenta, e a placa envia ao computador tanto os valores de i quanto o número de voltas. Com os blocos das imagens, você montaria assim: nas variáveis globais, embaixo do vetor ledPins, adicione “declarar inteiro (int) rounds = 0”. A configuração ganha um bloco “iniciar serial a 9600 baud”. Dentro do laço de contagem, antes de o LED acender, blocos “escrever na serial” imprimem o texto “i = ”, depois i, depois o texto “ pin = ” com a opção “sem quebra” e, por fim, “elemento i de ledPins” com a opção “nova linha”. Depois do laço de contagem, ainda dentro de repetir para sempre, um bloco “definir rounds como …” recebe a soma rounds + 1, e o número de voltas é impresso com “escrever na serial … nova linha”.

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri / LED pins
2int rounds = 0;                       // tamamlanan tur sayısı / number of finished rounds
3
4void setup() {
5  Serial.begin(9600);                 // seri port 9600 baud / serial port at 9600 baud
6  for (int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for (int i = 0; i < 6; i++) {
13    Serial.print("i = ");             // aynı satırda kal / stay on the same line
14    Serial.print(i);
15    Serial.print("  pin = ");
16    Serial.println(ledPins[i]);       // alt satıra geç / new line
17    digitalWrite(ledPins[i], HIGH);
18    delay(300);
19    digitalWrite(ledPins[i], LOW);
20  }
21  rounds = rounds + 1;                // sayacı bir artır / add one to the counter
22  Serial.print("Tur / Round: ");
23  Serial.println(rounds);
24}

Depois de carregar, abra o Monitor Serial na Arduino IDE e ajuste para 9600 baud. A cada volta você vai ver seis linhas, de “i = 0 pin = 2” até “i = 5 pin = 7”, seguidas de uma linha “Tur / Round” (volta) que conta 1, 2, 3. Essa saída é a prova mais clara de que o valor final do bloco de contagem está incluído: “de 0 até 5” produz exatamente seis valores. Repare também que rounds é declarada nas variáveis globais; ela não é zerada cada vez que o loop() começa, então leva o seu valor de uma volta para a outra. Uma volta leva 6 × 300 = 1,8 segundo, então o limite de 32767 do int é atingido depois de umas 16 horas; se precisar contar por mais tempo, transforme a variável em unsigned long. Mais sobre o Monitor Serial em Monitor Serial do Arduino.

Circuito: 6 LEDs, resistores de 220 Ω e um potenciômetro

Um resistor de 220 Ω deixa passar cerca de (5 − 2) / 220 ≈ 14 mA por um LED vermelho alimentado com 5 V, o que é seguro tanto para o LED quanto para o pino do Arduino. Se você usar LEDs de outra cor, confira o resistor com a calculadora de resistor para LED. Junte todos os cátodos na trilha de GND da protoboard e ligue essa trilha ao pino GND do Arduino. Se você inverter as pernas das pontas do potenciômetro, nada estraga; só o sentido de giro fica invertido. Os projetos Sequencial de LEDs e Efeito Knight Rider com LEDs não usam o potenciômetro, e deixá-lo ligado não faz mal nenhum, então você pode testar os quatro projetos no mesmo circuito, um depois do outro.

Erros comuns com laços e variáveis

Explorando os blocos de laço e de variável no app BlueGrays

Os quatro projetos deste artigo e os listados abaixo são totalmente grátis no app BlueGrays, tanto os blocos quanto o código. Na seção de código de um projeto, ative a chave Ver em blocos e o código é substituído pelos blocos do mesmo programa; toque na imagem para abri-la em tela cheia e ampliar com calma os laços de contagem longos. A aba Entenda os blocos explica o programa passo a passo, mostrando só os blocos daquele passo e o que eles fazem. Outros projetos grátis que valem a pena ver em blocos: Luzes de polícia com LEDs, que funciona com uma variável delayTime e dois laços de contagem; Semáforo, que passa por quatro estados dentro de repetir para sempre; Medição da intensidade da luz com LDR, que guarda a leitura numa variável e a imprime na porta serial; e Ligar e desligar um LED com botão, que lembra o estado do LED numa variável. Todo exemplo de Arduino do Guia de código também aparece em blocos, e as Perguntas do dia ajudam você a reforçar o que aprendeu com 5 perguntas por dia, de A1 a C2. A lista completa de projetos com blocos está na página programação em blocos. Os blocos não são carregados diretamente na placa; a placa sempre recebe o código real do projeto, então você copia para a Arduino IDE o programa que entendeu pelos blocos e o envia para a sua placa.

Agora que você conhece laços e variáveis, o próximo passo é tirar esses números do mundo real: na parte 5 da série falamos de como ler sensores com blocos, a porta serial e a passagem para o MicroPython no Pico. Até lá, você pode ver no app BlueGrays o Sequencial de LEDs, o efeito Knight Rider e as versões com velocidade ajustável, com o esquema do circuito e o código, passar para os blocos com Ver em blocos e para a explicação passo a passo com Entenda os blocos, e acompanhar por conta própria a qual linha de código cada laço de contagem corresponde.