Irrigações Automatizadas Com Web Service Utilizando Python: 5 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:44

Neste projeto iremos desenvolver 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 UV, velocidade do vento e condição da planta (seca / molhada). Alguns desses dados são obtidos localmente, enquanto outros são obtidos por meio de um Web Service conectado à uma estação meteorológica (No caso, estamos utilizando a da Faculdade de Engenharia de Sorocaba). Após adquiridos, los datos están disponibles en una aplicación web basada en ThingSpeak.

Paso 1: Hardware Utilizado

Foi utilizado para una construção deste projeto:

1x tablero de dragón Qualcomm 410c

1x entrepiso con sensor Grove Seeed

1x sensor de agua Seeed

1x sensor IMU 10OF Grove v1.0

1x sensor de luz solar Grove v1.0

1x ratón USB

1x Teclado USB

1x monitor

1x Cabo HDMI

1x Adaptador HDMI-VGA

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

Paso 2: Montagem Do Hardware

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

1: Conexión directa entre el sensor Groove Sunlight v1.0.

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

3: + 5V e Gnd conectados aos pinos corresponsales do Sensor de agua.

4: TIERRA IMU-10DOF.

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

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

Paso 3: Firmware Atmega328

Através da Sensors Mezzanine, es posible acceder a un microcontrolador Atmega328, o mesmo utilizado en plataformas Arduino, y programado directamente, usando un IDE Arduino instalado en DragonBoard. Vale ressaltar que un Mezzanine y un DragonBoard en un conjunto de posibilidades de todos los periféricos necesarios para un programa y gravação de firmware sin microcontrolador.

O firmware embarcado é responsável por realizar como lecturas de dos sensores, gerenciando los protocolos de comunicación e operação dos mesmos, e após a aquisição dos dados, os encaminha via porta serial para a DragonBoard.

* Pode ser necesario a inclusão das bibliotecas utilizadas sin firmware. Elas podem ser encontradas em:

imu-10DOF

Sensor de luz solar

O firmware utilizado pode ser encontrado aqui ou aqui:

Paso 4: Programación en Python

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

import urllib2, json #para pegar os dados da estacaoimport time #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ão obtidos 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 iremos 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 un variável 'jsonurl' como 'None'. Esta variável irá a abrir una URL JSON, portanto ao inicializarmos ela no início do 'while', estamos então resetando ela toda vez que repetirmos o loop. O próximo paso é abrir o URL usando una función 'urllib2.urlopen (url)', podendo también adicionar um argumento 'timeout = X', sendo X uma quantidade em segundos limite para o URL ser aberto. Se o programa conseguir abrir una URL dentro del tempo do timeout, o programa irá realizar una función 'comJSON' mencionada anteriormente. Caso no consiga abrir una URL sin tempo estipulado, realiza-se una función 'semJSON'. Ambos como 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 = None #Inicializa a varivavel como None print 'Passo:', j print 'Atualizando dados' try: jsonurl = urllib2.urlopen (url, timeout = 5) #tenta abrir o url em no máximo 5 segundos si jsonurl no es None: print 'Dados atualizados' comJSON (jsonurl) #Se conseguiu abrir o URL, mostra todos os dados except: if jsonurl is None: print 'Erro ao atualizar dados' semJSON () #Se não abriu o URL, mostra os dados obtidos localmente (do Arduino) pass j + = 1 print '---------------------------------- -------------------------------------------------- -------------------------------------------- / n 'tiempo.sueño (1)

Na primeira linha da função 'comJSON', recebemos todos os dados da URL já abertos numa variável 'dados'. Esta irá receber um objeto com duas Arrays, das quais iremos somente usar uma ('ReturnDataSet'). Realizada esta operação, iremos então inicializar o Serial do Arduíno e ler as linhas (readline ()) que o Arduíno está imprimindo e jogando as Strings convertidas dentro de variáveis e, então, mostrando esses dados na tela. Recebidos os dados do Arduíno, receberemos os dados dados da estação, simplemente acessando os sensores específicos dentro del objeto 'dados' (por ejemplo '[' 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 a variavel 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 = flotar (ard.readline (). rstrip ())

imprimir "\ nArduino"

if ardAgua == 1: imprime 'Molhado' else: imprime 'Seco' imprime 'Temperatura:', ardTemp, '* C' imprime 'Pressao:', ardPres, 'Pa' imprime '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 'Datos:', datos

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 un ID do canal, una Chave de Escrita e o Host em variáveis, além de configurar o useUnsecuredTCP, useUnsecuredWebsockets e useSSLWebsockets (usamos True, False, False). 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 como variáveis convertidas) e então tentar publicar os dados no servidor usando 'publish. single (tema, carga útil = tPayload, nombre de host = mqttHost, puerto = tPort, tls = tTLS, transporte = tTransport) '. A função então acaba e retorna para o loop principal.

#Envia channelID = "344243" #Canal criado para o grupo apiKey = "1PK9ELK0L4AH8CVP" # Código dado pelo ThingSpeak mqttHost = "mqtt.thingspeak.com" # configurações de comunicação useUnsecuredTCP = True useUnsecured useUnsecuredWebsockets = "tcp" tPort = 1883 tTLS = Ninguno si useUnsecuredWebsockets: tTransport = "websockets" tPort = 80 tTLS = Ninguno si useSSLWebsockets: import ssl tTransport = "websockets" tTLS = {'ca_certs': "/ etc / ssl / certs / ca certificate.crt ", 'tls_version': ssl. PROTOCOL_TLSv1} tPort = 443 topic =" channels / "+ channelID +" / publish / "+ apiKey #Cria variavel com o 'caminho' para o canal tPayload =" field1 = "+ str (ardAgua) + "& field2 =" + str (ardTemp) + "& field3 =" + str (ardPres) + "& field4 =" + str (ardUV) + "& field5 =" + str (data) + "& field6 =" + str (vel_vento) + "& field7 =" + str (umidade) #Organiza todas como 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' excepto: print 'Erro ao enviar dados'

Paso 5: Configurando O Web Service

Para enviar los datos ofrecidos ao Web Service, utilizamos una plataforma ThingSpeak. Para tal, no entramos en el sitio 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 se encuentra abaixo do nome do canal e a Chave de Escrita na aba "Chaves". Para que o código Python envie as informações obtidas 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, también são necessárias outras configurações sin código em Python app.py:

useUnsecuredTCP = True

useUnsecuredWebsockets = FalseuseSSLWebsockets = False mqttHost = "mqtt.thingspeak.com" if useUnsecuredTCP: tTransport = "tcp" tPort = 1883 tTLS = Ninguno si useUnsecuredWebsockets: tTransport = "websockets" tLSport = 80 websockets "tTLS = {'ca_certs':" / etc / ssl / certs / ca -ificates.crt ", 'tls_version': ssl. PROTOCOL_TLSv1} tPort = 443 topic =" channels / "+ channelID +" / publish / "+ Clave API

Para que una aplicação web realmente receba, por ejemplo, o valor Temperatura no campo 2 (campo que escolhemos para ser a Temperatura), es necesario 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 (datos) + "& field6 =" + str (vel_vento) + "& field7 =" + str (umidade)

Tendo vinculado a todos los datos del Canal a programação em Python, basta con ejecutar o código que todos los datos escolhidos são enviados ao Web Service. No ThingSpeak, es posible realizar todo el seguimiento de gráficos.