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 poderia 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 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 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

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

Anúncios

IoT: Sensor de movimento com o NodeMCU e BLYNK

 

Step 1: Principais componentes

  • Resistor (1K, 2.2K and 330ohm)
  • LED
  • Breadboard
  • Cables

Step 2: O HC-SR501 “Passive Infrared (PIR) Motion Sensor”

Este módulo de sensor de movimento utiliza-se do sensor passivo de sinal infravermelho  LHI778 e o do circuito integrado BISS0001 para controlar como o “movimento deve ser 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 ajustes finos dentro de sua aplicação.

fkscpzbivo85exc-large

f19wasdivo85ey1-large

 

O link abaixo nos fornece mais detalhes do funcionamanto do sensor:

Arduino HC-SR501 Motion Sensor Tutorial

Step 3: O HW

O HW é muito simples. O sensor tem 3 pinos (+Power, GND e Saída).

É importante lembrar que a saída do HC-SR501 gera um sinal lógico de + 3.3V (ALTO) ou 0V (LOW), o qual É COMPATÍVEL com os níveis de entrada do NodeMCU, que também funciona com o nível 3.3V. Eu mantive a circuito com um conversor de nível para garantir caso seja utilizado algum outro sensor  com saída 5V. 

Assim, você precisará de um divisor de tensão para converter os níveis de sinal (veja o diagrama elétrico acima).

  • Saída do HC-SR501 ==> para a entrada do divisor de tensão
  • NodeMCU Pin D1 (GPIO 5) ==> para o ponto médio do Divisor de Tensão

Também incluíremos um LED no pino D7 (GPIO13), para uma visualização local.

Step 4: Testando o sensor

Primeiramente faremos um programinha simples para testar e calibrar o sensor.

Carregue o código abaixo no Arduino IDE:

/* HC-SR501 Motion Detector */
#define ledPin D7 // Red LED
#define pirPin D1 // Input for HC-SR501

int pirValue; // variable to store read PIR Value

void setup() 
{
  pinMode(ledPin, OUTPUT);
  pinMode(pirPin, INPUT);
  digitalWrite(ledPin, LOW);
}

void loop() 
{
  pirValue = digitalRead(pirPin);
  digitalWrite(ledPin, pirValue);
}

Ao fazer um movimento na frente do sensor, você verá o LED vermelho acender. Você poderá usar o código acima para ajustes no sensor, se necessário.

Se você não sabe como preparar o IDE do arduino para trabalhar com o NodeMCU, por favor de uma olhadinha em meu tutorial:

Do “blink” ao BLYNK, uma viagem pela “Internet das coisas” nas asas do NodeMCU ESP-12E

Step 5: Incluindo o BLYNK

Siga os Passos abaixo::

  • Crie um  New Project.
  • Defina um nome para o projeto (em meu caso: “Motion Detector“)

  • Selecione NodeMCU como HW Model
  • Copie o  AUTH TOKEN para ser adicionado ao seu código do IDE (o melhor é enviar-lo para seu email).
  • Inclua o “Widget”:  Push Notification.

  • Pressione “Play” (o triangulo no canto superior direito)

fyieb1nivo85k5p-large

Naturalmante o appicativo Blynk nesse ponto irá informar que o NodeMCU está off-line. antes de rodar o aplicativo Blynk, o codigo deve ser carregado e iniciado no módulo NodeMCU. Abaixo o código a ser ingressado no Arduino IDE:

/**************************************************************
 * IoT Motion Detector with Blynk
 * Blynk library is licensed under MIT license
 * This example code is in public domain.
 * 
 * Developed by Marcelo Rovai - 30 November 2016
 **************************************************************/
#include <ESP8266WiFi.h>

#define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
#include <BlynkSimpleEsp8266.h>
char auth[] = "YOUR AUTH CODE HERE";

/* WiFi credentials */
char ssid[] = "YOUR SSID";
char pass[] = "YOUR PASSWORD";

/* HC-SR501 Motion Detector */
#define ledPin D7 
#define pirPin D1 // Input for HC-S501
int pirValue; // Place to store read PIR Value

void setup()
{
  Serial.begin(115200);
  delay(10);
  Blynk.begin(auth, ssid, pass);
  pinMode(ledPin, OUTPUT);
  pinMode(pirPin, INPUT);
  digitalWrite(ledPin, LOW);
}

void loop()
{
  getPirValue();
  Blynk.run();
}

/***************************************************
 * Get PIR data
 **************************************************/
void getPirValue(void)
{
  pirValue = digitalRead(pirPin);
  if (pirValue) 
  { 
    Serial.println("==> Motion detected");
    Blynk.notify("T==> Motion detected");  
  }
  digitalWrite(ledPin, pirValue);
}

Assim que o código é carregado e executado, verifique a aplicação BLYNK, a qual também deverá estar funcionando.

Faça um movimento na frente do sensor, você deverá receber uma mensagem em seu celular como a mostrada abaixo:

Abaixo o código completo para ser executado no Arduino IDE (não se esqueça de entrar com seus dados):

Observação sobre o código:

Vale a pena comentar que os testes para este projeto foram executados somente em laboratório. Para projetos envolvendo sistemas caseiros de alarmes o código funcionaria sem problemas, mas se o sensor perceber muitas variações de movimento ao mesmo tempo, poderíamos chegar a ter problemas. Neste caso, uma solução envolvendo “SimpleTimer” seria o aconselhável.

O ideal quando se desenvolve projetos com o Blink é manter-se na função void loop() somente a função Blynk.run(), movendo-se a getPirValue() para dentro de uma função de timer, por exemplo: timer.setInterval(1000L, getPirValue);

 

Step 6: Conclusão

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

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

LaserCat – IoT com NodeMCU e Blynk

Exploraremos como controlar servos via internet, utilizando-se o NodeMCU ESP12-E e o Blynk.

Este é um projeto muito simples, onde a idéia principal é explorar como controlar servos via internet. Para isso, usaremos uma grande dupla de componentes, o NodeMCU ESP12-E e um aplicativo Blynk.
O projeto foi baseado em um grande tutorial: Smartphone Controlled Cat Laser, desenvolvido usando-se um Arduino Uno conectado a um PC via Serial. Aqui porém, usaremos o NodeMCU, em um formato mais “portátil” utilizando-se WiFi e bateria.

IMPORTANTE: O apontador laser pode ser perigoso se apontado diretamente para os olhos. Proteja os seus olhos, o de animais e outras pessoas. Use com cuidado.

Abaixo, você poderá ver minha gatinha Cleo brincando com o laser:

Step 1: Os componentes principais:

Step 2: O mecanismo “Pan/Tilt” de posicionamento

Vamos construir um mecanismo de “Pan / Tilt” muito simples, montando os servos “um em cima do outro” como mostrado nas fotos abaixo:

  • O “Pan” Servo  é usado “como base”. Mantenha-o na vertical.

  • Fixe o “Tilt” Servo sobre a parte de movimento do “Pan” Servo  (na posição horizontal)
  • Fixe o ponteiro laser na parte movel do “Tilt” Servo como mostrado.

Note que usei algumas peças metálicas, aproveitadas de um brinquedo desmontado, como estrutura de base para o mecanismo “Pan / Tilt”. Você poderá utilizar outros tipos de estrutura, O importante é manter os movimentos horizontal e vertical.

Step 3: O HW

O circuito elétrico é bem simples:

Antes de iniciar as conexões, leve em consideração que apesar do nodeMCU ser alimentado com 5V, ele funciona internamente com 3.3V (assim como seus pinos de I/O). Assim, os Servos não poderão ser alimentados a partir de uma das 3 saídas de 3.3V do NodeMCU. A exceção é o pino “Vin”, que pode tanto fornecer 5V para o breadboard “+ VCC rail”quanto alimentar o NodeMCU quando uma fonte externa é utilizada (como mostrado no diagrama elétrico abaixo).

O módulo laser deve ser alimentado com 5V, porém ele também funciona com 3.3V o  que faz com que a potência do laser seja menor e consequentemente, seu uso mais seguro.

IMPORTANTE: O apontador laser pode ser perigoso se apontado diretamente para os olhos. Proteja os seus olhos, o de animais e outras pessoas. Use com cuidado.

Observando atentamente o diagrama elétrico acima, execute as seguintes ligações:

  • Ligue o cabo de dados do servo Pan (eixo X) ao NodeMCU Pin D1 (note que todos os pinos digitais do NodeMCU são PWM)
  • Ligue os dados do servo Tilt (eixo “Y”) ao NodeMCU Pin D2
  • Ligue o pino “S” do ponteiro laser ao NodeMCU Pin D3
  • Ligue o pino “Vin” de NodeMCU ao “+ 5V Rail” do Breadboard
  • Conecte os pinos GND (comum ou terra) do NodeMCU, Servos e Ponteiro Laser ao “GND Rail” do Breadboard
  • Conecte os cabos de alimentação dos Servos ao  “+ 5V Rail” do Breadboard

 

Step 4: O codigo

Para o controle dos servos, usaremos a biblioteca do IDE: Servo.h, a qual gerará sinais PWM posicionando-os facilmente com entradas angulares.

Uma vez que a base do projeto é usar o aplicativo BLYNK, o código torna-se muito simples. Devemos definir 4 variáveis virtuais:

V0: “X position”

V1: “Y position”

V2: “Random or manual” operation

V3: Laser ON/OFF command

BLYNK_WRITE(V0) 
{
  xPotReading = param.asInt();
}
BLYNK_WRITE(V1) 
{
  yPotReading = param.asInt();
}
BLYNK_WRITE(V2) 
{
  randState = param.asInt();
}
BLYNK_WRITE(V4) 
{
  laserState = param.asInt();
}

Se você não sabe como preparar o IDE do Arduino para trabalhar com o NodeMCU, por favor de uma olhadinha em meu tutorial:

Do “blink” ao BLYNK, uma viagem pela “Internet das coisas” nas asas do NodeMCU ESP-12E

Abaixo, o código completo. de uma passada de olhos nele. É muito fácil de entender.

Step 5: O “Blynk”

Step 6: Conclusão

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

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

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

“Saludos desde el sur del mundo!” 😉

Obrigado

Marcelo