com.xrlab.labframe_brainbit 1.0.9 → 1.1.1

package/README.md

@@ -2,11 +2,16 @@
 
 此套件為 LabFrame 2023 專用的 BrainBit 設備插件，用於連接與管理 BrainBit 腦波儀。
 
+> [!NOTE]
+> 請再記得多安裝此套件 https://github.com/BrainbitLLC/unity_em_st_artifacts.git#a04238a934b3da0494dd9120a489005277063a1f
+> 開發當下此套件最新版(1.0.3)在android平台會有問題
+
 ## 支援功能
 1. **設備連線管理：** 自動搜尋並手動觸發連接藍牙 BrainBit 設備。
 2. **EEG 腦波數據收集：** 自動收集四個通道 (T3, T4, O1, O2) 的腦波數據。
 3. **即時阻抗檢查：** 確認電極與頭皮的接觸阻抗值是否過高 (> 200,000Ω)。
 4. **多階段資料分流儲存：** 收集期間可動態切換儲存 Tag（依照遊戲階段無縫寫入不同檔案）。
+5. **情緒與光譜分析：** 透過 NeuroSDK `EegEmotionalMath` 即時運算專注 / 放鬆（MindData）與 δ/θ/α/β/γ 五頻段光譜百分比。
 
 ---
 
@@ -103,7 +108,95 @@ void CheckImpedanceStatus()
 
 ---
 
-### 4. 設備搜尋與多設備選擇機制
+### 4. 情緒與光譜分析 (MindData / SpectralData)
+
+整合 NeuroSDK `EegEmotionalMath`，即時取得受測者的**專注度 / 放鬆度**以及**五頻段光譜百分比**。
+
+> 情緒處理需要先完成約 6 秒的**校正** (請受測者安靜配戴)，校正完成後才會開始輸出有效的 MindData / SpectralData。
+
+#### 👉 開始 / 停止情緒處理
+
+```csharp
+// 啟動情緒處理（若 EEG 尚未啟動，會自動開啟；停止時會一併停止該次自動啟動的 EEG）
+BrainBitManager.Instance.StartEmotionsProcessing(
+    autoWriteToLabData: true,
+    mindTag: "Gameplay_Mind",
+    spectralTag: "Gameplay_Spectral");
+
+// 停止情緒處理
+BrainBitManager.Instance.StopEmotionsProcessing();
+```
+
+#### 👉 等待校正完成
+
+```csharp
+BrainBitManager.Instance.OnCalibrationProgress += pct => Debug.Log($"校正中 {pct}%");
+BrainBitManager.Instance.OnCalibrationFinished += () => Debug.Log("校正完成！");
+
+// 或在輪詢中判斷：
+if (BrainBitManager.Instance.IsEmotionsCalibrated)
+{
+    // 此時才能讀到有效的 MindData / SpectralData
+}
+```
+
+若遊戲中需要重新校正（換受測者、中途摘下又戴回）：
+```csharp
+BrainBitManager.Instance.RestartCalibration();
+```
+
+#### 👉 取得最新的專注 / 放鬆值
+
+```csharp
+void Update()
+{
+    if (!BrainBitManager.Instance.IsEmotionsCalibrated) return;
+
+    var mind = BrainBitManager.Instance.GetLatestMindData();
+    if (mind == null) return;
+
+    Debug.Log($"專注: {mind.Attention:F1} / 放鬆: {mind.Relaxation:F1}");
+    // mind.InstAttention / mind.InstRelaxation 為瞬時值（抖動大，僅進階使用）
+}
+```
+
+#### 👉 取得最新的五頻段光譜百分比
+
+```csharp
+var spec = BrainBitManager.Instance.GetLatestSpectralData();
+if (spec != null)
+{
+    Debug.Log($"δ:{spec.Delta:F1} θ:{spec.Theta:F1} α:{spec.Alpha:F1} β:{spec.Beta:F1} γ:{spec.Gamma:F1}");
+}
+```
+
+#### 👉 事件訂閱（event-driven 寫法）
+
+```csharp
+BrainBitManager.Instance.OnMindDataReceived     += mind => { /* 更新 UI */ };
+BrainBitManager.Instance.OnSpectralDataReceived += spec => { /* 更新 UI */ };
+BrainBitManager.Instance.OnEmotionsArtifact     += hasArtifact => { /* 顯示雜訊警告 */ };
+```
+
+#### 👉 動態無縫切換儲存階段 (Tag)
+
+```csharp
+// 不用停情緒處理，下一筆資料就會被寫進新 tag
+BrainBitManager.Instance.SetMindTag("Boss_Phase_Mind");
+BrainBitManager.Instance.SetSpectralTag("Boss_Phase_Spectral");
+```
+
+#### 👉 可調設定（`BrainBitConfig`）
+
+| 欄位 | 預設 | 說明 |
+|---|---|---|
+| `EmotionsCalibrationLength` | `6` | 校正時間（秒）。越長越穩，但受測者需要等更久 |
+| `EmotionsMentalEstimation` | `false` | 啟用 Mental Estimation（依實驗類型決定） |
+| `EmotionsPrioritySide` | `SideType.NONE` | 優先分析腦側：`NONE` / `LEFT` / `RIGHT` |
+
+---
+
+### 5. 設備搜尋與多設備選擇機制
 
 預設情況下，`BrainBitManager` 會自動過濾周遭的藍牙設備，只尋找型號為 `SensorLEBrainBit` 的腦波儀。
 
@@ -115,7 +208,7 @@ void CheckImpedanceStatus()
 
 ---
 
-### 5. 實用除錯工具：獲取設備詳細參數
+### 6. 實用除錯工具：獲取設備詳細參數
 
 如果需要查看設備底層的詳細資訊（例如：電量、硬體版本、韌體版本、取樣頻率等），可使用內建的解析器 `SensorInfoProvider.cs` 將複雜的底層參數結構化。
 

package/Scripts/BrainBitConfig.cs

@@ -1,6 +1,7 @@
 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
+using SignalMath;
 
 /// <summary>
 /// BrainBit 設備配置
@@ -48,4 +49,19 @@ public class BrainBitConfig
     /// 停止掃描後等待一段時間再建立連接
     /// </summary>
     public float ConnectDelaySeconds = 1.0f;
+
+    /// <summary>
+    /// 情緒處理校正時間（秒）。較長 → 較穩定，但受測者要等更久。
+    /// </summary>
+    public int EmotionsCalibrationLength = 6;
+
+    /// <summary>
+    /// 啟用 Mental Estimation（依實驗類型決定是否開啟）。
+    /// </summary>
+    public bool EmotionsMentalEstimation = false;
+
+    /// <summary>
+    /// 情緒分析優先腦側：NONE / LEFT / RIGHT，預設 NONE（雙側平均）。
+    /// </summary>
+    public SideType EmotionsPrioritySide = SideType.NONE;
 }

package/Scripts/BrainBitData.cs

@@ -3,6 +3,7 @@ using System.Collections;
 using System.Collections.Generic;
 using LabFrame2023;
 using System;
+using SignalMath;
 
 /// <summary>
 /// BrainBit EEG 數據
@@ -184,4 +185,72 @@ public class BrainBit_ConnectionData : LabDataBase
     {
         return $"{EventType}: {DeviceName} ({DeviceAddress}) - Connected: {IsConnected}";
     }
+}
+
+/// <summary>
+/// BrainBit 情緒/心智狀態數據（專注、放鬆）
+/// </summary>
+[Serializable]
+public class BrainBit_MindData : LabDataBase
+{
+    /// <summary>相對專注度（平滑值，0-100，建議使用）</summary>
+    public double Attention;
+
+    /// <summary>相對放鬆度（平滑值，0-100，建議使用）</summary>
+    public double Relaxation;
+
+    /// <summary>瞬時專注度（抖動大，進階用）</summary>
+    public double InstAttention;
+
+    /// <summary>瞬時放鬆度（抖動大，進階用）</summary>
+    public double InstRelaxation;
+
+    public BrainBit_MindData() : base() { }
+
+    public BrainBit_MindData(MindData raw) : base()
+    {
+        Attention      = raw.RelAttention;
+        Relaxation     = raw.RelRelaxation;
+        InstAttention  = raw.InstAttention;
+        InstRelaxation = raw.InstRelaxation;
+    }
+
+    public override string ToString()
+        => $"Attention: {Attention:F1} | Relaxation: {Relaxation:F1}";
+}
+
+/// <summary>
+/// BrainBit 五頻段光譜百分比
+/// </summary>
+[Serializable]
+public class BrainBit_SpectralData : LabDataBase
+{
+    /// <summary>δ 波（深度放鬆 / 睡眠）</summary>
+    public double Delta;
+
+    /// <summary>θ 波（冥想 / 創意）</summary>
+    public double Theta;
+
+    /// <summary>α 波（放鬆清醒）</summary>
+    public double Alpha;
+
+    /// <summary>β 波（專注思考）</summary>
+    public double Beta;
+
+    /// <summary>γ 波（高階認知）</summary>
+    public double Gamma;
+
+    public BrainBit_SpectralData() : base() { }
+
+    public BrainBit_SpectralData(SpectralDataPercents raw) : base()
+    {
+        Delta = raw.Delta;
+        Theta = raw.Theta;
+        Alpha = raw.Alpha;
+        Beta  = raw.Beta;
+        Gamma = raw.Gamma;
+    }
+
+    public override string ToString()
+        => $"δ:{Delta:F1} θ:{Theta:F1} α:{Alpha:F1} β:{Beta:F1} γ:{Gamma:F1}";
 }

package/Scripts/BrainBitManager.cs

@@ -5,6 +5,7 @@ using System.Collections.Concurrent;
 using LabFrame2023;
 using UnityEngine.Events;
 using NeuroSDK;
+using SignalMath;
 using System;
 
 /// <summary>
@@ -43,6 +44,21 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
     /// 是否正在掃描設備
     /// </summary>
     public bool IsScanning { get; private set; } = false;
+
+    /// <summary>
+    /// 正在跑情緒處理？
+    /// </summary>
+    public bool IsProcessingEmotions { get; private set; } = false;
+
+    /// <summary>
+    /// 情緒校正是否已完成？校正完成前 Mind / Spectral 回傳 null
+    /// </summary>
+    public bool IsEmotionsCalibrated { get; private set; } = false;
+
+    /// <summary>
+    /// 情緒校正進度 0-100
+    /// </summary>
+    public int CalibrationProgress { get; private set; } = 0;
     #endregion
 
     #region Events
@@ -70,6 +86,31 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
     /// 錯誤事件
     /// </summary>
     public event UnityAction<string> OnError;
+
+    /// <summary>
+    /// 情緒/心智資料更新事件
+    /// </summary>
+    public event UnityAction<BrainBit_MindData> OnMindDataReceived;
+
+    /// <summary>
+    /// 五頻段光譜資料更新事件
+    /// </summary>
+    public event UnityAction<BrainBit_SpectralData> OnSpectralDataReceived;
+
+    /// <summary>
+    /// 情緒校正進度 0-100
+    /// </summary>
+    public event UnityAction<int> OnCalibrationProgress;
+
+    /// <summary>
+    /// 情緒校正完成
+    /// </summary>
+    public event UnityAction OnCalibrationFinished;
+
+    /// <summary>
+    /// 偵測到情緒處理期間的雜訊（sequence 或雙側）
+    /// </summary>
+    public event UnityAction<bool> OnEmotionsArtifact;
     #endregion
 
     #region Private Fields
@@ -83,10 +124,12 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
     private bool _autoWriteEEGData = false;
     private bool _autoWriteImpedanceData = false;
 
-    private Coroutine _connectionMonitorCoroutine;
-    private Coroutine _scanTimeoutCoroutine;
-
-    private int _reconnectAttempts = 0;
+    private Coroutine _connectionMonitorCoroutine;
+    private Coroutine _scanTimeoutCoroutine;
+
+    private int _reconnectAttempts = 0;
+    private bool _isInitialized = false;
+    private bool _autoConnectScheduled = false;
 
     // 用於記錄目前 EEG 寫入資料的標籤 (對應不同的儲存檔案)
     private string _currentEEGTag = "eeg";
@@ -95,6 +138,16 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
 
     // 主執行緒派發佇列，用於將背景執行緒的回呼安全地轉移到主執行緒執行
     private readonly ConcurrentQueue<Action> _mainThreadActions = new ConcurrentQueue<Action>();
+
+    // === Emotions ===
+    private EmotionsController _emotionsController;
+    private bool _autoWriteEmotionData = false;
+    private string _currentMindTag = "mind";
+    private string _currentSpectralTag = "spectral";
+    private BrainBit_MindData _lastMindData;
+    private BrainBit_SpectralData _lastSpectralData;
+    // 若為 true，代表 EEG 串流是被情緒處理自動啟動的 — StopEmotionsProcessing 時要一起停
+    private bool _emotionsStartedEEG = false;
     #endregion
 
     #region IManager Implementation
@@ -103,20 +156,21 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
         LabTools.Log("[BrainBit] Initializing BrainBit Manager...");
 
         // 載入配置
-        _config = LabTools.GetConfig<BrainBitConfig>(true);
+        if (!EnsureInitialized(nameof(ManagerInit)))
+        {
+            return;
+        }
 
         // 初始化數據對象
-        _lastEEGData = new BrainBit_EEGData();
-        _lastImpedanceData = new BrainBit_ImpedanceData();
 
         // 開始連接監控
-        _connectionMonitorCoroutine = StartCoroutine(MonitorConnection());
 
         // 自動連接
-        if (_config.AutoConnectOnInit)
-        {
-            StartCoroutine(DelayedAutoConnect());
-        }
+        if (_config.AutoConnectOnInit && !_autoConnectScheduled && !IsConnected && !IsScanning)
+        {
+            _autoConnectScheduled = true;
+            StartCoroutine(DelayedAutoConnect());
+        }
 
         LabTools.Log("[BrainBit] Manager initialized successfully");
         LabTools.Log($"[BrainBit] Config - AutoConnect: {_config.AutoConnectOnInit}, ScanTimeout: {_config.ScanTimeoutSeconds}s");
@@ -146,6 +200,7 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
         LabTools.Log("[BrainBit] Disposing BrainBit Manager...");
 
         // 停止所有數據流
+        StopEmotionsProcessing();
         StopEEGStream();
         StopImpedanceStream();
 
@@ -180,17 +235,59 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
     }
     #endregion
 
-    #region Public Methods
-    /// <summary>
+    #region Public Methods
+    private bool EnsureInitialized(string callerName)
+    {
+        if (_isInitialized && _config != null)
+        {
+            return true;
+        }
+
+        try
+        {
+            _config ??= LabTools.GetConfig<BrainBitConfig>(true);
+            if (_config == null)
+            {
+                LabTools.LogError($"[BrainBit] {callerName} failed - BrainBitConfig is missing");
+                OnError?.Invoke("BrainBit config is missing");
+                return false;
+            }
+
+            _lastEEGData ??= new BrainBit_EEGData();
+            _lastImpedanceData ??= new BrainBit_ImpedanceData();
+
+            if (_connectionMonitorCoroutine == null)
+            {
+                _connectionMonitorCoroutine = StartCoroutine(MonitorConnection());
+            }
+
+            _isInitialized = true;
+            LabTools.Log($"[BrainBit] Initialization ready for {callerName}");
+            return true;
+        }
+        catch (Exception e)
+        {
+            LabTools.LogError($"[BrainBit] {callerName} failed during initialization: {e.Message}");
+            OnError?.Invoke($"Initialization failed: {e.Message}");
+            return false;
+        }
+    }
+
+    /// <summary>
     /// 開始掃描 BrainBit 設備
     /// </summary>
-    public void StartScan()
-    {
-        if (IsScanning)
-        {
-            LabTools.LogError("[BrainBit] Already scanning for devices");
-            return;
-        }
+    public void StartScan()
+    {
+        if (!EnsureInitialized(nameof(StartScan)))
+        {
+            return;
+        }
+
+        if (IsScanning)
+        {
+            LabTools.LogError("[BrainBit] Already scanning for devices");
+            return;
+        }
 
         try
         {
@@ -525,10 +622,18 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
         }
     }
 
-    private IEnumerator ScanTimeout()
-    {
-        LabTools.Log($"[BrainBit] Scan timeout set for {_config.ScanTimeoutSeconds} seconds");
-        yield return new WaitForSeconds(_config.ScanTimeoutSeconds);
+    private IEnumerator ScanTimeout()
+    {
+        if (!EnsureInitialized(nameof(ScanTimeout)))
+        {
+            IsScanning = false;
+            _scanTimeoutCoroutine = null;
+            yield break;
+        }
+
+        float timeoutSeconds = _config.ScanTimeoutSeconds;
+        LabTools.Log($"[BrainBit] Scan timeout set for {timeoutSeconds} seconds");
+        yield return new WaitForSeconds(timeoutSeconds);
 
         if (_scanTimeoutCoroutine != null && _currentSensor == null)
         {
@@ -629,12 +734,18 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
     /// 延遲連接設備
     /// </summary>
     /// <param name="sensorInfo">設備信息</param>
-    private IEnumerator DelayedConnect(SensorInfo sensorInfo)
-    {
-        LabTools.Log($"[BrainBit] Waiting {_config.ConnectDelaySeconds}s before connecting...");
+    private IEnumerator DelayedConnect(SensorInfo sensorInfo)
+    {
+        if (!EnsureInitialized(nameof(DelayedConnect)))
+        {
+            yield break;
+        }
+
+        float connectDelaySeconds = _config.ConnectDelaySeconds;
+        LabTools.Log($"[BrainBit] Waiting {connectDelaySeconds}s before connecting...");
 
         // 等待指定時間，確保掃描完全停止
-        yield return new WaitForSeconds(_config.ConnectDelaySeconds);
+        yield return new WaitForSeconds(connectDelaySeconds);
 
         // 建立連接
         ConnectToDevice(sensorInfo);
@@ -698,6 +809,7 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
             if (IsConnected)
             {
                 // 停止所有數據流
+                StopEmotionsProcessing();
                 StopEEGStream();
                 StopImpedanceStream();
 
@@ -724,12 +836,18 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
         }
     }
 
-    private void HandleDisconnection()
-    {
-        LabTools.LogError($"[BrainBit] Device disconnected: {ConnectedDeviceName}");
-
-        if (_config.DisconnectNotification)
-        {
+    private void HandleDisconnection()
+    {
+        LabTools.LogError($"[BrainBit] Device disconnected: {ConnectedDeviceName}");
+
+        if (!EnsureInitialized(nameof(HandleDisconnection)))
+        {
+            Disconnect();
+            return;
+        }
+
+        if (_config.DisconnectNotification)
+        {
             LabPromptBox.Show($"BrainBit 設備已斷線！\nDevice {ConnectedDeviceName} disconnected!");
         }
 
@@ -742,12 +860,18 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
         Disconnect();
     }
 
-    private IEnumerator AttemptReconnect()
-    {
-        _reconnectAttempts++;
-        LabTools.Log($"[BrainBit] Attempting reconnection ({_reconnectAttempts}/{_config.AutoReconnectAttempts})...");
-
-        yield return new WaitForSeconds(_config.ReconnectIntervalSeconds);
+    private IEnumerator AttemptReconnect()
+    {
+        if (!EnsureInitialized(nameof(AttemptReconnect)))
+        {
+            yield break;
+        }
+
+        _reconnectAttempts++;
+        LabTools.Log($"[BrainBit] Attempting reconnection ({_reconnectAttempts}/{_config.AutoReconnectAttempts})...");
+
+        float reconnectIntervalSeconds = _config.ReconnectIntervalSeconds;
+        yield return new WaitForSeconds(reconnectIntervalSeconds);
 
         if (!IsConnected)
         {
@@ -778,6 +902,12 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
                     }
                 });
             }
+
+            // 情緒處理（寄生在同一條 NeuroSDK 背景緒，不開額外 thread）
+            if (IsProcessingEmotions)
+            {
+                _emotionsController?.ProcessData(data);
+            }
         }
         catch (Exception e)
         {
@@ -838,13 +968,25 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
                 _currentSensor = null;
             }
 
-            // 重置狀態
-            IsConnected = false;
-            IsStreamingEEG = false;
-            IsStreamingImpedance = false;
-            IsScanning = false;
+            // 清理情緒控制器
+            if (_emotionsController != null)
+            {
+                UnwireEmotionsCallbacks();
+                _emotionsController.Dispose();
+                _emotionsController = null;
+            }
+            IsProcessingEmotions = false;
+            IsEmotionsCalibrated = false;
 
-            LabTools.Log("[BrainBit] Resources cleaned up");
+            // 重置狀態
+            IsConnected = false;
+            IsStreamingEEG = false;
+            IsStreamingImpedance = false;
+            IsScanning = false;
+            _isInitialized = false;
+            _autoConnectScheduled = false;
+
+            LabTools.Log("[BrainBit] Resources cleaned up");
         }
         catch (Exception e)
         {
@@ -852,4 +994,238 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
         }
     }
     #endregion
-}
+
+    #region Emotions Processing
+
+    /// <summary>
+    /// 啟動情緒處理（MindData / SpectralData / 校正進度）。
+    /// 若 EEG 串流未啟動，會自動啟動；呼叫 StopEmotionsProcessing 時會同步停止該 EEG 串流。
+    /// </summary>
+    public void StartEmotionsProcessing(bool autoWriteToLabData = true,
+                                        string mindTag = "mind",
+                                        string spectralTag = "spectral")
+    {
+        if (!EnsureInitialized(nameof(StartEmotionsProcessing)))
+        {
+            return;
+        }
+
+        if (!IsConnected)
+        {
+            LabTools.LogError("[BrainBit] Device not connected");
+            OnError?.Invoke("Device not connected");
+            return;
+        }
+
+        if (IsProcessingEmotions)
+        {
+            LabTools.LogError("[BrainBit] Emotions processing already active");
+            return;
+        }
+
+        try
+        {
+            _autoWriteEmotionData = autoWriteToLabData;
+            _currentMindTag = string.IsNullOrEmpty(mindTag) ? "mind" : mindTag;
+            _currentSpectralTag = string.IsNullOrEmpty(spectralTag) ? "spectral" : spectralTag;
+
+            // 若 EEG 未啟動，自動啟動並記錄
+            if (!IsStreamingEEG)
+            {
+                StartEEGStream(autoWriteToLabData: false);
+                _emotionsStartedEEG = true;
+            }
+            else
+            {
+                _emotionsStartedEEG = false;
+            }
+
+            // 建立 / 重建 controller（套用目前 BrainBitConfig）
+            _emotionsController?.Dispose();
+            _emotionsController = new EmotionsController(_config);
+            WireEmotionsCallbacks();
+
+            // 校正狀態重置
+            IsEmotionsCalibrated = false;
+            CalibrationProgress = 0;
+            _lastMindData = null;
+            _lastSpectralData = null;
+
+            _emotionsController.StartCalibration();
+            IsProcessingEmotions = true;
+
+            LabTools.Log($"[BrainBit] Emotions processing started (mindTag: {_currentMindTag}, spectralTag: {_currentSpectralTag})");
+        }
+        catch (Exception e)
+        {
+            if (_emotionsStartedEEG)
+            {
+                StopEEGStream();
+                _emotionsStartedEEG = false;
+            }
+            LabTools.LogError($"[BrainBit] Failed to start emotions processing: {e.Message}");
+            OnError?.Invoke($"Emotions processing failed: {e.Message}");
+        }
+    }
+
+    /// <summary>
+    /// 停止情緒處理。若本次 EEG 串流是由情緒處理自動啟動的，同步停止該 EEG 串流；
+    /// 否則保留 EEG 串流（避免誤停使用者正在錄的 EEG）。
+    /// </summary>
+    public void StopEmotionsProcessing()
+    {
+        if (!IsProcessingEmotions) return;
+
+        try
+        {
+            IsProcessingEmotions = false;
+
+            if (_emotionsController != null)
+            {
+                UnwireEmotionsCallbacks();
+                _emotionsController.Dispose();
+                _emotionsController = null;
+            }
+
+            _autoWriteEmotionData = false;
+            IsEmotionsCalibrated = false;
+            CalibrationProgress = 0;
+
+            if (_emotionsStartedEEG && IsStreamingEEG)
+            {
+                StopEEGStream();
+            }
+            _emotionsStartedEEG = false;
+
+            LabTools.Log("[BrainBit] Emotions processing stopped");
+        }
+        catch (Exception e)
+        {
+            LabTools.LogError($"[BrainBit] Error stopping emotions processing: {e.Message}");
+        }
+    }
+
+    /// <summary>
+    /// 重新校正（例如換受測者、中途摘下又戴回）。
+    /// </summary>
+    public void RestartCalibration()
+    {
+        if (!IsProcessingEmotions || _emotionsController == null)
+        {
+            LabTools.LogError("[BrainBit] Cannot restart calibration - emotions processing not active");
+            return;
+        }
+
+        IsEmotionsCalibrated = false;
+        CalibrationProgress = 0;
+        _emotionsController.StartCalibration();
+
+        LabTools.Log("[BrainBit] Emotion calibration restarted");
+    }
+
+    /// <summary>
+    /// 動態切換 MindData 寫入 Tag
+    /// </summary>
+    public void SetMindTag(string tag)
+    {
+        _currentMindTag = string.IsNullOrEmpty(tag) ? "mind" : tag;
+        LabTools.Log($"[BrainBit] Mind data tag dynamically changed to: {_currentMindTag}");
+    }
+
+    /// <summary>
+    /// 動態切換 SpectralData 寫入 Tag
+    /// </summary>
+    public void SetSpectralTag(string tag)
+    {
+        _currentSpectralTag = string.IsNullOrEmpty(tag) ? "spectral" : tag;
+        LabTools.Log($"[BrainBit] Spectral data tag dynamically changed to: {_currentSpectralTag}");
+    }
+
+    /// <summary>
+    /// 取得最新的情緒/心智資料。校正完成前回傳 null。
+    /// </summary>
+    public BrainBit_MindData GetLatestMindData() => _lastMindData;
+
+    /// <summary>
+    /// 取得最新的五頻段光譜資料。校正完成前回傳 null。
+    /// </summary>
+    public BrainBit_SpectralData GetLatestSpectralData() => _lastSpectralData;
+
+    private void WireEmotionsCallbacks()
+    {
+        if (_emotionsController == null) return;
+
+        _emotionsController.progressCalibrationCallback = OnEmotionsCalibrationProgress;
+        _emotionsController.lastMindDataCallback = OnRawMindDataReceived;
+        _emotionsController.lastSpectralDataCallback = OnRawSpectralDataReceived;
+        _emotionsController.isArtefactedSequenceCallback = OnEmotionsArtifactDetected;
+        _emotionsController.isBothSidesArtifactedCallback = OnEmotionsArtifactDetected;
+    }
+
+    private void UnwireEmotionsCallbacks()
+    {
+        if (_emotionsController == null) return;
+
+        _emotionsController.progressCalibrationCallback = null;
+        _emotionsController.lastMindDataCallback = null;
+        _emotionsController.lastSpectralDataCallback = null;
+        _emotionsController.isArtefactedSequenceCallback = null;
+        _emotionsController.isBothSidesArtifactedCallback = null;
+    }
+
+    private void OnEmotionsCalibrationProgress(int progress)
+    {
+        // 這些 callback 由 NeuroSDK/EmotionsController 在背景緒觸發
+        _mainThreadActions.Enqueue(() =>
+        {
+            CalibrationProgress = progress;
+            OnCalibrationProgress?.Invoke(progress);
+
+            if (progress >= 100 && !IsEmotionsCalibrated)
+            {
+                IsEmotionsCalibrated = true;
+                OnCalibrationFinished?.Invoke();
+                LabTools.Log("[BrainBit] Emotion calibration finished");
+            }
+        });
+    }
+
+    private void OnRawMindDataReceived(MindData raw)
+    {
+        var wrapped = new BrainBit_MindData(raw);
+
+        _mainThreadActions.Enqueue(() =>
+        {
+            _lastMindData = wrapped;
+            OnMindDataReceived?.Invoke(wrapped);
+
+            if (_autoWriteEmotionData && LabDataManager.Instance.IsInited)
+            {
+                LabDataManager.Instance.WriteData(wrapped, _currentMindTag);
+            }
+        });
+    }
+
+    private void OnRawSpectralDataReceived(SpectralDataPercents raw)
+    {
+        var wrapped = new BrainBit_SpectralData(raw);
+
+        _mainThreadActions.Enqueue(() =>
+        {
+            _lastSpectralData = wrapped;
+            OnSpectralDataReceived?.Invoke(wrapped);
+
+            if (_autoWriteEmotionData && LabDataManager.Instance.IsInited)
+            {
+                LabDataManager.Instance.WriteData(wrapped, _currentSpectralTag);
+            }
+        });
+    }
+
+    private void OnEmotionsArtifactDetected(bool hasArtifact)
+    {
+        _mainThreadActions.Enqueue(() => OnEmotionsArtifact?.Invoke(hasArtifact));
+    }
+
+    #endregion
+}

package/Scripts/EmotionalMathConfig.cs

@@ -0,0 +1,115 @@
+using SignalMath;
+
+
+public class EmotionalMathConfig
+{
+    public static EmotionalMathConfig GetDefault(bool isBipolar, BrainBitConfig labConfig = null)
+    {
+        int samplingFrequencyHz = 250;
+
+        var mathLib = new MathLibSetting
+        {
+            sampling_rate = (uint)samplingFrequencyHz,
+            process_win_freq = 25,
+            fft_window = (uint)samplingFrequencyHz * 2,
+            n_first_sec_skipped = 4,
+            bipolar_mode = isBipolar,
+            squared_spectrum = true,
+            channels_number = (uint)1,
+            channel_for_analysis = 0
+        };
+
+        var artsDetect = new ArtifactDetectSetting
+        {
+            art_bord = 110,
+            allowed_percent_artpoints = 70,
+            raw_betap_limit = 800_000,
+            total_pow_border = (uint)(8 * 1e7),
+            global_artwin_sec = 4,
+            spect_art_by_totalp = false,
+            hanning_win_spectrum = false,
+            hamming_win_spectrum = true,
+            num_wins_for_quality_avg = 100
+        };
+
+        var shortArtsDetect = new ShortArtifactDetectSetting
+        {
+            ampl_art_detect_win_size = 200,
+            ampl_art_zerod_area = 200,
+            ampl_art_extremum_border = 25
+        };
+
+        var mentalAndSpectralSettings = new MentalAndSpectralSetting
+        {
+            n_sec_for_instant_estimation = 2,
+            n_sec_for_averaging = 4
+        };
+
+        var emConfigs = new EmotionalMathConfig(samplingFrequencyHz, mathLib, artsDetect, shortArtsDetect, mentalAndSpectralSettings);
+
+        if (labConfig != null)
+        {
+            emConfigs.CallibrationLength   = labConfig.EmotionsCalibrationLength;
+            emConfigs.MentalEstimation     = labConfig.EmotionsMentalEstimation;
+            emConfigs.PrioritySide         = labConfig.EmotionsPrioritySide;
+        }
+
+        return emConfigs;
+    }
+
+    public int SamplingFrequencyHz
+    {
+        get; set;
+    }
+
+    public MathLibSetting MathLib;
+
+    public ArtifactDetectSetting ArtifactDetect;
+
+    public ShortArtifactDetectSetting ShortArtifactDetect;
+
+    public MentalAndSpectralSetting MentalAndSpectral;
+
+    public bool MentalEstimation { get; set; } = false;
+
+    public SideType PrioritySide { get; set; } = SideType.NONE;
+
+    public int CallibrationLength { get; set; } = 6;
+
+    public int SkipWinsAfterArtifact { get; set; } = 5;
+
+    // ZeroSpectWaves
+    public bool Active { get; set; } = true;
+    public int alpha { get; set; } = 1;
+    public int beta { get; set; } = 1;
+    public int theta { get; set; } = 1;
+    public int delta { get; set; } = 0;
+    public int gamma { get; set; } = 0;
+
+    // WeightsForSpectra
+    public double delta_c { get; set; } = 1;
+    public double theta_c { get; set; } = 1;
+    public double alpha_c { get; set; } = 1;
+    public double beta_c { get; set; } = 1;
+    public double gamma_c { get; set; } = 1;
+
+    public bool SpectNormalizationByBandsWidth { get; set; }
+
+    public bool SpectNormalizationByCoeffs { get; set; }
+
+    public EmotionalMathConfig(
+        int samplingFrequencyHz,
+        MathLibSetting mathLib,
+        ArtifactDetectSetting artifactDetect,
+        ShortArtifactDetectSetting shortArtifactDetect,
+        MentalAndSpectralSetting mentalAndSpectral
+        )
+    {
+        SamplingFrequencyHz = samplingFrequencyHz;
+        MathLib = mathLib;
+        ArtifactDetect = artifactDetect;
+        ShortArtifactDetect = shortArtifactDetect;
+        MentalAndSpectral = mentalAndSpectral;
+    }
+
+}

package/Scripts/EmotionalMathConfig.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7c68ef6736878fc4d9a35c9653976b09
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/EmotionsController.cs

@@ -0,0 +1,133 @@
+using NeuroSDK;
+using SignalMath;
+using System;
+using System.Linq;
+
+public class EmotionsController
+{
+    private readonly EegEmotionalMath _math;
+
+    public Action<int> progressCalibrationCallback = null;
+    public Action<bool> isArtefactedSequenceCallback = null;
+    public Action<bool> isBothSidesArtifactedCallback = null;
+    public Action<SpectralDataPercents> lastSpectralDataCallback = null;
+    public Action<RawSpectVals> rawSpectralDataCallback = null;
+    public Action<MindData> lastMindDataCallback = null;
+
+    private bool isCalibrated = false;
+
+    public EmotionsController(BrainBitConfig labConfig = null)
+    {
+        var config = EmotionalMathConfig.GetDefault(true, labConfig);
+
+        _math = new EegEmotionalMath(
+            config.MathLib,
+            config.ArtifactDetect,
+            config.ShortArtifactDetect,
+            config.MentalAndSpectral);
+
+        _math?.SetZeroSpectWaves(config.Active, config.delta, config.theta, config.alpha, config.beta, config.gamma);
+        _math?.SetWeightsForSpectra(config.delta_c, config.theta_c, config.alpha_c, config.beta_c, config.gamma_c);
+        _math?.SetCallibrationLength(config.CallibrationLength);
+        _math?.SetMentalEstimationMode(config.MentalEstimation);
+        _math?.SetPrioritySide(config.PrioritySide);
+        _math?.SetSkipWinsAfterArtifact(config.SkipWinsAfterArtifact);
+        _math?.SetSpectNormalizationByBandsWidth(config.SpectNormalizationByBandsWidth);
+        _math?.SetSpectNormalizationByCoeffs(config.SpectNormalizationByCoeffs);
+    }
+
+    public void Dispose() { _math.Dispose(); }
+
+    public void StartCalibration()
+    {
+        isCalibrated = false;
+        _math.StartCalibration();
+    }
+
+    public void ProcessData(BrainBitSignalData[] samples)
+    {
+        var bipolarSamples = new RawChannels[samples.Length];
+
+        for (var i = 0; i < samples.Length; i++)
+        {
+            bipolarSamples[i].LeftBipolar = samples[i].T3 - samples[i].O1;
+            bipolarSamples[i].RightBipolar = samples[i].T4 - samples[i].O2;
+        }
+
+        try
+        {
+            _math.PushData(bipolarSamples);
+            _math.ProcessDataArr();
+
+            resolveArtefacted();
+
+            if (!isCalibrated)
+            {
+                processCalibration();
+            }
+            else
+            {
+                resolveSpectralData();
+                resolveRawSpectralData();
+                resolveMindData();
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.ToString());
+        }
+    }
+
+    private void resolveArtefacted()
+    {
+        // sequence artifacts
+        bool isArtifactedSequence = _math.IsArtifactedSequence();
+        isArtefactedSequenceCallback?.Invoke(isArtifactedSequence);
+
+        // both sides artifacts
+        bool isBothSideArtifacted = _math.IsBothSidesArtifacted();
+        isBothSidesArtifactedCallback?.Invoke(isBothSideArtifacted);
+    }
+
+    private void processCalibration()
+    {
+        bool wasCalibrated = isCalibrated;
+        isCalibrated = _math.CalibrationFinished();
+
+        if (!isCalibrated)
+        {
+            int progress = _math.GetCallibrationPercents();
+            progressCalibrationCallback?.Invoke(progress);
+        }
+        else if (!wasCalibrated)
+        {
+            // Transition: just finished calibrating — emit 100% once
+            progressCalibrationCallback?.Invoke(100);
+        }
+    }
+
+    private void resolveSpectralData()
+    {
+        var spectralValues = _math?.ReadSpectralDataPercentsArr();
+        if (spectralValues.Length > 0)
+        {
+            var spectralVal = spectralValues.Last();
+            //if(spectralVal.Delta > 0)
+            lastSpectralDataCallback?.Invoke(spectralValues.Last());
+        }
+    }
+    private void resolveRawSpectralData()
+    {
+        var rawSpectralValues = _math.ReadRawSpectralVals();
+        rawSpectralDataCallback?.Invoke(rawSpectralValues);
+    }
+    private void resolveMindData()
+    {
+        var mentalValues = _math.ReadMentalDataArr();
+        if (mentalValues.Length > 0)
+        {
+            lastMindDataCallback?.Invoke(mentalValues.Last());
+        }
+    }
+
+}

package/Scripts/EmotionsController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0877a16ab18a1734bb4c2847f2aa94ba
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/LabFrame2023_Brainbit.asmdef

@@ -4,7 +4,8 @@
     "references": [
         "GUID:446fbb70571d4224d98108c0517d6b29",
         "GUID:a5a806c53ddbe413484b9d0109675c29",
-        "GUID:6055be8ebefd69e48b49212b09b47b2f"
+        "GUID:6055be8ebefd69e48b49212b09b47b2f",
+        "GUID:920348d3c44c9b44493d16cb002928b8"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.xrlab.labframe_brainbit",
-  "version": "1.0.9",
+  "version": "1.1.1",
   "displayName": "Lab Frame 2023 - BrainBit Plugin",
   "description": "BrainBit Support for LabFrame2023.\nNote: Currently only supports BrainBit in lab!!",
   "unity": "2022.3",