Merge pull request #3124 from FoamyGuy/sensor_llm_project

FoamyGuy · web-flow · commit a992f8abf646 · 2025-09-22T16:33:15.000-05:00
Sensor data LLM project code
diff --git a/Raspberry_Pi_LLM_Sensor_Data/db_models.py b/Raspberry_Pi_LLM_Sensor_Data/db_models.py
@@ -0,0 +1,52 @@
+# SPDX-FileCopyrightText: 2025 Tim Cocks for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+from datetime import datetime
+from sqlalchemy import Column, Integer, Float, String, DateTime, create_engine
+from sqlalchemy.ext.declarative import declarative_base
+
+
+Base = declarative_base()
+
+
+class SensorReading(Base):
+    """
+    Database model for environmental sensor readings.
+    """
+
+    __tablename__ = "sensor_readings"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    datetime = Column(DateTime, nullable=False, default=datetime.utcnow)
+    room_name = Column(String(100), nullable=False)
+    temperature_c = Column(Float, nullable=True)
+    temperature_f = Column(Float, nullable=True)
+    humidity = Column(Float, nullable=True)  # Percentage
+    pm25 = Column(Float, nullable=True)  # PM2.5 in µg/m³
+    voc_index = Column(Float, nullable=True)  # VOC index
+    nox_index = Column(Float, nullable=True)  # NOx index
+    co2 = Column(Float, nullable=True)  # CO2 in ppm
+
+    def __repr__(self):
+        return (
+            f"<SensorReading(room='{self.room_name}', "
+            f"datetime='{self.datetime}', "
+            f"temp_c={self.temperature_c}, "
+            f"humidity={self.humidity})>"
+        )
+
+
+if __name__ == "__main__":
+
+    def create_database(db_url="sqlite:///sensor_data.db"):
+        """Create the database and all tables."""
+        engine = create_engine(db_url, echo=True)
+
+        # Create all tables
+        Base.metadata.create_all(engine)
+
+        print(f"Database created successfully at: {db_url}")
+        return engine
+
+    # Create the database when script is run directly
+    create_database()
diff --git a/Raspberry_Pi_LLM_Sensor_Data/prompt_llm_for_summary.py b/Raspberry_Pi_LLM_Sensor_Data/prompt_llm_for_summary.py
@@ -0,0 +1,197 @@
+# SPDX-FileCopyrightText: 2025 Tim Cocks for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+import csv
+from datetime import datetime, timedelta, UTC
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from ollama import chat
+from db_models import SensorReading
+
+# pylint: disable=too-many-locals, too-many-nested-blocks
+
+# Database connection configuration
+DATABASE_URL = "sqlite:///sensor_data.db"
+
+MODEL = "gemma3:1b"
+
+# Room name to pull data for. Update to match one of your rooms.
+ROOM = "Basement"
+
+# Specify a Custom Date Range
+# QUERY_START = datetime(2025, 9, 16, 0, 0, 0, tzinfo=UTC)
+# QUERY_END = datetime(2025, 9, 18, 19, 0, 0, tzinfo=UTC)
+
+# Defaults to last 24 hours if start and end are None
+QUERY_START = None
+QUERY_END = None
+
+# Time interval in minutes to export data with i.e. one data point every 30 minutes.
+SAMPLE_RATE = 30  # minutes
+
+
+PROMPT = """Analyze the following environmental sensor data. Provide a summary of its content,
+ identify key patterns or insights, and suggest potential further analysis or questions based on this data.
+
+Data:
+---
+%%_DATA_PLACEHOLDER_%%
+---
+
+The data fields are:
+- UTC Datetime
+- Temperature in degrees F
+- Humidity percent
+- pm2.5 in µg/m³
+- VOC index 
+- NOx index
+- CO2 in ppm
+
+Please summarize the data, identify key patterns, insights, or trends.
+"""
+
+
+def fetch_data(
+    room, start_datetime=None, end_datetime=None, output_file=None, sample_rate=30
+):
+    """
+    Fetch all SensorReading records from a specified time range for RoomC
+    and save them to a CSV file
+
+    Args:
+        room (str): Room name
+        start_datetime (Optional[datetime]): Start of the time range (default: 24 hours ago)
+        end_datetime (Optional[datetime]): End of the time range (default: now)
+        output_file (str): Name of the CSV file to create
+        sample_rate (int): Sampling interval in minutes (e.g., 5 for every 5 minutes)
+    """
+    # Create database engine and session
+    engine = create_engine(DATABASE_URL)
+    Session = sessionmaker(bind=engine)
+    session = Session()
+
+    try:
+        # Set default values if not provided
+        if end_datetime is None:
+            end_datetime = datetime.now(UTC)
+        if start_datetime is None:
+            start_datetime = end_datetime - timedelta(hours=24)
+
+        # Ensure start_datetime is before end_datetime
+        if start_datetime >= end_datetime:
+            raise ValueError("start_datetime must be before end_datetime")
+
+        print(f"Fetching data for {room} from {start_datetime} to {end_datetime}")
+
+        # Query for RoomC records within the specified time range
+        query = (
+            session.query(SensorReading)
+            .filter(
+                SensorReading.room_name == room,
+                SensorReading.datetime >= start_datetime,
+                SensorReading.datetime <= end_datetime,
+            )
+            .order_by(SensorReading.datetime.desc())
+        )
+
+        # Execute the query
+        results = query.all()
+
+        # Apply sampling if sample_rate > 1
+        if sample_rate > 1:
+            sampled_results = []
+            if results:
+                # Start from the most recent record (first in desc order)
+                base_time = results[0].datetime
+
+                for reading in results:
+                    # Calculate minutes difference from the base time
+                    time_diff = abs((base_time - reading.datetime).total_seconds() / 60)
+
+                    # Include reading if it falls on a sample interval
+                    if time_diff % sample_rate < 1:  # Allow 1 minute tolerance
+                        sampled_results.append(reading)
+
+            results = sampled_results
+            print(
+                f"Applied {sample_rate}-minute sampling: {len(results)} records selected"
+            )
+
+        if output_file is not None:
+            # Write results to CSV file
+            with open(output_file, "w", newline="", encoding="utf-8") as csvfile:
+                fieldnames = [
+                    "datetime",
+                    "temperature_f",
+                    "humidity",
+                    "pm25",
+                    "voc_index",
+                    "nox_index",
+                    "co2",
+                ]
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+
+                # Write header
+                writer.writeheader()
+
+                # Write data rows
+                for reading in results:
+                    writer.writerow(
+                        {
+                            "datetime": (
+                                reading.datetime.isoformat()
+                                if reading.datetime
+                                else None
+                            ),
+                            "temperature_f": reading.temperature_f,
+                            "humidity": reading.humidity,
+                            "pm25": reading.pm25,
+                            "voc_index": reading.voc_index,
+                            "nox_index": reading.nox_index,
+                            "co2": reading.co2,
+                        }
+                    )
+
+            time_range = end_datetime - start_datetime
+            print(
+                f"Successfully saved {len(results)} records for RoomC to '{output_file}'"
+                + f" (time range: {time_range})"
+                + (f" (sampled every {sample_rate} minutes)" if sample_rate > 1 else "")
+            )
+        return results
+    # pylint:disable=broad-except
+    except Exception as e:
+        print(f"Error fetching data: {e}")
+        return []
+
+    finally:
+        # Always close the session
+        session.close()
+
+
+if __name__ == "__main__":
+
+    records = fetch_data(
+        room=ROOM,
+        start_datetime=QUERY_START,
+        end_datetime=QUERY_END,
+        sample_rate=30,
+        output_file="sensor_data.csv",
+    )
+
+    with open("sensor_data.csv", "r") as f:
+        csv_data = f.read()
+
+    stream = chat(
+        model=MODEL,
+        messages=[
+            {
+                "role": "user",
+                "content": PROMPT.replace("%%_DATA_PLACEHOLDER_%%", csv_data),
+            },
+        ],
+        stream=True,
+    )
+
+    for chunk in stream:
+        print(chunk["message"]["content"], end="", flush=True)
diff --git a/Raspberry_Pi_LLM_Sensor_Data/sensor-reading.service b/Raspberry_Pi_LLM_Sensor_Data/sensor-reading.service
@@ -0,0 +1,35 @@
+# SPDX-FileCopyrightText: 2025 Tim Cocks for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+[Unit]
+Description=Python Script with Virtual Environment
+After=network.target
+Wants=network.target
+
+[Service]
+Type=simple
+User=pi
+Group=pi
+WorkingDirectory=/home/pi/RaspberryPi_LLM_Sensor_Data
+Environment=PATH=/home/pi/venvs/sensor_llm_venv/bin
+ExecStart=/home/pi/RaspberryPi_LLM_Sensor_Data/start_service.sh
+Restart=always
+RestartSec=10
+
+# Optional: Set environment variables
+Environment=PYTHONPATH=/home/pi/RaspberryPi_LLM_Sensor_Data
+Environment=PYTHONUNBUFFERED=1
+
+# Optional: Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=Environmental-Sensor-Reader
+
+# Optional: Security settings
+NoNewPrivileges=yes
+ProtectSystem=strict
+#ProtectHome=yes
+ReadWritePaths=/home/pi/RaspberryPi_LLM_Sensor_Data
+
+[Install]
+WantedBy=multi-user.target
diff --git a/Raspberry_Pi_LLM_Sensor_Data/start_service.sh b/Raspberry_Pi_LLM_Sensor_Data/start_service.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+# SPDX-FileCopyrightText: 2025 Tim Cocks for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+cd /home/pi/RaspberryPi_LLM_Sensor_Data
+source /home/pi/venvs/sensor_llm_venv/bin/activate
+exec python /home/pi/RaspberryPi_LLM_Sensor_Data/take_sensor_readings.py
diff --git a/Raspberry_Pi_LLM_Sensor_Data/take_sensor_readings.py b/Raspberry_Pi_LLM_Sensor_Data/take_sensor_readings.py
