Túnel de Desinfecção Inteligente: Sanitização Automatizada para Áreas de Alto Tráfego

Componentes e Materiais

Componente	Quantidade
Arduino UNO	1
Fios Jumper (genéricos)	1
Sensor de Movimento PIR (genérico)	2
Relé de Potência 12V (4PDT)	1
Fonte Chaveada 12 Volts (SMPS)	1
Relé SPDT 2 Canais Seeed Grove	1
Fonte Chaveada 5 Volts (SMPS)	1
Chave Seletora, (On)-Off-(On)	1
Raspberry Pi 3 Model B	1
Módulo Câmera Raspberry Pi V2	1
Cartão Micro SD	1
Cabo Micro-USB para USB (Genérico)	1
Dissipador de Calor	1
Bomba d'Água 1 HP	1
Tubo de Aço Caixa	1
Tanque de Água (200 L)	1
Tubo PVC	1
Nebulizador 4 Vias (4-Way Fogger)	1
Banner Flex	1
Conexão em T (Tee Joint)	1
Micro Tubo	1
Lâmpada de Fixação na Parede	1
Cotovelo (Elbow)	1
Abraçadeira de Cabo, Dupla Face	1

Ferramentas e Máquinas Necessárias

Máquina de Solda
Máquina de Corte
Ferro de Solda (genérico)
Fio de Solda, Livre de Chumbo
Cortadora a Laser (genérica)

Aplicativos e Serviços Online

Arduino IDE
Raspberry Pi Raspbian
OpenCV

Sobre o Projeto

Introdução

O Túnel Inteligente de Desinfecção e Sanitização é uma demonstração de como foi projetado para fornecer proteção máxima às pessoas que passam pelo túnel em cerca de 15 segundos. O que pode ajudar a comunidade a combater o COVID-19.

A ideia principal deste projeto é criar um túnel que possa tentar prevenir a propagação do COVID-19.

Este túnel de desinfecção e sanitização foi preparado para higienizar pessoas em 15 segundos de quaisquer bactérias possíveis.

A solução desinfetante usada consiste em uma combinação de hipoclorito de sódio (NaOCl) e água (H2O). O desinfetante não é volátil, permitindo atividade viricida e bactericida prolongada e higienizando as superfícies.

Então, tomei a iniciativa de fazer este Túnel Inteligente de Desinfecção e Sanitização. Este túnel foi feito em um período de 12 horas. Pode desinfetar uma pessoa completamente da cabeça aos pés em apenas 15 segundos e a solução usada é completamente inofensiva*. O custo total do túnel é aproximadamente ₹30.000 ou $400. (Custo revisado)

Túnel de Desinfecção Inteligente: Sanitização Automatizada para Áreas de Alto Tráfego

Onde Usar?

Mercados de alimentos
Escritórios
Shoppings
Aeroportos
Paradas de ônibus
Estações ferroviárias
Delegacias
Faculdades
Hospitais
Condomínios

Como Funciona

Uma máquina de Bomba d'Água 1HP é colocada ao lado de cada túnel, que pega a solução de 0.4% de hipoclorito de sódio em 100 Litros de água do tanque. Como a máquina é automática, ela detecta se alguém está entrando no túnel. Quando alguém entra no túnel, a Bomba d'Água é ligada por 15 segundos. Para que o usuário possa passar pelo túnel e, se não houver ninguém no túnel, a bomba será desligada para economizar água e eletricidade. O spray desinfetante nebulizado protege os cidadãos de pegar bactérias por um período de pelo menos 60 minutos (Aprox*). Pois desinfeta o ar, a pele exposta e a roupa humana.

Um tanque plástico para 200 litros de solução e uma bomba para o sistema de tubulação de alta pressão está localizado ao lado do túnel. Conforme cálculo, a solução deve ser suficiente para 8-10 horas. Como tem um sensor de movimento acima da entrada para economizar antisséptico. (Pode variar de acordo com as pessoas entrando no túnel**)

Diagrama de Fluxo

Configuração do Hardware

Montei a estrutura com perfil metálico, dobrável para que pudesse ser transportado de lugar para lugar, e quando tudo acabar, guardado para o próximo apocalipse. A cobertura é pelo banner (usado para publicidade externa em outdoors). O banner é fácil de prender ao perfil metálico com abraçadeiras plásticas. É rápido e não requer habilidades especiais.

Confira o modelo - https://skfb.ly/6RGvZ

Um tanque plástico para 200 litros de solução e uma bomba para o sistema de tubulação de alta pressão está localizado ao lado do túnel, conectado com a Montagem do Nebulizador 4 Vias.

Micro tubos foram usados em todo o túnel para fornecer a solução ao nebulizador.

Dentro, há uma tubulação de alta pressão com 4 Nebulizadores 4 Vias que podem ser conectados. A névoa não deixa marcas nas roupas, enquanto envolve completamente a pessoa que entra e destrói o vírus mesmo em dobras de difícil acesso da roupa e protege por algum tempo após a saída.

Como solução, uma solução certificada é usada neste projeto. (Certificado anexado abaixo)

Especificações do Nebulizador 4 Vias

Taxa de Descarga: 30 LPH/0.5 LPM (para 1 nebulizador)
Pressão Recomendada: 45-60 psi
Tamanho Médio de Gotícula: 65 mícrons (a 55-60 psi)
Filtração Necessária: 130 Mícron (malha 120)
Bomba necessária: 40 a 45 metros de coluna d'água

Outros Acessórios Usados

Prepare o Arduino

A bomba d'água funciona detectando raios infravermelhos. Sempre que o corpo humano se aproxima de um sensor de movimento, o corpo humano reflete raios infravermelhos, o sensor de movimento detecta estes raios infravermelhos e nos dá um sinal HIGH através do pino de saída. Este sinal HIGH é então lido pelo Arduino. Então, se o Arduino lê um sinal HIGH, ele dará um sinal HIGH para o módulo relé, o que significa que o relé ligará, e como resultado o Relé de Potência ligará e ligará a Bomba d'Água por 15 segundos (Pode ser alterado). Similarmente, se o Arduino lê um sinal LOW, ele tornará o pino do relé LOW e como resultado a Bomba d'Água permanecerá desligada.

Neste projeto, usei 2 sensores PIR para torná-lo mais preciso: se qualquer um deles detectar movimento, o relé ligará por 15 segundos (Pode ser alterado).

Não podemos usar Relé 5V diretamente com a Bomba d'Água porque, no meu caso, a bomba d'água que usei neste projeto tem uma classificação de Ampere(A) de 16 Ampere e o Relé 5V tem carga máxima de 10 Ampere, então para controlar a bomba d'água usei mais um relé com o Módulo Relé 5V, que é o Relé de Potência 12V.

Código do Arduino:

/*
 * Túnel Inteligente de Desinfecção e Sanitização
 */

int relayPin = 12; // escolhe o pino para o Pino do Relé

int inputPin = 2; // escolhe o pino de entrada (para sensor PIR)
int inputPin2 = 3; // escolhe o pino de entrada (para sensor PIR 02)

int pirState = LOW; // no início, assumindo nenhum movimento detectado
int val = 0; // variável para ler o status do pino
int val2 = 0; // variável para ler o status do pino

void setup() {
  pinMode(relayPin, OUTPUT); // declara Relé como saída
  pinMode(inputPin, INPUT);  // declara sensor como entrada
  pinMode(inputPin2, INPUT); 
  Serial.begin(9600);
}

void loop(){
  val = digitalRead(inputPin);  // lê valor de entrada
  val2 = digitalRead(inputPin2); // lê valor de entrada
  if (val == HIGH || val2 == HIGH) { // verifica se a entrada é HIGH
    digitalWrite(relayPin, HIGH); // liga Relé
    if (pirState == LOW) {
      // acabou de ligar
      Serial.println("Movimento detectado!");
      // delay de 15 seg
      delay(15000);
      pirState = HIGH;
    }
  } else {
    digitalWrite(relayPin, 0); // desliga Relé
    if (pirState == HIGH){
      // acabou de desligar
      Serial.println("Movimento encerrado!");
      pirState = LOW;
    }
  }
}

A fiação final do projeto parece um pouco bagunçada, mas funcionou perfeitamente.

Depois que tudo foi conectado, apenas testei com detecção básica e depois verifiquei se o relé estava disparando.

Prepare o Raspberry Pi 3 (Opcional)

Esta parte é opcional. Caso você precise fazer alguma análise dos dados e contar precisamente o número de pessoas usando este túnel. Você pode implementar esta parte.

Embora existam muitas maneiras de contar isso com sensores físicos como Sensor PIR e Sensor Ultrassônico, achei esta mais precisa ao considerar todos os cenários.

Existe um modelo de machine learning que detecta o corpo humano usando OpenCV em Python e armazena o log no arquivo que pode ser processado para mostrar os dados no app.

Conecte a Câmera Pi

Desligue o Raspberry Pi
Localize o Módulo da Câmera, entre o Módulo USB e HDMI.
Destrave o clipe plástico preto puxando suavemente para cima
Insira o cabo flat do Módulo da Câmera (conectores metálicos voltados para longe das portas Ethernet/USB no Raspberry Pi 4)
Trave o clipe plástico preto

Ative a Câmera Pi

Execute sudo raspi-config
Selecione Interfacing Options (4ª opção) no menu principal da Ferramenta de Configuração de Software do Raspberry Pi. Pressione ENTER.

Selecione a opção de menu Enable Camera (5ª opção) e pressione ENTER.

No próximo menu, use a tecla de seta direita para destacar ENABLE e pressione ENTER.

Teste a Câmera Pi

Em seguida, verifique se a Câmera Pi está instalada corretamente iniciando a sobreposição de visualização da câmera. A sobreposição será renderizada na tela.

Conecte ao Raspberry Pi usando VNC Viewer.
Execute o seguinte comando:

raspistill -v -o test.jpg

Se você instalou a Câmera Pi corretamente, deve ver imagens da câmera renderizadas na sua tela.

Instalando OpenCV

Siga este link para instalar OpenCV:

https://www.learnopencv.com/install-opencv-4-on-raspberry-pi/

Código Python (main.py)

import cv2.cv as cv
from datetime import datetime
import time
import sys
import datetime
count=0

class MotionDetector():
  def onChange(self, val): #callback quando o usuário muda o teto
    self.ceil = val

  def __init__(self,ceil=8, doRecord=True, showWindows=True):
    self.writer = None
    self.font = None
    self.doRecord=doRecord #Gravar ou não o objeto em movimento
    self.show = showWindows #Mostrar ou não as 2 janelas
    self.frame = None
    self.capture=cv.CaptureFromCAM(0)
    self.frame = cv.QueryFrame(self.capture) #Pega um frame para iniciar gravador
    if doRecord:
      self.initRecorder()
    self.frame1gray = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U) #Frame cinza em t-1
    cv.CvtColor(self.frame, self.frame1gray, cv.CV_RGB2GRAY)
    #Guardará o resultado thresholded
    self.res = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U)
    self.frame2gray = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U) #Frame cinza em t
    self.width = self.frame.width
    self.height = self.frame.height
    self.nb_pixels = self.width * self.height
    self.ceil = ceil
    self.isRecording = False
    self.trigger_time = 0 #Guarda timestamp da última detecção
    if showWindows:
      cv.NamedWindow("Image")
      #cv.CreateTrackbar("Mytrack", "Image", self.ceil, 100, self.onChange)

  def initRecorder(self): #Cria o gravador
    codec = cv.CV_FOURCC('D', 'I', 'V', 'X')
    #codec = cv.CV_FOURCC("D", "I", "B", " ")
    self.writer=cv.CreateVideoWriter(datetime.now().strftime("%b-%d_%H:%M:%S")+".avi", codec, 15, cv.GetSize(self.frame), 1)
    #FPS definido em 15 porque parece ser o fps da minha cam mas deve ser ajustado às suas necessidades
    self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2, 8) #Cria uma fonte

  def run(self):
    global count
    started = time.time()
    while True:
      curframe = cv.QueryFrame(self.capture)
      instant = time.time() #Pega timestamp do frame
      self.processImage(curframe) #Processa a imagem
      if not self.isRecording:
        if self.somethingHasMoved():
          self.trigger_time = instant #Atualiza trigger_time
          if instant > started +5:#Espera 5 segundos após início da webcam para ajuste de luminosidade etc..
            print "Humano Detectado"
            count += 1
            print(count/2)
            orig_stdout = sys.stdout
            f = open('out.txt', 'a+')
            sys.stdout = f
            print(count/2)
            sys.stdout = orig_stdout
            f.close()
            #log de timestamp
            orig_stdout = sys.stdout
            f = open('log.txt', 'a+')
            sys.stdout = f
            timestampc =('Timestamp: {:%Y-%b-%d %H:%M:%S}'.format(datetime.datetime.now()))
            print(timestampc+' Log Entry : 1')
            sys.stdout = orig_stdout
            f.close()
            if self.doRecord: #define isRecording=True apenas se gravarmos vídeo
              self.isRecording = True
      else:
        if instant >= self.trigger_time +10: #Grava durante 10 segundos
          print "Parar gravação"
          self.isRecording = False
        else:
          cv.PutText(curframe,datetime.now().strftime("%b %d, %H:%M:%S"), (25,30),self.font, 0) #Coloca data no frame
          cv.WriteFrame(self.writer, curframe) #Escreve o frame
      if self.show:
        cv.ShowImage("Image", curframe)
        #cv.ShowImage("Res", self.res)
      cv.Copy(self.frame2gray, self.frame1gray)
      c=cv.WaitKey(1)
      if c==27 or c == 1048603: #Break se usuário pressionar 'Esc'.
        break

  def processImage(self, frame):
    cv.CvtColor(frame, self.frame2gray, cv.CV_RGB2GRAY)
    #Absdiff para obter a diferença entre os frames
    cv.AbsDiff(self.frame1gray, self.frame2gray, self.res)
    #Remove ruído e faz threshold
    cv.Smooth(self.res, self.res, cv.CV_BLUR, 5,5)
    element = cv.CreateStructuringElementEx(5*2+1, 5*2+1, 5, 5, cv.CV_SHAPE_RECT)
    cv.MorphologyEx(self.res, self.res, None, None, cv.CV_MOP_OPEN)
    cv.MorphologyEx(self.res, self.res, None, None, cv.CV_MOP_CLOSE)
    cv.Threshold(self.res, self.res, 10, 255, cv.CV_THRESH_BINARY_INV)

  def somethingHasMoved(self):
    nb=0 #Guardará o número de pixels pretos
    for y in range(self.height): #Itera toda a imagem
      for x in range(self.width):
        if self.res[y,x] == 0.0: #Se o pixel é preto, mantém
          nb += 1
    avg = (nb*100.0)/self.nb_pixels #Calcula a média de pixels pretos na imagem
    #print "Average: ",avg, "%\r",
    if avg > self.ceil:#Se acima do teto, dispara alarme
      return True
    else:
      return False

if __name__=="__main__":
  detect = MotionDetector(doRecord=False)
  detect.run()

Download - https://www.hackster.io/code_files/438321/download

Uma vez feito, simplesmente salve o arquivo digitando "CTRL+X", depois Y, e depois ENTER. O script pode ser executado digitando o seguinte comando:

python main.py

Você deve ser capaz de ver uma imagem na tela e por favor veja o vídeo para verificar, se necessário, e há a contagem de humanos pelo programa no terminal.

Criei apenas um gabinete com chapa MDF para o Arduino e Raspberry Pi 3

Criando um Dashboard para App Desktop

Passo 1: Instalar Apache

Instale o pacote apache2 com este comando:

sudo apt install apache2 -y

Passo 2: Instalar PHP

Para permitir que seu servidor Apache processe arquivos PHP, você precisará instalar a versão mais recente do PHP e o módulo PHP para Apache. Digite o seguinte comando para instalar estes:

sudo apt install php libapache2-mod-php -y

Agora baixe o Dashboard.zip:

cd /var/www/html
wget "https://hacksterio.s3.amazonaws.com/uploads/attachments/1097966/Dashboard.zip"

e instale unzip:

sudo apt-get install unzip

extraia os arquivos de um arquivo ZIP:

unzip Dashboard.zip

Agora salve e atualize seu navegador. Você deve ver

Configurando um Raspberry Pi como Ponto de Acesso Sem Fio

Siga este link https://www.raspberrypi.org/documentation/configuration/wireless/access-point.md

Nota: Nomeie o Ponto de Acesso Sem Fio como SanitizingTunnel

interface=wlan0
driver=nl80211
ssid=SanitizingTunnel
hw_mode=g
channel=7
wmm_enabled=0
macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0
wpa=2
wpa_passphrase=SecretPassword
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP

Agora Vamos Começar a Construir o App

App Android:

Pré-requisito: Android Studio

Você pode simplesmente baixar o código diretamente daqui.

E altere suas credenciais como Endereço IP do seu Raspberry Pi de acordo com suas necessidades.

App iOS:

Pré-requisito: XCode

Você pode simplesmente baixar o código diretamente daqui.

E altere suas credenciais como Endereço IP do seu Raspberry Pi de acordo com suas necessidades.

Solução Química Usada

O túnel de desinfecção tem 0.4% de solução de hipoclorito de sódio em 100 litros de água.

Atualização - Vi muitos comentários dizendo que você está usando produtos químicos nocivos.

Então, coletei informações do fornecedor que me fornecia este químico. Ele me disse que o químico que estou usando neste túnel é da Raman & Weil Pvt. Ltd e eles têm "Declaração" da Bode Chemie Germany, sobre eficácia contra COVID-19.

Link Oficial - https://ramanweil.com/pdf/Declaration%20from%20Bode%20Chemie%20Germany%20on%20efficacy%20against%20COVID%2019.pdf

Juntando Tudo

Finalmente, era hora de ligar o Túnel e verificar se todas as rotinas e apps estão funcionando conforme o planejado.

Custo

Link - Planilha de custos no Google Sheets

Código

Código Arduino Túnel
main.py
Arquivos do Dashboard
Código Fonte Android Sanitation-Tunnel
App Android Sanitation-Tunnel
Código Fonte iOS Sanitation-Tunnel

Código Arduino Túnel C/C++

/* 
 * Túnel Inteligente de Desinfecção e Sanitização 
 */
int relayPin = 12; // escolhe o pino para o Pino do Relé
int inputPin = 2; // escolhe o pino de entrada (para sensor PIR)
int inputPin2 = 3; // escolhe o pino de entrada (para sensor PIR 02)
int pirState = LOW; // começamos, assumindo nenhum movimento detectado
int val = 0; // variável para ler o status do pino
int val2 = 0; // variável para ler o status do pino

void setup() {
  pinMode(relayPin, OUTPUT); // declara Relé como saída
  pinMode(inputPin, INPUT);  // declara sensor PIR como entrada
  pinMode(inputPin2, INPUT);
  Serial.begin(9600);
}

void loop(){
  val = digitalRead(inputPin);  // lê valor de entrada
  val2 = digitalRead(inputPin2); // lê valor de entrada
  if (val == HIGH || val2 == HIGH) { // verifica se a entrada é HIGH
    digitalWrite(relayPin, HIGH); // liga Relé
    if (pirState == LOW) {
      // acabamos de ligar
      Serial.println("Movimento detectado!");
      // delay de 15 seg
      delay(15000); // Só queremos imprimir na mudança de saída, não no estado
      pirState = HIGH;
    }
  } else {
    digitalWrite(relayPin, 0); // desliga Relé
    if (pirState == HIGH){
      // acabamos de desligar
      Serial.println("Movimento encerrado!");
      // Só queremos imprimir na mudança de saída, não no estado
      pirState = LOW;
    }
  }
}

main.py Python

import cv2.cv as cv
from datetime import datetime
import time
import sys
import datetime
count=0

class MotionDetector():
  def onChange(self, val): #callback quando o usuário muda o teto
    self.ceil = val

  def __init__(self,ceil=8, doRecord=True, showWindows=True):
    self.writer = None
    self.font = None
    self.doRecord=doRecord #Gravar ou não o objeto em movimento
    self.show = showWindows #Mostrar ou não as 2 janelas
    self.frame = None
    self.capture=cv.CaptureFromCAM(0)
    self.frame = cv.QueryFrame(self.capture) #Pega um frame para iniciar gravador
    if doRecord:
      self.initRecorder()
    self.frame1gray = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U) #Frame cinza em t-1
    cv.CvtColor(self.frame, self.frame1gray, cv.CV_RGB2GRAY)
    #Guardará o resultado thresholded
    self.res = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U)
    self.frame2gray = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U) #Frame cinza em t
    self.width = self.frame.width
    self.height = self.frame.height
    self.nb_pixels = self.width * self.height
    self.ceil = ceil
    self.isRecording = False
    self.trigger_time = 0 #Guarda timestamp da última detecção
    if showWindows:
      cv.NamedWindow("Image")
      #cv.CreateTrackbar("Mytrack", "Image", self.ceil, 100, self.onChange)

  def initRecorder(self): #Cria o gravador
    codec = cv.CV_FOURCC('D', 'I', 'V', 'X')
    #codec = cv.CV_FOURCC("D", "I", "B", " ")
    self.writer=cv.CreateVideoWriter(datetime.now().strftime("%b-%d_%H:%M:%S")+".avi", codec, 15, cv.GetSize(self.frame), 1)
    #FPS definido em 15 porque parece ser o fps da minha cam mas deve ser ajustado às suas necessidades
    self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2, 8) #Cria uma fonte

  def run(self):
    global count
    started = time.time()
    while True:
      curframe = cv.QueryFrame(self.capture)
      instant = time.time() #Pega timestamp do frame
      self.processImage(curframe) #Processa a imagem
      if not self.isRecording:
        if self.somethingHasMoved():
          self.trigger_time = instant #Atualiza trigger_time
          if instant > started +5:#Espera 5 segundos após início da webcam para ajuste de luminosidade etc..
            print "Humano Detectado"
            count += 1
            print(count/2)
            orig_stdout = sys.stdout
            f = open('out.txt', 'a+')
            sys.stdout = f
            print(count/2)
            sys.stdout = orig_stdout
            f.close()
            #log de timestamp
            orig_stdout = sys.stdout
            f = open('log.txt', 'a+')
            sys.stdout = f
            timestampc =('Timestamp: {:%Y-%b-%d %H:%M:%S}'.format(datetime.datetime.now()))
            print(timestampc+' Log Entry : 1')
            sys.stdout = orig_stdout
            f.close()
            if self.doRecord: #define isRecording=True apenas se gravarmos vídeo
              self.isRecording = True
      else:
        if instant >= self.trigger_time +10: #Grava durante 10 segundos
          print "Parar gravação"
          self.isRecording = False
        else:
          cv.PutText(curframe,datetime.now().strftime("%b %d, %H:%M:%S"), (25,30),self.font, 0) #Coloca data no frame
          cv.WriteFrame(self.writer, curframe) #Escreve o frame
      if self.show:
        cv.ShowImage("Image", curframe)
        #cv.ShowImage("Res", self.res)
      cv.Copy(self.frame2gray, self.frame1gray)
      c=cv.WaitKey(1)
      if c==27 or c == 1048603: #Break se usuário pressionar 'Esc'.
        break

  def processImage(self, frame):
    cv.CvtColor(frame, self.frame2gray, cv.CV_RGB2GRAY)
    #Absdiff para obter a diferença entre os frames
    cv.AbsDiff(self.frame1gray, self.frame2gray, self.res)
    #Remove ruído e faz threshold
    cv.Smooth(self.res, self.res, cv.CV_BLUR, 5,5)
    element = cv.CreateStructuringElementEx(5*2+1, 5*2+1, 5, 5, cv.CV_SHAPE_RECT)
    cv.MorphologyEx(self.res, self.res, None, None, cv.CV_MOP_OPEN)
    cv.MorphologyEx(self.res, self.res, None, None, cv.CV_MOP_CLOSE)
    cv.Threshold(self.res, self.res, 10, 255, cv.CV_THRESH_BINARY_INV)

  def somethingHasMoved(self):
    nb=0 #Guardará o número de pixels pretos
    for y in range(self.height): #Itera toda a imagem
      for x in range(self.width):
        if self.res[y,x] == 0.0: #Se o pixel é preto, mantém
          nb += 1
    avg = (nb*100.0)/self.nb_pixels #Calcula a média de pixels pretos na imagem
    #print "Average: ",avg, "%\r",
    if avg > self.ceil:#Se acima do teto, dispara alarme
      return True
    else:
      return False

if __name__=="__main__":
  detect = MotionDetector(doRecord=False)
  detect.run()