Merge pull request #35 from PayalLakra/bio_amptool

Adding NPG, Beetle Game, and Updated Readme.

Author: lorforlinux

README.md

@@ -37,11 +37,24 @@ Chords Python script is designed to interface with an Arduino-based bio-potentia
    ```bash
    .\venv\Scripts\activate  
    ```
-3. Install the required Python libraries:
+
+> [!IMPORTANT]
+> You may get an execution policy error if scripts are restricted. To fix it, run:
+
+> ```bash
+> Set-ExecutionPolicy Unrestricted -Scope Process
+> ```
+
+3. Install the required Python libraries needed to run the python script:
     ```bash
     pip install -r chords_requirements.txt
     ```
 
+4. Install the required Python libraries needed to run the applications:
+    ```bash
+    pip install -r app_requirements.txt
+    ```
+
 ## Usage
 
 To use the script, run it from the command line with various options:
@@ -57,6 +70,12 @@ To use the script, run it from the command line with various options:
 - `-v`, `--verbose`: Enable verbose output with detailed statistics and error reporting.
 - `-t` : Enable the timer to run program for a set time in seconds.
 
+### Example:
+  ```bash
+  python chords.py --lsl -v --csv -t 60
+  ```
+- This command executes the Python script `chords.py`, initiates the LSL stream, enables verbose output, activates CSV logging, and sets a timer for 60 seconds:  
+
 ### Data Logging
 
 - **CSV Output**: The script saves the processed data in a CSV file with a timestamped name.
@@ -78,37 +97,45 @@ pip install -r app_requirements.txt
 
 ### Available Applications  
 
-#### GUI  
-
-- `python gui.py`: Enable the real-time data plotting GUI.
-
-#### TUG OF WAR GAME
-
-- `python game.py`: Enable a GUI to play tug of war game using EEG Signal.
-
-#### HEART RATE
+#### ECG with Heart Rate
 
 - `python heartbeat_ecg.py`:Enable a GUI with real-time ECG and heart rate.
 
-#### EMG ENVELOPE
+#### EMG with Envelope
 
 - `python emgenvelope.py`: Enable a GUI with real-time EMG & its Envelope.
 
-#### EOG
+#### EOG with Blinks
 
 - `python eog.py`: Enable a GUI with real-time EOG that detects blinks and mark them with red dots.
 
-#### EEG
+#### EEG with FFT
 
 - `python ffteeg.py`: Enable a GUI with real-time EEG data with its FFT and band powers.
 
-#### Keystroke
+#### EEG Tug of War Game
+
+- `python game.py`: Enable a GUI to play tug of war game using EEG Signal.
+
+#### EEG Beetle Game
+
+- `python beetle.py`: Enable a GUI for Beetle Game using EEG signal.
+
+#### GUI  
+
+- `python gui.py`: Enable the real-time data plotting GUI.
+
+#### EOG Keystroke Emulator
 
 - `python keystroke.py`: On running, a pop-up opens for connecting, and on pressing Start, blinks are detected to simulate spacebar key presses.
 
-## Running All Applications Together
+#### CSV Plotter
+
+- `python csv_plotter.py`: On running, a pop-up window opens with option to load a file, select a channel to plot, and then plot the data.
+
+## Running All Applications Together in a Web-Interface
 
-To run all applications together:
+To run all applications simultaneously, execute:
 
 ```bash
 python app.py
@@ -122,29 +149,32 @@ pip install -r app_requirements.txt
 
 This will launch a Web interface. Use the interface to control the applications:
 
-1. Click the `Start LSL Stream` button to initiate the LSL stream.
+1. Click the `Start LSL Stream` button to initiate the LSL stream or `Start NPG Stream` button to initiate the NPG stream.
 2. Then, click on any application button to run the desired module.
+Important: Keep the `python app.py` script running in the background while using any application.
 
 ### Available Applications
-- `ffteeg`: Real-time EEG analysis with FFT and brainwave power calculation.
-- `heartbeat_ecg`: Analyze ECG data and extract heartbeat metrics.
-- `eog`: Real-time EOG monitoring with blink detection.
-- `emgenvelope`: Real-time EMG monitor with filtering and RMS envelope.
-- `keystroke`: GUI for EOG-based blink detection triggering a keystroke.
-- `game`: Launch an EEG game for 2 players (Tug of War).
-- `csv_plotter`: Plot data from a CSV file.
-- `gui`: Launch the GUI for real time signal visualization.
+- `ECG with Heart Rate`: Analyze ECG data and extract heartbeat metrics.
+- `EMG with Envelope`: Real-time EMG monitor with filtering and RMS envelope.
+- `EOG with Blinks`: Real-time EOG monitoring with blink detection.
+- `EEG with FFT`: Real-time EEG analysis with FFT and brainwave power calculation.
+- `EEG Tug of War`: A 2-player game where brain activity determines the winner in a battle of focus.  
+- `EEG Beetle Game`: Use your concentration to control a beetle's movement in this brain-powered challenge.
+- `GUI of Channels`: Launch the GUI for real time signal visualization.
+- `EOG Keystroke Emulator`: GUI for EOG-based blink detection triggering a keystroke.
+- `CSV Plotter`: Plot data from a CSV file.
 
 ## Troubleshooting
 
 - **Arduino Not Detected:** Ensure the Arduino is properly connected and powered. Check the serial port and baud rate settings.
 - **CSV File Not Created:** Ensure you have write permissions in the directory where the script is run.
-- **LSL Stream Issues:** Verify that the `pylsl` library is installed and configured correctly.
+- **LSL Stream Issues:** Ensure that the `pylsl` library is properly installed and configured. Additionally, confirm that Bluetooth is turned off.
 
 ## Contributors
 
 We are thankful to our awesome contributors, the list below is alphabetically sorted.
 
+- [Aman Maheshwari](https://github.com/Amanmahe)
 - [Payal Lakra](https://github.com/payallakra)
 
 The audio file used in `game.py` is sourced from [Pixabay](https://pixabay.com/sound-effects/brass-fanfare-with-timpani-and-windchimes-reverberated-146260/)

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,71 @@ 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, bufsize=1)
         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, bufsize=1)
 
+        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 render_template("index.html", lsl_started= False, lsl_status= "Failed to Start", lsl_color= "red", apps_enabled=False)
         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 render_template("index.html", lsl_started= True, lsl_status= "Running", lsl_color= "green", apps_enabled=True)
+
     except Exception as e:
-        return render_template("index.html", lsl_started=False, lsl_status=f"Error: {e}", lsl_color="red")
+        return render_template("index.html", 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()
+
+        if "NPG WebSocket connected!" in npg_process.stdout.readline().strip():
+            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 +100,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 +123,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 +132,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)

app_requirements.txt

@@ -9,4 +9,5 @@ pandas==2.2.3
 tk==0.1.0
 PyAutoGUI==0.9.54
 Flask==3.1.0
-psutil==6.1.1
+psutil==6.1.1
+websocket-client==1.8.0