Construye una granja inteligente IoT con Raspberry Pi y Actian Zen

La tecnología está cambiando todos los sectores, y la agricultura no es una excepción. El Internet de las Cosas (IoT) y la computación en el borde proporcionan potentes herramientas para hacer que las prácticas agrícolas tradicionales sean más eficientes, sostenibles y basadas en datos. Una plataforma asequible y versátil que puede constituir la base de un sistema agrícola inteligente es la Raspberry Pi.

En esta entrada del blog, construiremos un sistema agrícola inteligente utilizando dispositivos IoT para monitorizar la humedad del suelo, la temperatura y los niveles de humedad en una granja. El objetivo es optimizar el riego y garantizar unas condiciones de crecimiento óptimas para los cultivos. Utilizaremos una Raspberry Pi con Raspbian OS, Actian Zen Edge para la gestión de bases de datos, Zen Enterprise para gestionar las anomalías detectadas en la base de datos del servidor remoto, y Python con la interfaz Zen ODBC para el manejo de datos. Además, aprovecharemos AWS SNS (Simple Notification Service) para enviar alertas de anomalías detectadas en tiempo real para una acción inmediata.

Requisitos previos

Antes de empezar, asegúrate de tener lo siguiente:

• Una Raspberry Pi con Raspbian OS.
• Python instalado en tu Raspberry Pi.
• base de données Edge Actian Zen base de données Edge instalada.
• Biblioteca PyODBC instalada.
• AWS SNS configurado con un tema apropiado y credenciales de acceso.

Paso 1: Configuración de la Raspberry Pi

En primer lugar, actualiza tu Raspberry Pi e instala las librerías necesarias:

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

Paso 2: Instalar Actian Zen Edge

Siga las instrucciones de la página de descarga de Actian Zen Edge para descargar e instalar Actian Zen Edge en su Raspberry Pi.

Paso 3: Crear tablas en la base de datos

Necesitamos crear tablas para almacenar los datos de los sensores y las anomalías. Conéctese a su Actian Zen base de données Edge y cree la siguiente tabla:

CREAR TABLA sensor_data (
    id identidad PRIMARIO CLAVE,
    timestamp DATETIME,
    humedad_suelo FLOAT,
    temperatura FLOAT,
    humedad FLOAT
);

Instale Zen Enterprise, conéctese a la base de datos central y cree la siguiente tabla:

 CREAR TABLA anomalías (
    id identidad PRIMARIO CLAVE ,
    timestamp DATETIME,
    humedad_suelo FLOAT,
    temperatura FLOAT,
    humedad FLOAT,
    descripción longvarchar
);

Paso 4: Definir el script Python

Ahora, vamos a escribir el script Python para manejar la inserción de datos del sensor, la detección de anomalie y la alerta a través de AWS SNS.

Lógica de detección de anomalie

Defina una función para comprobar la existencia de anomalías en función de umbrales predefinidos:

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

Insertar datos del sensor

Definir una función para insertar los datos del sensor en la base de datos:

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()

Enviar anomalías a la base de datos remota

Defina una función para enviar las anomalías detectadas a la base de datos:

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()

Enviar alertas mediante AWS SNS

Defina una función para enviar alertas mediante AWS SNS:

def send_alert(mensaje):
    sns_client = boto3.client('sns', aws_access_key_id='Tu ID de clave',
    aws_secret_access_key ='Tu clave de acceso', region_name='tu-región')
    topic_arn = 'arn:aws:sns:tu-región:tu-id-cuenta:tu-nombre-de-tema'
    response = sns_client.publish(
        TopicArn=nombre_tema,
        Mensaje=mensaje,
        Asunto='Alertaanomalie '
    )
    devolver respuesta

Sustituya su-región, your-account-idy su-nombre-de-tema con los detalles reales de tu tema de AWS SNS.

Paso 5: Generar datos del sensor

Define una función para simular datos de sensores del mundo real:

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)
    }

Paso 6: Función principal para simular la recogida y el tratamiento de datos

Por último, júntalo todo en una función principal:

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()

Conclusión

¡Y ahí lo tienes! Siguiendo estos pasos, has configurado con éxito un sistema básico de agricultura inteligente en una Raspberry Pi utilizando Actian Zen Edge y Python. Este sistema, que monitoriza los niveles de humedad, temperatura y humedad del suelo, detecta anomalías, almacena datos en bases de datos y envía notificaciones a través de AWS SNS, es una solución escalable para optimizar el riego y garantizar unas condiciones óptimas de crecimiento para los cultivos. Ahora, le toca a usted aplicar estos conocimientos y contribuir al futuro de la agricultura inteligente.

Recuerde reemplazar los marcadores de posición con los detalles reales de su tema AWS SNS y los detalles de conexión a la base de datos. ¡Feliz cultivo!

Sobre Johnson Varughese

Johnson Varughese gestiona la Ingeniería de Soporte en Actian, ayudando a los desarrolladores a aprovechar las interfaces ZEN (Btrieve, ODBC, JDBC, ADO.NET, etc.). Proporciona orientación técnica y experiencia en la resolución de problemas para garantizar un rendimiento sólido de las aplicaciones en diferentes entornos de programación. La riqueza de conocimientos de Johnson en interfaces de acceso a datos ha agilizado numerosos proyectos de desarrollo. Sus entradas en el blog de Actian detallan las mejores prácticas para integrar Btrieve y otras interfaces. Explore sus artículos para optimizar sus aplicaciones basadas en bases de datos.