com.xrlab.labframe_brainbit 1.0.8 → 1.1.0

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

@@ -1,9 +1,11 @@
 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
+using System.Collections.Concurrent;
 using LabFrame2023;
 using UnityEngine.Events;
 using NeuroSDK;
+using SignalMath;
 using System;
 
 /// <summary>
@@ -42,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
@@ -69,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
@@ -91,6 +133,19 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
     private string _currentEEGTag = "eeg";
     // 用於記錄目前阻抗寫入資料的標籤
     private string _currentImpedanceTag = "impedance";
+
+    // 主執行緒派發佇列，用於將背景執行緒的回呼安全地轉移到主執行緒執行
+    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
@@ -119,11 +174,30 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
         LabTools.Log($"[BrainBit] Config - AutoSelectBestSignal: {_config.AutoSelectBestSignal}, ConnectDelay: {_config.ConnectDelaySeconds}s");
     }
 
+    /// <summary>
+    /// 每幀執行主執行緒佇列中的 Action（處理從背景執行緒派發過來的回呼）
+    /// </summary>
+    private void Update()
+    {
+        while (_mainThreadActions.TryDequeue(out var action))
+        {
+            try
+            {
+                action?.Invoke();
+            }
+            catch (Exception e)
+            {
+                LabTools.LogError($"[BrainBit] Error executing main thread action: {e.Message}");
+            }
+        }
+    }
+
     public IEnumerator ManagerDispose()
     {
         LabTools.Log("[BrainBit] Disposing BrainBit Manager...");
 
         // 停止所有數據流
+        StopEmotionsProcessing();
         StopEEGStream();
         StopImpedanceStream();
 
@@ -174,8 +248,11 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
         {
             LabTools.Log("[BrainBit] Starting device scan...");
 
-            // 根據 BrainBit SDK2 文檔，確保使用正確的 SensorFamily
-            _scanner = new Scanner(SensorFamily.SensorLEBrainBit);
+            // 重用 Scanner，避免重複建立造成 native 資源洩漏
+            if (_scanner == null)
+            {
+                _scanner = new Scanner(SensorFamily.SensorLEBrainBit);
+            }
             _scanner.EventSensorsChanged += OnSensorsFound;
 
             // 開始掃描
@@ -520,37 +597,46 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
 
     private void OnSensorsFound(IScanner scanner, IReadOnlyList<SensorInfo> sensors)
     {
+        // 此回呼由 NeuroSDK 在背景執行緒觸發！
+        // 必須將所有 Unity API 呼叫（StartCoroutine、StopCoroutine 等）派發到主執行緒
         try
         {
-            LabTools.Log($"[BrainBit] Found {sensors.Count} device(s)");
-
-            // 觸發設備發現事件
-            OnDeviceFound?.Invoke(new List<SensorInfo>(sensors));
+            LabTools.Log($"[BrainBit] Found {sensors.Count} device(s) (background thread)");
 
             if (sensors.Count > 0)
             {
-                // 重要：根據 BrainBit SDK 要求，必須先停止掃描才能建立連接
-                StopScan();
-
-                // 選擇要連接的設備
+                // 選擇要連接的設備（純邏輯，不涉及 Unity API，可以在背景執行緒執行）
                 SensorInfo targetSensor = SelectBestDevice(sensors);
-
                 LabTools.Log($"[BrainBit] Selected device: {targetSensor.Name} (RSSI: {targetSensor.RSSI})");
-                if (_scanTimeoutCoroutine != null)
+
+                // 先在背景緒停止 Scanner（SDK 層級，非 Unity API）
+                _scanner?.Stop();
+                _scanner.EventSensorsChanged -= OnSensorsFound;
+
+                // 將剩下的操作排入主執行緒執行
+                _mainThreadActions.Enqueue(() =>
                 {
-                    StopCoroutine(_scanTimeoutCoroutine);
-                    _scanTimeoutCoroutine = null;
-                    LabTools.Log("[BrainBit] Scan timeout coroutine stopped");
-                }
+                    IsScanning = false;
 
-                // 等待一段時間後建立連接（確保掃描完全停止）
-                StartCoroutine(DelayedConnect(targetSensor));
+                    // 觸發設備發現事件
+                    OnDeviceFound?.Invoke(new List<SensorInfo>(sensors));
+
+                    if (_scanTimeoutCoroutine != null)
+                    {
+                        StopCoroutine(_scanTimeoutCoroutine);
+                        _scanTimeoutCoroutine = null;
+                        LabTools.Log("[BrainBit] Scan timeout coroutine stopped");
+                    }
+
+                    // 等待一段時間後建立連接（確保掃描完全停止）
+                    StartCoroutine(DelayedConnect(targetSensor));
+                });
             }
         }
         catch (Exception e)
         {
             LabTools.LogError($"[BrainBit] Error in OnSensorsFound: {e.Message}");
-            OnError?.Invoke($"Device discovery error: {e.Message}");
+            _mainThreadActions.Enqueue(() => OnError?.Invoke($"Device discovery error: {e.Message}"));
         }
     }
 
@@ -612,6 +698,13 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
         {
             LabTools.Log($"[BrainBit] Connecting to device: {sensorInfo.Name} ({sensorInfo.Address})");
 
+            // 清理舊的 Sensor（如果有的話），避免 native 資源洩漏
+            if (_currentSensor != null)
+            {
+                try { _currentSensor.Dispose(); } catch (Exception) { }
+                _currentSensor = null;
+            }
+
             // 創建 Sensor（此時掃描已停止）
             _currentSensor = _scanner.CreateSensor(sensorInfo) as BrainBitSensor;
 
@@ -657,6 +750,7 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
             if (IsConnected)
             {
                 // 停止所有數據流
+                StopEmotionsProcessing();
                 StopEEGStream();
                 StopImpedanceStream();
 
@@ -716,20 +810,32 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
 
     private void OnSignalDataReceived(ISensor sensor, BrainBitSignalData[] data)
     {
+        // 此回呼由 NeuroSDK 在背景執行緒觸發！
         try
         {
             foreach (var packet in data)
             {
-                _lastEEGData = new BrainBit_EEGData(packet.T3, packet.T4, packet.O1, packet.O2);
-
-                // 觸發事件
-                OnEEGDataReceived?.Invoke(_lastEEGData);
+                var eegData = new BrainBit_EEGData(packet.T3, packet.T4, packet.O1, packet.O2);
+                _lastEEGData = eegData;
 
-                // 自動保存到 LabDataManager
-                if (_autoWriteEEGData && LabDataManager.Instance.IsInited)
+                // 將事件觸發和資料寫入排入主執行緒
+                _mainThreadActions.Enqueue(() =>
                 {
-                    LabDataManager.Instance.WriteData(_lastEEGData, _currentEEGTag);
-                }
+                    // 觸發事件（訂閱者可能更新 UI）
+                    OnEEGDataReceived?.Invoke(eegData);
+
+                    // 自動保存到 LabDataManager
+                    if (_autoWriteEEGData && LabDataManager.Instance.IsInited)
+                    {
+                        LabDataManager.Instance.WriteData(eegData, _currentEEGTag);
+                    }
+                });
+            }
+
+            // 情緒處理（寄生在同一條 NeuroSDK 背景緒，不開額外 thread）
+            if (IsProcessingEmotions)
+            {
+                _emotionsController?.ProcessData(data);
             }
         }
         catch (Exception e)
@@ -740,24 +846,30 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
 
     private void OnResistanceDataReceived(ISensor sensor, BrainBitResistData data)
     {
+        // 此回呼由 NeuroSDK 在背景執行緒觸發！
         try
         {
-            _lastImpedanceData = new BrainBit_ImpedanceData(data.T3, data.T4, data.O1, data.O2);
-
-            // 觸發事件
-            OnImpedanceDataReceived?.Invoke(_lastImpedanceData);
+            var impedanceData = new BrainBit_ImpedanceData(data.T3, data.T4, data.O1, data.O2);
+            _lastImpedanceData = impedanceData;
 
-            // 檢查阻抗警告: 當有任一通道阻抗超過 200,000 時
-            if (!_lastImpedanceData.IsImpedanceGood)
+            // 將事件觸發和資料寫入排入主執行緒
+            _mainThreadActions.Enqueue(() =>
             {
-                LabTools.LogError($"[BrainBit] High impedance detected: {_lastImpedanceData.GetImpedanceStatus()}");
-            }
+                // 觸發事件（訂閱者可能更新 UI）
+                OnImpedanceDataReceived?.Invoke(impedanceData);
 
-            // 自動保存到 LabDataManager
-            if (_autoWriteImpedanceData && LabDataManager.Instance.IsInited)
-            {
-                LabDataManager.Instance.WriteData(_lastImpedanceData, _currentImpedanceTag);
-            }
+                // 檢查阻抗警告: 當有任一通道阻抗超過 200,000 時
+                if (!impedanceData.IsImpedanceGood)
+                {
+                    LabTools.LogError($"[BrainBit] High impedance detected: {impedanceData.GetImpedanceStatus()}");
+                }
+
+                // 自動保存到 LabDataManager
+                if (_autoWriteImpedanceData && LabDataManager.Instance.IsInited)
+                {
+                    LabDataManager.Instance.WriteData(impedanceData, _currentImpedanceTag);
+                }
+            });
         }
         catch (Exception e)
         {
@@ -785,6 +897,16 @@ public class BrainBitManager : LabSingleton<BrainBitManager>, IManager
                 _currentSensor = null;
             }
 
+            // 清理情緒控制器
+            if (_emotionsController != null)
+            {
+                UnwireEmotionsCallbacks();
+                _emotionsController.Dispose();
+                _emotionsController = null;
+            }
+            IsProcessingEmotions = false;
+            IsEmotionsCalibrated = false;
+
             // 重置狀態
             IsConnected = false;
             IsStreamingEEG = false;
@@ -799,4 +921,233 @@ 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 (!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.8",
+  "version": "1.1.0",
   "displayName": "Lab Frame 2023 - BrainBit Plugin",
   "description": "BrainBit Support for LabFrame2023.\nNote: Currently only supports BrainBit in lab!!",
   "unity": "2022.3",