Da programação em blocos ao MicroPython: sensores e Raspberry Pi Pico

Passar da programação em blocos para o MicroPython fica muito mais fácil quando você já sabe ler um sensor com blocos. Ler um sensor com blocos é obter um valor sem digitar código: o bloco “ler analógico A0” pega o nível de luz de um LDR, e o bloco “escrever na serial” envia esse número para o Monitor Serial no seu computador. Neste artigo você primeiro vai ler sensores com blocos no Arduino usando os projetos de LDR e HC-SR04, comparando cada bloco com a linha analogRead(), Serial.begin(), Serial.println() ou pulseIn() correspondente. Depois vai dar o passo dos blocos para o MicroPython no Raspberry Pi Pico e ver o que muda quando os mesmos blocos viram código Python.

Até aqui, todo programa da série fazia algo acontecer no mundo lá fora: acendemos LEDs, verificamos um botão e montamos um contador com um laço. Ler um sensor funciona no sentido contrário: a placa mede o mundo e você vê o número. Por isso a porta serial entra em cena agora, já que o jeito mais fácil de entender o que um sensor mede é acompanhar o valor na tela. Na segunda metade, os projetos de programação em blocos no Raspberry Pi Pico correspondem a MicroPython em vez de C++. Todos os projetos usados aqui são grátis no BlueGrays, e o código citado abaixo é exatamente o código do projeto.

O que significa ler um sensor: entradas digitais e analógicas

Um botão informa só dois estados: pressionado ou não. Você o lê com o bloco de leitura digital do pino, “ler pino …” (digitalRead), e o resultado é 0 ou 1. Componentes como um LDR, um potenciômetro ou um sensor de umidade do solo dão todos os valores intermediários: a tensão no pino varia de forma contínua entre 0 e 5 V. O circuito que transforma essa tensão em número é o ADC (conversor analógico-digital). O ADC do Arduino Uno é de 10 bits, então divide a tensão em 1024 degraus e devolve um número de 0 a 1023; cada degrau vale cerca de 4,9 mV. O ESP32 e o Pico têm ADCs de 12 bits que trabalham com 3,3 V. Essa diferença entre placas é uma das fontes de confusão mais comuns na passagem dos blocos para o código; os detalhes estão no artigo ADC e conversão analógico-digital.

Lendo um LDR com blocos no Arduino

Nosso primeiro exemplo é o projeto Medição da intensidade da luz com LDR. Um LDR é um resistor cuja resistência cai à medida que a luz fica mais forte; sozinho, ele não produz tensão. Para medi-lo, nós o colocamos em série com um resistor fixo de 10 kΩ, formando um divisor de tensão, e ligamos o ponto do meio ao A0. Com a ligação abaixo, o LDR fica do lado do 5V, então mais luz significa mais tensão no A0 e uma leitura maior; troque o LDR e o resistor de lugar e o sentido se inverte. Você pode calcular a saída do divisor para diferentes valores de LDR com a calculadora de divisor de tensão e ver quantos ohms um LDR tem no escuro e sob luz forte no artigo sensor de luz LDR. Vamos usar a coluna do Pico da tabela no exemplo em MicroPython, perto do final.

Leia os blocos de cima para baixo. O bloco “declarar inteiro (int) value = 0”, dentro de variáveis globais (no topo), é a linha int value; no topo do código. A seção configuração (uma vez) tem um único bloco, “iniciar serial a 9600 baud”, que é Serial.begin(9600);. Dentro de repetir para sempre vem primeiro “definir value como ler analógico A0”; essa é a linha value = analogRead(A0);. Depois há dois blocos “escrever na serial”. O primeiro escreve o texto “Value:” com a opção sem quebra e vira Serial.print(); o segundo escreve value com a opção nova linha e vira Serial.println(). Assim cada medição aparece numa única linha, como “Value: 512”. O último bloco, “aguardar 500 ms”, é delay(500);, então você tem duas leituras por segundo. Para converter a leitura em tensão, use value × 5,0 / 1023: 512 equivale a cerca de 2,5 V. Num quarto escuro o valor cai para algumas centenas e, com uma lanterna apontada para o LDR, passa de 900; os números exatos dependem do seu LDR e do ambiente.

1int value;   // Işık değeri / Light reading (0-1023)
2
3void setup() {
4  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
5}
6
7void loop() {
8  value = analogRead(A0);   // LDR gerilimini oku / Read the LDR voltage
9  Serial.print("Value: ");
10  Serial.println(value);
11  delay(500);               // 0,5 sn bekle / Wait 0.5 s
12}

Abrindo o Monitor Serial e acompanhando os valores

1. Cole o código na Arduino IDE, selecione a placa e a porta e clique em Carregar.
2. Quando o carregamento terminar, clique no ícone de lupa no canto superior direito ou abra Ferramentas > Monitor Serial (atalho Ctrl+Shift+M).
3. Ajuste a caixa de baud rate do Monitor Serial para o valor do código: 9600 baud neste projeto.
4. Uma linha “Value: …” passa a rolar a cada meio segundo. Cubra o LDR com a mão e veja o número cair.
5. Para ver a variação em forma de gráfico, abra Ferramentas > Plotter Serial; os mesmos dados são desenhados como uma linha do tempo.
6. As configurações de final de linha e o envio de dados do Monitor Serial para a placa são explicados em detalhes no artigo Monitor Serial do Arduino.

Distância com o HC-SR04: os blocos de espera em µs e de duração do pulso

O segundo projeto de sensor é Medição de distância com HC-SR04 (Monitor Serial). Ele traz dois blocos novos. O trio que começa com “escrever ALTO no pino trigPin” manda o sensor emitir um pulso de som: o bloco “aguardar 10 µs”, no meio, é delayMicroseconds(10);, uma espera mil vezes mais curta que “aguardar … ms”. Em seguida vem “definir duration como duração do pulso ALTO no pino echoPin (µs)”, que é a linha unsigned long duration = pulseIn(echoPin, HIGH); e mede quantos microssegundos o pino Echo fica em ALTO. O som viaja no ar a cerca de 0,034 cm/µs, e esse tempo cobre a ida e a volta. Por isso “definir totalPath como duration × 0.034” calcula o caminho todo e “definir distance como totalPath ÷ 2”, a distância só de ida. Um pulso de 1000 µs, por exemplo, significa um caminho de 34 cm, então o objeto está a 17 cm; como distance é um int, as casas decimais são descartadas. Por fim, o bloco “se distance > minDistance e distance < maxDistance” vira if (distance > minDistance && distance < maxDistance) e só escreve leituras entre 3 e 100 cm. Se o sensor não recebe eco, pulseIn() devolve 0, e essa verificação também mantém esses zeros falsos fora da tela. No código, os pinos são trigPin = 7 e echoPin = 6. Para o alcance e a precisão do sensor, veja o artigo sensor de distância HC-SR04.

A mesma ideia no ESP32: um ADC de 12 bits

A versão para ESP32 da mesma lógica do LDR é o projeto Leitura da intensidade da luz com módulo LDR e ESP32. Os blocos continuam correspondendo a C++ e se leem como no Arduino, com três diferenças. Primeiro, o setup() fixa o ADC em 12 bits com analogReadResolution(12), então analogRead() devolve 0–4095 em vez de 0–1023, e um limite escrito para o Arduino, como “escuro abaixo de 500”, não significa a mesma coisa no ESP32. Segundo, a porta serial roda a 115200 baud em vez de 9600, então ajuste o Monitor Serial para 115200 também. Terceiro, na saída AO do módulo LDR, a tensão e o valor bruto caem à medida que a luz fica mais forte. Por isso o código usa os valores de calibração RAW_DARK = 4000 e RAW_LIGHT = 100, mantém a leitura nessa faixa com constrain() e a transforma em 0% para escuro e 100% para claro com map(). Num ESP32 DevKit clássico, o LDR vai no GPIO 34, um pino só de entrada do ADC1. Como os pinos do ADC2 não podem ser lidos com o Wi-Fi ligado, ligar sensores analógicos a pinos do ADC1 é um bom hábito. Para as características gerais da placa, veja o que é o ESP32.

Dos blocos ao MicroPython no Raspberry Pi Pico

Nos projetos de Pico, os blocos correspondem a MicroPython em vez de C++. Os blocos parecem familiares, mas a linguagem por baixo é outra: não há chaves nem ponto e vírgula, os blocos de código são marcados pela indentação, e não existem as funções setup() e loop(). Vamos fazer a troca com o projeto mais simples, Raspberry Pi Pico: controle de LED externo (GP14 + protoboard). O circuito é mínimo: o GP14 (pino físico 19) passa por um resistor de 220–330 Ω até a perna longa do LED, e a perna curta do LED vai ao GND (por exemplo, o pino físico 18). O programa acende o LED por meio segundo, apaga por meio segundo e escreve uma linha no Shell do Thonny a cada passo. Se o Pico é novidade para você, comece por o que é o Raspberry Pi Pico.

1from machine import Pin
2import time
3
4# ============ PIN / PIN ============
5LED_PIN = 14                    # Boştaki herhangi bir GPIO / Any free GPIO
6led = Pin(LED_PIN, Pin.OUT)
7
8print("== BlueGrays: Pico Harici LED Blink ==")
9print("LED pin: GP" + str(LED_PIN))
10print("500ms yakip 500ms sonduruyor / 500ms on 500ms off")
11
12# ============ ANA DÖNGÜ / MAIN LOOP ============
13while True:
14    led.on()                    # LED'i yak / Turn the LED on
15    print("[LED] ACIK / ON")
16    time.sleep(0.5)
17
18    led.off()                   # LED'i söndür / Turn the LED off
19    print("[LED] KAPALI / OFF")
20    time.sleep(0.5)

Quatro coisas chamam a atenção nessa tabela. Primeiro, as linhas from machine import Pin e import time não têm bloco; em Python você importa no topo os módulos de que precisa, e os blocos já pressupõem isso por você. Segundo, o bloco “iniciar serial a 9600 baud” do Arduino não tem equivalente aqui: no Pico, a saída de print() vai direto pelo USB para o Shell do Thonny, sem baud rate para ajustar. Terceiro, a unidade de espera mudou: no Arduino, “aguardar 500 ms” é delay(500), enquanto no Pico “aguardar 0.5 segundos” é time.sleep(0.5). Quarto, e mais importante, a indentação: todo bloco encaixado dentro do bloco “repetir para sempre” é escrito quatro espaços para dentro, abaixo da linha while True:. Apague a indentação de uma linha e ela sai do laço; em Python, os espaços fazem o papel que as chaves fazem em C++. As outras regras básicas do MicroPython estão no artigo fundamentos do MicroPython.

As mesmas operações em três linguagens: blocos, C++ e MicroPython

Seu próprio exemplo: lendo um LDR no Pico com MicroPython

Agora vamos levar o projeto de LDR do Arduino para o Pico. A ligação segue a coluna do Pico da tabela acima: um terminal do LDR no pino 3V3(OUT), o outro terminal ao mesmo tempo no GP26 e numa ponta do resistor de 10 kΩ, e a outra ponta do resistor no GND. O Pico tem três pinos que leem valores analógicos: GP26 (ADC0), GP27 (ADC1) e GP28 (ADC2). No MicroPython você cria um objeto ADC(26) e chama read_u16(); embora o ADC do Pico seja de 12 bits no hardware, essa função escala o resultado para 0–65535. Para obter a tensão, multiplique o valor por 3,3 e divida por 65535. O programa segue o mesmo fluxo da versão do Arduino: medir, escrever, aguardar meio segundo. Além disso, acrescentamos um limite: quando o ambiente escurece, o LED da placa acende. Pensando em blocos, as linhas antes de while True são a seção “configuração (uma vez)”, while True: é “repetir para sempre”, o if/else é o bloco “se … fazer … senão” da parte 3 da série, led.on() é “ligar (on) pino led”, time.sleep(0.5) é “aguardar 0.5 segundos”, e o + str() dentro do print() é o bloco “juntar textos”. A linha ADC(26).read_u16() faz o papel do bloco “ler analógico A0” do Arduino. Ajuste THRESHOLD aos números que você vê no Shell, no seu próprio ambiente.

1from machine import Pin, ADC
2import time
3
4# ============ PIN / PIN ============
5ldr = ADC(26)                   # GP26 = ADC0, bölücünün orta noktası / divider midpoint
6led = Pin(25, Pin.OUT)          # Dahili LED; Pico W'de Pin("LED") / Onboard LED; Pico W: Pin("LED")
7THRESHOLD = 20000               # Karanlık eşiği, odana göre ayarla / Darkness threshold, tune for your room
8
9print("== BlueGrays: Pico LDR ==")
10
11# ============ ANA DÖNGÜ / MAIN LOOP ============
12while True:
13    value = ldr.read_u16()                      # 0-65535
14    voltage = value * 3.3 / 65535               # Volt / Volts
15    print("Value: " + str(value) + "  Voltage: " + str(round(voltage, 2)) + " V")
16
17    if value < THRESHOLD:                       # Az ışık = küçük değer / Little light = small value
18        led.on()
19    else:
20        led.off()
21
22    time.sleep(0.5)                             # 0,5 sn = 500 ms / 0.5 s = 500 ms

Carregando no Pico com o Thonny e o main.py

1. Instale o Thonny no computador. Se o Pico ainda não tem MicroPython, segure o botão BOOTSEL enquanto conecta o cabo USB; o Thonny se oferece para instalar o MicroPython na primeira conexão.
2. No canto inferior direito do Thonny, escolha MicroPython (Raspberry Pi Pico) como interpretador. Se aparecer o prompt >>> no Shell, na parte de baixo, a conexão está feita.
3. Copie o código do projeto no BlueGrays e cole no editor do Thonny.
4. Clique no botão verde Executar (Run) ou pressione F5. O código roda no Pico e a saída de print() aparece no Shell. Para parar, use o botão Parar (Stop) ou Ctrl+F2.
5. Se quiser que o código rode sem computador, escolha Arquivo > Salvar como, selecione Raspberry Pi Pico na janela que abrir e dê ao arquivo o nome main.py. O Pico executa esse arquivo automaticamente toda vez que recebe energia, então um carregador USB ou um power bank é tudo de que você precisa.
6. Se o Thonny não enxerga a placa, verifique o cabo e os drivers na ordem indicada no artigo Raspberry Pi Pico não reconhecido.

Mais projetos grátis de Pico com blocos

• Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W): não precisa de nenhuma ligação; ele pisca o LED da placa com LED_PIN = 25. O código é quase idêntico ao do projeto acima, então abra os dois lado a lado e você vai ver que só o número do pino muda. No Pico W, o LED da placa é ligado ao chip de Wi-Fi, por isso se usa Pin("LED").
• Raspberry Pi Pico: dois LEDs alternados (padrão flip-flop, GP14 + GP13): começa com estados opostos, com led1.value(1) e led2.value(0), e depois chama toggle() nos dois LEDs dentro do laço. Como o código diz from time import sleep, a espera aparece como sleep(0.5) em vez de time.sleep(0.5).
• Raspberry Pi Pico: semáforo (3 LEDs em sequência, GP11/GP12/GP13): uma função chamada all_off() apaga todos os LEDs; o verde fica aceso por 4 segundos, o amarelo por 1,5 e o vermelho por 3, seguidos de uma fase de partida de 1 segundo com vermelho+amarelo (uma fase que os semáforos brasileiros não têm).
• Raspberry Pi Pico: efeito de luz policial (vermelho + azul, GP11 + GP12): desta vez a espera é em milissegundos, com sleep_ms(WAIT_MS), em que WAIT_MS = 300. Ver as funções de segundos e de milissegundos lado a lado em dois projetos é o melhor jeito de evitar o erro mais comum, que aparece logo abaixo.

Erros comuns e como corrigi-los

Continue com os blocos no app BlueGrays

Todos os projetos deste artigo são grátis no app BlueGrays. Ative a chave Ver em blocos na seção de código de um projeto, e o código é substituído pelo mesmo programa em blocos; toque na imagem para abri-la em tela cheia. A aba Entenda os blocos explica o programa passo a passo, mostrando só os blocos de cada passo e o que eles fazem. É ali que você vê exatamente o que o bloco de duração do pulso mede no projeto do HC-SR04, ou por que a parte de configuração de um projeto de Pico vem antes do while True. Todos os exemplos de comandos de Arduino e MicroPython do Guia de código também aparecem em blocos. Para testar o que aprendeu, as Perguntas do dia trazem 5 perguntas por dia, de A1 a C2, um ranking semanal e medalhas. Lembre-se: os blocos nunca são carregados diretamente na placa; a placa sempre recebe o código real do projeto, que você copia para a Arduino IDE, no Arduino e no ESP32, ou para o Thonny, no Pico. Você pode filtrar a lista de projetos pelos que têm o selo “Blocos” e encontrar todos os projetos com blocos para Arduino, ESP32 e Pico na página programação em blocos.

Com a porta serial e a leitura de sensores na bagagem, agora você consegue ler todas as partes básicas de um projeto tanto em blocos quanto em código. A última parte da série leva esses passos para a sala de aula: um plano de aula de robótica com programação em blocos para professores. Até lá, você pode percorrer passo a passo os esquemas do circuito e o código dos projetos de LDR, HC-SR04 e LED no Pico no app BlueGrays, passar para a versão em blocos do mesmo programa com Ver em blocos e acompanhar o que cada passo faz com Entenda os blocos.