Merge pull request #15 from PayalLakra/bio_amptool

lorforlinux · web-flow · commit 51395fdbf1c9 · 2024-10-19T18:06:14.000+05:30
hearbeat_ecg.py file update
diff --git a/app_requirements.txt b/app_requirements.txt
@@ -0,0 +1,6 @@
+pyqtgraph==0.13.7
+PySide2==5.15.2.1
+keyboard==0.13.5
+scipy==1.14.1
+pygame==2.6.1
+neurokit2==0.2.10
diff --git a/applications/heartbeat_ecg.py b/applications/heartbeat_ecg.py
@@ -1,181 +1,124 @@
-import sys
 import numpy as np
-import time
-from pylsl import StreamInlet, resolve_stream
-from scipy.signal import butter, lfilter, find_peaks
-import pyqtgraph as pg  # For real-time plotting
-from pyqtgraph.Qt import QtWidgets, QtCore  # PyQt components for GUI
-import signal  # For handling Ctrl+C
-from collections import deque  # For creating a ring buffer
-
-# Initialize global variables
-inlet = None
-data_buffer = np.zeros(2000)  # Buffer to hold the last 2000 samples for ECG data
-
-# Function to design a Butterworth filter
-def butter_filter(cutoff, fs, order=4, btype='low'):
-    nyquist = 0.5 * fs  # Nyquist frequency
-    normal_cutoff = cutoff / nyquist
-    b, a = butter(order, normal_cutoff, btype=btype, analog=False)
-    return b, a
-
-# Apply the Butterworth filter to the data
-def apply_filter(data, b, a):
-    return lfilter(b, a, data)
-
-# Function to detect heartbeats using peak detection
-def detect_heartbeats(ecg_data, sampling_rate):
-    peaks, _ = find_peaks(ecg_data, distance=sampling_rate * 0.6, prominence=0.5)  # Adjust as necessary
-    return peaks
-
-class DataCollector(QtCore.QThread):
-    data_ready = QtCore.pyqtSignal(np.ndarray)
-
-    def __init__(self):
-        super().__init__()
-        self.running = True
-        self.sampling_rate = None
-
-    def run(self):
-        global inlet
-        print("Looking for LSL stream...")
-        streams = resolve_stream('name', 'BioAmpDataStream')
-        
-        if not streams:
-            print("No LSL Stream found! Exiting...")
-            sys.exit(0)
-
-        inlet = StreamInlet(streams[0])
-        self.sampling_rate = inlet.info().nominal_srate()
-        print(f"Detected sampling rate: {self.sampling_rate} Hz")
-
-        # Create and design filters
-        low_cutoff = 20.0  # 20 Hz low-pass filter
-        self.low_b, self.low_a = butter_filter(low_cutoff, self.sampling_rate, order=4, btype='low')
-
-        while self.running:
-            # Pull multiple samples at once
-            samples, _ = inlet.pull_chunk(timeout=0.0, max_samples=10)  # Pull up to 10 samples
-            if samples:
-                global data_buffer
-                data_buffer = np.roll(data_buffer, -len(samples))  # Shift data left
-                data_buffer[-len(samples):] = [sample[0] for sample in samples]  # Add new samples to the end
-
-                filtered_data = apply_filter(data_buffer, self.low_b, self.low_a)   # Low-pass Filter
-                self.data_ready.emit(filtered_data)  # Emit the filtered data for plotting
-
-            time.sleep(0.01)
-
-    def stop(self):
-        self.running = False
+from scipy.signal import butter, filtfilt
+from PyQt5.QtWidgets import QApplication, QVBoxLayout, QLabel, QMainWindow, QWidget
+from PyQt5.QtCore import Qt
+from pyqtgraph import PlotWidget
+import pyqtgraph as pg
+import pylsl
+import neurokit2 as nk
+import sys
 
-class ECGApp(QtWidgets.QMainWindow):
-    def __init__(self):
+class ECGMonitor(QMainWindow):
+    def __init__(self): 
         super().__init__()
 
-        # Create a plot widget
-        self.plot_widget = pg.PlotWidget(title="ECG Signal")
-        self.setCentralWidget(self.plot_widget)
+        self.setWindowTitle("Real-Time ECG Monitor")  # Set up GUI window
+        self.setGeometry(100, 100, 800, 600)
+
+        self.plot_widget = PlotWidget(self)
         self.plot_widget.setBackground('w')
+        self.plot_widget.showGrid(x=True, y=True)
 
-        # Create a label to display heart rate
-        self.heart_rate_label = QtWidgets.QLabel("Heart rate: - bpm", self)
-        self.heart_rate_label.setStyleSheet("font-size: 20px; font-weight: bold;")
-        self.heart_rate_label.setAlignment(QtCore.Qt.AlignCenter)
+        # Heart rate label at the bottom
+        self.heart_rate_label = QLabel(self)
+        self.heart_rate_label.setStyleSheet("font-size: 20px; font-weight: bold; color: black;")
+        self.heart_rate_label.setAlignment(Qt.AlignCenter)
 
-        layout = QtWidgets.QVBoxLayout()
+        layout = QVBoxLayout()
         layout.addWidget(self.plot_widget)
         layout.addWidget(self.heart_rate_label)
 
-        container = QtWidgets.QWidget()
-        container.setLayout(layout)
-        self.setCentralWidget(container)
-
-        self.ecg_buffer = []
-        self.r_peak_times = deque(maxlen=10)  # Deque to store recent R-peak times
-        self.peak_intervals = deque(maxlen=9)  # Deque to store intervals between R-peaks
-
-        self.data_collector = DataCollector() # Data collector thread
-        self.data_collector.data_ready.connect(self.update_plot)
-        self.data_collector.start()
-
-        self.time_axis = np.linspace(0, 2000/200, 2000)       # Store the x-axis time window
-        self.plot_widget.setYRange(0,1000)                     # Set fixed y-axis limits 
+        central_widget = QWidget()
+        central_widget.setLayout(layout)
+        self.setCentralWidget(central_widget)
 
-        # Time to start heart rate calculation after 10 seconds
-        self.start_time = time.time()
-        self.initial_period = 10  # First 10 seconds to gather enough R-peaks
-
-        self.total_interval_sum = 0  # To track the sum of intervals for efficient heart rate calculation
-
-    def update_plot(self, ecg_data):
-        self.ecg_buffer = ecg_data  # Update buffer
-        self.plot_widget.clear()
-
-        # Set a fixed window (time axis) to ensure stable plotting
-        self.plot_widget.plot(self.time_axis, self.ecg_buffer, pen='#000000')  # Plot ECG data with black line
-        self.plot_widget.setXRange(self.time_axis[0], self.time_axis[-1], padding=0)
-
-        heartbeats = detect_heartbeats(np.array(self.ecg_buffer), self.data_collector.sampling_rate)
-
-        for index in heartbeats:
-            r_time = index / self.data_collector.sampling_rate
-            self.r_peak_times.append(r_time)
-
-            if len(self.r_peak_times) > 1:
-                # Calculate the interval between consecutive R-peaks
-                new_interval = self.r_peak_times[-1] - self.r_peak_times[-2]
-
-                if len(self.peak_intervals) == self.peak_intervals.maxlen:
-                    # Remove the oldest interval from the sum
-                    oldest_interval = self.peak_intervals.popleft()
-                    self.total_interval_sum -= oldest_interval    #Minus the oldest
-
-                # Add the new interval to the deque and update the sum
-                self.peak_intervals.append(new_interval)
-                self.total_interval_sum += new_interval     #   Plus the new
-
-        # Plot detected R-peaks
-        r_peak_times = self.time_axis[heartbeats]
-        r_peak_scatter = pg.ScatterPlotItem(x=r_peak_times, y=self.ecg_buffer[heartbeats],
-                                            symbol='o', size=10, pen='r', brush='r')
-        self.plot_widget.addItem(r_peak_scatter)
-
-        # Start heart rate calculation after 10 seconds
-        if time.time() - self.start_time >= self.initial_period:
-            self.update_heart_rate()
+        # Set up LSL stream inlet
+        streams = pylsl.resolve_stream('name', 'BioAmpDataStream')
+        if not streams:
+            print("No LSL stream found!")
+            sys.exit(0)
+        self.inlet = pylsl.StreamInlet(streams[0])
 
-    def update_heart_rate(self):
-        if len(self.peak_intervals) > 0:
-            # Efficiently calculate the heart rate using the sum of intervals
-            avg_interval = self.total_interval_sum / len(self.peak_intervals)
-            bpm = 60 / avg_interval  # Convert to beats per minute
-            self.heart_rate_label.setText(f"Heart rate: {bpm:.2f} bpm")
+        # Sampling rate
+        self.sampling_rate = int(self.inlet.info().nominal_srate())
+        print(f"Sampling rate: {self.sampling_rate} Hz")
+        
+        # Data and buffers
+        self.buffer_size = self.sampling_rate * 10  # Fixed-size buffer for 10 seconds
+        self.ecg_data = np.zeros(self.buffer_size)  # Fixed-size array for circular buffer
+        self.time_data = np.linspace(0, 10, self.buffer_size)  # Fixed time array for plotting
+        self.r_peaks = []  # Store the indices of R-peaks
+        self.heart_rate = None
+        self.current_index = 0  # Index for overwriting data
+
+        self.b, self.a = butter(4, 20.0 / (0.5 * self.sampling_rate), btype='low')   # Low-pass filter coefficients
+
+        self.timer = pg.QtCore.QTimer()   # Timer for updating the plot
+        self.timer.timeout.connect(self.update_plot)
+        self.timer.start(10)
+
+        # Set y-axis limits based on sampling rate
+        if self.sampling_rate == 250:  
+            self.plot_widget.setYRange(0, 2**10)  # for R3
+        elif self.sampling_rate == 500:  
+            self.plot_widget.setYRange(0, 2**14)  # for R4 
+
+        # Set fixed x-axis range
+        self.plot_widget.setXRange(0, 10)  # 10 seconds
+
+        self.ecg_curve = self.plot_widget.plot(self.time_data, self.ecg_data, pen=pg.mkPen('k', width=1))
+        self.r_peak_curve = self.plot_widget.plot([], [], pen=None, symbol='o', symbolBrush='r', symbolSize=10)  # R-peaks in red
+        
+        self.moving_average_window_size = 5   # Initialize moving average buffer
+        self.heart_rate_history = []          # Buffer to store heart rates for moving average
+
+    def update_plot(self):
+        samples, _ = self.inlet.pull_chunk(timeout=0.0, max_samples=30)
+        if samples:
+            for sample in samples:
+                # Overwrite the oldest data point in the buffer
+                self.ecg_data[self.current_index] = sample[0]
+                self.current_index = (self.current_index + 1) % self.buffer_size  # Circular increment
+
+            filtered_ecg = filtfilt(self.b, self.a, self.ecg_data) # Filter the signal
+
+            self.ecg_curve.setData(self.time_data, filtered_ecg)  # Use current buffer for plotting
+
+            # Detect R-peaks and update heart rate
+            self.r_peaks = self.detect_r_peaks(filtered_ecg)
+            self.calculate_heart_rate()
+            self.plot_r_peaks(filtered_ecg)
+
+    def detect_r_peaks(self, ecg_signal):
+        r_peaks = nk.ecg_findpeaks(ecg_signal, sampling_rate=self.sampling_rate)
+        return r_peaks['ECG_R_Peaks'] if 'ECG_R_Peaks' in r_peaks else []
+
+    def calculate_heart_rate(self):
+        if len(self.r_peaks) >= 10:  # Check if we have 10 or more R-peaks
+            recent_r_peaks = self.r_peaks[-10:]  # Use the last 10 R-peaks for heart rate calculation
+            rr_intervals = np.diff([self.time_data[i] for i in recent_r_peaks])  # Calculate RR intervals (time differences between consecutive R-peaks)
+            if len(rr_intervals) > 0:
+                avg_rr = np.mean(rr_intervals)  # Average RR interval
+                self.heart_rate = 60.0 / avg_rr  # Convert to heart rate (BPM)
+                self.heart_rate_history.append(self.heart_rate)   # Update moving average
+                if len(self.heart_rate_history) > self.moving_average_window_size:
+                    self.heart_rate_history.pop(0)  # Remove the oldest heart rate 
+                
+                # Calculate the moving average heart rate
+                moving_average_hr = np.mean(self.heart_rate_history)
+                
+                # Update heart rate label with moving average & convert into int
+                self.heart_rate_label.setText(f"Heart Rate: {int(moving_average_hr)} BPM")
         else:
-            self.heart_rate_label.setText("Heart rate: 0 bpm")
+            self.heart_rate_label.setText("Heart Rate: Calculating...") 
 
-    def closeEvent(self, event):
-        self.data_collector.stop()   # Stop the data collector thread on close
-        self.data_collector.wait()  # Wait for the thread to finish
-        event.accept()  # Accept the close event
-
-def signal_handler(sig, frame):
-    print("Exiting...")
-    QtWidgets.QApplication.quit()
+    def plot_r_peaks(self, filtered_ecg):
+        r_peak_times = self.time_data[self.r_peaks]   # Extract the time of detected R-peaks
+        r_peak_values = filtered_ecg[self.r_peaks]
+        self.r_peak_curve.setData(r_peak_times, r_peak_values)  # Plot R-peaks as red dots
 
 if __name__ == "__main__":
-    signal.signal(signal.SIGINT, signal_handler)  # Handle Ctrl+C
-
-    streams = resolve_stream('name', 'BioAmpDataStream')
-    if not streams:
-        print("No LSL Stream found! Exiting...")
-        sys.exit(0)
-
-    app = QtWidgets.QApplication(sys.argv)
-    
-    window = ECGApp()
-    window.setWindowTitle("Real-Time ECG Monitoring")
-    window.resize(800, 600)
+    app = QApplication(sys.argv)
+    window = ECGMonitor()  
     window.show()
-
-    sys.exit(app.exec_())
+    sys.exit(app.exec_())    
diff --git a/chords.py b/chords.py
@@ -111,8 +111,13 @@ def send_command(ser, command):
     return response
 
 # Function to read data from Arduino
-def read_arduino_data(ser, csv_writer=None):
+def read_arduino_data(ser, csv_writer=None, inverted=False):
     global total_packet_count, cumulative_packet_count, previous_sample_number, missing_samples, buffer, data
+
+    max_value = 2**14 if board == "UNO-R4" else 2**10
+    min_value = 0
+    mid_value = (max_value - 1) / 2
+    
     raw_data = ser.read(ser.in_waiting or 1)  # Read available data from the serial port
     if raw_data == b'':
         send_command(ser, 'START')
@@ -149,7 +154,16 @@ def read_arduino_data(ser, csv_writer=None):
                     high_byte = packet[2*channel + HEADER_LENGTH]
                     low_byte = packet[2*channel + HEADER_LENGTH + 1]
                     value = (high_byte << 8) | low_byte  # Combine high and low bytes
-                    channel_data.append(float(value))  # Convert to float and add to channel data
+                    if inverted:  # Apply inversion if the flag is set
+                        if value > mid_value:
+                            inverted_data = (mid_value) - abs(mid_value - value)
+                        elif value < mid_value:
+                            inverted_data = (mid_value) + abs(mid_value - value)
+                        else:
+                            inverted_data = value
+                        channel_data.append(float(inverted_data))  # Append the inverted value
+                    else:
+                        channel_data.append(float(value))  # Convert to float and add to channel data
 
                 if csv_writer:  # If CSV logging is enabled, write the data to the CSV file
                     csv_writer.writerow([counter] + channel_data)
@@ -195,7 +209,7 @@ def log_ten_minute_data(verbose=False):
     last_ten_minute_time = time.time()  # Update the last 10-minute interval start time
 
 # Main function to parse command-line arguments and handle data acquisition
-def parse_data(ser, lsl_flag=False, csv_flag=False, verbose=False, run_time=None):
+def parse_data(ser, lsl_flag=False, csv_flag=False, verbose=False, run_time=None, inverted= False):
     global total_packet_count, cumulative_packet_count, start_time, lsl_outlet, last_ten_minute_time, csv_filename
 
     csv_writer = None  # Placeholder for CSV writer
@@ -221,7 +235,7 @@ def parse_data(ser, lsl_flag=False, csv_flag=False, verbose=False, run_time=None
         send_command(ser, 'START')
 
         while True:
-            read_arduino_data(ser, csv_writer)  # Read and process data from Arduino
+            read_arduino_data(ser, csv_writer, inverted=inverted)  # Read and process data from Arduino
             if(start_time is not None):
                 current_time = time.time()   # Get the current time
                 elapsed_time = current_time - start_time   # Time elapsed since the last second
@@ -291,13 +305,14 @@ def signal_handler(sig, frame):
 # Main entry point of the script
 def main():
     global verbose,ser
-    parser = argparse.ArgumentParser(description="Upside Down Labs - BioAmp Tool",allow_abbrev = False)  # Create argument parser
+    parser = argparse.ArgumentParser(description="Upside Down Labs - Chords-Python Tool",allow_abbrev = False)  # Create argument parser
     parser.add_argument('-p', '--port', type=str, help="Specify the COM port")  # Port argument
     parser.add_argument('-b', '--baudrate', type=int, default=230400, help="Set baud rate for the serial communication")  # Baud rate 
     parser.add_argument('--csv', action='store_true', help="Create and write to a CSV file")  # CSV logging flag
     parser.add_argument('--lsl', action='store_true', help="Start LSL stream")  # LSL streaming flag
     parser.add_argument('-v', '--verbose', action='store_true', help="Enable verbose output with statistical data")  # Verbose flag
     parser.add_argument('-t', '--time', type=int, help="Run the program for a specified number of seconds and then exit")   #set time
+    parser.add_argument('--inverted', action='store_true', help="Invert the signal before streaming LSL and logging")  # Inverted flag
 
     args = parser.parse_args()  # Parse command-line arguments
     verbose = args.verbose  # Set verbose mode
@@ -321,7 +336,7 @@ def main():
         return
 
     # Start data acquisition
-    parse_data(ser, lsl_flag=args.lsl, csv_flag=args.csv, verbose=args.verbose, run_time=args.time)
+    parse_data(ser, lsl_flag=args.lsl, csv_flag=args.csv, verbose=args.verbose, run_time=args.time, inverted=args.inverted)
 
 # Run the main function if this script is executed
 if __name__ == "__main__":
diff --git a/chords_requirements.txt b/chords_requirements.txt
@@ -0,0 +1,3 @@
+numpy==1.26.4
+pylsl==1.16.2
+pyserial==3.5
diff --git a/requirements.txt b/requirements.txt

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+numpy==1.26.4`
	`2`	`+pylsl==1.16.2`
	`3`	`+pyserial==3.5`