Pool Pi Guy - Sistema de alarme acionado por IA e monitoramento de piscina usando Raspberry Pi: 12 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Ter uma piscina em casa é divertido, mas implica uma grande responsabilidade. Minha maior preocupação é monitorar se alguém está perto da piscina sem vigilância (especialmente crianças mais novas). Meu maior aborrecimento é garantir que a linha de água da piscina nunca desça abaixo da entrada da bomba, o que deixaria a bomba seca e a destruiria, custando $ $ $ em reparos.

Recentemente descobri como usar um Raspberry Pi com OpenCV e TensorFlow, junto com um sensor de nível de água e uma válvula solenóide para resolver os dois problemas - e divirta-se fazendo isso!

Ele também é um ótimo sistema de alarme - ativado por movimento, controlado por IA, infinitamente personalizável.

Vamos mergulhar.

Etapa 1: Grande Plano

Neste instrutível, mostraremos como:

1. Configure um Raspberry Pi com OpenCV e TensorFlow
2. Conecte uma webcam por meio de um cabo USB longo
3. Escreva um algoritmo OpenCV para detectar movimento
4. Use o TensorFlow para detecção de objetos
5. Configure um servidor web no Raspberry Pi para mostrar as imagens interessantes
6. Integre-se ao IFTTT para acionar alertas móveis caso uma pessoa seja detectada
7. Anexe um HAT de relé ao Raspberry Pi e conecte-o a uma válvula solenóide que adicionaria água à piscina
8. Anexe um sensor de nível de água ao Raspberry Pi e faça interface com ele usando o GPIO do Pi
9. Escreva algum código para colar tudo junto

Etapa 2: lista de compras

Todos os componentes estão disponíveis na Amazon. Sinta-se à vontade para experimentar e trocar componentes - isso é metade da diversão!

1. Raspberry Pi
2. Fonte de alimentação Raspberry Pi (não economize aqui)
3. Cartão de memória (quanto maior, melhor)
4. Caixa (esta é grande o suficiente para abrigar o Pi e o HAT)
5. Webcam USB (qualquer webcam serve, mas você quer uma que obtenha boas imagens e equilibre bem a iluminação)
6. Cabo de extensão USB (se necessário - meça a distância entre o Pi e onde você colocaria a câmera)
7. Placa de relé HAT (esta tem 3 relés e só precisamos de um, mas você encontrará uma utilidade para os outros em breve!)
8. Solenóide
9. Encaixe de solenóide 1 e Encaixe 2 (isso realmente depende de onde você encaixou o solenóide, mas funcionou para mim)
10. Fonte de alimentação do solenóide (qualquer 24 V AC serviria)
11. Cabo (novamente, quase qualquer cabo de 2 fios serviria - a corrente é mínima)
12. Interruptor de flutuação do nível da água (este é apenas um exemplo, verifique o que pode ser facilmente conectado à sua piscina)
13. Alguns fios de jumpers e conectores de fios

Etapa 3: configure seu Raspberry Pi

Raspberry Pi é um ótimo pequeno computador. Custa apenas US $ 35, é executado de forma consistente e tem muitos softwares e hardwares compatíveis. Configurá-lo é muito fácil:

1. Formate seu cartão SD. Isso requer cuidados especiais - o Raspberry Pi só pode inicializar a partir de um cartão SD formatado em FAT. Siga estas instruções.
2. Conecte o Raspberry Pi a um teclado e mouse USB, além de um monitor HDMI e siga as instruções no tutorial do Raspberry Pi NOOBS. Certifique-se de configurar o WiFi e habilitar o acesso SSH. Não se esqueça de configurar uma senha para a conta pi padrão.
3. Em sua rede doméstica, configure um IP estático para o Raspberry Pi - isso tornaria muito mais fácil fazer o SSH.
4. Certifique-se de ter um cliente ssh instalado em seu desktop / laptop. Para um PC, eu recomendaria o Putty, que você pode instalar aqui.
5. Desconecte o USB e o HDMI do Raspberry Pi, reinicie-o e conecte-o por ssh - se tudo funcionou, você verá algo como isto:

Linux raspberrypi 4.14.98-v7 + # 1200 SMP Ter 12 de fevereiro 20:27:48 GMT 2019 armv7l

Os programas incluídos no sistema Debian GNU / Linux são software livre; os termos de distribuição exatos para cada programa são descritos nos arquivos individuais em / usr / share / doc / * / copyright. O Debian GNU / Linux vem ABSOLUTAMENTE NENHUMA GARANTIA, até o limite permitido pela lei aplicável. Último login: Seg, 13 de maio 10:41:40 2019 de 104.36.248.13 pi @ raspberrypi: ~ $

Etapa 4: Configurar OpenCV

OpenCV é uma coleção incrível de funções de manipulação de imagens para visão computacional. Isso nos permitirá ler imagens da webcam, manipulá-las para encontrar áreas de movimento, salvá-las e muito mais. A configuração do Raspberry Pi não é difícil, mas requer alguns cuidados.

Comece instalando o virtaulenvwrapper: usaremos o python para fazer toda a nossa programação, e o virtualenv nos ajudaria a manter as dependências separadas para OpenCV e TensorFlow vs. Flask ou GPIO:

pi @ raspberrypi: ~ $ sudo pip install virtualenvwrapper

Agora você pode executar "mkvirtualenv" para criar um novo ambiente, "workon" para trabalhar nele e muito mais.

Então, vamos criar um ambiente para nossa manipulação de imagens, com o python 3 como o interpretador padrão (é 2019, não há razão para ficar com o antigo python 2):

pi @ raspberrypi: ~ $ mkvirtualenv cv -p python3

… (Cv) pi @ raspberrypi: ~

Agora estamos prontos para instalar o OpenCV. Seguiremos principalmente o excelente tutorial em Aprenda OpenCV. Siga especificamente as etapas 1 e 2:

sudo apt -y updatesudo apt -y upgrade ## Instalar dependências sudo apt-get -y install build-essential checkinstall cmake pkg-config yasm sudo apt-get -y install git gfortran sudo apt-get -y install libjpeg8-dev libjasper- dev libpng12-dev sudo apt-get -y instale libtiff5-dev sudo apt-get -y instale libtiff-dev sudo apt-get -y instale libavcodec-dev libavformat-dev libswscale-dev libdc1394-22-dev sudo apt-get - y instale libxine2-dev libv4l-dev cd / usr / include / linux sudo ln -s -f../libv4l1-videodev.h videodev.h sudo apt-get -y instale libgstreamer0.10-dev libgstreamer-plugins-base0. 10-dev sudo apt-get -y instalar libgtk2.0-dev libtbb-dev qt5-default sudo apt-get -y instalar libatlas-base-dev sudo apt-get -y instalar libmp3lame-dev libtheora-dev sudo apt-get -y instale libvorbis-dev libxvidcore-dev libx264-dev sudo apt-get -y instale libopencore-amrnb-dev libopencore-amrwb-dev sudo apt-get -y instale libavresample-dev sudo apt-get -y instale x264 v4l-utils sudo apt-get -y install libprotobuf -dev protobuf-compiler sudo apt-get -y install libgoogle-glog-dev libgflags-dev sudo apt-get -y install libgphoto2-dev libeigen3-dev libhdf5-dev doxygen sudo apt-get install libqtgui4 sudo apt-get install libqt4- teste

Agora podemos apenas instalar o OpenCV com ligações python dentro do cv virtualenv (você ainda está nele, certo?) Usando

pip install opencv-contrib-python

E é isso! Temos OpenCV instalado em nosso Raspberry Pi, pronto para capturar fotos e vídeos, manipulá-los e ser legal.

Verifique isso abrindo um interpretador Python e importando opencv e verifique se não há erros:

(cv) pi @ raspberrypi: ~ $ python

Python 3.5.3 (padrão, 27 de setembro de 2018, 17:25:39) [GCC 6.3.0 20170516] no linux Digite "ajuda", "direitos autorais", "créditos" ou "licença" para obter mais informações. >>> import cv2 >>>

Etapa 5: configurar o TensorFlow

TensorFlow é uma estrutura de aprendizado de máquina / IA desenvolvida e mantida pelo Google. Ele tem amplo suporte para modelos de aprendizado profundo para uma variedade de tarefas, incluindo detecção de objetos em imagens, e agora é bastante simples de instalar no Raspberry Pi. O desempenho de seus modelos leves no minúsculo Pi é de cerca de 1 quadro por segundo, o que é perfeitamente adequado para uma aplicação como a nossa.

Basicamente, seguiremos o excelente tutorial da Edje Electronics, com modificações possibilitadas por distribuições mais recentes do TensorFlow:

pi @ raspberrypi: ~ $ workon cv

(cv) pi @ raspberrypi: ~ $ pip instalar tensorflow (cv) pi @ raspberrypi: ~ $ sudo apt-get instalar libxml2-dev libxslt-dev (cv) pi @ raspberrypi: ~ $ pip instalar travesseiro lxml jupyter matplotlib cython (cv) pi @ raspberrypi: ~ $ sudo apt-get install python-tk

Agora precisamos compilar o protobuf do Google. Basta seguir as instruções na etapa 4 do mesmo excelente tutorial

Por fim, clone e configure as definições de modelo do TensorFlow - siga a etapa 5 no tutorial da Edje Electronics

Sinta-se à vontade para seguir o exemplo da etapa 6 também, é uma ótima introdução à detecção de objetos no Raspberry Pi.

Etapa 6: detecção de movimento usando OpenCV

Vamos começar testando se o OpenCV pode fazer interface com nossa webcam: ssh no Raspberry Pi, vá para o cv virtualenv (workon cv), abra um interpretador python (basta digitar python) e digite os seguintes comandos python:

import cv2

cap = cv2. VideoCapture (0) cap.set (cv2. CAP_PROP_FRAME_WIDTH, 1920) cap.set (cv2. CAP_PROP_FRAME_HEIGHT, 1080) ret, frame = cap.read () print ('Ler tamanho do frame: {} x {}'.format (frame.shape [1], frame.shape [0])

Com alguma sorte, você verá que o OpenCV foi capaz de ler um quadro HD da câmera.

Você pode usar cv2.imwrite (caminho, quadro) para gravar esse quadro no disco e enviá-lo de volta para uma aparência real.

A estratégia para detectar movimento é bastante simples:

1. Trabalhe em quadros de resolução mais baixa - não há necessidade de operar em full HD aqui
2. Além disso, desfoque as imagens para garantir o mínimo de ruído possível.
3. Mantenha uma média contínua dos últimos N quadros. Para este aplicativo, em que a taxa de quadros é em torno de 1 FPS (só porque o TensorFlow leva algum tempo por quadro), descobri que N = 60 retorna bons resultados. E uma vez que uma implementação cuidadosa não ocupa mais CPU com mais frames, está tudo bem (leva mais memória - mas isso é insignificante quando trabalhamos com frames de resolução mais baixa)
4. Subtraia a imagem atual da média de execução (apenas tome cuidado ao digitar - você precisa permitir valores positivos e negativos [-255.. 255], então o quadro precisa ser convertido para int)
5. Você pode realizar a subtração em uma conversão em escala de cinza do quadro (e da média), ou fazê-lo separadamente para cada um dos canais RGB e depois combinar os resultados (que é a estratégia que escolhi, tornando-a sensível às mudanças de cor)
6. Use um limite no delta e remova o ruído por erosão e dilatação
7. Finalmente, procure contornos de áreas com um delta - essas áreas são onde o movimento aconteceu e a imagem atual é diferente da média das imagens anteriores. Podemos ainda encontrar caixas delimitadoras para esses contornos, se necessário.

Eu encapsulei o código para fazer isso na classe DeltaFinder python que você pode encontrar em meu github aqui

Etapa 7: detectar objetos usando o TensorFlow

Se você seguiu o procedimento de instalação do TensorFlow, já testou se o TensorFlow está instalado e funcionando.

Com o objetivo de detectar pessoas em uma cena externa geral, os modelos pré-treinados no conjunto de dados COCO têm um desempenho muito bom - que é exatamente o modelo que baixamos no final da instalação do TensorFlow. Só precisamos usá-lo para inferência!

Novamente, encapsulei o carregamento e a inferência do modelo na classe TFClassify python para facilitar as coisas, que você pode encontrar aqui.

Etapa 8: Configurar um servidor da Web no Raspberry Pi

A maneira mais fácil de acessar os resultados da detecção de objetos é um navegador da web, então vamos configurar um servidor da web no Raspberry Pi. Podemos então configurá-lo para servir imagens de um determinado diretório.

Existem várias opções para uma estrutura de servidor web. Eu escolhi o Flask. É extremamente configurável e fácil de estender com Python. Como a "escala" de que precisamos é trivial, era mais do que suficiente.

Eu sugiro instalá-lo em um novo virtualenv, então:

pi @ raspberrypi: ~ $ mkvirtualenv webserv

(webserv) pi @ raspberrypi: ~ $ pip install Flask

Observe que, com uma configuração de rede normal, ele só estará acessível quando seu navegador estiver na mesma LAN sem fio que o Raspberry Pi. Você poderia criar um mapeamento de porta / configuração NAT em seu roteador de Internet para permitir acesso externo - mas eu não recomendo isso. O código que escrevi não tenta fornecer a segurança de que você precisa ao permitir o acesso geral à Internet para o seu Raspberry Pi.

Teste sua instalação seguindo o guia de início rápido do Flask

Etapa 9: notificações móveis do Raspberry Pi usando IFTTT

Eu realmente quero receber notificações móveis quando ocorrerem eventos. Neste caso, quando uma pessoa é detectada e quando o nível da água baixa. A maneira mais simples que descobri de fazer isso, sem precisar escrever um aplicativo móvel personalizado, é usando IFTTT. IFTTT significa "If This Then That" e permite que muitos tipos de eventos acionem muitos tipos de ações. Em nosso caso, estamos interessados no gatilho IFTTT Maker Webhook. Isso nos permite acionar uma ação IFTTT fazendo uma solicitação HTTP POST ao servidor IFTTT com uma chave especial atribuída à nossa conta, junto com dados que especificam o que aconteceu. A ação que realizamos pode ser tão simples quanto criar uma notificação em nosso dispositivo móvel usando o aplicativo móvel IFTTT, ou qualquer coisa mais complexa do que isso.

Aqui está como fazer isso:

1. Crie uma conta IFTTT em ifttt.com
2. Enquanto estiver conectado, vá para a página de configurações do serviço Webhook e digite o URL em seu navegador (algo como https://maker.ifttt.com/use/. Essa página da web mostrará sua chave e o URL a ser usado para acionar ações.

3. Crie um miniaplicativo IFTTT que irá gerar uma notificação móvel quando o Webhook for acionado com os detalhes do evento:

   1. Clique em "Meus miniaplicativos" e em "Novo miniaplicativo".
   2. Clique em "+ this" e escolha "webhooks". Clique em "Receber uma solicitação da web" para acessar os detalhes
   3. Dê um nome ao seu evento, por exemplo "PoolEvent" e clique em "Criar gatilho"
   4. Clique em "+ isso" e escolha "notificações". Em seguida, escolha "Enviar uma notificação avançada do aplicativo IFTTT"
   5. Para "título", escolha algo como "PoolPi"
   6. Para "mensagem" escreva "Pool Pi detectado:" e clique em "adicionar ingrediente".. "Valor1".
   7. Volte para a URL que você copiou na etapa 2. Ela mostrará a URL a ser usada para invocar o miniaplicativo recém-criado. Copie esse URL, substituindo o espaço reservado {evento} pelo nome do evento (no nosso exemplo PoolEvent)
4. Baixe, instale e faça login no aplicativo IFTTT para o seu dispositivo móvel
5. Execute este script Python no seu Raspberry Pi para vê-lo funcionando (observe que pode levar alguns segundos ou minutos para ser acionado no seu dispositivo móvel):

pedidos de importação

request.post ('https://maker.ifttt.com/trigger/PoolEvent/with/key/', json = {"value1": "Hello Notifications"})

Etapa 10: adicionar um relé HAT ao Raspberry Pi e conectá-lo a uma válvula solenóide

Antes de prosseguir com esta etapa DESLIGUE o Raspberry Pi: ssh para ele e digite "sudo shutdown now" e, em seguida, desconecte-o da energia

Nosso objetivo é ligar e desligar a fonte de alimentação de uma válvula solenóide - uma válvula que pode abrir ou fechar o fornecimento de água com base na alimentação de 24 VCA que obtém de uma fonte de alimentação. Relés são os componentes elétricos que podem abrir ou fechar um circuito com base em um sinal digital que nosso Raspberry Pi pode fornecer. O que fazemos aqui é conectar um relé a esses pinos de sinal digital do Raspberry Pi e fechar o circuito entre a fonte de alimentação de 24 Vca e a válvula solenóide.

Os pinos do Raspberry Pi que podem atuar como entrada ou saída digital são chamados de GPIO - General Purpose Input / Output e são a fileira de 40 pinos na lateral do Pi. Com o Pi desligado, insira o HAT do relé firmemente nele. O HAT que escolhi possui 3 relés e usaremos apenas um deles. Imagine tudo o que você pode fazer com os outros dois:)

Agora ligue o Raspberry Pi novamente. O LED vermelho de "energia" no HAT do relé deve acender, indicando que está recebendo energia do Pi por meio do GPIO. Vamos testar se podemos controlá-lo: ssh no Pi novamente, insira python e digite:

importar gpiozero

dev = gpiozero. DigitalOutputDevice (26, valor_inicial = Verdadeiro) dev.off ()

Você deve ouvir um "clique" audível, indicando que o relé está ativado, e ver um LED acender mostrando que o primeiro relé está na posição conectado. Agora você pode digitar

Devon()

O que colocaria o relé na posição "off" (estranho, eu sei …) e exit () do python.

Agora, usando cabos jumper e o cabo mais longo, conecte o relé entre a fonte de alimentação de 24 V e a válvula solenóide. Veja o diagrama. Finalmente, conecte a válvula solenóide a uma torneira usando os adaptadores e prepare-se para testar tudo repetindo os comandos acima - eles devem abrir e fechar a água.

Conecte uma mangueira à válvula solenóide e coloque a outra extremidade profundamente na piscina. Agora você tem um sistema de enchimento de piscina controlado por computador e é hora de conectar um sensor para avisá-lo quando executar.

Etapa 11: conectar um sensor de nível de água

Um sensor de nível de água é simplesmente uma bóia que conecta um circuito elétrico quando a bóia está para baixo e o interrompe quando ela flutua para cima. Se você inseri-lo na piscina na altura certa, o flutuador subirá quando o nível de água estiver adequado, mas cairá quando não houver água suficiente.

Para o Raspberry Pi saber o status do sensor de nível de água, precisamos do Pi para detectar um circuito aberto ou fechado. Felizmente, isso é muito simples: os mesmos conectores GPIO que usamos como saída digital para controlar os relés podem atuar como entradas (daí o I em GPIO). Especificamente, se conectarmos um fio do sensor a + 3,3 V no conector GPIO e o outro fio do sensor a um pino que configuramos como entrada pull-down (o que significa que estará normalmente no nível de tensão GND), esse pino irá medir uma tensão digital "alta" ou "ligada" somente quando o sensor de nível de água fecha o circuito - quando o nível de água está baixo. Usei o pino 16 do GPIO como entrada, que marquei na imagem acima.

O código Python para configurar o pino como entrada e testar seu estado atual é:

importar gpiozero

level_input = gpiozero. Button (16) water_low = level_input.is_pressed

Um desafio potencial é que, quando o sensor apenas muda de estado, ele oscila rapidamente entre os estados ligado e desligado. A solução para isso é conhecida como "debouncing" e procura uma mudança de estado consistente antes de agir. A biblioteca GPIOZERO tem código para fazer isso, mas por algum motivo esse código não funcionou bem para mim. Eu escrevi um loop simples para acionar alertas IFTTT quando uma mudança de estado consistente é detectada, que você pode encontrar em meu repositório aqui.

Etapa 12: Escreva o código para unir tudo

É isso. Nossa configuração está completa. Você pode escrever seu próprio código para unir as coisas em um sistema completo ou usar o código que eu forneço. Para fazer isso, basta criar a estrutura de diretório e clonar o repositório, assim:

mkdir poolpi

cd poolpi git clone

Em seguida, edite os arquivos denominados ifttt_url.txt nos diretórios motion_alert e water_level para ter a URL de seu próprio web hook IFTTT com sua chave secreta. Você pode usar dois web hooks diferentes para ações diferentes.

Por fim, queremos que esse código seja executado automaticamente. A maneira mais fácil de fazer isso é por meio do serviço crontab do Linux. Podemos adicionar algumas linhas crontab para duas tarefas principais:

1. Execute nossos três programas: o detector de objetos, o sensor de nível de água e o servidor web a cada reinicialização
2. Limpe o diretório de saída, excluindo imagens antigas e arquivos de vídeo antigos (eu escolhi excluir arquivos com mais de 1 dia e imagens com mais de 7 dias - sinta-se à vontade para experimentar)

Para fazer isso, digite crontab -e que abrirá seu editor de texto nano. Adicione as seguintes linhas ao final do arquivo:

0 1 * * * find / home / pi / poolpi / output -tipo f -nome "*.avi" -mtime +1 -excluir

0 2 * * * find / home / pi / poolpi / output -type f -name "*.jpg" -mtime +7 -delete @reboot python3 /home/pi/poolpi/motion_alert/webserv/webserv.py @reboot python3 /home/pi/poolpi/motion_alert/motion_obj_alert.py @reboot python3 /home/pi/poolpi/water_level/test_water_level.py

Finalmente, reinicie o Raspberry Pi. Agora ele está pronto para manter sua piscina cheia e segura.

Faça alterações na configuração, no código e não se esqueça de iniciar meu repositório github e comentar sobre o instrutível se você achar útil. Estou sempre procurando aprender mais.

Feliz fabricação!

Vice-campeão no Desafio de IoT