ims_device.py

"""
IMS-SDデバイス接続管理モジュール
"""

import time
from typing import Optional, Tuple
from serial_comm import SerialCommunication
from enum import Enum

class DeviceStatus(Enum):
    """デバイス状態"""
    NO_DEVICE = "NoDevice"
    INITIALIZE = "Initialize"
    IDLE = "IDLE"
    MEASURE = "MEASURE"
    EXT = "EXT"
    LOAD_DATA = "LOAD_DATA"
    ERR = "ERR"

class ImsDevice:
    """IMS-SDデバイス接続クラス"""

    def __init__(self):
        self.serial = SerialCommunication()
        self.status = DeviceStatus.NO_DEVICE
        self.is_connected = False

        # デバイス情報
        self.serial_number = ""
        self.version = ""
        self.step_number = 0
        self.model = "HighEnd"  # モデル (Standard/HighEnd)
        self.device_type = ""   # デバイスタイプ

        # センサー設定
        self.frequency = 100  # 測定周波数 [Hz]
        self.matome_pc = 1    # PCまとめ数
        self.matome_sd = 1    # SDまとめ数
        self.acc_range = 2    # 加速度レンジ [G]
        self.gyro_range = 4000 # ジャイロレンジ [deg/s]
        self.acc_bw = 250     # 加速度センサーバンド帯域 [Hz]
        self.gyro_bw = 200    # ジャイロセンサーバンド帯域 [Hz]
        self.save_to_flash = False  # SD保存有効/無効
        self.sd_exist = False # SDカード有無
        self.header = ""      # ファイルヘッダ
        self.save_time = 0    # 保存時間 [秒]
        self.soc_meas_stop_en = False  # 電池残量で測定停止する機能の有効/無効
        self.meas_stop_soc = 0         # 測定停止する電池残量 [%]
        self.pwr_on_st_en = False      # 電源オン時測定開始機能の有効/無効
        self.save_interval = 0         # データ保存間隔 [秒]
        self.error_code = ""           # エラーコード

        # 校正値（辞書形式で格納）
        self.acc_prf = {}     # 加速度校正値 {range: {axis: value}}
        self.acc_zero = {}    # 加速度ゼロ点 {range: {axis: value}}
        self.acc_itf = {}     # 加速度干渉補正 {range: [9個の値]}
        self.gyro_prf = {}    # ジャイロ校正値 {range: {axis: value}}
        self.gyro_zero = {}   # ジャイロゼロ点 {range: {axis: value}}
        self.gyro_itf = {}    # ジャイロ干渉補正 {range: [9個の値]}
        self.mag_zero = {}    # 地磁気ゼロ点 {axis: value}
        self.mag_prf = {}     # 地磁気校正値 {axis: value}
        self.mag_itf = []     # 地磁気干渉補正 [9個の値]
        self.mag_offzero = {} # 地磁気OFFSETZERO {axis: value}
        self.mag_off = {}     # 地磁気OFFSET {axis: value}
        self.mag_fineout = {} # 地磁気FINEOUTPUT {axis: value}
        self.mag_sens = {}    # 地磁気SENSITIVITY {axis: value}
        self.mag_gainpara = [] # 地磁気GAINPARA [6個の値]

    def connect(self, port_name: str) -> bool:
        """
        デバイスに接続

        Args:
            port_name: COMポート名 (例: "COM3")

        Returns:
            bool: 接続成功時True
        """
        print(f"接続処理開始: {port_name}")

        # ポートオープン
        if not self.serial.open_port(port_name):
            print("ポートオープンに失敗")
            self.status = DeviceStatus.NO_DEVICE
            return False

        self.status = DeviceStatus.INITIALIZE
        print("ポートオープン成功")

        # 測定中や処理中の場合を考慮してSTOP/LOAD_STOPコマンド送信
        self._send_command("STOP")
        self._send_command("LOAD_STOP")

        # 未受信データが送信される可能性があるため500ms待機後バッファクリア
        time.sleep(0.5)
        self.serial.clear_buffers()

        # デバイスパラメータ取得
        print("デバイスパラメータ取得開始")
        if self._get_parameters():
            print("デバイスパラメータ取得成功")
            self.status = DeviceStatus.IDLE
            self.is_connected = True
            return True
        else:
            print("デバイスパラメータ取得失敗")
            self.disconnect()
            return False

    def disconnect(self) -> bool:
        """
        デバイスから切断

        Returns:
            bool: 切断成功時True
        """
        if self.is_connected:
            self._send_command("STOP")
            self._send_command("LOAD_STOP")
            time.sleep(0.1)

        result = self.serial.close_port()
        self.status = DeviceStatus.NO_DEVICE
        self.is_connected = False

        # デバイス情報クリア
        self.serial_number = ""
        self.version = ""
        self.step_number = 0

        return result

    def _send_command(self, command: str) -> bool:
        """
        コマンド送信（内部使用）

        Args:
            command: 送信するコマンド文字列

        Returns:
            bool: 送信成功時True
        """
        # コマンドは改行(LF)で終端
        data = (command + "\n").encode('ascii')
        return self.serial.write_bytes(data)

    def _read_response(self, timeout: float = 1.0) -> Optional[str]:
        """
        レスポンス読み込み（内部使用）

        Args:
            timeout: タイムアウト時間（秒）

        Returns:
            str: レスポンス文字列、タイムアウト時None
        """
        start_time = time.time()
        response = b''

        while time.time() - start_time < timeout:
            data = self.serial.read_available()
            if data:
                response += data
                # 改行で終端されたら完了
                if b'\n' in response:
                    try:
                        return response.decode('ascii').strip()
                    except:
                        return None
            time.sleep(0.01)

        return None

    def _send_and_receive(self, command: str, timeout: float = 1.0) -> Tuple[bool, str]:
        """
        コマンド送信とレスポンス受信

        Args:
            command: 送信するコマンド
            timeout: タイムアウト時間（秒）

        Returns:
            Tuple[bool, str]: (成功フラグ, レスポンス文字列)
        """
        # バッファクリア
        self.serial.clear_buffers()

        # コマンド送信
        if not self._send_command(command):
            return (False, "")

        # レスポンス受信
        response = self._read_response(timeout)
        if response is None:
            return (False, "")

        return (True, response)

    def _get_parameters(self) -> bool:
        """
        デバイスパラメータ取得

        Returns:
            bool: 取得成功時True
        """
        # STATUS取得でデバイス状態確認
        success, status_response = self._send_and_receive("GET_STATUS")
        if success and status_response.startswith("STATUS_"):
            status = status_response.replace("STATUS_", "")
            print(f"デバイス状態: {status}")

            # MEASURE、EXTの場合はSTOPコマンド送信
            if status in ["MEASURE", "EXT"]:
                self._send_command("STOP")
                time.sleep(0.1)

            # LOAD_DATAの場合はLOAD_STOPコマンド送信
            if status == "LOAD_DATA":
                self._send_command("LOAD_STOP")
                time.sleep(0.1)
        else:
            print("STATUS取得失敗")
            return False

        # 基本情報取得
        if not self._get_serial():
            return False

        if not self._get_version():
            return False

        # バージョンチェック（2.2.0未満はエラー）
        if not self._check_version():
            return False

        # モデル取得
        if not self._get_model():
            return False

        # モデルチェック（HighEndでない場合はエラー）
        if not self._check_model():
            return False

        # ステップ番号取得
        if not self._get_step_number():
            return False

        # 共通パラメータ取得
        if not self._get_frequency():
            return False

        if not self._get_matome():
            return False

        # センサー設定取得
        if not self._get_sensor_range():
            return False

        # 校正値取得
        if not self._get_calibration_values():
            return False

        # SD保存設定取得
        if not self._get_save_settings():
            return False

        if not self._get_header():
            return False

        if not self._get_save_time():
            return False

        # 電池管理設定取得
        if not self._get_soc_meas_stop_en():
            return False

        if not self._get_meas_stop_soc():
            return False

        # デバイスタイプ取得
        if not self._get_device_type():
            return False

        # ICMセンサー帯域設定
        success, response = self._send_and_receive("GET_ICM_ACC_BW")
        if success and response.startswith("ICM_ACC_BW_"):
            try:
                bw_code = int(response.replace("ICM_ACC_BW_", ""))
                bw_map = {0: 50, 1: 110, 2: 250, 3: 500}
                self.acc_bw = bw_map.get(bw_code, 250)
                print(f"加速度バンド帯域: {self.acc_bw} Hz")
            except:
                return False
        else:
            return False

        success, response = self._send_and_receive("GET_ICM_GYRO_BW")
        if success and response.startswith("ICM_GYRO_BW_"):
            try:
                bw_code = int(response.replace("ICM_GYRO_BW_", ""))
                bw_map = {0: 50, 1: 120, 2: 200, 3: 400}
                self.gyro_bw = bw_map.get(bw_code, 200)
                print(f"ジャイロバンド帯域: {self.gyro_bw} Hz")
            except:
                return False
        else:
            return False

        # 地磁気追加パラメータ取得
        if not self._get_mag_additional_params():
            return False

        # 地磁気センサーオフセット値調整
        is_over_range = False
        for axis in ['X', 'Y', 'Z']:
            if axis in self.mag_off:
                offset_value = self.mag_off[axis]
                if offset_value < 35 or 55 < offset_value:
                    is_over_range = True
                    break

        # 電源オン時測定開始機能取得
        if not self._get_pwr_on_st_en():
            return False

        # データ保存間隔取得
        if not self._get_save_interval():
            return False

        # 地磁気オフセット値調整処理
        if is_over_range:
            print("地磁気オフセット値が範囲外のため調整が必要です")
            print("オフセット値調整処理を開始")

            # オフセット値が大きい場合の調整コマンド（3回実行）
            for count in range(3):
                print(f"MAG_WINDOW実行 ({count + 1}/3)")
                if self._send_command("MAG_WINDOW"):
                    print("MAG_WINDOW成功")
                else:
                    print("MAG_WINDOW失敗")
                    break
                time.sleep(0.1)

            # 調整後のオフセット値を再取得
            print("オフセット値を再取得")
            if self._get_mag_off():
                print("オフセット値調整完了")
            else:
                print("オフセット値再取得失敗")

        # ステータス取得
        if not self._get_status():
            return False

        # エラー取得
        if not self._get_error():
            return False

        return True

    def _get_serial(self) -> bool:
        """シリアル番号取得"""
        success, response = self._send_and_receive("GET_SERIAL")
        if success and response.startswith("SERIAL_"):
            self.serial_number = response.replace("SERIAL_", "")
            print(f"シリアル番号: {self.serial_number}")
            return True
        return False

    def _get_version(self) -> bool:
        """バージョン取得"""
        success, response = self._send_and_receive("GET_VERSION")
        if success and response.startswith("VERSION_"):
            self.version = response.replace("VERSION_", "")
            print(f"バージョン: {self.version}")
            return True
        return False

    def _get_step_number(self) -> bool:
        """ステップ番号取得"""
        success, response = self._send_and_receive("GET_STEP_NUMBER")
        if success and response.startswith("STEP_NUMBER_"):
            try:
                self.step_number = int(response.replace("STEP_NUMBER_", ""))
                print(f"ステップ番号: {self.step_number}")
                return True
            except Exception as e:
                print(f"ステップ番号変換エラー: {e}")
        return False

    def _get_device_type(self) -> bool:
        """デバイスタイプ取得"""
        success, response = self._send_and_receive("GET_TYPE")
        if success and response.startswith("TYPE_"):
            self.device_type = response.replace("TYPE_", "")
            print(f"デバイスタイプ: {self.device_type}")
            return True
        return False

    def _get_model(self) -> bool:
        """モデル取得"""
        success, response = self._send_and_receive("GET_MS_SD_MODEL")
        if success and response.startswith("MS_SD_MODEL_"):
            try:
                model_code = int(response.replace("MS_SD_MODEL_", ""))
                if model_code == 0:
                    self.model = "Standard"
                elif model_code == 1:
                    self.model = "HighEnd"
                else:
                    self.model = "Unknown"
                print(f"モデル: {self.model}")
                return True
            except:
                pass
        return False

    def _check_version(self) -> bool:
        """バージョンチェック（2.2.0未満はエラー）"""
        try:
            # "Ver.2.2.0" の形式から数値部分を抽出
            version_str = self.version.replace("Ver.", "").strip()
            version_parts = version_str.split(".")

            if len(version_parts) >= 3:
                major = int(version_parts[0])
                minor = int(version_parts[1])
                patch = int(version_parts[2])

                # 2.2.0未満かチェック
                if major < 2 or (major == 2 and minor < 2):
                    print(f"エラー: バージョン {self.version} は対応していません（2.2.0以上が必要）")
                    return False

                print(f"バージョンチェック: OK ({self.version})")
                return True
            else:
                print(f"エラー: バージョン形式が不正です ({self.version})")
                return False

        except Exception as e:
            print(f"エラー: バージョンチェック失敗 ({e})")
            return False

    def _check_model(self) -> bool:
        """モデルチェック（HighEndでない場合はエラー）"""
        if self.model != "HighEnd":
            print(f"エラー: モデル {self.model} は対応していません（HighEndが必要）")
            return False

        print(f"モデルチェック: OK ({self.model})")
        return True

    def _get_calibration_values(self) -> bool:
        """校正値取得"""
        # 加速度校正値取得
        if not self._get_acc_prf():
            return False

        # 加速度ゼロ点取得
        if not self._get_acc_zero():
            return False

        # 加速度干渉補正取得
        if not self._get_acc_itf():
            return False

        # ジャイロ校正値取得
        if not self._get_gyro_prf():
            return False

        # ジャイロゼロ点取得
        if not self._get_gyro_zero():
            return False

        # ジャイロ干渉補正取得
        if not self._get_gyro_itf():
            return False

        # 地磁気ゼロ点取得
        if not self._get_mag_zero():
            return False

        # 地磁気校正値取得
        if not self._get_mag_prf():
            return False

        # 地磁気干渉補正取得
        if not self._get_mag_itf():
            return False

        # 地磁気追加パラメータ取得
        if not self._get_mag_additional_params():
            return False

        return True

    def _get_acc_prf(self) -> bool:
        """加速度校正値取得"""
        success, response = self._send_and_receive("GET_ACC_PRF")
        if success and response.startswith("ACC_PRF_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                data_str = response.replace("ACC_PRF_", "")
                values = [float(x.strip()) for x in data_str.split(",")]

                # レンジ×軸の組み合わせで格納
                ranges = [2, 4, 8, 16, 30]  # G2, G4, G8, G16, G30
                axes = ['X', 'Y', 'Z']

                self.acc_prf = {}
                for i, range_val in enumerate(ranges):
                    if self.model == "Standard" and range_val == 30:
                        continue  # Standardモデルは30Gなし

                    self.acc_prf[range_val] = {}
                    for j, axis in enumerate(axes):
                        idx = i * 3 + j
                        if idx < len(values):
                            self.acc_prf[range_val][axis] = values[idx]

                print(f"加速度校正値取得完了 ({len(values)}個)")
                return True
            except Exception as e:
                print(f"加速度校正値解析エラー: {e}")
                pass
        return False

    def _get_acc_zero(self) -> bool:
        """加速度ゼロ点取得"""
        success, response = self._send_and_receive("GET_ACC_ZERO")
        if success and response.startswith("ACC_ZERO_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                data_str = response.replace("ACC_ZERO_", "")
                values = [float(x.strip()) for x in data_str.split(",")]

                # レンジ×軸の組み合わせで格納
                ranges = [2, 4, 8, 16, 30]  # G2, G4, G8, G16, G30
                axes = ['X', 'Y', 'Z']

                self.acc_zero = {}
                for i, range_val in enumerate(ranges):
                    if self.model == "Standard" and range_val == 30:
                        continue  # Standardモデルは30Gなし

                    self.acc_zero[range_val] = {}
                    for j, axis in enumerate(axes):
                        idx = i * 3 + j
                        if idx < len(values):
                            self.acc_zero[range_val][axis] = values[idx]

                print(f"加速度ゼロ点取得完了 ({len(values)}個)")
                return True
            except Exception as e:
                print(f"加速度ゼロ点解析エラー: {e}")
                pass
        return False

    def _get_acc_itf(self) -> bool:
        """加速度干渉補正取得"""
        ranges = [2, 4, 8, 16, 30]  # G2, G4, G8, G16, G30
        range_codes = [0, 1, 2, 3, 4]  # コマンドで使用するコード

        self.acc_itf = {}

        for i, range_val in enumerate(ranges):
            if self.model == "Standard" and range_val == 30:
                continue  # Standardモデルは30Gなし

            # コマンド形式: GET_ACC_ITF_<range_code>
            success, response = self._send_and_receive(f"GET_ACC_ITF_{range_codes[i]}")
            if success and response.startswith("ACC_ITF_"):
                try:
                    # データ部分を抽出（カンマ区切りの数値）
                    # レスポンス形式: ACC_ITF_1,0,0,0,1,0,0,0,1 (ヘッダー + 9個のパラメータ)
                    data_part = response.replace("ACC_ITF_", "")  # ヘッダーを除去
                    values = [float(x.strip()) for x in data_part.split(",")]  # 9個のパラメータ
                    if len(values) == 9:  # 9個のパラメータ
                        self.acc_itf[range_val] = values

                except Exception as e:
                    print(f"加速度干渉補正解析エラー (±{range_val}G): {e}")
                    return False
            else:
                print(f"加速度干渉補正取得失敗 (±{range_val}G)")
                return False

        print(f"加速度干渉補正取得完了 ({len(self.acc_itf)}レンジ)")
        return True

    def _get_gyro_prf(self) -> bool:
        """ジャイロ校正値取得"""
        success, response = self._send_and_receive("GET_GYRO_PRF")
        if success and response.startswith("GYRO_PRF_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                data_str = response.replace("GYRO_PRF_", "")
                values = [float(x.strip()) for x in data_str.split(",")]

                # レンジ×軸の組み合わせで格納
                ranges = [125, 250, 500, 1000, 2000, 4000]  # deg/s
                axes = ['X', 'Y', 'Z']

                self.gyro_prf = {}
                for i, range_val in enumerate(ranges):
                    self.gyro_prf[range_val] = {}
                    for j, axis in enumerate(axes):
                        idx = i * 3 + j
                        if idx < len(values):
                            self.gyro_prf[range_val][axis] = values[idx]

                print(f"ジャイロ校正値取得完了 ({len(values)}個)")
                return True
            except Exception as e:
                print(f"ジャイロ校正値解析エラー: {e}")
                pass
        return False

    def _get_gyro_zero(self) -> bool:
        """ジャイロゼロ点取得"""
        success, response = self._send_and_receive("GET_GYRO_ZERO")
        if success and response.startswith("GYRO_ZERO_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                data_str = response.replace("GYRO_ZERO_", "")
                values = [float(x.strip()) for x in data_str.split(",")]

                # レンジ×軸の組み合わせで格納
                ranges = [125, 250, 500, 1000, 2000, 4000]  # deg/s
                axes = ['X', 'Y', 'Z']

                self.gyro_zero = {}
                for i, range_val in enumerate(ranges):
                    self.gyro_zero[range_val] = {}
                    for j, axis in enumerate(axes):
                        idx = i * 3 + j
                        if idx < len(values):
                            self.gyro_zero[range_val][axis] = values[idx]

                print(f"ジャイロゼロ点取得完了 ({len(values)}個)")
                return True
            except Exception as e:
                print(f"ジャイロゼロ点解析エラー: {e}")
                pass
        return False

    def _get_gyro_itf(self) -> bool:
        """ジャイロ干渉補正取得"""
        ranges = [125, 250, 500, 1000, 2000, 4000]  # deg/s
        range_codes = [0, 1, 2, 3, 4, 5]  # コマンドで使用するコード

        self.gyro_itf = {}

        for i, range_val in enumerate(ranges):
            # コマンド形式: GET_GYRO_ITF_<range_code>
            success, response = self._send_and_receive(f"GET_GYRO_ITF_{range_codes[i]}")
            if success and response.startswith("GYRO_ITF_"):
                try:
                    # データ部分を抽出（カンマ区切りの数値）
                    # レスポンス形式: GYRO_ITF_1,0,0,0,1,0,0,0,1 (ヘッダー + 9個のパラメータ)
                    data_part = response.replace("GYRO_ITF_", "")  # ヘッダーを除去
                    values = [float(x.strip()) for x in data_part.split(",")]  # 9個のパラメータ
                    if len(values) == 9:  # 9個のパラメータ
                        self.gyro_itf[range_val] = values

                except Exception as e:
                    print(f"ジャイロ干渉補正解析エラー (±{range_val}deg/s): {e}")
                    return False
            else:
                print(f"ジャイロ干渉補正取得失敗 (±{range_val}deg/s)")
                return False

        print(f"ジャイロ干渉補正取得完了 ({len(self.gyro_itf)}レンジ)")
        return True

    def _get_mag_zero(self) -> bool:
        """地磁気ゼロ点取得"""
        success, response = self._send_and_receive("GET_MAG_ZERO")
        if success and response.startswith("MAG_ZERO_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                # レスポンス形式: MAG_ZERO_x,x,x (X, Y, Z軸)
                data_str = response.replace("MAG_ZERO_", "")
                values = [float(x.strip()) for x in data_str.split(",")]

                if len(values) == 3:  # X, Y, Z軸
                    axes = ['X', 'Y', 'Z']
                    self.mag_zero = {}
                    for i, axis in enumerate(axes):
                        self.mag_zero[axis] = values[i]

                    print(f"地磁気ゼロ点取得完了 ({len(values)}軸)")
                    return True
            except Exception as e:
                print(f"地磁気ゼロ点解析エラー: {e}")
                pass
        return False

    def _get_mag_prf(self) -> bool:
        """地磁気校正値取得"""
        success, response = self._send_and_receive("GET_MAG_PRF")
        if success and response.startswith("MAG_PRF_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                # レスポンス形式: MAG_PRF_x,x,x (X, Y, Z軸)
                data_str = response.replace("MAG_PRF_", "")
                values = [float(x.strip()) for x in data_str.split(",")]

                if len(values) == 3:  # X, Y, Z軸
                    axes = ['X', 'Y', 'Z']
                    self.mag_prf = {}
                    for i, axis in enumerate(axes):
                        self.mag_prf[axis] = values[i]

                    print(f"地磁気校正値取得完了 ({len(values)}軸)")
                    return True
            except Exception as e:
                print(f"地磁気校正値解析エラー: {e}")
                pass
        return False

    def _get_mag_itf(self) -> bool:
        """地磁気干渉補正取得"""
        success, response = self._send_and_receive("GET_MAG_ITF")
        if success and response.startswith("MAG_ITF_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                # レスポンス形式: MAG_ITF_x,x,x,x,x,x,x,x,x (9個のパラメータ)
                data_part = response.replace("MAG_ITF_", "")  # ヘッダーを除去
                values = [float(x.strip()) for x in data_part.split(",")]  # 9個のパラメータ
                if len(values) == 9:  # 9個のパラメータ
                    self.mag_itf = values
                    print(f"地磁気干渉補正取得完了 (9パラメータ)")
                    return True

            except Exception as e:
                print(f"地磁気干渉補正解析エラー: {e}")
                return False
        else:
            print("地磁気干渉補正取得失敗")
            return False

    def _get_mag_additional_params(self) -> bool:
        """地磁気追加パラメータ取得"""
        # OFFSETZERO取得
        if not self._get_mag_offzero():
            return False

        # OFFSET取得
        if not self._get_mag_off():
            return False

        # FINEOUTPUT取得
        if not self._get_mag_fineout():
            return False

        # SENSITIVITY取得
        if not self._get_mag_sens():
            return False

        # GAINPARA取得
        if not self._get_mag_gainpara():
            return False

        return True

    def _get_mag_offzero(self) -> bool:
        """地磁気OFFSETZERO取得"""
        success, response = self._send_and_receive("GET_MAG_OFFZERO")
        if success and response.startswith("MAG_OFFZERO_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                # レスポンス形式: MAG_OFFZERO_x,x,x (X, Y, Z軸)
                data_str = response.replace("MAG_OFFZERO_", "")
                values = [float(x.strip()) for x in data_str.split(",")]

                if len(values) == 3:  # X, Y, Z軸
                    axes = ['X', 'Y', 'Z']
                    self.mag_offzero = {}
                    for i, axis in enumerate(axes):
                        self.mag_offzero[axis] = values[i]

                    print(f"地磁気OFFSETZERO取得完了 ({len(values)}軸)")
                    return True
            except Exception as e:
                print(f"地磁気OFFSETZERO解析エラー: {e}")
                pass
        return False

    def _get_mag_off(self) -> bool:
        """地磁気OFFSET取得"""
        success, response = self._send_and_receive("GET_MAG_OFF")
        if success and response.startswith("MAG_OFF_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                # レスポンス形式: MAG_OFF_x,x,x (X, Y, Z軸)
                data_str = response.replace("MAG_OFF_", "")
                values = [float(x.strip()) for x in data_str.split(",")]

                if len(values) == 3:  # X, Y, Z軸
                    axes = ['X', 'Y', 'Z']
                    self.mag_off = {}
                    for i, axis in enumerate(axes):
                        self.mag_off[axis] = values[i]

                    print(f"地磁気OFFSET取得完了 ({len(values)}軸)")
                    return True
            except Exception as e:
                print(f"地磁気OFFSET解析エラー: {e}")
                pass
        return False

    def _get_mag_fineout(self) -> bool:
        """地磁気FINEOUTPUT取得"""
        success, response = self._send_and_receive("GET_MAG_FINEOUT")
        if success and response.startswith("MAG_FINEOUT_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                # レスポンス形式: MAG_FINEOUT_x,x,x (X, Y, Z軸)
                data_str = response.replace("MAG_FINEOUT_", "")
                values = [float(x.strip()) for x in data_str.split(",")]

                if len(values) == 3:  # X, Y, Z軸
                    axes = ['X', 'Y', 'Z']
                    self.mag_fineout = {}
                    for i, axis in enumerate(axes):
                        self.mag_fineout[axis] = values[i]

                    print(f"地磁気FINEOUTPUT取得完了 ({len(values)}軸)")
                    return True
            except Exception as e:
                print(f"地磁気FINEOUTPUT解析エラー: {e}")
                pass
        return False

    def _get_mag_sens(self) -> bool:
        """地磁気SENSITIVITY取得"""
        success, response = self._send_and_receive("GET_MAG_SENS")
        if success and response.startswith("MAG_SENS_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                # レスポンス形式: MAG_SENS_x,x,x (X, Y, Z軸)
                data_str = response.replace("MAG_SENS_", "")
                values = [float(x.strip()) for x in data_str.split(",")]

                if len(values) == 3:  # X, Y, Z軸
                    axes = ['X', 'Y', 'Z']
                    self.mag_sens = {}
                    for i, axis in enumerate(axes):
                        self.mag_sens[axis] = values[i]

                    print(f"地磁気SENSITIVITY取得完了 ({len(values)}軸)")
                    return True
            except Exception as e:
                print(f"地磁気SENSITIVITY解析エラー: {e}")
                pass
        return False

    def _get_mag_gainpara(self) -> bool:
        """地磁気GAINPARA取得"""
        success, response = self._send_and_receive("GET_MAG_GAINPARA")
        if success and response.startswith("MAG_GAINPARA_"):
            try:
                # データ部分を抽出（カンマ区切りの数値）
                # レスポンス形式: MAG_GAINPARA_x,x,x,x,x,x (6個のパラメータ)
                data_part = response.replace("MAG_GAINPARA_", "")  # ヘッダーを除去
                values = [float(x.strip()) for x in data_part.split(",")]  # 6個のパラメータ
                if len(values) == 6:  # 6個のパラメータ
                    self.mag_gainpara = values
                    print(f"地磁気GAINPARA取得完了 (6パラメータ)")
                    return True

            except Exception as e:
                print(f"地磁気GAINPARA解析エラー: {e}")
                return False
        else:
            print("地磁気GAINPARA取得失敗")
            return False

    def _get_frequency(self) -> bool:
        """測定周波数取得"""
        success, response = self._send_and_receive("GET_FREQUENCY")
        if success and response.startswith("FREQUENCY_"):
            try:
                self.frequency = int(response.replace("FREQUENCY_", ""))
                print(f"測定周波数: {self.frequency} Hz")
                return True
            except:
                pass
        return False

    def _get_matome(self) -> bool:
        """まとめ数取得"""
        # PCまとめ数
        success, response = self._send_and_receive("GET_MATOME")
        if success and response.startswith("MATOME_"):
            try:
                self.matome_pc = int(response.replace("MATOME_", ""))
                print(f"PCまとめ数: {self.matome_pc}")
            except:
                return False
        else:
            return False

        # SDまとめ数
        success, response = self._send_and_receive("GET_MATOME_SD")
        if success and response.startswith("MATOME_SD_"):
            try:
                self.matome_sd = int(response.replace("MATOME_SD_", ""))
                print(f"SDまとめ数: {self.matome_sd}")
                return True
            except:
                pass
        return False

    def _get_sensor_range(self) -> bool:
        """センサーレンジ取得"""
        # 加速度レンジ
        success, response = self._send_and_receive("GET_ACC_RANGE")
        if success and response.startswith("ACC_RANGE_"):
            try:
                range_code = int(response.replace("ACC_RANGE_", ""))
                # コード変換: 0=2G, 1=4G, 2=8G, 3=16G, 4=30G
                range_map = {0: 2, 1: 4, 2: 8, 3: 16, 4: 30}
                self.acc_range = range_map.get(range_code, 2)
                print(f"加速度レンジ: ±{self.acc_range} G")
            except:
                return False
        else:
            return False

        # ジャイロレンジ
        success, response = self._send_and_receive("GET_GYRO_RANGE")
        if success and response.startswith("GYRO_RANGE_"):
            try:
                range_code = int(response.replace("GYRO_RANGE_", ""))
                # コード変換: 0=125, 1=250, 2=500, 3=1000, 4=2000, 5=4000
                range_map = {0: 125, 1: 250, 2: 500, 3: 1000, 4: 2000, 5: 4000}
                self.gyro_range = range_map.get(range_code, 250)
                print(f"ジャイロレンジ: ±{self.gyro_range} deg/s")
                return True
            except:
                return False
        else:
            return False

    def _get_save_settings(self) -> bool:
        """SD保存設定取得"""
        # SD保存設定
        success, response = self._send_and_receive("GET_SAVE_TO_FLASH")
        if success and response.startswith("SAVE_TO_FLASH_"):
            try:
                value = int(response.replace("SAVE_TO_FLASH_", ""))
                self.save_to_flash = (value == 1)
                print(f"SD保存: {'有効' if self.save_to_flash else '無効'}")
            except:
                return False
        else:
            return False

        # SDカード有無
        success, response = self._send_and_receive("GET_SD_EXIST")
        if success and response.startswith("SD_EXIST_"):
            try:
                value = int(response.replace("SD_EXIST_", ""))
                self.sd_exist = (value == 1)
                print(f"SDカード: {'あり' if self.sd_exist else 'なし'}")
                return True
            except:
                pass
        return False

    def _get_header(self) -> bool:
        """ファイルヘッダ取得"""
        success, response = self._send_and_receive("GET_HEADER")
        if success and response.startswith("HEADER_"):
            self.header = response.replace("HEADER_", "")
            print(f"ファイルヘッダ: {self.header}")
            return True
        return False

    def _get_save_time(self) -> bool:
        """保存時間取得"""
        success, response = self._send_and_receive("GET_SAVE_TIME")
        if success and response.startswith("SAVE_TIME_"):
            try:
                self.save_time = int(response.replace("SAVE_TIME_", ""))
                print(f"保存時間: {self.save_time} 秒")
                return True
            except Exception as e:
                print(f"保存時間変換エラー: {e}")
        return False

    def _get_soc_meas_stop_en(self) -> bool:
        """電池残量測定停止機能取得"""
        success, response = self._send_and_receive("GET_SOC_MEAS_STOP_EN")
        if success and response.startswith("SOC_MEAS_STOP_EN_"):
            try:
                value = int(response.replace("SOC_MEAS_STOP_EN_", ""))
                self.soc_meas_stop_en = (value == 1)
                print(f"電池残量測定停止機能: {'有効' if self.soc_meas_stop_en else '無効'}")
                return True
            except Exception as e:
                print(f"電池残量測定停止機能変換エラー: {e}")
        return False

    def _get_meas_stop_soc(self) -> bool:
        """測定停止電池残量取得"""
        success, response = self._send_and_receive("GET_MEAS_STOP_SOC")
        if success and response.startswith("MEAS_STOP_SOC_"):
            try:
                self.meas_stop_soc = int(response.replace("MEAS_STOP_SOC_", ""))
                print(f"測定停止電池残量: {self.meas_stop_soc} %")
                return True
            except Exception as e:
                print(f"測定停止電池残量変換エラー: {e}")
        return False

    def _get_pwr_on_st_en(self) -> bool:
        """電源オン時測定開始機能取得"""
        success, response = self._send_and_receive("GET_PWR_ON_ST_EN")
        if success and response.startswith("PWR_ON_ST_EN_"):
            try:
                value = int(response.replace("PWR_ON_ST_EN_", ""))
                self.pwr_on_st_en = (value == 1)
                print(f"電源オン時測定開始機能: {'有効' if self.pwr_on_st_en else '無効'}")
                return True
            except Exception as e:
                print(f"電源オン時測定開始機能変換エラー: {e}")
        return False

    def _get_save_interval(self) -> bool:
        """データ保存間隔取得"""
        success, response = self._send_and_receive("GET_SAVE_INTERVAL")
        if success and response.startswith("SAVE_INTERVAL_"):
            try:
                self.save_interval = int(response.replace("SAVE_INTERVAL_", ""))
                print(f"データ保存間隔: {self.save_interval} 秒")
                return True
            except Exception as e:
                print(f"データ保存間隔変換エラー: {e}")
        return False

    def _get_status(self) -> bool:
        """ステータス取得"""
        success, response = self._send_and_receive("GET_STATUS")
        if success and response.startswith("STATUS_"):
            status = response.replace("STATUS_", "")
            # DeviceStatusのenumに変換
            try:
                self.status = DeviceStatus(status)
                print(f"ステータス: {self.status.value}")
                return True
            except ValueError:
                print(f"不明なステータス: {status}")
        return False

    def get_status(self):
        """
        デバイスステータス取得（公開メソッド）

        Returns:
            DeviceStatus: 現在のデバイスステータス
        """
        if self._get_status():
            return self.status
        return None

    def receive_file_data(self) -> tuple:
        """
        ファイルデータ受信（8194byte）

        Returns:
            tuple: (success: bool, data: bytes)
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False, b''

        try:
            # LOAD_DATAコマンド送信
            if not self._send_command("LOAD_DATA"):
                print("LOAD_DATAコマンド送信失敗")
                return False, b''

            # 8194byte受信完了を待機
            import time
            timeout = 10.0  # 10秒タイムアウト
            start_time = time.time()
            last_available = 0

            while True:
                available_bytes = self.serial.get_bytes_in_buffer()

                # デバッグ情報：バッファサイズが変化した場合のみ表示
                if available_bytes != last_available:
                    elapsed = time.time() - start_time
                    print(f"受信バッファ: {available_bytes} bytes (経過時間: {elapsed:.1f}秒)")
                    last_available = available_bytes

                if available_bytes >= 8194:
                    # 8194byteのバイナリデータを受信
                    data = self.serial.read_bytes(8194)
                    if data and len(data) == 8194:
                        print(f"✓ {len(data)}byte受信完了")
                        return True, data
                    else:
                        print(f"受信データサイズ異常: {len(data) if data else 0}byte (期待値: 8194byte)")
                        return False, b''

                # タイムアウトチェック
                if time.time() - start_time > timeout:
                    print(f"バイナリデータ受信タイムアウト (最終受信バッファ: {available_bytes}byte)")
                    return False, b''

                # 少し待機
                time.sleep(0.1)  # 待機時間を少し長くしてCPU負荷軽減

        except Exception as e:
            print(f"ファイルデータ受信エラー: {e}")
            return False, b''

    def _get_error(self) -> bool:
        """エラー取得"""
        success, response = self._send_and_receive("GET_ERROR")
        if success and response.startswith("ERROR_"):
            self.error_code = response.replace("ERROR_", "")
            print(f"エラーコード: {self.error_code}")
            return True
        return False

    def set_frequency(self, frequency: int) -> bool:
        """
        測定周波数設定

        Args:
            frequency: 測定周波数 [Hz] (1,2,5,10,20,50,100,200,500,1000)

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # 有効な周波数値チェック
        valid_frequencies = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000]
        if frequency not in valid_frequencies:
            print(f"無効な周波数: {frequency} Hz")
            print(f"有効な値: {valid_frequencies}")
            return False

        # SET_FREQUENCYコマンド送信
        success, response = self._send_and_receive(f"SET_FREQUENCY_{frequency}")
        if success and response == "SET_FREQUENCY_OK":
            self.frequency = frequency
            print(f"測定周波数設定完了: {frequency} Hz")
            return True
        else:
            print(f"測定周波数設定失敗: {response}")
            return False

    def set_acc_range(self, range_g: int) -> bool:
        """
        加速度レンジ設定

        Args:
            range_g: 加速度レンジ [G] (2,4,8,16,30)

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # 有効なレンジ値チェック
        valid_ranges = [2, 4, 8, 16, 30]
        if range_g not in valid_ranges:
            print(f"無効な加速度レンジ: {range_g} G")
            print(f"有効な値: {valid_ranges}")
            return False

        # レンジコード変換
        range_map = {2: 0, 4: 1, 8: 2, 16: 3, 30: 4}
        range_code = range_map[range_g]

        # SET_ACC_RANGEコマンド送信
        success, response = self._send_and_receive(f"SET_ACC_RANGE_{range_code}")
        if success and response == "SET_ACC_RANGE_OK":
            self.acc_range = range_g
            print(f"加速度レンジ設定完了: ±{range_g} G")
            return True
        else:
            print(f"加速度レンジ設定失敗: {response}")
            return False

    def set_gyro_range(self, range_dps: int) -> bool:
        """
        ジャイロレンジ設定

        Args:
            range_dps: ジャイロレンジ [deg/s] (125,250,500,1000,2000,4000)

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # 有効なレンジ値チェック
        valid_ranges = [125, 250, 500, 1000, 2000, 4000]
        if range_dps not in valid_ranges:
            print(f"無効なジャイロレンジ: {range_dps} deg/s")
            print(f"有効な値: {valid_ranges}")
            return False

        # レンジコード変換
        range_map = {125: 0, 250: 1, 500: 2, 1000: 3, 2000: 4, 4000: 5}
        range_code = range_map[range_dps]

        # SET_GYRO_RANGEコマンド送信
        success, response = self._send_and_receive(f"SET_GYRO_RANGE_{range_code}")
        if success and response == "SET_GYRO_RANGE_OK":
            self.gyro_range = range_dps
            print(f"ジャイロレンジ設定完了: ±{range_dps} deg/s")
            return True
        else:
            print(f"ジャイロレンジ設定失敗: {response}")
            return False

    def set_matome_pc(self, matome: int) -> bool:
        """
        PCまとめ数設定

        Args:
            matome: PCまとめ数 (1-1000)

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # 有効な値チェック
        if matome < 1 or matome > 1000:
            print(f"無効なPCまとめ数: {matome}")
            print("有効な値: 1-1000")
            return False

        # SET_MATOMEコマンド送信
        success, response = self._send_and_receive(f"SET_MATOME_{matome}")
        if success and response == "SET_MATOME_OK":
            self.matome_pc = matome
            print(f"PCまとめ数設定完了: {matome}")
            return True
        else:
            print(f"PCまとめ数設定失敗: {response}")
            return False

    def set_save_to_flash(self, enable: bool) -> bool:
        """
        SD保存設定

        Args:
            enable: SD保存有効/無効

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # SET_SAVE_TO_FLASHコマンド送信
        value = 1 if enable else 0
        success, response = self._send_and_receive(f"SET_SAVE_TO_FLASH_{value}")
        if success and response == "SET_SAVE_TO_FLASH_OK":
            self.save_to_flash = enable
            print(f"SD保存設定完了: {'有効' if enable else '無効'}")
            return True
        else:
            print(f"SD保存設定失敗: {response}")
            return False

    def set_acc_bw_icm(self, bw_code: int) -> bool:
        """
        加速度センサーバンド帯域設定

        Args:
            bw_code: バンド帯域コード (0=50Hz, 1=110Hz, 2=250Hz, 3=500Hz)

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # 有効なコード値チェック
        valid_codes = [0, 1, 2, 3]
        if bw_code not in valid_codes:
            print(f"無効な加速度バンド帯域コード: {bw_code}")
            print(f"有効な値: {valid_codes} (0=50Hz, 1=110Hz, 2=250Hz, 3=500Hz)")
            return False

        # SET_ICM_ACC_BWコマンド送信
        success, response = self._send_and_receive(f"SET_ICM_ACC_BW_{bw_code}")
        if success and response == "SET_ICM_ACC_BW_OK":
            # バンド帯域値更新
            bw_map = {0: 50, 1: 110, 2: 250, 3: 500}
            self.acc_bw = bw_map[bw_code]
            print(f"加速度バンド帯域設定完了: {self.acc_bw} Hz")
            return True
        else:
            print(f"加速度バンド帯域設定失敗: {response}")
            return False

    def set_gyro_bw_icm(self, bw_code: int) -> bool:
        """
        ジャイロセンサーバンド帯域設定

        Args:
            bw_code: バンド帯域コード (0=50Hz, 1=120Hz, 2=200Hz, 3=400Hz)

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # 有効なコード値チェック
        valid_codes = [0, 1, 2, 3]
        if bw_code not in valid_codes:
            print(f"無効なジャイロバンド帯域コード: {bw_code}")
            print(f"有効な値: {valid_codes} (0=50Hz, 1=120Hz, 2=200Hz, 3=400Hz)")
            return False

        # SET_ICM_GYRO_BWコマンド送信
        success, response = self._send_and_receive(f"SET_ICM_GYRO_BW_{bw_code}")
        if success and response == "SET_ICM_GYRO_BW_OK":
            # バンド帯域値更新
            bw_map = {0: 50, 1: 120, 2: 200, 3: 400}
            self.gyro_bw = bw_map[bw_code]
            print(f"ジャイロバンド帯域設定完了: {self.gyro_bw} Hz")
            return True
        else:
            print(f"ジャイロバンド帯域設定失敗: {response}")
            return False

    def get_appropriate_acc_bw(self, frequency: int) -> int:
        """
        測定周波数に適した加速度バンド帯域コード取得

        Args:
            frequency: 測定周波数 [Hz]

        Returns:
            int: バンド帯域コード (0=50Hz, 1=110Hz, 2=250Hz, 3=500Hz)
        """
        if frequency >= 500:
            return 3  # 500Hz
        elif frequency >= 100:
            return 1  # 110Hz
        else:
            return 0  # 50Hz

    def get_appropriate_gyro_bw(self, frequency: int) -> int:
        """
        測定周波数に適したジャイロバンド帯域コード取得

        Args:
            frequency: 測定周波数 [Hz]

        Returns:
            int: バンド帯域コード (0=50Hz, 1=120Hz, 2=200Hz, 3=400Hz)
        """
        if frequency >= 500:
            return 3  # 400Hz
        elif frequency >= 100:
            return 2  # 200Hz
        else:
            return 0  # 50Hz

    def set_ext_mode(self) -> bool:
        """
        外部トリガ待ち受けモードに移行

        Returns:
            bool: 移行成功時True
        """
        success, response = self._send_and_receive("EXT")
        if success and response == "EXT_OK":
            return True
        return False

    def send_trigger(self) -> bool:
        """
        トリガ出力

        Returns:
            bool: トリガ出力成功時True
        """
        success, response = self._send_and_receive("TRIG")
        if success and response == "TRIG_OK":
            return True
        return False

    def set_file_header(self, header: str) -> bool:
        """
        SDカード保存時のファイルヘッダ設定

        Args:
            header: ファイルヘッダ文字列（半角5文字以内）

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # ヘッダ文字列の検証
        if len(header) > 5:
            print(f"ヘッダが長すぎます: {len(header)}文字 (最大5文字)")
            return False

        # SET_HEADERコマンド送信
        success, response = self._send_and_receive(f"SET_HEADER_{header}")
        if success and response in ["SET_HEADER_OK", "SET_HEADER_NG"]:
            if response == "SET_HEADER_OK":
                self.header = header
                print(f"ファイルヘッダ設定完了: {header}")
                return True
            else:
                print(f"ファイルヘッダ設定失敗: {response}")
                return False
        else:
            print(f"無効な応答: {response}")
            return False

    def set_step_number(self, step_num: int) -> bool:
        """
        ステップナンバー設定

        Args:
            step_num: ステップナンバー

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # SET_STEP_NUMBERコマンド送信
        success, response = self._send_and_receive(f"SET_STEP_NUMBER_{step_num}")
        if success and response in ["SET_STEP_NUMBER_OK", "SET_STEP_NUMBER_NG"]:
            if response == "SET_STEP_NUMBER_OK":
                self.step_number = step_num
                print(f"ステップナンバー設定完了: {step_num}")
                return True
            else:
                print(f"ステップナンバー設定失敗: {response}")
                return False
        else:
            print(f"無効な応答: {response}")
            return False

    def set_save_time(self, save_time: int) -> bool:
        """
        保存時間設定

        Args:
            save_time: 保存時間（秒）

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # SET_SAVE_TIMEコマンド送信
        success, response = self._send_and_receive(f"SET_SAVE_TIME_{save_time}")
        if success and response in ["SET_SAVE_TIME_OK", "SET_SAVE_TIME_NG"]:
            if response == "SET_SAVE_TIME_OK":
                print(f"保存時間設定完了: {save_time}秒")
                return True
            else:
                print(f"保存時間設定失敗: {response}")
                return False
        else:
            print(f"無効な応答: {response}")
            return False

    def set_stop_on_low_battery(self, enable: bool) -> bool:
        """
        電池残量で測定停止するかを設定

        Args:
            enable: True=有効、False=無効

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # SET_SOC_MEAS_STOP_ENコマンド送信
        param = 1 if enable else 0
        success, response = self._send_and_receive(f"SET_SOC_MEAS_STOP_EN_{param}")
        if success and response in ["SET_SOC_MEAS_STOP_EN_OK", "SET_SOC_MEAS_STOP_EN_NG"]:
            if response == "SET_SOC_MEAS_STOP_EN_OK":
                status_text = "有効" if enable else "無効"
                print(f"電池残量での測定停止設定完了: {status_text}")
                return True
            else:
                print(f"電池残量での測定停止設定失敗: {response}")
                return False
        else:
            print(f"無効な応答: {response}")
            return False

    def set_meas_stop_soc(self, soc_percent: int) -> bool:
        """
        測定停止する電池残量を設定

        Args:
            soc_percent: 電池残量（%）

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # SET_MEAS_STOP_SOCコマンド送信
        success, response = self._send_and_receive(f"SET_MEAS_STOP_SOC_{soc_percent}")
        if success and response in ["SET_MEAS_STOP_SOC_OK", "SET_MEAS_STOP_SOC_NG"]:
            if response == "SET_MEAS_STOP_SOC_OK":
                print(f"測定停止電池残量設定完了: {soc_percent}%")
                return True
            else:
                print(f"測定停止電池残量設定失敗: {response}")
                return False
        else:
            print(f"無効な応答: {response}")
            return False

    def set_save_interval(self, interval_hours: int) -> bool:
        """
        SD保存する時間間隔を設定

        Args:
            interval_hours: 時間間隔（hour）

        Returns:
            bool: 設定成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"設定不可能な状態: {self.status.value}")
            return False

        # SET_SAVE_INTERVALコマンド送信
        success, response = self._send_and_receive(f"SET_SAVE_INTERVAL_{interval_hours}")
        if success and response in ["SET_SAVE_INTERVAL_OK", "SET_SAVE_INTERVAL_NG"]:
            if response == "SET_SAVE_INTERVAL_OK":
                print(f"SD保存時間間隔設定完了: {interval_hours}時間")
                return True
            else:
                print(f"SD保存時間間隔設定失敗: {response}")
                return False
        else:
            print(f"無効な応答: {response}")
            return False

    def get_file_count(self) -> int:
        """
        SDメモリ内のBINファイル数を取得

        Returns:
            int: ファイル数（取得失敗時は-1）
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return -1

        success, response = self._send_and_receive("GET_FILE_COUNT")
        if success and response.startswith("FILE_COUNT_"):
            try:
                file_count = int(response.replace("FILE_COUNT_", ""))
                print(f"SDファイル数: {file_count}")
                return file_count
            except ValueError:
                print(f"無効な応答形式: {response}")
                return -1
        else:
            print(f"無効な応答: {response}")
            return -1

    def get_file_info(self, file_index: int) -> dict:
        """
        SDメモリ内の指定BINファイルの情報を取得

        Args:
            file_index: ファイルインデックス

        Returns:
            dict: ファイル情報（取得失敗時は空辞書）
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return {}

        success, response = self._send_and_receive(f"GET_FILE_INFO_{file_index}")
        if success and response.startswith("FILE_INFO_"):
            try:
                info_str = response.replace("FILE_INFO_", "")
                parts = info_str.split(",")
                if len(parts) >= 7:
                    return {
                        "filename": parts[0],
                        "size": int(parts[1]),
                        "year": int(parts[2]),
                        "month": int(parts[3]),
                        "day": int(parts[4]),
                        "hour": int(parts[5]),
                        "minute": int(parts[6]),
                        "second": int(parts[7]) if len(parts) > 7 else 0
                    }
            except (ValueError, IndexError):
                print(f"無効な応答形式: {response}")
                return {}
        else:
            print(f"無効な応答: {response}")
            return {}

    def remove_file(self, filename: str) -> bool:
        """
        SDメモリ内の指定BINファイルを削除

        Args:
            filename: 削除するファイル名

        Returns:
            bool: 削除成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        success, response = self._send_and_receive(f"SET_FILE_REMOVE_{filename}")
        if success and response in ["SET_FILE_REMOVE_OK", "SET_FILE_REMOVE_NG"]:
            if response == "SET_FILE_REMOVE_OK":
                print(f"ファイル削除完了: {filename}")
                return True
            else:
                print(f"ファイル削除失敗: {filename}")
                return False
        else:
            print(f"無効な応答: {response}")
            return False

    def start_load(self, filename: str) -> bool:
        """
        SDメモリ内のデータ読み込みを開始

        Args:
            filename: 読み込むファイル名

        Returns:
            bool: 開始成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        if self.status != DeviceStatus.IDLE:
            print(f"読み込み開始不可能な状態: {self.status.value}")
            return False

        success, response = self._send_and_receive(f"SET_START_LOAD_{filename}")
        if success and response in ["SET_START_LOAD_OK", "SET_START_LOAD_NG"]:
            if response == "SET_START_LOAD_OK":
                print(f"データ読み込み開始: {filename}")
                return True
            else:
                print(f"データ読み込み開始失敗: {filename}")
                return False
        else:
            print(f"無効な応答: {response}")
            return False

    def stop_load(self) -> bool:
        """
        データ読み込みを停止

        Returns:
            bool: 停止成功時True
        """
        if not self.is_connected:
            print("デバイスが接続されていません")
            return False

        success, response = self._send_and_receive("LOAD_STOP")
        if success and response in ["SET_START_LOAD_OK", "SET_START_LOAD_NG"]:
            if response == "SET_START_LOAD_OK":
                print("データ読み込み停止完了")
                return True
            else:
                print("データ読み込み停止失敗")
                return False
        else:
            print(f"無効な応答: {response}")
            return False

    def stop_measurement(self) -> bool:
        """
        測定停止（データパケット混在対応）

        Returns:
            bool: 停止成功時True
        """
        import time

        if not self.is_connected:
            return False

        # STOPコマンド送信
        if not self._send_command("STOP"):
            print("STOPコマンド送信失敗")
            return False

        # パケットサイズ定義
        total_packet_size = 192  # ヘッダー4 + データ184 + フッター4
        stop_response_size = 8   # "STOP_OK\n"

        consecutive_8byte_count = 0
        timeout_start = time.time()
        timeout_duration = 5.0  # 5秒でタイムアウト

        while time.time() - timeout_start < timeout_duration:
            bytes_available = self.serial.get_bytes_in_buffer()

            if bytes_available == stop_response_size:
                # 8バイトちょうど
                consecutive_8byte_count += 1
                print(f"8バイト検出 {consecutive_8byte_count}/3")

                if consecutive_8byte_count >= 3:
                    # 3回連続8バイトを確認したので受信してSTOP_OK確認
                    data = self.serial.read_bytes(stop_response_size)
                    if data:
                        try:
                            response = data.decode('ascii').strip()
                            if response == "STOP_OK":
                                print("STOP_OK確認完了")
                                return True
                            else:
                                print(f"予期しない応答: {response}")
                                consecutive_8byte_count = 0  # カウントリセット
                        except UnicodeDecodeError:
                            print("応答デコードエラー")
                            consecutive_8byte_count = 0  # カウントリセット
                    else:
                        consecutive_8byte_count = 0  # カウントリセット

                time.sleep(0.01)  # 少し待機

            elif bytes_available > stop_response_size:
                # 8バイト超 → データパケットが混在
                consecutive_8byte_count = 0  # カウントリセット

                if bytes_available >= total_packet_size:
                    # パケットサイズ分を捨てる
                    discard_data = self.serial.read_bytes(total_packet_size)
                    print(f"データパケット破棄: {len(discard_data)}バイト")
                else:
                    # パケットサイズに達するまで待機
                    time.sleep(0.01)

            else:
                # 8バイト未満 → 待機
                if bytes_available > 0:
                    consecutive_8byte_count = 0  # カウントリセット
                time.sleep(0.01)

        print("測定停止タイムアウト")
        return False

# テスト用コード
if __name__ == "__main__":
    import sys
    import io
    # Windows環境でのエンコーディング設定
    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

    device = ImsDevice()

    # 利用可能なポートを表示
    print("Available COM ports:")
    ports = device.serial.list_available_ports()
    for port in ports:
        print(f"  {port['device']}: {port['description']}")

    # COM3に接続テスト
    print("\nTrying to connect to COM3...")
    if device.connect("COM3"):
        print("\n=== 接続成功 ===")
        print(f"状態: {device.status.value}")
        print(f"\n--- デバイス情報 ---")
        print(f"シリアル番号: {device.serial_number}")
        print(f"バージョン: {device.version}")
        print(f"ステップ番号: {device.step_number}")
        print(f"モデル: {device.model}")
        print(f"デバイスタイプ: {device.device_type}")
        print(f"\n--- センサー設定 ---")
        print(f"測定周波数: {device.frequency} Hz")
        print(f"PCまとめ数: {device.matome_pc}")
        print(f"SDまとめ数: {device.matome_sd}")
        print(f"加速度レンジ: ±{device.acc_range} G")
        print(f"ジャイロレンジ: ±{device.gyro_range} deg/s")
        print(f"加速度バンド帯域: {device.acc_bw} Hz")
        print(f"ジャイロバンド帯域: {device.gyro_bw} Hz")
        print(f"\n--- SD設定 ---")
        print(f"SD保存: {'有効' if device.save_to_flash else '無効'}")
        print(f"SDカード: {'あり' if device.sd_exist else 'なし'}")
        print(f"ファイルヘッダ: {device.header}")
        print(f"保存時間: {device.save_time} 秒")
        print(f"\n--- 電池管理設定 ---")
        print(f"電池残量測定停止機能: {'有効' if device.soc_meas_stop_en else '無効'}")
        print(f"測定停止電池残量: {device.meas_stop_soc} %")
        print(f"電源オン時測定開始機能: {'有効' if device.pwr_on_st_en else '無効'}")
        print(f"データ保存間隔: {device.save_interval} 秒")
        print(f"エラーコード: {device.error_code}")
        print(f"\n--- 校正データ ---")
        print(f"加速度校正値: {device.acc_prf}")
        print(f"加速度ゼロ点: {device.acc_zero}")
        print(f"加速度干渉補正: {device.acc_itf}")
        print(f"ジャイロ校正値: {device.gyro_prf}")
        print(f"ジャイロゼロ点: {device.gyro_zero}")
        print(f"ジャイロ干渉補正: {device.gyro_itf}")
        print(f"地磁気ゼロ点: {device.mag_zero}")
        print(f"地磁気校正値: {device.mag_prf}")
        print(f"地磁気干渉補正: {device.mag_itf}")
        print(f"\n--- 磁気センサー追加パラメータ ---")
        print(f"OFFSETZERO: {device.mag_offzero}")
        print(f"OFFSET: {device.mag_off}")
        print(f"FINEOUTPUT: {device.mag_fineout}")
        print(f"SENSITIVITY: {device.mag_sens}")
        print(f"GAINPARA: {device.mag_gainpara}")

        # 切断
        print("\n切断中...")
        device.disconnect()
        print("切断完了")
    else:
        print("接続失敗")