Upload openbci_impedance.py

openbci_impedance.py

@@ -0,0 +1,694 @@
+#!/usr/bin/env python3
+"""
+OpenBCI Cyton + Daisy — Moniteur d'impedance live des electrodes
+================================================================
+Connexion via dongle USB, protocole serie officiel OpenBCI.
+
+Dependances :
+    pip install pyserial scipy matplotlib numpy
+
+Usage :
+    python openbci_impedance.py                    # auto-detection du port
+    python openbci_impedance.py --port COM3
+    python openbci_impedance.py --list-ports
+
+Sources protocole :
+  https://docs.openbci.com/Cyton/CytonSDK/
+  https://docs.openbci.com/Cyton/CytonDataFormat/
+  https://openbci.com/forum/index.php?p=/discussion/2436/
+"""
+
+import sys
+import time
+import threading
+import argparse
+from collections import deque
+
+import numpy as np
+import serial
+import serial.tools.list_ports
+from scipy.signal import butter, sosfiltfilt, iirnotch
+
+import matplotlib
+matplotlib.use("TkAgg")
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+from matplotlib.patches import Circle, Arc
+from matplotlib.animation import FuncAnimation
+
+# ╔══════════════════════════════════════════════════╗
+# ║              CONSTANTES OFFICIELLES              ║
+# ╚══════════════════════════════════════════════════╝
+
+BAUD_RATE    = 115200
+PACKET_SIZE  = 33
+START_BYTE   = 0xA0
+
+ADS1299_VREF = 4.5
+ADS1299_GAIN = 24.0
+SCALE_UV     = (ADS1299_VREF / ADS1299_GAIN) / (2**23 - 1) * 1_000_000
+
+# Pleine echelle ADS1299 en µV (seuil railing)
+ADC_MAX_UV   = (2**23 - 1) * SCALE_UV   # ≈ 187 500 µV
+
+LEAD_OFF_FREQ    = 31.5      # Hz
+LEAD_OFF_AMPS    = 6e-9      # A
+SERIES_RESISTOR  = 2200      # Ω
+
+N_CHANNELS   = 16
+SAMPLE_RATE  = 125           # Hz effectif par canal (pairing Cyton+Daisy)
+DAISY_CHARS  = ['Q','W','E','R','T','Y','U','I']
+
+# ╔══════════════════════════════════════════════════╗
+# ║           MAPPING ELECTRODES                     ║
+# ║  CORRECTION : Y positif = POSTERIOR (arriere)    ║
+# ║  On inverse Y a l'affichage pour placer les      ║
+# ║  electrodes dans la region posterieure du crane. ║
+# ╚══════════════════════════════════════════════════╝
+# Coordonnees brutes fournies (X, Y)
+ELECTRODE_POSITIONS_RAW = [
+    ( 0.15,  0.35),   # CH1
+    (-0.15,  0.35),   # CH2
+    ( 0.25,  0.38),   # CH3
+    (-0.25,  0.38),   # CH4
+    (-0.35,  0.40),   # CH5
+    ( 0.35,  0.40),   # CH6
+    ( 0.15,  0.45),   # CH7
+    ( 0.00,  0.48),   # CH8
+    (-0.20,  0.25),   # CH9
+    (-0.10,  0.25),   # CH10
+    ( 0.00,  0.25),   # CH11
+    ( 0.10,  0.25),   # CH12
+    ( 0.20,  0.25),   # CH13
+    ( 0.00,  0.35),   # CH14
+    ( 0.00,  0.00),   # CH15 (inactive)
+    ( 0.00,  0.00),   # CH16 (inactive)
+]
+
+HEAD_CENTER_Y = 0.12   # centre geometrique de la tete dans l'axe plot
+
+def _posterior_y(y_raw):
+    """
+    Reflechit Y autour du centre de la tete pour placer les electrodes
+    dans la region posterieure (bas du head plot = arriere du crane).
+    y_raw > 0 → affiche sous l'equateur.
+    """
+    return 2.0 * HEAD_CENTER_Y - y_raw   # = 0.24 - y_raw
+
+# Positions d'affichage finales
+ELECTRODE_POSITIONS = [
+    (x, _posterior_y(y)) if not (x == 0.0 and y == 0.0) else (0.0, 0.0)
+    for x, y in ELECTRODE_POSITIONS_RAW
+]
+
+# Seuils d'impedance et couleurs
+IMP_THRESHOLDS = [5_000, 10_000, 25_000]
+IMP_COLORS     = ['#00CC44', '#CCCC00', '#FF8800', '#CC2222']
+IMP_LABELS_LEG = ['<5 kΩ  Good', '5-10 kΩ  OK', '10-25 kΩ  Fair', '>25 kΩ  Poor']
+IMP_NO_DATA    = '#555577'
+IMP_RAILED     = '#220033'   # violet fonce = saturation / circuit ouvert
+
+
+# ╔══════════════════════════════════════════════════╗
+# ║           DETECTION DU PORT SERIE                ║
+# ╚══════════════════════════════════════════════════╝
+
+def find_openbci_port():
+    keywords = ['openbci', 'ftdi', 'usbserial', 'ttyusb', 'ft231', 'ft232']
+    ports = serial.tools.list_ports.comports()
+    for p in ports:
+        combined = ((p.description or '') + (p.hwid or '')).lower()
+        if any(k in combined for k in keywords):
+            return p.device
+    for p in ports:
+        if 'usb' in (p.hwid or '').lower():
+            return p.device
+    return None
+
+
+# ╔═══════════════════════════════════════════════��══╗
+# ║          PARSING DES PAQUETS OPENBCI             ║
+# ╚══════════════════════════════════════════════════╝
+
+def parse_24bit_signed(b0, b1, b2):
+    val = (b0 << 16) | (b1 << 8) | b2
+    if val & 0x800000:
+        val -= 0x1000000
+    return val
+
+
+def parse_packet(data: bytes):
+    if len(data) < PACKET_SIZE:
+        return None
+    if data[0] != START_BYTE:
+        return None
+    if (data[32] & 0xF0) != 0xC0:
+        return None
+    sample_num = data[1]
+    channels_uv = []
+    for ch in range(8):
+        offset = 2 + ch * 3
+        raw = parse_24bit_signed(data[offset], data[offset+1], data[offset+2])
+        channels_uv.append(raw * SCALE_UV)
+    return sample_num, channels_uv
+
+
+# ╔══════════════════════════════════════════════════╗
+# ║       FILTRES NUMERIQUES                         ║
+# ╚══════════════════════════════════════════════════╝
+
+def _make_notch_sos(freq_hz: float, q: float = 30.0, fs: float = SAMPLE_RATE):
+    """Filtre notch IIR (bande rejetee autour de freq_hz)."""
+    w0 = freq_hz / (fs / 2.0)
+    if w0 <= 0 or w0 >= 1.0:
+        return None
+    b, a = iirnotch(w0, q)
+    # Convertir en SOS pour stabilite numerique
+    from scipy.signal import tf2sos
+    return tf2sos(b, a)
+
+
+def _make_bandpass_sos(low_hz: float, high_hz: float, order: int = 4,
+                        fs: float = SAMPLE_RATE):
+    """Filtre passe-bande Butterworth en SOS."""
+    nyq  = fs / 2.0
+    low  = low_hz  / nyq
+    high = high_hz / nyq
+    if low <= 0 or high >= 1.0:
+        return None
+    return butter(order, [low, high], btype='band', output='sos')
+
+
+# Pre-calculer les filtres une seule fois
+# Californie = reseau 60 Hz uniquement (pas de 50 Hz)
+_NOTCH_60_SOS  = _make_notch_sos(60.0)
+_BANDPASS_SOS  = _make_bandpass_sos(28.0, 35.0)
+
+
+# ╔══════════════════════════════════════════════════╗
+# ║          CALCUL D'IMPEDANCE (methode GUI)        ║
+# ╚══════════════════════════════════════════════════╝
+
+# Seuil de railing : si >RAIL_FRAC des echantillons depasse RAIL_THRESH_UV
+# on considere le canal sature (circuit ouvert)
+RAIL_THRESH_UV = 0.90 * ADC_MAX_UV   # 90 % de la pleine echelle
+RAIL_FRAC      = 0.05                # 5 % d'echantillons suffit
+
+def compute_impedance(buffer_uv: list):
+    """
+    Calcule l'impedance en Ohms depuis un buffer de donnees µV.
+
+    Retourne :
+      float  → impedance en Ω
+      'open' → canal sature (railing) = electrode non connectee
+      None   → pas assez de donnees
+
+    Formule GUI OpenBCI :
+      impedance = (sqrt(2) * std_uV * 1e-6) / LEAD_OFF_AMPS - SERIES_RESISTOR
+
+    Pipeline de filtrage :
+      1. Notch 50 Hz  (secteur europeen)
+      2. Notch 60 Hz  (securite)
+      3. Passe-bande 28-35 Hz (isole le signal lead-off a 31.5 Hz)
+    """
+    if len(buffer_uv) < SAMPLE_RATE:
+        return None
+
+    arr = np.array(buffer_uv[-SAMPLE_RATE * 2:], dtype=float)
+
+    # ── Detection du railing ────────────────────────────────────────────
+    # Un canal sature (entree flottante clippee) presente des echantillons
+    # proches de la pleine echelle +/- ADC. Dans ce cas l'impedance calculee
+    # serait faussement basse (std ≈ 0 apres saturation DC).
+    railed_frac = np.mean(np.abs(arr) > RAIL_THRESH_UV)
+    if railed_frac >= RAIL_FRAC:
+        return 'open'
+
+    # ── Filtrage ────────────────────────────────────────────────────────
+    sig = arr.copy()
+    if _NOTCH_60_SOS is not None:
+        sig = sosfiltfilt(_NOTCH_60_SOS, sig)
+    if _BANDPASS_SOS is None:
+        return None
+    filtered = sosfiltfilt(_BANDPASS_SOS, sig)
+
+    std_uv = np.std(filtered)
+    impedance = (np.sqrt(2.0) * std_uv * 1e-6) / LEAD_OFF_AMPS - SERIES_RESISTOR
+    return max(0.0, impedance)
+
+
+# ╔══════════════════════════════════════════════════╗
+# ║          CONTROLEUR DU BOARD CYTON+DAISY         ║
+# ╚══════════════════════════════════════════════════╝
+
+class CytonDaisyBoard:
+    INIT_TIMEOUT = 15.0
+    CMD_DELAY    = 0.05
+
+    def __init__(self, port: str):
+        self.port    = port
+        self.ser     = None
+        self.running = False
+        self._lock   = threading.Lock()
+
+        self._buf_size = SAMPLE_RATE * 4
+        self._buffers  = [deque(maxlen=self._buf_size) for _ in range(N_CHANNELS)]
+        self._last_cyton_data = None
+        self._rx_thread = None
+
+    def connect(self):
+        print(f"[Board] Ouverture port {self.port} @ {BAUD_RATE} baud…")
+        self.ser = serial.Serial(
+            self.port, BAUD_RATE,
+            timeout=5,
+            rtscts=False,
+            dsrdtr=False,
+        )
+        self.ser.reset_input_buffer()
+        self.ser.reset_output_buffer()
+        time.sleep(0.5)
+
+        print("[Board] Envoi 's' pour stopper un stream residuel…")
+        self._send(b's')
+        time.sleep(1.2)
+        self.ser.reset_input_buffer()
+
+        print("[Board] Envoi 'v' (soft reset)…")
+        self._send(b'v')
+        time.sleep(0.5)
+
+        print("[Board] Attente '$$$'…")
+        self._wait_for_dollar_signs()
+        print("[Board] Board pret.")
+
+        self._send(b'C')   # mode 16 canaux
+        time.sleep(0.5)
+        self._flush_rx()
+
+        print("[Board] Activation impedance 16 canaux…")
+        self._enable_all_impedances()
+        time.sleep(1.0)
+
+        self._send(b'b')   # start stream
+        print("[Board] Stream demarre.")
+
+        self.running = True
+        self._rx_thread = threading.Thread(
+            target=self._read_loop, name="rx_thread", daemon=True
+        )
+        self._rx_thread.start()
+
+    def disconnect(self):
+        print("[Board] Deconnexion…")
+        self.running = False
+        if self.ser and self.ser.is_open:
+            try:
+                self._send(b's')
+                time.sleep(0.3)
+                self._disable_all_impedances()
+                time.sleep(0.3)
+            finally:
+                self.ser.close()
+        print("[Board] Port ferme.")
+
+    def _send(self, cmd: bytes):
+        if self.ser and self.ser.is_open:
+            self.ser.write(cmd)
+            self.ser.flush()
+
+    def _wait_for_dollar_signs(self):
+        buf = b''
+        start = time.time()
+        retry_sent = False
+        while time.time() - start < self.INIT_TIMEOUT:
+            if self.ser.in_waiting:
+                chunk = self.ser.read(self.ser.in_waiting)
+                buf += chunk
+                try:
+                    readable = chunk.decode('utf-8', errors='replace')
+                    if readable.strip():
+                        print(f"[Board] Recu : {readable.strip()!r}")
+                except Exception:
+                    pass
+                if b'$$$' in buf:
+                    decoded = buf.decode('utf-8', errors='replace').strip()
+                    print(f"[Board] Message init :\n{decoded}")
+                    return
+            elapsed = time.time() - start
+            if elapsed > 4.0 and not retry_sent:
+                print("[Board] Pas de reponse apres 4s, re-envoi 'v'…")
+                self.ser.reset_input_buffer()
+                self._send(b'v')
+                retry_sent = True
+            time.sleep(0.05)
+        raise TimeoutError(
+            "Le board n'a pas envoye '$$$'.\n"
+            "  1. Board sous tension (LED bleue allumee)\n"
+            "  2. Dongle USB branche AVANT le board\n"
+            "  3. Interrupteur dongle sur GPIO6 (pas RESET)\n"
+            "  4. Aucune autre application sur ce port"
+        )
+
+    def _flush_rx(self, duration=0.5):
+        deadline = time.time() + duration
+        while time.time() < deadline:
+            if self.ser.in_waiting:
+                data = self.ser.read(self.ser.in_waiting)
+                try:
+                    d = data.decode('utf-8', errors='replace')
+                    if d.strip():
+                        print(f"[Board] Reponse : {d.strip()!r}")
+                except Exception:
+                    pass
+            time.sleep(0.05)
+
+    def _impedance_cmd(self, ch_char: str, pchan: int, nchan: int):
+        cmd = f'z{ch_char}{pchan}{nchan}Z'.encode('ascii')
+        self._send(cmd)
+        time.sleep(self.CMD_DELAY)
+
+    def _enable_all_impedances(self):
+        for ch in range(1, 9):
+            self._impedance_cmd(str(ch), pchan=1, nchan=0)
+        for char in DAISY_CHARS:
+            self._impedance_cmd(char, pchan=1, nchan=0)
+        print("[Board] Impedance activee sur 16 canaux.")
+
+    def _disable_all_impedances(self):
+        for ch in range(1, 9):
+            self._impedance_cmd(str(ch), pchan=0, nchan=0)
+        for char in DAISY_CHARS:
+            self._impedance_cmd(char, pchan=0, nchan=0)
+
+    def _read_loop(self):
+        sync_buf = bytearray()
+        while self.running:
+            try:
+                if not self.ser.is_open:
+                    break
+                n = self.ser.in_waiting
+                if n == 0:
+                    time.sleep(0.001)
+                    continue
+                chunk = self.ser.read(n)
+                sync_buf.extend(chunk)
+                while len(sync_buf) >= PACKET_SIZE:
+                    idx = -1
+                    for i in range(len(sync_buf) - PACKET_SIZE + 1):
+                        if (sync_buf[i] == START_BYTE and
+                                (sync_buf[i + PACKET_SIZE - 1] & 0xF0) == 0xC0):
+                            idx = i
+                            break
+                    if idx == -1:
+                        del sync_buf[:max(0, len(sync_buf) - PACKET_SIZE + 1)]
+                        break
+                    if idx > 0:
+                        del sync_buf[:idx]
+                        continue
+                    packet = bytes(sync_buf[:PACKET_SIZE])
+                    del sync_buf[:PACKET_SIZE]
+                    result = parse_packet(packet)
+                    if result is not None:
+                        self._handle_sample(*result)
+            except serial.SerialException as e:
+                print(f"[Board] Erreur serie : {e}")
+                self.running = False
+                break
+            except Exception as e:
+                print(f"[Board] Erreur lecture : {e}")
+                time.sleep(0.005)
+
+    def _handle_sample(self, sample_num: int, ch_data_uv: list):
+        is_cyton = (sample_num % 2) == 1
+        with self._lock:
+            if is_cyton:
+                self._last_cyton_data = ch_data_uv[:]
+            else:
+                if self._last_cyton_data is not None:
+                    for i in range(8):
+                        self._buffers[i].append(self._last_cyton_data[i])
+                    for i in range(8):
+                        self._buffers[8 + i].append(ch_data_uv[i])
+                    self._last_cyton_data = None
+
+    def get_impedances(self) -> list:
+        with self._lock:
+            snapshot = [list(b) for b in self._buffers]
+        return [compute_impedance(buf) for buf in snapshot]
+
+    def n_samples_collected(self) -> int:
+        with self._lock:
+            return max((len(b) for b in self._buffers), default=0)
+
+
+# ╔══════════════════════════════════════════════════╗
+# ║         AFFICHAGE MATPLOTLIB (HEAD PLOT)         ║
+# ╚══════════════════════════════════════════════════╝
+
+def _impedance_color(val):
+    if val is None:
+        return IMP_NO_DATA
+    if val == 'open':
+        return IMP_RAILED
+    if val < IMP_THRESHOLDS[0]:
+        return IMP_COLORS[0]
+    elif val < IMP_THRESHOLDS[1]:
+        return IMP_COLORS[1]
+    elif val < IMP_THRESHOLDS[2]:
+        return IMP_COLORS[2]
+    else:
+        return IMP_COLORS[3]
+
+
+def _impedance_text(val):
+    if val is None:
+        return '---'
+    if val == 'open':
+        return 'OPEN'
+    if val >= 1_000_000:
+        return f'{val/1_000_000:.1f} MΩ'
+    elif val >= 1_000:
+        return f'{val/1_000:.1f} kΩ'
+    else:
+        return f'{val:.0f} Ω'
+
+
+class ImpedanceDisplay:
+    ELECTRODE_RADIUS = 0.042
+    HEAD_RADIUS      = 0.50
+    UPDATE_MS        = 500
+
+    def __init__(self, board: CytonDaisyBoard):
+        self.board = board
+        self._build_figure()
+
+    def _build_figure(self):
+        self.fig = plt.figure(figsize=(10, 10), facecolor='#12121f')
+        self.ax  = self.fig.add_subplot(111)
+        self.ax.set_facecolor('#1a1a2e')
+        self.ax.set_xlim(-0.78, 0.78)
+        self.ax.set_ylim(-0.60, 0.82)
+        self.ax.set_aspect('equal')
+        self.ax.axis('off')
+
+        self.fig.suptitle(
+            'OpenBCI Cyton + Daisy  —  Electrode Impedance (live)',
+            color='white', fontsize=13, fontweight='bold', y=0.97
+        )
+
+        self._draw_head()
+        self._draw_legend()
+        self._create_electrode_artists()
+
+        self.status_lbl = self.ax.text(
+            0, -0.55,
+            'Collecting data... (minimum 1 s required per channel)',
+            ha='center', va='center', fontsize=8.5, color='#aaaacc'
+        )
+
+        self.anim = FuncAnimation(
+            self.fig, self._update_frame,
+            interval=self.UPDATE_MS, blit=False, cache_frame_data=False
+        )
+
+    def _draw_head(self):
+        """
+        Tete avec nez vers le HAUT (anterieur) et region posterieure en bas.
+        Les electrodes vont apparaitre dans la moitie inferieure (posterieure).
+        """
+        cx, cy = 0, HEAD_CENTER_Y
+        r = self.HEAD_RADIUS
+
+        head_circle = Circle(
+            (cx, cy), r, fill=False,
+            linewidth=2.5, edgecolor='#9999bb', zorder=1
+        )
+        self.ax.add_patch(head_circle)
+
+        # Nez (anterieur = haut)
+        nose_x = [-0.04, 0.0,  0.04]
+        nose_y = [cy + r - 0.01, cy + r + 0.06, cy + r - 0.01]
+        self.ax.plot(nose_x, nose_y, color='#9999bb', linewidth=2.5, zorder=1)
+
+        # Oreilles
+        ear_l = Arc((-r + cx, cy), 0.10, 0.22, angle=0,
+                    theta1=90, theta2=270,
+                    linewidth=2.5, edgecolor='#9999bb', zorder=1)
+        ear_r = Arc(( r + cx, cy), 0.10, 0.22, angle=0,
+                    theta1=270, theta2=90,
+                    linewidth=2.5, edgecolor='#9999bb', zorder=1)
+        self.ax.add_patch(ear_l)
+        self.ax.add_patch(ear_r)
+
+        # Lignes de reference (axe sagittal + coronal)
+        self.ax.plot([cx, cx], [cy - r, cy + r], '--',
+                     color='#2a2a4a', linewidth=1.0, zorder=0)
+        self.ax.plot([cx - r, cx + r], [cy, cy], '--',
+                     color='#2a2a4a', linewidth=1.0, zorder=0)
+
+        # Etiquettes orientation
+        self.ax.text(0, cy + r + 0.09, 'FRONT', ha='center', va='bottom',
+                     fontsize=7, color='#6666aa')
+        self.ax.text(0, cy - r - 0.04, 'BACK', ha='center', va='top',
+                     fontsize=7, color='#6666aa')
+
+    def _draw_legend(self):
+        legend_y = -0.53
+        items = (list(zip(IMP_LABELS_LEG, IMP_COLORS))
+                 + [('Open circuit / saturated', IMP_RAILED),
+                    ('No data', IMP_NO_DATA)])
+        x_start = -0.72
+        x_step  =  0.248
+        for i, (label, color) in enumerate(items):
+            x = x_start + i * x_step
+            self.ax.add_patch(Circle((x, legend_y), 0.018, color=color, zorder=4))
+            self.ax.text(x + 0.025, legend_y, label,
+                         va='center', ha='left', fontsize=6.5, color='white')
+
+    def _create_electrode_artists(self):
+        self.circles    = []
+        self.imp_labels = []
+        self.ch_labels  = []
+
+        for i, (x, y) in enumerate(ELECTRODE_POSITIONS):
+            ch_num   = i + 1
+            inactive = (x == 0.0 and y == 0.0)
+
+            if inactive:
+                self.circles.append(None)
+                self.imp_labels.append(None)
+                self.ch_labels.append(None)
+                continue
+
+            circ = Circle(
+                (x, y), self.ELECTRODE_RADIUS,
+                facecolor=IMP_NO_DATA, edgecolor='white',
+                linewidth=1.2, zorder=3
+            )
+            self.ax.add_patch(circ)
+            self.circles.append(circ)
+
+            ch_lbl = self.ax.text(
+                x, y, f'CH{ch_num}',
+                ha='center', va='center',
+                fontsize=5.8, color='black', fontweight='bold', zorder=5
+            )
+            self.ch_labels.append(ch_lbl)
+
+            imp_lbl = self.ax.text(
+                x, y - self.ELECTRODE_RADIUS - 0.025,
+                '---',
+                ha='center', va='top',
+                fontsize=7.5, color='white', fontweight='bold', zorder=5
+            )
+            self.imp_labels.append(imp_lbl)
+
+    def _update_frame(self, _frame):
+        impedances = self.board.get_impedances()
+        n_samples  = self.board.n_samples_collected()
+        n_active   = sum(1 for v in impedances
+                         if v is not None and v != 'open')
+
+        for i, imp in enumerate(impedances):
+            circ    = self.circles[i]
+            imp_lbl = self.imp_labels[i]
+            if circ is None:
+                continue
+            circ.set_facecolor(_impedance_color(imp))
+            if imp_lbl is not None:
+                imp_lbl.set_text(_impedance_text(imp))
+                # Couleur du texte : blanc sauf sur OPEN (violet fonce → texte clair)
+                imp_lbl.set_color('#ddaaff' if imp == 'open' else 'white')
+
+        need = SAMPLE_RATE
+        pct  = min(100, int(n_samples / need * 100))
+        n_open = sum(1 for v in impedances if v == 'open')
+
+        if n_samples < need:
+            self.status_lbl.set_text(
+                f'Collecting: {n_samples}/{need} samples ({pct}%)'
+            )
+        else:
+            self.status_lbl.set_text(
+                f'Live — {n_active}/14 channels measured  |  {n_open} open circuit(s)'
+            )
+        return []
+
+    def show(self):
+        plt.tight_layout(rect=[0, 0, 1, 0.96])
+        plt.show()
+
+
+# ╔══════════════════════════════════════════════════╗
+# ║                   POINT D'ENTREE                 ║
+# ╚══════════════════════════════════════════════════╝
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="OpenBCI Cyton+Daisy — Moniteur d'impedance live"
+    )
+    parser.add_argument('--port', type=str, default=None,
+                        help='Port serie (ex: COM3, /dev/ttyUSB0)')
+    parser.add_argument('--list-ports', action='store_true',
+                        help='Lister les ports disponibles et quitter')
+    args = parser.parse_args()
+
+    if args.list_ports:
+        print("Ports serie disponibles :")
+        for p in serial.tools.list_ports.comports():
+            print(f"  {p.device:20s}  {p.description}  [{p.hwid}]")
+        sys.exit(0)
+
+    port = args.port
+    if port is None:
+        port = find_openbci_port()
+        if port is None:
+            print("ERREUR : dongle introuvable. Utilisez --port.")
+            sys.exit(1)
+        print(f"Dongle detecte automatiquement : {port}")
+    else:
+        print(f"Port specifie : {port}")
+
+    board = CytonDaisyBoard(port)
+    try:
+        board.connect()
+    except TimeoutError as e:
+        print(f"\nERREUR de connexion : {e}")
+        sys.exit(1)
+    except serial.SerialException as e:
+        print(f"\nERREUR serie : {e}")
+        sys.exit(1)
+
+    display = ImpedanceDisplay(board)
+    print("\nFenetre ouverte. Fermez-la ou Ctrl+C pour quitter.")
+    try:
+        display.show()
+    except KeyboardInterrupt:
+        print("\nInterruption.")
+    finally:
+        board.disconnect()
+        print("Programme termine.")
+
+
+if __name__ == '__main__':
+    main()