Para um projeto simples com a luz de led piscando, precisaremos do IDE Thonny e dos itens abaixo:
▶ Placa Raspberry Pi Pico W com cabo usb
▶ Protoboard (400)
▶ 2 Jumper macho-macho
▶1 LED Vermelho 5mm (um de seus terminais é mais longo que o outro. Conecte o terminal mais longo à mesma fileira do resistor e o fio mais curto à mesma fileira no espaço intermediário da protoboard)
▶1 Resistor 220 ohm (Os anéis coloridos do resistor de 220 ohms são vermelho, vermelho, preto, preto e marrom.)
No esquema da montagem do circuito, as linhas coloridas são a representação gráfica dos jumpers. Utilize-os para ligar os componentes entre si conforme a ilustração abaixo.
Para proteger o LED, a corrente deve passar por um resistor de 220 ohms. Um terminal do resistor deve ser inserido na mesma linha do pino Pico W GP15, e o outro terminal deve ser inserido na linha livre da protoboard.
Este projeto pode emitir níveis altos e baixos digitais (0 e 1)
usamos apenas dois sinais de saída: nível alto e nível baixo (também chamados de ON e OFF), que é chamado de saída digital. No entanto, na utilização real, muitos dispositivos não se limitam a LIGAR/DESLIGAR para funcionar.
Montagem do circuito:
Script:
import machine
import utime
led = machine.Pin(15, machine.Pin.OUT)
while True:
led.value(1)
utime.sleep(2)
led.value(0)
utime.sleep(2)
Explicação:
A biblioteca que será usada neste projeto é a machine, que será necessária para usar as portas GPIO. Essa biblioteca já faz parte do pacote de bibliotecas básicas do MicroPhyton que instalamos na IDE Thonny.
import machine
A biblioteca contém todas as instruções necessárias para a comunicação entre MicroPython e a Pico W. Na ausência desta linha de código, não poderemos controlar nenhum GPIO.
A próxima que temos que prestar atenção é esta linha:
led = machine.Pin(15, machine.Pin.OUT)
O objeto led é definido aqui. Tecnicamente, pode ser qualquer nome, como x, y, banana, ou qualquer personagem. Para garantir que o programa seja fácil de ler, é melhor usar um nome que descreva a finalidade.
Na segunda parte desta linha (a parte após o sinal de igual), chamamos a função Pin, encontrada na biblioteca machine. É usada para informar aos pinos GPIO da Pico o que fazer.
A função Pin possui dois parâmetros:
O primeiro (15) representa o pino a ser configurado;
O segundo parâmetro (machine.Pin.OUT) especifica que o pino deve ser de saída em vez de entrada.
O código acima “configurou” o pino, mas não acenderá o LED. Para fazer isso, também precisamos “usar” o pino, ou seja, dizer qual função ele fará.
led.value(1)
O pino GP15 foi configurado anteriormente e denominado led. A função desta instrução é definir o valor de led como 1 para acender o LED.
Resumindo, para usar o GPIO, estas etapas são necessárias:
Importar biblioteca da máquina: isso é necessário e só é executado uma vez.
Definir GPIO: Antes de usar, cada pino deve ser definido.
Uso: Altere o estado de funcionamento do pino atribuindo um valor a ele.
Se seguirmos as etapas acima para escrever um exemplo, você obterá um código como este:
import machine
led = machine.Pin(15, machine.Pin.OUT)
led.value(1)
Execute-o e você poderá acender o LED.
A seguir, tentamos adicionar a declaração oposta, ou seja LED desligado:
import machine
led = machine.Pin(15, machine.Pin.OUT)
led.value(1)
led.value(0)
Com base na linha de código, este programa acenderá primeiro o LED e depois o apagará. Mas ao usá-lo, você descobrirá que não é esse o caso, pois não vemos o LED aceso. Isto se deve à velocidade de execução muito rápida entre as duas linhas, muito mais rápida do que o olho humano pode reagir. Quando o LED acende, não percebemos a luz instantaneamente. Isso pode ser corrigido desacelerando o programa.
A segunda linha do programa deve conter a seguinte instrução:
import utime
Da mesma forma que machine, a biblioteca utime é importada aqui, que trata de todas as coisas relacionadas ao tempo. Os atrasos que precisamos usar estão incluídos nisso. Adicione uma instrução de atraso entre led.value(1)e led.value(0) deixe-os separados por 2 segundos.
utime.sleep(2)
É assim que o código deve ficar agora. Veremos que o LED acende primeiro e depois apaga quando o executamos:
import machine
import utime
led = machine.Pin(15, machine.Pin.OUT)
led.value(1)
utime.sleep(2)
led.value(0)
Finalmente, devemos fazer o LED piscar. Vamos criar um laço para repetir infinitamente a parte que queremos do programa com o laço while. Coloque as linhas que você quer que repitam após adicionar a linha while True: Todas as linhas que serão repetidas devem ser identadas (espaçadas com tab). Esse espaçamento determina todas as linhas de código que serão englobadas pelo laço de repetição.
Emitir o sinal PWM
Projeto para emitir o sinal PWM do GP15 para controlar o brilho do LED, para funcionar, por exemplo, ajustando a velocidade do motor, ajustando o brilho da lâmpada de mesa, e assim por diante. Para atingir esse objetivo a modulação por largura de pulso (PWM) surgiu como uma solução viável para problemas tão complexos.
Um pulso é uma saída digital que contém um nível alto e um nível baixo. A largura de pulso desses pinos pode ser ajustada alterando a velocidade ON/OFF.
Quando estivermos em um curto período de tempo (como 20ms, que é o período de retenção visual da maioria das pessoas), deixar o LED acender, desligar e ligar novamente, não veremos que ele foi desligado, mas sim o brilho da luz será ligeiramente mais fraca. Durante este período, quanto mais tempo o LED estiver aceso, mais brilhante ele se tornará. Em outras palavras, no ciclo, quanto mais amplo o pulso, maior será a “intensidade do sinal elétrico” emitida pelo microcontrolador. É assim que o PWM controla o brilho do LED (ou a velocidade do motor).
A Pico W suporta PWM em cada pino GPIO, mas na verdade existem 16 saídas PWM independentes (em vez de 30), distribuídas entre GP0 a GP15 à esquerda, e a saída PWM do GPIO direito é idêntica à esquerda.
É importante evitar configurar o mesmo canal PWM para finalidades diferentes durante a programação. Por exemplo, GP0 e GP16 são ambos PWM_0A.
O brilho do LED em PWM é controlado pelo controle da largura do pulso, que é a quantidade de tempo que o LED fica aceso a cada ciclo. Com uma frequência de temporizador de 100 Hz, cada ciclo leva 0,01 segundo, ou 10 ms.
Para obter o efeito de desbotamento mostrado no início deste tutorial, queremos definir a extensão do pulso para um valor pequeno, depois aumentar lentamente a extensão do pulso para iluminar o LED e recomeçar quando atingirmos o brilho máximo.
import machine
import utime
led = machine.PWM(machine.Pin(15))
led.freq(1000)
for brilho in range(0,65535,50):
led.duty_u16(brilho)
utime.sleep_ms(10) led.duty_u16(0)
A linha led = machine.PWM(machine.Pin(15)) define o pino GP15 como saída PWM.
A linha led.freq(1000) é usada para definir a frequência PWM, aqui ela é configurada para 1000Hz, o que significa que 1ms (1/1000) é um ciclo.
a linha for brightness in range(0,65535,50): itera a variável brightness
A linha led.duty_u16() é usada para definir o ciclo de trabalho, que é um número inteiro de 16 bits (2 ^ 16 = 65536). Um 0 indica ciclo de trabalho de 0%, o que significa que cada ciclo tem 0% de tempo para gerar um nível alto, ou seja, o sinal fica desligado durante todo o ciclo. O valor 65535 indica um ciclo de trabalho de 100%, o que significa que o sinal está ativado durante todo o ciclo, e o resultado é ‘1’. Quando for 32768 (metade do valor) , ele ficará em nível alto durante metade do ciclo, então o LED terá metade do brilho quando estiver totalmente ligado.