Primeiros Passos com Raspberry Pi Pico

O que é?

Lançada em 2021, Raspberry Pi Pico é a primeira placa microcontrolada da série Raspberry Pi. Diferentemente das demais, seu chip principal é o RP2040, o primeiro microcontrolador desenvolvido pela empresa. Tendo baixo custo quando comparada com as demais placas com chips de 32 bits, é bem versátil e, portanto, tem potencial para integrar diversos projetos. A seguir, algumas características destacadas no datasheet da placa:

• 2MB de memória flash;
• 264KB de memória SRAM;
• 26 GPIO, das quais 3 podem ser utilizadas como entrada analógica de 12 bits;
• Alimentação de 1.8 a 5.5 V, com conversão chaveada para 3.3 V;
• Processador Dual Core Cortex M0+;
• Clock de até 133MHz;
• 2 x UART, 2 x I2C, 2 x SPI;
• Timer, RTC, PWM de 16 bits;

Pinagem

Pinagem da placa

• VBUS: Ligado diretamente à alimentação USB (pode ser utilizado para alimentar o Pico);
• VSYS: Ligado por meio de um diodo à alimentação USB (pode ser utilizado para alimentar o Pico sem impor tensão à porta USB);
• 3V3_EN: Conectado ao pino “enable” do chip de chaveamento (desabilita o Pico quando colocado em nível baixo);
• 3v3(OUT): Saída do conversor DC-DC;
• ADC_VREF e AGND: Pinos de referência para o ADC (usados quando a precisão do conversor é um fator crítico);
• ADC0-2: Conversores analógico-digital;
• I2c0-1: Portas I2C (para cada porta, diferentes pinos podem ser utilizados para a interface);
• RUN: Habilita o RP2040 (quando colocado em nível baixo, reseta o sistema);
• SPIo-1: Portas SPI (para cada porta, diferentes pinos podem ser utilizados para a interface);
• UART0-1: Portas UART (para cada porta, diferentes pinos podem ser utilizados para a interface);
• SWD: Porta para depuração em circuito.

Como Programar?

A forma mais simples de programar o Raspberry Pi Pico é utilizando o MicroPython. Este interpretador pode ser carregado como firmware na placa e usado para traduzir os códigos em Python salvos em sua memória flash. Já o software que melhor funciona com este interpretador é o Thonny Python, que pode ser baixado pelo link.

Ferramentas de software utilizadas neste tutorial

Com a IDE instalada e configurada de acordo com suas preferências, poderemos carregar o firmware na placa. Para isso, feche a IDE e, com a placa desenergizada, pressione e segure o botão “BOOTSEL”, visto na imagem abaixo.

Enquanto o mantém pressionado, conecte a placa, via USB, ao computador, que irá percebe-la como um dispositivo de armazenamento. Então, abra a IDE e, no canto inferior direito, clique na versão do Python mostrada.

No menu que será aberto, selecione “MicroPython (Raspberry Pi Pico)”.

A partir daí, prossiga com o processo de instalação.

Ao término, você poderá controlar sua placa pela IDE. Para testar, digite, no terminal que aparece no canto inferior da tela, “from machine import Pin”, pressione enter, “led = Pin(25, Pin.OUT)”, pressione enter e “led.value(1)” e pressione enter. Neste momento, o Led embutido na placa deverá estar aceso. Para apaga-lo, digite “led.value(0)” e tecle enter. Caso algo dê errado no processo, verifique se as etapas de instalação foram executadas adequadamente.

Controle do Raspberry Pi Pico por REPL

Já para salvar um programa na memória do Pico, abra um novo arquivo na IDE, escreva seu código no campo de edição, clique em salvar e escolha “MicroPython device”.

No nome, inclua, ao fim, a extensão “.py”. Com o arquivo salvo, basta clicar em “Run current script” (circulo verde ao lado da opção de salvar) com ele aberto na IDE para que o Raspberry Pi Pico o execute. Para que o código seja executado automaticamente na energização do Pico, mesmo que desconectado do computador, basta nomear o arquivo como “main.py”.

Exemplos

Em todos os exemplos utilizaremos a montagem vista a seguir. Nela serão utilizados:

Materiais necessários para os projetos de exemplo

• Conversor de Nível Lógico 3.3V-5V Bidirecional – 2 Canais (já que o LCD opera em 5 volts e o Pico em 3.3 volts)
• Potenciômetro linear 50 k
• Led Alto Brilho 5mm Amarelo
• Resistores 220 ohm e 6k8 ohm
• Botão de 2 pinos
• Jumpers rígidos
• Jumpers Macho/Femea
• LCD com módulo I2C e backlight azul
• Protoboard 830 pontos
• Raspberry Pi Pico

Montagem a ser utilizada ao longo dos exemplos

Caso a comunicação I2C falhe por conta do conversor de nível, é possível ligar diretamente os barramentos. Entretanto, não é uma boa prática.

Blink

Para nosso primeiro programa, led_blink.py, utilizaremos o código a seguir, explicado por comentários nele mesmo.

#importa as classes a serem utilizadas
from machine import Pin, Timer

#instancia o pino 15 como uma saída para led
led = Pin(15, Pin.OUT)

#instancia timer como um objeto do tipo Timer()
timer = Timer()

#descreve a função blink
def blink(timer): #colocar timer como parâmetro é necessário para indicar que a função é callback deste objeto
    led.toggle()  #inverte o estado do led

#inicia o timer com frequencia de 1 Hz, modo periódico (não encerra após o primeiro ciclo) e callback para blink
timer.init(freq = 1, mode = Timer.PERIODIC, callback = blink)

Repare que não há rotinas de delay ou sleep neste código. Portanto, é possível atribuir instruções para que o processador execute nos intervalos entre as mudanças de estado do led.

A seguir, o funcionamento do código:

PWM

Nosso segundo exemplo, led_pwm.py, visa demonstrar o funcionamento das saídas analógicas da placa. O código a seguir também tem sua descrição em forma de comentários.

#importa as classes que serão utilizadas
from machine import Pin, PWM
from time import sleep

#instancia o pino 15 como saída PWM
pwm = PWM(Pin(15))

#define a frequencia, em Hz, da saída
pwm.freq(1000)

#ciclo infinito
while True:
    for duty in range(65025): #varia duty de 0 a 2^16
        pwm.duty_u16(duty)    #define o duty-cicle como igual a duty
        sleep(0.0001)         #delay de 100 us
    for duty in range(65025, 0, -1): #realiza o mesmo processo
        pwm.duty_u16(duty)           #do ciclo anterior, mas com
        sleep(0.0001)                #duty variando decrescentemente

O funcionamento:

Botão

Neste exemplo, led_button.py, veremos como utilizar as entradas digitais do Pico. A explicação está no código, em forma de comentários.

#importa as classes que serão utilizadas
from machine import Pin
from time import sleep

#instancia led como saida digital
#e button como entrada digital
led = Pin(15, Pin.OUT)
button = Pin(16, Pin.IN)

#ciclo infinito
while True:
    if not button.value(): #se o botao não estiver em nível alto
                           #e, portanto, estiver apertado
                           #já que liga a entrada ao GND
        led.toggle()       #inverte o valor do led
        sleep(0.5)         #delay para debounce

O funcionamento pode ser visto abaixo:

Leitura analógica demonstrada em LCD

Para nosso último exemplo, será necessário o uso de duas bibliotecas. Ambas podem ser encontradas neste link. Abra dois novos arquivos na IDE. Em um, cole o conteúdo de lcd_api.py. No outro, o de pico_i2c_lcd.py. Salve cada um com o respectivo nome e feche-os. Eles estarão salvos na memória do microcontrolador como os demais arquivos. Por fim, crie o arquivo adc_lcd.py e, nele, escreva o código:

#importa as classes que serão utilizadas
from pico_i2c_lcd import I2cLcd
from machine import I2C, Pin, ADC
from time import sleep

#instancia o pino de entrada analógica
adc = ADC(Pin(26))

#instancia a conexão I2C, utilizando a interface 0
#o pino 1 como scl, o 0 como sda e a frequencia de
#medições como 100000 Hz
i2c = I2C(id=0,scl=Pin(1),sda=Pin(0),freq=100000)

#instancia o LCD com a conexão i2c iniciada anteriormente,
#o endereço 0x27 do barramento e 2 linhas de 16 caracteres
lcd = I2cLcd(i2c, 0x27, 2, 16)

#ciclo infinito
while True:
    lcd.putstr('V: ')                               #escreve a partir da primeira posição
    lcd.putstr(str(adc.read_u16()  * 3.3 / 65535))  #escreve a leitura do ADC convertida p/ tensão
    sleep(0.5)                                      #aguarda meio segundo
    lcd.clear()                                     #limpa o LCD e volta p/ primeira posição

Para descobrir o endereço do LCD, rode o seguinte código com ele conectado ao Pico.

import machine
 
sda=machine.Pin(0)
scl=machine.Pin(1)
 
i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)
 
print('I2C address:')
print(i2c.scan(),' (decimal)')
print(hex(i2c.scan()[0]), ' (hex)')

O endereço será mostrado no terminal da IDE.

Funcionamento:

Por Fim

Neste post, vimos algumas funcionalidades do Raspberry Pi Pico e uma forma diferente de programar um microcontrolador. O MicroPython também pode ser utilizado junto aos ESP’s e outros chips. Futuramente, veremos como explorar sua divisão de núcleos e como programa-lo com linguagens compiladas, aumentando sua eficiência e aproveitando melhor seu armazenamento. Obrigado pela leitura!

Referência:

https://projects.raspberrypi.org/en/projects/getting-started-with-the-pico/0

Tenha a Metodologia Eletrogate na sua Escola! Conheça nosso Programa de Robótica Educacional.

Sobre o Autor

Eduardo Henrique Formado técnico em mecatrônica no CEFET-MG, atualmente estuda Engenharia de Controle e Automação na UFMG.