Construindo uma ferramenta de monitoramento de plantas com IoT

Criar um aplicativo de Internet das Coisas (IoT) para monitorar uma planta doméstica é um ponto de partida pragmático para aprender sobre dados que mudam com o tempo. É útil para quem adora a ideia de jardinagem interior, mas se esquece de verificar regularmente as suas plantas.

Este projeto é acessível a todos, desde estudantes que trabalham em um projeto de feira de ciências até botânicos que monitoram viveiros de plantas exóticas. Há muitas maneiras de monitorar uma planta de casa, mas esta é a forma de alta tecnologia – com sensores e sistemas de software avançados.

Para este projeto, usaremos o InfluxDB, uma plataforma de série temporal especializada em armazenar dados sequenciais conforme aparecem ao longo do tempo. Isto é útil ao comparar dados, criar alertas para limites específicos e monitorar eventos nos mundos físico e virtual.

A lista completa de suprimentos, um desenho esquemático para sua placa de ensaio (com microcontrolador de sua escolha) e o código-fonte estão disponíveis em meu repositório git se você quiser acompanhar para sua própria edificação ou precisar desesperadamente manter viva uma planta de casa.

A arquitetura

Um sensor IoT rastreia as métricas de saúde da minha planta em intervalos programados. Classificamos os dados coletados como dados de série temporal porque incluem um carimbo de data/hora, que aparece como a primeira coluna no armazenamento. Os sensores IoT geram dados sobre a saúde da planta. Em seguida, uso o Telegraf, um agente de coleta de código aberto, e a biblioteca cliente Python para coletar esses dados e enviá-los para a camada de armazenamento, InfluxDB. A biblioteca gráfica Plotly fornece a visualização de dados. Codifiquei o projeto em Python e ele usa a biblioteca Flask para roteamento.

Começando

Instrumentos:

• Uma planta para monitorar
• Uma partícula de boro ou microcontrolador semelhante
• Pelo menos um sensor IoT para sua planta
• Uma placa de ensaio
• Saltar fios

Eu uso quatro sensores para gerar os cinco pontos de dados a seguir:

• Temperatura do ar
• Umidade
• Luz
• Temperatura do solo
• Umidade do solo

Microcontrolador

Eu uso o microcontrolador Boron e configuro o aparelho através do site da empresa. Para receber dados do próprio microcontrolador, eu o conecto ao meu laptop por meio de um cabo USB. A configuração do microcontrolador depende de qual microcontrolador você selecionou para uso. Seu microcontrolador pode fornecer outras opções de conexão, incluindo Bluetooth ou acesso a pequenos servidores via TCP/IP.

Siga as instruções fornecidas pelo fabricante do seu microcontrolador até receber informações dos seus sensores. Você não precisa entender os dados ainda; apenas certifique-se de que seu microcontrolador esteja enviando dados brutos.

InfluxoDB

Faça login no InfluxDB. Crie um bucket, onde o InfluxDB armazena os dados. Iremos nos conectar ao InfluxDB por meio de uma API. A próxima etapa é criar as credenciais e tokens necessários.

Código

Escrever dados no InfluxDB é simples e começa com a biblioteca cliente. Eu uso a biblioteca cliente Python do InfluxDB para este projeto. O código abaixo é um exemplo de como você pode escrever código para enviar dados brutos dos sensores do seu microcontrolador para o InfluxDB.

def write_to_influx(self,data):
	p = (influxdb_client.Point("sensor_data")
                    	.tag("user",data("user"))
                    	.tag("device_id",data("device"))                     
                    	.field(data("sensor_name"), int(data("value"))
                    	))
	self.write_api.write(bucket=self.cloud_bucket, org=self.cloud_org, record=p)
	print(p, flush=True)

Tag

As medições são o equivalente do InfluxDB às tabelas em um banco de dados relacional. Meu código faz bom uso de tags. As tags não são obrigatórias, mas são úteis porque são metadados que tornam os dados mais fáceis de entender e trabalhar. Neste caso, eles podem especificar diferentes plantas, dispositivos ou qualquer outra coisa dependendo do quão complicado você deseja.

Consultando dados

As consultas retornam tabelas semelhantes à mostrada abaixo.

Antes de poder consultar meus dados, preciso inicializar o cliente Flight SQL.

from flightsql import FlightSQLClient

Seguido pela:

# This is our flight client setup, it’s how we will query from IOX
    	# we need to remove the Https:// from our host
    	host = host.split("://")(1)
    	self.flight_client = FlightSQLClient(host=host,
                     	token=token,
                     	metadata= {'bucket-name': bucket}
        	             )
                        
    	self.cloud_bucket = bucket
    	self.cloud_org = org

Abaixo está uma consulta SQL básica para recuperar dados do InfluxDB.

SELECT {sensor_name}, time FROM sensor_data WHERE time > (NOW() - INTERVAL '2 HOURS') AND device_id='{deviceID}'

Antes de podermos recuperar e ler os dados, temos que convertê-los para o formato Pyarrow. O código abaixo é uma função que inclui a consulta e conexão ao Flight SQL para recuperar os dados.

def querydata(self, sensor_name, deviceID) -> DataFrame:   	
 
        query = self.flight_client.execute(f"SELECT {sensor_name}, time FROM sensor_data WHERE time > (NOW() - INTERVAL '2 HOURS') AND device_id='{deviceID}'")
    	
        # Create reader to consume result
    	reader = self.flight_client.do_get(query.endpoints(0).ticket)
 
    	# Read all data into a pyarrow.Table
    	Table = reader.read_all()
    	print(Table)
 
   	# Convert to Pandas DataFrame
    	df = Table.to_pandas()
    	df = df.sort_values(by="time")
    	print(df)
    	return df

Você pode chamar a consulta anterior e substituir as variáveis ​​por suas seleções, incluindo balde, sensor e dispositivo. O resultado retornado permite representar graficamente os dados recebidos. O return df método extrai nossos dados em um formato de quadro de dados.

Quadros de dados

Pandas DataFrames são estruturas de dados bidimensionais que permitem análise e processamento rápido de dados. Convertemos nossos dados em um DataFrame para facilitar o trabalho em Python. Existem algumas outras opções de saída de dados para escolher se você preferir um estilo diferente.

@app.callback(Output("store", "data"), (Input("button", "n_clicks")))
def generate_graphs(n):
# Generate graphs based upon pandas data frame. 
    df = influx.querydata( "soil_temperature", graph_default("deviceID") )
    soil_temp_graph = px.line(df, x="time", y="soil_temperature", title="Soil Temperature")
 
    df = influx.querydata( "air_temperature", graph_default("deviceID") )
    air_temp_graph= px.line(df, x="time", y="air_temperature", title="Air Temperature")
 
    df = influx.querydata( "humidity", graph_default("deviceID") )
    humidity_graph= px.line(df, x="time", y="humidity", title="humidity")
 
    df = influx.querydata( "soil_moisture", graph_default("deviceID") )
    soil_moisture= px.line(df, x="time", y="soil_moisture", title="Soil Moisture")
 
    df = influx.querydata( "light", graph_default("deviceID") )
    light_graph= px.line(df, x="time", y="light", title="light")

A biblioteca gráfica espera que você retorne um quadro de dados para visualização. Este é o resultado final da consulta dos pontos de dados. As imagens abaixo são gráficos codificados que ilustram os pontos de dados. Guias diferentes exibem gráficos diferentes e rastreiam métricas separadas. Esta é apenas uma pequena parte das capacidades do projeto.

Conclusão

Confira minha apresentação centrada no Plant Buddy para uma discussão mais aprofundada sobre este projeto e o ecossistema InfluxDB em geral. Nossa página da comunidade tem outros ótimos exemplos de projetos interessantes. Agora comece com o InfluxDB e crie algo legal!

A postagem Construindo uma ferramenta de monitoramento de planta com IoT apareceu pela primeira vez em The New Stack.