Update app.py

app.py

@@ -7,22 +7,22 @@ import os
 import csv
 import io
 
-# ─── CONFIG ───────────────────────────────────────────
-HOST = "0.0.0.0"
-PORT = 7860
-
-BASE_DIR = os.path.dirname(__file__)
-DB_PATH = os.path.join(BASE_DIR, "telemetry.db")
+# ─── CONFIG ──────────────────────────────────────────────────
+HOST    = "0.0.0.0"
+PORT    = 7860
+DB_PATH = os.path.join(os.path.dirname(__file__), "telemetry.db")
 
 app = Flask(__name__)
 CORS(app)
 
-# ─── DATABASE ─────────────────────────────────────────
+# ─── DATABASE ─────────────────────────────────────────────────
 
 def get_db():
     if "db" not in g:
-        g.db = sqlite3.connect(DB_PATH)
+        g.db = sqlite3.connect(DB_PATH, detect_types=sqlite3.PARSE_DECLTYPES)
         g.db.row_factory = sqlite3.Row
+        g.db.execute("PRAGMA journal_mode=WAL")
+        g.db.execute("PRAGMA synchronous=NORMAL")
     return g.db
 
 
@@ -35,37 +35,44 @@ def close_db(exc=None):
 
 def init_db():
     with sqlite3.connect(DB_PATH) as db:
+        db.execute("PRAGMA journal_mode=WAL")
         db.execute("""
-        CREATE TABLE IF NOT EXISTS telemetry (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            device_id TEXT,
-            server_time TEXT,
-            server_unix REAL,
-            uptime_sec INTEGER,
-
-            speed_pct REAL,
-            speed_ups REAL,
-
-            pos_x REAL,
-            pos_y REAL,
-            pos_z REAL,
-            total_distance REAL,
-
-            voltage_V REAL,
-            current_mA REAL,
-            current_A REAL,
-            power_mW REAL,
-            power_W REAL,
-            drawn_mW REAL,
-            generated_mW REAL,
-
-            samples INTEGER,
-            interval_sec INTEGER
-        )
+            CREATE TABLE IF NOT EXISTS telemetry (
+                id             INTEGER PRIMARY KEY AUTOINCREMENT,
+                device_id      TEXT    NOT NULL,
+                server_time    TEXT    NOT NULL,
+                server_unix    REAL    NOT NULL,
+                uptime_sec     INTEGER DEFAULT 0,
+
+                -- Motion
+                speed_pct      REAL    NOT NULL,
+                speed_ups      REAL    NOT NULL,
+                pos_x          REAL    NOT NULL,
+                pos_y          REAL    NOT NULL DEFAULT 0,
+                pos_z          REAL    NOT NULL DEFAULT 0,
+                total_distance REAL    NOT NULL,
+
+                -- Power
+                voltage_V      REAL    NOT NULL,
+                current_mA     REAL    NOT NULL,
+                current_A      REAL    NOT NULL,
+                power_mW       REAL    NOT NULL,
+                power_W        REAL    NOT NULL,
+                drawn_mW       REAL    NOT NULL DEFAULT 0,
+                generated_mW   REAL    NOT NULL DEFAULT 0,
+                samples        INTEGER NOT NULL DEFAULT 25,
+                interval_sec   INTEGER NOT NULL DEFAULT 5
+            )
         """)
+
+        db.execute("""
+            CREATE INDEX IF NOT EXISTS idx_device_time
+            ON telemetry (device_id, server_unix DESC)
+        """)
+
         db.commit()
 
-    print("Database initialized")
+    print(f"[DB] SQLite ready → {DB_PATH}")
 
 
 # 🔴 IMPORTANT FIX (Gunicorn compatible)
@@ -73,130 +80,180 @@ with app.app_context():
     init_db()
 
 
-# ─── HELPERS ─────────────────────────────────────────
+def row_to_dict(row):
+    return dict(row)
+
+
+# ─── HELPERS ──────────────────────────────────────────────────
 
 def query(sql, params=(), one=False):
     cur = get_db().execute(sql, params)
     rows = cur.fetchall()
-    data = [dict(r) for r in rows]
-    return (data[0] if data else None) if one else data
+    result = [row_to_dict(r) for r in rows]
+    return result[0] if (one and result) else (None if one else result)
+
+
+def compute_stats(rows):
+    if not rows:
+        return {}
 
+    n = len(rows)
 
-def safe_float(data, key, default=0):
+    return {
+        "speed_avg_pct": round(sum(r["speed_pct"] for r in rows) / n, 2),
+        "speed_max_pct": round(max(r["speed_pct"] for r in rows), 2),
+        "power_avg_mW": round(sum(r["power_mW"] for r in rows) / n, 2),
+        "power_max_mW": round(max(r["power_mW"] for r in rows), 2),
+        "voltage_avg_V": round(sum(r["voltage_V"] for r in rows) / n, 3),
+        "pos_x_latest": round(rows[-1]["pos_x"], 3),
+        "pos_x_range": round(
+            max(r["pos_x"] for r in rows) - min(r["pos_x"] for r in rows), 3
+        ),
+    }
+
+
+def safe_float(data, key, default=0.0):
     try:
         return float(data.get(key, default))
-    except:
+    except (TypeError, ValueError):
         return default
 
 
-# ─── ROUTES ─────────────────────────────────────────
-
+# ─── ROUTES ───────────────────────────────────────────────────
 
 @app.post("/api/telemetry")
-def receive():
-    data = request.get_json()
+def receive_telemetry():
+
+    data = request.get_json(force=True, silent=True)
 
     if not data:
-        return jsonify({"error": "invalid json"}), 400
+        return jsonify({"error": "Invalid JSON"}), 400
+
+    required = ["device_id", "speed_pct", "speed_ups", "position", "total_distance", "power"]
 
-    pos = data.get("position", {})
-    pwr = data.get("power", {})
+    missing = [k for k in required if k not in data]
+
+    if missing:
+        return jsonify({"error": f"Missing fields: {missing}"}), 400
+
+    pos = data["position"]
+    pwr = data["power"]
 
     now = datetime.now()
-    server_time = now.isoformat()
+    server_time = now.isoformat(timespec="milliseconds")
     server_unix = time.time()
 
     db = get_db()
 
     db.execute("""
-    INSERT INTO telemetry (
-        device_id, server_time, server_unix, uptime_sec,
-        speed_pct, speed_ups,
-        pos_x, pos_y, pos_z, total_distance,
-        voltage_V, current_mA, current_A,
-        power_mW, power_W, drawn_mW, generated_mW,
-        samples, interval_sec
-    )
-    VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+        INSERT INTO telemetry (
+            device_id, server_time, server_unix, uptime_sec,
+            speed_pct, speed_ups,
+            pos_x, pos_y, pos_z, total_distance,
+            voltage_V, current_mA, current_A,
+            power_mW, power_W, drawn_mW, generated_mW,
+            samples, interval_sec
+        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
     """, (
-        data.get("device_id"),
+        data["device_id"],
         server_time,
         server_unix,
         data.get("uptime_sec", 0),
 
-        data.get("speed_pct", 0),
-        data.get("speed_ups", 0),
+        float(data["speed_pct"]),
+        float(data["speed_ups"]),
 
         safe_float(pos, "x"),
         safe_float(pos, "y"),
         safe_float(pos, "z"),
-        data.get("total_distance", 0),
-
-        pwr.get("voltage_V", 0),
-        pwr.get("current_mA", 0),
-        pwr.get("current_A", 0),
-        pwr.get("power_mW", 0),
-        pwr.get("power_W", 0),
-        pwr.get("drawn_mW", 0),
-        pwr.get("generated_mW", 0),
-
-        pwr.get("samples", 25),
-        pwr.get("interval_sec", 5),
+        float(data["total_distance"]),
+
+        float(pwr["voltage_V"]),
+        float(pwr["current_mA"]),
+        float(pwr["current_A"]),
+        float(pwr["power_mW"]),
+        float(pwr["power_W"]),
+
+        safe_float(pwr, "drawn_mW"),
+        safe_float(pwr, "generated_mW"),
+
+        int(pwr.get("samples", 25)),
+        int(pwr.get("interval_sec", 5)),
     ))
 
     db.commit()
 
-    return jsonify({"status": "ok"})
+    return jsonify({"status": "ok", "server_time": server_time}), 201
 
 
 @app.get("/api/latest")
-def latest():
+def get_latest():
+
     row = query(
         "SELECT * FROM telemetry ORDER BY server_unix DESC LIMIT 1",
         one=True
     )
 
     if not row:
-        return jsonify({"error": "no data"}), 404
+        return jsonify({"error": "No data yet"}), 404
 
-    return jsonify(row)
+    total = query("SELECT COUNT(*) AS n FROM telemetry", one=True)["n"]
+
+    return jsonify({
+        "latest": row,
+        "total_stored": total
+    })
 
 
 @app.get("/api/history")
-def history():
-    limit = int(request.args.get("limit", 100))
+def get_history():
+
+    limit = min(int(request.args.get("limit", 200)), 1000)
 
     rows = query(
         "SELECT * FROM telemetry ORDER BY server_unix DESC LIMIT ?",
         (limit,)
     )
 
+    rows = list(reversed(rows))
+
     return jsonify({
+        "readings": rows,
         "count": len(rows),
-        "data": list(reversed(rows))
+        "stats": compute_stats(rows)
     })
 
 
 @app.get("/api/devices")
-def devices():
+def get_devices():
+
     rows = query("""
-    SELECT device_id,
-           COUNT(*) as packets,
-           MAX(server_time) as last_seen
-    FROM telemetry
-    GROUP BY device_id
+        SELECT device_id,
+               COUNT(*) AS total_packets,
+               MAX(server_time) AS last_seen,
+               MAX(pos_x) AS max_x,
+               MAX(speed_pct) AS max_speed,
+               AVG(voltage_V) AS avg_voltage,
+               AVG(power_mW) AS avg_power
+        FROM telemetry
+        GROUP BY device_id
     """)
 
-    return jsonify(rows)
+    devices = {r["device_id"]: r for r in rows}
+
+    return jsonify({
+        "devices": devices,
+        "count": len(devices)
+    })
 
 
 @app.get("/api/export")
 def export_csv():
 
-    rows = query("SELECT * FROM telemetry")
+    rows = query("SELECT * FROM telemetry ORDER BY server_unix ASC")
 
     if not rows:
-        return jsonify({"error": "no data"}), 404
+        return jsonify({"error": "No data"}), 404
 
     out = io.StringIO()
 
@@ -207,40 +264,50 @@ def export_csv():
     return Response(
         out.getvalue(),
         mimetype="text/csv",
-        headers={"Content-Disposition": "attachment; filename=telemetry.csv"}
+        headers={"Content-Disposition": "attachment; filename=telemetry_all.csv"}
     )
 
 
 @app.delete("/api/clear")
-def clear():
+def clear_data():
 
     db = get_db()
     db.execute("DELETE FROM telemetry")
     db.commit()
 
-    return jsonify({"status": "cleared"})
+    return jsonify({"status": "ok", "message": "All data cleared"})
 
 
 @app.get("/health")
 def health():
 
-    row = query("SELECT COUNT(*) as n FROM telemetry", one=True)
+    row = query("SELECT COUNT(*) AS n FROM telemetry", one=True)
 
     return jsonify({
         "status": "ok",
-        "records": row["n"] if row else 0,
         "db": DB_PATH,
-        "time": datetime.now().isoformat()
+        "total_records": row["n"] if row else 0,
+        "server_time": datetime.now().isoformat(timespec="milliseconds")
     })
 
 
 @app.get("/")
 def dashboard():
-    return send_file(os.path.join(BASE_DIR, "dashboard.html"))
+
+    html_path = os.path.join(os.path.dirname(__file__), "dashboard.html")
+
+    return send_file(html_path)
 
 
-# ─── LOCAL RUN ───────────────────────────────────────
+# ─── MAIN ─────────────────────────────────────────────────────
 
 if __name__ == "__main__":
-    print("Server running at http://localhost:7860")
-    app.run(host=HOST, port=PORT)
+
+    init_db()
+
+    print(f"\n[SERVER] Flask running  → http://{HOST}:{PORT}")
+    print(f"[SERVER] Dashboard      → http://localhost:{PORT}")
+    print(f"[SERVER] API telemetry  → POST http://localhost:{PORT}/api/telemetry")
+    print(f"[SERVER] DB path        → {DB_PATH}\n")
+
+    app.run(host=HOST, port=PORT, debug=True)