Monitoramento de água com IoT - Parte 3

monitoramento de água
Este post faz parte da série Monitoramento de água com IoT. Leia também os outros posts da série:

Esta é a terceira parte da série de artigos que descrevem um projeto de monitoramento de água usando IoT. A série é composta de três artigos, sendo eles: 

  1. Parte 1 - objetiva introduzir o leitor ao que o projeto consiste e em como configurar a comunicação ZigBEE utilizada no projeto;
  2. Parte 2 - visa apresentar a parte bare-metal da solução, com explicações detalhadas do código e conceitos e estratégias de desenvolvimento;
  3. Parte 3 - parte final da série, destinada a explicar em detalhes a parte de Linux Embarcado do projeto e interação com usuário via Internet (aqui o conceito de IoT é dominante).

 

Este artigo tornou-se viável graças ao apoio da Eletrogate, a qual forneceu o sensor de fluxo de água utilizado no projeto.

 

 

Pré-requisitos

 

Devido à multidisciplinaridade deste projeto, para uma boa compreensão dos conteúdos desta série de artigos são desejados os seguintes pré-requisitos: 

  • Conhecimento básico de Linux Embarcado;
  • Conhecimento de linguagem de programação C;
  • Conhecimento de linguagem de programação Python;
  • Conhecimentos de MQTT (recomendo fortemente a leitura do artigo MQTT e Intel Edison);
  • Conhecimento em desenvolvimento de sistemas embarcados bare-metal (ter noção das principais técnicas e conceitos deste tipo de sistema, tais como: interrupções externas, timers, comunicação serial por interrupção, watchdog timer, etc.).

 

 

Sistema Linux Embarcado do projeto

 

Nesta terceira e última parte da série de artigos, mostramos a parte da solução que usa Linux Embarcado (Intel Edison). Este sistema consiste em um sistema rodando em Linux Embarcado, sendo este responsável por interfacear o usuário final com as medições obtidas na placa com sistema bare-metal, além de acrescentar funcionalidades de alto nível (serão melhor explicadas com o decorrer deste artigo).

 

Além disso, esta parte do sistema se comunica via MQTT com uma página web, sendo esta a interface com usuário final.

 

Em diagrama, esta parte do sistema pode ser descrita conforme a figura 1.

 

monitoramento de água: sistema com linux embarcado
Figura 1 - Diagrama do sistema Linux embarcado do projeto.

 

As funcionalidades deste sistema são: 

  • Solicitar consumo acumulado e vazão instantânea ao sistema bare-metal;
  • Solicitar versão do firmware do sistema bare-metal;
  • Resetar/zerar consumo acumulado total. Deste modo pode-se medir o consumo acumulado a partir do momento que o usuário desejar;
  • Estabelecer um limite de consumo de água. Se o limite for excedido, um e-mail é enviado ao usuário avisando da situação. Além disso, na interface com o usuário, haverá um aviso que o limite de consumo foi atingido.

 

Todas as interações com o usuário ocorrerão através de um site / tela no browser, sendo que os dados enviados e recebidos para o sistema utilizarão MQTT (veja este artigo para mais detalhes sobre MQTT).

 

 

O que será utilizado para compor o sistema Linux Embarcado?

 

Os recursos utilizados para compor este sistema estão descritos abaixo: 

 

Recursos de hardware

 

O hardware deste sistema consiste em um Intel Edison, uma placa expansora de I/O Arduino Breakout Board e um dongle ZigBEE ligado à porta USB Host da placa expansora.

 

 

A Intel Edison consiste em um sistema poderoso, capaz de rodar um sistema operacional Linux (de fábrica, já vem com uma distribuição baseada em Yocto instalada). Possui um hardware muito interessante para suas dimensões físicas (próximas às dimensões de um SD Card) e conectividade WiFi e Bluetooth embutidas, sendo assim uma solução muito boa para sistemas IoT e sistemas stand-alone (sobretudo pelo fato de não possuir interface gráfica, o que significa que o consumo é muito baixo em relação a uma Rapiberry Pi, por exemplo).  Mais informações sobre a Intel Edison podem ser obtidas neste artigo aqui.

 

 

Tal sistema possui conectividade Wi-Fi com a internet. Além disso, uma fotne 5V / 1,5A é utilizada para alimentar todo o sistema Linux Embarcado.

 

Recursos de software

 

O software do sistema é feito totalmente em Python, dada a maior facilidade de entender o código-fonte final (em relação a um feito em C puro, por exemplo).

 

 

Preparando a Intel Edison

 

Antes de prosseguirmos com o desenvolvimento do sistema em si, precisamos preparar a Intel Edison para se comunicar serialmente com o dongle ZigBEE. Este dongle utiliza um chip FTDI, logo é necessário instalar o driver dele na Intel Edison. Para isto, seguir os passos abaixo:

 

  1. Certificar-se que a Intel Edison está conectada à internet. Caso estiver utilizando o Wi-Fi do próprio Intel Edison para isto, esta verificação pode ser feita com o seguinte comando:
    ifconfig
  2. Serão exibidas todas as ionterfaces de comunicação da Intel Edison, assim se na interface wlan0 estiver um IP associado, a Intel Edison está corretamente conectada à internet;
  3. A configuração do repositório de pacotes conforme este artigo instrui;
  4. Atualizar a lista de pacotes disponíveis com o seguinte comando:
    opkg update
    
  5. Instalar o driver do chip FTDI com o comando:
    opkg install kernel-module-ftdi-sio

     

Após feito isso, coloque na USB Host da Arduino Breakboard o dongle ZigBEE. Aguarde alguns segundos e execute o comando abaixo: 

 

dmesg | grep tty

 

Este comando mostra todas as interfaces seriais disponíveis. Deverá aparecer uma entrada serial (no meu caso /dev/ttyUSB0) para o chip FTDI.

 

Além disso, é necessário baixar o pyserial (biblioteca Python para lidar com serial). Para isso, Primeiro baixe o pyserial com o seguinte comando: 

 

wget https://pypi.python.org/packages/source/p/pyserial/pyserial-2.7.tar.gz#md5=794506184df83ef2290de0d18803dd11 --no-check-certificate

 

Descomprima o arquivo baixado com o seguinte comando:

 

tar xvf pyserial-2.7.tar.gz

 

E, por fim, execute os comandos a seguir para instalar o pyserial:

 

cd pyserial-2.7
python setup.py install

 

 

Observações gerais sobre a comunicação com sistema bare-metal

 

Segue abaixo algumas observações gerais sobre a comunicação com o sistema bare-metal: 

  1. Dada a chance de o comando enviado não chegar ao sistema bare-metal (dados corrompidos / perda de integridade dos dados, interferência, etc.), são feitas tentativas seguidas de envio do comando (até o sistema bare-metal responder corretamente, ou seja, o checksum dos dados recebidos coincidir com o calculado, garantindo assim a integridade dos dados recebidos);
  2. Cada tentativa de envio do comando tem um timeout de 1 segundo;
  3. Não há fila de transmissão e recepção.

 

 

Código-fonte

 

O script Python pode ser divido em duas partes distintas: contínua e sob demanda. A parte contínua roda "sem parar" (enquanto o script Python estiver em execução), enquanto a parte sob demanda responde a comandos enviados via MQTT da página de monitoramento.

 

A parte contínua faz a leitura das informações de vazão, consumo acumulado e versão de firmware do sistema bare-metal de cinco em cinco segundos (em outras palavras, consiste no laço principal).

 

Após a leitura, estes dados são enviados via MQTT para a página de monitoramento. Além destes dados, são enviados também a meta estabelecida de consumo e o status do consumo (se excedeu a meta de consumo de água ou não) e esta parte também é a responsável por enviar o e-mail de aviso ao usuário caso o consumo acumulado de água exceder a meta estipulada. 

 

A parte sob demanda é responsável por responder comandos MQTT recebidos da página de monitoração. Seguem esses comandos: 

  • Reset de consumo acumulado;
  • Início de calibração;
  • Finalização de calibração;
  • Requisição de informações (vazão, consumo acumulado e versão de firmware do sistema bare-metal, meta configurada e status de consumo de água);
  • Envio de meta de consumo de água e e-mail para avisar usuário em caso de a meta ser excedida.*

 

*Neste caso, ambos os dados são gravados em arquivos texto na Intel Edison. 

 

Será necessário ter uma conta de e-mail YahooMail, pois foi o único e-mail grátis que não barrou e-mail disparado pelo Python (não consegui fazer o mesmo com o GMail). Portanto, crie uma conta no YahooMail e preencha os dados de login e senha no código antes de rodar o script.

  

Abaixo, segue o código-fonte completo:

 

"Sistema de monitoramento de agua com IoT (parte Linux Embarcado)"


__author__ = 'Pedro Bertoleti <[email protected]>'
__copyright__ = 'Copyright (C) 2011 Pedro Bertoleti'
__version__ = '0.1'
__date__ = 'Sep 2015'
__license__ = 'MIT'



import sys
import time
try:
  import paho.mqtt.client as mqtt
  import mraa
  import serial
  import smtplib
  from binascii import hexlify
except ImportError, mod:
  print "%s not found" % (mod)
  sys.exit(7)

 
TempoEntreLeituraSensores = 5  #Tempo (em segundos) entre duas leituras de sensores
TimeoutConexao = 5  #Timeout da conexao com broker
TopicoSubscriber = "MQTTAguaIOTEnvia"   #topico usado para receber dados do websocket 
TopicoPublisher = "MQTTAguaIOTRecebe"   #topico usado para enviar dados do websocket
EmailConsumoJaFoiEnviado = 0 #variavel de controle do envio de e-mail (alerta que a meta de consumo de agua foi excedida)
EstaEmCalibracao = 0   #variavel que indica se a placa esta em modo de calibracao


def CalculaChecksum(BytesRecebidos):
  """
     Funcao: Calcula checksum da mensagem recebida
     parametros: array de bytes a ser calculado checksum
     retorno: resposta do comando
  """
  CheckSumCalculado = 0    
  SomaCks = sum(BytesRecebidos)        
  CheckSumCalculado = ((~SomaCks) + 1)&0xFF
  return   CheckSumCalculado 

def EnviaComandoSerial(ComandoASerEnviado, OpcodeResposta):
  """
     Funcao: Envia requisicao ate receber resposta
     parametros: Comando a ser enviado (string) e opcode que deve estar presente na resposta
     retorno: resposta do comando
  """
	
	comando_bytes = ComandoASerEnviado.decode("hex")
	RecebeuResposta=0
		
	#tenta finalizar a calibracao ate conseguir. As tentativas sao feitas em intervalos de 1 segundo.
	while RecebeuResposta == 0:
		usart.write(comando_bytes)
		dados_lidos = usart.readline()
		
		#se ha o opcode esperado na resposta, trata-se de uma mensagem valida
		if (OpcodeResposta in dados_lidos):
			#obtem checksum recebido e tamanho recebido
			CksRecebidoStr = dados_lidos[3]
			HexCksRecebido = hexlify(CksRecebidoStr)
			CksRecebido = int (HexCksRecebido,16)
			TamanhoString = dados_lidos[2]
			hex = hexlify(TamanhoString)
			TamInt = int(hex, 16)
			DadosLidosBytes = bytearray()
			DadosLidosBytes.extend(dados_lidos[4:4+TamInt])		
		
			#verificacao do checksum	
			if (CalculaChecksum(DadosLidosBytes) == CksRecebido):
				RecebeuResposta = 1
				print "- Checksum do comando de opcode ",dados_lidos[1]," esta OK!"
			else:
				print "- Checksum Recebido: ",repr(CksRecebido)," Cks Calculado: ",CalculaChecksum(DadosLidosBytes)," Opcode: ",dados_lidos[1]
		
	return dados_lidos
	
def EnviaEmailAvisoMetaAtingida():    
  """
     Funcao: envia e-mail de aviso de meta de consumo atingido
     parametros: Meta configurada
     retorno: nenhum
  """	
	global EmailConsumoJaFoiEnviado

	if (EmailConsumoJaFoiEnviado == 1):   #se o e-mail ja foi enviado, nada eh feito
		return 0

	#gravacao do e-mail em arquivo-texto externo
	arqEmail = open('email.txt', 'r')
	destinatario = arqEmail.readline()
	arqEmail.close()		
		
	#informacoes referentes ao e-mail	
	
	#IMPORTANTE: descomentar a linha abaixo e inserir o e-mail remetente desejado
	#remetente = ''	
	
	mensagem = "Aviso do sistema de monitoramento de Agua com IoT: seu consumo de agua excedeu a meta estabelecida. Consulte sua pagina de monitoramento."
	
	#IMPORTANTE: descomentar as linhas abaixo e inserir os dados de sua conta YahooMail
	#login = ''
	#senha = ''

	#envio do e-mail
	server = smtplib.SMTP('smtp.mail.yahoo.com', 587)
	server.starttls()
	server.login(login,senha)
	server.sendmail(remetente, destinatario, mensagem)
	server.quit()
	
	#sinlaiza que e-mail (alerta que a meta de consumo de agua foi excedida) ja foi enviado
	EmailConsumoJaFoiEnviado = 1

def LeMetaGravada():   
  """
     Funcao: le a meta gravada no arquivo externo
     parametros: nenhum
     retorno: meta lida do arquivo externo
  """ 
	MetaLida=0
	
	try:
		#leitura (do arquivo texto) da meta estabelecida) e conversao do dado lido para float
		arqMeta = open('meta.txt', 'r')
		MetaLida = float(arqMeta.readline())
		arqMeta.close()		
	except  IOError:
		print "- Falha ao ler arquivo de meta"
	
	return MetaLida

def VerificaSeAtingiuMeta(ConsumoLido,MetaDeConsumo):    
  """
     Funcao: verifica se a meta de consumo foi atingida e, se sim, dispara um e-mail ao usuario
     parametros: consumo lido
     retorno: "ok" - consumo acumulado abaixo da meta estabelecida
			  "naook" - consumo acumulado acima da meta estabelecida
  """ 	
	StatusMeta="ok"
	
	try:
		ValorConsumoLido = float(ConsumoLido) 		

		print "Consumo usado na comparacao: ",repr(ConsumoLido)
		
		print "Meta lida: ",str(MetaDeConsumo)
		print "Consumo lido: ",ConsumoLido
		
		#verifica se consumo excedeu a meta
		if (ValorConsumoLido > MetaDeConsumo):
			StatusMeta="naook"
			
			#se a meta de consumo foi excedida, envia e-mail alertando o usuario
			EnviaEmailAvisoMetaAtingida()
	except  IOError:
		print "- Falha ao ler arquivo de meta"
	except ValueError:
		print "- Problemas ao converter leitura do consumo em float. Bytes recebidos: ",repr(ConsumoLido)
	
	return StatusMeta

	
def GravaEmailEMeta(EmailRecebido, MetaRecebida):
  """
     Funcao: grava em um arquivo texto o e-mail e meta informados
     parametros: email e meta informados pela pagina de monitoramento
     retorno: nenhum
  """ 
	try:
		#gravacao do e-mail em arquivo-texto externo
		arqEmail = open('email.txt', 'w')
		arqEmail.write(EmailRecebido)
		arqEmail.close()
		
		print "- Arquivo de e-mail gravado com sucesso"
		
		#gravacao da meta em arquivo-texto externo
		arqMeta = open('meta.txt', 'w')
		arqMeta.write(MetaRecebida)
		arqMeta.close()
		
		print "- Arquivo de meta gravado com sucesso"
	except  IOError:
		print "- Falha ao gravar email e meta"


def EnviaInformacoes():
  """
     Funcao: requisita informacoes ao sistema bare-metal e as envia, por mqtt, a pagina de monitoramento
     parametros: nenhum
     retorno: nenhum
  """ 
	global EstaEmCalibracao

	#se esta em modo de calibracao, nao ha porque solicitar informacoes da placa.
	if (EstaEmCalibracao == 1):
		return 0

	#requisita versao de firmware	
	#tenta ler a versao do firmware ate conseguir. As leituras sao feitas em intervalos de 1 segundo.
	dados_lidos = EnviaComandoSerial("02510000","Q")
	
	#String da versao
	VersaoString = dados_lidos[4:9]
	
	#requisita consumo acumulado
	#tenta ler o consumo acumulado ate conseguir. As leituras sao feitas em intervalos de 1 segundo.
	dados_lidos = EnviaComandoSerial("024C0000","L")
	
	#String do consumo acumulado
	ConsumoAcumuladoString = dados_lidos[4:11]
	
	#requisita vazao instantanea
	#tenta ler a vazao instantanea ate conseguir. As leituras sao feitas em intervalos de 1 segundo.
	dados_lidos = EnviaComandoSerial("02560000","V")
	
	#String da vazao instantanea
	VazaoString = dados_lidos[4:11]

	#envia as informacoes via MQTT	
	MetaConfigurada = LeMetaGravada()

	#verifica se meta de consumo foi atingida / excedida	
	StatusMeta = VerificaSeAtingiuMeta(ConsumoAcumuladoString,MetaConfigurada)
	
	#envia para a pagina de monitoramento, por MQTT, as informacoes obtidas do sistema bare-metal
	client.publish(TopicoPublisher, VersaoString+">"+ConsumoAcumuladoString+">"+VazaoString+">"+str(MetaConfigurada)+">"+StatusMeta)


def on_connect(client, userdata, flags, rc):
  """
     Callback  - chamada quando a conexao eh estabelecida
  """ 
    print("Conectado ao broker. Retorno da conexao: "+str(rc))
 
    # Informa que o topico que este subscriber ira escutar
    client.subscribe(TopicoSubscriber)

	
def on_message(client, userdata, msg):
  """
     Callback - chamado quando alguma mensagem eh recebida
	 Corresponde a parte do sistema que opera sob demanda.
  """ 
	global EmailConsumoJaFoiEnviado
	global EstaEmCalibracao

	#escreve na tela a mensagem recebida
	print("Topico: "+msg.topic+" - Mensagem recebida: "+str(msg.payload)) 
	
	#recebeu comando para resetar consumo acumulado
	if (str(msg.payload) == "ResetConsumo"):
		#tenta resetar / zerar o consumo acumulado ate conseguir. As tentativas sao feitas em intervalos de 1 segundo.
		dados_lidos = EnviaComandoSerial("02520000","R")	
				
		#reinicia variavel que controla envio do email (alerta que a meta de consumo de agua foi excedida)
		EmailConsumoJaFoiEnviado = 0
		
		#le e envia informacoes do sistema bare-metal por MQTT para pagina de monitoramento
		EnviaInformacoes()
		return 0
		
	if (str(msg.payload) == "IniciaCalibracao"):
		#tenta iniciar a calibracao ate conseguir. As tentativas sao feitas em intervalos de 1 segundo.
		dados_lidos = EnviaComandoSerial("02450000","E")
		EstaEmCalibracao = 1
		print "--- Entrada no modo de calibracao ---"
		return 0
		
	if (str(msg.payload) == "FinalizaCalibracao"):
		#tenta finalizar a calibracao ate conseguir. As tentativas sao feitas em intervalos de 1 segundo.
		dados_lidos = EnviaComandoSerial("02530000","S")
		EstaEmCalibracao = 0
		print "--- Saida do modo de calibracao ---"
		EnviaInformacoes()
		return 0
	
    	
	if (str(msg.payload) == "RequisitaInformacoes"):
		#le e envia informacoes do sistema bare-metal por MQTT para pagina de monitoramento
		EnviaInformacoes()
		return 0
	
	if ("EnviaConfigsMeta" in str(msg.payload)):
		#meta de consumo e agua e e-mail para aviso foram recebidos. Sera feita a gravacao dos mesmos em arquivos-texto externos
		DadosConfigs = str(msg.payload).split(">")
		GravaEmailEMeta(DadosConfigs[2], DadosConfigs[1])
		
		#reinicia variavel que controla envio do email (alerta que a meta de consumo de agua foi excedida)
		EmailConsumoJaFoiEnviado = 0




if __name__ == '__main__':

  #---------------------------		
  #   Programa principal
  #---------------------------

  #configuracao da serial (FTDI): 9600 bauds, 8 bits, sem paridade e 1 stop-bit
 
  try:
      port = "/dev/ttyUSB0"   
      usart = serial.Serial (port,9600,serial.EIGHTBITS,serial.PARITY_NONE,serial.STOPBITS_ONE, 1)
  except serial.SerialException as e:
      print("Falha ao abrir porta serial '{0}'".format(e))
      sys.exit(9)

  client = mqtt.Client()
  client.on_connect = on_connect   #configura callback (de quando eh estabelecida a conexao)
  client.on_message = on_message   #configura callback (de quando eh recebida uma mensagem)
 
  # tenta se conectar ao broker na porta 1883 (o parametro '60' eh o tempo de keepalive). 
  # Nesse caso, se   nenhuma mensagem for trafegada em ate 60 segundos, eh enviado um ping ao 
  # broker de tempos em tempos (para manter a conexao ativa)
  client.connect("test.mosquitto.org", 1883, 60)  

  #loop infinito. Gerencia conexao periodicamente e executa demais tarefas necessarias
  StatusConexaoBroker=0
  TempoInicialSegundos=int(time.time())
  TempoAtualSegundos=0


  #-------------------------------------------------------------------------
  #   Laco principal do sistema. Corresponde a parte continua do sistema
  #-------------------------------------------------------------------------
  while True:
	  StatusConexaoBroker = client.loop(TimeoutConexao)

	  if (StatusConexaoBroker > 0):
		  client.connect("test.mosquitto.org", 1883, 60)  #se ocorrer algum erro, reconecta-se ao broker
  
	  TempoAtualSegundos = int(time.time())
	
	  #verifica se chegou o momento de executar o envio das informacoes para a pagina de monitoramento
	  if ((TempoAtualSegundos-TempoInicialSegundos) > TempoEntreLeituraSensores):
		  #reinicia a contagem de tempo
		  TempoInicialSegundos = TempoAtualSegundos
		
		  #le e envia informacoes do sistema bare-metal por MQTT para pagina de monitoramento
		  EnviaInformacoes()

 

Ou, se preferir, baixe o arquivo com o script Python clicando aqui.

 

 

Execução do script Python

 

Durante a execução, no terminal de dados conectado à Intel Edison (via USB-Serial ou SSH) serão escritas algumas informações gerais da comunicação: recepção de dados solicitados da placa bare-metal (incluindo se o checksum "bateu" ou não, para se ter uma noção da qualidade da comunicação sem fio), leitura da meta configurada e alertas de entrada e saída do modo de calibração.

 

O script Python pode ser executado da forma clássica (comando: python AguaIOT.py). Porém, para uma aplicação embarcada que deve ser alimentada e sair funcionando, seria muito útil a execução automática do script ao inicializar a placa, não é mesmo?

 

Para isso, basta seguir um tutorial clicando aqui

 

 

Inteface Web para monitoramento de água

 

O código-fonte completo da interface Web pode ser baixado clicando aqui.

 

Esta consiste de um site simples, com alguns arquivos .js e imagens (ou seja, pode ser hospedado em qualquer servidor grátis por aí ou, até mesmo, rodar na sua própria máquina). Este se comunica via MQTT com um broker, assim como a Intel Edison. Deste modo, a Intel Edison e a página Web podem estabelecer comunicação. E o melhor: esta página roda em tablet, PC e smartphone, independente da "religião" (fãs das maçãs, robozinhos verdes e janelas agradecem)! Enfim, qualquer coisa que tenha um navegador com suporte a JavaScript consegue acessar. Em suma, trata-se de uma interface de usuário realmente portável.

 

Na figura 2 pode-se ver a tela de interface com usuário.

 

monitoramento de água: sistema web com IoT
Figura 2 - Screenshot do sistema web de monitoramento de água.

 

Este sistema pode ser acessado online também. Para isto, clique aqui.

 

 

Vídeo - Sistema completo

 

Um vídeo do sistema completo funcionando pode ser visto abaixo:

 

 

 

The end of the beginning - Considerações finais e possibilidades de expansão

 

Este sistema foi construído com o intuito de monitoramento inteligente de água utilizando conceitos de IoT, porém isto não pára por aqui.

 

Conforme a arquitetura de comunicação entre Intel Edison e sistema-bare metal adotado, sobretudo a topologia de comunicação (em estrela), com poucas modificações (no protocolo de comunicação) é possível colocar mais módulos sendo lidos. Logo, é possível controlar periféricos ou ler o consumo de energia remotamente, via Internet, adicionando um módulo/sistema bare-metal para cada funcionalidade extra. Portanto, eu gostaria muito que este projeto servisse de base para projetos maiores, com mais medições e controles via IoT sendo usados. Afinal, tudo evolui, certo?

 

Como sugestões de implementações futuras / sistemas bare-metal a serem acoplados no sistema, seguem: 

  • Medição de consumo de energia elétrica;
  • Controle on/off e monitoramento de cargas (lâmpadas, irrigadores, eletrodomésticos, etc.);
  • Monitoramento de temperatura em diferentes ambientes;
  • Monitoramento de poluição sonora em diferentes ambientes;
  • Monitoramento de consumo de água em vários locais diferentes de uma mesma planta, como o caso de um hotel, por exemplo;
  • Monitoramento de consumo de água potável em bebedouros (para fins de se ter uma média de consumo de água por período ou por consumidor);
  • ...E por aí vai!

 

Ou seja, este é o fim desta série, mas espero que não seja o fim de projetos utilizando os conceitos e sistemas aqui apresentados.

 

 

Agradecimentos

 

Sobre a realização desta parte do projeto, eu gostaria de agradecer ao Cleiton Bueno pela ajuda nas dúvidas e melhorias no script em Python construído.

Outros artigos da série

<< Monitoramento de água com IoT - Parte 2
Este post faz da série Monitoramento de água com IoT. Leia também os outros posts da série:
NEWSLETTER

Receba os melhores conteúdos sobre sistemas eletrônicos embarcados, dicas, tutoriais e promoções.

Obrigado! Sua inscrição foi um sucesso.

Ops, algo deu errado. Por favor tente novamente.

Licença Creative Commons Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Pedro Bertoleti
Sou engenheiro eletricista formado pela Faculdade de Engenharia de Guaratinguetá (FEG - UNESP) e trabalho com Android embarcado em Campinas-SP. Curioso e viciado em tecnologia, sempre busco me aprimorar na área de sistemas embarcados (modalidades bare-metal, RTOS, Linux embarcado e Android embarcado).Para mais informações, acesse minha página no Facebook:https://www.facebook.com/pbertoleti

4
Deixe um comentário

avatar
 
3 Comment threads
1 Thread replies
0 Followers
 
Most reacted comment
Hottest comment thread
3 Comment authors
Matheus Schlosser BassophfbertoletiJoão Victor Paulo SilvaMONITORAMENTO DE ÁGUA VIA INTERNET « Revista In The Mine Recent comment authors
  Notificações  
recentes antigos mais votados
Notificar
Matheus Schlosser Basso
Visitante
Matheus

Olá! Gostaria de saber se o dongle zigbee é compatível com a minibreakout board se eu usar um conversor usb -> microusb

João Victor Paulo Silva
Visitante
João Victor Paulo Silva

Parabéns novamente pelo artigo, pretendo implementar a mesma solução porém utilizando ESP8266 e Raspbery. Esse artigo ajudou a esclarecer diversas dúvidas e ter algumas idéias e com certeza deverá aparecer nas referências do projeto.

phfbertoleti
Visitante
phfbertoleti

João, muito obrigado!

Fico feliz que você curtiu a série e que irá utilizar os conceitos aqui apresentados. É gratificante saber que este projeto pode inspirar outros!