Merge pull request #21 from PayalLakra/bio_amptool

Added - emg.ipynb and CSV File for emg & ecg

Author: lorforlinux

Notebooks/ECG.ipynb renamed to Notebooks/ecg.ipynb

@@ -1,18 +1,19 @@
 # Chords - Python
 
-Chords Python script is designed to interface with an Arduino-based bioamplifier, read data from it, optionally log this data to CSV or stream it via the Lab Streaming Layer (LSL), and visualize it through a graphical user interface (GUI) with live plotting.
+Chords Python script is designed to interface with an Arduino-based bio-potential amplifier, read data from it, optionally log this data to CSV or stream it via the Lab Streaming Layer (LSL), and visualize it through a graphical user interface (GUI) with live plotting.
 
 > [!NOTE]
 > Flash Arduino code to your hardware from [Chords Arduino Firmware](https://github.com/upsidedownlabs/Chords-Arduino-Firmware) to use this python tool.
 
 ## Features
 
 - **Automatic Arduino Detection:** Automatically detects connected Arduino devices via serial ports.
-- **Data Reading:** Read  ModularEEG P2 format data packets from the Arduino's serial port.
+- **Data Reading:** Read data packets from the Arduino's serial port.
 - **CSV Logging:** Optionally logs data to a CSV file.
 - **LSL Streaming:** Optionally streams data to an LSL outlet for integration with other software.
 - **Verbose Output:** Provides detailed statistics and error reporting, including sampling rate and drift.
 - **GUI:** Live plotting of six channels using a PyQt-based GUI.
+- **Invert:** Optionally Invert the signal before streaming LSL and logging
 - **Timer:** Record data for a set time period in seconds.
 
 ## Requirements
@@ -101,61 +102,26 @@ To use the script, run it from the command line with various options:
 
 - `python gui.py`: Enable the real-time data plotting GUI.
 
-#### Script Functions
-
-`init_gui()`: Initializes and displays the GUI with six real-time plots, one for each bio-signal channel.
-
-`update_plots()`: Updates the plot data by pulling new samples from the LSL stream and shifting the existing buffer.
-
 ### FORCE BALL GAME
 
 - `python game.py`: Enable a GUI to play game using EEG Signal.
 
-#### Script Functions
-
-`bandpower(data, sf, band, window_sec=None, relative=False)`: Calculates the band power of EEG data in a specified frequency band using the Welch method.
-
-`eeg_data_thread(eeg_queue)`: Continuously retrieves EEG data from an LSL stream and computes power ratios for Player A and Player B.
-
-`reset_game()`: Resets the game state and initializes the ball and player forces.
-
-`update_ball_position(force_player1, force_player2)`: Updates the ball's position based on the net force exerted by both players.
-
-`check_win_condition()`: Determines if either player has won based on the ball's position.
-
 ### HEART RATE
 
 - `python heartbeat.ecg.py`:Enable a GUI with real-time ECG and heart rate.
 
-#### Script Functions
-
-`butter_filter(cutoff, fs, order=4, btype='low')`: Designs a Butterworth filter to remove unwanted frequencies from the ECG signal.
-
-`apply_filter(data, b, a)`: Applies the designed Butterworth filter to the ECG data for noise reduction.
-
-`detect_heartbeats(ecg_data, sampling_rate)`: Detects heartbeats in the ECG signal using peak detection.
-
-`run(self)`: Collects ECG data from the LSL stream, applies filtering, and emits the filtered data for real-time plotting.
-
-`update_plot(self, ecg_data)`: Updates the plot with the latest ECG data and detects heartbeats to display on the GUI.
-
-`update_heart_rate(self)`: Calculates and updates the heart rate based on detected R-peaks in the ECG signal.
-
 ### EMG ENVELOPE
 
-- `python emgenvelope.py` :Enable a GUI with real-time EMG & its Envelope.
-
-#### Script Functions
-
- `update_plot` : Updates the plot with latest Filtered EMG Data and its Envelope.
+- `python emgenvelope.py`: Enable a GUI with real-time EMG & its Envelope.
 
 ### EOG
 
-- `python eog.py` :Enable a GUI with real-time EOG.
+- `python eog.py`: Enable a GUI with real-time EOG that detects the blinks and mark them with red dot.
+
+### EEG
 
-#### Script Functions
+- `python ffteeg.py`: Enable a GUI with real-time EEG data with its FFT.
 
- `update_plot` : Updates the plot with latest Filtered EOG Data.
 
 ## Troubleshooting
 

Notebooks/emg.ipynb

@@ -1,34 +1,47 @@
 import numpy as np
-from scipy.signal import butter, filtfilt
-from PyQt5.QtWidgets import QApplication, QVBoxLayout, QMainWindow, QWidget
-from pyqtgraph import PlotWidget
+from scipy.signal import butter, lfilter, lfilter_zi
+from PyQt5.QtWidgets import QApplication, QVBoxLayout, QMainWindow, QWidget, QHBoxLayout
 import pyqtgraph as pg
 import pylsl
 import sys
+import time
+from collections import deque
 
 class EOGMonitor(QMainWindow):
-    def __init__(self): 
+    def __init__(self):
         super().__init__()
 
         self.setWindowTitle("Real-Time EOG Monitor - Eye Blink Detection")
         self.setGeometry(100, 100, 800, 400)
 
         # Create layout
         layout = QVBoxLayout()
+        central_widget = QWidget()
+        central_widget.setLayout(layout)
+        self.setCentralWidget(central_widget)
 
         # Create plot widget for EOG
-        self.eog_plot = PlotWidget(self)
+        self.eog_plot = pg.PlotWidget(self)
         self.eog_plot.setBackground('w')
         self.eog_plot.showGrid(x=True, y=True)
+        # self.eog_plot.setAutoVisible(y=True)    # On Autoscale for y-axis only
+        self.eog_plot.setMouseEnabled(x=False, y=False)  # To Disable zoom functionality
         self.eog_plot.setTitle("Filtered EOG Signal (Low Pass: 10 Hz)")
 
-        # Add plot to layout
-        layout.addWidget(self.eog_plot)
+        # Bottom layout for Blink Detection
+        self.bottom_layout = QHBoxLayout()
 
-        # Central widget
-        central_widget = QWidget()
-        central_widget.setLayout(layout)
-        self.setCentralWidget(central_widget)
+        # Blink detection plot
+        self.blink_plot = pg.PlotWidget(self)
+        self.blink_plot.setBackground('w')
+        self.blink_plot.showGrid(x=True, y=True)
+        self.blink_plot.setYRange(0, 1, padding=0)
+        self.blink_plot.setMouseEnabled(x=False, y=False)  # To Disable zoom functionality mark it as true
+        self.blink_plot.setTitle("Blink Detection")
+
+        # Add both plots to the layout
+        layout.addWidget(self.eog_plot)
+        layout.addWidget(self.blink_plot)
 
         # Set up LSL stream inlet
         streams = pylsl.resolve_stream('name', 'BioAmpDataStream')
@@ -37,33 +50,37 @@ def __init__(self):
             sys.exit(0)
         self.inlet = pylsl.StreamInlet(streams[0])
 
-        # Sampling rate
         self.sampling_rate = int(self.inlet.info().nominal_srate())
         print(f"Sampling rate: {self.sampling_rate} Hz")
-        
-        # Data and buffer
+
         self.buffer_size = self.sampling_rate * 5  # 5 seconds buffer for recent data
         self.eog_data = np.zeros(self.buffer_size)
         self.time_data = np.linspace(0, 5, self.buffer_size)
+        self.blink_data = np.zeros(self.buffer_size)  # Blink data array
         self.current_index = 0
 
         # Low-pass filter for EOG (10 Hz)
         self.b, self.a = butter(4, 10.0 / (0.5 * self.sampling_rate), btype='low')
+        self.zi = lfilter_zi(self.b, self.a)  # Initialize filter state
 
-        # Set fixed axis ranges
         self.eog_plot.setXRange(0, 5, padding=0)
-        if self.sampling_rate == 250:
-            self.eog_plot.setYRange(-((2**10)/2), ((2**10)/2), padding=0)
-        elif self.sampling_rate == 500:
-            self.eog_plot.setYRange(-((2**14)/2), ((2**14)/2), padding=0)
+        if self.sampling_rate == 250:  
+            self.eog_plot.setYRange(0, 2**10,padding=0)  # for R3 & ensuring no extra spaces at end
+        elif self.sampling_rate == 500:  
+            self.eog_plot.setYRange(0, 2**14,padding=0)  # for R4 & ensuring no extra spaces at end
 
-        # Plot curve for EOG data
+        # Plot curves
         self.eog_curve = self.eog_plot.plot(self.time_data, self.eog_data, pen=pg.mkPen('b', width=1))
+        self.blink_curve = self.blink_plot.plot(self.time_data, self.blink_data, pen=pg.mkPen('r', width=2))
+
+        # Circular buffer for detected peaks
+        self.detected_peaks = deque(maxlen=self.sampling_rate * 5)  # Store peaks with 5-second window
 
         # Timer for plot update
         self.timer = pg.QtCore.QTimer()
         self.timer.timeout.connect(self.update_plot)
         self.timer.start(15)
+        self.start_time = time.time()
 
     def update_plot(self):
         samples, _ = self.inlet.pull_chunk(timeout=0.0, max_samples=30)
@@ -73,14 +90,78 @@ def update_plot(self):
                 self.eog_data[self.current_index] = sample[0]
                 self.current_index = (self.current_index + 1) % self.buffer_size
 
-            # Apply only the low-pass filter to the EOG data
-            filtered_eog = filtfilt(self.b, self.a, self.eog_data)
+            # Filter only the new data (not the entire buffer)
+            filtered_eog, self.zi = lfilter(self.b, self.a, self.eog_data, zi=self.zi)
+
+            # Update curve with the filtered EOG signal (5-second window)
+            self.eog_plot.clear()    # Clear the previous peaks from the plot
+            self.eog_curve = self.eog_plot.plot(self.time_data, filtered_eog, pen=pg.mkPen('b', width=1))
+
+            if time.time() - self.start_time >= 2:
+                self.detect_blinks(filtered_eog)
+
+            # Clear out old peaks from the circular buffer after 4 seconds(As we want to clear the peaks just after the data overwrite.)
+            current_time = time.time()
+            while self.detected_peaks and (current_time - self.detected_peaks[0][1] > 4):
+                self.detected_peaks.popleft()  # Remove old peaks from the buffer
+
+            # Update the blink plot based on stored peaks
+            self.blink_data[:] = 0  # Reset blink data
+            for index, _ in self.detected_peaks:
+                if 0 <= index < self.buffer_size:
+                    self.blink_data[index] = 1  # Keep blink data high at detected peaks
+
+            # Mark the stored peaks on the EOG plot
+            peak_indices = [index for index, t in self.detected_peaks]
+            peak_values = [filtered_eog[i] for i in peak_indices]
+            self.eog_plot.plot(self.time_data[peak_indices], peak_values, pen=None, symbol='o', symbolPen='r', symbolSize=6)
+
+            # Update the blink plot with the current blink data
+            self.blink_curve.setData(self.time_data, self.blink_data)
+
+    def detect_blinks(self, filtered_eog):
+        mean_signal = np.mean(filtered_eog)
+        stdev_signal = np.std(filtered_eog)
+        threshold = mean_signal + (2 * stdev_signal)
+
+        # Calculate the start and end indices for the 1-second window
+        window_size = 1 * self.sampling_rate
+        start_index = self.current_index - window_size
+        if start_index < 0:
+            start_index = 0
+        end_index = self.current_index
+
+        # Use a 1-second window for peak detection
+        filtered_window = filtered_eog[start_index:end_index]
+        peaks = self.detect_peaks(filtered_window, threshold)
+
+        # Mark detected peaks and store them with timestamps
+        for peak in peaks:
+            full_peak_index = start_index + peak
+            self.detected_peaks.append((full_peak_index, time.time()))  # Add detected peak with current timestamp
+
+    def detect_peaks(self, signal, threshold):
+        peaks = []
+        prev_peak_time = None  # Variable to store the timestamp of the previous peak
+        min_peak_gap = 0.1     # Minimum time gap between two peaks in seconds
+
+        for i in range(1, len(signal) - 1):
+            if signal[i] > signal[i - 1] and signal[i] > signal[i + 1] and signal[i] > threshold:
+                current_peak_time = i / self.sampling_rate  # Time in seconds based on the sampling rate
+
+                if prev_peak_time is not None:
+                    time_gap = current_peak_time - prev_peak_time
+                    if time_gap < min_peak_gap:
+                        continue
+
+                peaks.append(i)
+                prev_peak_time = current_peak_time
 
-            # Update curve with the low-pass filtered EOG signal
-            self.eog_curve.setData(self.time_data, filtered_eog)
+        return peaks
 
 if __name__ == "__main__":
     app = QApplication(sys.argv)
     window = EOGMonitor()
+    print("Note: There will be a 2s calibration delay before peak detection starts.")
     window.show()
     sys.exit(app.exec_())

Notebooks/eog.ipynb

@@ -6,7 +6,7 @@
 import pyqtgraph as pg
 import pylsl
 import sys
-from scipy.signal import butter, filtfilt
+from scipy.signal import butter, filtfilt, iirnotch
 from scipy.fft import fft
 
 class EEGMonitor(QMainWindow):
@@ -27,7 +27,7 @@ def __init__(self):
         self.eeg_plot_widget.setLabel('bottom', 'EEG Plot')
         self.eeg_plot_widget.setYRange(0, 15000, padding=0)
         self.eeg_plot_widget.setXRange(0, 10, padding=0)
-        self.eeg_plot_widget.setMouseEnabled(x=False, y=False)  # Disable zoom
+        self.eeg_plot_widget.setMouseEnabled(x=False, y=True)  # Disable zoom
         self.main_layout.addWidget(self.eeg_plot_widget)
 
         # Second half for FFT and Brainwave Power, aligned horizontally
@@ -77,6 +77,10 @@ def __init__(self):
         self.time_data = np.linspace(0, 10, self.buffer_size)  # Fixed time array for plotting
         self.current_index = 0  # Index for overwriting data
 
+        # Notch filter at 50 Hz
+        self.b_notch, self.a_notch = iirnotch(50, 30, self.sampling_rate)
+        # High-pass filter (cutoff at 0.5 Hz)
+        self.b_highpass, self.a_highpass = butter(4, 0.5 / (0.5 * self.sampling_rate), btype='high')
         # Low-pass filter (4th order, cutoff at 45 Hz)
         self.b_lowpass, self.a_lowpass = butter(4, 45 / (0.5 * self.sampling_rate), btype='low')
 
@@ -96,15 +100,27 @@ def update_plot(self):
                 self.eeg_data[self.current_index] = sample[0]
                 self.current_index = (self.current_index + 1) % self.buffer_size  # Circular increment
 
-            # Apply low-pass filter
-            filtered_eeg = filtfilt(self.b_lowpass, self.a_lowpass, self.eeg_data)
+            if self.current_index >= self.buffer_size:
+                plot_data = self.eeg_data
+            else:
+                plot_data = np.concatenate((self.eeg_data[self.current_index:], self.eeg_data[:self.current_index]))
+
+            # Apply filters to the full data for EEG plot
+            filtered_eeg = filtfilt(self.b_notch, self.a_notch, plot_data)
+            filtered_eeg = filtfilt(self.b_highpass, self.a_highpass, filtered_eeg)
+            filtered_eeg = filtfilt(self.b_lowpass, self.a_lowpass, filtered_eeg)
 
             # Update the EEG plot with the filtered data
             self.eeg_curve.setData(self.time_data, filtered_eeg)
 
-            # Perform FFT with windowing (Hamming window)
-            window = hamming(len(filtered_eeg))  # Apply Hamming window to reduce spectral leakage
-            filtered_eeg_windowed = filtered_eeg * window  # Element-wise multiply
+            # Perform FFT on the latest 1-second slice
+            latest_data = plot_data[-self.sampling_rate:]  # Most recent 1-second data
+            window = hamming(len(latest_data))
+            filtered_eeg_windowed = latest_data * window
+
+            # Apply zero-padding
+            zero_padded_length = 2048
+            filtered_eeg_windowed_padded = np.pad(filtered_eeg_windowed, (0, zero_padded_length - len(filtered_eeg_windowed)), 'constant')
 
             eeg_fft = np.abs(fft(filtered_eeg_windowed))[:len(filtered_eeg_windowed) // 2]  # Positive frequencies only
             freqs = np.fft.fftfreq(len(filtered_eeg_windowed), 1 / self.sampling_rate)[:len(filtered_eeg_windowed) // 2]