Uma maneira simples de aprender eletrónica é a usar o Raspberry Pi e a sua biblioteca “GPIO Zero”. Com poucas linhas de código em Python, poderá facilmente controlar atuadores, ler sensores, etc. Esta biblioteca foi criada por Ben Nuttall da Raspberry Pi Foundation, entre outros.
Aqui, neste rápido tutorial procurarei fornecer-lhe a base para a criação de circuitos simples, controlados pelo Raspberry Pi.
Para obter maiores detalhes, consulte o link abaixo:
GPIO Zero V 1.3.1 Documentation
Também poderá fazer o download grátis de um livro completo fornecido pela revista MagPi, que irá guiar-lo passo a passo no desenvolvimento de vários projetos utilizando a biblioteca GPIO Zero:
SIMPLE ELECTRONICS WITH GPIO ZERO
Neste tutorial, exploraremos os dispositivos de entrada (“sensores”):
- Botão
- Sensor de Detecção de Movimento e como saída (“atuadores”):
- LED
- Buzzer
- Saída digital genérica (motor de passo)
Vamos lá, mãos a obra!
1: Material utilizado
- Raspberry Pi (Tanto o V2 como o V3 funcionam da mesma maneira)
- PIR Motion Sensor
- Push-Button
- Resistência 330 ohms
- Cabos para ligação (“jumpers”) do tipo “Dupont” (Fêmea/Macho e Macho/Macho)
2: Instalar a biblioteca “GPIO Zero”
A primeira coisa a fazer é atualizar a sua lista de repositórios:
“sudo apt-get update“
Em seguida, instale o pacote à sua escolha. Tanto o Python 3 como o Python 2 são suportados. Mas o Python 3 é o recomendado:
“sudo apt-get install python3-gpiozero“
Numeração dos pinos do Raspberry Pi
É importante mencionar que a biblioteca “GPIO Zero” utiliza a numeração de pinos “Broadcom” (BCM) para os seus GPIOs, em oposição à numeração física da board. Qualquer pino marcado como GPIO ”x”, onde “x” é o número, no diagrama abaixo poderá ver a que pino do Raspberry Pi corresponde.
Por exemplo, se um LED for ligado fisicamente ao pino 12, deve ser associado ao “GPIO18” conforme o esquema abaixo indica:
3: “Hello World”: Piscar um LED
Para começar a dar o verdadeiro uso ao nosso Raspberry Pi, vamos começar por interligar:
- Pino físico 6 (GND) ao GND do “Breadboard Power Grid” (Azul -), utilizando um jumper preto.
- Pino físico 1 (3.3V) ao + VCC do “Breadboard Power Grid (Vermelho+), utilizando um jumper vermelho.
Agora, instalemos o LED, utilizando o pino físico 12 (GPIO18) ligado ao seu cátodo (perna mais longa do LED ). Monte agora o ânodo do LED ao GND do breadbord, utilizando e uma resistência de 330 ohms, reduzindo assim a corrente que passará no Led (para não danificar o mesmo), como mostra a figura abaixo:
Quando o hardware estiver ligado, vamos criar um programa em Python para ativar o LED:
from gpiozero import LED led = LED(18) led.on()
Para criar e executar o programa, poderá utilizar a aplicação Python3 que aparece no menu do RPi ou utilizar qualquer editor de texto gravando o arquivo, por exemplo como “MyPgmName.py” e depois executa-lo ou utilizando de uma linha de comando no monitor, por exemplo:
“sudo Python MyPgmName.py“
Como pode ver, criar um código em Python é muito simples, utilizando a biblioteca “GPIO Zero”.
Agora, vamos fazer um pisca-pisca com o LED.
Para fazer isso, também precisaremos importar outra biblioteca que é a “time”. Vamos precisar dela para definir a quantidade de tempo em que o LED permanecerá ligado e/ou desligado. No nosso caso, o LED piscará de 1 em 1 segundo (o argumento “time” da função sleep(time) foi dado em segundos).
from gpiozero import LED
from time import sleep
led = LED(18)
while True:
led.on()
sleep(1)
led.off()
sleep(1)
Como alternativa, poderá reduzir o código, utilizando a função “Blink()”, incluída na biblioteca:
from gpiozero import LED from signal import pause red = LED(17) red.blink() pause()
O vídeo abaixo, mostra o programa em funcionamento:
4: Lendo um sinal digital
Uma maneira simples de se obter um comando externo, é utilizando um botão e a Biblioteca GPIO Zero sendo uma maneira fácil de incluir no seu projeto. Não precisa de pensar em resistências pull-up ou pull-down, etc. Em termos de hardware, a única coisa a fazer é ligar uma perna de seu botão a qualquer um dos pinos digitais do Raspberry Pi, e a outra perna à terra (GND), como demonstra na figura anterior.
- Perna 1 do botão para GPIO2
- Perna 2 do botão para GND
Poderíamos escrever um simples código para ler o botão como este:
from gpiozero import Button
button = Button(2)
while True:
if button.is_pressed:
print("Button is pressed")
else:
print("Button is not pressed")
Outra ideia poderia ser adicionar um LED ao circuito, de maneira que o LED acenda quando o botão é pressionado e apague quando o mesmo é libertado.
Abaixo vemos como ficaria o código em Python para executar a tarefa:
from gpiozero import LED, Button from signal import pause led = LED(18) button = Button(2) button.when_pressed = led.on button.when_released = led.off pause()
O vídeo mostra o nosso projeto em funcionamento:
5: Como detetar movimento com o Raspberry Pi e PIR
Vamos explorar agora outros dispositivos comuns incluídos na biblioteca. Aproveitaremos um buzzer e um sensor de movimento (PIR) que juntamente com um LED funcionarão como um alarme.
O sensor PIR vai gerar um pulso de nível ALTO a qualquer movimento que aconteça no seu raio de visão. Este módulo utiliza o sensor infravermelho passivo LHI778 e o CI BISS0001 para controlar como o movimento é detetado. O módulo possui sensibilidade ajustável que permite uma faixa de detecção de movimento de 3 a 7 metros.
O dispositivo PIR tem uma pequena placa de circuito com três pinos: VCC, OUT e GND. O pino VCC deve ser ligado a um pino de 5V do RPi, o GND a um dos pinos de terra, e finalmente o pino OUT a um dos GPIOs, no nosso caso escolhemos o GPIO23.
Apesar do PIR ser alimentado com 5V, a sua saída fornece um máximo de 3.3V, por isso é seguro liga-lo diretamente ao pino do RPi.
O código Python abaixo mostra como podemos utilizar-lo:
from gpiozero import MotionSensor
pir = MotionSensor(23)
pir.wait_for_motion()
print("Motion detected!")
Para construir um alarme mais interessante, incluiremos um LED (ligado no GPIO18) e um buzzer (ligado ao GPIO24).
Assim, devemos importar os 3 dispositivos, como mostrado abaixo:
from gpiozero import MotionSensor, Buzzer, LED
import time
pir = MotionSensor(23)
bz = Buzzer(24)
led = LED(18)
print("Waiting for PIR to settle")
pir.wait_for_no_motion()
while True:
led.off()
print("Ready")
pir.wait_for_motion()
led.on()
print("Motion detected!")
bz.beep(0.5, 0.25, 8)
time.sleep(3)
Em baixo, mostro-lhe um pequeno filme mostrando o alarme a funcionar:
6: Como controlar um motor de passo com o Raspberry Pi (“Stepper Motor”)
Um motor de passo tem 4 bobinas que devem ser devidamente energizadas para faze-lo girar sobre o seu eixo. Noutras palavras, para rodar o motor passo-a-passo, deverá fornecer comandos com níveis “alto” e “baixo” para cada uma das 4 entradas numa dada sequência.
Ajustando a sequência correta de níveis altos e baixos, o eixo do motor rodará. A direção pode ser revertida simplesmente invertendo a sequência.
Vamos usar 4 GPIOs como saídas digitais para acionar o motor de passos.
O motor deve ser ligado à sua placa controladora (driver) utilizando o ligador que normalmente já traz de fabrica (conector branco de 5 pinos). A placa controladora tem 4 + 2 pinos que precisam ser ligados ao RPi:
Fonte (2 pinos laterais):
- (Pin 1) ==> 5V
- (Pin 2) ==> GND
Entradas digitais (4 pinos frontais):
- IN1 ==> GPIO12
- IN2 ==> GPIO16
- IN3 ==> GPIO20
- IN4 ==> GPIO21
O link abaixo vai-lhe dar mais detalhes sobre como trabalhar com um Stepper Motor utilizando um Raspberry Pi programado em Python:
Stepper Motor Control In Python
Com base no link acima, podemos recriar o código simplificando-o para o usar com a biblioteca GPIO Zero. Além disso, deverá decidir entre “velocidade” ou “torque”. Este é um compromisso que pode escolher dependendo da sequência de passos (4 ou 8 etapas).
Nesta caso criei uma variável “mode”, para que possa testar ambas sequências.
Poderá executar este programa tanto utilizando a aplicação Python 3 disponível no sistema operativo Raspbian ou diretamente no monitor usando uma linha de comando como esta:
“sudo Python StepMotorCtrl.py 2”
Onde o parâmetro “2” significa que o atraso ao mudar de passo será de 2ms. Se nenhum parâmetro for usado, o código assumirá 4ms (waitTime = 0.004).
import time import sys from gpiozero import OutputDevice as stepper IN1 = stepper(12) IN2 = stepper(16) IN3 = stepper(20) IN4 = stepper(21) stepPins = [IN1,IN2,IN3,IN4] # Motor GPIO pinsstepDir = -1 # Set to 1 for clockwise # Set to -1 for anti-clockwise mode = 1 # mode = 1: Low Speed ==> Higher Power # mode = 0: High Speed ==> Lower Power if mode: # Low Speed ==> High Power seq = [[1,0,0,1], # Define step sequence as shown in manufacturers datasheet [1,0,0,0], [1,1,0,0], [0,1,0,0], [0,1,1,0], [0,0,1,0], [0,0,1,1], [0,0,0,1]] else: # High Speed ==> Low Power seq = [[1,0,0,0], # Define step sequence as shown in manufacturers datasheet [0,1,0,0], [0,0,1,0], [0,0,0,1]] stepCount = len(seq) if len(sys.argv)>1: # Read wait time from command line waitTime = int(sys.argv[1])/float(1000) else: waitTime = 0.004 # 2 miliseconds was the maximun speed got on my tests stepCounter = 0 while True: # Start main loop for pin in range(0,4): xPin=stepPins[pin] # Get GPIO if seq[stepCounter][pin]!=0: xPin.on() else: xPin.off() stepCounter += stepDir if (stepCounter >= stepCount): stepCounter = 0 if (stepCounter < 0): stepCounter = stepCount+stepDir time.sleep(waitTime) # Wait before moving on
O vídeo abaixo mostra o programa a ser executado pelo monitor e com diferentes velocidades:
Gostaram deste artigo ? Deixem o vosso comentário no formulário a baixo.
Não se esqueçam de fazer like na nossa página no facebook.
Todos os produtos utilizados neste artigo podem ser encontrados na loja de componentes eletrónicos ElectroFun.