Irrigações Automatizadas Com Web Service Utilizando Python: 5 etapas (com fotos)

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

Neste projeto desenvolveremos um sistema de monitoramento para plantações, que irá obter dados de umidade relativa do ar, pressão atmosférica, temperatura do ar, incidência de UV, velocidade do vento e condição da planta (seca / molhada). Alguns dados são obtidos localmente, enquanto outros são obtidos por meio de um Web Service conectado a uma estação meteorológica (No caso, estamos utilizando a Faculdade de Engenharia de Sorocaba). Após adquiridos, os dados serão disponibilizados em uma aplicação web baseada em ThingSpeak.

Etapa 1: Hardware Utilizado

Foi usado para a construção deste projeto:

1x Qualcomm Dragonboard 410c

1x Grove Seeed Sensor Mezzanine

1x sensor de água observada

1x IMU 10OF Grove Sensor v1.0

1x Sensor Sunlight Grove v1.0

1x mouse USB

1x teclado USB

1x monitor

1x cabo HDMI

1x Adaptador HDMI-VGA

Acesso à dados da estação meteorológica FACENS

Etapa 2: Montagem Do Hardware

Após conectar a placa Sensor Mezzanine à dragonboard, execute uma ligação de acordo com o esquemático anterior, sendo:

1: Conexão direta entre o sensor Groove Sunlight v1.0.

2: + 5V conectado ao Vcc do IMU-10DOF.

3: + 5V e Gnd conectados aos pinos correspondentes do sensor de água.

4: GND IMU-10DOF.

5: SDA / SCL conectado ao pino correspondente do IMU-10.

6: Pino Sig do Sensor de água conectado ao pino 2.

Etapa 3: Firmware Atmega328

Através de Sensors Mezzanine, é possível acessar um microcontrolador Atmega328, o mesmo usado em plataformas Arduíno, e programá-lo diretamente, utilizando um IDE Arduíno instalado no DragonBoard. Vale ressaltar que um Mezanino e um DragonBoard em conjunto possuem todos os periféricos transitados para a programação e gravação do firmware no microcontrolador.

O firmware embarcado é responsável por realizar as leituras dos sensores, gerenciando os protocolos de comunicação e operação dos mesmos, e após a aquisição dos dados, o encaminhamento via porta serial para um DragonBoard.

* Pode ser necessário incluir as bibliotecas utilizadas no firmware. Elas podem ser encontradas em:

imu-10DOF

Sensor de luz solar

O firmware utilizado pode ser encontrado aqui ou aqui:

Etapa 4: Programação Em Python

Para o programa criado, foram examinadas as seguintes importações: 'urllib2', 'json', 'time', 'serial', 'paho.mqtt.publish', 'psutil' e 'decimal'. Foram definidas duas funções ('comJSON' e 'semJSON') que serão explicadas mais tarde.

import urllib2, json #para pegar os dados da estaçãoimportar tempo #para o time.sleep () import serial #para o Arduino import paho.mqtt.publish as publish #para publicar import psutil #para configurar o url import decimal #para converter

O primeiro passo é gravar em uma variável o endereço de onde será aproveitado os dados da Estação Meteorológica (no caso estamos gravando na variável 'url'). Em seguida, inicializamos duas variáveis ('i' e 'j'), utilizando 'i' para pegar os dados mais atuais do Array que receberá receber via JSON (como a posição mais recente da Array será a 49, inicializamos 'i' como 49) e 'j' para contar quantas vezes o código já rodou.

url = "https://www.fieldclimate.com/api/CIDIStationData/GetLast?user_name=facens&user_passw=clima&station_name=002035C0" #Define o URL da estação

i = 49 #Para pegar os dados mais atuais da estação

j = 0 #Passo do programa

Entrando no 'while (1)', inicializamos a variável 'jsonurl' como 'None'. Esta variável irá abrir um URL JSON, portanto ao inicializarmos ela no início do 'while', estamos então resetando ela toda vez que repetir o loop. O próximo passo é abrir o URL usando uma função 'urllib2.urlopen (url)', podendo também adicionar um argumento 'timeout = X', sendo X uma quantidade em segundos limite para o URL ser aberto. Se o programa conseguir abrir uma URL dentro do tempo do timeout, o programa irá realizar uma função 'comJSON' mencionada anteriormente. Caso não consiga abrir um URL no tempo estipulado, realiza-se a função 'semJSON'. Ambos as funções são muito parecidas, tendo como diferença os dados da estação ('comJSON' irá mostrar e enviar os dados da estação, enquanto 'semJSON' não). Como 'semJSON' é uma função derivada de 'comJSON'. Iremos explicar somente a 'comJSON'

while (1): jsonurl = Nenhum #Inicializa a varivavel como Nenhum print 'Passo:', j print 'Atualizando dados' try: jsonurl = urllib2.urlopen (url, timeout = 5) #tenta abrir o url em no máximo 5 if jsonurl não for None: print 'Dados técnicos' comJSON (jsonurl) #Se conseguiu abrir o URL, mostra todos os dados exceto: if jsonurl is None: print 'Erro ao atualizar dados' semJSON () #Se não abriu o URL, mostra os dados capturados localmente (do Arduino) pass j + = 1 print '---------------------------------- -------------------------------------------------- -------------------------------------------- / n 'time.sleep (1)

Na primeira linha da função 'comJSON', recebemos todos os dados da URL já aberto numa variável 'dados'. Esta irá receber um objeto com duas matrizes, das quais iremos usar somente uma ('ReturnDataSet'). Realizada esta operação, será então inicializar o Serial do Arduíno e ler as linhas (readline ()) que o Arduíno está imprimindo e jogando como Strings convertidas dentro de variáveis e, então, mostrando esses dados na tela. Recebidos os dados do Arduíno, receberemos os dados da estação, simplesmente acessando os sensores específicos dentro do objeto 'dados' (por exemplo '[' ReturnDataSet '] [' sens_aver_6_5] ') e então mostramos estes novos dados na tela também.

def comJSON (jsonurl): #envia todos os dados dados = json.loads (jsonurl.read ()) #carrega os dados JSON da página já aberta #Arduino ard = serial. Serial ('/ dev / tty96B0', 115200) # inicializa uma variável que receberá os dados do Arduíno #Recebe os dados do Arduíno ardAgua = int (ard.readline (). rstrip ()) ardTemp = float (ard.readline (). rstrip ()) ardPres = int (ard.readline ().rstrip ()) ardUV = float (ard.readline (). rstrip ())

imprimir "\ nArduino"

if ardAgua == 1: imprimir 'Molhado' else: imprimir 'Seco' imprimir 'Temperatura:', ardTemp, '* C' imprimir 'Pressao:', ardPres, 'Pa' imprimir 'Ultra-Violeta:', ardUV, ' lx '

#Estacao

print '\ nJSON' print 'URL:', jsonurl #Recebe os dados da estação data = dados ['ReturnDataSet'] ['f_date'] vel_vento = dados ['ReturnDataSet'] ['sens_aver_6_5'] umidade = dados ['ReturnDataSet'] ['sens_aver_19_507']

imprimir 'Dados:', dados

imprimir 'Velocidade do Vento:', vel_vento, 'm / s' imprimir 'Umidade do ar:', umidade, '%'

#Converte

vel_vento = decimal. Decimal (vel_vento.rstrip ()) umidade = decimal. Decimal (umidade.rstrip ())

O próximo passo é enviar todos esses dados coletados. Para isso, precisamos colocar um ID do canal, uma Chave de Escrita e o Host em variáveis, além de configurar o useUnsecuredTCP, useUnsecuredWebsockets e useSSLWebsockets (neutro, falso, falso). Criamos mais uma variável que irá guardar o 'caminho' para o canal, e uma outra para guardar, em String, o que será enviado para o servidor (com todas as variáveis convertidas) e então tentar publicar os dados no servidor usando 'publicar. único (tópico, carga útil = tPayload, nome do host = mqttHost, porta = tPort, tls = tTLS, transporte = tTransport) '. A função então acaba e retorna para o principal do loop.

#Envia channelID = "344243" #Canal criado para o grupo apiKey = "1PK9ELK0L4AH8CVP" # Código dado pelo ThingSpeak mqttHost = "mqtt.thingspeak.com" # posições de usoUnsecuredTCP = True useUnsecuredWebsockets = False useUnsecuredWebsockets = False useSSecuredWebsockets ifCPsockets = False useSSecuredWebsockets = False useSSecuredWebsockets ifCPsockets "tcp" tPort = 1883 tTLS = Nenhum se useUnsecuredWebsockets: tTransport = "websockets" tPort = 80 tTLS = Nenhum se useSSLWebsockets: import ssl tTransport = "websockets" tTLS = {'ca_certs': "/ etc / ssl / certs / ca- certificados.crt ", 'tls_version': ssl. PROTOCOL_TLSv1} tPort = 443 tópico =" canais / "+ channelID +" / publicar / "+ apiKey #Cria variavel com o 'caminho' para o canal tPayload =" campo1 = "+ str (ardAgua) + "& field2 =" + str (ardTemp) + "& field3 =" + str (ardPres) + "& field4 =" + str (ardUV) + "& field5 =" + str (data) + "& field6 =" + str (vel_vento) + "& field7 =" + str (umidade) #Organiza todas as variaveis em uma String para ser enviado print 'Enviando dados' try: publish.single (topic, payload = tPayload, hostname = mqttHost, port = tPort, tls = tTLS, transport = tTransport) #Envia os dados time.sleep (0.5) print 'Dados enviados' exceto: print 'Erro ao enviar dados'

Etapa 5: Configurando O Web Service

Para enviar os dados obtidos ao Web Service, utilizamos a plataforma ThingSpeak. Para tal, entramos no site thingspeak.com e criamos uma conta. Após a criação e login na conta, nos dirigimos ao cabeçalho de menus -> Canais -> Meus Canais e então clicamos no botão "Novo Canal". Ao clicar, escolhemos o nome do Canal, escrevemos uma descrição para ele, e então decidimos quantos dos 8 campos possíveis utilizaríamos. No caso, utilizamos 7.

Ao criar um canal, é gerado um ID do Canal, uma Chave de Escrita e uma Chave de Leitura. O ID do Canal encontra-se abaixo do nome do canal e a Chave de Escrita na aba "Chaves". Para que o código Python envie as informações necessárias para o canal é, necessário configurá-lo ao ID do Canal:

channelID = "Insira o ID do Canal aqui"

E também com a Chave de Escrita:

apiKey = "Insira a Chave de Escrita"

Além da conexão com o canal criado, também são necessárias outras configurações no código do Python app.py:

useUnsecuredTCP = True

useUnsecuredWebsockets = FalseuseSSLWebsockets = False mqttHost = "mqtt.thingspeak.com" se useUnsecuredTCP: tTransport = "tcp" tPort = 1883 tTLS = Nenhum se useUnsecuredWebsockets: tTransport = "websockets" tPortTransport = "tcp" tPort = 1883 tTLS = Nenhum se useUnsecuredWebsockets: tTransport = "websockets" tPortTrans = 80 tSSTLS = Nenhum se use SSTLS import websockets "tTLS = {'ca_certs':" / etc / ssl / certs / ca-certificates.crt ", 'tls_version': ssl. PROTOCOL_TLSv1} tPort = 443 topic =" channels / "+ channelID +" / publish / "+ Chave API

Para que uma aplicação web realmente receba, por exemplo, o valor Temperatura no campo 2 (campo que escolhemos para ser a Temperatura), é necessário indicar o "field2 =" + variável_temperatura, como no código a seguir:

tPayload = "field1 =" + str (ardAgua) + "& field2 =" + str (ardTemp) + "& field3 =" + str (ardPres) + "& field4 =" + str (ardUV) + "& field5 =" + str (dados) + "& field6 =" + str (vel_vento) + "& field7 =" + str (umidade)

Tendo vinculado todos os dados do Canal à programação em Python, basta executar o código que todos os dados escolhidos são enviados ao Web Service. No ThingSpeak, é possível realizar todo o monitoramento através de gráficos.