Merge branch 'bio_amptool' of https://github.com/PayalLakra/Chords-Python

Author: Amanmahe

app.py

@@ -4,9 +4,14 @@
 import os
 import signal
 import sys
+import atexit
+import threading
 
 app = Flask(__name__)
 lsl_process = None
+lsl_running = False
+npg_running = False
+npg_process = None
 app_processes = {}
 
 def is_process_running(name):
@@ -21,36 +26,70 @@ def home():
 
 @app.route("/start_lsl", methods=["POST"])
 def start_lsl():
-    global lsl_process
-    if lsl_process and lsl_process.poll() is None:
+    global lsl_process, lsl_running
+
+    if lsl_running:
         return jsonify({"status": "LSL stream already running", "lsl_started": True})
+
     try:
-        # Start the LSL stream as a subprocess
         if sys.platform == "win32":
-            lsl_process = subprocess.Popen(["python", "chords.py", "--lsl"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, creationflags=subprocess.CREATE_NO_WINDOW)
+            lsl_process = subprocess.Popen(["python", "chords.py", "--lsl"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, creationflags=subprocess.CREATE_NO_WINDOW, text=True)
         else:
-            lsl_process = subprocess.Popen(["python", "chords.py", "--lsl"],stdout=subprocess.PIPE,stderr=subprocess.PIPE)
-        output = lsl_process.stderr.readline().decode().strip()  # Read the initial stderr line
+            lsl_process = subprocess.Popen(["python", "chords.py", "--lsl"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
 
+        output = lsl_process.stderr.readline().strip()
         print(output)
-        if output == "No":
-            return render_template("index.html", lsl_started=False, lsl_status="Failed to Start", lsl_color="red")
+
+        if "No" in output:
+            lsl_running = False
+            return jsonify({"lsl_started": False, "lsl_status": "Failed to Start", "lsl_color": "red"})
         else:
-            return render_template("index.html", lsl_started=True, lsl_status="Running", lsl_color="green")
-    except subprocess.TimeoutExpired:
-        return render_template(
-            "index.html", lsl_started=False, lsl_status="Timeout Error", lsl_color="red"
-        )
+            lsl_running = True
+            return jsonify({"lsl_started": True, "lsl_status": "Running", "lsl_color": "green"})
+
     except Exception as e:
-        return render_template("index.html", lsl_started=False, lsl_status=f"Error: {e}", lsl_color="red")
+        return jsonify({"lsl_started": False, "lsl_status": f"Error: {e}", "lsl_color": "red"})
+
+def read_npg_output():
+    global npg_process
+
+    if npg_process:
+        for line in iter(npg_process.stdout.readline, ''):
+            print(line.strip())  # Print npg.py output to the terminal
+
+@app.route("/start_npg", methods=["POST"])
+def start_npg():
+    global npg_process, npg_running
+
+    if npg_running:
+        return jsonify({"status": "NPG already running", "npg_started": True})
+
+    try:
+        if sys.platform == "win32":
+            npg_process = subprocess.Popen(["python", "npg.py"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, creationflags=subprocess.CREATE_NO_WINDOW, text=True, bufsize=1)
+        else:
+            npg_process = subprocess.Popen(["python3", "npg.py"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1)
+
+        # Start a separate thread to read npg.py output
+        threading.Thread(target=read_npg_output, daemon=True).start()
+
+        npg_running = True
+        return render_template("index.html", npg_started=True, npg_status="Running", npg_color="green", apps_enabled=True)
+
+    except Exception as e:
+        npg_running = False
+        return render_template("index.html", npg_started=False, npg_status=f"Error: {e}", npg_color="red", apps_enabled=False)
 
 @app.route("/run_app", methods=["POST"])
 def run_app():
+    global lsl_running, npg_running
     app_name = request.form.get("app_name")
 
-    # Check if the app is already running
+    if not (lsl_running or npg_running):
+        return render_template("index.html", message="Start LSL or NPG first!", running_apps=app_processes.keys())
+
     if app_name in app_processes and app_processes[app_name].poll() is None:
-        return render_template("index.html", lsl_started=True, lsl_status="Running", lsl_color="green", message=f"{app_name} is already Running", running_apps=app_processes.keys())
+        return render_template("index.html", message=f"{app_name} is already running", running_apps=app_processes.keys())
 
     try:
         # Start the app subprocess
@@ -60,19 +99,19 @@ def run_app():
             process = subprocess.Popen(["python", f"{app_name}.py"])
 
         app_processes[app_name] = process
-        return render_template("index.html", lsl_started=True, lsl_status="Running", lsl_color="green", running_apps=app_processes.keys(), message=None)
-        
+        return render_template("index.html", running_apps=app_processes.keys(), message=None)
     except Exception as e:
-        return render_template("index.html", lsl_started=True, lsl_status="Running", lsl_color="green", message=f"Error starting {app_name}: {e}", running_apps=app_processes.keys())
+        return render_template("index.html", message=f"Error starting {app_name}: {e}", running_apps=app_processes.keys())
 
 @app.route("/app_status", methods=["GET"])
 def app_status():
     # Check the status of all apps
     try:
         statuses = {
-            app_name: (process.poll() is None)  # True if running, False if not
-            for app_name, process in app_processes.items()
+            "lsl_started": lsl_running,
+            "npg_started": npg_running
         }
+        statuses.update({app_name: (process.poll() is None) for app_name, process in app_processes.items()})
         return jsonify(statuses)
     except Exception as e:
        return jsonify({"error": str(e)}), 500
@@ -83,7 +122,7 @@ def stop_lsl():
     return jsonify({'status': 'LSL Stream and applications stopped and server is shutting down.'})
 
 def stop_all_processes():
-    global lsl_process, app_processes
+    global lsl_process, npg_process, app_processes, lsl_running, npg_running
 
     # Terminate LSL process
     if lsl_process and lsl_process.poll() is None:
@@ -92,25 +131,35 @@ def stop_all_processes():
             lsl_process.wait(timeout=3)
         except subprocess.TimeoutExpired:
             lsl_process.kill()
+        lsl_running = False
+
+    if npg_process and npg_process.poll() is None:
+        npg_process.terminate()
+        try:
+            npg_process.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            npg_process.kill()
+        npg_running = False
 
-    # Terminate all app processes
-    for app_name, process in app_processes.items():
+    for app_name, process in list(app_processes.items()):
         if process.poll() is None:
             process.terminate()
             try:
                 process.wait(timeout=3)
             except subprocess.TimeoutExpired:
                 process.kill()
+        del app_processes[app_name]
 
-    app_processes.clear()
     print("All processes terminated.")
 
 def handle_sigint(signal_num, frame):
     print("\nCtrl+C pressed! Stopping all processes...")
     stop_all_processes()
     sys.exit(0)
 
-signal.signal(signal.SIGINT, handle_sigint)   # Register signal handler for Ctrl+C
+# Register signal handler for Ctrl+C
+signal.signal(signal.SIGINT, handle_sigint)
+atexit.register(stop_all_processes)
 
 if __name__ == "__main__":
     app.run(debug=True)

beetle.py

@@ -2,19 +2,32 @@
 import pylsl
 import numpy as np
 import time
-from pylsl import StreamInlet, resolve_stream
+from pylsl import StreamInlet, resolve_streams, resolve_byprop
 from scipy.signal import iirnotch, butter, lfilter
 import math
 from PIL import Image
 
 # Initialize LSL stream
-streams = resolve_stream('name', 'BioAmpDataStream')
-if not streams:
-    print("No LSL stream found!")
-    exit()
+print("Searching for available LSL streams...")
+streams = resolve_streams()
+available_streams = [s.name() for s in streams]
+
+if not available_streams:
+    print("No LSL streams found!")
+
+for stream_name in available_streams:
+    print(f"Trying to connect to {stream_name}...")
+    resolved_streams = resolve_byprop('name', stream_name, timeout=2)
 
-inlet = StreamInlet(streams[0])
-print("LSL Stream Started")
+    if resolved_streams:
+        print(f"Successfully connected to {stream_name}!")
+        inlet = StreamInlet(resolved_streams[0])
+        break
+    else:
+        print(f"Failed to connect to {stream_name}.")
+
+if inlet is None:
+    print("Could not connect to any stream.")
 sampling_rate = int(inlet.info().nominal_srate())
 print(f"Sampling rate: {sampling_rate} Hz")
 
@@ -27,7 +40,7 @@
 
 # Beetle properties
 beetle_x, beetle_y = 380, 530
-focus_speed_upward = 15
+focus_speed_upward = 10
 focus_speed_downward = 5
 focus_timeout = 2
 focus_threshold = None
@@ -37,25 +50,19 @@
 screen = pygame.display.set_mode((800, 600))
 pygame.display.set_caption('Beetle Game')
 
-# Load GIF and extract frames
-gif_path = 'media/RobotBug.gif'
-gif = Image.open(gif_path)
-
-frames = []
-for frame in range(gif.n_frames):
-    gif.seek(frame)
-    frame_surface = pygame.image.fromstring(gif.tobytes(), gif.size, gif.mode)
-    frame_surface = pygame.transform.scale(frame_surface, (120, 120))
-    frames.append(frame_surface)
+sprite_count = 10
+beetle_sprites = [pygame.image.load(f'media/beetle{i}.JPG') for i in range(1, sprite_count + 1)]
+beetle_sprites = [pygame.transform.scale(sprite, (140, 160)) for sprite in beetle_sprites]
 
-frame_index = 0
-frame_delay = 100  # Time per frame in milliseconds
-last_frame_time = pygame.time.get_ticks()
+# Animation Variables
+current_sprite = 0
+animation_speed = 100
+sprite_timer = 0
 
 # Function to display a message on the screen
 def show_message(message, duration=3):
     start_time = time.time()
-    font = pygame.font.Font(None, 50)
+    font = pygame.font.SysFont("Arial", 50)
     text = font.render(message, True, (0, 0, 0))
     text_rect = text.get_rect(center=(400, 300))
 
@@ -84,7 +91,6 @@ def calculate_focus_level(eeg_data, sampling_rate=500):
     gamma_power = math.sqrt(np.sum((fft_data[(freqs >= 30) & (freqs <= 45)]) ** 2))
 
     power = (beta_power + gamma_power) / (delta_power + theta_power + alpha_power + beta_power + gamma_power)
-    print(power)
     return power
 
 # Calibration Phase
@@ -109,21 +115,23 @@ def calculate_focus_level(eeg_data, sampling_rate=500):
     std_focus = np.std(baseline_focus_levels)
 
     focus_threshold = mean_focus + 1.5 * std_focus  
-    print(f"Calibration Complete. Focus Threshold set at: {focus_threshold:.2f}")
+    print(f"Calibration Complete. Focus Threshold set at: {focus_threshold:.3f}")
 else:
     print("Calibration failed due to insufficient data.")
     exit()
 
 # Show Game Start Message
 show_message("Game Starting...", 1)
+game_start_time = time.time()
+game_duration = 45  # Game lasts 45 seconds
 
 # Update beetle position
 def update_beetle_position(focus_level, is_focus_stable):
     global beetle_y
     if is_focus_stable:
-        beetle_y = max(10 + frames[0].get_height() // 2, beetle_y - focus_speed_upward)     
+        beetle_y = max(10 + beetle_sprites[0].get_height() // 2, beetle_y - focus_speed_upward)     
     else:
-        beetle_y = min(580 - frames[0].get_height() // 2, beetle_y + focus_speed_downward)  
+        beetle_y = min(580 - beetle_sprites[0].get_height() // 2, beetle_y + focus_speed_downward)  
 
 print("STARTING GAME...")
 running = True
@@ -143,6 +151,8 @@ def update_beetle_position(focus_level, is_focus_stable):
             buffer.append(filtered_sample)
 
         current_time = time.time()
+        elapsed_time = int(current_time - game_start_time)
+
         if current_time - last_time >= 1:
             last_time = current_time
             buffer = buffer[int(len(buffer) * 0.2):]
@@ -152,6 +162,7 @@ def update_beetle_position(focus_level, is_focus_stable):
             buffer = []
 
             focus_level = calculate_focus_level(eeg_data)
+            print(focus_level)
 
             if focus_level > focus_threshold:
                 focus_timer = min(focus_timeout, focus_timer + (current_time - last_focus_time))
@@ -164,17 +175,32 @@ def update_beetle_position(focus_level, is_focus_stable):
 
             last_focus_time = current_time
 
-        # Update GIF animation
-        current_tick = pygame.time.get_ticks()
-        if current_tick - last_frame_time >= frame_delay:
-            frame_index = (frame_index + 1) % len(frames)
-            last_frame_time = current_tick
+        # Update sprite animation
+        sprite_timer += (current_time - last_focus_time)
+        if sprite_timer >= animation_speed:
+            sprite_timer = 0
+            current_sprite = (current_sprite + 1) % len(beetle_sprites)
+
+        # Check win condition
+        if beetle_y <= 80:
+            show_message("You Win!", 1)
+            running = False
+
+        # Check game over condition
+        if elapsed_time >= game_duration:
+            show_message("Game Over! Try Again.", 1)
+            running = False
 
+        # Draw everything
         screen.fill("#FFFFFF")
         pygame.draw.rect(screen, (0, 0, 0), (10, 10, 780, 580), 5)  
-        beetle_image = frames[frame_index]  # Get current frame
-        screen.blit(beetle_image, (beetle_x - beetle_image.get_width() // 2, beetle_y - beetle_image.get_height() // 2))
-        
+        screen.blit(beetle_sprites[current_sprite], (beetle_x - 40, beetle_y - 40))
+
+        # Display Timer
+        font = pygame.font.SysFont("Arial", 30)
+        timer_text = font.render(f"Time: {game_duration - elapsed_time}s", True, (0, 0, 0))
+        screen.blit(timer_text, (650, 20))  
+
         pygame.display.update()
 
     except KeyboardInterrupt:

chords.py

@@ -65,6 +65,7 @@
     "MEGA-2560-R3": {"sampling_rate": 250, "Num_channels": 16},
     "MEGA-2560-CLONE": {"sampling_rate": 250, "Num_channels": 16},
     "GIGA-R1": {"sampling_rate": 500, "Num_channels": 6},
+    "NPG-LITE": {"sampling_rate": 500, "Num_channels": 3},
 }
 
 # Initialize gloabal variables for Incoming Data

emgenvelope.py

@@ -39,11 +39,25 @@ def __init__(self):
         self.setCentralWidget(central_widget)
 
         # Set up LSL stream inlet
-        streams = pylsl.resolve_stream('name', 'BioAmpDataStream')
-        if not streams:
-            print("No LSL stream found!")
+        print("Searching for available LSL streams...")
+        available_streams = pylsl.resolve_streams()
+
+        if not available_streams:
+            print("No LSL streams found! Exiting...")
+            sys.exit(0)
+
+        self.inlet = None
+        for stream in available_streams:
+            try:
+                self.inlet = pylsl.StreamInlet(stream)
+                print(f"Connected to LSL stream: {stream.name()}")
+                break
+            except Exception as e:
+                print(f"Failed to connect to {stream.name()}: {e}")
+
+        if self.inlet is None:
+            print("Unable to connect to any LSL stream! Exiting...")
             sys.exit(0)
-        self.inlet = pylsl.StreamInlet(streams[0])
 
         # Sampling rate
         self.sampling_rate = int(self.inlet.info().nominal_srate())