O que é MicroPython? Comandos básicos, REPL e primeiros programas

MicroPython é uma reimplementação pequena e rápida da linguagem Python 3 para microcontroladores. Depois que você carrega o MicroPython em uma placa como Raspberry Pi Pico ou ESP32, a placa executa código Python por conta própria: você digita um comando, sem etapa de compilação, e vê o LED acender imediatamente. Se aprendeu Python na escola ou no computador, pode usar a mesma sintaxe para ler pinos, acionar motores, coletar dados de sensores e se conectar ao Wi-Fi.

Neste guia, você vai aprender como o MicroPython difere do Python comum, conhecer o REPL, que permite conversar com a placa instantaneamente, e os módulos que mais vai usar, como machine.Pin, PWM, ADC e I2C, com exemplos de código. Depois, verá a diferença entre time.sleep e ticks_ms, os arquivos main.py e boot.py executados na inicialização, o carregamento de arquivos com Thonny e mpremote, a adição de bibliotecas com mip e a gravação do firmware no Pico e ESP32. Na última seção, comparamos MicroPython e Arduino C++ lado a lado.

O que é MicroPython e como ele difere do Python?

MicroPython é um projeto de código aberto iniciado por Damien George em 2013 para uma pequena placa e hoje oferece suporte a dezenas de microcontroladores. O firmware que você carrega na placa contém o interpretador Python, os módulos básicos e um pequeno sistema de arquivos. Primeiro, seu código é convertido em bytecode na placa; depois, o interpretador executa esse bytecode passo a passo. Como é impossível colocar todo o Python do computador em algumas centenas de KB de RAM, a linguagem continua a mesma, mas a maioria das bibliotecas é reduzida ou totalmente ausente. Em troca, foi acrescentado algo que o Python de computador não tem: o módulo machine, que dá acesso direto ao hardware.

Placas que executam MicroPython

Gravação do firmware MicroPython no Pico e ESP32

1. Pico: Mantenha o botão BOOTSEL da placa pressionado enquanto conecta o cabo USB e depois solte. Uma unidade chamada RPI-RP2 aparece no computador (RP2350 no Pico 2).
2. Baixe o arquivo .uf2 correto para sua placa na página oficial de downloads do MicroPython (RPI_PICO para o Pico, RPI_PICO_W para o Pico W) e arraste-o para essa unidade.
3. Quando a cópia termina, a placa reinicia automaticamente e a unidade desaparece; o MicroPython está instalado. No Thonny, escolha MicroPython (Raspberry Pi Pico) em Ferramentas > Opções > Interpretador.
4. ESP32: Se o Python estiver instalado no computador, digite pip install esptool na linha de comando. Conecte a placa e encontre sua porta (por exemplo, COM3 no Windows, /dev/ttyUSB0 no Linux).
5. Primeiro, apague a memória flash: esptool.py --chip esp32 --port COM3 erase_flash. Se a placa não conectar, mantenha o botão BOOT pressionado enquanto o comando é executado.
6. Grave o firmware: esptool.py --chip esp32 --port COM3 --baud 460800 write_flash -z 0x1000 ESP32_GENERIC-....bin. No ESP32-S3 e ESP32-C3, o endereço é 0x0. A opção Install or update MicroPython (esptool) do Thonny faz a mesma tarefa por uma janela.

O REPL: conversando com a placa instantaneamente

O REPL (Read-Eval-Print Loop) é a linha de comando que a placa disponibiliza pela porta serial. O prompt >>> que aparece na janela Shell, na parte inferior do Thonny, significa que o REPL está esperando por você. Digite 1 + 1 e a placa calcula e retorna 2; digite from machine import Pin seguido de Pin("LED", Pin.OUT).value(1) e o LED do Pico acende naquele instante. Não há maneira mais rápida que o REPL de ler o valor de um sensor, conferir se um pino está conectado corretamente ou explorar como uma biblioteca funciona, tudo sem esperar pela compilação e pelo carregamento.

Primeiro programa e seu equivalente em Arduino C++

1# İlk program: dahili LED'i yakıp söndür / First program: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)        # Pico ve Pico W; ESP32'de Pin(2, Pin.OUT) / Pico and Pico W; Pin(2, Pin.OUT) on ESP32
6
7while True:
8    led.value(1)                 # yak / on
9    time.sleep(0.5)              # saniye cinsinden / in seconds
10    led.value(0)                 # söndür / off
11    time.sleep(0.5)

1// Aynı program Arduino C++ ile / The same program in Arduino C++
2void setup() {
3  pinMode(LED_BUILTIN, OUTPUT);
4}
5
6void loop() {
7  digitalWrite(LED_BUILTIN, HIGH);
8  delay(500);                    // milisaniye cinsinden / in milliseconds
9  digitalWrite(LED_BUILTIN, LOW);
10  delay(500);
11}

Os dois programas fazem a mesma tarefa, mas têm estruturas diferentes. MicroPython não tem setup() nem loop(): o arquivo é executado uma vez, de cima para baixo, e você cria o laço infinito com while True:. Em vez de chaves e ponto e vírgula, ele usa indentação; todas as linhas dentro do laço devem ter o mesmo recuo (geralmente 4 espaços). A espera também usa uma unidade diferente: time.sleep(0.5) recebe segundos, enquanto delay(500) do Arduino recebe milissegundos. No MicroPython, você usa time.sleep_ms() para milissegundos e time.sleep_us() para microssegundos. Os fundamentos do lado do Arduino estão em Fundamentos de programação com Arduino.

machine.Pin: entrada e saída digital

time.sleep e ticks_ms: medindo o tempo sem bloqueio

time.sleep() faz a placa esperar completamente; enquanto isso, nenhum botão é lido e nenhum sensor é verificado. Para executar várias tarefas ao mesmo tempo, você usa o equivalente em MicroPython à abordagem com millis() do Arduino: time.ticks_ms() informa os milissegundos desde a inicialização, e time.ticks_diff(new, old) calcula a diferença entre dois instantes. É importante obter a diferença com ticks_diff em vez de uma subtração simples; o contador volta ao início depois de atingir determinado valor, e uma subtração simples dá o resultado errado nesse ponto. O código abaixo pisca o LED sem bloqueio enquanto monitora um botão por uma interrupção (IRQ); cada pressionamento muda a velocidade das piscadas.

1# delay kullanmadan iki iş: LED yanıp söner, buton kesmeyle modu değiştirir
2# Two jobs without blocking: the LED blinks, a button interrupt switches the mode
3from machine import Pin
4import time
5
6led = Pin(15, Pin.OUT)                       # LED + 220 Ω, GP15
7buton = Pin(14, Pin.IN, Pin.PULL_UP)         # buton GP14 ile GND arasında / button between GP14 and GND
8
9hizli = False
10son_basma = 0
11son_degisim = time.ticks_ms()
12
13def buton_kesme(pin):                        # kesme fonksiyonu kısa olmalı / keep the handler short
14    global hizli, son_basma
15    simdi = time.ticks_ms()
16    if time.ticks_diff(simdi, son_basma) > 200:   # 200 ms debounce / 200 ms debounce
17        son_basma = simdi
18        hizli = not hizli
19
20buton.irq(trigger=Pin.IRQ_FALLING, handler=buton_kesme)   # basınca HIGH'dan LOW'a iner / goes HIGH to LOW when pressed
21
22while True:
23    aralik = 100 if hizli else 500
24    if time.ticks_diff(time.ticks_ms(), son_degisim) >= aralik:   # taşmaya karşı güvenli / safe against wrap-around
25        son_degisim = time.ticks_ms()
26        led.value(not led.value())
27    # burada başka işler yapılabilir / other work can run here

PWM: brilho, servos e som

1# PWM: LED parlaklığı ve servo açısı / PWM: LED brightness and servo angle
2from machine import Pin, PWM
3import time
4
5led = PWM(Pin(15))
6led.freq(1000)                               # 1 kHz: titreme görünmez / no visible flicker
7
8for d in range(0, 65536, 2048):              # duty_u16: 0 (kapalı) ... 65535 (tam) / 0 (off) ... 65535 (full)
9    led.duty_u16(d)
10    time.sleep_ms(20)
11led.duty_u16(0)
12
13servo = PWM(Pin(16))
14servo.freq(50)                               # servolar 50 Hz (20 ms) ister / servos expect 50 Hz (20 ms)
15
16def servo_aci(derece):
17    us = 500 + derece * 2000 // 180          # 0° = 0,5 ms, 180° = 2,5 ms; servona göre ayarla / tune for your servo
18    servo.duty_ns(us * 1000)
19
20for a in (0, 90, 180, 90):
21    servo_aci(a)
22    time.sleep(1)

O objeto PWM liga e desliga um pino muito rapidamente para definir uma potência média. freq() define quantas vezes por segundo isso se repete, e duty_u16() define por quanto tempo o pino fica ligado, com um número entre 0 e 65.535; 32.768 significa aproximadamente 50 por cento. Essa escala oferece passos muito mais finos que a faixa de 0–255 do analogWrite do Arduino. Servos esperam um sinal de 50 Hz e uma largura de pulso entre 0,5 e 2,5 ms; duty_ns() define a duração do pulso diretamente em nanossegundos, o que torna o código do servo muito mais simples. Você também pode tocar notas atribuindo diferentes valores de freq() a um buzzer passivo. O ciclo de trabalho e a frequência são explicados em detalhes em O que é PWM.

ADC: leitura analógica

1# ADC: potansiyometre ve Pico'nun dahili sıcaklık sensörü
2# ADC: a potentiometer and the Pico's internal temperature sensor
3from machine import ADC, Pin
4import time
5
6pot = ADC(Pin(26))                           # GP26 = ADC0; ESP32'de ADC(Pin(34)) / ADC(Pin(34)) on ESP32
7yonga = ADC(4)                               # 4. kanal: dahili sıcaklık / channel 4: internal temperature
8
9def ortalama(adc, n=16):                     # gürültüyü azalt / reduce noise
10    toplam = 0
11    for _ in range(n):
12        toplam += adc.read_u16()
13    return toplam // n
14
15while True:
16    ham = ortalama(pot)                      # 0-65535 (12 bit ölçüm 16 bite ölçeklenir) / 12-bit reading scaled to 16 bits
17    volt = ham * 3.3 / 65535
18    v_t = ortalama(yonga) * 3.3 / 65535
19    derece = 27 - (v_t - 0.706) / 0.001721   # RP2040 veri sayfasındaki formül / formula from the RP2040 datasheet
20    print("Pot: {} ({:.2f} V)  Yonga / chip: {:.1f} C".format(ham, volt, derece))
21    time.sleep(1)

read_u16() retorna um valor entre 0 e 65.535 em todas as placas, então o mesmo código funciona no Pico e no ESP32. O ADC do Pico é, na verdade, de 12 bits, e a leitura é convertida para uma escala de 16 bits. O Pico tem três pinos analógicos acessíveis ao usuário: GP26 (ADC0), GP27 (ADC1) e GP28 (ADC2); o quarto canal é o sensor de temperatura dentro do chip, que mede a temperatura do chip, não a do ambiente. No ESP32, você precisa de adc.atten(ADC.ATTN_11DB) para ler toda a faixa de 0–3,3 V, e os pinos ADC2 não podem ser usados enquanto o Wi-Fi está ligado, então escolha os pinos ADC1 entre GPIO 32 e 39. A média de 16 amostras no código reduz perceptivelmente o ruído do ADC. Conceitos como resolução e tensão de referência são abordados em O que é um ADC.

I2C: conectando sensores e displays

1# I2C: hattı tara ve SSD1306 OLED'e yaz / I2C: scan the bus and write to an SSD1306 OLED
2from machine import Pin, I2C
3import ssd1306                               # önce: mpremote mip install ssd1306 / first: mpremote mip install ssd1306
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)   # Pico; ESP32'de I2C(0, sda=Pin(21), scl=Pin(22))
6adresler = i2c.scan()
7print("Bulunan / found:", [hex(a) for a in adresler])   # OLED genelde 0x3c / OLED is usually 0x3c
8
9if 0x3C in adresler:
10    oled = ssd1306.SSD1306_I2C(128, 64, i2c)
11    oled.fill(0)
12    oled.text("MicroPython", 0, 0)
13    oled.text("I2C: " + hex(adresler[0]), 0, 16)
14    oled.show()

I2C(0, sda=..., scl=...) inicia a unidade I2C de hardware nos pinos escolhidos, e scan() retorna uma lista dos endereços de todos os dispositivos que respondem no barramento. Se um sensor não estiver funcionando, essa varredura é a primeira coisa a fazer: uma lista vazia significa que o problema está na fiação, e um endereço inesperado significa que você deve corrigir o endereço no código. No Pico, os pinos que cada unidade I2C pode usar são fixos; por exemplo, os pares GP0-GP1, GP4-GP5 ou GP8-GP9 funcionam para I2C0, e escolher um par errado gera um ValueError. No ESP32, o I2C pode ser atribuído a quase qualquer pino. Os detalhes do display estão em display OLED de 0,96 polegada, e os do protocolo em si em O que é I2C.

main.py e boot.py: código executado na inicialização

Quando você pressiona Executar no Thonny, o código só é executado naquele momento, sem ser salvo na placa; ele desaparece quando você desconecta o USB. Para que o código seja executado automaticamente toda vez que a placa iniciar, é preciso salvar o arquivo na placa como main.py. Na inicialização, boot.py é executado primeiro, seguido de main.py. boot.py serve para preparações feitas uma única vez, como conectar ao Wi-Fi ou ajustar o relógio; o firmware do ESP32 cria esse arquivo automaticamente, enquanto no Pico ele geralmente não existe. Seu programa principal sempre fica em main.py. Você pode trazer funções escritas em outros arquivos para main.py com import e salvar leituras no sistema de arquivos da placa com open().

1# main.py: kart her açıldığında otomatik çalışır / runs automatically every time the board starts
2import time
3from machine import Pin
4
5time.sleep(3)                                # Ctrl+C ile durdurmak için güvenlik payı / a safety window for Ctrl+C
6led = Pin("LED", Pin.OUT)
7sayac = 0
8
9try:
10    while True:
11        sayac += 1
12        led.value(sayac % 2)
13        print("Calisiyor / running", sayac)
14        time.sleep(1)
15except KeyboardInterrupt:                    # Thonny'de Stop ya da Ctrl+C / Stop in Thonny or Ctrl+C
16    led.value(0)
17    print("Durduruldu / stopped")

Carregamento de arquivos: Thonny e mpremote

Se você está começando, o Thonny é o caminho mais fácil: escreva o código, escolha Arquivo > Salvar como, selecione Raspberry Pi Pico ou Dispositivo MicroPython na janela que abrir e dê ao arquivo o nome main.py. Abra Exibir > Arquivos para ver os arquivos do computador e da placa lado a lado e copiar de um para o outro com um clique do botão direito. Para quem gosta da linha de comando e usa um editor como o VS Code, a ferramenta oficial é mpremote; instale com pip install mpremote, e ela se conecta automaticamente à primeira placa MicroPython que encontrar.

Adição de bibliotecas: mip

Não há pip no MicroPython; em seu lugar, usa-se o pequeno gerenciador de pacotes mip. Em uma placa que pode acessar a internet, como Pico W ou ESP32, primeiro você se conecta ao Wi-Fi e depois digita import mip e mip.install("ssd1306") no REPL; o pacote é baixado do repositório oficial micropython-lib e colocado na pasta /lib da placa. Você também pode instalar um driver do GitHub com mip.install("github:user/repo"). Para um Pico sem Wi-Fi, faça o mesmo pelo computador com o comando mpremote mip install ou pelo menu Ferramentas > Gerenciar pacotes do Thonny. Copiar um driver de arquivo único (por exemplo, um arquivo .py escrito para um sensor) para a placa também funciona; desde que o arquivo esteja na raiz ou em /lib, você pode carregá-lo com import. Os passos para conectar ao Wi-Fi estão em Wi-Fi no Pico W.

MicroPython ou Arduino C++?

Na prática, seu projeto determina a escolha. Ler um sensor e enviar os dados por Wi-Fi, servir uma página web ou acionar um display exige menos linhas e fica pronto mais rápido em MicroPython. Gerar sinais com precisão de microssegundos, atualizar centenas de LEDs muito rapidamente ou ter apenas uma placa pequena como o Uno favorece o C++. Você pode acelerar uma função lenta com o decorador @micropython.native e reduzir as pausas do coletor de lixo evitando criar novas listas e strings dentro dos laços. Para escolher uma placa, veja também Arduino ou ESP32.

Erros comuns e soluções

MicroPython é o caminho mais curto para o mundo dos microcontroladores se você já sabe Python: você vê o resultado no instante em que testa um pino no REPL, e poucas linhas bastam para ler um sensor e se conectar ao Wi-Fi. Depois de aprender os módulos básicos, a ideia de main.py e a temporização sem bloqueio com ticks_ms, seus projetos crescem rapidamente. No app BlueGrays, você encontra projetos com Raspberry Pi Pico usando LEDs, semáforo, botões e PWM, com diagramas de fiação passo a passo e código MicroPython.