Merge pull request #3 from Portiloop/milo/no_portiloop

.gitignore

@@ -2,6 +2,11 @@
 .vscode/
 .idea/
 
+# Output from the demo
+output.csv
+# Any xdf file used for testing
+*.xdf
+
 # Vagrant
 .vagrant/
 
@@ -122,4 +127,4 @@ venv.bak/
 # mypy
 .mypy_cache/
 .dmypy.json
-dmypy.json
+dmypy.json

portiloop/notebooks/tests.ipynb

@@ -2,35 +2,60 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "16651843",
    "metadata": {
     "scrolled": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f46843d136af4c79a73841b997fa3284",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(Accordion(children=(GridBox(children=(Label(value='CH2'), Label(value='CH3'), Label(value='CH4'…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Exception in thread Thread-3:\n",
+      "Traceback (most recent call last):\n",
+      "  File \"C:\\Users\\milos\\AppData\\Local\\Programs\\Python\\Python37\\lib\\threading.py\", line 917, in _bootstrap_inner\n",
+      "    self.run()\n",
+      "  File \"C:\\Users\\milos\\AppData\\Local\\Programs\\Python\\Python37\\lib\\threading.py\", line 865, in run\n",
+      "    self._target(*self._args, **self._kwargs)\n",
+      "  File \"c:\\users\\milos\\documents\\github\\portiloop-software\\portiloop\\src\\capture.py\", line 927, in start_capture\n",
+      "    detector = detector_cls(threshold, channel=channel) if detector_cls is not None else None\n",
+      "  File \"c:\\users\\milos\\documents\\github\\portiloop-software\\portiloop\\src\\detection.py\", line 56, in __init__\n",
+      "    self.interpreters.append(edgetpu.make_interpreter(model_path))\n",
+      "NameError: name 'edgetpu' is not defined\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
-    "from portiloop.capture import Capture\n",
-    "from portiloop.detection import SleepSpindleRealTimeDetector\n",
-    "from portiloop.stimulation import SleepSpindleRealTimeStimulator\n",
+    "from portiloop.src.capture import Capture\n",
+    "from portiloop.src.detection import SleepSpindleRealTimeDetector\n",
+    "from portiloop.src.stimulation import SleepSpindleRealTimeStimulator\n",
     "\n",
     "my_detector_class = SleepSpindleRealTimeDetector  # you may want to implement yours\n",
     "my_stimulator_class = SleepSpindleRealTimeStimulator  # you may also want to implement yours\n",
     "\n",
     "cap = Capture(detector_cls=my_detector_class, stimulator_cls=my_stimulator_class)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cded6bbc",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3.7.0b2 ('venv': venv)",
    "language": "python",
    "name": "python3"
   },
@@ -44,7 +69,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.7.0b2"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "770b75f59a9c369b74cb4cefed633f309c892e213e0ed32eed0937c0a5627480"
+   }
   }
  },
  "nbformat": 4,

portiloop/src/__init__.py

@@ -0,0 +1 @@
+ADS = False

portiloop/{capture.py → src/capture.py}

@@ -1,345 +1,31 @@
-import os
-import sys
+
 
 from time import sleep
 import time
 import numpy as np
-import os
 from copy import deepcopy
-from pathlib import Path
-from datetime import datetime, timedelta
+from datetime import datetime
 import multiprocessing as mp
 import warnings
-import shutil
 from threading import Thread, Lock
-import alsaaudio
+from portiloop.src import ADS
+
+if ADS:
+    import alsaaudio
+    from portiloop.src.hardware.frontend import Frontend
+    from portiloop.src.hardware.leds import LEDs, Color
 
-from EDFlib.edfwriter import EDFwriter
-from scipy.signal import firwin
+from portiloop.src.stimulation import UpStateDelayer
 
-from portilooplot.jupyter_plot import ProgressPlot
-from portiloop.hardware.frontend import Frontend
-from portiloop.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 IPython.display import clear_output, display
 import ipywidgets as widgets
 
 
-DEFAULT_FRONTEND_CONFIG = [
-    # nomenclature: name [default setting] [bits 7-0] : description
-    # Read only ID:
-    0x3E, # ID [xx] [REV_ID[2:0], 1, DEV_ID[1:0], NU_CH[1:0]] : (RO)
-    # Global Settings Across Channels:
-    0x96, # CONFIG1 [96] [1, DAISY_EN(bar), CLK_EN, 1, 0, DR[2:0]] : Datarate = 250 SPS
-    0xC0, # CONFIG2 [C0] [1, 1, 0, INT_CAL, 0, CAL_AMP0, CAL_FREQ[1:0]] : No tests
-    0x60, # CONFIG3 [60] [PD_REFBUF(bar), 1, 1, BIAS_MEAS, BIASREF_INT, PD_BIAS(bar), BIAS_LOFF_SENS, BIAS_STAT] : Power-down reference buffer, no bias
-    0x00, # LOFF [00] [COMP_TH[2:0], 0, ILEAD_OFF[1:0], FLEAD_OFF[1:0]] : No lead-off
-    # Channel-Specific Settings:
-    0x61, # CH1SET [61] [PD1, GAIN1[2:0], SRB2, MUX1[2:0]] : Channel 1 active, 24 gain, no SRB2 & input shorted
-    0x61, # CH2SET [61] [PD2, GAIN2[2:0], SRB2, MUX2[2:0]] : Channel 2 active, 24 gain, no SRB2 & input shorted
-    0x61, # CH3SET [61] [PD3, GAIN3[2:0], SRB2, MUX3[2:0]] : Channel 3 active, 24 gain, no SRB2 & input shorted
-    0x61, # CH4SET [61] [PD4, GAIN4[2:0], SRB2, MUX4[2:0]] : Channel 4 active, 24 gain, no SRB2 & input shorted
-    0x61, # CH5SET [61] [PD5, GAIN5[2:0], SRB2, MUX5[2:0]] : Channel 5 active, 24 gain, no SRB2 & input shorted
-    0x61, # CH6SET [61] [PD6, GAIN6[2:0], SRB2, MUX6[2:0]] : Channel 6 active, 24 gain, no SRB2 & input shorted
-    0x61, # CH7SET [61] [PD7, GAIN7[2:0], SRB2, MUX7[2:0]] : Channel 7 active, 24 gain, no SRB2 & input shorted
-    0x61, # CH8SET [61] [PD8, GAIN8[2:0], SRB2, MUX8[2:0]] : Channel 8 active, 24 gain, no SRB2 & input shorted
-    0x00, # BIAS_SENSP [00] [BIASP8, BIASP7, BIASP6, BIASP5, BIASP4, BIASP3, BIASP2, BIASP1] : No bias
-    0x00, # BIAS_SENSN [00] [BIASN8, BIASN7, BIASN6, BIASN5, BIASN4, BIASN3, BIASN2, BIASN1] No bias
-    0x00, # LOFF_SENSP [00] [LOFFP8, LOFFP7, LOFFP6, LOFFP5, LOFFP4, LOFFP3, LOFFP2, LOFFP1] : No lead-off
-    0x00, # LOFF_SENSN [00] [LOFFM8, LOFFM7, LOFFM6, LOFFM5, LOFFM4, LOFFM3, LOFFM2, LOFFM1] : No lead-off
-    0x00, # LOFF_FLIP [00] [LOFF_FLIP8, LOFF_FLIP7, LOFF_FLIP6, LOFF_FLIP5, LOFF_FLIP4, LOFF_FLIP3, LOFF_FLIP2, LOFF_FLIP1] : No lead-off flip
-    # Lead-Off Status Registers (Read-Only Registers):
-    0x00, # LOFF_STATP [00] [IN8P_OFF, IN7P_OFF, IN6P_OFF, IN5P_OFF, IN4P_OFF, IN3P_OFF, IN2P_OFF, IN1P_OFF] : Lead-off positive status (RO)
-    0x00, # LOFF_STATN [00] [IN8M_OFF, IN7M_OFF, IN6M_OFF, IN5M_OFF, IN4M_OFF, IN3M_OFF, IN2M_OFF, IN1M_OFF] : Laed-off negative status (RO)
-    # GPIO and OTHER Registers:
-    0x0F, # GPIO [0F] [GPIOD[4:1], GPIOC[4:1]] : All GPIOs as inputs
-    0x00, # MISC1 [00] [0, 0, SRB1, 0, 0, 0, 0, 0] : Disable SRBM
-    0x00, # MISC2 [00] [00] : Unused
-    0x00, # CONFIG4 [00] [0, 0, 0, 0, SINGLE_SHOT, 0, PD_LOFF_COMP(bar), 0] : Single-shot, lead-off comparator disabled
-]
-
-FRONTEND_CONFIG = [
-    0x3E, # ID (RO)
-    0x95, # CONFIG1 [95] [1, DAISY_EN(bar), CLK_EN, 1, 0, DR[2:0]] : Datarate = 500 SPS
-    0xD0, # CONFIG2 [C0] [1, 1, 0, INT_CAL, 0, CAL_AMP0, CAL_FREQ[1:0]]
-    0xFC, # CONFIG3 [E0] [PD_REFBUF(bar), 1, 1, BIAS_MEAS, BIASREF_INT, PD_BIAS(bar), BIAS_LOFF_SENS, BIAS_STAT] : Power-down reference buffer, no bias
-    0x00, # No lead-off
-    0x62, # CH1SET [60] [PD1, GAIN1[2:0], SRB2, MUX1[2:0]] set to measure BIAS signal
-    0x60, # CH2SET
-    0x60, # CH3SET
-    0x60, # CH4SET
-    0x60, # CH5SET
-    0x60, # CH6SET
-    0x60, # CH7SET
-    0x60, # CH8SET
-    0x00, # BIAS_SENSP 00
-    0x00, # BIAS_SENSN 00
-    0x00, # LOFF_SENSP Lead-off on all positive pins?
-    0x00, # LOFF_SENSN Lead-off on all negative pins?
-    0x00, # Normal lead-off
-    0x00, # Lead-off positive status (RO)
-    0x00, # Lead-off negative status (RO)
-    0x00, # All GPIOs as output ?
-    0x20, # Enable SRB1
-]
-
-
-LEADOFF_CONFIG = [
-    0x3E, # ID (RO)
-    0x95, # CONFIG1 [95] [1, DAISY_EN(bar), CLK_EN, 1, 0, DR[2:0]] : Datarate = 500 SPS
-    0xC0, # CONFIG2 [C0] [1, 1, 0, INT_CAL, 0, CAL_AMP0, CAL_FREQ[1:0]]
-    0xFC, # CONFIG3 [E0] [PD_REFBUF(bar), 1, 1, BIAS_MEAS, BIASREF_INT, PD_BIAS(bar), BIAS_LOFF_SENS, BIAS_STAT] : Power-down reference buffer, no bias
-    0x00, # No lead-off
-    0x60, # CH1SET [60] [PD1, GAIN1[2:0], SRB2, MUX1[2:0]] set to measure BIAS signal
-    0x60, # CH2SET
-    0x60, # CH3SET
-    0x60, # CH4SET
-    0x60, # CH5SET
-    0x60, # CH6SET
-    0x60, # CH7SET
-    0x60, # CH8SET
-    0x00, # BIAS_SENSP 00
-    0x00, # BIAS_SENSN 00
-    0xFF, # LOFF_SENSP Lead-off on all positive pins?
-    0xFF, # LOFF_SENSN Lead-off on all negative pins?
-    0x00, # Normal lead-off
-    0x00, # Lead-off positive status (RO)
-    0x00, # Lead-off negative status (RO)
-    0x00, # All GPIOs as output ?
-    0x20, # Enable SRB1
-    0x00,
-    0x02,
-]
-
-EDF_PATH = Path.home() / 'workspace' / 'edf_recording'
-
-
-def to_ads_frequency(frequency):
-    possible_datarates = [250, 500, 1000, 2000, 4000, 8000, 16000]
-    dr = 16000
-    for i in possible_datarates:
-        if i >= frequency:
-            dr = i
-            break
-    return dr
-    
-def mod_config(config, datarate, channel_modes):
-    
-    # datarate:
-
-    possible_datarates = [(250, 0x06),
-                          (500, 0x05),
-                          (1000, 0x04),
-                          (2000, 0x03),
-                          (4000, 0x02),
-                          (8000, 0x01),
-                          (16000, 0x00)]
-    mod_dr = 0x00
-    for i, j in possible_datarates:
-        if i >= datarate:
-            mod_dr = j
-            break
-    
-    new_cf1 = config[1] & 0xF8
-    new_cf1 = new_cf1 | mod_dr
-    config[1] = new_cf1
-    
-    # bias:
-    assert len(channel_modes) == 7
-    config[13] = 0x00  # clear BIAS_SENSP
-    config[14] = 0x00  # clear BIAS_SENSN
-    for chan_i, chan_mode in enumerate(channel_modes):
-        n = 6 + chan_i
-        mod = config[n] & 0x78  # clear PDn and MUX[2:0]
-        if chan_mode == 'simple':
-            # If channel is activated, we send the channel's output to the BIAS mechanism
-            bit_i = 1 << chan_i + 1
-            config[13] = config[13] | bit_i
-            config[14] = config[14] | bit_i
-        elif chan_mode == 'disabled':
-            mod = mod | 0x81  # PDn = 1 and input shorted (001)
-        else:
-            assert False, f"Wrong key: {chan_mode}."
-        config[n] = mod
-    for n, c in enumerate(config):  # print ADS1299 configuration registers
-        print(f"config[{n}]:\t{c:08b}\t({hex(c)})")
-    return config
-
-
-def filter_24(value):
-    return (value * 4.5) / (2**23 - 1) / 24.0 * 1e6  # 23 because 1 bit is lost for sign
-
-
-def filter_2scomplement_np(value):
-    return np.where((value & (1 << 23)) != 0, value - (1 << 24), value)
-
-
-def filter_np(value):
-    return filter_24(filter_2scomplement_np(value))
-
-
-def shift_numpy(arr, num, fill_value=np.nan):
-    result = np.empty_like(arr)
-    if num > 0:
-        result[:num] = fill_value
-        result[num:] = arr[:-num]
-    elif num < 0:
-        result[num:] = fill_value
-        result[:num] = arr[-num:]
-    else:
-        result[:] = arr
-    return result
-
-
-class FIR:
-    def __init__(self, nb_channels, coefficients, buffer=None):
-        
-        self.coefficients = np.expand_dims(np.array(coefficients), axis=1)
-        self.taps = len(self.coefficients)
-        self.nb_channels = nb_channels
-        self.buffer = np.array(z) if buffer is not None else np.zeros((self.taps, self.nb_channels))
-    
-    def filter(self, x):
-        self.buffer = shift_numpy(self.buffer, 1, x)
-        filtered = np.sum(self.buffer * self.coefficients, axis=0)
-        return filtered
-
-    
-class FilterPipeline:
-    def __init__(self,
-                 nb_channels,
-                 sampling_rate,
-                 power_line_fq=60,
-                 use_custom_fir=False,
-                 custom_fir_order=20,
-                 custom_fir_cutoff=30,
-                 alpha_avg=0.1,
-                 alpha_std=0.001,
-                 epsilon=0.000001,
-                 filter_args=[]):
-        if len(filter_args) > 0:
-            use_fir, use_notch, use_std = filter_args
-        else:
-            use_fir=True,
-            use_notch=True,
-            use_std=True
-        self.use_fir = use_fir
-        self.use_notch = use_notch
-        self.use_std = use_std
-        self.nb_channels = nb_channels
-        assert power_line_fq in [50, 60], f"The only supported power line frequencies are 50 Hz and 60 Hz"
-        if power_line_fq == 60:
-            self.notch_coeff1 = -0.12478308884588535
-            self.notch_coeff2 = 0.98729186796473023
-            self.notch_coeff3 = 0.99364593398236511
-            self.notch_coeff4 = -0.12478308884588535
-            self.notch_coeff5 = 0.99364593398236511
-        else:
-            self.notch_coeff1 = -0.61410695998423581
-            self.notch_coeff2 =  0.98729186796473023
-            self.notch_coeff3 = 0.99364593398236511
-            self.notch_coeff4 = -0.61410695998423581
-            self.notch_coeff5 = 0.99364593398236511
-        self.dfs = [np.zeros(self.nb_channels), np.zeros(self.nb_channels)]
-        
-        self.moving_average = None
-        self.moving_variance = np.zeros(self.nb_channels)
-        self.ALPHA_AVG = alpha_avg
-        self.ALPHA_STD = alpha_std
-        self.EPSILON = epsilon
-        
-        if use_custom_fir:
-            self.fir_coef = firwin(numtaps=custom_fir_order+1, cutoff=custom_fir_cutoff, fs=sampling_rate)
-        else:
-            self.fir_coef = [
-                0.001623780150148094927192721215192250384,
-                0.014988684599373741992978104065059596905,
-                0.021287595318265635502275046064823982306,
-                0.007349500393709578957568417933998716762,
-                -0.025127515717112181709014251396183681209,
-                -0.052210507359822452833064687638398027048,
-                -0.039273839505489904766477593511808663607,
-                0.033021568427940004020193498490698402748,
-                0.147606943281569008563636202779889572412,
-                0.254000252034505602516389899392379447818,
-                0.297330876398883392486283128164359368384,
-                0.254000252034505602516389899392379447818,
-                0.147606943281569008563636202779889572412,
-                0.033021568427940004020193498490698402748,
-                -0.039273839505489904766477593511808663607,
-                -0.052210507359822452833064687638398027048,
-                -0.025127515717112181709014251396183681209,
-                0.007349500393709578957568417933998716762,
-                0.021287595318265635502275046064823982306,
-                0.014988684599373741992978104065059596905,
-                0.001623780150148094927192721215192250384]
-        self.fir = FIR(self.nb_channels, self.fir_coef)
-        
-    def filter(self, value):
-        """
-        value: a numpy array of shape (data series, channels)
-        """
-        for i, x in enumerate(value):  # loop over the data series
-            # FIR:
-            if self.use_fir:
-                x = self.fir.filter(x)
-            # notch:
-            if self.use_notch:
-                denAccum = (x - self.notch_coeff1 * self.dfs[0]) - self.notch_coeff2 * self.dfs[1]
-                x = (self.notch_coeff3 * denAccum + self.notch_coeff4 * self.dfs[0]) + self.notch_coeff5 * self.dfs[1]
-                self.dfs[1] = self.dfs[0]
-                self.dfs[0] = denAccum
-            # standardization:
-            if self.use_std:
-                if self.moving_average is not None:
-                    delta = x - self.moving_average
-                    self.moving_average = self.moving_average + self.ALPHA_AVG * delta
-                    self.moving_variance = (1 - self.ALPHA_STD) * (self.moving_variance + self.ALPHA_STD * delta**2)
-                    moving_std = np.sqrt(self.moving_variance)
-                    x = (x - self.moving_average) / (moving_std + self.EPSILON)
-                else:
-                    self.moving_average = x
-            value[i] = x
-        return value
-
-
-class LiveDisplay():
-    def __init__(self, channel_names, window_len=100):
-        self.datapoint_dim = len(channel_names)
-        self.history = []
-        self.pp = ProgressPlot(plot_names=channel_names, max_window_len=window_len)
-        self.matplotlib = False
-
-    def add_datapoints(self, datapoints):
-        """
-        Adds 8 lists of datapoints to the plot
-        
-        Args:
-            datapoints: list of 8 lists of floats (or list of 8 floats)
-        """
-        if self.matplotlib:
-            import matplotlib.pyplot as plt
-        disp_list = []
-        for datapoint in datapoints:
-            d = [[elt] for elt in datapoint]
-            disp_list.append(d)
-            
-            if self.matplotlib:
-                self.history += d[1]
-        
-        if not self.matplotlib:
-            self.pp.update_with_datapoints(disp_list)
-        elif len(self.history) == 1000:
-            plt.plot(self.history)
-            plt.show()
-            self.history = []
-    
-    def add_datapoint(self, datapoint):
-        disp_list = [[elt] for elt in datapoint]
-        self.pp.update(disp_list)
-
-
-def _capture_process(p_data_o, p_msg_io, duration, frequency, python_clock, time_msg_in, channel_states):
+def capture_process(p_data_o, p_msg_io, duration, frequency, python_clock, time_msg_in, channel_states):
     """
     Args:
         p_data_o: multiprocessing.Pipe: captured datapoints are put here
@@ -434,69 +120,8 @@ def _capture_process(p_data_o, p_msg_io, duration, frequency, python_clock, time
         p_msg_io.send('STOP')
         p_msg_io.close()
         p_data_o.close()
-
-
-class DummyAlsaMixer:
-    def __init__(self):
-        self.volume = 50
-    
-    def getvolume(self):
-        return [self.volume]
     
-    def setvolume(self, volume):
-        self.volume = volume
-
 
-class UpStateDelayer:
-    def __init__(self, sample_freq, spindle_freq, peak): 
-        '''
-        args:
-            buffer_size: int -> Size of desired buffer in length
-            sample_freq: int -> Sampling frequency of signal in Hz
-        '''
-        # 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 = []
-
-    def add_point(self, point):
-        '''
-        Adds a point to the buffer to be able to keep track of peaks
-        '''
-        self.buffer.append(point)
-        if len(self.buffer) > self.buffer_size:
-            self.buffer.pop(0)
-
-    def stimulate(self): 
-        # Calculate how far away is last peak
-        last_peak = -1
-        count = 0
-        for idx, point in reversed(list(enumerate(self.buffer))):
-            if self.peak:
-                try:
-                    sup = point >= self.buffer[idx+1]
-                except IndexError:
-                    sup = False
-                try:
-                    inf = point >= self.buffer[idx-1]
-                except IndexError:
-                    inf = False
-            else:
-                try:
-                    sup = point <= self.buffer[idx+1]
-                except IndexError:
-                    sup = False
-                try:
-                    inf = point <= self.buffer[idx-1]
-                except IndexError:
-                    inf = False
-            if sup and inf:
-                last_peak = count
-                return self.spindle_timesteps - last_peak
-            count += 1
-        return -1        
 
 class Capture:
     def __init__(self, detector_cls=None, stimulator_cls=None):
@@ -521,13 +146,10 @@ class Capture:
         self.threshold = 0.5
         self.lsl = False
         self.display = False
+        self.signal_input = "ADS"
         self.python_clock = True
         self.edf_writer = None
         self.edf_buffer = []
-        self.nb_signals = 8
-        self.samples_per_datarecord_array = self.frequency
-        self.physical_max = 5
-        self.physical_min = -5
         self.signal_labels = ['Common Mode', 'ch2', 'ch3', 'ch4', 'ch5', 'ch6', 'ch7', 'ch8']
         self._lock_msg_out = Lock()
         self._msg_out = None
@@ -546,22 +168,25 @@ class Capture:
         self._pause_detect_lock = Lock()
         self._pause_detect = True
         
-        try:
-            mixers = alsaaudio.mixers()
-            if len(mixers) <= 0:
+        if ADS:
+            try:
+                mixers = alsaaudio.mixers()
+                if len(mixers) <= 0:
+                    warnings.warn(f"No ALSA mixer found.")
+                    self.mixer = DummyAlsaMixer()
+                elif 'PCM' in mixers:
+                    self.mixer = alsaaudio.Mixer(control='PCM')
+                else:
+                    warnings.warn(f"Could not find mixer PCM, using {mixers[0]} instead.")
+                    self.mixer = alsaaudio.Mixer(control=mixers[0])
+            except ALSAAudioError as e:
                 warnings.warn(f"No ALSA mixer found.")
                 self.mixer = DummyAlsaMixer()
-            elif 'PCM' in mixers:
-                self.mixer = alsaaudio.Mixer(control='PCM')
-            else:
-                warnings.warn(f"Could not find mixer PCM, using {mixers[0]} instead.")
-                self.mixer = alsaaudio.Mixer(control=mixers[0])
-        except ALSAAudioError as e:
-            warnings.warn(f"No ALSA mixer found.")
+            
+            self.volume = self.mixer.getvolume()[0]  # we will set the same volume on all channels
+        else:
             self.mixer = DummyAlsaMixer()
-        
-        self.volume = self.mixer.getvolume()[0]  # we will set the same volume on all channels
-        
+            self.volume = self.mixer.getvolume()[0]
         
         # widgets ===============================
         
@@ -678,7 +303,7 @@ class Capture:
         )
         
         self.b_clock = widgets.ToggleButtons(
-            options=['Coral', 'ADS'],
+            options=['ADS', 'Coral'],
             description='Clock:',
             disabled=False,
             button_style='', # 'success', 'info', 'warning', 'danger' or ''
@@ -694,6 +319,15 @@ class Capture:
             tooltips=['North America 60 Hz',
                       'Europe 50 Hz'],
         )
+
+        self.b_signal_input = widgets.ToggleButtons(
+            options=['ADS', 'File'],
+            description='Signal Input:',
+            disabled=False,
+            button_style='', # 'success', 'info', 'warning', 'danger' or ''
+            tooltips=['Read data from ADS.',
+                      'Read data from file.'],
+        )
         
         self.b_custom_fir = widgets.ToggleButtons(
             options=['Default', 'Custom'],
@@ -890,6 +524,7 @@ class Capture:
         self.b_spindle_mode.observe(self.on_b_spindle_mode, 'value')
         self.b_spindle_freq.observe(self.on_b_spindle_freq, 'value')
         self.b_power_line.observe(self.on_b_power_line, 'value')
+        self.b_signal_input.observe(self.on_b_power_line, 'value')
         self.b_custom_fir.observe(self.on_b_custom_fir, 'value')
         self.b_custom_fir_order.observe(self.on_b_custom_fir_order, 'value')
         self.b_custom_fir_cutoff.observe(self.on_b_custom_fir_cutoff, 'value')
@@ -900,9 +535,10 @@ class Capture:
         self.b_test_stimulus.on_click(self.on_b_test_stimulus)
         self.b_test_impedance.on_click(self.on_b_test_impedance)
         self.b_pause.observe(self.on_b_pause, 'value')
-        
+
         self.display_buttons()
 
+
     def __del__(self):
         self.b_capture.close()
     
@@ -912,6 +548,7 @@ class Capture:
                               self.b_frequency,
                               self.b_duration,
                               self.b_filename,
+                              self.b_signal_input,
                               self.b_power_line,
                               self.b_clock,
                               widgets.HBox([self.b_filter, self.b_detect, self.b_stimulate, self.b_record, self.b_lsl, self.b_display]),
@@ -941,6 +578,7 @@ class Capture:
         self.b_radio_ch7.disabled = False
         self.b_radio_ch8.disabled = False
         self.b_power_line.disabled = False
+        self.b_signal_input.disabled = False
         self.b_channel_detect.disabled = False
         self.b_spindle_freq.disabled = False
         self.b_spindle_mode.disabled = False
@@ -981,6 +619,7 @@ class Capture:
         self.b_channel_detect.disabled = True
         self.b_spindle_freq.disabled = True
         self.b_spindle_mode.disabled = True
+        self.b_signal_input.disabled = True
         self.b_power_line.disabled = True
         self.b_polyak_mean.disabled = True
         self.b_polyak_std.disabled = True
@@ -1067,8 +706,6 @@ class Capture:
             self._t_capture = None
             self.enable_buttons()
             
-    
-    
     def on_b_custom_fir(self, value):
         val = value['new']
         if val == 'Default':
@@ -1083,13 +720,20 @@ class Capture:
             self.python_clock = True
         elif val == 'ADS':
             self.python_clock = False
-    
+
+    def on_b_signal_input(self, value):
+        val = value['new']
+        if val == "ADS":
+            self.signal_input = "ADS"
+        elif val == "File":
+            self.signal_input = "File"
+
     def on_b_power_line(self, value):
         val = value['new']
         if val == '60 Hz':
             self.power_line = 60
         elif val == '50 Hz':
-            self.python_clock = 50
+            self.power_line = 50
     
     def on_b_frequency(self, value):
         val = value['new']
@@ -1243,42 +887,6 @@ class Capture:
         elif val == 'Paused':
             with self._pause_detect_lock:
                 self._pause_detect = True
-    
-    def open_recording_file(self):
-        nb_signals = self.nb_signals
-        samples_per_datarecord_array = self.samples_per_datarecord_array
-        physical_max = self.physical_max
-        physical_min = self.physical_min
-        signal_labels = self.signal_labels
-
-        print(f"Will store edf recording in {self.filename}")
-
-        self.edf_writer = EDFwriter(p_path=str(self.filename),
-                                    f_file_type=EDFwriter.EDFLIB_FILETYPE_EDFPLUS,
-                                    number_of_signals=nb_signals)
-        
-        for signal in range(nb_signals):
-            assert self.edf_writer.setSampleFrequency(signal, samples_per_datarecord_array) == 0
-            assert self.edf_writer.setPhysicalMaximum(signal, physical_max) == 0
-            assert self.edf_writer.setPhysicalMinimum(signal, physical_min) == 0
-            assert self.edf_writer.setDigitalMaximum(signal, 32767) == 0
-            assert self.edf_writer.setDigitalMinimum(signal, -32768) == 0
-            assert self.edf_writer.setSignalLabel(signal, signal_labels[signal]) == 0
-            assert self.edf_writer.setPhysicalDimension(signal, 'V') == 0
-
-    def close_recording_file(self):
-        assert self.edf_writer.close() == 0
-    
-    def add_recording_data(self, data):
-        self.edf_buffer += data
-        if len(self.edf_buffer) >= self.samples_per_datarecord_array:
-            datarecord_array = self.edf_buffer[:self.samples_per_datarecord_array]
-            self.edf_buffer = self.edf_buffer[self.samples_per_datarecord_array:]
-            datarecord_array = np.array(datarecord_array).transpose()
-            assert len(datarecord_array) == self.nb_signals, f"len(data)={len(data)}!={self.nb_signals}"
-            for d in datarecord_array:
-                assert len(d) == self.samples_per_datarecord_array, f"{len(d)}!={self.samples_per_datarecord_array}"
-                assert self.edf_writer.writeSamples(d) == 0
 
     def start_capture(self,
                       filter,
@@ -1292,15 +900,17 @@ class Capture:
                       viz,
                       width,
                       python_clock):
-        if self.__capture_on:
-            warnings.warn("Capture is already ongoing, ignoring command.")
-            return
-        else:
-            self.__capture_on = True
-            p_msg_io, p_msg_io_2 = mp.Pipe()
-            p_data_i, p_data_o = mp.Pipe(duplex=False)
-        SAMPLE_TIME = 1 / self.frequency
 
+        if self.signal_input == "ADS":
+            if self.__capture_on:
+                warnings.warn("Capture is already ongoing, ignoring command.")
+                return
+            else:
+                self.__capture_on = True
+                p_msg_io, p_msg_io_2 = mp.Pipe()
+                p_data_i, p_data_o = mp.Pipe(duplex=False)
+
+        # Initialize filtering pipeline
         if filter:
             fp = FilterPipeline(nb_channels=8,
                                 sampling_rate=self.frequency,
@@ -1312,28 +922,37 @@ class Capture:
                                 alpha_std=self.polyak_std,
                                 epsilon=self.epsilon,
                                 filter_args=filter_args)
-            
+        
+        # Initialize detector and stimulator
         detector = detector_cls(threshold, channel=channel) if detector_cls is not None else None
         stimulator = stimulator_cls() if stimulator_cls is not None else None
 
-        self._p_capture = mp.Process(target=_capture_process,
-                                     args=(p_data_o,
-                                           p_msg_io_2,
-                                           self.duration,
-                                           self.frequency,
-                                           python_clock,
-                                           1.0,
-                                           self.channel_states)
-                                    )
-        self._p_capture.start()
-        print(f"PID capture: {self._p_capture.pid}")
+        # Launch the capture process
+        if self.signal_input == "ADS":
+            self._p_capture = mp.Process(target=capture_process,
+                                        args=(p_data_o,
+                                            p_msg_io_2,
+                                            self.duration,
+                                            self.frequency,
+                                            python_clock,
+                                            1.0,
+                                            self.channel_states)
+                                        )
+            self._p_capture.start()
+            print(f"PID capture: {self._p_capture.pid}")
+        else:
+            filename = "INSERT FILENAME" # TODO
+            file_reader = FileReader(filename)
 
+        # Initialize display if requested
         if viz:
             live_disp = LiveDisplay(channel_names = self.signal_labels, window_len=width)
 
+        # Initialize recording if requested
         if record:
-            self.open_recording_file()
+            recorder = EDFRecorder(self.signal_label)
         
+        # Initialize LSL to stream if requested
         if lsl:
             from pylsl import StreamInfo, StreamOutlet
             lsl_info = StreamInfo(name='Portiloop Filtered',
@@ -1353,53 +972,71 @@ class Capture:
 
         buffer = []
 
+        # 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')
+            stimulation_delayer = UpStateDelayer(self.frequency, self.spindle_freq, self.spindle_detection_mode == 'Peak', time_to_buffer=0.1)
             stimulator.add_delayer(stimulation_delayer)
         else:
             stimulation_delayer = None
 
+        # Main capture loop
         while True:
-            with self._lock_msg_out:
-                if self._msg_out is not None:
-                    p_msg_io.send(self._msg_out)
-                    self._msg_out = None
-            if p_msg_io.poll():
-                mess = p_msg_io.recv()
-                if mess == 'STOP':
-                    break
-                elif mess[0] == 'PRT':
-                    print(mess[1])
+            if self.signal_input == "ADS":
+                # Send message in communication pipe if we have one
+                with self._lock_msg_out:
+                    if self._msg_out is not None:
+                        p_msg_io.send(self._msg_out)
+                        self._msg_out = None
+
+                # Check if we have received a message in communication pipe
+                if p_msg_io.poll():
+                    mess = p_msg_io.recv()
+                    if mess == 'STOP':
+                        break
+                    elif mess[0] == 'PRT':
+                        print(mess[1])
+
+                # Retrieve all data points from data pipe p_data
+                point = None
+                if p_data_i.poll(timeout=(1 / self.frequency)):
+                    point = p_data_i.recv()
+                else:
+                    continue
 
-            # retrieve all data points from p_data and put them in a list of np.array:
-            point = None
-            if p_data_i.poll(timeout=SAMPLE_TIME):
-                point = p_data_i.recv()
-            else:
-                continue
-                
-            n_array = np.array([point])
-            n_array_raw = filter_np(n_array)
+                # 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()
             
+            # Go through filtering pipeline
             if filter:
                 n_array = fp.filter(deepcopy(n_array_raw))
             else:
-                n_array = n_array_raw
-            
+                n_array = deepcopy(n_array_raw)
+
+            # Contains the filtered point (if filtering is off, contains a copy of the raw point)
             filtered_point = n_array.tolist()
             
+            # Send both raw and filtered points over LSL
             if lsl:
                 raw_point = n_array_raw.tolist()
                 lsl_outlet_raw.push_sample(raw_point[-1])
                 lsl_outlet.push_sample(filtered_point[-1])
-                
+            
+            # Adds point to buffer for delayed stimulation
             if stimulation_delayer is not None:
-                stimulation_delayer.add_point(filtered_point[channel-1])
+                stimulation_delayer.step(filtered_point[0][channel-1])
 
+            # Check if detection is on or off
             with self._pause_detect_lock:
                 pause = self._pause_detect
+
+            # If detection is on
             if detector is not None and not pause:
+                # Detect using the latest point
                 detection_signal = detector.detect(filtered_point)
+
+                # Stimulate
                 if stimulator is not None:                    
                     stimulator.stimulate(detection_signal)
                     with self._test_stimulus_lock:
@@ -1407,35 +1044,36 @@ class Capture:
                         self._test_stimulus = False
                     if test_stimulus:
                         stimulator.test_stimulus()
+                
+                if self.signal_input == "File" and gt_stimulation:
+                    stimulator.send_stimulation("GROUND_TRUTH_STIM", False)
             
+            # Add point to the buffer to send to viz and recorder
             buffer += filtered_point
             if len(buffer) >= 50:
-
                 if viz:
                     live_disp.add_datapoints(buffer)
-
                 if record:
-                    self.add_recording_data(buffer)
-                    
+                    recorder.add_recording_data(buffer)
                 buffer = []
 
-        # empty pipes
-        while True:
-            if p_data_i.poll():
-                _ = p_data_i.recv()
-            elif p_msg_io.poll():
-                _ = p_msg_io.recv()
-            else:
-                break
+        if self.signal_input == "ADS":
+            # Empty pipes 
+            while True:
+                if p_data_i.poll():
+                    _ = p_data_i.recv()
+                elif p_msg_io.poll():
+                    _ = p_msg_io.recv()
+                else:
+                    break
 
-        p_data_i.close()
-        p_msg_io.close()
+            p_data_i.close()
+            p_msg_io.close()
+            self._p_capture.join()
+            self.__capture_on = False
         
         if record:
-            self.close_recording_file()
-
-        self._p_capture.join()
-        self.__capture_on = False
+            recorder.close_recording_file()
 
 
 if __name__ == "__main__":

portiloop/src/config.py

@@ -0,0 +1,136 @@
+DEFAULT_FRONTEND_CONFIG = [
+    # nomenclature: name [default setting] [bits 7-0] : description
+    # Read only ID:
+    0x3E, # ID [xx] [REV_ID[2:0], 1, DEV_ID[1:0], NU_CH[1:0]] : (RO)
+    # Global Settings Across Channels:
+    0x96, # CONFIG1 [96] [1, DAISY_EN(bar), CLK_EN, 1, 0, DR[2:0]] : Datarate = 250 SPS
+    0xC0, # CONFIG2 [C0] [1, 1, 0, INT_CAL, 0, CAL_AMP0, CAL_FREQ[1:0]] : No tests
+    0x60, # CONFIG3 [60] [PD_REFBUF(bar), 1, 1, BIAS_MEAS, BIASREF_INT, PD_BIAS(bar), BIAS_LOFF_SENS, BIAS_STAT] : Power-down reference buffer, no bias
+    0x00, # LOFF [00] [COMP_TH[2:0], 0, ILEAD_OFF[1:0], FLEAD_OFF[1:0]] : No lead-off
+    # Channel-Specific Settings:
+    0x61, # CH1SET [61] [PD1, GAIN1[2:0], SRB2, MUX1[2:0]] : Channel 1 active, 24 gain, no SRB2 & input shorted
+    0x61, # CH2SET [61] [PD2, GAIN2[2:0], SRB2, MUX2[2:0]] : Channel 2 active, 24 gain, no SRB2 & input shorted
+    0x61, # CH3SET [61] [PD3, GAIN3[2:0], SRB2, MUX3[2:0]] : Channel 3 active, 24 gain, no SRB2 & input shorted
+    0x61, # CH4SET [61] [PD4, GAIN4[2:0], SRB2, MUX4[2:0]] : Channel 4 active, 24 gain, no SRB2 & input shorted
+    0x61, # CH5SET [61] [PD5, GAIN5[2:0], SRB2, MUX5[2:0]] : Channel 5 active, 24 gain, no SRB2 & input shorted
+    0x61, # CH6SET [61] [PD6, GAIN6[2:0], SRB2, MUX6[2:0]] : Channel 6 active, 24 gain, no SRB2 & input shorted
+    0x61, # CH7SET [61] [PD7, GAIN7[2:0], SRB2, MUX7[2:0]] : Channel 7 active, 24 gain, no SRB2 & input shorted
+    0x61, # CH8SET [61] [PD8, GAIN8[2:0], SRB2, MUX8[2:0]] : Channel 8 active, 24 gain, no SRB2 & input shorted
+    0x00, # BIAS_SENSP [00] [BIASP8, BIASP7, BIASP6, BIASP5, BIASP4, BIASP3, BIASP2, BIASP1] : No bias
+    0x00, # BIAS_SENSN [00] [BIASN8, BIASN7, BIASN6, BIASN5, BIASN4, BIASN3, BIASN2, BIASN1] No bias
+    0x00, # LOFF_SENSP [00] [LOFFP8, LOFFP7, LOFFP6, LOFFP5, LOFFP4, LOFFP3, LOFFP2, LOFFP1] : No lead-off
+    0x00, # LOFF_SENSN [00] [LOFFM8, LOFFM7, LOFFM6, LOFFM5, LOFFM4, LOFFM3, LOFFM2, LOFFM1] : No lead-off
+    0x00, # LOFF_FLIP [00] [LOFF_FLIP8, LOFF_FLIP7, LOFF_FLIP6, LOFF_FLIP5, LOFF_FLIP4, LOFF_FLIP3, LOFF_FLIP2, LOFF_FLIP1] : No lead-off flip
+    # Lead-Off Status Registers (Read-Only Registers):
+    0x00, # LOFF_STATP [00] [IN8P_OFF, IN7P_OFF, IN6P_OFF, IN5P_OFF, IN4P_OFF, IN3P_OFF, IN2P_OFF, IN1P_OFF] : Lead-off positive status (RO)
+    0x00, # LOFF_STATN [00] [IN8M_OFF, IN7M_OFF, IN6M_OFF, IN5M_OFF, IN4M_OFF, IN3M_OFF, IN2M_OFF, IN1M_OFF] : Laed-off negative status (RO)
+    # GPIO and OTHER Registers:
+    0x0F, # GPIO [0F] [GPIOD[4:1], GPIOC[4:1]] : All GPIOs as inputs
+    0x00, # MISC1 [00] [0, 0, SRB1, 0, 0, 0, 0, 0] : Disable SRBM
+    0x00, # MISC2 [00] [00] : Unused
+    0x00, # CONFIG4 [00] [0, 0, 0, 0, SINGLE_SHOT, 0, PD_LOFF_COMP(bar), 0] : Single-shot, lead-off comparator disabled
+]
+
+FRONTEND_CONFIG = [
+    0x3E, # ID (RO)
+    0x95, # CONFIG1 [95] [1, DAISY_EN(bar), CLK_EN, 1, 0, DR[2:0]] : Datarate = 500 SPS
+    0xD0, # CONFIG2 [C0] [1, 1, 0, INT_CAL, 0, CAL_AMP0, CAL_FREQ[1:0]]
+    0xFC, # CONFIG3 [E0] [PD_REFBUF(bar), 1, 1, BIAS_MEAS, BIASREF_INT, PD_BIAS(bar), BIAS_LOFF_SENS, BIAS_STAT] : Power-down reference buffer, no bias
+    0x00, # No lead-off
+    0x62, # CH1SET [60] [PD1, GAIN1[2:0], SRB2, MUX1[2:0]] set to measure BIAS signal
+    0x60, # CH2SET
+    0x60, # CH3SET
+    0x60, # CH4SET
+    0x60, # CH5SET
+    0x60, # CH6SET
+    0x60, # CH7SET
+    0x60, # CH8SET
+    0x00, # BIAS_SENSP 00
+    0x00, # BIAS_SENSN 00
+    0x00, # LOFF_SENSP Lead-off on all positive pins?
+    0x00, # LOFF_SENSN Lead-off on all negative pins?
+    0x00, # Normal lead-off
+    0x00, # Lead-off positive status (RO)
+    0x00, # Lead-off negative status (RO)
+    0x00, # All GPIOs as output ?
+    0x20, # Enable SRB1
+]
+
+
+LEADOFF_CONFIG = [
+    0x3E, # ID (RO)
+    0x95, # CONFIG1 [95] [1, DAISY_EN(bar), CLK_EN, 1, 0, DR[2:0]] : Datarate = 500 SPS
+    0xC0, # CONFIG2 [C0] [1, 1, 0, INT_CAL, 0, CAL_AMP0, CAL_FREQ[1:0]]
+    0xFC, # CONFIG3 [E0] [PD_REFBUF(bar), 1, 1, BIAS_MEAS, BIASREF_INT, PD_BIAS(bar), BIAS_LOFF_SENS, BIAS_STAT] : Power-down reference buffer, no bias
+    0x00, # No lead-off
+    0x60, # CH1SET [60] [PD1, GAIN1[2:0], SRB2, MUX1[2:0]] set to measure BIAS signal
+    0x60, # CH2SET
+    0x60, # CH3SET
+    0x60, # CH4SET
+    0x60, # CH5SET
+    0x60, # CH6SET
+    0x60, # CH7SET
+    0x60, # CH8SET
+    0x00, # BIAS_SENSP 00
+    0x00, # BIAS_SENSN 00
+    0xFF, # LOFF_SENSP Lead-off on all positive pins?
+    0xFF, # LOFF_SENSN Lead-off on all negative pins?
+    0x00, # Normal lead-off
+    0x00, # Lead-off positive status (RO)
+    0x00, # Lead-off negative status (RO)
+    0x00, # All GPIOs as output ?
+    0x20, # Enable SRB1
+    0x00,
+    0x02,
+]
+
+def to_ads_frequency(frequency):
+    possible_datarates = [250, 500, 1000, 2000, 4000, 8000, 16000]
+    dr = 16000
+    for i in possible_datarates:
+        if i >= frequency:
+            dr = i
+            break
+    return dr
+    
+def mod_config(config, datarate, channel_modes):
+    
+    # datarate:
+
+    possible_datarates = [(250, 0x06),
+                          (500, 0x05),
+                          (1000, 0x04),
+                          (2000, 0x03),
+                          (4000, 0x02),
+                          (8000, 0x01),
+                          (16000, 0x00)]
+    mod_dr = 0x00
+    for i, j in possible_datarates:
+        if i >= datarate:
+            mod_dr = j
+            break
+    
+    new_cf1 = config[1] & 0xF8
+    new_cf1 = new_cf1 | mod_dr
+    config[1] = new_cf1
+    
+    # bias:
+    assert len(channel_modes) == 7
+    config[13] = 0x00  # clear BIAS_SENSP
+    config[14] = 0x00  # clear BIAS_SENSN
+    for chan_i, chan_mode in enumerate(channel_modes):
+        n = 6 + chan_i
+        mod = config[n] & 0x78  # clear PDn and MUX[2:0]
+        if chan_mode == 'simple':
+            # If channel is activated, we send the channel's output to the BIAS mechanism
+            bit_i = 1 << chan_i + 1
+            config[13] = config[13] | bit_i
+            config[14] = config[14] | bit_i
+        elif chan_mode == 'disabled':
+            mod = mod | 0x81  # PDn = 1 and input shorted (001)
+        else:
+            assert False, f"Wrong key: {chan_mode}."
+        config[n] = mod
+    # for n, c in enumerate(config):  # print ADS1299 configuration registers
+    #     print(f"config[{n}]:\t{c:08b}\t({hex(c)})")
+    return config

portiloop/src/demo/demo.py

@@ -0,0 +1,53 @@
+import gradio as gr
+
+from portiloop.src.demo.offline import run_offline
+
+        
+def on_upload_file(file):
+    # Check if file extension is .xdf
+    if file.name.split(".")[-1] != "xdf":
+        raise gr.Error("Please upload a .xdf file.")
+    else:
+        return file.name
+
+
+def main():
+    with gr.Blocks(title="Portiloop") as demo:
+        gr.Markdown("# Portiloop Demo")
+        gr.Markdown("This Demo takes as input an XDF file coming from the Portiloop EEG device and allows you to convert it to CSV and perform the following actions:: \n * Filter the data offline \n * Perform offline spindle detection using Wamsley or Lacourse. \n * Simulate the Portiloop online filtering and spindle detection with different parameters.")
+        gr.Markdown("Upload your XDF file and click **Run Inference** to start the processing...")
+
+        with gr.Row():
+            xdf_file_button = gr.UploadButton(label="Click to Upload", type="file", file_count="single")
+            xdf_file_static = gr.File(label="XDF File", type='file', interactive=False)
+
+            xdf_file_button.upload(on_upload_file, xdf_file_button, xdf_file_static)
+
+            # Make a checkbox group for the options
+            detect_filter = gr.CheckboxGroup(['Offline Filtering', 'Lacourse Detection', 'Wamsley Detection', 'Online Filtering', 'Online Detection'], type='index', label="Filtering/Detection options")
+
+            # Threshold value
+            threshold = gr.Slider(0, 1, value=0.82, step=0.01, label="Threshold", interactive=True)
+            # Detection Channel
+            detect_channel = gr.Dropdown(choices=["1", "2", "3", "4", "5", "6", "7", "8"], value="2", label="Detection Channel in XDF recording", interactive=True) 
+            # Frequency
+            freq = gr.Dropdown(choices=["100", "200", "250", "256", "500", "512", "1000", "1024"], value="250", label="Sampling Frequency (Hz)", interactive=True)
+
+        output_array = gr.File(label="Output CSV File")
+
+        run_inference = gr.Button(value="Run Inference")
+        run_inference.click(
+            fn=run_offline, 
+            inputs=[
+                xdf_file_static, 
+                detect_filter,
+                threshold, 
+                detect_channel,
+                freq], 
+            outputs=[output_array])
+
+    demo.queue()
+    demo.launch(share=True)
+
+if __name__ == "__main__":
+    main() 

portiloop/src/demo/offline.py

@@ -0,0 +1,120 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from portiloop.src.detection import SleepSpindleRealTimeDetector
+plt.switch_backend('agg')
+from portiloop.src.processing import FilterPipeline
+from portiloop.src.demo.utils import xdf2array, offline_detect, offline_filter, OfflineSleepSpindleRealTimeStimulator
+import gradio as gr
+
+
+def run_offline(xdf_file, detect_filter_opts, threshold, channel_num, freq):
+    # Get the options from the checkbox group
+    offline_filtering = 0 in detect_filter_opts
+    lacourse = 1 in detect_filter_opts
+    wamsley = 2 in detect_filter_opts
+    online_filtering = 3 in detect_filter_opts
+    online_detection = 4 in detect_filter_opts
+
+    # Make sure the inputs make sense:
+    if not offline_filtering and (lacourse or wamsley):
+        raise gr.Error("You can't use the offline detection methods without offline filtering.")
+
+    if not online_filtering and online_detection:
+        raise gr.Error("You can't use the online detection without online filtering.")
+
+    if xdf_file is None:
+        raise gr.Error("Please upload a .xdf file.")
+
+    freq = int(freq)
+
+    # Read the xdf file to a numpy array
+    print("Loading xdf file...")
+    data_whole, columns = xdf2array(xdf_file.name, int(channel_num))
+    # Do the offline filtering of the data
+    if offline_filtering:
+        print("Filtering offline...")
+        offline_filtered_data = offline_filter(data_whole[:, columns.index("raw_signal")], freq)
+        # Expand the dimension of the filtered data to match the shape of the other columns
+        offline_filtered_data = np.expand_dims(offline_filtered_data, axis=1)
+        data_whole = np.concatenate((data_whole, offline_filtered_data), axis=1)
+        columns.append("offline_filtered_signal")
+
+    #  Do Wamsley's method
+    if wamsley:
+        print("Running Wamsley detection...")
+        wamsley_data = offline_detect("Wamsley", \
+            data_whole[:, columns.index("offline_filtered_signal")],\
+                data_whole[:, columns.index("time_stamps")],\
+                    freq)
+        wamsley_data = np.expand_dims(wamsley_data, axis=1)
+        data_whole = np.concatenate((data_whole, wamsley_data), axis=1)
+        columns.append("wamsley_spindles")
+
+    # Do Lacourse's method
+    if lacourse:
+        print("Running Lacourse detection...")
+        lacourse_data = offline_detect("Lacourse", \
+            data_whole[:, columns.index("offline_filtered_signal")],\
+                data_whole[:, columns.index("time_stamps")],\
+                    freq)
+        lacourse_data = np.expand_dims(lacourse_data, axis=1)
+        data_whole = np.concatenate((data_whole, lacourse_data), axis=1)
+        columns.append("lacourse_spindles")
+
+    # Get the data from the raw signal column
+    data = data_whole[:, columns.index("raw_signal")]
+    
+    # Create the online filtering pipeline
+    if online_filtering:
+        filter = FilterPipeline(nb_channels=1, sampling_rate=freq)
+
+    # Create the detector
+    if online_detection:
+        detector = SleepSpindleRealTimeDetector(threshold=threshold, channel=1) # always 1 because we have only one channel
+        stimulator = OfflineSleepSpindleRealTimeStimulator()
+
+    if online_filtering or online_detection:
+        print("Running online filtering and detection...")
+
+        points = []
+        online_activations = []
+
+        # Go through the data
+        for index, point in enumerate(data):
+            # Filter the data
+            if online_filtering:
+                filtered_point = filter.filter(np.array([point]))
+            else:
+                filtered_point = point
+            filtered_point = filtered_point.tolist()
+            points.append(filtered_point[0])
+
+            if online_detection:
+                # Detect the spindles
+                result = detector.detect([filtered_point])
+
+                # Stimulate if necessary
+                stim = stimulator.stimulate(result)
+                if stim:
+                    online_activations.append(1)
+                else:
+                    online_activations.append(0)
+
+    if online_filtering:
+        online_filtered = np.array(points)
+        online_filtered = np.expand_dims(online_filtered, axis=1)
+        data_whole = np.concatenate((data_whole, online_filtered), axis=1)
+        columns.append("online_filtered_signal")
+
+    if online_detection:
+        online_activations = np.array(online_activations)
+        online_activations = np.expand_dims(online_activations, axis=1)
+        data_whole = np.concatenate((data_whole, online_activations), axis=1)
+        columns.append("online_stimulations")
+
+    print("Saving output...")
+    # Output the data to a csv file
+    np.savetxt("output.csv", data_whole, delimiter=",", header=",".join(columns), comments="")
+
+    print("Done!")
+    return "output.csv"

portiloop/src/demo/test_offline.py

@@ -0,0 +1,49 @@
+import itertools
+import unittest
+from portiloop.src.demo.offline import run_offline
+from pathlib import Path
+
+
+class TestOffline(unittest.TestCase):
+
+    def setUp(self):
+        combinatorial_config = {
+            'offline_filtering': [True, False],
+            'online_filtering': [True, False],
+            'online_detection': [True, False],
+            'wamsley': [True, False],
+            'lacourse': [True, False],
+        }
+
+        self.exclusives = [("duplicate_as_window", "use_cnn_encoder")]
+
+        keys = list(combinatorial_config)
+        all_options_iterator = itertools.product(*map(combinatorial_config.get, keys))
+        all_options_dicts = [dict(zip(keys, values)) for values in all_options_iterator]
+        self.filtered_options = [value for value in all_options_dicts if (value['online_detection'] and value['online_filtering']) or not value['online_detection']]
+        self.xdf_file = Path(__file__).parents[3] / "test_xdf" / "test_file.xdf"
+
+
+    def test_all_options(self):
+        for config in self.filtered_options:
+            if config['online_detection']:
+                self.assertTrue(config['online_filtering'])
+
+    def test_single_option(self):
+        res = list(run_offline(
+                self.xdf_file,
+                offline_filtering=True,
+                online_filtering=True,
+                online_detection=True,
+                wamsley=True,
+                lacourse=True,
+                threshold=0.5,
+                channel_num=2,
+                freq=250))
+        print(res)
+
+    def tearDown(self):
+        pass
+
+if __name__ == '__main__':
+    unittest.main()

portiloop/src/demo/utils.py

@@ -0,0 +1,132 @@
+import numpy as np
+import pyxdf
+from wonambi.detect.spindle import DetectSpindle, detect_Lacourse2018, detect_Wamsley2012
+from scipy.signal import butter, filtfilt, iirnotch, detrend
+import time
+from portiloop.src.stimulation import Stimulator
+
+
+STREAM_NAMES = {
+    'filtered_data': 'Portiloop Filtered',
+    'raw_data': 'Portiloop Raw Data',
+    'stimuli': 'Portiloop_stimuli'
+}
+
+
+class OfflineSleepSpindleRealTimeStimulator(Stimulator):
+    def __init__(self):
+        self.last_detected_ts = time.time()
+        self.wait_t = 0.4  # 400 ms
+        self.delayer = None
+    
+    def stimulate(self, detection_signal):
+        stim = False
+        for sig in detection_signal:
+            # We detect a stimulation
+            if sig:
+                # Record time of stimulation
+                ts = time.time()
+                
+                # Check if time since last stimulation is long enough
+                if ts - self.last_detected_ts > self.wait_t:
+                    if self.delayer is not None:
+                        # If we have a delayer, notify it
+                        self.delayer.detected()
+                    stim = True
+
+                self.last_detected_ts = ts
+        return stim
+
+    def add_delayer(self, delayer):
+        self.delayer = delayer
+        self.delayer.stimulate = lambda: True
+
+def xdf2array(xdf_path, channel):
+    xdf_data, _ = pyxdf.load_xdf(xdf_path)
+
+    # Load all streams given their names
+    filtered_stream, raw_stream, markers = None, None, None
+    for stream in xdf_data:
+        # print(stream['info']['name'])
+        if stream['info']['name'][0] == STREAM_NAMES['filtered_data']:
+            filtered_stream = stream
+        elif stream['info']['name'][0] == STREAM_NAMES['raw_data']:
+            raw_stream = stream
+        elif stream['info']['name'][0] == STREAM_NAMES['stimuli']:
+            markers = stream
+    
+    if filtered_stream is None or raw_stream is None:
+        raise ValueError("One of the necessary streams could not be found. Make sure that at least one signal stream is present in XDF recording")
+
+    # Add all samples from raw and filtered signals
+    csv_list = []
+    diffs = []
+    shortest_stream = min(int(filtered_stream['footer']['info']['sample_count'][0]),
+                          int(raw_stream['footer']['info']['sample_count'][0]))
+    for i in range(shortest_stream):
+        if markers is not None:
+            datapoint = [filtered_stream['time_stamps'][i], 
+                        float(filtered_stream['time_series'][i, channel-1]), 
+                        raw_stream['time_series'][i, channel-1], 
+                        0]
+        else:
+            datapoint = [filtered_stream['time_stamps'][i], 
+                        float(filtered_stream['time_series'][i, channel-1]), 
+                        raw_stream['time_series'][i, channel-1]]
+        diffs.append(abs(filtered_stream['time_stamps'][i] - raw_stream['time_stamps'][i]))
+        csv_list.append(datapoint)
+
+    # Add markers
+    columns = ["time_stamps", "online_filtered_signal_portiloop", "raw_signal"]
+    if markers is not None:
+        columns.append("online_stimulations_portiloop")
+        for time_stamp in markers['time_stamps']:
+            new_index = np.abs(filtered_stream['time_stamps'] - time_stamp).argmin()
+            csv_list[new_index][3] = 1
+    
+    return np.array(csv_list), columns
+    
+
+def offline_detect(method, data, timesteps, freq):
+    # Get the spindle data from the offline methods
+    time = np.arange(0, len(data)) / freq
+    if method == "Lacourse":
+        detector = DetectSpindle(method='Lacourse2018')
+        spindles, _, _ = detect_Lacourse2018(data, freq, time, detector)
+    elif method == "Wamsley":
+        detector = DetectSpindle(method='Wamsley2012')
+        spindles, _, _ = detect_Wamsley2012(data, freq, time, detector)
+    else:
+        raise ValueError("Invalid method")
+
+    # Convert the spindle data to a numpy array
+    spindle_result = np.zeros(data.shape)
+    for spindle in spindles:
+        start = spindle["start"]
+        end = spindle["end"]
+        # Find index of timestep closest to start and end
+        start_index = np.argmin(np.abs(timesteps - start))
+        end_index = np.argmin(np.abs(timesteps - end))
+        spindle_result[start_index:end_index] = 1
+    return spindle_result
+
+
+def offline_filter(signal, freq):
+
+    # Notch filter
+    f0 = 60.0  # Frequency to be removed from signal (Hz)
+    Q = 100.0  # Quality factor
+    b, a = iirnotch(f0, Q, freq)
+    signal = filtfilt(b, a, signal)
+
+    # Bandpass filter
+    lowcut = 0.5
+    highcut = 40.0
+    order = 4
+    b, a = butter(order, [lowcut / (freq / 2.0), highcut / (freq / 2.0)], btype='bandpass')
+    signal = filtfilt(b, a, signal)
+
+    # Detrend the signal
+    signal = detrend(signal)
+
+    return signal

portiloop/{detection.py → src/detection.py}

@@ -1,8 +1,12 @@
 from abc import ABC, abstractmethod
 import time
 from pathlib import Path
+from portiloop.src import ADS
 
-from pycoral.utils import edgetpu
+if ADS:
+    from pycoral.utils import edgetpu
+else:
+    import tensorflow as tf
 import numpy as np
 
 
@@ -39,7 +43,7 @@ class Detector(ABC):
 
 # Example implementation for sleep spindles:
         
-DEFAULT_MODEL_PATH = str(Path(__file__).parent / "models/portiloop_model_quant.tflite")
+DEFAULT_MODEL_PATH = str(Path(__file__).parent.parent / "models/portiloop_model_quant.tflite")
 # print(DEFAULT_MODEL_PATH)
 
 class SleepSpindleRealTimeDetector(Detector):
@@ -51,7 +55,10 @@ class SleepSpindleRealTimeDetector(Detector):
         
         self.interpreters = []
         for i in range(self.num_models_parallel):
-            self.interpreters.append(edgetpu.make_interpreter(model_path))
+            if ADS:
+                self.interpreters.append(edgetpu.make_interpreter(model_path))
+            else:
+                self.interpreters.append(tf.lite.Interpreter(model_path=model_path))
             self.interpreters[i].allocate_tensors()
         self.interpreter_counter = 0
         
@@ -74,6 +81,10 @@ class SleepSpindleRealTimeDetector(Detector):
         super().__init__(threshold)
 
     def detect(self, datapoints):
+        """
+        Takes datapoints as input and outputs a detection signal.
+        datapoints is a list of lists of n channels: may contain several datapoints.
+        """
         res = []
         for inp in datapoints:
             result = self.add_datapoint(inp)
@@ -143,7 +154,3 @@ class SleepSpindleRealTimeDetector(Detector):
             print(f"Computed output {output_data_y} in {end_time - start_time} seconds")
 
         return output_data_y, output_data_h
-        
-        
-    
-    

portiloop/src/processing.py

@@ -0,0 +1,141 @@
+import numpy as np
+from scipy.signal import firwin
+
+
+def filter_24(value):
+    return (value * 4.5) / (2**23 - 1) / 24.0 * 1e6  # 23 because 1 bit is lost for sign
+
+def filter_2scomplement_np(value):
+    return np.where((value & (1 << 23)) != 0, value - (1 << 24), value)
+
+
+def int_to_float(value):
+    """
+    Convert the int value out of the ADS into a value in microvolts 
+    """
+    return filter_24(filter_2scomplement_np(value))
+
+
+def shift_numpy(arr, num, fill_value=np.nan):
+    result = np.empty_like(arr)
+    if num > 0:
+        result[:num] = fill_value
+        result[num:] = arr[:-num]
+    elif num < 0:
+        result[num:] = fill_value
+        result[:num] = arr[-num:]
+    else:
+        result[:] = arr
+    return result
+
+
+class FIR:
+    def __init__(self, nb_channels, coefficients, buffer=None):
+        
+        self.coefficients = np.expand_dims(np.array(coefficients), axis=1)
+        self.taps = len(self.coefficients)
+        self.nb_channels = nb_channels
+        self.buffer = np.array(buffer) if buffer is not None else np.zeros((self.taps, self.nb_channels))
+    
+    def filter(self, x):
+        self.buffer = shift_numpy(self.buffer, 1, x)
+        filtered = np.sum(self.buffer * self.coefficients, axis=0)
+        return filtered
+
+    
+class FilterPipeline:
+    def __init__(self,
+                 nb_channels,
+                 sampling_rate,
+                 power_line_fq=60,
+                 use_custom_fir=False,
+                 custom_fir_order=20,
+                 custom_fir_cutoff=30,
+                 alpha_avg=0.1,
+                 alpha_std=0.001,
+                 epsilon=0.000001,
+                 filter_args=[]):
+        if len(filter_args) > 0:
+            use_fir, use_notch, use_std = filter_args
+        else:
+            use_fir=True,
+            use_notch=True,
+            use_std=True
+        self.use_fir = use_fir
+        self.use_notch = use_notch
+        self.use_std = use_std
+        self.nb_channels = nb_channels
+        assert power_line_fq in [50, 60], f"The only supported power line frequencies are 50 Hz and 60 Hz"
+        if power_line_fq == 60:
+            self.notch_coeff1 = -0.12478308884588535
+            self.notch_coeff2 = 0.98729186796473023
+            self.notch_coeff3 = 0.99364593398236511
+            self.notch_coeff4 = -0.12478308884588535
+            self.notch_coeff5 = 0.99364593398236511
+        else:
+            self.notch_coeff1 = -0.61410695998423581
+            self.notch_coeff2 =  0.98729186796473023
+            self.notch_coeff3 = 0.99364593398236511
+            self.notch_coeff4 = -0.61410695998423581
+            self.notch_coeff5 = 0.99364593398236511
+        self.dfs = [np.zeros(self.nb_channels), np.zeros(self.nb_channels)]
+        
+        self.moving_average = None
+        self.moving_variance = np.zeros(self.nb_channels)
+        self.ALPHA_AVG = alpha_avg
+        self.ALPHA_STD = alpha_std
+        self.EPSILON = epsilon
+        
+        if use_custom_fir:
+            self.fir_coef = firwin(numtaps=custom_fir_order+1, cutoff=custom_fir_cutoff, fs=sampling_rate)
+        else:
+            self.fir_coef = [
+                0.001623780150148094927192721215192250384,
+                0.014988684599373741992978104065059596905,
+                0.021287595318265635502275046064823982306,
+                0.007349500393709578957568417933998716762,
+                -0.025127515717112181709014251396183681209,
+                -0.052210507359822452833064687638398027048,
+                -0.039273839505489904766477593511808663607,
+                0.033021568427940004020193498490698402748,
+                0.147606943281569008563636202779889572412,
+                0.254000252034505602516389899392379447818,
+                0.297330876398883392486283128164359368384,
+                0.254000252034505602516389899392379447818,
+                0.147606943281569008563636202779889572412,
+                0.033021568427940004020193498490698402748,
+                -0.039273839505489904766477593511808663607,
+                -0.052210507359822452833064687638398027048,
+                -0.025127515717112181709014251396183681209,
+                0.007349500393709578957568417933998716762,
+                0.021287595318265635502275046064823982306,
+                0.014988684599373741992978104065059596905,
+                0.001623780150148094927192721215192250384]
+        self.fir = FIR(self.nb_channels, self.fir_coef)
+        
+    def filter(self, value):
+        """
+        value: a numpy array of shape (data series, channels)
+        """
+        for i, x in enumerate(value):  # loop over the data series
+            # FIR:
+            if self.use_fir:
+                x = self.fir.filter(x)
+            # notch:
+            if self.use_notch:
+                denAccum = (x - self.notch_coeff1 * self.dfs[0]) - self.notch_coeff2 * self.dfs[1]
+                x = (self.notch_coeff3 * denAccum + self.notch_coeff4 * self.dfs[0]) + self.notch_coeff5 * self.dfs[1]
+                self.dfs[1] = self.dfs[0]
+                self.dfs[0] = denAccum
+            # standardization:
+            if self.use_std:
+                if self.moving_average is not None:
+                    delta = x - self.moving_average
+                    self.moving_average = self.moving_average + self.ALPHA_AVG * delta
+                    self.moving_variance = (1 - self.ALPHA_STD) * (self.moving_variance + self.ALPHA_STD * delta**2)
+                    moving_std = np.sqrt(self.moving_variance)
+                    x = (x - self.moving_average) / (moving_std + self.EPSILON)
+                else:
+                    self.moving_average = x
+            value[i] = x
+        return value

portiloop/{stimulation.py → src/stimulation.py}

@@ -1,10 +1,17 @@
 from abc import ABC, abstractmethod
+from enum import Enum
 import time
 from threading import Thread, Lock
 from pathlib import Path
-import alsaaudio
+
+from portiloop.src import ADS
+
+if ADS:
+    import alsaaudio
+    import pylsl
+    
 import wave
-import pylsl
+from scipy.signal import find_peaks
 
 
 # Abstract interface for developers:
@@ -32,13 +39,11 @@ class Stimulator(ABC):
 
 class SleepSpindleRealTimeStimulator(Stimulator):
     def __init__(self):
-        self._sound = Path(__file__).parent / 'sounds' / 'stimulus.wav'
+        self._sound = Path(__file__).parent.parent / 'sounds' / 'stimulus.wav'
         print(f"DEBUG:{self._sound}")
         self._thread = None
         self._lock = Lock()
         self.last_detected_ts = time.time()
-        self.wait_counter = 0
-        self.delayed = False
         self.wait_t = 0.4  # 400 ms
         
         lsl_markers_info = pylsl.StreamInfo(name='Portiloop_stimuli',
@@ -55,8 +60,6 @@ class SleepSpindleRealTimeStimulator(Stimulator):
         
         self.lsl_outlet_markers = pylsl.StreamOutlet(lsl_markers_info)
         self.lsl_outlet_markers_fast = pylsl.StreamOutlet(lsl_markers_info_fast)
-
-        self.delayer = None
         
         # Initialize Alsa stuff
         # Open WAV file and set PCM device
@@ -88,7 +91,7 @@ class SleepSpindleRealTimeStimulator(Stimulator):
             while data:
                 self.wav_list.append(data)
                 data = f.readframes(self.periodsize)            
-       
+
     def play_sound(self):
         '''
         Open the wav file and play a sound
@@ -98,39 +101,35 @@ class SleepSpindleRealTimeStimulator(Stimulator):
     
     def stimulate(self, detection_signal):
         for sig in detection_signal:
-            # We are waiting for a delayed stimulation
-            if self.delayed:
-                if self.wait_counter >= self.wait_time:
-                    with self._lock:
-                        if self._thread is None: 
-                            self._thread = Thread(target=self._t_sound, daemon=True)
-                            self._thread.start()
-                    self.delayed = False
-                else:
-                    self.wait_counter += 1
             # We detect a stimulation
-            elif sig:
+            if sig:
                 # Record time of stimulation
-                self.lsl_outlet_markers_fast.push_sample(['FASTSTIM'])
                 ts = time.time()
                 
-                # Prompt delayer to try and get a stimulation
-                if self.delayer is not None:
-                    self.wait_time = self.delayer.stimulate()
-                    self.delayed = True
-                    self.wait_counter = 0
-                    continue
-                
-                # Stimulate if allowed
+                # Check if time since last stimulation is long enough
                 if ts - self.last_detected_ts > self.wait_t:
-                    with self._lock:
-                        if self._thread is None: 
-                            self._thread = Thread(target=self._t_sound, daemon=True)
-                            self._thread.start()
+                    if self.delayer is not None:
+                        # If we have a delayer, notify it
+                        self.delayer.detected()
+                        # Send the LSL marer for the fast stimulation 
+                        self.send_stimulation("FAST_STIM", False)
+                    else:
+                        self.send_stimulation("STIM", True)
+
                 self.last_detected_ts = ts
+
+    def send_stimulation(self, lsl_text, sound):
+        # Send lsl stimulation
+        self.lsl_outlet_markers.push_sample([lsl_text])
+        # Send sound to patient
+        if sound:
+            with self._lock:
+                if self._thread is None: 
+                    self._thread = Thread(target=self._t_sound, daemon=True)
+                    self._thread.start()
+
                 
     def _t_sound(self):
-        self.lsl_outlet_markers.push_sample(['STIM'])
         self.play_sound()
         with self._lock:
             self._thread = None
@@ -140,6 +139,94 @@ class SleepSpindleRealTimeStimulator(Stimulator):
             if self._thread is None:
                 self._thread = Thread(target=self._t_sound, daemon=True)
                 self._thread.start()
-                
+
     def add_delayer(self, delayer):
         self.delayer = delayer
+        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): 
+        '''
+        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.state = States.NO_SPINDLE
+
+    def step(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 time.time() - self.time_started >= self.time_to_buffer:
+                # Compute the necessary time to wait
+                self.time_to_wait = self.compute_time_to_wait()
+                self.state = States.DELAYING
+                self.buffer = []
+                self.time_started = time.time()
+            return False
+        elif self.state == States.DELAYING:
+            # Check if we are done delaying
+            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 detected(self):
+        if self.state == States.NO_SPINDLE:
+            self.state = States.BUFFERING
+            self.time_started = time.time()
+
+    def compute_time_to_wait(self):
+        """
+        Computes the time we want to wait in total based on the spindle frequency and the buffer
+        """
+        # If we want to look at the valleys, we search for peaks on the inversed signal
+        if not self.peak: 
+            self.buffer = -self.buffer
+
+        # Returns the index of the last peak in the buffer
+        peaks, _ = find_peaks(self.buffer, prominence=1)
+
+        # Compute the time until next peak and return it
+        return (len(self.buffer) - peaks[-1]) * (1 / self.sample_freq)
+
+class States(Enum):
+    NO_SPINDLE = 0
+    BUFFERING = 1
+    DELAYING = 2 
+
+
+if __name__ == "__main__":
+    import numpy as np
+    import matplotlib.pyplot as plt
+
+    freq = 250
+    spindle_freq = 10
+    time = 10
+    x = np.linspace(0, time * np.pi, num=time*freq)
+    n = np.random.normal(scale=1, size=x.size)
+    y = np.sin(x) + n
+    plt.plot(x, y)
+    plt.show()
+

portiloop/src/utils.py

@@ -0,0 +1,108 @@
+from EDFlib.edfwriter import EDFwriter
+from portilooplot.jupyter_plot import ProgressPlot
+from pathlib import Path
+import numpy as np
+
+EDF_PATH = Path.home() / 'workspace' / 'edf_recording'
+
+
+
+class DummyAlsaMixer:
+    def __init__(self):
+        self.volume = 50
+    
+    def getvolume(self):
+        return [self.volume]
+    
+    def setvolume(self, volume):
+        self.volume = volume   
+
+
+class EDFRecorder:
+    def __init__(self, signal_labels):
+        self.filename = EDF_PATH / 'recording.edf'
+        self.nb_signals = 8
+        self.samples_per_datarecord_array = self.frequency
+        self.physical_max = 5
+        self.physical_min = -5
+        self.signal_labels = signal_labels
+
+    def open_recording_file(self):
+        nb_signals = self.nb_signals
+        samples_per_datarecord_array = self.samples_per_datarecord_array
+        physical_max = self.physical_max
+        physical_min = self.physical_min
+        signal_labels = self.signal_labels
+
+        print(f"Will store edf recording in {self.filename}")
+
+        self.edf_writer = EDFwriter(p_path=str(self.filename),
+                                    f_file_type=EDFwriter.EDFLIB_FILETYPE_EDFPLUS,
+                                    number_of_signals=nb_signals)
+        
+        for signal in range(nb_signals):
+            assert self.edf_writer.setSampleFrequency(signal, samples_per_datarecord_array) == 0
+            assert self.edf_writer.setPhysicalMaximum(signal, physical_max) == 0
+            assert self.edf_writer.setPhysicalMinimum(signal, physical_min) == 0
+            assert self.edf_writer.setDigitalMaximum(signal, 32767) == 0
+            assert self.edf_writer.setDigitalMinimum(signal, -32768) == 0
+            assert self.edf_writer.setSignalLabel(signal, signal_labels[signal]) == 0
+            assert self.edf_writer.setPhysicalDimension(signal, 'V') == 0
+
+    def close_recording_file(self):
+        assert self.edf_writer.close() == 0
+    
+    def add_recording_data(self, data):
+        self.edf_buffer += data
+        if len(self.edf_buffer) >= self.samples_per_datarecord_array:
+            datarecord_array = self.edf_buffer[:self.samples_per_datarecord_array]
+            self.edf_buffer = self.edf_buffer[self.samples_per_datarecord_array:]
+            datarecord_array = np.array(datarecord_array).transpose()
+            assert len(datarecord_array) == self.nb_signals, f"len(data)={len(data)}!={self.nb_signals}"
+            for d in datarecord_array:
+                assert len(d) == self.samples_per_datarecord_array, f"{len(d)}!={self.samples_per_datarecord_array}"
+                assert self.edf_writer.writeSamples(d) == 0
+
+
+class LiveDisplay():
+    def __init__(self, channel_names, window_len=100):
+        self.datapoint_dim = len(channel_names)
+        self.history = []
+        self.pp = ProgressPlot(plot_names=channel_names, max_window_len=window_len)
+        self.matplotlib = False
+
+    def add_datapoints(self, datapoints):
+        """
+        Adds 8 lists of datapoints to the plot
+        
+        Args:
+            datapoints: list of 8 lists of floats (or list of 8 floats)
+        """
+        if self.matplotlib:
+            import matplotlib.pyplot as plt
+        disp_list = []
+        for datapoint in datapoints:
+            d = [[elt] for elt in datapoint]
+            disp_list.append(d)
+            
+            if self.matplotlib:
+                self.history += d[1]
+        
+        if not self.matplotlib:
+            self.pp.update_with_datapoints(disp_list)
+        elif len(self.history) == 1000:
+            plt.plot(self.history)
+            plt.show()
+            self.history = []
+    
+    def add_datapoint(self, datapoint):
+        disp_list = [[elt] for elt in datapoint]
+        self.pp.update(disp_list)
+
+
+class FileReader:
+    def __init__(self, filename):
+        raise NotImplementedError
+
+    def get_point(self):
+        raise NotImplementedError

setup.py

@@ -11,10 +11,17 @@ setup(
                       'portilooplot',
                       'ipywidgets',
                       'python-periphery',
-                      'spidev',
-                      'pylsl-coral',
                       'scipy',
-                      'pycoral',
-                      'pyalsaaudio'
-                     ]
+                      'matplotlib',
+                     ],
+    extras_require={
+        'Portiloop': ['pycoral', 
+                'spidev', 
+                'pylsl-coral', 
+                'pyalsaaudio'],
+        'PC': ['gradio',
+               'tensorflow',
+               'pyxdf',
+               'wonambi']
+    },
 )