Como criador sempre à procura de placas microcontroladoras acessíveis, mas potentes, apaixonei-me pelo Raspberry Pi Pico. O seu tamanho compacto, desempenho impressionante e opções de programação versáteis tornam-no perfeito para uma vasta gama de projetos. Neste artigo, vou partilhar alguns dos meus projetos Pico favoritos que demonstram as suas capacidades, desde construções simples para principiantes até aplicações mais avançadas.
Projeto 1: LED piscando com padrões personalizados (adequado para iniciantes)
Configuração do hardware
Para este projeto, você precisará de um Raspberry Pi Pico, uma placa de ensaio, um LED, um resistor de 220 ohms e fios de ligação. Conecte o ânodo do LED ao pino GPIO 25 através do resistor e o cátodo ao pino terra no Pico. Essa configuração garante que o LED seja protegido contra sobrecorrente pelo resistor e esteja conectado corretamente ao pino GPIO do Pico para controle.
Implementação do código
Usando MicroPython, criaremos um programa para fazer o LED piscar em diferentes padrões. Primeiro, importe os módulos necessários:
from machine import Pin, Timer
Em seguida, inicialize o pino LED:
led = Pin(25, Pin.OUT)
Crie um objeto temporizador para controlar os intervalos de piscar. O trecho de código a seguir configura um temporizador que alterna o LED a cada 500 milissegundos:
tim = Timer()
def tick(timer):
led.toggle()
tim.init(freq=2, mode=Timer.PERIODIC, callback=tick)
Testes e personalização
Depois que o código for carregado no Pico (salvando-o como main.py e conectando o Pico), o LED deve começar a piscar. Você pode personalizar os padrões de piscar alterando o período do temporizador ou criando funções mais complexas para controlar os tempos de ligar e desligar do LED. Por exemplo, você poderia criar uma função que faça o LED piscar em um padrão de código Morse ou um padrão que mude com base em uma entrada externa. Este projeto é uma ótima maneira de se familiarizar com o controle do pino GPIO e o MicroPython no Pico.
Projeto 2: Sistema de monitoramento de temperatura (intermediário)
Requisitos de hardware
Reúna um Raspberry Pi Pico, um sensor de temperatura DS18B20, um resistor de 4,7 k-ohm, uma placa de ensaio e fios de ligação. O DS18B20 usa uma interface 1-Wire, portanto, conecte seu VCC a 3,3 V, GND ao terra e o pino DATA ao pino GPIO 18 no Pico. O resistor fica entre o pino DATA e o VCC para puxar o sinal para cima. Essa configuração garante uma comunicação estável entre o Pico e o sensor de temperatura, pois o protocolo 1-Wire requer um resistor pull-up adequado para uma transmissão de dados confiável.
Desenvolvimento de código
No MicroPython, use as bibliotecas onewire e ds18x20 para se comunicar com o sensor. Primeiro, importe as bibliotecas e inicialize o barramento 1-Wire:
import machine
import onewire
import ds18x20
import time
Em seguida, configure o barramento no pino GPIO escolhido:
ds_pin = machine.Pin(18)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
Procure dispositivos e crie um objeto DS18B20:
roms = ds_sensor.scan()
print('Found DS devices: ', roms)
O código a seguir lê a temperatura e a imprime no console:
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
print(ds_sensor.read_temp(rom))
time.sleep(2)
Registro e exibição de dados
Para tornar o sistema mais útil, você pode adicionar um pequeno display OLED (conectado via I2C) para mostrar a temperatura em tempo real ou registrar os dados em um arquivo em um computador conectado. Para o display OLED, você pode usar a biblioteca ssd1306. Primeiro, importe os módulos necessários e inicialize a interface I2C:
from machine import I2C, Pin
import ssd1306
i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000)
oled = ssd1306.SSD1306_I2C(128, 32, i2c)
Em seguida, modifique o loop de leitura da temperatura para exibir a temperatura no OLED:
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
print(temp)
oled.fill(0)
oled.text(f"Temp: {temp} C", 0, 0)
oled.show()
time.sleep(2)
Para registrar dados, você pode usar o código a seguir para gravar os dados de temperatura em um arquivo no sistema de arquivos interno do Pico:
file = open('temperatures.txt', 'w')
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
print(temp)
file.write(f"{time.time()},{temp}\n")
file.flush()
time.sleep(2)
Este projeto demonstra como fazer a interface com sensores externos usando os pinos GPIO do Pico e mostra sua capacidade de lidar com a aquisição de dados de sensores.
Projeto 3: Carregador de dados IoT (avançado)
Configuração do hardware
Você precisará de um Raspberry Pi Pico W (com Wi-Fi integrado), um sensor ambiental BME280 (mede temperatura, umidade e pressão), uma placa de ensaio e fios de ligação. Conecte o BME280 ao Pico usando I2C: SDA ao GPIO 8, SCL ao GPIO 9, VCC ao 3,3 V e GND ao terra. Essa configuração de conexão permite que o Pico se comunique com o sensor BME280 através do barramento I2C, possibilitando a recuperação de dados ambientais.
Integração de código e IoT
Usando o MicroPython no Pico W, primeiro conecte-se a uma rede Wi-Fi. Configure as credenciais Wi-Fi:
import network
ssid = 'your_SSID'
password = 'your_PASSWORD'
Conecte-se usando a interface de rede:
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(ssid, password)
while not wlan.isconnected():
pass
print('Connected to WiFi')
Em seguida, inicialize o sensor BME280 usando a classe bme280. Pode ser necessário instalar a biblioteca bme280, caso ainda não esteja instalada. Veja como inicializá-la:
import bme280_i2c
i2c = machine.I2C(0, sda=machine.Pin(8), scl=machine.Pin(9))
bme = bme280_i2c.BME280_I2C(i2c)
O código lê os dados do sensor e os envia para uma plataforma IoT como Ubidots ou Thingspeak usando o método HTTP POST. Aqui está uma versão simplificada da função de envio de dados:
import urequests
def upload_data(temperature, humidity, pressure):
url = 'https://industrial.api.ubidots.com/api/v1.6/devices/your_device_label'
headers = {'X-Auth-Token': 'your_token', 'Content-Type': 'application/json'}
data = '{"temperature": %s, "humidity": %s, "pressure": %s}' % (temperature, humidity, pressure)
response = urequests.post(url, headers=headers, data=data)
if response.status_code == 200:
print('Data uploaded successfully')
else:
print('Error uploading data')
response.close()
while True:
temperature, pressure, humidity = bme.values
temperature = float(temperature.strip(' C'))
humidity = float(humidity.strip(' %'))
pressure = float(pressure.strip(' hPa'))
upload_data(temperature, humidity, pressure)
time.sleep(60)
Testes e escalabilidade
Assim que o código estiver em execução, o Pico W se conectará à Internet, lerá os dados do BME280 e os enviará para a plataforma IoT escolhida. Você pode visualizar os dados em tempo real no painel da plataforma. Este projeto destaca os recursos sem fio do Pico W e mostra como construir soluções IoT escaláveis com o Pico, abrindo as portas para aplicações domésticas inteligentes, monitoramento ambiental e muito mais. Se você planeja expandir este projeto, pode adicionar mais sensores, ajustar os intervalos de coleta de dados ou até mesmo usar uma plataforma IoT mais robusta com recursos avançados de análise.
Conclusão
O Raspberry Pi Pico é uma ferramenta fantástica para criadores de todos os níveis, oferecendo possibilidades infinitas para projetos criativos. Quer você esteja apenas começando com um simples LED piscante ou construindo um sistema IoT avançado, o preço acessível, o desempenho e a facilidade de uso do Pico o tornam a melhor escolha. Espero que esses projetos o inspirem a começar a experimentar suas próprias construções com o Pico. Compartilhe seus projetos nos comentários abaixo — adoraria ver o que você criou!
