Added ability to read from file and fixed delayer bugs

portiloop/src/capture.py

@@ -16,7 +16,7 @@ from portiloop.src.hardware.frontend import Frontend
 from portiloop.src.hardware.leds import LEDs, Color
 from portiloop.src.processing import FilterPipeline, int_to_float
 from portiloop.src.config import mod_config, LEADOFF_CONFIG, FRONTEND_CONFIG, to_ads_frequency
-from portiloop.src.utils import FileReader, LiveDisplay, DummyAlsaMixer, EDFRecorder, EDF_PATH
+from portiloop.src.utils import FileReader, LiveDisplay, DummyAlsaMixer, EDFRecorder, EDF_PATH, RECORDING_PATH
 from IPython.display import clear_output, display
 import ipywidgets as widgets
 
@@ -493,6 +493,7 @@ class Capture:
         
         self.b_capture.observe(self.on_b_capture, 'value')
         self.b_clock.observe(self.on_b_clock, 'value')
+        self.b_signal_input.observe(self.on_b_signal_input, 'value')
         self.b_frequency.observe(self.on_b_frequency, 'value')
         self.b_threshold.observe(self.on_b_threshold, 'value')
         self.b_duration.observe(self.on_b_duration, 'value')
@@ -901,6 +902,8 @@ class Capture:
                 self.__capture_on = True
                 p_msg_io, p_msg_io_2 = mp.Pipe()
                 p_data_i, p_data_o = mp.Pipe(duplex=False)
+        else:
+            p_msg_io, _ = mp.Pipe()
 
         # Initialize filtering pipeline
         if filter:
@@ -933,7 +936,7 @@ class Capture:
             self._p_capture.start()
             print(f"PID capture: {self._p_capture.pid}")
         else:
-            filename = "INSERT FILENAME" # TODO
+            filename = RECORDING_PATH / 'test_recording.csv'
             file_reader = FileReader(filename)
 
         # Initialize display if requested
@@ -966,7 +969,7 @@ class Capture:
 
         # Initialize stimulation delayer if requested
         if not self.spindle_detection_mode == 'Fast' and stimulator is not None:
-            stimulation_delayer = UpStateDelayer(self.frequency, self.spindle_freq, self.spindle_detection_mode == 'Peak', time_to_buffer=0.1)
+            stimulation_delayer = UpStateDelayer(self.frequency, self.spindle_detection_mode == 'Peak', 0.3)
             stimulator.add_delayer(stimulation_delayer)
         else:
             stimulation_delayer = None
@@ -998,7 +1001,14 @@ class Capture:
                 # Convert point from int to corresponding value in microvolts
                 n_array_raw = int_to_float(np.array([point]))
             elif self.signal_input == "File":
-                n_array_raw, gt_stimulation = file_reader.get_point()
+                # Check if the message to stop has been sent
+                with self._lock_msg_out:
+                    if self._msg_out == "STOP":
+                        break
+
+                index, raw_point, off_filtered_point, past_stimulation, lacourse_stimulation = file_reader.get_point()
+                n_array_raw = np.array([0, raw_point, 0, 0, 0, 0, 0, 0])
+                n_array_raw = np.reshape(n_array_raw, (1, 8))
             
             # Go through filtering pipeline
             if filter:
@@ -1017,7 +1027,7 @@ class Capture:
             
             # Adds point to buffer for delayed stimulation
             if stimulation_delayer is not None:
-                stimulation_delayer.step(filtered_point[0][channel-1])
+                stimulation_delayer.step_timesteps(filtered_point[0][channel-1])
 
             # Check if detection is on or off
             with self._pause_detect_lock:
@@ -1037,8 +1047,10 @@ class Capture:
                     if test_stimulus:
                         stimulator.test_stimulus()
                 
-                if self.signal_input == "File" and gt_stimulation:
-                    stimulator.send_stimulation("GROUND_TRUTH_STIM", False)
+                # Send the stimulation from the file reader
+                if stimulator is not None:
+                    if self.signal_input == "File" and lacourse_stimulation:
+                        stimulator.send_stimulation("GROUND_TRUTH_STIM", False)
             
             # Add point to the buffer to send to viz and recorder
             buffer += filtered_point
@@ -1062,7 +1074,7 @@ class Capture:
             p_data_i.close()
             p_msg_io.close()
             self._p_capture.join()
-            self.__capture_on = False
+        self.__capture_on = False
         
         if record:
             recorder.close_recording_file()

portiloop/src/stimulation.py

@@ -7,6 +7,11 @@ import alsaaudio
 import wave
 import pylsl
 from scipy.signal import find_peaks
+import numpy as np
+import matplotlib.pyplot as plt
+
+import alsaaudio
+import pylsl
 
 
 # Abstract interface for developers:
@@ -47,14 +52,14 @@ class SleepSpindleRealTimeStimulator(Stimulator):
                                   channel_format='string',
                                   source_id='portiloop1')  # TODO: replace this by unique device identifier
         
-        lsl_markers_info_fast = pylsl.StreamInfo(name='Portiloop_stimuli_fast',
-                                  type='Markers',
-                                  channel_count=1,
-                                  channel_format='string',
-                                  source_id='portiloop1')  # TODO: replace this by unique device identifier
+#         lsl_markers_info_fast = pylsl.StreamInfo(name='Portiloop_stimuli_fast',
+#                                   type='Markers',
+#                                   channel_count=1,
+#                                   channel_format='string',
+#                                   source_id='portiloop1')  # TODO: replace this by unique device identifier
         
         self.lsl_outlet_markers = pylsl.StreamOutlet(lsl_markers_info)
-        self.lsl_outlet_markers_fast = pylsl.StreamOutlet(lsl_markers_info_fast)
+#         self.lsl_outlet_markers_fast = pylsl.StreamOutlet(lsl_markers_info_fast)
         
         # Initialize Alsa stuff
         # Open WAV file and set PCM device
@@ -114,6 +119,7 @@ class SleepSpindleRealTimeStimulator(Stimulator):
                 self.last_detected_ts = ts
 
     def send_stimulation(self, lsl_text, sound):
+        print(f"Stimulating with text: {lsl_text}")
         # Send lsl stimulation
         self.lsl_outlet_markers.push_sample([lsl_text])
         # Send sound to patient
@@ -137,24 +143,22 @@ class SleepSpindleRealTimeStimulator(Stimulator):
 
     def add_delayer(self, delayer):
         self.delayer = delayer
-        self.delayer.stimulate = lambda x: self.send_stimulation("DELAY_STIM", True)
+        self.delayer.stimulate = lambda: self.send_stimulation("DELAY_STIM", True)
 
 # Class that delays stimulation to always stimulate peak or through
 class UpStateDelayer:
-    def __init__(self, sample_freq, spindle_freq, peak, time_to_buffer): 
+    def __init__(self, sample_freq, peak, time_to_buffer, stimulate=None): 
         '''
         args:
             sample_freq: int -> Sampling frequency of signal in Hz
             time_to_wait: float -> Time to wait to build buffer in seconds
         '''
         # Get number of timesteps for a whole spindle
-        self.spindle_timesteps = (1/spindle_freq) * sample_freq # s * 
         self.sample_freq = sample_freq
-        self.buffer_size = 1.5 * self.spindle_timesteps
         self.peak = peak
         self.buffer = []
         self.time_to_buffer = time_to_buffer
-        self.stimulate = None
+        self.stimulate = stimulate
         
         self.state = States.NO_SPINDLE
 
@@ -177,7 +181,37 @@ class UpStateDelayer:
             return False
         elif self.state == States.DELAYING:
             # Check if we are done delaying
-            if time.time() - self.time_started >= self.time_to_wait():
+            if time.time() - self.time_started >= self.time_to_wait:
+                # Actually stimulate the patient after the delay
+                if self.stimulate is not None:
+                    self.stimulate()
+                # Reset state
+                self.time_to_wait = -1
+                self.state = States.NO_SPINDLE
+                return True
+            return False
+
+    def step_timesteps(self, point):
+        '''
+        Step the delayer, ads a point to buffer if necessary.
+        Returns True if stimulation is actually done
+        '''
+        if self.state == States.NO_SPINDLE:
+            return False
+        elif self.state == States.BUFFERING:
+            self.buffer.append(point)
+            # If we are done buffering, move on to the waiting stage
+            if len(self.buffer) >= self.time_to_buffer * self.sample_freq:
+                # Compute the necessary time to wait
+                self.time_to_wait = self.compute_time_to_wait()
+                self.state = States.DELAYING
+                self.buffer = []
+                self.delaying_counter = 0
+            return False
+        elif self.state == States.DELAYING:
+            # Check if we are done delaying
+            self.delaying_counter += 1
+            if self.delaying_counter >= self.time_to_wait * self.sample_freq:
                 # Actually stimulate the patient after the delay
                 if self.stimulate is not None:
                     self.stimulate()
@@ -190,7 +224,6 @@ class UpStateDelayer:
     def detected(self):
         if self.state == States.NO_SPINDLE:
             self.state = States.BUFFERING
-            self.time_started = time.time()
 
     def compute_time_to_wait(self):
         """
@@ -203,8 +236,27 @@ class UpStateDelayer:
         # Returns the index of the last peak in the buffer
         peaks, _ = find_peaks(self.buffer, prominence=1)
 
+        # Make a figure to show the peaks
+        if False:
+            plt.figure()
+            plt.plot(self.buffer)
+            for peak in peaks:
+                plt.axvline(x=peak)
+            plt.plot(np.zeros_like(self.buffer), "--", color="gray")
+            plt.show()
+
+        if len(peaks) == 0:
+            print("No peaks found, increase buffer size")
+            return (self.sample_freq / 10) * (1.0 / self.sample_freq)
+
+        # Compute average distance between each peak
+        avg_dist = np.mean(np.diff(peaks))
+
         # Compute the time until next peak and return it
-        return (len(self.buffer) - peaks[-1]) * (1 / self.sample_freq)
+        if (avg_dist < len(self.buffer) - peaks[-1]):
+            print("Average distance between peaks is smaller than the time to last peak, decrease buffer size")
+            return (len(self.buffer) - peaks[-1]) * (1.0 / self.sample_freq)
+        return (avg_dist - (len(self.buffer) - peaks[-1])) * (1.0 / self.sample_freq)
 
 class States(Enum):
     NO_SPINDLE = 0

portiloop/src/utils.py

@@ -2,9 +2,13 @@ from EDFlib.edfwriter import EDFwriter
 from portilooplot.jupyter_plot import ProgressPlot
 from pathlib import Path
 import numpy as np
+import csv
+import time
 
-EDF_PATH = Path.home() / 'workspace' / 'edf_recording'
 
+EDF_PATH = Path.home() / 'workspace' / 'edf_recording'
+# Path to the recordings
+RECORDING_PATH = Path.home() / 'portiloop-software' / 'portiloop' / 'recordings'
 
 
 class DummyAlsaMixer:
@@ -102,7 +106,21 @@ class LiveDisplay():
 
 class FileReader:
     def __init__(self, filename):
-        raise NotImplementedError
+        file = open(filename, 'r')
+        # Open a csv file
+        print(f"Reading from file {filename}")
+        self.csv_reader = csv.reader(file, delimiter=',')
+        self.wait_time = 1/250.0
+        self.index = -1
+        self.last_time = time.time()
 
     def get_point(self):
-        raise NotImplementedError
+        """
+        Returns the next point in the file
+        """
+        point = next(self.csv_reader)
+        self.index += 1
+        while time.time() - self.last_time < self.wait_time:
+            continue
+        self.last_time = time.time()
+        return self.index, float(point[0]), float(point[1]), point[2] == '1', point[3] == '1'