chordspy 0.1.0__tar.gz

chordspy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Upside Down Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chordspy-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include requirements.txt
+include README.md
+recursive-include chordspy/templates *
+recursive-include chordspy/static *
+recursive-include chordspy/config *

chordspy-0.1.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: chordspy
+Version: 0.1.0
+Summary: An open source bag of tools for recording and visualizing Bio-potential signals like EEG, ECG, EMG , or EOG.
+Home-page: https://github.com/upsidedownlabs/Chords-Python
+Author: Payal
+Author-email: payallakra307@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy==2.1.3
+Requires-Dist: pylsl==1.16.2
+Requires-Dist: pyserial==3.5
+Requires-Dist: bleak==0.22.3
+Requires-Dist: pyqtgraph==0.13.7
+Requires-Dist: PyQt5==5.15.11
+Requires-Dist: keyboard==0.13.5
+Requires-Dist: scipy==1.14.1
+Requires-Dist: pygame==2.6.1
+Requires-Dist: neurokit2==0.2.10
+Requires-Dist: plotly==5.24.1
+Requires-Dist: pandas==2.2.3
+Requires-Dist: tk==0.1.0
+Requires-Dist: PyAutoGUI==0.9.54
+Requires-Dist: Flask==3.1.1
+Requires-Dist: psutil==6.1.1
+Requires-Dist: websocket-client==1.8.0
+Requires-Dist: PyYAML==6.0.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Chords - Python
+
+Chords- Python is a bag of tools designed to interface with Micro-controller development boards running [Chords Arduino Firmware](https://github.com/upsidedownlabs/Chords-Arduino-Firmware).Use Upside Down Labs bio-potential amplifiers to read data, visualize it, record data in CSV Files, and stream it via Lab Streaming Layer.  
+
+> [!NOTE]  
+> **Firmware Required:**  
+> - For Arduino: [Chords Arduino Firmware](https://github.com/upsidedownlabs/Chords-Arduino-Firmware)
+
+## Features  
+- **Multiple Protocols**: Supports `Wi-Fi`, `Bluetooth`, and `Serial` communication.  
+- **LSL Data Streaming**:Once the LSL stream starts, any PC on the same Wi-Fi network can access the data using tools like BrainVision LSL Viewer. 
+- **CSV Logging**: Save raw data with Counter 
+- **GUI**: Live plotting for all channels. 
+- **Applications**: EEG/ECG/EMG/EOG-based games and utilities (e.g., Tug of War, Keystroke Emulator). 
+
+
+## Installation
+
+```bash
+pip install chordspy
+
+## Usage  
+Run the script and access the web interface:  
+```bash
+python app.py  
+```  
+**Web Interface Preview**:  
+![Web Interface Screenshot](./media/Interface.png)
+
+![Web Interface Screenshot](./media/Webinterface.png)
+
+### Key Options:
+
+- **LSL Streaming**: Choose a protocol (`Wi-Fi`, `Bluetooth`, `Serial`).  
+- **CSV Logging**: Data saved as `ChordsPy_{timestamp}.csv`.  
+- **Applications**: Multiple Applications can be Launch from the Interface simultaneously(e.g., `EEG Tug of War`). 
+
+## Connection Guide  
+
+#### WIFI Connection  
+  1. Upload the NPG-Lite WIFI Code to your device.  
+  2. Connect to the device's WIFI network.  
+  3. Click the **WIFI** button in the interface, then select **CONNECT**.  
+  4. Once connected, the button will change to **Disconnect**, and a pop-up will confirm: *"Connected via Wifi!"*  
+
+#### Bluetooth Connection  
+  1. Ensure Bluetooth is turned ON on your system.  
+  2. Upload the Bluetooth code to your device.  
+  3. Click the **Bluetooth** button to scan for available devices.  
+  4. Select your device from the list and click **Connect**.
+  5. Once connected, the button will change to **Disconnect**, and a pop-up will confirm: *"Connected via Bluetooth!"*  
+
+#### Serial Connection  
+  1. Ensure Bluetooth is OFF and the device is connected via USB.  
+  2. Upload the required code to your hardware.  
+  3. Click the **Serial** button, then select **Connect**.
+  4. Once connected, the button will change to **Disconnect**, and a pop-up will confirm: *"Connected via Serial!"* 
+
+## CSV Logging  
+To save sensor data for future analysis, follow these steps:  
+1. **Start Data Streaming** – Begin streaming data via **WiFi, Bluetooth, or Serial**.  
+2. **Start Recording** – Click the **Start Recording** button (it will change to **Stop Recording**).  
+3. **File Saved Automatically** – The data is saved as `ChordsPy_{timestamp}.csv` in your default folder.  
+
+Visualizing CSV Data - You can plot the recorded data using the **CSV Plotter** tool.  
+
+## Applications 
+| Application                | Description                                                      |  
+|----------------------------|------------------------------------------------------------------|  
+| **ECG with Heart Rate**    | Real-time ECG with BPM calculation.                              | 
+| **EMG with Envelope**      | Real-time EMG Visualization with Envelope.                       |
+| **EOG with Blinks**        | Real-time EOG Signal visualization with Blinks marked as Red Dot.|
+| **EEG with FFT**           | Real-time EEG Signal visualization with FFT and Brainpower bands.|
+| **EEG Tug of War Game**    | 2 Player EEG Based Game                                          |
+| **EEG Beetle game**        | Real-time EEG focus based game.                                  |
+| **EOG Keystroke Emulator** | Blink detection triggers spacebar.                               |  
+| **GUI**                    | Visualize raw data in real-time                                  |
+| **CSV Plotter**            | Tool to plot the recorded CSV Files                              |
+
+## 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:** Ensure that the `pylsl` library is properly installed and configured. Additionally, confirm that Bluetooth is turned off.
+
+## How to Contribute
+
+You can add your project to this repo:
+
+- Add a button in apps.yaml to link your application.
+- Include your script as a .py file with LSL Data Reception code.
+(Pull requests welcome!)
+
+## 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/)

chordspy-0.1.0/README.md

@@ -0,0 +1,101 @@
+# Chords - Python
+
+Chords- Python is a bag of tools designed to interface with Micro-controller development boards running [Chords Arduino Firmware](https://github.com/upsidedownlabs/Chords-Arduino-Firmware).Use Upside Down Labs bio-potential amplifiers to read data, visualize it, record data in CSV Files, and stream it via Lab Streaming Layer.  
+
+> [!NOTE]  
+> **Firmware Required:**  
+> - For Arduino: [Chords Arduino Firmware](https://github.com/upsidedownlabs/Chords-Arduino-Firmware)
+
+## Features  
+- **Multiple Protocols**: Supports `Wi-Fi`, `Bluetooth`, and `Serial` communication.  
+- **LSL Data Streaming**:Once the LSL stream starts, any PC on the same Wi-Fi network can access the data using tools like BrainVision LSL Viewer. 
+- **CSV Logging**: Save raw data with Counter 
+- **GUI**: Live plotting for all channels. 
+- **Applications**: EEG/ECG/EMG/EOG-based games and utilities (e.g., Tug of War, Keystroke Emulator). 
+
+
+## Installation
+
+```bash
+pip install chordspy
+
+## Usage  
+Run the script and access the web interface:  
+```bash
+python app.py  
+```  
+**Web Interface Preview**:  
+![Web Interface Screenshot](./media/Interface.png)
+
+![Web Interface Screenshot](./media/Webinterface.png)
+
+### Key Options:
+
+- **LSL Streaming**: Choose a protocol (`Wi-Fi`, `Bluetooth`, `Serial`).  
+- **CSV Logging**: Data saved as `ChordsPy_{timestamp}.csv`.  
+- **Applications**: Multiple Applications can be Launch from the Interface simultaneously(e.g., `EEG Tug of War`). 
+
+## Connection Guide  
+
+#### WIFI Connection  
+  1. Upload the NPG-Lite WIFI Code to your device.  
+  2. Connect to the device's WIFI network.  
+  3. Click the **WIFI** button in the interface, then select **CONNECT**.  
+  4. Once connected, the button will change to **Disconnect**, and a pop-up will confirm: *"Connected via Wifi!"*  
+
+#### Bluetooth Connection  
+  1. Ensure Bluetooth is turned ON on your system.  
+  2. Upload the Bluetooth code to your device.  
+  3. Click the **Bluetooth** button to scan for available devices.  
+  4. Select your device from the list and click **Connect**.
+  5. Once connected, the button will change to **Disconnect**, and a pop-up will confirm: *"Connected via Bluetooth!"*  
+
+#### Serial Connection  
+  1. Ensure Bluetooth is OFF and the device is connected via USB.  
+  2. Upload the required code to your hardware.  
+  3. Click the **Serial** button, then select **Connect**.
+  4. Once connected, the button will change to **Disconnect**, and a pop-up will confirm: *"Connected via Serial!"* 
+
+## CSV Logging  
+To save sensor data for future analysis, follow these steps:  
+1. **Start Data Streaming** – Begin streaming data via **WiFi, Bluetooth, or Serial**.  
+2. **Start Recording** – Click the **Start Recording** button (it will change to **Stop Recording**).  
+3. **File Saved Automatically** – The data is saved as `ChordsPy_{timestamp}.csv` in your default folder.  
+
+Visualizing CSV Data - You can plot the recorded data using the **CSV Plotter** tool.  
+
+## Applications 
+| Application                | Description                                                      |  
+|----------------------------|------------------------------------------------------------------|  
+| **ECG with Heart Rate**    | Real-time ECG with BPM calculation.                              | 
+| **EMG with Envelope**      | Real-time EMG Visualization with Envelope.                       |
+| **EOG with Blinks**        | Real-time EOG Signal visualization with Blinks marked as Red Dot.|
+| **EEG with FFT**           | Real-time EEG Signal visualization with FFT and Brainpower bands.|
+| **EEG Tug of War Game**    | 2 Player EEG Based Game                                          |
+| **EEG Beetle game**        | Real-time EEG focus based game.                                  |
+| **EOG Keystroke Emulator** | Blink detection triggers spacebar.                               |  
+| **GUI**                    | Visualize raw data in real-time                                  |
+| **CSV Plotter**            | Tool to plot the recorded CSV Files                              |
+
+## 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:** Ensure that the `pylsl` library is properly installed and configured. Additionally, confirm that Bluetooth is turned off.
+
+## How to Contribute
+
+You can add your project to this repo:
+
+- Add a button in apps.yaml to link your application.
+- Include your script as a .py file with LSL Data Reception code.
+(Pull requests welcome!)
+
+## 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/)

chordspy-0.1.0/chordspy/__init__.py

@@ -0,0 +1,2 @@
+from chordspy.app import main
+from chordspy.connection import Connection

chordspy-0.1.0/chordspy/app.py

@@ -0,0 +1,256 @@
+from flask import Flask, render_template, request, jsonify
+from chordspy.connection import Connection
+import threading
+import asyncio
+import logging
+from bleak import BleakScanner
+from flask import Response
+import queue
+import yaml
+from pathlib import Path
+import os
+import webbrowser
+
+console_queue = queue.Queue()
+app = Flask(__name__)
+logging.basicConfig(level=logging.INFO)
+
+# Global variables
+connection_manager = None
+connection_thread = None
+ble_devices = []
+stream_active = False
+running_apps = {}  # Dictionary to track running apps
+
+@app.route('/log_error', methods=['POST'])
+def log_error():
+    try:
+        error_data = request.get_json()
+        if not error_data or 'error' not in error_data or 'log_error' in str(error_data):
+            return jsonify({'status': 'error', 'message': 'Invalid data'}), 400
+        
+        os.makedirs('logs', exist_ok=True)
+        
+        with open('logs/logging.txt', 'a') as f:
+            f.write(error_data['error'])
+            
+        return jsonify({'status': 'success'})
+    except Exception as e:
+        return jsonify({'status': 'error', 'message': 'Logging failed'}), 500
+
+def run_async(coro):
+    def wrapper(*args, **kwargs):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(coro(*args, **kwargs))
+        finally:
+            loop.close()
+    return wrapper
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/get_apps_config')
+def get_apps_config():
+    try:
+        config_path = Path(__file__).parent / 'config' / 'apps.yaml' # Try package-relative path first
+        if not config_path.exists():
+            config_path = Path('chordspy.config') / 'apps.yaml'      # Fallback to local path
+            
+        if config_path.exists():
+            with open(config_path, 'r') as file:
+                config = yaml.safe_load(file)
+                return jsonify(config)
+        return jsonify({'apps': []})
+    
+    except Exception as e:
+        logging.error(f"Error loading apps config: {str(e)}")
+        return jsonify({'apps': [], 'error': str(e)})
+
+@app.route('/scan_ble')
+@run_async
+async def scan_ble_devices():
+    global ble_devices
+    try:
+        devices = await BleakScanner.discover(timeout=5)
+        ble_devices = [{'name': d.name or 'Unknown', 'address': d.address} 
+                      for d in devices if d.name and d.name.startswith(('NPG', 'npg'))]
+        return jsonify({'status': 'success', 'devices': ble_devices})
+    except Exception as e:
+        logging.error(f"BLE scan error: {str(e)}")
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+
+@app.route('/check_stream')
+def check_stream():
+    is_connected = connection_manager.stream_active if hasattr(connection_manager, 'stream_active') else False
+    return jsonify({'connected': is_connected})
+
+@app.route('/check_connection')
+def check_connection():
+    if connection_manager and connection_manager.stream_active:
+        return jsonify({'status': 'connected'})
+    return jsonify({'status': 'connecting'})
+
+def post_console_message(message):
+    global stream_active
+    if "LSL stream started" in message:
+        stream_active = True
+    elif "disconnected" in message:
+        stream_active = False
+    console_queue.put(message)
+
+@app.route('/console_updates')
+def console_updates():
+    def event_stream():
+        while True:
+            message = console_queue.get()
+            yield f"data: {message}\n\n"
+    
+    return Response(event_stream(), mimetype="text/event-stream")
+
+@app.route('/launch_app', methods=['POST'])
+def launch_application():
+    if not connection_manager or not connection_manager.stream_active:
+        return jsonify({'status': 'error', 'message': 'No active stream'}), 400
+    
+    data = request.get_json()
+    module_name = data.get('app')
+    
+    if not module_name:
+        return jsonify({'status': 'error', 'message': 'No application specified'}), 400
+    
+    # Check if app is already running
+    if module_name in running_apps and running_apps[module_name].poll() is None:
+        return jsonify({'status': 'error', 'message': f'{module_name} is already running','code': 'ALREADY_RUNNING'}), 400
+    
+    try:
+        import subprocess
+        import sys
+        
+        # Run the module using Python's -m flag
+        process = subprocess.Popen([sys.executable, "-m", f"chordspy.{module_name}"])
+        
+        running_apps[module_name] = process
+        
+        return jsonify({'status': 'success', 'message': f'Launched {module_name}'})
+    except Exception as e:
+        logging.error(f"Error launching {module_name}: {str(e)}")
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+
+@app.route('/check_app_status/<app_name>')
+def check_app_status(app_name):
+    if app_name in running_apps:
+        if running_apps[app_name].poll() is None:  # Still running
+            return jsonify({'status': 'running'})
+        else:  # Process has terminated
+            del running_apps[app_name]
+            return jsonify({'status': 'not_running'})
+    return jsonify({'status': 'not_running'})
+
+@app.route('/connect', methods=['POST'])
+def connect_device():
+    global connection_manager, connection_thread, stream_active
+    
+    data = request.get_json()
+    protocol = data.get('protocol')
+    device_address = data.get('device_address')
+    
+    # Reset stream status
+    stream_active = False
+    
+    # Clean up any existing connection
+    if connection_manager:
+        connection_manager.cleanup()
+        if connection_thread and connection_thread.is_alive():
+            connection_thread.join()
+    
+    # Create new connection
+    connection_manager = Connection()
+    
+    def run_connection():
+        try:
+            if protocol == 'usb':
+                success = connection_manager.connect_usb()
+            elif protocol == 'wifi':
+                success = connection_manager.connect_wifi()
+            elif protocol == 'ble':
+                if not device_address:
+                    logging.error("No BLE device address provided")
+                    return
+                
+                # For BLE, we need to run in an event loop
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                success = connection_manager.connect_ble(device_address)
+            
+            if success:
+                post_console_message("LSL stream started")
+            else:
+                post_console_message("Connection failed")
+        except Exception as e:
+            logging.error(f"Connection error: {str(e)}")
+            post_console_message(f"Connection error: {str(e)}")
+    
+    # Start connection in a separate thread
+    connection_thread = threading.Thread(target=run_connection, daemon=True)
+    connection_thread.start()
+    
+    return jsonify({'status': 'connecting', 'protocol': protocol})
+
+@app.route('/disconnect', methods=['POST'])
+def disconnect_device():
+    global connection_manager, stream_active
+    if connection_manager:
+        connection_manager.cleanup()
+        stream_active = False
+        post_console_message("disconnected")
+        return jsonify({'status': 'disconnected'})
+    return jsonify({'status': 'no active connection'})
+
+@app.route('/start_recording', methods=['POST'])
+def start_recording():
+    global connection_manager
+    if not connection_manager:
+        return jsonify({'status': 'error', 'message': 'No active connection'}), 400
+    
+    data = request.get_json()
+    filename = data.get('filename')
+    
+    # If filename is empty or None, let connection_manager use default
+    if filename == "":
+        filename = None
+    
+    try:
+        if connection_manager.start_csv_recording(filename):
+            post_console_message(f"Recording started: {filename or 'default filename'}")
+            return jsonify({'status': 'recording_started'})
+        return jsonify({'status': 'error', 'message': 'Failed to start recording'}), 500
+    except Exception as e:
+        logging.error(f"Recording error: {str(e)}")
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+
+@app.route('/stop_recording', methods=['POST'])
+def stop_recording():
+    global connection_manager
+    if connection_manager:
+        try:
+            if connection_manager.stop_csv_recording():
+                post_console_message("Recording stopped")
+                return jsonify({'status': 'recording_stopped'})
+            return jsonify({'status': 'error', 'message': 'Failed to stop recording'}), 500
+        except Exception as e:
+            logging.error(f"Stop recording error: {str(e)}")
+            return jsonify({'status': 'error', 'message': str(e)}), 500
+    return jsonify({'status': 'error', 'message': 'No active connection'}), 400
+
+def main():
+    def open_browser():
+        webbrowser.open("http://localhost:5000")
+
+    threading.Timer(1.5, open_browser).start()
+    app.run(debug=True, use_reloader=False, host='0.0.0.0', port=5000)
+
+if __name__ == "__main__":
+    main()