Universidade de Pernambuco

Faculdade de Ciência e Tecnologia de Caruaru

Bacharelado em Sistemas de Informação

USO EFICIENTE DA ÁGUA ATRAVÉS DO

MONITORAMENTO EM TEMPO REAL DO
CONSUMO

Trabalho de Graduação

Sistemas de Informação

Rodolpho Victor França Vasconcelos

Orientador: Prof. Fernando Ferreira Carvalho

 RODOLPHO VICTOR FRANÇA
VASCONCELOS

USO EFICIENTE DA ÁGUA ATRAVÉS

DO MONITORAMENTO EM TEMPO
REAL DO CONSUMO

Monografia apresentada como requisito parcial

para obtenção do diploma de Bacharel em
Sistemas de Informação pela Faculdade de
Ciência e Tecnologia de Caruaru – Universidade
de Pernambuco.

Caruaru, outubro de 2019.

Dedico esse trabalho a minha família que sempre me
incentivou e me apoiou em todos os momentos da minha vida.
Agradecimentos

Agradeço primeiramente a minha mãe Adriana quem me educou junto ao meu

pai e sempre me incentivou a ser sempre o melhor naquilo que me proponho a fazer,
ao meu pai Arivonaldo Vasconcelos que sempre me apoiou se dedicou para me
proporcionar o melhor, aos meus avós Eunice e Edenilson meus segundos pais
essenciais na minha vida, a minha noiva Mayara Lima pelo incentivo e ajuda em
todo tempo , a minha tia Andréa França por todo incentivo e dedicação, ao meu
irmão Matheus e primo/irmão Rômulo por serem o primeiro exemplo do significado
da palavra amizade.

Aos meus bons amigos, professores e demais servidores da UPE que de

alguma forma auxiliaram a concluir essa etapa.
 Resumo
Diante do cenário de otimizar o gasto de água nas residências ou empresas
contribuindo de modo sustentável para o planeta o presente trabalho apresenta o
desenvolvimento de uma aplicação de software e hardware para o monitoramento do
consumo de água em residências ou empresas, como também, em pontos
específicos que se deseja observar. A aplicação integra dispositivos IoT (Internet of
Things) coletando dados do sensor conectado à rede hidráulica e publicando na
internet. Para atingir o objetivo proposto são utilizadas explorações de bibliotecas e
métodos utilizados pela literatura. O protótipo utiliza como hardware o NodeMcu em
conjunto com um sensor de fluxo de água e o software conta uma aplicação web
para monitorar os dados obtidos.

Palavras chave: Internet das coisas, NodeMcu, monitoramento, consumo, água.

 Abstract

Given the scenario of optimizing water consumption in homes or businesses

contributing in a sustainable way to the planet, this paper presents the development

of a software and hardware application for monitoring water consumption in homes or

businesses, as well as in points specific ones to be observed. The application

integrates IoT (Internet of Things) devices collecting data from the sensor connected

to the hydraulic network and publishing it on the internet. To achieve the proposed

objective, library explorations and methods used in the literature are used. The

prototype uses NodeMcu as hardware together with a water flow sensor and the

software has a web application to monitor the data obtained.

Keywords: internet of things, NodeMcu, monitoring, consumption, water.

 Lista de Figuras
Figura 2.1. Arduino Uno .............................................................................. 19

Figura 2.2. Módulos externos e sensores Arduino ...................................... 20

Figura 2.3. Modelos de Arduino .................................................................. 20

Figura 2.4. Especificações Arduino Uno...................................................... 21

Figura 2.5. Placa Raspberry Pi Model B...................................................... 22

Figura 2.6. Pinout NodeMcu ........................................................................ 25

Figura 2.7. Funcionamento Blynk ................................................................ 26

Figura 2.8. Esquema funcionamento MQTT ................................................ 30

Figura 3.1. Análise de SWOT ...................................................................... 32

Figura 3.2. Arquitetura do Projeto................................................................ 33

Figura 3.3. Função Setup do projeto ........................................................... 34

Figura 3.4. Função FazLeituraVazao(); ....................................................... 35

Figura 3.5. Protótipo do projeto ................................................................... 36

Figura 3.6. Visão geral do sistema .............................................................. 38

Figura 3.7. Conexão com o firebase............................................................ 39

Figura 3.8. Conexão MQTT/Javascript ........................................................ 39

Lista de Tabelas
Tabela 1 - Comparação modelos Raspberry Pi .......................................... 23

Tabela 2 - Comparação placas de desenvolvimento .................................. 25

Tabela 3 - Estrutura tarifária da Compesa .................................................. 40

 Lista de Siglas
BIT- Binary Digit (Digito Binário)

BLE- Bluetooth

GB- Gigabyte

GPIO- General Purpose Input/Output (Entrada/ Saída de Uso Geral)

HDMI- High-Definition Multimedia Interface (Interface multimídia de alta definição)

HTML- HyperText Markup Language (Linguagem de Marcação de Hipertexto)

HTTP- HyperText Transfer Protocol (Protocolo de Transferência de Hipertexto)

IDE- Integrated Development Environment (Ambiente de desenvolvimento integrado)

IEEE- Instituto de Engenheiros Elétricos e Eletrônicos

IO- Input/output (Entrada/ Saída)

IoT- Internet of Things (Internet das coisas)

IP- Internet Protocol (Protocolo de Internet)

LAN- Local Area Network (Rede Local)

LED- Light Emitting Diode (diodo emissor de luz)

MQQT- acrônimo de Message Queuing Telemetry Transport (

transporte de telemetria do serviço de enfileiramento de mensagens)

NodeMCU- Node MicroController Unit ( Unidade de Microcontrolamento)

OpenGL- Open Graphics Library (biblioteca de Gráficos)

SWOT- Forças (Strengths), Fraquezas (Weaknesses), Oportunidades

(Opportunities) e Ameaças (Threats)
TCP- Transmission Control Protocol (Protocolo de Controle de Transmissão)

TV- Televisão

USB- Universal Serial Bus (Porta Universal)

W3C- World Wide Web Consortium

WI-FI- Wireless Fidelity (Fidelidade sem fio)

dpi – dots per inch (pontos por polegada)

Sumário

Capítulo 1- Introdução ...................................................................................... 14

1.1 Caracterização do Problema ............................................................... 15

1.2 Objetivos e Metas ................................................................................... 16

Capítulo 2- Referencial Teórico ........................................................................ 17

2.1 IoT - Internet das Coisas......................................................................... 17

2.2 Hardware ................................................................................................ 18

2.2.1 Arduino ............................................................................................. 18

2.2.3 Raspberry Pi .................................................................................... 22

2.2.2 NodeMcu .......................................................................................... 24

2.3 Software.................................................................................................. 26

2.3.1 Blynk App ......................................................................................... 26

2.3.2 Sistema Web- Hidrômetro IoT .......................................................... 27

- Html 5...................................................................................................... 27

- Javascript ................................................................................................ 28

- MQTT ...................................................................................................... 29

Capítulo 3- Uso eficiente da água através do monitoramento em tempo real do seu

consumo ........................................................................................................... 31

3.1 Análise de SWOT ................................................................................ 31

 3.2 Protótipo .............................................................................................. 32

3.2.1 Sensor de fluxo de água FS300A G3/4’ ....................................... 35

3.2.2 Função attachInterrupt ..................................................................... 36

3.3 Sistema Web ....................................................................................... 37

Capítulo 4- Conclusão e Trabalhos Futuros ..................................................... 41

Referências ...................................................................................................... 42

Apêndice A ....................................................................................................... 44

Código Fonte NodeMcu ................................................................................ 44

Código Fonte Javascript ............................................................................... 49

 14

Capítulo 1- Introdução
Atualmente vivencia- se uma era em que a celeridade da evolução
tecnológica chega a assustar. Ao se comparar as últimas três décadas com os dias
atuais, grande parte da população ainda possui dificuldades para perceber a
dimensão desse enriquecimento tecnológico e o quão benéfico ele pode ser.
O grande responsável por essa evolução provavelmente foi o segmento
eletrônico, que concedeu a constante miniaturização dos dispositivos eletrônicos,
consequentemente áreas como a telecomunicação, automação, instrumentação
industrial e claro o desenvolvimento de sensores tem garantido que cada vez mais o
monitoramento de diferentes grandezas físicas e ofertar acessos a dados
simultaneamente por distintos públicos, oferecendo os mais diversos tipos de
analises e/ou processamento desses dados.
Inserir sensores e poder acompanhar os dados gerados por eles
remotamente é benéfico para diferentes setores da economia e afeta diretamente o
dia a dia de toda uma população.
O Brasil, por exemplo, começou a viver, a partir de 2014, os primeiros focos
principais do que pode ser a maior crise de água em sua história. Com um problema
de seca severa, bem como a gestão de recursos naturais, o país tem apresentado
baixos níveis em seus reservatórios em épocas do ano em que eles são geralmente
mais cheios. Essa ocorrência, de certa forma, representa uma grande contradição, já
que o Brasil é considerado a maior potência hídrica do planeta.
Para DINO (2017) apesar do problema relacionado a crise hídrica, parte da
população não tem consciência da importância da preservação do recurso, pois os
números também mostram que o país se destaca por causa do desperdício:
segundo o relatório do Ministério das Cidades, cerca de 41% de toda a água tratada
é desperdiçado.

Face à crescente necessidade de utilização dos recursos naturais, o

presente estudo vem a fazer uso do desenvolvimento das tecnologias como descrito
acima para auxiliar na utilização da água de maneira consciente e eficiente, criando
um sistema que utiliza IoT (internet das coisas) onde se emprega como plataforma
 15

open source o NodeMCU para fazer a conexão entre o sensor físico e a Internet
baseado no Arduino juntamente com MQTT (Message Queue Telemetry Transport)
que funcionará como protocolo para comunicação. Resumidamente, o trabalho
discorre da elaboração de um sistema onde será possível com um baixo custo
monitorar o consumo de água caseiro, empresarial ou industrial de forma remota,
garantindo acompanhamento do consumo, gasto financeiro ou até mesmo identificar
algum tipo de vazamento.

1.1 Caracterização do Problema

Diante da crise hídrica vivenciada principalmente em nossa região, é de

grande importância que o consumidor saiba identificar maneiras de reduzir o seu
consumo de água. Com o monitoramento diário e em tempo real fica mais fácil
identificar os picos de consumo, descobrir vazamentos de água e problemas em
equipamentos que utilizam água.

Com o apoio de um sistema disponibilizando os dados de consumo com fácil

acesso e buscando com esses dados mudar determinados hábitos de consumo,
tornaria benéfico para o consumidor e para o meio ambiente. A busca constante de
inovações e tecnologias tem contribuído de forma significativa não só para o
crescimento e a competitividade das organizações, como também para áreas pouco
exploradas até algum tempo atrás e que vem ganhando visibilidade nos dias atuais,
como a sustentabilidade.

Face à crescente necessidade de utilização dos recursos naturais, o

presente estudo vem a fazer uso do desenvolvimento de tecnologias para auxiliar na
utilização da água de maneira consciente e eficiente. Apresenta- se então a
pergunta problema desta investigação cientifica:

Será que o monitoramento do consumo de água em tempo real tornará seu

uso mais eficiente?
 16

1.2 Objetivos e Metas

Este trabalho tem como objetivo geral o desenvolvimento de um sistema de

Internet das Coisas para o monitoramento do consumo de água, com o intuito de
controlar e reduzir o desperdício da água, contribuindo assim de maneira sustentável
para a sociedade.

Os objetivos específicos para alcançar ao final de tudo o objetivo geral são:

▪ Analisar e comparar os hardwares disponíveis no mercado para

definição da placa de desenvolvimento que será utilizada.

▪ Apresentar as tecnologias usadas no processo de desenvolvimento da

aplicação.

▪ Desenvolver firmware para o NodeMcu com a finalidade de obter dados

de sensores conectados à rede hidráulica.

▪ Possibilitar a visualização em tempo real do consumo e dados

históricos.
 17

Capítulo 2- Referencial Teórico

Este capítulo apresenta os fundamentos teóricos necessários para o
desenvolvimento do Hidrômetro IoT, abordando nas perspectivas tanto do hardware
como de software, apresentando tecnologias que poderiam ser usadas e explicando
os motivos porque usar ou não cada uma das tecnologias.

2.1 IoT - Internet das Coisas

Originaria dos Estados Unidos, a internet surgiu no ano de 1969 com o intuito
de interligar alguns laboratórios de pesquisas militares, nos anos seguintes foi sendo
aprimorada, diversos progressos baseados em definições foram alcançados, como a
criação do protocolo TCP/IP que define o padrão de transmissão até os dias atuais.

No Brasil, a internet teve seu surgimento em 1989 com a criação da rede

nacional de pesquisa (RNP) com o objetivo de controlar a infraestrutura da própria
internet no país, já em 1991 foi instalado o primeiro ponto de distribuição de acesso
(backbone) destinado a comunidade acadêmica e em 1995 foi aberta ao público.

A internet é um ambiente virtual repleto de informações advinda de vários

dispositivos a ela conectados, não precisando necessariamente estar no mesmo
espaço para que seja realizada uma comunicação, assim um imenso conjunto de
dados podem estar acessíveis virtualmente, originando o que podemos chamar de
nuvem. Qualquer dispositivo conectado à internet pode vir a ser identificado através
do protocolo de internet, mais conhecido como IP, é possível se imaginar que
qualquer coisa possa prover informações nesse ambiente e vir a se comunicar com
qualquer outra “coisa” que a ela esteja ligada, esse seria um resumo e mais
diretamente o significado de IoT.

Alguns autores referem-se à localização ou rastreio de objetos quando falam

de Internet das coisas, porém atualmente entende-se por IoT toda troca de
informação, seja de cunho informativo, automatizado ou inteligente.
 18

Para Estevam Júnior (2018) A internet das coisas pode ser vista em diferentes
perspectivas como em nosso lar, por meio das casa inteligentes provendo
facilidades como comandos de voz para controle de iluminação, controle de acesso
por biometria, eletrodomésticos conectados a internet, medição de consumo de
energia e água, como também nas empresas e indústrias por meio de controle de
válvulas, monitoramento de temperaturas e até mesmo muitas das facilidades
existentes nas casas inteligentes podem sem usufruídas também nas empresas.
Ainda existe a perspectiva de cidades inteligentes auxiliando na gestão de trânsito,
conectividade do cidadão e controle de iluminação inteligente.

É justamente no cenário residencial e empresarial que a solução proposta se

encaixa, o desenvolvimento do Hidrômetro IoT, que propõe por meio de sensores
conectados à internet tornar visível em qualquer lugar do mundo dados que antes só
seriam acessados localmente, por meio de leituras no hidrômetro físico, ainda
necessitando realizar cálculos para obter as mesmas informações oferecidas pelo
sistema, assim otimizando o controle de uso da água e aplicando exatamente o
conceito de IoT no dia a dia.

2.2 Hardware
2.2.1 Arduino

O arduino foi criado em 2005 para solucionar um problema que o professor

Massimo Banzi enfrentava, que era ensinar conceitos de eletrônica e programação,
na época não existiam placas com o custo acessível dificultando a aquisição pelos
seus alunos, a partir disso Banzi decidiu criar uma placa com estrutura semelhante a
de um computador (Souza, 2019) .

Mais especificamente falando, o arduino é considerado um microcontrolador

de placa única e um conjunto de software para programá-lo. O hardware consiste em
um projeto simples Open Source para o controlador, com um processador Atmel
AVR e suporte embutido de entrada/saída. O software consiste de uma linguagem
de programação padrão e do bootloader que roda na placa.
 19

Segundo McRoberts (2011) o arduino é um pequeno computador que pode

ser programado para processar entradas e saídas entre o dispositivo e os
componentes externos conectados a ele.

Já para Banzi (2009) o arduino é composto de duas partes principais: a Placa

Arduino, que é a peça de hardware em que se trabalha e constrói os projetos
(exemplificada na figura 2.1) e a Arduino IDE, a parte de software que é executado
em seu computador. Usa-se a IDE para criar o código de programação e fazer o
upload para a placa Arduino, o código diz a placa o que fazer e essa por sua vez
executa as funções.

Figura 2.1. Arduino Uno

Fonte: Arduino.cc (2019).

O microcontrolador utiliza uma linguagem baseada em C/C++ e opera sem a

necessidade de equipamentos extras, no entanto seu uso se torna mais interessante
quando conectado a módulos externos que são placas com sensores e outros
componentes auxiliares como resistores, capacitores e LEDs, ampliando assim o
leque de possibilidades para atuação, podendo conectar o arduino a internet ou com
outro dispositivo através do bluetooth por exemplo. A figura 2.2 mostra alguns
módulos externos existentes.
 20

Figura 2.2. Módulos externos e sensores Arduino

Fonte: www.usinainfo.com.br (2018).

Por se tratar um hardware Open-Source qualquer placa com a mesma

estrutura do Arduino original e que utilize a mesma linguagem padrão consegue
realizar as mesmas funções do Arduino Original.

A partir do sucesso do microcontrolador em sua placa padrão (Arduino Uno),

foram sendo criados diversos modelos para cada fim específico de uso. A Figura 2.3
apresenta alguns dos modelos disponíveis.

Figura 2.3. Modelos de Arduino

Fonte: (HISTÓRIA..., 2015).

O Arduino Uno é a placa padrão e mais conhecida, é baseada no

microcontrolador ATmega328, possui 14 pinos digitais de input e output (I/O), 6
inputs analógicos normalmente utilizadas para a leitura de sensores, possui entrada
 21

para cabo usb com a finalidade de transferência dos dados e alimentação da placa
além de poder receber uma alimentação externa com uma tensão entre 6v e 20v. Na
Figura 2.4 traz as especificações:

Figura 2.4. Especificações Arduino Uno

Fonte: (HISTÓRIA..., 2015).

O Arduino mega é uma versão maior do arduino uno, essa placa é

recomendada para o uso em projetos mais elaborados e com maior dimensão, pois
conta com maior quantidade de memória já que é baseada no microcontrolador
ATmega2560 e também a quantidade maior de inputs e outputs, são 54 I/O digitais
do Mega contra 14 do Uno e 16 inputs analógicas, 10 a mais que o Uno.
Sem dúvidas o Arduino foi o impulsionador para a popularização do
movimento maker (faça você mesmo), difundindo também a IoT conectando vários
sensores e atuadores a internet, seria com toda certeza uma solução para a
elaboração do nosso projeto proposto, o desenvolvimento de um hidrômetro IoT, no
entanto já existem alternativas mais aperfeiçoadas e que entregam uma maior
praticidade em um tamanho reduzido, os primeiros testes do projeto foram feitos em
um arduino uno equipado com o Ethernet shield, placa que permite o arduino
conectar-se a internet, logo após com aperfeiçoamento do projeto foi substituído o
arduino por outra placa mais otimizada para projetos IoT.
 22

2.2.3 Raspberry Pi

Surgiu em 2006 quando Eben Upton, Rob Mullins, Jack Lang e Alan Mycroft
decidiram criar um computador pequeno e acessível para crianças no laboratório da
Universidade de Cambridge.
Para Eberman (2017, p. 34), “O Raspberry Pi logo se tornou famoso pelas
suas duas principais características: o tamanho (tem as dimensões de um cartão de
crédito) e seu baixo custo (US$ 35)”.
A placa originalmente conta com o sistema operacional Raspbian, que se
trata de uma variante da distribuição Debian do Linux, mas também podem ser
usados outros sistemas operacionais (EBERMAM et al., 2017).
A pequena placa possui diversas conexões comuns em computadores
responsáveis pela transmissão de áudio, vídeo e dados, as principais são: HDMI,
USB, Ethernet e GPIO. A porta HDMI é responsável pela transmissão de áudio e
vídeo de alta qualidade através de um único cabo seja para o monitor, TV ou outro
dispositivo de mídia. As portas USB, amplamente utilizadas em dispositivos de
informática e aparelhos eletrônicos, são o meio de conexão com os diversos
periféricos, que podem ser mouses, teclados, adaptador WI-FI, entre outros. Cabo
Ethernet utilizado para a comunicação com a rede e a internet. Os pinos GPIO
(General Purpose Input/Output) são usados para comunicação de outros dispositivos
externos, como controle de equipamentos de automação.

Figura 2.5. Placa Raspberry Pi Model B+

 23

Fonte: (EBERMAM et al., 2017).

O mini PC é amplamente utilizado para criação de sistemas portáteis e de

automação conectados à Internet das Coisas (IoT) e até videogames retrô, por
exemplo. Atualmente o Raspberry Pi se encontra em sua quarta geração, seu
primeiro modelo foi lançado em 2012 e o ultimo em 2019.

A Tabela 1 faz uma comparação das especificações e destaca as diferenças

entre o modelo mais recente da placa, o Pi4 Model B e os seus antecessores o Pi3
Model B (figura 2.5) e Model B+.

Tabela 1 - Comparação modelos Raspberry Pi

Pi3 Model B Pi3 Model B+ Pi4 Model B

Processador Broadcom Broadcom BCM283780, Broadcom 2711, Quad-

BCM2837A1(B0), Quad- Quad-core Cortex-A53 core Cortex-A72 64-bit
core Cortex-A53 64-bit 64-bit SoC@ 1.4Ghz SoC@ 1.5Ghz
SoC@ 1.2Ghz

Memória 1GB LPDDR2 SDRAM 1GB LPDDR2 SDRAM 1GB, 2GB or 4GB
LPDDR4 SDRAM

Conectividade 2.4GHz IEEE 2.4GHz / 5.0GHz IEEE 2.4GHz / 5.0GHz IEEE

802.11.b/g/n/ac wireless
LAN, Bluetooth 4.1, BLE
4x USB 2.0 ports
802.11.b/g/n/ac wireless 802.11.b/g/n/ac wireless
LAN, Bluetooth 4.2, BLE LAN, Bluetooth 5.0, BLE
4x USB 2.0 ports, 2x USB 2.0 / 2x USB 3.0
Gigabit Ethernet over ports delivering true
USB2.0 (max. 300MPS) Gigabit Ethernet

Conexões 1x full size HDMI 1x full size HDMI 2x micro HDMI, 4k video

1x MIPI DSI display port 1x MIPI DSI display port 1x MIPI DSI display port

1x MIPI CSI camera port 1x MIPI CSI camera port 1x MIPI CSI camera port

4 pole stereo output and 4 pole stereo output and 4 pole stereo output and
composite vídeo port composite vídeo port composite vídeo port
 24

Multimídia H.264, MPEG-4 decode H.264, MPEG-4 decode H.265 decode (4kp60)
(1080 30p), (1080 30p),
H264 decode (1080p60)
H.264 encode (1080 H.264 encode (1080
30p), 30p), H.264 encode
(1080p30)
OpenGL ES 1.1, 2.0 OpenGL ES 1.1, 2.0
graphics graphics OpenGL ES 1.1, 2.0, 3.0
graphics

O Raspberry Pi é uma plataforma que permite sua utilização em diversos tipos

de projeto, principalmente os mais complexos, devido a sua grande capacidade de
processamento e semelhança com um PC, foi cogitado o seu uso na implementação
do projeto, no entanto como a finalidade era atingir o menor custo possível e
também a menor complexidade, foi adotado outra solução.

2.2.2 NodeMcu

“NodeMcu, assim como o Arduino, é uma plataforma de código aberto (open

source) e hardware aberto (open hardware), para desenvolvimento de equipamentos
na filosofia de internet das coisas, ou IoT (Internet of Things)” (FRIZZARIN, 2019,
p.17).

De acordo com Frizzarin (2019) o módulo NodeMcu foi criado com base no
módulo ESP8266, que inicialmente era utilizado como um módulo Wi-fi para o
Arduino, o NodeMcu incrementou o Esp8266 com a adição da comunicação USB-
serial para a conexão ao computador, o acréscimo de mais pinos GPIO (entrada e
saída), a inserção de um bootloader que é possível ser programado na linguagem
LUA e Arduino, tudo isso mantendo o tamanho reduzido.

A grande vantagem dessa placa é que ela pode ser programada como um
Arduino, bastando conectar ao computador via usb e carregar os programas com a
IDE do Arduino. A Figura 2.6 a seguir mostra a disposição dos pinos na placa
NodeMcu.
 25

Figura 2.6. Pinout NodeMcu

Fonte: www.arduining.com (2015).

Para Estevam Júnior (2018) “As principais vantagens da plataforma NodeMcu

em relação ao arduino são: baixo custo, suporte integrado para rede wi-fi, tamanho
reduzido da placa e baixo consumo de energia”.

A tabela 2 faz uma comparação entre o Esp8266 que é a base do NodeMcu,

o Arduino Uno e o Raspberry Pi 3 Model B, ficando assim mais fácil fazer a escolha
de qual hardware usar no projeto, nesse projeto em especifico será usado o
NodeMcu devido a sua facilidade de prototipagem, baixo consumo de energia,
tamanho e por ser projetado para execução de projetos IoT, assim facilitando o
andamento do projeto.

Tabela 2 - Comparação placas de desenvolvimento

Esp8266 Arduino Uno Raspberry Pi 3

Corrente 197 mA 40 mA 800 mA
Núcleo 1 1 4
Arquitetura 32 bits 8 bits 64 bits
Clock 80 – 160 Mhz 16 Mhz 1200 Mhz
Wifi Sim Não Sim
Ram 160Kb 2Kb 1 Gb
Gpio 11 12 46
 26

2.3 Software
2.3.1 Blynk App

O aparecimento de novas placas inspiradas no Arduino e quem podem ser

programadas com a mesma IDE e linguagem do Arduino aumentaram a
possibilidade de projetos no âmbito da IoT (Internet of Things), ao mesmo tempo que
o surgimento de serviços conectados à internet que utilizam o conceito de IoT fez
com que a demanda por dispositivos que tenham conectividade e possibilitem o
envio de dados e controle remoto por meio dessas plataformas crescesse
(SERRANO; NUNEZ, 2018) .

É justamente nesse contexto em que o Blynk se insere, agindo como uma

ferramenta de elaboração de dashboards para monitoramento e controle de
dispositivos IoT como o NodeMcu, Arduino e Raspeberry Pi através da internet , nas
palavras de Oliveira (2017) “A principal característica do Blynk é permitir que a
comunicação com uma plataforma microcontrolada / embarcada possa ser realizada
sabendo o mínimo de programação e até mesmo sem criar uma linha de código”.

O Blynk é estruturado em 3 partes: App Blynk, Servidor Blynk e Bibliotecas

Blynk, como exemplifica a Figura 2.7:

Figura 2.7. Funcionamento Blynk

Fonte: (SERRANO; NUNEZ, 2018).
 27

O App Blynk pode ser usado tanto no Android como no IOS e possibilita ao
usuário criar aplicações personalizadas somente arrastando Widgets em sua
interface, esses Widgets incorporam funções ao projeto, como, botões para envio de
comandos ao hardware, painéis para exibição de valores recebidos do hardware,
como um sensor de temperatura por exemplo, gráficos entre outros.

O Servidor Blynk é responsável por toda comunicação entre o hardware e

app Blynk, ele também armazena dados de sensores mesmo com o App fechado, os
dados que ficam armazenados no servidor Blynk podem também ser acessados
externamente através de uma API HTTPP. As Bibliotecas Blynk permitem a
comunicação com o hardware de forma simples, ela faz a ponte entre o servidor e as
plataformas disponíveis que podem ser o Arduino, Raspberry Pi, entre outros.

O serviço é em sua grande parte disponibilizado gratuitamente, o app pode

ser baixado sem custo algum assim como o servidor e as bibliotecas também podem
ser usadas de forma gratuita o gargalo fica somente para aplicações de grande
complexidade, pois no app cada Widget utilizado custa um valor, chamado no
aplicativo de Energy, inicialmente está disponível 2000 Energy, a medida que é
acrescentado algum Widget esse valor vai diminuindo de acordo com o valor de
cada Widget, para as aplicações mais comuns é suficiente o valor de Energy
disponível e caso seja preciso pode ser adquirido mais comprando.

2.3.2 Sistema Web- Hidrômetro IoT

A solução utilizada neste trabalho foi o desenvolvimento de um sistema Web

próprio com base em sistemas IoT, da forma mais simples e prática possível
utilizando as seguintes tecnologias: Html 5, Javascript, Firebase e Mqtt.

- Html 5

Para Scheidt (2015, p.48) “HTML ou Hypertext Markup Language (linguagem

de marcação de hipertexto) é uma linguagem utilizada para escrever e organizar
 28

páginas web. O termo hipertexto nada mais é do que texto/ informação que possui
marcações e hiperligações (links) para outros documentos”.
O Html é considerado uma linguagem de marcação e não de programação
porque não dispõe dos conceitos básicos que a linguagem de programação
proporciona que são: 1- variáveis; 2- estruturas de decisão; 3- estruturas de
repetição e 4- estrutura de dados (SCHEIDT, 2015).
O seu surgimento foi em 1993 e foi publicado por Tim Berners-Lee, após
algumas publicações o W3C (World Wide Web Consortium), consórcio responsável
em padronizar a World Wide Web, ficou responsável por publicar suas novas
versões, a última versão publicada foi a HTML5 em 2014 (SCHEIDT, 2015).
De acordo com Scheidt (2015) a nova versão do HTML trouxe melhorias
significativs com novas funcionalidades de codificação e melhor suporte a conteúdo
multimídias, acelerando o desenvolvimento e deixando o código mais leve e de fácil
entendimento.

- Javascript

Segundo Scheidt (2015) A HTML não é a única linguagem para o

desenvolvimento web, existem outras e uma das fundamentais para o
desenvolvimento Web é o Javascript.
Foi criada em 1995, e se tornou fundamental para o desenvolvimento Web,
suas características principais são: Alta performance, Multi-plataforma e
Multiparadigma (BIFFI, 2018).
A linguagem é responsável por criar o dinamismo nas páginas web, por ser
uma linguagem de scripting podemos controlar alguns comportamentos que são
enviados na página HTML, outra característica é que ela é uma linguagem
interpretada, ou seja, o código é executado conforme é lido no navegador, linha a
linha, das mesma forma que o HTML (PRESCOTT, 2016).
O javascript foi indispensável para o desenvolvimento do projeto, por meio
dele foi possível manipular o HTML para exibição das informações recebidas do
NodeMcu, como também indispensável para a comunicação com o hardware por
meio do protocolo MQTT.
 29

- MQTT

Foi utilizado no projeto por meio da biblioteca Paho JavaScript – MQTT Client,
escolhida por ser considerada muito estável e usada em várias aplicações web
baseadas em MQTT, que significa, Message Queue Telemetry Transport.
No mundo da IoT a internet é fundamental, através dela é possível a
comunicação entre os dispositivos. O protocolo padrão utilizado na internet é o
TCP/IP, já na IoT o MQTT se tornou o padrão para a comunicação.
Criado e inicialmente desenvolvido na década de 90 pela IBM, sua função
inicial era conectar sensores em pipelines de petróleo com satélites. Na prática é um
protocolo de mensagem com comunicação assíncrona que utiliza um modelo de
publicação e assinatura, ideal para redes que não são confiáveis (YUAN, 2017).
Nesse padrão de publicação e assinatura, mais conhecido como
publisher/subscriber, de acordo com Basílio (2019?) a comunicação gira em torno de
dois elementos, o servidor, conhecido como o broker e os clientes, que podem ser
publishers ou subscribers. O broker recebe todas as informações tanto dos
publishers quanto dos subscribers e fica responsável redirecioná-las para o seu
destino, os publishers são os responsáveis por enviar as mensagens ao servidor, no
caso o Broker, que pode ser um dado de um sensor lido.O Broker recebe a
informação e dispara para os subscibers que assinaram aquele determinado tópico,
pois nesse modelo quando se deseja receber alguma informação é necessário se
subscrever ao determinado tópico requisitando o mesmo ao Broker.A figura 2.8
exemplifica o caminho percorrido pelas mensagens.
 30

Figura 2.8. Esquema funcionamento MQTT

Fonte: (OLIVEIRA, 2017).

De modo mais simples e fácil de entender podemos exemplificar a comunicação

Publisher/subscriber em 3 passos: 1- Conexão do cliente ao broker por meio de
TCP/IP; 2- Publicação do cliente de mensagens nos tópicos, enviando a mensagem
e o tópico ao broker; 3- Envio das mensagens por parte do broker a todos
subscribers que assinaram o tópico.

Yuan (2017) afirma que o MQTT é um protocolo de rede leve e flexível ideal para
a IoT e cita alguns pontos explicando por que usá-lo, entre eles está a possibilidade
de implementação em dispositivos limitados em processamento e a capacidade de
operar bem em redes com banda limitada e alta latência.
 31

Capítulo 3- Uso eficiente da água através

do monitoramento em tempo real do seu
consumo
No capítulo anterior foram apresentadas as plataformas de hardware e
software que compõe o desenvolvimento deste projeto. Neste capítulo será
abordado a implementação de um protótipo de hardware e da aplicação web.

O projeto do hidrômetro IoT visa proporcionar ao usuário um

acompanhamento em tempo real de sua utilização de água, seja ela na sua
residência, empresa ou ponto específico (chuveiro, máquina de lavar, torneira de
jardim), proporcionando assim um controle mais eficaz da utilização da água e em
possíveis casos de vazamento proporciona uma identificação mais ágil do problema,
tendo em vista que o sistema emite alertas de acordo com o consumo e ainda
permite o usuário visualizar informações como: vazão instantânea em litros por
segundo, totalizador em litros, totalizador em metros cúbicos, histórico mensal do
consumo em m³ e acompanhamento financeiro.

3.1 Análise de SWOT

Foi realizada uma análise de SWOT neste projeto para identificar as forças,
fraquezas, oportunidades e ameaças, no intuito de auxiliar no desenvolvimento do
trabalho.

• Strengths (forças) - Monitoramento em tempo real do consumo de

água, identificação de consumo excessivo ou vazamento de água em
um menor espaço de tempo, uso da IoT;

• Weaknesses (fraquezas) – pequenas oscilações nas leituras do sensor

proveniente de ar na rede, perda de comunicação;
 32

• Opportunities (oportunidades) – Possibilidade de controlar melhor o

gasto da água, fácil acesso aos dados;

• Threats (ameaças) – Problemas ou danos no sensor ou dispositivo de

monitoramento, quedas ou instabilidades no servidor;

Figura 3.1. Análise de SWOT

Fonte: Autor (2019).

3.2 Protótipo

Neste trabalho é proposto um protótipo de hardware responsável por fazer o

monitoramento do consumo de água através do NodeMcu junto com o sensor de
fluxo de água enviando em tempo real as informações para um broker MQTT onde o
usuário poderá monitorar os dados através de um computador ou celular. O protótipo
visou um baixo custo, tendo em vista que o valor final do protótipo custou
aproximadamente 10 dólares importando as peças em sites chineses como o
Aliexpress.
 33

Figura 3.2. Arquitetura do Projeto

Fonte: Autor (2019).

Apesar de ser possível utilizar a linguagem Lua, desenvolver projetos no

NodeMcu com essa linguagem requer o aprendizado de uma nova linguagem e a
adaptação a um novo ambiente de desenvolvimento, devido a isso foi utilizado a IDE
do arduino com sua linguagem padrão para a programação do NodeMcu, utilizando
3 bibliotecas, a “FirebaseArduino.h”, a “ESP8266WiFi.h” e a “PubSubClient.h”. No
setup do código por meio da biblioteca “ESP8266WiFi.h” é possível conectar o
NodeMcu a rede Wi-fi informando o nome e senha da rede wireless, a partir dai a
biblioteca retorna a informação de sucesso ou não da conexão com a rede, após
esse passo entra em ação a biblioteca “PubSubClient.h” estabelecendo a conexão
com o Broker MQTT, que no caso do projeto foi utilizado o MQTT público da
HiveMQ, empresa com foco em soluções MQTT, utilizando a porta TCP 1883, optou-
se por esse broker devido a sua gratuidade e estabilidade. Feita a conexão com o
broker inicia-se o pino digital de comunicação com o sensor de fluxo e configura-o
para trabalhar como interrupção, após isso a biblioteca “Firebase Arduino.h” faz a
conexão com o Host do firebase configurado, utilizando sua autorização para ler a
variável do totalizador armazenada no banco de dados e assim continuar a marcar o
totalizador do consumo de onde foi parado.
 34

Figura 3.3. Função Setup do projeto

Fonte: Autor (2019).

No loop do projeto (Figura 3.3), função que será executada continuamente no

projeto, é onde está a função mais importante, a “FazLeituraVazao” (Figura 3.4),
nela é feita a leitura do sensor de vazão FS300A G3/4’ utilizando o modo de
interrupção, conversão do valor em pulsos para litros por minuto e totalizadores em
litros e em metros cúbicos. A função também faz a publicação dos dados convertidos
para o broker MQTT, publicando cada um em seu tópico especifico.
 35

Figura 3.4. Função FazLeituraVazao();

Fonte: Autor (2019).

3.2.1 Sensor de fluxo de água FS300A G3/4’

O Sensor de Fluxo de água utilizado no projeto se trata de um sensor de

efeito Hall, que à medida que a água passa por ele e faz o rotor girar gera pulsos
magnéticos. Através desses pulsos que são lidos pelo NodeMcu que é possível
saber a vazão de água.

Possui 3 fios: Vermelho (5v), preto (GND), Amarelo (sinal de saída); a tensão
de funcionamento é de: DC 4.5v ~ 18v; a sua faixa de vazão varia de 1 a 60 litros
por minuto pode trabalha com no máximo 80º Celsius e 1.75 Mpa de pressão. Na
imagem 3.5 é possível observar o sensor de fluxo de água junto ao protótipo do
projeto.
 36

Figura 3.5. Protótipo do projeto

Fonte: Autor (2019)

3.2.2 Função attachInterrupt

Função disponível na linguagem do arduino e usada obrigatoriamente para a

leitura de dados em sensores de efeito Hall, pois sem isso o controlador, no caso o
NodeMcu, ficaria lendo ininterruptamente a porta digital do sensor sem sobrar tempo
para executar mais nenhum outro comando.

A interrupção tem prioridade na execução do código sendo tratada assim que

é chamada, quando acontece a interrupção uma rotina será executada e depois o
código será retomado de onde parou (SUHANKO, [2017?]).

No caso do nosso projeto, a leitura do sensor de fluxo de água FS300A que

usa um sensor de efeito hall para a obtenção dos dados, é indispensável o uso de
interrupções no código e isso reflete na prática, onde foram feitos vários testes de
precisão, usando recipientes graduados, e em todos eles os cálculos de litros
usados confere exatamente com a realidade.
 37

3.3 Sistema Web

Além do protótipo de hardware utilizado no projeto é necessário um sistema

para exibição dos dados lidos através do sensor e enviado para internet. O sistema
está disponível através da página http://hidrometro-iot.000webhostapp.com e devido
ao seu design responsivo pode ser acessado de qualquer dispositivo.

Esse sistema foi desenvolvido utilizando o HTML5 com o CSS Materialize

para a harmonização visual, organizando os dados para exibição, o javascript foi
utilizado a fim de proporcionar toda a parte lógica para a página, por meio dele é
feita a conexão com o banco de dados firebase como também a escuta dos dados
no Broker IoT, além do cálculo financeiro para exibição do valor da conta e exibição
do gráfico com o histórico dos dados.

O sistema conta com as seguintes funcionalidades:

• Painel de acompanhamento dos gastos – Alerta em porcentagem

quanto já foi gasto do consumo mínimo;

• Vazão - Exibe a vazão em litros por minutos e gráfico atualizado a

cada 6 leituras;

• Totalizador (litros) – Exibe o consumo acumulado em litros, para um

controle mais refinado do consumo (não é valido para o cálculo
financeiro) e gráfico atualizado automaticamente;

• Totalizador (m³) – Exibe o consumo acumulado em metros cúbicos

(valor utilizado para o cálculo financeiro) e exibe o valor atual da conta
no mês, baseado no consumo em m³.

• Resumo – Exibe o consumo acumulado em m³ de cada mês.

A visualização dos dados obtidos é feita por meio do navegador web como
mostra a Figura 3.6.
 38

Figura 3.6. Visão geral do sistema

Fonte: Autor (2019).

O sistema possui 2 códigos fontes, o do arquivo HTML, responsável pela

estruturação e exibição da página e o do arquivo javascript, responsável pela
interação dinâmica da página. A codificação do javascript é baseada em funções
que são executadas de acordo com algum acontecimento ou à medida que são
chamadas no código.

Para o armazenamento dos dados está sendo usado o Firebase, que é uma
plataforma do google que oferece uma série de ferramentas para o desenvolvimento
de projetos, entre elas está o Realtime Database que promove uma sincronia de
valores de forma simples, rápida e eficiente através do javascript.

O código é iniciado com a configuração da conexão com o firebase (Figura

3.7), informando alguns dados como a apiKey, authDomain, databaseURL,
projectID, storageBucket e messagingSenderId, dados esses que são fornecidos na
plataforma do firebase e sendo possíveis de ser usados no javascript devido a
biblioteca firebase.js.
 39

Figura 3.7. Conexão com o firebase

Fonte: Autor (2019).

Outro trecho importante do código é a utilização da biblioteca javascript Paho

MQTT, que no caso da aplicação web é utilizada para se conectar ao broker e
assinar os respectivos tópicos, como demonstra a Figura 3.8, que estão sendo
publicados pelo NodeMcu no protótipo do hardware e assim receber os dados
obtidos na leitura do sensor. A biblioteca é baseada em websockets para fazer a
conexão com o broker e possui algumas características como suporte a websockets,
alta disponibilidade, reconexão automática, persistência da mensagem entre outras.

Figura 3.8. Conexão MQTT/Javascript

Fonte: Autor (2019).

 40

Em seguida é feito o cálculo financeiro para estipular o valor da conta em

tempo real, baseado na estrutura tarifária da empresa de saneamento do estado, a
Compesa, de acordo com a Resolução da ARPE Nº147/2019-Publicada no DOE
nº.132 de 13/07/2019, que determina a tarifa mínima em R$44,08 para um consumo
até 10.000 litros/mês, a partir disso o valor do metro cúbico sobe gradativamente de
acordo com a tabela 3.

Tabela 3 - Estrutura tarifária da Compesa

Fonte: Compesa (2019)

 41

Capítulo 4- Conclusão e Trabalhos Futuros

O estímulo deste trabalho se deu na intenção de proporcionar um
monitoramento do consumo de água residencial mais eficiente. Esse objetivo foi
alcançado na implementação de forma acessível, com um protótipo simples e
funcional oferecendo uma forma moderna de gerenciamento.

O referencial teórico expôs os fundamentos necessários para o

desenvolvimento do projeto, apresentando algumas tecnologias que poderiam ser
usadas e esclarecendo os motivos pelos quais cada uma foi escolhida ou rejeitada,
tanto para o desenvolvimento do protótipo de hardware quanto para a elaboração do
sistema web de monitoramento.

Com base nos testes realizados viu-se que realmente pode-se tornar o uso da
água mais eficiente utilizando as funcionalidades oferecidas pelo sistema de
monitoramento, devido a facilidade de acompanhar de qualquer lugar e de diversos
dispositivos como smartphones, tablets e computadores as informações disponíveis,
podendo identificar alguma atividade em que se consome mais água e tentar
diminuir o tempo dessa atividade por exemplo, ou até identificando algum vazamento
antes mesmo de receber uma conta com valor fora do normal da companhia de
saneamento.

Este trabalho teve como principal contribuição a implementação das

aplicações web e de hardware trabalhando de forma integrada para o
monitoramento do consumo de água, como foi proposto no início do trabalho.

Abrindo assim um leque de possibilidades, adaptando o projeto pode-se

monitorar pontos específicos da residência ou empresa, pode-se ainda usá-lo para
individualização de consumo em prédios por apartamentos e permitindo ainda
incrementação de novas funcionalidades como a instalação de uma válvula
solenoide para controle remoto de fechamento e abertura da água.
 42

Referências
BANZI, Massimo. GettingStartedWithArduino. Sebastopol: O’Reilly, 2008.

Eberman, E., Presente, G., Rios, R. O., & Pulini, I. C. (2017). Programação
para Leigos com Raspberry Pi. João Pessoa: Edifes.

ESTEVAM JÚNIOR, Sergio Luiz. IoT Internet das Coisas: Fundamentos e

Aplicações em Arduino e nodemcu. 1ª. ed. São Paulo: Saraiva, 2018. 224 p.

FRIZZARIN, Fernando Bryan. NodeMcu: 15 passos para se tornar um mestre

em Iot. 1. ed. [S. l.]: Casa do Código, 2019. 181 p. ISBN 8572540083.

HISTÓRIA do Arduíno e seus modelos. [S. l.], 22 abr. 2015. Disponível

em:https://arduinoaprendizes.wordpress.com/2015/04/22/historiaarduino/.
Acesso em: 21 nov. 2019.

MCROBERTS, Michael. Arduino Básico [tradução Rafael Zanolli]. São

Paulo: Novatec Editora, 2011.

OLIVEIRA, Euler. Conhecendo o Blynk. [S. l.], 14 nov. 2017. Disponível em:
http://blogmasterwalkershop.com.br/blynk/conhecendo-o-blynk/. Acesso em:
27 set. 2019.

SCHEIDT, Felippe Alex. Introdução ao Html 5. 1ª. ed. Foz do Iguaçu: Editora
Itacaiúnas, 2015. ISBN 978-85-68154-22-9. E-book.

SERRANO, Tiago Medicci; NUNEZ, Ronaldo. Introdução ao Blynk App. [S.

l.], 8 maio 2018. Disponível em: https://www.embarcados.com.br/introducao-
ao-blynk-app/. Acesso em: 27 set. 2019.

SOUZA, F. d. (Agosto de 2019). Fonte: Embarcados.com:

https://www.embarcados.com.br/wp-content/uploads/filebase/ebooks/ebook-
introducao-arduino-embarcados-2019.pdf

BIFFI, Kelvin Baumhardt. Javascript: Básico ao Avançado: Guia completo

para iniciantes. 1. ed. [S. l.: s. n.], 2018. 127 p. E-book.
 43

PRESCOTT, Preston. Programação em JavaScript. Tradução: Fernando

Souza. 1. ed. [S. l.]: Babelcube Inc., 2016. 73 p. E-book.

CONHECENDO o MQTT. [S. l.], 4 out. 2017. Disponível em:

https://www.ibm.com/developerworks/br/library/iot-mqtt-why-good-for-
iot/index.html. Acesso em: 17 out. 2019.

CONHECENDO o protocolo MQTT. [S. l.], [2019?]. Disponível em:

https://blogmasterwalkershop.com.br/outros/conhecendo-o-protocolo-mqt.
Acesso em: 21 out. 2019.

INTERRUPÇÃO e timer com Arduino. In: SUHANKO, Djames. Interrupção e

timer com Arduino. [S. l.], [2017?]. Disponível em:
https://www.dobitaobyte.com.br/interrupcao-e-timer-com-arduino/. Acesso em:
1 nov. 2019.
 44

Apêndice A
Código Fonte NodeMcu

Código fonte disponível no link:

https://drive.google.com/open?id=1X1STSdOpLrBDrYoe-C9bDdkoQl8P2mBo

#include <FirebaseArduino.h>

#include <ESP8266WiFi.h>

#include <PubSubClient.h>

#define FIREBASE_HOST "hidrometro-iot.firebaseio.com"

#define FIREBASE_AUTH
"YxS1eGZLnCHuzXkxJkzhq2yV6kaWVtcKuB5iCbgC"

const char* SSID = "NET.COM FIBRA_5744"; // rede wifi

const char* PASSWORD = "sport2019"; // senha da rede wifi

const char* BROKER_MQTT = "broker.mqttdashboard.com";

int BROKER_PORT = 1883;

float vazao; //Variavel para armazenar o valor em L/min

int contaPulso; //Variavel para a quantidade de pulsos utilizado na vazao

int contpulso; //Variavel para a quant. de pulsos utilizado no totalizador

float litros; //Variavel para armazenamento do totalizador em litros

double cont; //Variavel para a conversão em m³

void initSerial();

void initWiFi();

void initMQTT();

WiFiClient client;

PubSubClient mqtt(client); // instancia o mqtt

 45

void setup() {

initSerial();

initWiFi();

initMQTT();

InitInput();

Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH);

Serial.print("number: ");

Serial.println(Firebase.getInt("total"));

int valor_recebido = Firebase.getInt("total");

contpulso = valor_recebido;

void loop() {

if (!mqtt.connected()) {

reconnectMQTT();

recconectWiFi();

mqtt.loop();

FazLeituraVazao();

int FazLeituraVazao(void) {

contaPulso = 0; //Zera a variavel para contar os giros por segundos

sei(); //Habilita interrupcao

delay (1000); //Aguarda 1 segundo

cli(); //Desabilita interrupcao

cont = contpulso;
 46

Firebase.setInt("total", contpulso);

if (Firebase.failed()) {

Serial.println(Firebase.error());

litros = (cont) / 330;

int m3 = litros*0.001;

vazao = contaPulso / 5.5; //Converte para L/min

Serial.print(cont); //Imprime na serial o valor dos pulsos

Serial.print(" Pulsos - "); //Imprime L/min

Serial.print(vazao); //Imprime na serial o valor da vazao

Serial.print(" L/min - "); //Imprime L/min

Serial.print(litros); //Imprime na serial o valor do totalizador em litros

Serial.print(" Total Consumido Litros- ");

Serial.print(m3); //Imprime na serial o valor do totalizador em litros

Serial.println(" Total Consumido m3 ");

char vazao_mqtt[4]; //cria a variavel para envio ao topico

dtostrf(vazao, 2, 2, vazao_mqtt);

mqtt.publish("RT/sensor/vazao", vazao_mqtt);

char litros_mqtt[4];//cria a variavel para envio ao topico

dtostrf(litros, 2, 2, litros_mqtt);

mqtt.publish("RT/sensor/litros", litros_mqtt);

char m3_mqtt[4];

dtostrf(m3, 2, 2, m3_mqtt);

mqtt.publish("RT/sensor/m3", m3_mqtt);

}
 47

void incpulso ()

contaPulso++; //Incrementa a variavel de contagem dos pulsos

contpulso++;

void initSerial() {

Serial.begin(115200);

void initWiFi() {

delay(10);

Serial.println("Conectando-se em: " + String(SSID));

WiFi.begin(SSID, PASSWORD);

while (WiFi.status() != WL_CONNECTED) {

delay(100);

Serial.print(".");

Serial.println();

Serial.print("Conectado na Rede " + String(SSID) + " | IP => ");

Serial.println(WiFi.localIP());

void initMQTT() {

mqtt.setServer(BROKER_MQTT, BROKER_PORT);

mqtt.setCallback(mqtt_callback);

void InitInput(void){
 48

pinMode(D2, INPUT);

attachInterrupt(D2, incpulso, RISING);

Serial.println("\n\nInicio\n\n");

void reconnectMQTT() {

while (!mqtt.connected()) {

Serial.println("Tentando se conectar ao Broker MQTT: " +

String(BROKER_MQTT));

if (mqtt.connect("RodoxTCC")) {

Serial.println("Conectado");

//mqtt.subscribe("RT/Sensor/#");

} else {

Serial.println("Falha ao Reconectar");

Serial.println("Tentando se reconectar em 2 segundos");

delay(2000);

void recconectWiFi() {

while (WiFi.status() != WL_CONNECTED) {

delay(100);

Serial.print(".");

}
 49

Código Fonte Javascript

Código fonte disponível no link:

https://drive.google.com/open?id=1qQmh1cu0i8XCyj2FARS2tv-WuM7dvJmV

var config = {

apiKey: "AIzaSyC8icSxWmIV4QGxSoS-eYEe0qmMDuUlcYk",

authDomain: "hidrometro-iot.firebaseapp.com",

databaseURL: "https://hidrometro-iot.firebaseio.com",

projectId: "hidrometro-iot",

storageBucket: "hidrometro-iot.appspot.com",

messagingSenderId: "69099937572"

};

firebase.initializeApp(config);

var database = firebase.database();

var arrayMes = new Array(12);

arrayMes[0] = "Janeiro";

arrayMes[1] = "Fevereiro";

arrayMes[2] = "Março";

arrayMes[3] = "Abril";

arrayMes[4] = "Maio";

arrayMes[5] = "Junho";
 50

arrayMes[6] = "Julho";

arrayMes[7] = "Agosto";

arrayMes[8] = "Setembro";

arrayMes[9] = "Outubro";

arrayMes[10] = "Novembro";

arrayMes[11] = "Dezembro";

now = new Date;

var consumo_minimo= 44.08;

var vazao_topic = "RT/sensor/vazao";

var litros_topic = "RT/sensor/litros";

var m3_topic = "RT/sensor/m3";

client = new Paho.MQTT.Client("broker.mqttdashboard.com",

8000,"RodoxTCC23");

client.onConnectionLost = onConnectionLost;

client.onMessageArrived = onMessageArrived;

var options = {

onSuccess:onConnect,

onFailure:doFail,

// useSSL: true

client.connect(options);
 51

function onConnect() {

console.log("onConnect");

options = {qos:0, onSuccess:function(context){ console.log("subscribed"); } }

client.subscribe(vazao_topic, options);

client.subscribe(litros_topic, options);

client.subscribe(m3_topic, options);

function doFail(e){

console.log(e);

function onConnectionLost(responseObject) {

if (responseObject.errorCode !== 0) {

console.log("onConnectionLost:"+responseObject.errorMessage);

var contador = 0; // contador para gerar o eixo x do gráfico

var ctx = document.getElementById("vazaoLineChart");

var data = {

labels: [],

datasets: [

{
 52

label: "Vazão",

fillColor: "rgba(151,187,205,0.2)",

strokeColor: "rgba(151,187,205,1)",

pointColor: "rgba(151,187,205,1)",

pointStrokeColor: "#fff",

pointHighlightFill: "#fff",

pointHighlightStroke: "rgba(151,187,205,1)",

data: []

};

var option = {

showLines: true

};

var myLineChart = Chart.Line(ctx,{

data:data,

options:option

});

var contador_tot = 0; // contador para gerar o eixo x do gráfico

var ctx_tot = document.getElementById("totalLineChart");

var data_tot = {
 53

labels: [],

datasets: [

label: "Totalizador",

fillColor: "rgba(151,187,205,0.2)",

strokeColor: "rgba(151,187,205,1)",

pointColor: "rgba(151,187,205,1)",

pointStrokeColor: "#fff",

pointHighlightFill: "#fff",

pointHighlightStroke: "rgba(151,187,205,1)",

data: []

};

var myLineChart_tot = Chart.Line(ctx_tot,{

data:data_tot,

options:option

});

function onMessageArrived(message) {

console.log("onMessageArrived:"+message.payloadString);

console.log(message.destinationName, message.payloadString);
 54

if (message.destinationName == vazao_topic){

var vazao_heading = document.getElementById("currentVazao");

vazao_heading.innerText = message.payloadString;

var number = parseFloat(message.payloadString);

var c = contador++;

if (c > 6) {

contador = 0;

};

adddata(number, c);

} else if (message.destinationName == litros_topic) {

var litros_heading = document.getElementById("currentTotal");

litros_heading.innerText = message.payloadString;

var number_tot = parseFloat(message.payloadString);

var c_tot = contador_tot++;

if (c_tot > 6) {

contador_tot = 0;

};

adddata_tot(number_tot, c_tot);

} else if (message.destinationName == m3_topic) {

var m3_heading = document.getElementById("currentM3");

m3_heading.innerText = message.payloadString;
 55

var valor_heading = document.getElementById("valor_conta1");

var x_2 = valor_conta(message.payloadString);

var x = x_2.toFixed(2);

console.log("valor conta: "+ x);

var real = x.toString();

var exibir = "Valor: R$"+real;

valor_heading.innerText = exibir;

var mes_string = getMesExtenso(now.getMonth()).toString();

document.getElementById("mes1").innerText = mes_string;

salva_consumo(message.payloadString);

function adddata(valor, cont){

myLineChart.data.datasets[0].data[cont] = valor;

myLineChart.data.labels[cont] = " ";

myLineChart.update();

function adddata_tot(valor_tot, cont_tot){

myLineChart_tot.data.datasets[0].data[cont_tot] = valor_tot;

myLineChart_tot.data.labels[cont_tot] = " ";

myLineChart_tot.update();
 56

function valor_conta(calcula_gasto) {

var excedente;

var conta_final;

var mes_c = getMesExtenso(now.getMonth() - 1).toString();

console.log("consultando mes :"+mes_c);

var consumo_mes_anterior = consulta_firebase(mes_c);

console.log("retorno bd :" + consumo_mes_anterior);

var total_gasto = calcula_gasto - consumo_mes_anterior;

if (total_gasto <= 10){

return consumo_minimo;

} else if (total_gasto > 10 && total_gasto <= 20) {

excedente = total_gasto - 10;

conta_final = (excedente*5.05) + consumo_minimo;

return conta_final;

} else if (total_gasto > 20 && total_gasto <= 30) {

excedente = total_gasto - 20;

conta_final = (excedente*6.01) + 94.58;

return conta_final;

} else if (total_gasto > 30 && total_gasto <= 50) {

excedente = total_gasto - 30;

 57

conta_final = (excedente*8.27) + 154.68;

return conta_final;

} else if (total_gasto > 50 && total_gasto <= 90) {

excedente = total_gasto - 50;

conta_final = (excedente*9.80) + 320.08;

return conta_final;

function getMesExtenso(mes){

return this.arrayMes[mes];

var intervalo = window.setInterval(salva_consumo(), 60000);

function salva_consumo(consumo) {

var mes_extenso = getMesExtenso(now.getMonth()).toString();

salva_firebase(mes_extenso,consumo);

console.log("Salvo no Firebase..")

if (consumo == 3) {document.getElementById("alert1").innerText =
"Atenção! 30% do consumo mínimo atingido.";}

if (consumo == 5) {document.getElementById("alert1").innerText =
"Atenção! 50% do consumo mínimo atingido.";}

if (consumo == 7) {document.getElementById("alert1").innerText =
"Atenção! 70% do consumo mínimo atingido.";}
 58

if (consumo == 10) {document.getElementById("alert1").innerText =

"Atenção! 100% do consumo mínimo atingido.";}

document.getElementById("jan").innerText = "Janeiro: " +

consulta_firebase(getMesExtenso(0).toString()) + " M³";

document.getElementById("fev").innerText = "Fevereiro: " +

consulta_firebase(getMesExtenso(1).toString()) + " M³";

document.getElementById("mar").innerText = "Março: " +

consulta_firebase(getMesExtenso(2).toString()) + " M³";

document.getElementById("abr").innerText = "Abril: " +

consulta_firebase(getMesExtenso(3).toString()) + " M³";

document.getElementById("mai").innerText = "Maio: " +

consulta_firebase(getMesExtenso(4).toString()) + " M³";

document.getElementById("jun").innerText = "Junho: " +

consulta_firebase(getMesExtenso(5).toString()) + " M³";

function daysInMonth(month,year) {

var dd = new Date(year, month, 0);

return dd.getDate();

function salva_firebase(mes_consumo, consumo_db) {

firebase.database().ref('Mes/' + mes_consumo).set({

consumo_db: consumo_db

});
 59

function consulta_firebase(mes_consulta) {

var consumo_rec;

var ref = firebase.database().ref("Mes/" + mes_consulta);

ref.on('value',function(snapshot){

console.log("bd: " + snapshot.val().consumo_db);

consumo_rec = snapshot.val().consumo_db;

})

if(consumo_rec == null){

return 0;

}else{

return consumo_rec;

console.log("bd2: " + consumo_rec);

}}