Uma introdução ao Raspberry Pi Pico com MicroPython

Tempo de leitura: 9 minutes

O Raspberry Pi Pico foi lançado recentemente pela Raspberry Pi Foundation como um microcontrolador competitivo na esfera da eletrônica de código aberto. O Pico compartilha muitos dos recursos das placas Arduino comuns, incluindo: conversão analógico para digital (ADC de 12 bits), UART, SPI, I2C, PWM, entre outros. A placa tem apenas 21mm x 51mm de tamanho, tornando-a ideal para aplicações que exigem designs de baixo perfil. Uma das inovações do Pico é o processador dual-core, que permite multiprocessamento a taxas de clock de até 133 MHz. Um atrativo particular do Pico é sua compatibilidade com MicroPython, que é escolhido como a ferramenta de programação para este projeto. O foco em MicroPython, em oposição a C/C++, minimiza a confusão e o tempo necessário para começar a usar o Pico. Um computador Raspberry Pi 4 é ideal para interface com o Pico, que pode ser usado para preparar, depurar e programar o Pico. Do início ao fim – este tutorial ajuda os usuários a executar seu primeiro script MicroPython personalizado no Pico em apenas alguns minutos. Um LED RGB será usado para demonstrar a entrada/saída de uso geral do microcontrolador Pico.

 

Lista de peças para o tutorial

Um computador Raspberry Pi Pico e Raspberry Pi 4 são os componentes mínimos necessários para testar o Pico. O Pico possui um LED integrado que pode ser controlado e usado para testar a funcionalidade básica do microcontrolador. No entanto, queremos testar os recursos em uma peça externa de hardware. Um LED RGB será usado para testar as entradas/saídas de uso geral (GPIOs) do Pico junto com a modulação por largura de pulso (PWM) para ajustar o brilho do(s) LED(s). Uma meia protoboard (as mini protoboard são muito pequenas) também será usada para nossos testes do LED RGB. A lista completa de peças é fornecida abaixo para acompanhar o tutorial:

  1. Raspberry Pi Pico (1)
  2. Computador Raspberry Pi 4 (1)
  3. LED RGB (1)
  4. fios de jumper (macho para macho)
  5. ProtoBoard Pequena (400 pontos)

Observe que o Raspberry Pi Pico , em conjunto com um computador Raspberry Pi 4, são as únicas partes necessárias para este tutorial!

O diagrama de pinagem para o Raspberry Pi Pico é fornecido abaixo para referência:

O diagrama de pinagem será essencial para testar o Pico e determinar quais pinos GPIO serão usados para controlar o LED RGB.

Configuração MicroPython no Microcontrolador Pico

O microcontrolador RP2040 está no centro do Raspberry Pi Pico. O RP2040 possui uma porta MicroPython nativa e um bootloader USB Flashing Format (UF2) em sua memória, o que significa que o Pico pode lidar diretamente com o código Python carregado por meio de um IDE. Thonny será usado como IDE no computador Raspberry Pi 4, que já está instalado nas distribuições mais recentes do Raspberry Pi OS.

O guia de “Primeiros passos” do MicroPython na página da web do Raspberry Pi Pico é usado como modelo para grande parte da inicialização do MicroPython e do Pico que se segue. As capturas de tela a seguir resumem o processo necessário para preparar o Pico para programação MicroPython com Thonny:

Etapa 1: Baixe o arquivo UF2 do MicroPython para o Pico

Também disponível para download na página do Pico

(Download)

Etapa 2: mantenha pressionado o BOOTSEL e conecte o Pico à porta USB no Raspberry Pi 4

O Pico agora deve ser mostrado como um dispositivo de armazenamento em massa na área de trabalho do Raspberry Pi 4. O nome do dispositivo deve ser RPI-RP2, que representa o microcontrolador RP2040.

Etapa 3: Verifique o dispositivo RPI-RP2 no gerenciador de arquivos

Em seguida, arraste e solte o arquivo UF2 baixado contendo a distribuição MicroPython no dispositivo RPI-RP2:

Etapa 4: arraste e solte o arquivo UF2 MicroPython baixado para o dispositivo RPI-RP2 (Pico)

RPI-RP2 é o nome do dispositivo de armazenamento em massa do Pico, que deve desaparecer após arrastar e soltar o arquivo UF2 nele

Neste ponto, o Pico está pronto para funcionar como um dispositivo habilitado para MicroPython. O dispositivo agora funciona como um microcontrolador pronto para ser programado em Python.

Agora podemos verificar se o Python está funcionando no Pico testando sua interface de linha de comando com o minicom. Primeiro, certifique-se de que ‘minicom’ esteja instalado no RPi por meio do terminal:

[email protected]:~ $ sudo apt-get install minicom

Assim que o minicom estiver instalado, verifique a localização do microcontrolador Pico usando o seguinte comando no terminal:

[email protected]:~ $ ls /dev/tty*

O Pico pode ser encontrado desconectando e executando o comando acima e, em seguida, conectando o Pico e executando o comando novamente e procurando a porta alterada. O Pico provavelmente está na port/dev/ttyACM1, se nenhum outro dispositivo estiver conectado. A porta do Pico aparecerá conforme mostrado abaixo:

Descoberta da porta do dispositivo Pico (ttyACM0)

Antes e depois de conectar o Pico à porta USB

Agora podemos verificar a comunicação entre o microcontrolador Raspberry Pi e Pico usando comandos minicom para obter acesso ao terminal Python:

[email protected]:~ $ minicom -o -D /dev/ttyACM0

O menu minicom resultante deve aparecer:

Menu Minicom no Microcontrolador Pico

Pressionar “Enter” leva o usuário ao terminal Python, onde o usuário pode controlar o microcontrolador Pico usando comandos Python

O primeiro teste real que podemos fazer neste momento é ligar o LED integrado por meio de uma série de comandos:

Alternando o LED Pico Onboard para seu estado On

O LED integrado deve estar aceso após as três linhas do código Python serem inseridas

As três linhas de código são:

>>>from machine import Pin
>>>led = Pin(25,Pin.OUT)
>>>led.high()

Da mesma forma, se a variável led for então definida como led.low() – o LED integrado será desligado.

 

Intérprete MicroPython no Thonny IDE

Agora que o MicroPython está funcionando no Pico, podemos passar para uma programação mais robusta com Python no Pico. A maneira como fazemos isso é trabalhando com o IDE Thonny no Raspberry Pi. A maioria das distribuições do Raspberry Pi OS tem uma instalação do Thonny incluída na primeira inicialização do sistema operacional. No entanto, se uma versão sem cabeça ou lite estiver sendo usada, Thonny precisará ser instalado. Isso pode ser feito por meio de ‘sudo pip3 install thonny’. Daqui para frente, presume-se que Thonny já esteja instalado no Raspberry Pi. Primeiro, abra Thonny e procure o menu ‘Ferramentas’ na barra de ferramentas:

Abra Thonny no The Raspberry Pi

Alterne para o modo normal se nenhuma barra de ferramentas estiver disponível, saia e reabra o IDE

Se o Thonny IDE for semelhante ao acima, clique em ‘Alternar para o modo normal’ e, em seguida, saia e reabra o IDE.

A janela Thonny correta com a barra de ferramentas habilitada

Observe o Shell indicando Python 3. Isso será alterado para MicroPython no Pico.

A seguir, diremos a Thonny para usar o Raspberry Pi Pico como intérprete, o que pode ser feito da seguinte maneira:

Navegue até Ferramentas -> Opções

 

Selecione Intérprete e escolha ‘MicroPython (Raspberry Pi Pico)’ para usar o Pico com Thonny

Agora, o shell Thonny pode ser usado de maneira semelhante à interface do minicom. Voltando às três linhas de código que controlam o LED integrado do Pico, podemos testar o interpretador MicroPython no Pico:

Confirme MicroPython no Thonny Shell

O interpretador MicroPython também pode ser verificado ligando o LED do Pico no shell

A vantagem de usar Thonny é que ele permite scripts e depuração de software ao vivo. Um script também pode ser enviado ao Pico com o nome ‘main.py’ e será executado em um loop infinito semelhante ao loop() executado indefinidamente em um microcontrolador Arduino. Na próxima seção, será desenvolvido um script que controla os componentes vermelho, verde e azul de um LED RGB usando as entradas/saídas de uso geral (GPIOs) no Pico.

 

Pico GPIO testa com um LED RGB

Os pinos de entrada/saída de uso geral (GPIO) no microcontrolador Pico serão testados através do desenvolvimento de um script que ajusta o brilho dos componentes em um LED RGB usando dois tipos de controle: booleano e modulação por largura de pulso (PWM). O controle booleano liga e desliga cada LED com uma designação alta e baixa. O controle PWM usa uma modulação de ciclo de trabalho para controlar o brilho dos LEDs.

Diagrama de fiação do LED RGB para Raspberry Pi Pico

GPIOs 16-18 conectados aos pinos de LED vermelho, verde e azul

 

O pino 23 é usado como aterramento

O script abaixo é usado para ligar e desligar cada LED em um loop infinito:

################################
# Testes de LED RGB no RPi Pico
################################
from machine import Pin
import time

led_pins = [16,17,18] # pinos onde o LED RGB está conectado
leds = [Pin(led_pins[0],Pin.OUT),Pin(led_pins[1],Pin.OUT),
        Pin(led_pins[2],Pin.OUT)] # matriz de controle de pinos
delay_t = 0.1 # segundos para atrasar entre alternâncias
while True: # loop infinitely
    for led in leds: # loop através de cada led
        led.high() # LED alto
        time.sleep(delay_t) # wait
        led.low() # LED baixo
        time.sleep(delay_t) # wait

O código acima deve ser inserido na parte do script <untitled> do Thonny IDE.

 

Procedimento para enviar o código ao microcontrolador Pico:

  1. Pressione F5 ou o botão Executar
  2. Selecione ‘Raspberry Pi Pico’ como o local para salvar
  3. Nomeie o arquivo ‘main.py’ para executar o script indefinidamente no Pico
  4. Clique em OK e observe a execução do script (LED Blink Loop)

Salvar o script como ‘main.py’ irá executar o script imediatamente após as botas do Pico

Salvar o script com outro nome irá salvá-lo no Pico, mas só será executado quando for instruído (via Minicom ou Thonny).

A seguir, podemos testar as funções de modulação por largura de pulso (PWM) do Pico ajustando o brilho de cada LED no LED RGB. Especificamente, o LED pode ser feito para parecer “respirando” aumentando e diminuindo seu brilho. O código para fazer isso é fornecido abaixo:

################################
# Controle Pico PWM de LED RGB
################################
import time
from machine import Pin,PWM

pwm_pins = [16,17,18] # set PWM pins
pwms = [PWM(Pin(pwm_pins[0])),PWM(Pin(pwm_pins[1])),
                PWM(Pin(pwm_pins[2]))] # matriz pwm
[pwm.freq(1000) for pwm in pwms] # definir freqs pwm

step_val = 64 # valor da etapa para respiração de 16 bits
range_0 = [ii for ii in range(0,2**16,step_val)] # iluminando
range_1 = [ii for ii in range(2**16,-step_val,-step_val)] # escurecimento

while True: # loop indefinitely
    # looping através da respiração vermelha, azul e verde
    for pwm in pwms: 
           for ii in range_0+range_1:
               pwm.duty_u16(ii) # definir o ciclo de trabalho de 16 bits
               time.sleep(0.001) # dormir 1ms entre mudança pwm
    # respiração de pixel branco (todos os três LEDs)
    for ii in range_0+range_1:
        for pwm in pwms:
            pwm.duty_u16(ii) # definir o ciclo de trabalho
        time.sleep(0.001) # wait 1ms

Semelhante ao código acima, certifique-se de selecionar F5 ou Executar e salve o arquivo como o novo arquivo ‘main.py’ no Pico. Isso fará com que o script seja executado indefinidamente, resultando em uma aparência de “respiração” interminável do LED RGB.

A frequência do pulso PWM foi definida para 1000Hz (1kHz), que é semelhante a algumas placas Arduino. 500 Hz também pode ser usado, já que outras placas/pinos Arduino também usam essa frequência. Da mesma forma, o retardo pode ser alterado para alterar o efeito ou a velocidade da respiração.

 

Conclusão

O Raspberry Pi Pico foi apresentado como um novo microcontrolador habilitado para MicroPython produzido pela Raspberry Pi Foundation. É um rival direto em alguns aspectos para empresas de eletrônicos de código aberto e ‘fabricantes’ competitivas, como Arduino, Espressif, PIC, Teensy e outras. Usando apenas um Raspberry Pi 4, o microcontrolador Pico pode ser programado para executar MicroPython e aproveitar seus vários periféricos: I2C, SPI, UART, PWM, conversão analógico-digital, etc. Neste tutorial, o Raspberry Pi Pico foi explorado usando Thonny, um Python IDE já instalado na distribuição geral do sistema operacional Raspberry Pi (Raspberry Pi OS). Os princípios básicos de introdução ao MicroPython e ao microcontrolador Pico foram introduzidos pela primeira vez, seguidos por alguns testes de hardware simples com entradas e saídas de uso geral (GPIOs) e um LED RGB. Este foi concebido como um tutorial simplificado de “introdução” com o Pico e o primeiro de uma série dedicada a trabalhar com o microcontrolador Raspberry Pi Pico.
Visits: 1 Visits: 1199748