Da programação em blocos ao Arduino C++: tabela de consulta com MicroPython

O jeito mais rápido de passar da programação em blocos ao Arduino C++ é ter ao lado uma tabela de uma página que mostra em qual linha de código real cada bloco se transforma. A resposta curta: blocos não são uma linguagem nova, são a forma visual de linhas de Arduino C++. O bloco “configurar pino 13 como SAÍDA” é a linha pinMode(13, OUTPUT);, o bloco “aguardar 1000 ms” é delay(1000); e o bloco “se … fazer” é uma estrutura if. A tabela abaixo coloca lado a lado os rótulos reais dos blocos do app BlueGrays, o código correspondente em Arduino C++ e o código em MicroPython no Raspberry Pi Pico.

Esta página não é uma aula, é uma folha de consulta. Você pode imprimir a tabela, deixá-la ao lado da mesa e conferir qual linha corresponde a qual bloco enquanto olha um projeto. Depois da tabela, você vai encontrar os erros mais comuns na transição, um método em quatro etapas para deixar os blocos para trás e o mesmo programa escrito em blocos, C++ e MicroPython. O exemplo compila na Arduino IDE e roda no Pico com o Thonny.

Antes de ler a tabela: quatro diferenças entre os três

Blocos, C++ e MicroPython expressam a mesma ideia, mas as regras de escrita são diferentes. É nestas quatro diferenças que você mais vai tropeçar. A primeira é a estrutura: um programa em Arduino C++ tem duas partes, setup() e loop(), que nos blocos aparecem como “configuração (uma vez)” e “repetir para sempre”. O MicroPython não tem um setup separado; o arquivo roda uma vez de cima para baixo e a parte que se repete vai dentro de um laço while True:. A segunda são os tipos: em C++ toda variável tem um tipo escrito (int, float, bool), nos blocos isso é a opção “declarar inteiro (int)”, e em Python nenhum tipo é escrito.

A terceira diferença são as faixas de números. No Arduino Uno uma leitura analógica vai de 0–1023 e o PWM de 0–255; no ESP32 a leitura analógica chega a 0–4095; no Pico, o MicroPython dá tanto as leituras quanto o ciclo de trabalho do PWM na faixa 0–65535. Por isso você não pode copiar um limite de uma placa para outra do jeito que está. A quarta diferença é a unidade de tempo: delay() recebe milissegundos, time.sleep() recebe segundos. Meio segundo é delay(500) em C++ e time.sleep(0.5) em MicroPython. Com essas quatro regras em mente, a maioria das linhas da tabela se encaixa sozinha.

• Os números da tabela são exemplos: onde um bloco diz 13, o seu projeto pode usar 7, e o número na linha de código muda junto.
• Os pinos da coluna MicroPython são números GP do Pico (GP14, GP15, GP26). Eles não precisam coincidir com os números de pino do Uno; confira o esquema do circuito.
• Linhas marcadas com “Sem bloco no Pico” indicam que aquele bloco não é usado em projetos com Pico; mesmo assim, foi incluído o código MicroPython que faz o mesmo trabalho.
• O ESP32 também é programado em Arduino C++; a coluna C++ vale para ele também, só a faixa analógica e alguns números de pino mudam.

Tabela de referência: blocos, Arduino C++ e MicroPython

A tabela está dividida em 12 grupos: estrutura do programa, pinos, tempo, condições, laços, variáveis, matemática, porta serial, analógico e PWM, som, servo e sensor. O texto da coluna Bloco é o rótulo impresso nos blocos do app, e “…” e “?” marcam o encaixe onde outro bloco se conecta. Quando uma linha tem mais de um bloco, eles são separados por um ponto.

Algumas linhas parecem equivalentes à primeira vista, mas pedem atenção. Em “contar com i de 0 até 5” o 5 está incluído e o laço roda 6 vezes; por isso em C++ se usa <= em vez de <, e em Python é preciso range(0, 6), porque o range deixa de fora o número final. O bloco de divisão também é uma armadilha: quando você divide dois inteiros, o C++ descarta a parte fracionária e 7 / 2 dá 3, enquanto o Python dá 3,5. Para ter divisão inteira no estilo do C++ em Python, use //. A função map() por trás do bloco “mapear x” não vem pronta no MicroPython; no exemplo abaixo, uma função arduino_map() de duas linhas faz o mesmo cálculo.

Como blocos encaixados uns nos outros viram código?

Conhecer os blocos um a um não basta; a habilidade de verdade é transformar blocos encaixados em uma só linha. Para isso, diferencie dois formatos. Blocos empilhados um embaixo do outro, com um entalhe na borda, são comandos, e cada um vira uma linha de código. Blocos ovais ou pontudos que se encaixam no espaço de outro bloco são valores; no código, eles ficam dentro de parênteses, à direita de um sinal de igual ou dentro de uma condição. As linhas abaixo vêm do projeto grátis Ajuste de frequência com buzzer: quatro botões ligam e desligam o som e aumentam ou diminuem a frequência, que fica entre 50 e 5000 Hz.

Crie um hábito ao ler esta tabela: traduza primeiro o bloco mais interno e depois vá para fora. Em “definir frequency como (restringir frequency mín. 50 máx. 5000)” a parte mais interna é constrain(frequency, 50, 5000), e o bloco externo definir a envolve como frequency = …. Um bloco de valor não pode ser uma linha sozinho; se você deixá-lo com um ponto e vírgula, o compilador pode não reclamar, mas o resultado não fica guardado em lugar nenhum.

Erros comuns ao passar dos blocos para o código

O editor de blocos não deixa você cometer a maioria destes erros; o formato das peças impede que elas se encaixem no lugar errado. O código tira essa proteção, então quase todo mundo encontra os erros abaixo nas primeiras semanas. As mensagens de erro vêm em inglês, mas os padrões são poucos e, depois de vê-los algumas vezes, você vai reconhecê-los.

Deixando os blocos para trás: um método em 4 etapas

Tentar mudar de uma vez só cansa. As quatro etapas abaixo vão da leitura à escrita em pequenos passos. Um ou dois projetos por etapa bastam; você está pronto para a próxima quando consegue fazer a atual sem olhar a tabela.

1. Leia lado a lado. Abra os blocos e o código de um projeto ao mesmo tempo e ligue, com o dedo, cada bloco à sua linha no código. Mantenha a tabela ao lado nesta etapa. Objetivo: conseguir associar cada linha de código a um bloco.
2. Esconda os blocos e adivinhe. Olhe primeiro os blocos, depois desligue a visualização em blocos e escreva no papel o C++ desses blocos sem olhar o código. Em seguida, compare com o código real. Tente também o contrário: leia o código e adivinhe os blocos.
3. Mude um valor no código. Leve o código para o computador e mude só um número: aumente a espera de 100 para 500, ou o limite de 400 para 600. Carregue e veja a diferença com seus próprios olhos. Se der erro de compilação, volte à tabela de erros acima.
4. Escreva uma linha nova. Acrescente uma linha que não está nos blocos: um Serial.println() que mostra o valor no Monitor Serial, um segundo LED ou um if que funcione com um botão. Agora você não está mais traduzindo blocos, está escrevendo código diretamente.

Cada etapa tem uma aula correspondente na série. Para a primeira etapa, a tabela bloco-linha de piscar um LED com blocos é um bom começo. Para trabalhar com condições e laços nas etapas dois e três, veja o bloco se e laços e variáveis. Se você vai passar para MicroPython no Pico, dos blocos ao MicroPython também mostra como configurar o Thonny. Para distribuir a transição por várias semanas em sala de aula, o plano de robótica e programação de 8 semanas traz uma sequência pronta.

Abrindo blocos e código lado a lado no app BlueGrays

Você vai usar esta tabela principalmente ao alternar entre os blocos e o código de um projeto real. O app BlueGrays tem visualização em blocos para mais de 100 projetos; em mais de 30 projetos grátis os blocos também estão abertos, e nos projetos Premium os blocos são desbloqueados com o Premium. Os blocos servem para leitura: não é possível editar blocos no app e os blocos não são carregados na placa. O que vai para a placa é sempre o código real; você o pega com Copiar, ou com Copiar link para abri-lo no computador, e cola na Arduino IDE, ou no Thonny no caso do Pico.

• Ver em blocos: ative essa chave ao lado do código-fonte na página de um projeto e o mesmo programa aparece como imagem de blocos no idioma do app. Toque na imagem para abri-la em tela cheia; desligar e ligar a chave é exatamente como você pratica as etapas um e dois.
• Entenda os blocos: com a visualização em blocos ativada, a aba “Entenda o código” passa a ter esse nome. O programa é dividido em passos, cada um com a parte que cobre e uma explicação. A tarefa “Tente você mesmo” no final é um exercício pronto para a etapa quatro.
• Guia de código: cada um dos 36 cartões da seção Aprender (18 de Arduino C++, 18 de MicroPython) mostra o exemplo de três formas, com as abas Blocos, Arduino e MicroPython. Se quiser ver uma linha da tabela com mais detalhe, abra o cartão correspondente.
• Projetos com blocos: essa opção em Filtrar, em Descobrir > Projetos, lista só os projetos que têm visualização em blocos, o que facilita escolher um projeto para a transição.

Explicamos como o guia de código funciona no post sobre o guia de código, e as seções “Entenda o código” e “Tente você mesmo” no guia Entenda o código. Para cada comando explicado um a um, a lista de comandos do Arduino funciona bem junto com esta tabela.

Um programa de três formas: luz noturna que diminui com a claridade

Para ver a tabela em ação, vamos montar um programa pequeno. Um LDR mede a luz; enquanto o ambiente está claro o LED fica apagado e, conforme escurece, o LED vai ficando mais forte aos poucos. O programa usa blocos de variável, leitura analógica, condição, mapear, PWM, serial e aguardar, então mais da metade da tabela aparece em um só exemplo. A ideia se baseia no projeto grátis Luz noturna com LDR; lá o LED só acende ou apaga, aqui o PWM regula o brilho. Para a ligação do LDR, você também pode ver o esquema do circuito do projeto Medição da intensidade da luz com LDR.

Primeiro, a versão em blocos. Com os rótulos do app, o programa é formado pelos blocos abaixo; cada item corresponde a uma ou mais linhas do código C++ a seguir:

1. variáveis globais (no topo): declarar inteiro (int) lightValue = 0 e declarar inteiro (int) brightness = 0
2. configuração (uma vez): iniciar serial a 9600 baud, depois configurar pino 9 como SAÍDA
3. repetir para sempre: definir lightValue como (leitura analógica A0)
4. se (lightValue < 400) fazer: definir brightness como (mapear lightValue : 0 – 400 → 255 – 0); senão: definir brightness como 0
5. escrever PWM brightness no pino 9
6. imprimir na serial “Light: ” sem quebra de linha, imprimir na serial lightValue sem quebra de linha, imprimir na serial “ PWM: ” sem quebra de linha, imprimir na serial brightness nova linha
7. aguardar 200 ms

1// ─────────────────────────────────────────
2//   BlueGrays · bluegrays.com
3//   Işığa göre kısılan gece lambası / Dimming night light
4// ─────────────────────────────────────────
5
6int lightValue = 0;   // LDR okuması / LDR reading (0-1023)
7int brightness = 0;   // LED parlaklığı / LED brightness (0-255)
8
9void setup() {
10  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
11  pinMode(9, OUTPUT);   // LED, PWM pini D9 / LED on PWM pin D9
12}
13
14void loop() {
15  lightValue = analogRead(A0);   // Az ışık = küçük değer / Little light = small value
16
17  if (lightValue < 400) {
18    // Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
19    brightness = map(lightValue, 0, 400, 255, 0);
20  } else {
21    brightness = 0;   // Oda aydınlık, LED kapalı / Room is bright, LED off
22  }
23
24  analogWrite(9, brightness);   // PWM 0-255 / PWM 0-255
25
26  Serial.print("Light: ");
27  Serial.print(lightValue);
28  Serial.print("  PWM: ");
29  Serial.println(brightness);
30
31  delay(200);   // 0,2 sn bekle / Wait 0.2 s
32}
33

1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Işığa göre kısılan gece lambası / Dimming night light
4# ─────────────────────────────────────────
5from machine import Pin, ADC, PWM
6import time
7
8ldr = ADC(26)                # GP26 = ADC0 / GP26 = ADC0
9led = PWM(Pin(15))           # LED, GP15 / LED on GP15
10led.freq(1000)               # PWM frekansı 1000 Hz / PWM frequency 1000 Hz
11
12THRESHOLD = 25600            # Uno'daki 400'ün karşılığı / Same as 400 on the Uno
13
14
15def arduino_map(x, in_min, in_max, out_min, out_max):
16    # Arduino map() ile aynı hesap / Same math as Arduino map()
17    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
18
19
20while True:
21    light_value = ldr.read_u16()          # 0-65535 / 0-65535
22
23    if light_value < THRESHOLD:
24        # Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
25        brightness = arduino_map(light_value, 0, THRESHOLD, 65535, 0)
26    else:
27        brightness = 0                    # Oda aydınlık, LED kapalı / Room is bright, LED off
28
29    led.duty_u16(brightness)              # PWM 0-65535 / PWM 0-65535
30
31    print("Light:", light_value, " PWM:", brightness)
32
33    time.sleep(0.2)                       # 0,2 sn bekle / Wait 0.2 s
34

Compare os dois programas linha por linha e todas as diferenças da tabela aparecem. O setup() do C++ vira as linhas antes de while True no Python, e o Serial.begin() some. analogRead(A0) vira ADC(26).read_u16() e a faixa cresce de 0–1023 para 0–65535, por isso o limite é 25600 em vez de 400. Em vez de analogWrite(9, …), primeiro é criado um objeto PWM e o brilho é definido com duty_u16() entre 0 e 65535. Como map() não vem pronto, é escrita uma função arduino_map(); a divisão inteira // dentro dela corresponde à divisão inteira do C++. Um único print() substitui quatro chamadas separadas de Serial.print(), e delay(200) vira time.sleep(0.2).

Passar da programação em blocos ao Arduino C++ tem menos a ver com decorar algo novo e mais com reconhecer a forma escrita de blocos que você já conhece. Mantenha esta tabela ao lado, em cada projeto leia primeiro lado a lado, depois esconda os blocos e escreva você mesmo. Se quiser ver estas linhas em projetos reais, abra um projeto com visualização em blocos no app BlueGrays e alterne entre as duas formas do mesmo programa com Ver em blocos.