heboba/goodgarden
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Doc gemaakt voor scripts

Browse Source
This commit is contained in:
Atilla
2024-04-03 14:08:30 +02:00
parent 02ca9e7f58
commit 70e5633ce6
21 changed files with 629 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
mqtt/db_connect.py
View File

@@ -1,16 +1,36 @@
# Importeer de benodigde modules voor MySQL connectiviteit.
import mysql.connector
from mysql.connector import Error
def database_connect():
"""
Maakt verbinding met de MySQL database.
Probeert een verbinding met de MySQL-database op te zetten met behulp van
de mysql.connector.connect methode, gebruikmakend van de database
credentials. Bij succes retourneert het de verbinding; bij een mislukking
vangt het de fout op en print een bericht.
Returns:
connection (mysql.connector.connect object): Een connectie object als
de verbinding succesvol is. Anders None.
"""
try:
# Probeert een verbinding op te zetten met de MySQL database.
connection = mysql.connector.connect(
host="localhost",
user="root",
password="",
database="goodgarden"
host="localhost", # Database host
user="root", # Database gebruikersnaam
password="", # Database wachtwoord
database="goodgarden" # Database naam
)
# Controleert of de verbinding succesvol was.
if connection.is_connected():
return connection
return connection # Retourneert het verbinding object.
except Error as e:
# Vangt en print elke fout die optreedt tijdens het verbindingsproces.
print(f"Connection NIET gelukt! ${e}")
return None
# Retourneert None als de verbinding mislukt.
return None

46
mqtt/mqtt_client.py
View File

@@ -1,15 +1,59 @@
# Importeer de paho.mqtt.client module die MQTT-client functionaliteiten biedt.
import paho.mqtt.client as mqtt
def create_client(client_id, on_connect, on_message, broker="localhost", port=1883):
"""
Creëert en configureert een MQTT-client.
Deze functie initialiseert een MQTT-client met een unieke client_id,
definieert callback functies voor connect- en message-events, en
maakt vervolgens verbinding met de MQTT-broker.
Parameters:
client_id (str): Een unieke identifier voor de MQTT-client.
on_connect (function): Callback functie die wordt aangeroepen
wanneer de client verbinding maakt met de broker.
on_message (function): Callback functie die wordt aangeroepen
wanneer een bericht wordt ontvangen.
broker (str, optional): Het adres van de MQTT-broker.
Standaard is dit "localhost".
port (int, optional): De poort waarop de MQTT-broker luistert.
Standaard is dit 1883.
Returns:
mqtt.Client: Een geconfigureerde MQTT-clientobject.
"""
# Initialiseert een MQTT-client met de opgegeven client_id.
client = mqtt.Client(client_id)
# Stelt de callback functies in voor connect- en message-events.
client.on_connect = on_connect
client.on_message = on_message
client.connect(broker, port, 60)
# Maakt verbinding met de opgegeven MQTT-broker en poort.
client.connect(broker, port, 60) # De keepalive is ingesteld op 60 seconden.
# Retourneert het geïnitialiseerde en geconfigureerde client-object.
return client
def start_loop(client):
"""
Start de netwerkloop van de MQTT-client.
Deze functie start de oneindige loop van de client, waardoor deze
continu luistert naar berichten van de broker. De loop wordt onderbroken
bij het ontvangen van een KeyboardInterrupt (Ctrl+C).
Parameters:
client (mqtt.Client): De MQTT-client die de loop zal uitvoeren.
Returns:
None
"""
try:
# Start de oneindige loop die berichten verwerkt.
client.loop_forever()
except KeyboardInterrupt:
# Print een bericht en maakt de verbinding met de broker los
# als de gebruiker de loop onderbreekt.
print("Disconnecting from broker")

60
mqtt/publisher.py
View File

@@ -1,60 +1,82 @@
# Importeer benodigde modules voor het uitvoeren van HTTP-verzoeken, tijdbeheer, en JSON-operaties.
import requests
import time
import json
# Importeer MQTT-client functies van een aangepaste module.
from mqtt_client import create_client, start_loop
publish_interval = 30 # Secondes om een aanvraag te doen - MOET ~300 ZIJN!!!!!!!!!
# Stel het interval in seconden in voor het periodiek ophalen en publiceren van data.
publish_interval = 30 # MOET ~300 ZIJN voor productiegebruik.
# Definieer API-eindpunten en de corresponderende MQTT topics.
api_endpoints = [
{"url": "https://garden.inajar.nl/api/devices/", "topic": "goodgarden/devices"},
{"url": "https://garden.inajar.nl/api/relative_humidity_events/", "topic": "goodgarden/relative_humidity"},
{"url": "https://garden.inajar.nl/api/battery_voltage_events/", "topic": "goodgarden/battery_voltage"},
{"url": "https://garden.inajar.nl/api/soil_electric_conductivity_events/", "topic": "goodgarden/soil_electric_conductivity"},
{"url": "https://garden.inajar.nl/api/soil_relative_permittivity_events/", "topic": "goodgarden/soil_relative_permittivity"},
{"url": "https://garden.inajar.nl/api/soil_temperature_events/", "topic": "goodgarden/soil_temperature"},
{"url": "https://garden.inajar.nl/api/par_events/", "topic": "goodgarden/par_events"}
# Voeg meer API-eindpunten en topics toe zoals vereist.
]
def on_connect(client, userdata, flags, rc):
"""
Callback functie voor het afhandelen van de connectie-event met de MQTT broker.
Parameters:
client: De MQTT-client instantie.
userdata: De private user-specifieke data zoals ingesteld in Client() of user_data_set().
flags: Reactie vlaggen van de broker.
rc: De connectie resultaat code.
"""
print("Connected with result code "+str(rc))
def on_message(client, userdata, msg):
"""
Callback functie voor het afhandelen van inkomende berichten voor geabonneerde topics.
Parameters:
client: De MQTT-client instantie.
userdata: De private user-specifieke data.
msg: Het bericht instantie.
"""
print(f"Message: {msg.topic} {str(msg.payload)}")
client = create_client("publisher1", on_connect, on_message) # Gebruik een unieke client ID
# Initialiseer de MQTT-client met een unieke client ID en callback functies.
client = create_client("publisher1", on_connect, on_message)
def publish_to_mqtt(topic, data):
json_data = json.dumps(data) # Serialiseer de data naar een JSON-string
"""
Publiceert data naar een MQTT topic.
Parameters:
topic (str): Het MQTT topic waarop de data wordt gepubliceerd.
data (dict): De data die gepubliceerd moet worden, geconverteerd naar JSON formaat.
"""
json_data = json.dumps(data) # Serialiseer de data naar een JSON-string.
client.publish(topic, json_data)
print(f"\033[92mData published to MQTT topic {topic}.\033[0m")
def fetch_and_publish_data():
"""
Haalt data op van API-eindpunten en publiceert deze naar MQTT.
"""
for endpoint in api_endpoints:
url = endpoint["url"]
mqtt_topic = endpoint["topic"]
access_token = "33bb3b42452306c58ecedc3c86cfae28ba22329c"
access_token = "33bb3b42452306c58ecedc3c86cfae28ba22329c" # Voorbeeld token.
try:
headers = {"Authorization": f"Token {access_token}"}
response = requests.get(url, headers=headers)
response.raise_for_status() # Zorgt ervoor dat HTTPError wordt opgeworpen voor slechte responses
response.raise_for_status() # Verifieert respons status.
data = response.json()
print(f"Data from {url}: {data}")
publish_to_mqtt(mqtt_topic, data)
# load_data(data) # Zorg ervoor dat deze functie elders gedefinieerd is
except requests.exceptions.RequestException as e:
print(f"Error fetching data from {url}: {e}")
if __name__ == "__main__":
client.loop_start() # Start de niet-blokkerende loop
client.loop_start() # Start de niet-blokkerende MQTT-client loop.
while True:
fetch_and_publish_data()
fetch_and_publish_data() # Haal data op en publiceer.
print(f"\033[91mWachten, wachten en nog eens wachten... {publish_interval} secondes!\033[0m\n")
time.sleep(publish_interval) # Wacht voor het ingestelde interval.
time.sleep(publish_interval)
client.loop_stop()