electric-stimulation 0.1.2__tar.gz

electric_stimulation-0.1.2/.github/workflows/publish-pypi.yml

@@ -0,0 +1,31 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build dependencies
+        run: pip install hatch
+
+      - name: Build package
+        run: hatch build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true

electric_stimulation-0.1.2/.gitignore

@@ -0,0 +1,9 @@
+*.json
+*.exe
+*.pyc
+dist/
+build/
+*.egg-info/
+*.egg
+__pycache__/
+.spec

electric_stimulation-0.1.2/Electric_stimulation/WaveGeneGUI.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+Launcher for WaveGene - NI-DAQmx pulse generator.
+"""
+
+import sys
+from Electric_stimulation.wavegene_gui import main
+
+if __name__ == "__main__":
+    sys.exit(main())

electric_stimulation-0.1.2/Electric_stimulation/__init__.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+"""
+Electric Stimulation - NI-DAQmx pulse generator for electrical stimulation.
+
+Provides:
+- wavegene_backend: DAQWorker, build_channel_path for NI-DAQmx output
+- wavegene_gui: WaveGeneWindow, main() for the PyQt5 GUI
+"""
+
+from .wavegene_backend import (
+    DAQ_AVAILABLE,
+    DAQWorker,
+    build_channel_path,
+)
+from .wavegene_gui import WaveGeneWindow, main
+
+__all__ = [
+    "DAQ_AVAILABLE",
+    "DAQWorker",
+    "WaveGeneWindow",
+    "build_channel_path",
+    "main",
+]
+__version__ = "0.1.0"

electric_stimulation-0.1.2/Electric_stimulation/build_exe.py

@@ -0,0 +1,59 @@
+"""
+Script to build a standalone executable for WaveGene.
+
+Usage:
+    python build_exe.py
+    # or: python -m build_exe (from project root)
+
+Prerequisites:
+    pip install -r requirements.txt pyinstaller
+
+The executable will be generated in dist/ (in the current directory).
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+import tempfile
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+
+
+def main():
+    output_dir = Path.cwd() / "dist"
+    exe_name = "WaveGene.exe" if sys.platform == "win32" else "WaveGene"
+    exe_path = output_dir / exe_name
+
+    if exe_path.exists():
+        try:
+            exe_path.unlink()
+        except PermissionError:
+            print("ERROR: The executable is locked (running or in use by another program).")
+            print("Close WaveGene and try again.")
+            sys.exit(1)
+
+    launcher = SCRIPT_DIR / "WaveGeneGUI.py"
+    with tempfile.TemporaryDirectory() as tmp:
+        cmd = [
+            sys.executable, "-m", "PyInstaller",
+            "--name=WaveGene",
+            "--windowed",
+            "--onefile",
+            "--clean",
+            "--distpath", str(output_dir),
+            "--specpath", tmp,
+            "--workpath", tmp,
+            "--hidden-import=PyQt5",
+            "--hidden-import=PyQt5.QtCore",
+            "--hidden-import=PyQt5.QtGui",
+            "--hidden-import=PyQt5.QtWidgets",
+            "--hidden-import=numpy",
+            "--hidden-import=PyDAQmx",
+            str(launcher.resolve()),
+        ]
+        subprocess.run(cmd, check=True, cwd=Path.cwd())
+    print(f"\n✓ Executable created: {exe_path}")
+
+
+if __name__ == "__main__":
+    main()

electric_stimulation-0.1.2/Electric_stimulation/wavegene_backend.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+"""
+Backend for NI-DAQmx pulse generation.
+
+Contains:
+- build_channel_path: build device/channel path
+- DAQWorker: worker thread for DAQ output (infinite/finite, buffer, 0V on exit)
+"""
+
+import time
+from ctypes import byref, c_int32
+
+import numpy as np
+from PyQt5.QtCore import QObject, pyqtSignal, pyqtSlot
+
+# Optional: PyDAQmx for NI-DAQmx hardware access
+try:
+    import PyDAQmx as nidaq
+    DAQ_AVAILABLE = True
+except ImportError:
+    DAQ_AVAILABLE = False
+    nidaq = None
+
+
+def build_channel_path(device_str, channel_str):
+    """
+    Build full channel path for NI-DAQmx.
+    Example: Dev2 + ao0 -> Dev2/ao0
+    """
+    dev = device_str.strip() or "Dev2"
+    ch = channel_str.strip() or "ao0"
+    return f"{dev}/{ch}" if ch else dev
+
+
+class DAQWorker(QObject):
+    """
+    Worker for DAQ generation (runs in QThread).
+    Emits: started (when output begins), finished, error(str).
+    """
+    finished = pyqtSignal()
+    error = pyqtSignal(str)
+    started = pyqtSignal()
+
+    def __init__(self, device, sampling_rate, pulse_duration, inter_pulse_interval,
+                 infinite, nb_pulses, buffer_duration=5.0):
+        super().__init__()
+        self.device = device
+        self.sampling_rate = sampling_rate
+        self.pulse_duration = pulse_duration
+        self.inter_pulse_interval = inter_pulse_interval
+        self.infinite = infinite
+        self.nb_pulses = nb_pulses
+        self.buffer_duration = buffer_duration
+        self._stop_requested = False
+
+    def stop(self):
+        """Request worker to stop (called from main thread)."""
+        self._stop_requested = True
+
+    @pyqtSlot()
+    def run(self):
+        """Main generation logic (runs in worker thread)."""
+        try:
+            if not DAQ_AVAILABLE:
+                self.error.emit("PyDAQmx is not installed.")
+                return
+
+            # Compute sample counts from durations
+            buffer_samples = int(self.buffer_duration * self.sampling_rate)
+            pulse_samples = int(self.pulse_duration * self.sampling_rate)
+            interval_samples = int(self.inter_pulse_interval * self.sampling_rate)
+            samples_per_cycle = pulse_samples + interval_samples
+
+            # Build one cycle: pulse at 2V, then interval at 0V
+            Sig_cycle = np.zeros(samples_per_cycle)
+            Sig_cycle[:pulse_samples] = 2.0
+
+            read = c_int32()
+            t = None
+            if self.infinite:
+                # Buffer once at start, then repeat (pulse+interval) cycle
+                if buffer_samples > 0:
+                    # Phase 1: Output buffer (0V) once at start
+                    self.started.emit()
+                    t_buf = nidaq.Task()
+                    t_buf.CreateAOVoltageChan(self.device, None, -10.0, 10.0,
+                                              nidaq.DAQmx_Val_Volts, None)
+                    t_buf.CfgSampClkTiming("", self.sampling_rate, nidaq.DAQmx_Val_Rising,
+                                          nidaq.DAQmx_Val_FiniteSamps, buffer_samples)
+                    t_buf.WriteAnalogF64(buffer_samples, False, 10,
+                                         nidaq.DAQmx_Val_GroupByScanNumber,
+                                         np.zeros(buffer_samples), byref(read), None)
+                    t_buf.StartTask()
+                    # Poll for completion or stop; WaitUntilTaskDone raises on timeout
+                    buf_timeout = self.buffer_duration + 5
+                    elapsed = 0
+                    while not self._stop_requested and elapsed < buf_timeout:
+                        try:
+                            t_buf.WaitUntilTaskDone(1.0)
+                            break  # Task completed
+                        except Exception:
+                            elapsed += 1.0  # Timeout, keep polling
+                    t_buf.StopTask()
+                    t_buf.ClearTask()
+                    if self._stop_requested:
+                        t = None  # User stopped during buffer, skip main task
+                    else:
+                        # Phase 2: Continuous pulse+interval cycle
+                        t = nidaq.Task()
+                        t.CreateAOVoltageChan(self.device, None, -10.0, 10.0,
+                                             nidaq.DAQmx_Val_Volts, None)
+                        t.CfgSampClkTiming("", self.sampling_rate, nidaq.DAQmx_Val_Rising,
+                                          nidaq.DAQmx_Val_ContSamps, samples_per_cycle)
+                        t.WriteAnalogF64(samples_per_cycle, False, 10,
+                                         nidaq.DAQmx_Val_GroupByScanNumber,
+                                         Sig_cycle, byref(read), None)
+                        t.StartTask()
+                else:
+                    # No buffer: start continuous cycle directly
+                    t = nidaq.Task()
+                    t.CreateAOVoltageChan(self.device, None, -10.0, 10.0,
+                                         nidaq.DAQmx_Val_Volts, None)
+                    t.CfgSampClkTiming("", self.sampling_rate, nidaq.DAQmx_Val_Rising,
+                                      nidaq.DAQmx_Val_ContSamps, samples_per_cycle)
+                    t.WriteAnalogF64(samples_per_cycle, False, 10,
+                                     nidaq.DAQmx_Val_GroupByScanNumber,
+                                     Sig_cycle, byref(read), None)
+                    t.StartTask()
+            else:
+                # Finite mode: buffer + nb_pulses × (pulse + interval)
+                data = np.concatenate([
+                    np.zeros(buffer_samples),
+                    np.tile(Sig_cycle, self.nb_pulses)
+                ])
+                nb_samples = len(data)
+                t = nidaq.Task()
+                t.CreateAOVoltageChan(self.device, None, -10.0, 10.0,
+                                     nidaq.DAQmx_Val_Volts, None)
+                t.CfgSampClkTiming("", self.sampling_rate, nidaq.DAQmx_Val_Rising,
+                                  nidaq.DAQmx_Val_FiniteSamps, nb_samples)
+                t.WriteAnalogF64(nb_samples, False, 10,
+                                 nidaq.DAQmx_Val_GroupByScanNumber,
+                                 data, byref(read), None)
+                t.StartTask()
+
+            # Emit started for GUI timer (buffer case already emitted)
+            if self.infinite and buffer_samples == 0:
+                self.started.emit()
+            elif not self.infinite:
+                self.started.emit()
+
+            # Run main task until stop or completion
+            if t is not None:
+                if self.infinite:
+                    while not self._stop_requested:
+                        time.sleep(0.1)  # Poll for stop request
+                else:
+                    timeout = self.buffer_duration + self.nb_pulses * (self.inter_pulse_interval + self.pulse_duration) + 10
+                    elapsed = 0
+                    while not self._stop_requested and elapsed < timeout:
+                        try:
+                            t.WaitUntilTaskDone(1.0)
+                            break  # Task completed
+                        except Exception:
+                            elapsed += 1.0  # Timeout, keep polling
+
+                t.StopTask()
+                t.ClearTask()
+
+        except Exception as e:
+            self.error.emit(str(e))
+        finally:
+            # Safety: always set output to 0V on exit (stop, completion, or error)
+            if DAQ_AVAILABLE:
+                # First, stop and release any running task that might hold the channel
+                try:
+                    if t is not None:
+                        try:
+                            t.StopTask()
+                        except Exception:
+                            pass
+                        try:
+                            t.ClearTask()
+                        except Exception:
+                            pass
+                except NameError:
+                    pass
+                time.sleep(0.05)  # Allow hardware to release the channel
+                t_zero = None
+                try:
+                    t_zero = nidaq.Task()
+                    t_zero.CreateAOVoltageChan(self.device, None, -10.0, 10.0,
+                                               nidaq.DAQmx_Val_Volts, None)
+                    if hasattr(t_zero, 'WriteAnalogScalarF64'):
+                        t_zero.StartTask()
+                        t_zero.WriteAnalogScalarF64(1, 10.0, 0.0, None)
+                    else:
+                        read_zero = c_int32()
+                        t_zero.CfgSampClkTiming("", 1000, nidaq.DAQmx_Val_Rising,
+                                               nidaq.DAQmx_Val_FiniteSamps, 1)
+                        t_zero.WriteAnalogF64(1, True, 10, nidaq.DAQmx_Val_GroupByScanNumber,
+                                              np.array([0.0], dtype=np.float64), byref(read_zero), None)
+                        try:
+                            t_zero.WaitUntilTaskDone(10.0)
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
+                finally:
+                    if t_zero is not None:
+                        try:
+                            t_zero.StopTask()
+                            t_zero.ClearTask()
+                        except Exception:
+                            pass
+            self.finished.emit()

electric_stimulation-0.1.2/Electric_stimulation/wavegene_gui.py

@@ -0,0 +1,429 @@
+# -*- coding: utf-8 -*-
+"""
+GUI for WaveGene pulse generator.
+
+Displays parameters, state indicator, and controls.
+Uses wavegene_backend for DAQ logic.
+"""
+
+import json
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+from PyQt5.QtCore import Qt, QThread, QTimer
+from PyQt5.QtGui import QFont
+from PyQt5.QtWidgets import (
+    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
+    QGroupBox, QFormLayout, QSpinBox, QDoubleSpinBox, QCheckBox,
+    QPushButton, QLabel, QMessageBox, QLineEdit, QFrame, QFileDialog
+)
+try:
+    from .wavegene_backend import build_channel_path, DAQWorker, DAQ_AVAILABLE
+except ImportError:
+    from wavegene_backend import build_channel_path, DAQWorker, DAQ_AVAILABLE
+
+
+def _app_dir():
+    """Return app directory (next to exe when frozen, else script dir)."""
+    if getattr(sys, "frozen", False):
+        return Path(sys.executable).parent
+    return Path(__file__).parent
+
+
+class WaveGeneWindow(QMainWindow):
+    """Main application window for pulse generation control."""
+
+    def __init__(self):
+        super().__init__()
+        self.worker = None
+        self.worker_thread = None
+        self.state_timer = None
+        self.state_start_time = None
+        self.worker_params = None
+        self.init_ui()
+        self.load_params_from_json(silent=True)
+
+    def init_ui(self):
+        """Build the main window layout and widgets."""
+        self.setWindowTitle("WaveGene - NI-DAQmx Pulse Generator")
+        self.setMinimumWidth(400)
+
+        central = QWidget()
+        self.setCentralWidget(central)
+        layout = QVBoxLayout(central)
+
+        # --- Load Parameters (top left) ---
+        top_bar = QHBoxLayout()
+        self.load_btn = QPushButton("Load Parameters")
+        self.load_btn.setMinimumHeight(32)
+        self.load_btn.clicked.connect(self.load_params_from_json)
+        top_bar.addWidget(self.load_btn)
+        top_bar.addStretch()
+        layout.addLayout(top_bar)
+
+        # --- Parameters group ---
+        params_group = QGroupBox("Parameters")
+        params_layout = QFormLayout(params_group)
+
+        # Device and channel (e.g. Dev2, ao0)
+        self.device_edit = QLineEdit()
+        self.device_edit.setPlaceholderText("Dev1, Dev2, ...")
+        self.device_edit.setText("Dev2")
+        params_layout.addRow("Device NI-DAQmx:", self.device_edit)
+
+        self.channel_edit = QLineEdit()
+        self.channel_edit.setPlaceholderText("ao0, ao1, ...")
+        self.channel_edit.setText("ao0")
+        params_layout.addRow("Channel:", self.channel_edit)
+
+        # Sampling rate in Hz (output update frequency)
+        self.sampling_rate_spin = QDoubleSpinBox()
+        self.sampling_rate_spin.setRange(100, 100000)
+        self.sampling_rate_spin.setValue(1000)
+        self.sampling_rate_spin.setSuffix(" Hz")
+        self.sampling_rate_spin.setDecimals(0)
+        params_layout.addRow("Sampling rate:", self.sampling_rate_spin)
+
+        # Pulse duration at 2V (seconds)
+        self.pulse_duration_spin = QDoubleSpinBox()
+        self.pulse_duration_spin.setRange(0.001, 60)
+        self.pulse_duration_spin.setValue(0.2)
+        self.pulse_duration_spin.setSuffix(" s")
+        self.pulse_duration_spin.setDecimals(3)
+        params_layout.addRow("Pulse duration (2V):", self.pulse_duration_spin)
+
+        # Time at 0V between pulses (seconds)
+        self.inter_pulse_spin = QDoubleSpinBox()
+        self.inter_pulse_spin.setRange(0, 3600)
+        self.inter_pulse_spin.setValue(20)
+        self.inter_pulse_spin.setSuffix(" s")
+        self.inter_pulse_spin.setDecimals(1)
+        params_layout.addRow("Inter-pulse interval:", self.inter_pulse_spin)
+
+        # Initial 0V period before first pulse (seconds)
+        self.buffer_spin = QDoubleSpinBox()
+        self.buffer_spin.setRange(0, 300)
+        self.buffer_spin.setValue(5)
+        self.buffer_spin.setSuffix(" s")
+        self.buffer_spin.setDecimals(1)
+        self.buffer_spin.setToolTip("Time at 0V before the first pulse")
+        params_layout.addRow("Duration before first impulse:", self.buffer_spin)
+
+        # Infinite: repeat forever; else use nb_pulses
+        self.infinite_check = QCheckBox("Repeat indefinitely")
+        self.infinite_check.setChecked(True)
+        self.infinite_check.toggled.connect(self.on_infinite_toggled)
+        params_layout.addRow("", self.infinite_check)
+
+        self.nb_pulses_spin = QSpinBox()
+        self.nb_pulses_spin.setRange(1, 10000)
+        self.nb_pulses_spin.setValue(5)
+        self.nb_pulses_spin.setEnabled(False)
+        params_layout.addRow("Number of pulses:", self.nb_pulses_spin)
+
+        layout.addWidget(params_group)
+
+        # --- Action buttons ---
+        btn_layout = QHBoxLayout()
+        self.start_btn = QPushButton("Start")
+        self.start_btn.setMinimumHeight(40)
+        self.start_btn.setFont(QFont("", 11, QFont.Bold))
+        self.start_btn.clicked.connect(self.start_generation)
+        self.start_btn.setStyleSheet("background-color: #4CAF50; color: white;")
+
+        self.stop_btn = QPushButton("Stop")
+        self.stop_btn.setMinimumHeight(40)
+        self.stop_btn.setFont(QFont("", 11, QFont.Bold))
+        self.stop_btn.clicked.connect(self.stop_generation)
+        self.stop_btn.setEnabled(False)
+        self.stop_btn.setStyleSheet("background-color: #f44336; color: white;")
+
+        btn_layout.addWidget(self.start_btn)
+        btn_layout.addWidget(self.stop_btn)
+        layout.addLayout(btn_layout)
+
+        # --- State indicator: shows current phase (Duration before first impulse, Pulse, 0V) + countdown ---
+        self.state_frame = QFrame()
+        self.state_frame.setFrameStyle(QFrame.StyledPanel)
+        self.state_frame.setMinimumHeight(60)
+        self.state_frame.setStyleSheet("""
+            QFrame { background-color: #e0e0e0; border-radius: 8px; }
+        """)
+        state_layout = QVBoxLayout(self.state_frame)
+        self.state_label = QLabel("—")
+        self.state_label.setAlignment(Qt.AlignCenter)
+        self.state_label.setFont(QFont("", 18, QFont.Bold))
+        self.state_label.setStyleSheet("color: #666;")
+        state_layout.addWidget(self.state_label)
+        self.time_label = QLabel("—")
+        self.time_label.setAlignment(Qt.AlignCenter)
+        self.time_label.setFont(QFont("", 14))
+        self.time_label.setStyleSheet("color: #666;")
+        state_layout.addWidget(self.time_label)
+        layout.addWidget(self.state_frame)
+
+        # --- Total elapsed time (subtle display) ---
+        self.time_total_frame = QFrame()
+        self.time_total_frame.setFrameStyle(QFrame.NoFrame)
+        self.time_total_frame.setMaximumHeight(32)
+        self.time_total_frame.setStyleSheet("QFrame { background-color: transparent; }")
+        time_total_layout = QHBoxLayout(self.time_total_frame)
+        time_total_layout.setContentsMargins(4, 2, 4, 2)
+        time_total_label_txt = QLabel("Total time:")
+        time_total_label_txt.setStyleSheet("color: #999; font-size: 11px;")
+        time_total_layout.addWidget(time_total_label_txt)
+        self.time_total_label = QLabel("0:00")
+        self.time_total_label.setFont(QFont("", 11))
+        self.time_total_label.setStyleSheet("color: #999;")
+        time_total_layout.addWidget(self.time_total_label)
+        time_total_layout.addStretch()
+        layout.addWidget(self.time_total_frame)
+
+        # Disable start if PyDAQmx not installed
+        if not DAQ_AVAILABLE:
+            self.start_btn.setEnabled(False)
+            self.start_btn.setToolTip("PyDAQmx is not installed")
+
+    def on_infinite_toggled(self, checked):
+        """Enable nb_pulses only when not in infinite mode."""
+        self.nb_pulses_spin.setEnabled(not checked)
+
+    def set_params_enabled(self, enabled):
+        """Enable or disable all parameter fields."""
+        self.device_edit.setEnabled(enabled)
+        self.channel_edit.setEnabled(enabled)
+        self.sampling_rate_spin.setEnabled(enabled)
+        self.pulse_duration_spin.setEnabled(enabled)
+        self.inter_pulse_spin.setEnabled(enabled)
+        self.buffer_spin.setEnabled(enabled)
+        self.infinite_check.setEnabled(enabled)
+        self.nb_pulses_spin.setEnabled(enabled and not self.infinite_check.isChecked())
+        self.load_btn.setEnabled(enabled)
+
+    def start_generation(self):
+        """Start DAQ generation in a worker thread."""
+        if self.worker_thread and self.worker_thread.isRunning():
+            return
+
+        # Gather parameters from UI
+        device = build_channel_path(self.device_edit.text(), self.channel_edit.text())
+        sampling_rate = self.sampling_rate_spin.value()
+        pulse_duration = self.pulse_duration_spin.value()
+        inter_pulse = self.inter_pulse_spin.value()
+        buffer_duration = self.buffer_spin.value()
+        infinite = self.infinite_check.isChecked()
+        nb_pulses = self.nb_pulses_spin.value()
+
+        self.start_btn.setEnabled(False)
+        self.stop_btn.setEnabled(True)
+        self.set_params_enabled(False)
+
+        # Create worker and thread
+        self.worker = DAQWorker(device, sampling_rate, pulse_duration, inter_pulse,
+                                infinite, nb_pulses, buffer_duration)
+        self.worker_thread = QThread()
+        self.worker.moveToThread(self.worker_thread)
+
+        self.worker_thread.started.connect(self.worker.run)
+        self.worker.started.connect(self.on_generation_started)
+        self.worker.finished.connect(self.on_generation_finished)
+        self.worker.error.connect(self.on_generation_error)
+
+        # Store params for state indicator and JSON save
+        self.worker_params = {
+            "device": self.device_edit.text().strip(),
+            "channel": self.channel_edit.text().strip(),
+            "sampling_rate": sampling_rate,
+            "buffer": buffer_duration,
+            "pulse": pulse_duration,
+            "interval": inter_pulse,
+            "infinite": infinite,
+            "nb_pulses": nb_pulses,
+        }
+        self.experiment_start_time = datetime.now()
+        self.worker_thread.start()
+
+    def stop_generation(self):
+        """Request worker to stop generation."""
+        if self.worker:
+            self.worker.stop()
+
+    def on_generation_started(self):
+        """Start timer to display real-time state (called when DAQ output begins)."""
+        self.state_start_time = time.time()
+        self.state_timer = QTimer(self)
+        self.state_timer.timeout.connect(self.update_state_indicator)
+        self.state_timer.start(100)
+
+    def format_elapsed(self, seconds):
+        """Format elapsed time as m:ss.cc."""
+        m = int(seconds // 60)
+        s = seconds % 60
+        return f"{m}:{s:05.2f}"
+
+    def format_countdown(self, seconds):
+        """Format countdown in seconds."""
+        if seconds <= 0:
+            return "0.00 s"
+        return f"{seconds:.2f} s remaining"
+
+    def update_state_indicator(self):
+        """Update indicator based on current signal phase (called every 100ms)."""
+        if self.state_start_time is None or self.worker_params is None:
+            return
+        elapsed = time.time() - self.state_start_time
+        self.time_total_label.setText(self.format_elapsed(elapsed))
+        p = self.worker_params
+        buf, pulse, interval = p["buffer"], p["pulse"], p["interval"]
+        cycle_duration = pulse + interval
+
+        # Phase 1: Duration before first impulse (0V)
+        if elapsed < buf:
+            text, color, bg = "(0V)", "#666", "#e0e0e0"
+            remaining = buf - elapsed
+            countdown = self.format_countdown(remaining)
+        else:
+            # Phase 2: Pulse or interval
+            cycle_time = elapsed - buf
+            if p["infinite"]:
+                pos_in_cycle = cycle_time % cycle_duration
+            else:
+                total_cycles = p["nb_pulses"] * cycle_duration
+                if cycle_time >= total_cycles:
+                    # All pulses done
+                    text, color, bg = "Done", "#666", "#e0e0e0"
+                    self.state_label.setText(text)
+                    self.state_label.setStyleSheet(f"color: {color};")
+                    self.state_frame.setStyleSheet(f"QFrame {{ background-color: {bg}; border-radius: 8px; }}")
+                    self.time_label.setText("—")
+                    return
+                pos_in_cycle = cycle_time % cycle_duration
+
+            if pos_in_cycle < pulse:
+                # In pulse phase
+                text, color, bg = "Pulse (2V)", "#1b5e20", "#c8e6c9"
+                remaining = pulse - pos_in_cycle
+            else:
+                # In interval phase
+                text, color, bg = "0V (interval)", "#37474f", "#eceff1"
+                remaining = cycle_duration - pos_in_cycle
+            countdown = self.format_countdown(remaining)
+
+        self.state_label.setText(text)
+        self.state_label.setStyleSheet(f"color: {color};")
+        self.state_frame.setStyleSheet(f"QFrame {{ background-color: {bg}; border-radius: 8px; }}")
+        self.time_label.setText(countdown)
+
+    def save_params_to_json(self, duration_seconds):
+        """Save parameters and experiment info to a JSON file (on generation stop)."""
+        if self.worker_params is None:
+            return
+        p = self.worker_params
+        exp_time = getattr(self, "experiment_start_time", datetime.now())
+        data = {
+            "device": p.get("device", "Dev2"),
+            "channel": p.get("channel", "ao0"),
+            "sampling_rate": p.get("sampling_rate", 1000),
+            "pulse_duration": p.get("pulse", 0.2),
+            "inter_pulse_interval": p.get("interval", 20),
+            "buffer_duration": p.get("buffer", 5),
+            "infinite": p.get("infinite", True),
+            "nb_pulses": p.get("nb_pulses", 5),
+            "duree_secondes": round(duration_seconds, 2),
+            "heure_debut": exp_time.strftime("%Y-%m-%d %H:%M:%S"),
+            "heure_fin": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        }
+        save_dir = _app_dir() / "experiences"
+        save_dir.mkdir(exist_ok=True)
+        filename = exp_time.strftime("wavegene_%Y-%m-%d_%H-%M-%S.json")
+        filepath = save_dir / filename
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+    def load_params_from_json(self, silent=False):
+        """Load parameters from a JSON file.
+        If silent=True (e.g. at startup), loads the most recent file without dialog.
+        If silent=False (button click), opens a file dialog to choose the file."""
+        save_dir = _app_dir() / "experiences"
+        if not save_dir.exists():
+            if not silent:
+                QMessageBox.warning(self, "Load", "No experiments folder found.")
+            return
+        json_files = list(save_dir.glob("wavegene_*.json"))
+        if not json_files:
+            if not silent:
+                QMessageBox.warning(self, "Load", "No experiment file found.")
+            return
+
+        if silent:
+            path = max(json_files, key=lambda p: p.stat().st_mtime)
+        else:
+            path_str, _ = QFileDialog.getOpenFileName(
+                self, "Load Parameters",
+                str(save_dir),
+                "JSON files (*.json);;All files (*)"
+            )
+            if not path_str:
+                return
+            path = Path(path_str)
+
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            self.device_edit.setText(data.get("device", "Dev2"))
+            self.channel_edit.setText(data.get("channel", "ao0"))
+            self.sampling_rate_spin.setValue(data.get("sampling_rate", 1000))
+            self.pulse_duration_spin.setValue(data.get("pulse_duration", 0.2))
+            self.inter_pulse_spin.setValue(data.get("inter_pulse_interval", 20))
+            self.buffer_spin.setValue(data.get("buffer_duration", 5))
+            self.infinite_check.setChecked(data.get("infinite", True))
+            self.nb_pulses_spin.setValue(data.get("nb_pulses", 5))
+            if not silent:
+                QMessageBox.information(self, "Load", f"Parameters loaded from {path.name}")
+        except Exception as e:
+            if not silent:
+                QMessageBox.critical(self, "Error", f"Failed to load file:\n{e}")
+
+    def on_generation_finished(self):
+        """Clean up when generation stops (user stop or completion)."""
+        if self.state_timer:
+            self.state_timer.stop()
+            self.state_timer = None
+        duration = 0
+        if self.state_start_time is not None:
+            duration = time.time() - self.state_start_time
+            self.save_params_to_json(duration)
+        self.state_start_time = None
+        self.state_label.setText("—")
+        self.time_label.setText("—")
+        self.time_total_label.setText("0:00")
+        self.state_label.setStyleSheet("color: #666;")
+        self.time_label.setStyleSheet("color: #666;")
+        self.state_frame.setStyleSheet("QFrame { background-color: #e0e0e0; border-radius: 8px; }")
+        if self.worker_thread:
+            self.worker_thread.quit()
+            self.worker_thread.wait(2000)
+        self.start_btn.setEnabled(True)
+        self.stop_btn.setEnabled(False)
+        self.set_params_enabled(True)
+
+    def on_generation_error(self, msg):
+        """Handle DAQ or worker error: cleanup and show message."""
+        self.on_generation_finished()
+        QMessageBox.critical(self, "Error", msg)
+
+
+def main():
+    """Application entry point."""
+    app = QApplication([])
+    app.setStyle("Fusion")
+    window = WaveGeneWindow()
+    window.show()
+    return app.exec_()
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())

electric_stimulation-0.1.2/LICENSE

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

electric_stimulation-0.1.2/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: electric-stimulation
+Version: 0.1.2
+Summary: NI-DAQmx pulse generator for electrical stimulation with PyQt5 GUI
+Project-URL: Homepage, https://github.com/WNIlabs/Electric-stimulation
+Project-URL: Repository, https://github.com/WNIlabs/Electric-stimulation
+Author: Wireless Neural Interface Team
+Author-email: Pierre He <pierre.he@inserm.fr>
+License: MIT
+License-File: LICENSE
+Keywords: DAQ,NI-DAQmx,PyQt5,electrical-stimulation,pulse-generator
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.20
+Requires-Dist: pydaqmx>=1.4
+Requires-Dist: pyqt5>=5.15
+Description-Content-Type: text/markdown
+
+# Electric stimulation
+
+Manual GUI launcher <br>
+Backend <br>
+Frontend <br>
+Build for standalone EXE File <br>
+
+To build the standelone software, download all files, install libraries and run build_exe. 

electric_stimulation-0.1.2/README.md

@@ -0,0 +1,8 @@
+# Electric stimulation
+
+Manual GUI launcher <br>
+Backend <br>
+Frontend <br>
+Build for standalone EXE File <br>
+
+To build the standelone software, download all files, install libraries and run build_exe. 

electric_stimulation-0.1.2/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "electric-stimulation"
+version = "0.1.2"
+description = "NI-DAQmx pulse generator for electrical stimulation with PyQt5 GUI"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [
+    {name = "Wireless Neural Interface Team"},
+    {name = "Pierre He", email = "pierre.he@inserm.fr"},
+]
+keywords = ["DAQ", "NI-DAQmx", "electrical-stimulation", "pulse-generator", "PyQt5"]
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = [
+    "numpy>=1.20",
+    "PyDAQmx>=1.4",
+    "PyQt5>=5.15",
+]
+
+[project.scripts]
+wavegene = "Electric_stimulation.wavegene_gui:main"
+wavegene-build = "Electric_stimulation.build_exe:main"
+
+[project.urls]
+Homepage = "https://github.com/WNIlabs/Electric-stimulation"
+Repository = "https://github.com/WNIlabs/Electric-stimulation"
+
+[tool.hatch.build.targets.wheel]
+packages = ["Electric_stimulation"]

electric_stimulation-0.1.2/requirements.txt

@@ -0,0 +1,3 @@
+numpy>=1.20
+PyDAQmx>=1.4
+PyQt5>=5.15