Aufbau einer IoT Smart Farm mit Raspberry Pi und Actian Zen

Technologie verändert jede Branche, und die Landwirtschaft bildet da keine Ausnahme. Das Internet der DingeIoT) und Edge-Computing bieten leistungsstarke Werkzeuge, um traditionelle landwirtschaftliche Verfahren effizienter, nachhaltiger und data driven zu gestalten. Eine erschwingliche und vielseitige Plattform, die die Grundlage für ein solches intelligentes Landwirtschaftssystem bilden kann, ist der Raspberry Pi.

In diesem Blogbeitrag werden wir ein intelligentes Landwirtschaftssystem aufbauen, das IoT zur Überwachung von Bodenfeuchtigkeit, Temperatur und Luftfeuchtigkeit in einem Betrieb einsetzt. Das Ziel ist es, die Bewässerung zu optimieren und optimale Wachstumsbedingungen für die Pflanzen zu gewährleisten. Wir verwenden einen Raspberry Pi mit dem Betriebssystem Raspbian, Actian Zen Edge für die Datenbankverwaltung, Zen Enterprise für die Verarbeitung der erkannten Anomalien in der Remote-Server-Datenbank und Python mit der Zen ODBC-Schnittstelle für die Datenverarbeitung. Darüber hinaus werden wir AWS SNS (Simple Notification Service) nutzen, um Warnungen für erkannte Anomalien in Echtzeit zu senden und sofortige Maßnahmen zu ergreifen.

Voraussetzungen

Bevor wir beginnen, vergewissern Sie sich, dass Sie die folgenden Informationen haben:

• Ein Raspberry Pi mit dem Betriebssystem Raspbian.
• Python ist auf Ihrem Raspberry Pi installiert.
• Actian Zen Edge-Datenbank installiert.
• PyODBC-Bibliothek installiert.
• AWS SNS mit einem geeigneten Thema und Zugangsdaten einrichten.

Schritt 1: Einrichten des Raspberry Pi

Aktualisieren Sie zunächst Ihren Raspberry Pi und installieren Sie die erforderlichen Bibliotheken:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install python3-pip
pip3 install pyodbc boto3

Schritt 2: Actian Zen Edge installieren

Folgen Sie den Anweisungen auf der Actian Zen Edge Download-Seite, um Actian Zen Edge herunterzuladen und auf Ihrem Raspberry Pi zu installieren.

Schritt 3: Tabellen in der Datenbank erstellen

Wir müssen Tabellen erstellen, um Sensordaten und Anomalien zu speichern. Verbinden Sie sich mit Ihrer Actian Zen Edge-Datenbank und erstellen Sie die folgende Tabelle:

CREATE TABLE sensor_data (
    id Identität PRIMARY KEY,
    Zeitstempel DATETIME,
    boden_feuchtigkeit FLOAT,
    Temperatur FLOAT,
    Luftfeuchtigkeit FLOAT
);

Installieren Sie Zen Enterprise, stellen Sie eine Verbindung zur zentralen Datenbank her, und erstellen Sie die folgende Tabelle:

 CREATE TABLE anomalies (
    id Identität PRIMARY KEY ,
    Zeitstempel DATETIME,
    boden_feuchtigkeit FLOAT,
    Temperatur FLOAT,
    Luftfeuchtigkeit FLOAT,
    Beschreibung longvarchar
);

Schritt 4: Definieren Sie das Python

Schreiben wir nun das Python , das die Sensordateneingabe, die Erkennung von Anomalie und die Alarmierung über AWS SNS übernimmt.

Logik der Anomalie

Definieren Sie eine Funktion zur Prüfung auf Anomalien auf der Grundlage von vordefinierten Schwellenwerten:

def check_for_anomalies(data):
    threshold = {'soil_moisture': 30.0, 'temperature': 35.0, 'humidity': 70.0}
    anomalies = []
    if data['soil_moisture'] < threshold['soil_moisture']:
        anomalies.append('Low soil moisture detected')
    if data['temperature'] > threshold['temperature']:
        anomalies.append('High temperature detected')
    if data['humidity'] > threshold['humidity']:
        anomalies.append('High humidity detected')
    return anomalies

Sensordaten einfügen

Definieren Sie eine Funktion zum Einfügen von Sensordaten in die Datenbank:

import pyodbc

def insert_sensor_data(data):
    conn = pyodbc.connect('Driver={Pervasive ODBC 
Interface};servername=localhost;Port=1583;serverdsn=demodata;')
    cursor = conn.cursor()
    cursor.execute("INSERT INTO sensor_data (timestamp, soil_moisture, temperature, humidity) VALUES (?, ?, ?, ?)",
                   (data['timestamp'], data['soil_moisture'], data['temperature'], data['humidity']))
    conn.commit()
    cursor.close()
    conn.close()

Anomalien an die entfernte Datenbank senden

Definieren Sie eine Funktion, um erkannte Anomalien an die Datenbank zu senden:

def send_anomalies_to_server(anomaly_data):
    conn = pyodbc.connect('Driver={Pervasive ODBC Interface};servername=<remote server>;Port=1583;serverdsn=demodata;')
    cursor = conn.cursor()
    cursor.execute("INSERT INTO anomalies (timestamp, soil_moisture, temperature, humidity, description) VALUES (?, ?, ?, ?, ?)",
                   (anomaly_data['timestamp'], anomaly_data['soil_moisture'], anomaly_data['temperature'], anomaly_data['humidity'], anomaly_data['description']))
    conn.commit()
    cursor.close()
    conn.close()

Warnmeldungen über AWS SNS senden

Definieren Sie eine Funktion zum Senden von Warnmeldungen über AWS SNS:

def send_alert(nachricht):
    sns_client = boto3.client('sns', aws_access_key_id='Ihre Schlüssel-ID',
    aws_secret_access_key ='Ihr Zugangsschlüssel', region_name='ihre-region')
    topic_arn = 'arn:aws:sns:ihre-region:ihre-account-id:ihr-topic-name'
    response = sns_client.publish(
        TopicArn=topic_arn,
        Message=Nachricht,
        Subject=Anomalie '
    )
    return response

Ersetzen Sie ihre-region, ihre-konten-idund Ihr-Thema-Name mit Ihren aktuellen AWS SNS-Topic-Details.

Schritt 5: Sensordaten generieren

Definieren Sie eine Funktion, um reale Sensordaten zu simulieren:

import random
import datetime

def generate_sensor_data():
    return {
        'timestamp': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
        'soil_moisture': random.uniform(20.0, 40.0),
        'temperature': random.uniform(15.0, 45.0),
        'humidity': random.uniform(30.0, 80.0)
    }

Schritt 6: Hauptfunktion zur Simulation der Datenerfassung und -verarbeitung

Zum Schluss fügen Sie alles in einer Hauptfunktion zusammen:

def main():
    for _ in range(100):
        sensor_data = generate_sensor_data()
        insert_sensor_data(sensor_data)
        anomalies = check_for_anomalies(sensor_data)
        if anomalies:
            anomaly_data = {
                'timestamp': sensor_data['timestamp'],
                'soil_moisture': sensor_data['soil_moisture'],
                'temperature': sensor_data['temperature'],
                'humidity': sensor_data['humidity'],
                'description': ', '.join(anomalies)
            }
            send_anomalies_to_server(anomaly_data)
            send_alert(anomaly_data['description'])
if __name__ == "__main__":
    main()

Schlussfolgerung

Und da haben Sie es! Wenn Sie diese Schritte befolgen, haben Sie erfolgreich ein grundlegendes intelligentes Landwirtschaftssystem auf einem Raspberry Pi mit Actian Zen Edge und Python eingerichtet. Dieses System, das Bodenfeuchtigkeit, Temperatur und Luftfeuchtigkeit überwacht, Anomalien erkennt, Daten in Datenbanken speichert und Benachrichtigungen über AWS SNS sendet, ist eine skalierbar Lösung zur Optimierung der Bewässerung und zur Gewährleistung optimaler Wachstumsbedingungen für Pflanzen. Jetzt sind Sie an der Reihe, dieses Wissen anzuwenden und zur Zukunft der intelligenten Landwirtschaft beizutragen.

Denken Sie daran, die Platzhalter durch Ihre tatsächlichen AWS SNS-Themen- und Datenbankverbindungsdetails zu ersetzen. Viel Spaß beim Farmen!

Über Johnson Varughese

Johnson Varughese ist Manager of Support Engineering bei Actian. Er unterstützt Entwickler bei der Erstellung von Anwendungen mit ZEN-Schnittstellen wie Btrieve, ODBC, JDBC, ADO.NET, Btrieve2 und anderen. Seine Aufgabe besteht darin, technische Anleitungen zu geben, Fehler zu beheben und sicherzustellen, dass Entwickler diese Schnittstellen effektiv nutzen können, um robuste und effiziente Anwendungen in verschiedenen Programmierumgebungen zu erstellen. Johnsons Fachwissen in diesen Technologien trägt dazu bei, Entwicklungsprozesse zu rationalisieren und die Leistung und Funktionalität der entwickelten Anwendungen zu verbessern.