IoT Raspberry Pi Smart Container com Alerta de Email e Monitoramento da Web

Publicado em por
Tempo de leitura: 7 minutes

Você já deve ter ouvido falar do Smart Refrigerator, que pode solicitar automaticamente os itens alimentícios que estão acabando na geladeira, então, inspirador, estamos construindo um Raspberry Pi Smart Container usando a célula de carga e o sensor de peso HX711. Este Smart Container pode informá-lo sobre seu status, como se ele está cheio ou vazio, enviando um e-mail para seu ID de e-mail. Também podemos monitorar o peso do contêiner em tempo real usando o navegador da web, e isso o torna um projeto de IoT onde você pode monitorar seu contêiner de qualquer lugar usando a Internet. Aqui o peso do container será atualizado a cada 5 segundos no navegador da web, esta duração pode ser facilmente alterada em arquivo de código HTML. Definimos o valor de peso limite de 300 gramas para enviar o e-mail sobre o “Container is Full”, este limite também pode ser alterado.

Componentes necessários:

Aqui, estamos usando o Raspberry Pi 3 Raspbian Jessie OS. Todos os requisitos básicos de hardware e software foram discutidos anteriormente. Você pode consultá-los na introdução do Raspberry Pi e no LED Raspberry PI piscando para começar, exceto pelo que precisamos:

  • Raspberry Pi (qualquer modelo deve funcionar)
  • Célula de carga
  • Módulo amplificador de célula de carga HX711
  • LCD 16×2
  • Fonte de energia ou banco de energia
  • Fios de conexão
  • ProtoBoard
  • Parafusos de porca, estrutura e base

Aqui anexamos uma base de madeira com a célula de carga para estabilidade, com a ajuda de porcas e parafusos, conforme mostrado abaixo

Configuração de e-mail no Raspberry Pi para enviar e-mails de alerta:

Para enviar a correspondência do Raspberry Pi, que contém o status de Container (Cheio ou Vazio), é necessário instalar um software. Aqui estamos usando ssmtp, que é uma solução fácil e boa para enviar e-mail usando linha de comando ou usando Python Script. Precisamos instalar duas bibliotecas para enviar e-mails usando SMTP:

​sudo apt-get install ssmtp
sudo apt-get install mailutils​

Após instalar as bibliotecas, o usuário precisa abrir o arquivo ssmtp.conf e editar este arquivo de configuração conforme mostrado na imagem abaixo e, em seguida, salvar o arquivo. Para salvar e sair do arquivo, pressione ‘CTRL + x’, depois ‘y’ e depois pressione ‘enter’.

sudo nano /etc/ssmtp/ssmtp.conf
root=SeuEnderecoDeEmail
mailhub=smtp.gmail.com:587
hostname=raspberrypi
AuthUser=SeuEmailEndereco
AuthPass=SeuEmailSenha
FromLineOverride=YES
UseSTARTTLS=YES
UseTLS=YES

Também podemos testá-lo enviando um e-mail de teste, emitindo o comando abaixo, você receberá o e-mail no endereço de e-mail mencionado se tudo estiver funcionando bem:

echo "Oi capsistema" | mail -s "Testando..." capsistema@gmail.com

Abaixo está o instantâneo dos e-mails de alerta que obtivemos durante nossos testes.

 

Configuração do frasco no Raspberry Pi:

Aqui, criamos um servidor web, que fornece uma maneira de enviar o valor do peso do contêiner do Raspberry Pi para a rede usando o Flask em um navegador da web. O Flask nos permite executar nossos scripts python por meio de uma página da web e podemos enviar e receber dados do Raspberry Pi para o navegador da web e vice-versa. Flask é um microframework para Python. Esta ferramenta é baseada em Unicode com servidor de desenvolvimento e depurador embutidos, suporte para teste de unidade integrado, suporte para cookies seguros e é fácil de usar, o que a torna útil para o amador.

Instale um pacote de suporte de frasco no Raspberry Pi usando o comando fornecido:

$ pip install Flask

Então podemos usar o Flask apenas importando-o em nosso programa, como importamos os seguintes pacotes de flask para este projeto:

from flask import Flask, render_template, request, jsonify

Código HTML para página da web:

<head>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.1.1/jquery.min.js"></script>
</head>
<div><center>
<h1><span style="color:#5C5C5C;">CapSistema</span></h1>
<h2>Recipiente inteligente usando Raspberry Pi e sensor de peso</h2>
<h3>Peso do contêiner: <span id="result" style="color:#C33; font-size:28px">302</span> gramas/h3>
<span>(Atualizando a cada 5 segundos)</span>

<div id="alert" style="color:#F00; font-size:20px; "><br><br><b>Alerta!!!<br>O recipiente está cheio<br>Email Enviado.</b></div>

</center></div>

<script>
setInterval(
  function()
  {
    $.getJSON('/show_weight',function(data) {                                                
      $("#result").text(data.result);
        if( data.result > 300 ) {
           $("#alert").show();
        }
        else {
           $("#alert").hide();
        }
     });     
  },
5000);
</script>

O usuário precisa copiar e colar o código HTML fornecido acima em algum editor de texto (bloco de notas) e salvar o arquivo com a extensão .HTML (web.html). Em seguida, coloque esse arquivo HTML na pasta/templates em relação ao local do seu script Python. Significa que você precisa criar uma pasta chamada templates, onde você colocou seu arquivo de código Python para este contêiner Raspberry Pi Smart e, em seguida, colocou o arquivo web.html nesta pasta de templates. Esta etapa é importante, caso contrário, nosso projeto não funcionará. Você pode abrir diretamente o arquivo web.html clicando duas vezes nele para obter a saída do código HTML e você verá a página da web conforme mostrado abaixo. Depois de terminar a programação e tudo mais, podemos apenas executar o código Python no Raspberry Pi e abrir o IP_address_of_your_Pi: 5010 no navegador da web (como http://192.168.1.100:5010)

Você pode verificar o endereço IP do seu Raspberry Pi usando o comando ifconfig:

ifconfig

 

Explicação do circuito:

As conexões para este IoT Smart Container são fáceis e o esquema é fornecido abaixo. 16×2 LCD pinos RS, EN, d4, d5, d6 e d7 são conectados com GPIO pino número 18, 23, 24, 25, 8 e 7 de Raspberry Pi respectivamente e os pinos DT e SCK do Módulo HX711 estão diretamente conectados com GPIO de Raspberry Pi pinos 27 e 17.

 

Explicação de trabalho:

Trabalhar com este Smart Container é fácil. Neste projeto, usamos Raspberry Pi 3 para controlar todo o processo. A célula de carga detecta o peso do contêiner e fornece uma tensão elétrica analógica ao módulo amplificador de carga HX711. O HX711 é um ADC de 24 bits, que amplifica e converte a saída da célula de carga em formato digital. Em seguida, esse valor amplificado é alimentado para o Raspberry Pi. Agora, o Raspberry Pi calcula a saída de HX711 e a converte no valor do peso.

Em seguida, esse valor de peso é comparado com o valor limite predefinido (300 gramas) usando o código Raspberry Pi e Python, se o peso do contêiner ultrapassar 300gm, o Raspberry Pi enviará um e-mail informando que “Alerta de contêiner inteligente …. Recipiente cheio”. E se o peso permanecer abaixo de 300g, o Raspberry Pi enviará um e-mail informando “Alerta do recipiente inteligente …. O recipiente está vazio”.

O peso também pode ser monitorado usando o navegador da web, você só precisa abrir seu endereço IP do Raspberry Pi com a porta 5010 como http://192.168.1.100:5010 (substitua o endereço IP pelo seu endereço). Aqui, usamos o Flask para enviar os dados do Raspberry Pi para a página da web pela rede. Esta página será atualizada automaticamente a cada 5 segundos e obteremos dados atualizados, para isso usamos o jQuery conforme explicado anteriormente.

Um LCD 16×2 opcional também foi usado para exibir as mensagens de peso e status.

O código Python completo é fornecido abaixo, onde escrevemos funções para conduzir o LCD, para ler o valor do peso da célula de carga, para exibir dados na página da web, etc.

import RPi.GPIO as gpio
import serial
import time
import random
from flask import Flask, render_template, request, jsonify

import smtplib

RS =18
EN =23
D4 =24
D5 =25
D6 =8
D7 =7

DT =27
SCK=17
led=22
buz=5

m1=19
m2=26

HIGH=1
LOW=0

sample=0
val=0

flag=0

gpio.setwarnings(False)
gpio.setmode(gpio.BCM)
gpio.setup(RS, gpio.OUT)
gpio.setup(EN, gpio.OUT)
gpio.setup(D4, gpio.OUT)
gpio.setup(D5, gpio.OUT)
gpio.setup(D6, gpio.OUT)
gpio.setup(D7, gpio.OUT)
gpio.setup(led, gpio.OUT)
gpio.setup(buz, gpio.OUT)
gpio.setup(m1, gpio.OUT)
gpio.setup(m2, gpio.OUT)
gpio.setup(SCK, gpio.OUT)
gpio.output(led , 0)
gpio.output(buz , 0)
gpio.output(m1 , 0)
gpio.output(m2 , 0)

app = Flask(__name__)
a=1
@app.route("/")
def index():
 return render_template('web.html')
  
@app.route('/show_weight')
def show_weight():
    count= readCount()
    w=0
    w=(count-sample)/106
    print w,"g"
    setCursor(0,0)
    data=str(w);
    lcdprint(data)
    lcdprint("g   ")
    global flag
    if w>300:
      if flag == 0:
        lcdclear()
        lcdprint("O contêiner está cheio")
        setCursor(0,1);
        lcdprint("Enviando email")
        server = smtplib.SMTP('smtp.gmail.com', 587)
        server.starttls()
        server.login("capsistema@gmail.com", "password")
        msg = "Alerta de contêiner inteligente ... Recipiente cheio"
        server.sendmail("capsistema@gmail.com", "capsistema@gmail.com", msg)
        server.quit()
        lcdclear()
        lcdprint("Email Enviado")
        flag=1;
        lcdclear()
    elif w<300:
      if flag==1:
        lcdclear()
        lcdprint("Container Vazio")
        setCursor(0,1);
        lcdprint("Enviando email")
        server = smtplib.SMTP('smtp.gmail.com', 587)
        server.starttls()
        server.login("capsistema@gmail.com", "Password")
        msg = "Alerta de recipiente inteligente .... O recipiente está vazio"
        server.sendmail("capsistema@gmail.com", "capsistema@gmail.com", msg)
        server.quit()
        lcdclear()
        lcdprint("Email Enviado")
        flag=0;
        lcdclear()

    return jsonify(result=w)

def begin():
  lcdcmd(0x33) 
  lcdcmd(0x32) 
  lcdcmd(0x06)
  lcdcmd(0x0C) 
  lcdcmd(0x28) 
  lcdcmd(0x01) 
  time.sleep(0.0005)
 
def lcdcmd(ch): 
  gpio.output(RS, 0)
  gpio.output(D4, 0)
  gpio.output(D5, 0)
  gpio.output(D6, 0)
  gpio.output(D7, 0)
  if ch&0x10==0x10:
    gpio.output(D4, 1)
  if ch&0x20==0x20:
    gpio.output(D5, 1)
  if ch&0x40==0x40:
    gpio.output(D6, 1)
  if ch&0x80==0x80:
    gpio.output(D7, 1)
  gpio.output(EN, 1)
  time.sleep(0.005)
  gpio.output(EN, 0)

  # Bits baixos
  gpio.output(D4, 0)
  gpio.output(D5, 0)
  gpio.output(D6, 0)
  gpio.output(D7, 0)
  if ch&0x01==0x01:
    gpio.output(D4, 1)
  if ch&0x02==0x02:
    gpio.output(D5, 1)
  if ch&0x04==0x04:
    gpio.output(D6, 1)
  if ch&0x08==0x08:
    gpio.output(D7, 1)
  gpio.output(EN, 1)
  time.sleep(0.005)
  gpio.output(EN, 0)
  
def lcdwrite(ch): 
  gpio.output(RS, 1)
  gpio.output(D4, 0)
  gpio.output(D5, 0)
  gpio.output(D6, 0)
  gpio.output(D7, 0)
  if ch&0x10==0x10:
    gpio.output(D4, 1)
  if ch&0x20==0x20:
    gpio.output(D5, 1)
  if ch&0x40==0x40:
    gpio.output(D6, 1)
  if ch&0x80==0x80:
    gpio.output(D7, 1)
  gpio.output(EN, 1)
  time.sleep(0.005)
  gpio.output(EN, 0)

  # Bits baixos
  gpio.output(D4, 0)
  gpio.output(D5, 0)
  gpio.output(D6, 0)
  gpio.output(D7, 0)
  if ch&0x01==0x01:
    gpio.output(D4, 1)
  if ch&0x02==0x02:
    gpio.output(D5, 1)
  if ch&0x04==0x04:
    gpio.output(D6, 1)
  if ch&0x08==0x08:
    gpio.output(D7, 1)
  gpio.output(EN, 1)
  time.sleep(0.005)
  gpio.output(EN, 0)

def lcdclear():
  lcdcmd(0x01)
 
def lcdprint(Str):
  l=0;
  l=len(Str)
  for i in range(l):
    lcdwrite(ord(Str[i]))
    
def setCursor(x,y):
    if y == 0:
        n=128+x
    elif y == 1:
        n=192+x
    lcdcmd(n)

def readCount():
  i=0
  Count=0
 # print Count
 # time.sleep(0.001)
  gpio.setup(DT, gpio.OUT)
  gpio.output(DT,1)
  gpio.output(SCK,0)
  gpio.setup(DT, gpio.IN)

  while gpio.input(DT) == 1:
      i=0
  for i in range(24):
        gpio.output(SCK,1)
        Count=Count<<1

        gpio.output(SCK,0)
        #time.sleep(0.001)
        if gpio.input(DT) == 0: 
            Count=Count+1
            #print Count
        
  gpio.output(SCK,1)
  Count=Count^0x800000
  #time.sleep(0.001)
  gpio.output(SCK,0)
  return Count 

print "Olá"
begin()
lcdcmd(0x01)
lcdprint("Recipiente inteligente   ")
lcdcmd(0xc0)
lcdprint("    usando RPI     ")
time.sleep(3)
lcdcmd(0x01)
lcdprint("CapSistema")
lcdcmd(0xc0)
lcdprint("Te dá boas vindas")
time.sleep(3)
sample= readCount()
lcdclear()
while 1:
  print "Começar"  
  if __name__ == "__main__":
   app.run(host='0.0.0.0',port=5010)

 

Twittar
Compartilhar
Compartilhar
0 Compart.