ViperIDE, criado por Volodymyr Shymanskyy, é uma ferramenta extremamente útil para quem escreve código MicroPython e deseja fazê-lo a partir de uma variedade de dispositivos. Sendo baseado em navegador, o ViperIDE funciona em muitas máquinas diferentes, desde laptops e desktops até smartphones e Chromebooks (testamos isso em nosso próprio Lenovo Chromebook e tudo correu bem).
Shymanskyy foi recentemente um convidado no nosso programa temático do Raspberry Pi, “The Pi Cast”, e fez uma demonstração ao vivo do ViperIDE. Este software gratuito é fácil de usar, e neste tutorial vamos guiá-lo pelo uso do ótimo editor, hackeando com um Raspberry Pi Pico e MicroPython.
Você não está limitado apenas a essas duas seleções. O ViperIDE também funciona com CircuitPython, placas ESP, Adafruit, Seeed e microcontroladores micro:bit.
Para este projeto, você vai precisar
1. Flash a versão mais recente do MicroPython no seu Raspberry Pi Pico seguindo os três primeiros passos deste guia.
2. Abra um navegador e visite o site do ViperIDE.
3. Certifique-se de que seu Raspberry Pi Pico está conectado e clique no ícone USB no canto superior direito.
4. No menu, selecione o dispositivo correto, geralmente Board CDC, e clique em Conectar. Após alguns segundos, o ViperIDE se conectará.
A Interface do Usuário do Viper
A interface do usuário do ViperIDE é dividida em seis áreas principais.
- Salvar e executar arquivos no Pico: O ícone verde de salvar irá salvar seu arquivo no Pico como main.py. Isso garante que o código será executado quando o Pico for ligado. O botão azul de play executará o código no Pico; os resultados são vistos no Terminal (5).
- Editor de Código: Aqui é onde qualquer código do projeto é escrito.
- Conexões: Os ícones em ordem são WebREPL (uma interface web que acessa diretamente o Pico), conectividade Bluetooth, USB (como acabamos de usar) e janela do editor em tela cheia.
- Gerenciadores e Configurações: Os ícones em ordem são Gerenciador de Arquivos (gerenciamento de arquivos do projeto no Pico), Gerenciador de Pacotes (um meio de instalar módulos e bibliotecas extras), Ferramentas (conexões de dispositivos e REPLs), Configurações (configura a localização e outras opções centradas no código) e finalmente Informações (detalhes sobre o repositório GitHub).
- Terminal: Também conhecido como REPL (Read-Eval-Print-Loop), aqui é onde a saída do nosso código é impressa e podemos interagir com o código MicroPython.
- Controles do Terminal: Podemos deletar a saída do Terminal, realizar um reset suave, realizar um reset completo e definir o Terminal para tela cheia.
Vamos dar nossos primeiros passos com um simples piscar de LED. O Raspberry Pi Pico e o Pico W têm um LED onboard que podemos piscar como uma forma de provar que podemos comunicar e controlar a placa.
1. No editor de código (2), importe dois módulos. O primeiro é “machine”, e a partir dele importamos Pin. Este módulo nos permite usar o GPIO. O segundo módulo é time, e a partir dele importamos a função sleep, que é usada para adicionar atrasos ao nosso código.
from machine import Pin
from time import sleep2. Crie um objeto chamado “led” e nele crie uma referência ao pino GPIO usado para o LED e configure o pino para ser uma saída. O antigo Raspberry Pi Pico usava GPIO25 para o LED onboard. Isso mudou com o Pico W, e a referência “LED” funciona para ambas as placas. Configurar o pino como saída significa que a corrente fluirá para o LED, fazendo-o acender.
led = Pin("LED", Pin.OUT)3. Adicione um loop for para iterar o código dez vezes. O código dentro do loop for é executado dez vezes, depois o loop sai e o código para de ser executado.
for i in range(10):4. Ligue/desligue o LED, imprima uma mensagem no Terminal e depois pause o código por 0,1 segundos. A função toggle() alterna o estado dos pinos GPIO, então desligado se torna ligado, e vice-versa. A função print está lá para mostrar que o código está sendo executado no Terminal, útil se nosso LED não estiver piscando. O sleep impede que o código MicroPython seja executado tudo de uma vez.
led.toggle()
print("TOGGLE")
sleep(0.1)5. Clique no botão Salvar (1) e depois clique em Executar (1) para executar o código no Pico. O LED onboard vai ligar e desligar até que o loop termine.
from machine import Pin
from time import sleep
led = Pin("LED", Pin.OUT)
for i in range(10):
led.toggle()
print("TOGGLE")
sleep(0.1)O gerenciador de pacotes do ViperIDE é uma ferramenta útil para instalar módulos extras do MicroPython (às vezes chamados de bibliotecas) de código pré-escrito. Esses módulos nos permitem usar componentes extras. Para demonstrar, usaremos um stick NeoPixel. Nosso stick tem oito LEDs RGB, que podem ser controlados individualmente usando o módulo NeoPixel.
Antes de escrever qualquer código, você precisará conectar seus NeoPixels conforme este diagrama. Escolhemos usar o GPIO 16 no Raspberry Pi Pico, pois é acessível e fornece um exemplo de fiação organizado.
1. Clique no Gerenciador de Pacotes e na lista encontre Neopixel. Clique na seta de download à direita de sua entrada. O processo de instalação instalará um arquivo chamado neopixel.mpy na pasta lib do seu Pico.
2. Clique no ícone Gerenciador de Arquivos (4) e procure pelo / no gerenciador de arquivos. Clique no sinal de + e crie um novo arquivo chamado blinky.py
3. Certificando-se de que blinky.py está selecionado, importe quatro módulos de código. Machine é nossa conexão com o GPIO. NeoPixel é um módulo para facilitar o trabalho com NeoPixels. Sleep é novamente usado para adicionar atrasos ao código. Finalmente, importamos um gerador de números pseudo-aleatórios (randint) do módulo random.
import machine
import neopixel
from time import sleep
from random import randint4. Crie um objeto, np, para vincular nosso código aos NeoPixels. Diga ao Pico que os NeoPixels estão conectados ao GPIO16 e que temos oito deles. Altere o número final de LEDs para corresponder ao número que você tem.
np = neopixel.NeoPixel(machine.Pin(16), 8)5. Em um loop for que itera dez vezes, crie três objetos, r, g, b, para representar as cores vermelho, verde e azul. Use a função randint para criar um número aleatório. Cada um desses objetos armazenará um número aleatório entre 0 e 255. Zero sendo desligado, e 255 sendo brilho total. Cada vez que este loop for itera, dez vezes, os valores r, g, b mudarão para produzir uma cor aleatória.
for i in range(10):
r = randint(0,255)
g = randint(0,255)
b = randint(0,255)6. Usando outro loop for, itere sobre todos os LEDs nos NeoPixels, neste caso oito. Usamos a variável i para armazenar nossa posição enquanto nos movemos pelos LEDs. Começa em zero e termina em sete. Então i = 0, i = 1, i = 2…
for i in range(8):7. Cada vez que o loop itera, defina o pixel atual (i) para os valores escolhidos aleatoriamente armazenados em r, g, b.
np[i] = (r,g,b)8. Escreva as mudanças para que possamos ver os NeoPixels mudarem de cor, adicione uma pausa de 0,1 segundo para manter a transição suave.
np.write()
sleep(0.1)9. Usando outro loop for, desta vez invertido para contar de trás para frente de oito a zero, defina todos os pixels como desligados. Ao inverter a faixa, podemos contar de trás para frente de oito a zero, mas precisamos informar à faixa quantos passos dar cada vez que conta para trás.
for i in reversed(range(0,8,1)):
np[i] = (0,0,0)
np.write()
sleep(0.1)10. Clique no botão Salvar (1) e depois clique em Executar (1) para executar o código no Pico. Os NeoPixels devem contar para cima e para baixo, cada vez mostrando uma cor diferente.
Listagem Completa do Código
import machine
import neopixel
from time import sleep
from random import randint
np = neopixel.NeoPixel(machine.Pin(16), 8)
for i in range(10):
r = randint(0,255)
g = randint(0,255)
b = randint(0,255)
for i in range(8):
np[i] = (r,g,b)
np.write()
sleep(0.1)
for i in reversed(range(0,8,1)):
np[i] = (0,0,0)
np.write()
sleep(0.1)Fonte: Tom’s Hardware