Now, NPG-LITE BLE is added with autoscanning of devices

Author: PayalLakra

app.py

@@ -1,19 +1,25 @@
-from flask import Flask, render_template, request, redirect, url_for, jsonify
+from flask import Flask, render_template, request, redirect, url_for, jsonify, session
 import subprocess
 import psutil
 import signal
 import sys
 import atexit
 import time
 import os
+import json
+from threading import Thread
 
 app = Flask(__name__)
+app.secret_key = 'your_secret_key_here'
+
 lsl_process = None
 lsl_running = False
 npg_running = False
 npg_process = None
 app_processes = {}
 current_message = None
+discovered_devices = []
+npg_connection_thread = None
 
 def is_process_running(name):
     for proc in psutil.process_iter(['pid', 'name']):
@@ -23,7 +29,93 @@ def is_process_running(name):
 
 @app.route("/")
 def home():
-    return render_template("index.html", lsl_started=lsl_running, npg_started=npg_running, running_apps=[k for k,v in app_processes.items() if v.poll() is None], message=current_message)
+    return render_template("index.html", lsl_started=lsl_running, npg_started=npg_running, running_apps=[k for k,v in app_processes.items() if v.poll() is None], message=current_message, devices=session.get('devices', []), selected_device=session.get('selected_device'))
+
+@app.route("/scan_devices", methods=["POST"])
+def scan_devices():
+    global discovered_devices
+    
+    try:
+        # Run the scanning in a separate process
+        scan_process = subprocess.Popen([sys.executable, "npg-ble.py", "--scan"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        
+        # Wait for scan to complete (with timeout)
+        try:
+            stdout, stderr = scan_process.communicate(timeout=10)
+            if scan_process.returncode != 0:
+                raise Exception(f"Scan failed: {stderr}")
+            
+            # Parse the output to get devices
+            devices = []
+            for line in stdout.split('\n'):
+                if line.startswith("DEVICE:"):
+                    parts = line[len("DEVICE:"):].strip().split('|')
+                    if len(parts) >= 2:
+                        devices.append({
+                            "name": parts[0],
+                            "address": parts[1]
+                        })
+            
+            session['devices'] = devices
+            discovered_devices = devices
+            return jsonify({"status": "success", "devices": devices})
+            
+        except subprocess.TimeoutExpired:
+            scan_process.kill()
+            return jsonify({"status": "error", "message": "Device scan timed out"})
+            
+    except Exception as e:
+        return jsonify({"status": "error", "message": str(e)})
+
+@app.route("/connect_device", methods=["POST"])
+def connect_device():
+    global npg_process, npg_running, npg_connection_thread
+    
+    device_address = request.form.get("device_address")
+    if not device_address:
+        return jsonify({"status": "error", "message": "No device selected"})
+    
+    session['selected_device'] = device_address
+    
+    def connect_and_monitor():
+        global npg_process, npg_running, current_message
+        
+        try:
+            script_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "npg-ble.py")
+            npg_process = subprocess.Popen([sys.executable, script_path, "--connect", device_address], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1)
+            
+            # Monitor the output for connection status
+            connected = False
+            start_time = time.time()
+            while time.time() - start_time < 10:  # 10 second timeout
+                line = npg_process.stdout.readline()
+                if not line:
+                    break
+                if "Connected to" in line:
+                    connected = True
+                    npg_running = True
+                    current_message = f"Connected to {device_address}"
+                    break
+            
+            if not connected:
+                current_message = f"Failed to connect to {device_address}"
+                if npg_process.poll() is None:
+                    npg_process.terminate()
+                npg_running = False
+        
+        except Exception as e:
+            current_message = f"Connection error: {str(e)}"
+            npg_running = False
+    
+    # Start the connection in a separate thread
+    npg_connection_thread = Thread(target=connect_and_monitor)
+    npg_connection_thread.start()
+    
+    return jsonify({"status": "pending"})
+
+@app.route("/check_connection", methods=["GET"])
+def check_connection():
+    return jsonify({"connected": npg_running, "message": current_message})
 
 @app.route("/start_lsl", methods=["POST"])
 def start_lsl():

npg-ble.py

@@ -2,6 +2,8 @@
 from bleak import BleakScanner, BleakClient
 import time
 from pylsl import StreamInfo, StreamOutlet
+import sys
+import argparse
 
 # BLE parameters (must match your firmware)
 DEVICE_NAME_PREFIX = "NPG"
@@ -14,27 +16,39 @@
 BLOCK_COUNT = 10                   # Batch size: 10 samples per notification
 NEW_PACKET_LEN = SINGLE_SAMPLE_LEN * BLOCK_COUNT  # Total packet length (70 bytes)
 
-# Set up an LSL stream with int16 data format (irregular rate)
-stream_name = "NPG"
-info = StreamInfo(stream_name, "EXG", 3, 0, "int16", "uid007")
-outlet = StreamOutlet(info)
-
-# Global variables for unrolled counter, sample counting, and timing
-prev_unrolled_counter = None  # Unrolled (cumulative) counter from firmware
-samples_received = 0          # Total samples received in the last second
-start_time = None             # Time when first sample is received
+# Global variables
+prev_unrolled_counter = None
+samples_received = 0
+start_time = None
 total_missing_samples = 0
+outlet = None
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--scan", action="store_true", help="Scan for devices and print them")
+    parser.add_argument("--connect", type=str, help="Connect to a specific device address")
+    return parser.parse_args()
+
+async def scan_devices():
+    print("Scanning for BLE devices...", file=sys.stderr)
+    devices = await BleakScanner.discover()
+    filtered = [d for d in devices if d.name and d.name.startswith(DEVICE_NAME_PREFIX)]
+    
+    if not filtered:
+        print("No devices found.", file=sys.stderr)
+        return
+    
+    # Print devices in format that Flask can parse
+    for dev in filtered:
+        print(f"DEVICE:{dev.name}|{dev.address}")
 
 def process_sample(sample_data: bytearray):
-    global prev_unrolled_counter, samples_received, start_time, total_missing_samples
+    global prev_unrolled_counter, samples_received, start_time, total_missing_samples, outlet
+    
     if len(sample_data) != SINGLE_SAMPLE_LEN:
         print("Unexpected sample length:", len(sample_data))
         return
-    # Expected sample format:
-    # Byte0: Packet counter (0-255)
-    # Byte1-2: Channel 0 data (big-endian)
-    # Byte3-4: Channel 1 data (big-endian)
-    # Byte5-6: Channel 2 data (big-endian)
+        
     sample_counter = sample_data[0]
     # Unroll the counter:
     if prev_unrolled_counter is None:
@@ -45,76 +59,97 @@ def process_sample(sample_data: bytearray):
             current_unrolled = prev_unrolled_counter - last + sample_counter + 256
         else:
             current_unrolled = prev_unrolled_counter - last + sample_counter
+        
         if current_unrolled != prev_unrolled_counter + 1:
-            print(f"Missing sample: expected {prev_unrolled_counter + 1}, got {current_unrolled}")
-            total_missing_samples += current_unrolled - (prev_unrolled_counter + 1)
+            missing = current_unrolled - (prev_unrolled_counter + 1)
+            print(f"Missing {missing} sample(s): expected {prev_unrolled_counter + 1}, got {current_unrolled}")
+            total_missing_samples += missing
+        
         prev_unrolled_counter = current_unrolled
 
     # Set start_time when first sample is received
     if start_time is None:
         start_time = time.time()
-    elapsed = time.time() - start_time
-
-    channels = []
-    for ch in range(3):
-        offset = 1 + ch * 2
-        value = int.from_bytes(sample_data[offset:offset+2], byteorder='big', signed=True)
-        channels.append(value)
-    print(f"Sample {prev_unrolled_counter} at {elapsed:.2f} s: Channels: {channels} Total missing samples: {total_missing_samples}")
-    outlet.push_sample(channels)
+    
+    # Process channels
+    channels = [
+        int.from_bytes(sample_data[1:3]),  # Channel 0
+        int.from_bytes(sample_data[3:5]),  # Channel 1
+        int.from_bytes(sample_data[5:7])]
+    
+    # Push to LSL
+    if outlet:
+        outlet.push_sample(channels)
+    
     samples_received += 1
+    
+    # Periodic status print
+    if samples_received % 100 == 0:
+        elapsed = time.time() - start_time
+        print(f"Sample {prev_unrolled_counter} at {elapsed:.2f}s - Channels: {channels} - Missing: {total_missing_samples}")
 
 def notification_handler(sender, data: bytearray):
-    if len(data) == NEW_PACKET_LEN:
-        for i in range(0, NEW_PACKET_LEN, SINGLE_SAMPLE_LEN):
-            sample = data[i:i+SINGLE_SAMPLE_LEN]
-            process_sample(sample)
-    elif len(data) == SINGLE_SAMPLE_LEN:
-        process_sample(data)
-    else:
-        print("Unexpected packet length:", len(data))
-
-async def print_rate():
-    global samples_received
-    while True:
-        await asyncio.sleep(1)
-        print(f"Samples per second: {samples_received}")
-        samples_received = 0
-
-async def run():
-    print("Scanning for BLE devices with name starting with", DEVICE_NAME_PREFIX)
-    devices = await BleakScanner.discover()
-    # Filter devices with names starting with the prefix
-    filtered = [d for d in devices if d.name and d.name.lower().startswith(DEVICE_NAME_PREFIX.lower())]
-    if not filtered:
-        print("No devices found.")
-        return
+    try:
+        if len(data) == NEW_PACKET_LEN:
+            # Process batched samples
+            for i in range(0, NEW_PACKET_LEN, SINGLE_SAMPLE_LEN):
+                process_sample(data[i:i+SINGLE_SAMPLE_LEN])
+        elif len(data) == SINGLE_SAMPLE_LEN:
+            # Process single sample
+            process_sample(data)
+        else:
+            print(f"Unexpected packet length: {len(data)} bytes")
+    except Exception as e:
+        print(f"Error processing data: {e}")
 
-    print("Found devices:")
-    for idx, dev in enumerate(filtered):
-        print(f"{idx}: {dev.name} ({dev.address})")
+async def connect_to_device(device_address):
+    global outlet
+    
+    print(f"Attempting to connect to {device_address}...", file=sys.stderr)
 
-    # Let the user choose which device to connect to
+    # Set up LSL stream (500Hz sampling rate)
+    info = StreamInfo("NPG", "EXG", 3, 500, "int16", "npg1234")
+    outlet = StreamOutlet(info)
+    
+    client = None
     try:
-        choice = int(input("Enter the index of the device to connect: "))
-        target = filtered[choice]
-    except (ValueError, IndexError):
-        print("Invalid selection.")
-        return
-
-    print("Connecting to:", target.name, target.address)
-    async with BleakClient(target) as client:
+        client = BleakClient(device_address)
+        await client.connect()
+        
         if not client.is_connected:
-            print("Failed to connect")
-            return
-        print("Connected to", target.name)
+            print("Failed to connect", file=sys.stderr)
+            return False
+        
+        print(f"Connected to {device_address}")
+        
+        # Send start command
         await client.write_gatt_char(CONTROL_CHAR_UUID, b"START", response=True)
         print("Sent START command")
+        
+        # Subscribe to notifications
         await client.start_notify(DATA_CHAR_UUID, notification_handler)
         print("Subscribed to data notifications")
-        asyncio.create_task(print_rate())
-        while True:
+        
+        # Keep connection alive
+        while client.is_connected:
             await asyncio.sleep(1)
+            
+        return True
+        
+    except Exception as e:
+        print(f"Connection error: {str(e)}", file=sys.stderr)
+        return False
+    finally:
+        if client and client.is_connected:
+            await client.disconnect()
 
 if __name__ == "__main__":
-    asyncio.run(run())
+    args = parse_args()
+    
+    if args.scan:
+        asyncio.run(scan_devices())
+    elif args.connect:
+        asyncio.run(connect_to_device(args.connect))
+    else:
+        print("Please specify --scan or --connect", file=sys.stderr)
+        sys.exit(1)