Brincando com eletrônica: Como utilizar a biblioteca “GPIO Zero” no Raspberry Pi

Uma maneira simples de aprender eletrônica é usando o Raspberry Pi e sua biblioteca “GPIO Zero”. Com poucas linhas de código em Python, você poderá facilmente controlar atuadores, ler sensores, etc. Esta biblioteca foi criada por Ben Nuttall da Raspberry Pi Foundation, Dave Jones entre outros.

Aqui, neste rápido tutorial procurarei fornecer-lhes 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

Você poderá também fazer o download grátis de um livro completo fornecido pela reveista MagPi, que irá guiar-lo passo a passo no desenvolvimento de vários projetos utilisando-se  da 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 a V2 quanto a V3 funcionam da mesma maneira)
  • Breadboard
  • Push-Button
  • LED
  • Resistor 330 ohms
  • Cabos para conexão (“jumpers”) do tipo “Dupont” (Fêmea/Macho and Macho/Macho)

2: Instalando a biblioteca “GPIO Zero”

A primeira coisa a fazer é atualizar sua lista de repositórios:

sudo apt-get update

Em seguida, instale o pacote de sua escolha. Tanto o Python 3 quanto o Python 2 são suportados. 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 seus GPIOs, em oposição à numeração física (BOARD). Qualquer pino marcado como GPIO”x”, onde “x” é seu número, no diagrama abaixo poderá ser utilizado. Por exemplo, se um LED foi anexado ao “GPIO18” você especificaria o número do pino como 18 em vez de 12, que é seu número físico.

3: “Hello World”: Piscando um LED

Agora, instalemos o LED, utilizando-se o pino físico 12 (GPIO18) conectado ao seu catodo (perna mais longa do LED ). Conecte agora o ânodo do LED ao GND do breadbord, utilizando-se um resistor de 330 ohms,  reduzindo-se assim  a corrente que será drenada do RPi,  como mostra a figura abaixo:

Uma vez que o HW esteja conectado, criemos um programa em Python para ligar o LED:

from gpiozero import LED
led = LED(18)
led.on()

Para criar e executar o programa, você poderá utilizar-se o aplicativo Python3 que aparece no menu do RPi ou utilizar qualquer editor de texto salvando o arquivo, por exemplo como “MyPgmName.py” e depois executar-lo o utilizando-se de uma linha de comando no monitor, por exemplo:

sudo Python MyPgmName.py

Como você pode ver, é muito simples de se criar um código em Python utilizando-se da biblioteca “GPIO Zero”.

Agora, vamos fazer o LED piscar  (o verdadeiro “Olá mundo” (“Hello World”), quando estamos falando de HW.

Para fazer isso, também precisaremos importar outra biblioteca que é a “time”. Vamos precisaremos dela para definir a quantidade de tempo em que o LED permanecerá ligado e/ou desligado. Em nosso caso, o LED piscará de 1 em 1 segundo (o argumento “time” da função sleep(time) está 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, você poderá reduzir o código, utilizando-se  da 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-se de um botão e a Biblioteca GPIO Zero fornece uma maneira fácil de incluir-lo em seu projeto. Você não precisa pensar em resistores pull-up ou pull-down, etc. Em termos de HW, a única coisa a fazer é conectar uma perna de seu botão a qualquer um dos RPI GPIOs e a outra ao terra (GND), como mostrado na figura acima:

  • 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 abaixo:

from gpiozero import Button
button = Button(2)
while True: 
    if button.is_pressed: 
        print("Button is pressed") 
    else:
        print("Button is not pressed")

Outra idéia podería ser adicionar um LED ao circuito, de maneira que o LED acenda quando o botão é pressionado e apague quando o mesmo é liberado.

Abaixo vemos como ficaría 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 nosso projeto em funcionamento:

 

Agora que você domina o básico, dê uma passeada pelo documento: GPIO Zero: Button, explorando outras ideias de como utilizar botões em seus projetos.

Step 5: Motion Detection

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 simples.

Como exploramos em meu último tutorial, IoT: Sensor de movimento com o NodeMCU e BLYNK, o sensor PIR gerará um pulso de nível ALTO a qualquer movimento que aconteça em seu raio de visão. Este módulo utiliza-se do sensor infravermelho passivo LHI778 e do CI BISS0001 para controlar como o movimento é detectado. O módulo possui sensibilidade ajustável que permite uma faixa de detecção de movimento de 3 a 7 metros. O módulo também inclui ajustes de atraso de tempo e seleção de gatilho que permitem um ajuste mais fino dentro de sua aplicação.

O dispositivo PIR tem uma pequena placa de circuito com três pinos: VCC, OUT e GND. VCC deve ser conectado a um pino de 5V do RPi, GND a um dos pinos de terra, e finalmente OUT a um dos GPIOs, em nosso caso: GPIO23.

Apesar que o PIR é alimentado com 5V, sua saída fornece um máximo de 3.3V, assim que é seguro conectá-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 (conectado no GPIO18) e um buzzer (conectado 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)

Abaixo um pequeno filme mostrando o alarme funcionando:

6: Controlando um motor de passo (“Stepper Motor”)

Usaremos 4 GPIOs como saídas digitais para acionar o motor de passos.

O motor deve ser ligado a placa controladora utilizando-se do conector especial instalado na mesma (conector branco de 5 pinos). A placa controladora tem 4 + 2 pinos que precisam ser conectados ao RPi:

Fonte (2 pinos laterais):

  • (Pin 1) ==> 5V
  • (Pin 2) ==> GND

e

Entradas digitais (4 pinos frontais):

  • IN1 ==> GPIO12
  • IN2 ==> GPIO16
  • IN3 ==> GPIO20
  • IN4 ==> GPIO21

O link abaixo lhe dará mais detalhes sobre como trabalhar com um Stepper Motor utilizando-se de um Raspberry Pi programado em Python:

Stepper Motor Control In Python

Com base no link acima, podemos recriar o código simplificando-o para usar-lo com a biblioteca GPIO Zero. Além disso, você deverá decidir entre “velocidade” ou “torque”. Este é um compromisso que você pode escolher dependendo da seqüência de passos (4 ou 8 etapas). Eu criei uma variável “mode”, para que você possa testar ambas seqüências.

Você poderá executar este programa tanto utilizando-se do aplicativo Python 3 disponível no sistema operacional Raspbian ou diretamente no monitor usando-se de uma linha de comando como mostrado abaixo:

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 pins</p><p>
stepDir = -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</p><p>stepCounter = 0</p><p>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</p><p>  time.sleep(waitTime)     # Wait before moving on

O vídeo abaixo mostra o programa sendo executado pelo monitor e com diferentes velocidades:

7: Conclusão

Como sempre, espero que este projeto ajude outras pessoas a encontrar seu caminho no apaixonante mundo da eletrônica!

Não deixe de visitar e seguir minha página: MJRoBot.org no Facebook

“Saludos desde el sur del mundo!”😉

Um abraço e até o próximo post!

Obrigado

Marcelo

O “Mars Rover” tupiniquim – Protótipo de uma estação móvel para captura de dados ambientais

Descrição geral:

A idéia deste projecto é o desenvolvimento de um protótipo totalmente funcional para uma estação móvel  usada na coleta de dados ambientais tais como: temperatura, umidade e luminosidade.  Este protótipo foi desenvolvido somente para fins didáticos e fez parte de meu projeto final no curso de especialização do Coursera em parceria com a University of California, Irvine:  “Uma Introdução à Programação da Internet of Things (IOT)“.

Considerações do projeto:
  • O Rover será controlado remotamente por um dispositivo Android com capacidade Bluetooth. Os dados serão continuamente capturados e transmitidos independentemente se o Rover está parado ou em movimento.
  • O usuário deve receber um feedback visual (streaming de vídeo ao vivo)
  • Os dados capturados serão analisados através de um site público (neste caso: thingspeak.com)
  • Os dados estarão disponíveis para os usuários em um formato gráfico e tabela
  • Alarmes via Twitter serão gerados localmente pela estação ou pelo website
  • O Rover terá capacidade autónoma para evitar obstáculos a fim de proteger-se em caso de mau controle por parte do usuário.
Opções de projeto:

Com base nos requisitos, inicialmente 2 opções foram consideradas para este projeto.

  1. Um único processador responsável por todas as tarefas, que neste caso deveria ser um Raspberry Pi.
  2. Um processador dual , sendo as funções divididos entre eles ( Arduino e RPI ) :
    • Processor 1: RPi
      • Captura de dados
      • Comunicação com a Web
      • Transmissão de vídeo
      • Envío de mensagens via mídia social
    • Processor 2: Arduino
      • Controle dos motores (movimento e posicionamento da câmera)
      • Evasão de obstáculos
      • Comunicação com o controle remoto

Em termos de custos, utilizar 2 processadores é de fato menos custoso do que a opção de um único processador. Isso ocorre porque o Arduino é um item muito barato e portanto mais acessível que a opção de “Servo Hat”, necessária para o RPi controlar os servos de maneira adequada. Outra diferença é o módulo de BT. Para o Arduino, um módulo barato como o HC – 06 BT 3.0 é suficiente, sendo que o mesmo custa a metade do preço do “BT Dongle” a ser adicionado ao Rpi.  Assim,a opção escolhida foi o projeto com processador dual.

diag Block complete

A Lista de materiais:

BoM

Instalação e testes da Camera (Pi-Cam) no RPi
  1. Instale PIP
    • sudo apt- get install python- pip
  2. Instalar a biblioteca picamera :
    • pip install picamera
  3. Instalar a biblioteca flask Python:
    • sudo pip install flask
  4. Baixar projeto de streaming de vídeo Flask:
  5. Na pasta do projeto editar o arquivo app.py , comente esta linha:
    • #from camera import Camera
  6.  Tirar o comentario da linha:
    • from camera_pi import Camera
  7. Salve o arquivo app.py
  8. Executar ifconfig para descobrir o endereço IP local do seu Raspberry Pi “yourLocalIPaddress ” .
  9. Inicie o servidor Flask executando este comando :
    • python app.py 
  10. Uma mensagem será impressa no monitor:
  11. Abra um navegador e acesse este endereço :
    • ” YourLocalIPaddress ” : 5000
Instalando o sensor de temperatura e humidade: HC-11

DH11-RPiDH11-RPi hw

  1. Em primeiro lugar, obter a Biblioteca do Github :
  2. Instalação da Biblioteca :
    • sudo apt-get update
    • sudo apt- get install build-essential python -dev python- openssl
    • cd / Home / Pi / Adafruit_Python_DHT
    • sudo python setup.py install
  3. Teste o sensor, executando o programa: AdafruitDHT.py no monitor. Entre os parâmetros como : 11 ( sensor DHT11 ) e 4 ( GPIO onde o sensor está ligado )
    • sudo Python AdafruitDHT.py 11 4
  4. O resultado deve ser a temperatura ea humidade lido pelo sensor

DH11-RPi monitor

Enviando dados para a internet

Para a configuração básica do sensor DH- 11 com a RPI e envio dos dados à internet , uma grande ajuda foi começar a partir deste tutorial:

Plotting DHT11 sensor data at ThingSpeak.com using Raspberry Pi

Passos:

  • A definição de um canal em ThingSpeak.com :

ThinkSpeak1

  • Execução do códigoPython para testes:
    • sudo Python temp_hum_test.py
    • NOTA: Todos os códigos fonte estão disponíveis ao final do post.

ThinkSpeak2

ThinkSpeak3

Adicionando o sensor de luz:

Um tutorial muito bom que serviu de base para esta parte do projeto, pode ser visto aqui:

Continue Lendo “O “Mars Rover” tupiniquim – Protótipo de uma estação móvel para captura de dados ambientais”