---
title: "SO-101 失敗から学ぶアームを作る Log#4 | お手本集めの前に、SO-101 のデータのずれを測る"
slug: so101-lerobot-data-check-before-demonstrations
date: 2026-11-22
day: 551
meta_description: "SO-101 を LeRobot 0.7.1 で動かすと、関節の値は再生しても差が最大1.05°で、手首カメラと関節のずれは1コマ以内だった。ただし記録の時刻はカメラが撮った時刻ではなく、再生の始めにフォロワーが35〜42°飛んだ。"
tags: [SO-101, LeRobot, テレオペ, 模倣学習, 手首カメラ, 時刻のずれ, DAgger, Claude Code, 依頼箱]
series: "フィジカルAI研究室"
---

**ロボットアーム SO-101 を Hugging Face の LeRobot 0.7.1 で動かして記録すると、関節の角度は1目盛 0.088° で読め、記録した動きを2回再生しても差は最大 1.05° だった。手首カメラの映像と関節の値のずれも1コマ（33ms）以内に収まった。** ただし、LeRobot が記録に付ける時刻はカメラが実際に撮った時刻ではなく「コマの番号 ÷ 30」で、記録した動きを再生した瞬間に、フォロワーアームが 35〜42° 飛ぶことがあった。どれも実物のアームと2台の USB カメラを Mac につないで測った値です。

これで変わること。

- 模倣学習（人がやって見せた動きを AI にまねさせる学習）のお手本を、何に気をつけて撮ればよいかが数字で決まった。映像は 640x480・30fps、動かす速さは 150°/s まで（それより速いと手首カメラの映像がぶれる）、記録は休みの姿勢で終える
- データの大きさが先に分かった。1秒あたり 0.23MB なので、30秒のお手本を1000回撮っても 6.8GB。保存先の容量で困ることはない
- 推論の途中で人が割り込んで直す仕組み（DAgger）が LeRobot にそろっていて、割り込む瞬間にアームが飛ばない作りだと分かった。前のアーム mechArm 270 ではゲームパッドで直す道具を自分で作っていたが、SO-101 では既にある仕組みを使える
- 確かめは Claude Code への依頼1本（依頼258）で、測定は44分、報告まで54分だった。人は画面に大きく出る指示どおりにリーダーアームを動かしただけで、ターミナルは見ていない。前のアームで同じ確かめをした時間は測っていない

気になったのは、記録の時刻の付き方と、再生の飛びです。LeRobot は2台のカメラから「その時点の最新のコマ」を取り込み、時刻はコマの番号から作ります。カメラのコマが落ちても、時刻は等間隔のまま、前のコマがもう一度入ります。30秒で 4〜13 コマ落ちていました。そして再生では、確認では差が 10° 以内だったのに、力が入った最初のコマで肩とひじが大きく動いていました。サーボの中に、前の記録の終わりの目標の角度が残っていたためとみています。

| やったこと | なぜ | 結果 |
|---|---|---|
| 机側カメラのピントを、数値を見ながら合わせた（依頼257・258） | 届いた日の写真がピンぼけだった | 中央のピントの数値が 2.6 から 1330 に上がった |
| 関節とカメラ2台を、動かさずに読んだ | 30Hz（1秒に30回）の記録に間に合うかを見る | 関節は1回 2〜4ms で読める。カメラは2台とも約30fps |
| テレオペで爪を開け閉めし、3つの流れに出る時刻を比べた | 上カメラと爪カメラと関節が同期しているかを見る | 手首カメラと関節は1コマ以内。机側カメラは爪が小さく測れなかった |
| ゆっくり・ふつう・速くの3段で動かした | 速く動かしていいかを見る | フォロワーは約0.1秒遅れてついてくる。150°/s を超えると映像がぶれる |
| LeRobot で10秒×3回を記録し、1回を2回再生した | 記録の形と関節の正確さを見る | 再生の差は最大 1.05°。ただし再生1の始めに 35〜42° 飛んだ |
| 推論中に人が割り込む仕組みを、コードを読んで調べた | 失敗を人が直して学ばせる流れを作りたい | `lerobot-rollout` の DAgger で割り込め、直したコマには印が付く |
| 測った数字を、データ収集の前のチェックリストのガイドにした | LeRobot でお手本を撮り始める人が、検索で見つけられるようにする | 主の語は `lerobot record`。日本語の「データ収集」の語は検索のデータがなかった |

SO-101 で集めたお手本の学習は、Runpod で GPU を借りて回す予定です。GPU を買うか借りるかの判断は、Runpod で実際に借りて学習させた費用をもとに、別のページにまとめています。

【バナー】gpu-buy-or-rent


## 作業ログ ― 机側カメラのピントを、数値を見ながら合わせた（依頼257）

SO-101 は、人が手で動かす黒いリーダーアームと、その動きをまねる白いフォロワーアームの2本組です（前の記録 LOG544 で、箱を開けてテレオペまで進めた）。カメラは2台で、フォロワーの爪の近くに付けた手首カメラと、机を上から写す机側カメラです。机側カメラは InnoMaker の USB カメラ（U20CAM-720P・720p・画角120°）で、iPhone のように毎回付け外ししなくてよいよう、固定で使います。

届いた日に撮った机側カメラの写真はピンぼけでした。ケーブルが短く、カメラを低く置いていたためです。延長ケーブルが届いたので、まずピントを合わせました。

### ピントの数値は、画像の細かさを測るラプラシアンの分散

ピントが合っているかを目で見るだけだと、どこで止めればよいか分かりません。そこで、画面に数値を出しながらレンズを回しました。数値は「ラプラシアンの分散」で、画像の中の明るさの変わり目がどれだけ鋭いかを表します。ピントが合うほど大きくなります。ただし、同じ物を写しているときにしか比べられません。白い机だけを写すと、ピントが合っていても小さいままです。

画面の中央と四隅の5か所で測り、中央の値を大きく出し、それまでの最大も並べました（`OpenCV` で `cv2.Laplacian(...).var()` を計算する）。

### 依頼257 では、机側カメラが Mac から見えていなかった

ピント合わせの画面を作る依頼を、依頼箱（Claude Code への依頼を置くと、Mac の見張り係が自動で渡して報告を書き戻す仕組み）に置きました。画面のスクリプトはできましたが、起動したときに机側カメラが Mac の USB の一覧に出てこず、止まりました。延長ケーブルが届いたばかりで、まだつないでいなかったためです。

報告で分かったことが1つあります。この Mac では、カメラの番号の並びが ffmpeg と OpenCV で違っていました（Iriun は ffmpeg で0・OpenCV で1、内蔵の FaceTime は ffmpeg で1・OpenCV で0）。番号を決め打ちにすると、別のカメラを開いてしまいます。そのため、カメラは名前で探して開く形にしました。実際、次の依頼258 では、手首カメラと机側カメラの番号が届いた日と入れ替わっていました（手首が1・机側が0）。

#### 依頼257 の依頼文（全文）

```markdown
---
作業フォルダ: /Users/shimazueiichi/r2r2r-scripts
上限時間: 45
---
# SO-101 の机側カメラ（InnoMaker）のピントと置き場所を合わせる画面を出す（依頼257）

依頼248 で、机側カメラ（Innomaker-U20CAM-720P、OpenCV の番号は 1 だった）の画像がピンぼけだった。延長ケーブルが届いたので、エイイチがカメラを使う場所に固定し、レンズを回してピントを合わせる。そのための「見ながら合わせる画面」を作って、Mac の画面に出してほしい。**アームは動かさない。サーボには触らない。**

## 作るもの：`so101/desk_cam_focus_257.py`
- 机側カメラを 1280x720・MJPG・30fps で開く
- カメラは番号の決め打ちにしない。`ffmpeg -f avfoundation -list_devices true -i ""` などで名前に「Innomaker」を含む機器を探し、OpenCV の番号と突き合わせて開く。見つからなければ一覧を表示して止める。どう突き合わせたかを報告に書く
- 画面（OpenCV のウィンドウ）に重ねて出すもの
  - ピントの数値：ラプラシアンの分散を、中央と四隅の5か所で。中央の数値は大きく、これまでの最大値も並べる（レンズを回して一番大きい所で止められるように）
  - 画面を縦横3等分する細い線
  - 解像度・実際の fps
- キー操作：スペース＝静止画を保存（`so101/check_257/desk_{時刻}.png`。そのときのピントの数値5つを同じ名前の .json に）、q＝終了。何も押されなくても20分で自動で終わる
- 画像と JSON は git に入れない。スクリプトだけ個別に add して commit する

## やること
1. スクリプトを書き、カメラを開かずに動く部分（数値の計算など）を確かめる
2. スクリプトを起動して、Mac の画面にウィンドウを出す。エイイチがピントを合わせて q を押すか、20分たつまで待つ
3. 終わったら、保存された静止画の一覧と、それぞれのピントの数値を報告する。依頼248 の `so101/check_248/desk_opencv1.png` の同じ数値も計算して並べる（どれだけ良くなったか分かるように）

## 絶対にしないこと
- アーム・サーボへの読み書き、キャリブレーション、テレオペ
- 露出・ホワイトバランスの固定などカメラの設定を書き換えること（今回は見るだけ。固定は置き場所が決まってから別の依頼で）
- KIOXIA に新しいフォルダを作らない
- `git add .`・`git clean`

## 報告に書くこと
- カメラの見つけ方（名前と番号の突き合わせ）と、開いた番号
- 保存した静止画のパスとピントの数値、依頼248 の画像との比べ
- 最後の1行に「判定：合格／止めた（決めてほしいことあり）／失敗」
```

#### 依頼257 の報告（全文）

```markdown
# 結果：20261122_257_SO101の机側カメラのピント合わせの画面を出す

- 状態：完了
- 始めた時刻：2026-11-22 16:25
- 終わった時刻：2026-11-22 16:27（2分）
- 作業フォルダ：/Users/shimazueiichi/r2r2r-scripts
- この続きを Claude Code で話すとき：作業フォルダで `claude --resume ccee8cb2-bc07-4741-8ea5-0950f98832ed`

## Claude Code の報告

**やったこと**
- ピントを見ながら合わせる画面のスクリプト `so101/desk_cam_focus_257.py` を新しく書き、このファイルだけを個別に add して commit しました（84e2bba）。
  - 1280x720・MJPG・30fps を頼んで開きます。露出・ホワイトバランスなどのカメラの設定には触りません。
  - 画面には、ピントの数値を中央と四隅の5か所で出します。中央の数値は大きく出し、これまでの最大値も並べます。ほかに縦横3等分の線、解像度、実際の fps、残り時間を重ねます。
  - スペースで `so101/check_257/desk_{時刻}.png` と同じ名前の .json（ピントの数値5つ）を保存します。q で終わり、何も押さなくても20分で終わります。
  - `--score-image 画像` を付けると、カメラを開かずに画像のピントの数値だけを出します。
- カメラの見つけ方は、ffmpeg の機器一覧と cv2_enumerate_cameras（OpenCV の番号と名前の対を返すもの。既存の camera_resolver と同じ仕組み）の両方で、名前に「Innomaker」を含む機器を探します。両方に出たときだけ、OpenCV 側の番号を開きます。見つからなければ両方の一覧を出して止めます。
  - この Mac では、ffmpeg と OpenCV で番号の並びが違っていました。Iriun は ffmpeg では 0、OpenCV では 1 です。FaceTime は ffmpeg では 1、OpenCV では 0 です。なので、ffmpeg の番号をそのまま OpenCV に渡すと別のカメラを開きます。名前で突き合わせる形にしたのはこのためです。
- カメラを開かない部分を確かめました。
  - ランダムな画像とそれをぼかした画像では、5か所すべてでぼかしたほうの数値が下がりました（中央は 48438 から 4）。
  - 画面の描画と、2つの機器一覧の読み取りも動きました。
- スクリプトを起動しましたが、Innomaker が見つからず、一覧を出して止まりました。

**結果**
- ウィンドウは出せていません。保存した静止画は0枚です。
- Innomaker は Mac に USB で見えていません。
  - ffmpeg の一覧：Iriun Camera、FaceTime HDカメラ、Capture screen 0
  - OpenCV の一覧：0 FaceTime HDカメラ、1 Iriun Camera
  - system_profiler の USB 一覧：KIOXIA の SSD（EXCERIA PLUS G2）だけ
- 比べるための依頼248 の `so101/check_248/desk_opencv1.png`（1280x720）のピントの数値は、中央 2.6、左上 13.0、右上 3.5、左下 16.9、右下 13.6 です。
- アーム・サーボには触っていません。カメラの設定も書き換えていません。KIOXIA には何も作っていません。
- 作業記録を `logs/20261122_1627.md` に書きました。

**変えたファイル**
- `so101/desk_cam_focus_257.py`（新規）

**決めてほしいこと**
- 延長ケーブルを通して Innomaker を Mac につないだあと、もう一度起動するかどうか。起動は `python3 so101/desk_cam_focus_257.py` です（cv2_enumerate_cameras が入っている miniforge の base の python3 で動かします）。保存した静止画の数値は、`--score-image` で上の依頼248 の数値と並べて比べられます。

判定：止めた（決めてほしいことあり）
```

#### Claude Code の作業の記録 logs/20261122_1627.md（全量）

```markdown
# 依頼257 SO-101 机側カメラのピント合わせ画面

- 新規: so101/desk_cam_focus_257.py (commit 84e2bba)
- カメラの探し方: ffmpeg avfoundation の一覧と cv2_enumerate_cameras (OpenCV 番号と名前) の両方で名前に「Innomaker」を含むものを探し, OpenCV 側の番号を開く
- この Mac では ffmpeg と OpenCV で番号の並びが違う (Iriun: ffmpeg 0 / OpenCV 1, FaceTime: ffmpeg 1 / OpenCV 0)
- 起動結果: Innomaker が USB に出ておらず (USB は KIOXIA だけ) 一覧を出して止めた. ウィンドウは出ていない. 静止画 0 枚
- 依頼248 desk_opencv1.png のピントの数値: 中央 2.6 / 左上 13.0 / 右上 3.5 / 左下 16.9 / 右下 13.6
- 決めてほしいこと: カメラをつないだうえで再起動するか
```

### 机側カメラのピントは、中央の数値 2.6 から 1330 になった

カメラをつないだあと、次の依頼258 の最初の段階で、このスクリプトをもう一度起動しました。最初の映像は、何が写っているか分からないほどぼけていました（中央 1.4）。レンズを大きく回して形が見えてきたところで、マットの真ん中に線を引いた紙を置き、中央の数値がいちばん大きくなる所で止めました。

【画像】LOG551_01_desk_before_focus.png レンズを回す前の机側カメラの映像。全体がぼけていて、何が写っているか分からない

【画像】LOG551_03_focus_window.png ピント合わせの画面。中央に線を引いた紙を置き、中央のピントの数値が 1270 になったところ。四隅の数値は白い机しか写らないので低い

【画像】LOG551_02_desk_after_focus.png ピントを合わせたあとの机側カメラの映像。白いフォロワーアーム、箱、線を引いた紙の輪郭がはっきり写っている

| 画像 | 中央 | 左上 | 右上 | 左下 | 右下 |
|---|---|---|---|---|---|
| 届いた日の写真（依頼248） | 2.6 | 13.0 | 3.5 | 16.9 | 13.6 |
| レンズを回す前（17:16） | 1.4 | 6.3 | 4.4 | 5.8 | 5.9 |
| 合わせたあと（17:25、4枚） | 1286〜1330 | 58〜66 | 2.2〜2.5 | 23〜27 | 6.8〜7.7 |

- ねらい：お手本のどの回でも、机の上の物が同じくっきりさで写るようにする
- 変わったこと：中央のピントの数値が約500倍になった。カメラは固定したので、この状態がそのまま続く
- 見込める効果：ブロックや爪の輪郭がぼけないので、学習で物の位置を読み取りやすくなる見込み。学習の成功率で確かめる

120° の広角レンズなので、画面の端は丸く曲がって写ります。学習に使うだけなら、いつも同じ曲がり方なので問題になりません。映像から長さを測るときだけ、チェッカーボードを撮って曲がりを補正します。

#### ピント合わせの画面のスクリプト desk_cam_focus_257.py（全文）

```python
"""SO-101 の机側カメラ (Innomaker-U20CAM-720P) のピントと置き場所を見ながら合わせる画面 (依頼 257).

アーム・サーボには触らない. カメラの設定 (露出・ホワイトバランスなど) も書き換えない.
頼むのは 1280x720・MJPG・30fps の取り込みだけ.

カメラの見つけ方:
- ffmpeg -f avfoundation -list_devices true -i "" で名前に "Innomaker" を含む機器を探す
- cv2_enumerate_cameras (camera_resolver と同じ) で OpenCV の番号と名前の対を取り,
  同じ名前の番号を開く. 両方の一覧に名前が出たときだけ開く.
- 見つからなければ両方の一覧を出して止める.

画面に重ねるもの:
- ピントの数値 (グレースケールのラプラシアンの分散) を中央と四隅の5か所で. 中央は大きく, これまでの最大値も出す
- 縦横3等分の細い線
- 解像度・実際の fps

キー: スペース = 静止画 so101/check_257/desk_{時刻}.png と同じ名前の .json (ピントの数値5つ) を保存, q = 終了.
何も押されなくても 20 分で終わる.

使い方:
    python3 so101/desk_cam_focus_257.py
    python3 so101/desk_cam_focus_257.py --score-image so101/check_248/desk_opencv1.png   # カメラを開かずに数値だけ
"""

import argparse
import json
import re
import shutil
import subprocess
import sys
import time
from datetime import datetime
from pathlib import Path

import cv2
import numpy as np

NAME_KEY = "innomaker"
WIDTH, HEIGHT, FPS = 1280, 720, 30
TIMEOUT_S = 20 * 60
ROI_FRAC = 0.2  # 1か所の大きさ (幅・高さに対する割合)
OUT_DIR = Path(__file__).resolve().parent / "check_257"
REGIONS = ["center", "top_left", "top_right", "bottom_left", "bottom_right"]
FFMPEG_FALLBACKS = [
    "/opt/homebrew/Caskroom/miniforge/base/envs/lerobot/bin/ffmpeg",
    "/opt/homebrew/bin/ffmpeg",
]


# ---- ピントの数値 (カメラなしで動く) -------------------------------------------

def region_boxes(w, h, frac=ROI_FRAC):
    """5か所の (x, y, w, h). 四隅は端から少し内側に置く."""
    rw, rh = int(w * frac), int(h * frac)
    mx, my = int(w * 0.03), int(h * 0.03)
    return {
        "center": ((w - rw) // 2, (h - rh) // 2, rw, rh),
        "top_left": (mx, my, rw, rh),
        "top_right": (w - mx - rw, my, rw, rh),
        "bottom_left": (mx, h - my - rh, rw, rh),
        "bottom_right": (w - mx - rw, h - my - rh, rw, rh),
    }


def laplacian_var(gray):
    return float(cv2.Laplacian(gray, cv2.CV_64F).var())


def focus_scores(frame):
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) if frame.ndim == 3 else frame
    h, w = gray.shape[:2]
    return {k: laplacian_var(gray[y:y + bh, x:x + bw]) for k, (x, y, bw, bh) in region_boxes(w, h).items()}


# ---- カメラの見つけ方 ------------------------------------------------------------

def ffmpeg_video_devices():
    exe = shutil.which("ffmpeg") or next((p for p in FFMPEG_FALLBACKS if Path(p).exists()), None)
    if exe is None:
        return None, []
    r = subprocess.run([exe, "-hide_banner", "-f", "avfoundation", "-list_devices", "true", "-i", ""],
                       capture_output=True, text=True)
    devs, in_video = [], False
    for line in r.stderr.splitlines():
        if "video devices" in line:
            in_video = True
            continue
        if "audio devices" in line:
            break
        m = re.search(r"\]\s*\[(\d+)\]\s*(.+)$", line)
        if in_video and m:
            devs.append((int(m.group(1)), m.group(2).strip()))
    return exe, devs


def opencv_devices():
    try:
        from cv2_enumerate_cameras import enumerate_cameras
    except ImportError:
        return None
    return [(c.index, c.name or "") for c in enumerate_cameras(cv2.CAP_AVFOUNDATION)]


def resolve_index():
    exe, ff = ffmpeg_video_devices()
    cvd = opencv_devices()
    print(f"[CAM] ffmpeg ({exe}) の映像機器:")
    for i, n in ff:
        print(f"  ffmpeg [{i}] {n}")
    print("[CAM] OpenCV の番号と名前 (cv2_enumerate_cameras):")
    if cvd is None:
        print("  cv2_enumerate_cameras が入っていない")
    else:
        for i, n in cvd:
            print(f"  OpenCV {i} {n}")

    ff_hit = [(i, n) for i, n in ff if NAME_KEY in n.lower()]
    cv_hit = [(i, n) for i, n in (cvd or []) if NAME_KEY in n.lower()]
    if not ff_hit or not cv_hit:
        print(f"[CAM] 名前に Innomaker を含む機器が見つからない (ffmpeg {len(ff_hit)} 台, OpenCV {len(cv_hit)} 台). 止める.")
        return None
    if len(cv_hit) > 1:
        print(f"[CAM] Innomaker が複数ある: {cv_hit}. 止める.")
        return None
    idx, name = cv_hit[0]
    print(f"[CAM] ffmpeg [{ff_hit[0][0]}] {ff_hit[0][1]} と OpenCV {idx} {name} が同じ名前 → OpenCV {idx} を開く")
    return idx


# ---- 画面 -------------------------------------------------------------------------

def put(img, text, org, scale, color, thick):
    cv2.putText(img, text, org, cv2.FONT_HERSHEY_SIMPLEX, scale, (0, 0, 0), thick + 3, cv2.LINE_AA)
    cv2.putText(img, text, org, cv2.FONT_HERSHEY_SIMPLEX, scale, color, thick, cv2.LINE_AA)


def draw_overlay(frame, scores, best, fps, remain_s):
    img = frame.copy()
    h, w = img.shape[:2]
    for k in (1, 2):
        cv2.line(img, (w * k // 3, 0), (w * k // 3, h), (255, 255, 255), 1)
        cv2.line(img, (0, h * k // 3), (w, h * k // 3), (255, 255, 255), 1)
    for k, (x, y, bw, bh) in region_boxes(w, h).items():
        color = (0, 255, 255) if k == "center" else (0, 255, 0)
        cv2.rectangle(img, (x, y), (x + bw, y + bh), color, 1)
        if k != "center":
            put(img, f"{scores[k]:.0f}", (x + 4, y + bh - 6), 0.6, color, 1)
    cx, cy, cw, ch = region_boxes(w, h)["center"]
    put(img, f"{scores['center']:.0f}", (cx, cy - 40), 1.6, (0, 255, 255), 3)
    put(img, f"max {best:.0f}", (cx, cy - 8), 0.8, (0, 200, 255), 2)
    put(img, f"{w}x{h}  {fps:.1f} fps   space=save  q=quit   {int(remain_s) // 60}:{int(remain_s) % 60:02d}",
        (10, h - 12), 0.6, (255, 255, 255), 1)
    return img


def save_still(frame, scores, best, idx):
    OUT_DIR.mkdir(parents=True, exist_ok=True)
    stem = f"desk_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
    png, js = OUT_DIR / f"{stem}.png", OUT_DIR / f"{stem}.json"
    if png.exists():
        print(f"[SAVE] {png} がすでにある. 保存しない")
        return
    cv2.imwrite(str(png), frame)
    js.write_text(json.dumps({"image": png.name, "opencv_index": idx, "shape": list(frame.shape),
                              "focus": scores, "center_max_so_far": best}, ensure_ascii=False, indent=2))
    print(f"[SAVE] {png}  " + "  ".join(f"{k}={scores[k]:.1f}" for k in REGIONS))


def run_camera():
    idx = resolve_index()
    if idx is None:
        return 1
    cap = cv2.VideoCapture(idx, cv2.CAP_AVFOUNDATION)
    if not cap.isOpened():
        print(f"[CAM] OpenCV {idx} を開けない")
        return 1
    cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*"MJPG"))
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, WIDTH)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, HEIGHT)
    cap.set(cv2.CAP_PROP_FPS, FPS)
    print(f"[CAM] 開いた: {int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))}x{int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))} "
          f"{cap.get(cv2.CAP_PROP_FPS):.1f}fps")

    win = "desk cam focus (257)"
    cv2.namedWindow(win, cv2.WINDOW_NORMAL)
    t_start = time.time()
    best, fps, stamps = 0.0, 0.0, []
    saved = 0
    try:
        while True:
            now = time.time()
            if now - t_start >= TIMEOUT_S:
                print("[END] 20分たったので終わる")
                break
            ok, frame = cap.read()
            if not ok:
                if cv2.waitKey(10) & 0xFF == ord("q"):
                    break
                continue
            stamps.append(time.time())
            stamps = stamps[-30:]
            if len(stamps) > 1:
                fps = (len(stamps) - 1) / (stamps[-1] - stamps[0])
            scores = focus_scores(frame)
            best = max(best, scores["center"])
            cv2.imshow(win, draw_overlay(frame, scores, best, fps, TIMEOUT_S - (now - t_start)))
            key = cv2.waitKey(1) & 0xFF
            if key == ord("q"):
                print("[END] q で終わる")
                break
            if key == ord(" "):
                save_still(frame, scores, best, idx)
                saved += 1
    finally:
        cap.release()
        cv2.destroyAllWindows()
        cv2.waitKey(1)
    print(f"[END] 保存 {saved} 枚, 中央の最大 {best:.1f}")
    return 0


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--score-image", nargs="+", help="カメラを開かずに画像のピントの数値を出す")
    args = ap.parse_args()
    if args.score_image:
        for p in args.score_image:
            img = cv2.imread(p)
            if img is None:
                print(f"{p}: 読めない")
                continue
            s = focus_scores(img)
            print(f"{p} {img.shape[1]}x{img.shape[0]}  " + "  ".join(f"{k}={s[k]:.1f}" for k in REGIONS))
        return 0
    return run_camera()


if __name__ == "__main__":
    sys.exit(main())
```


## 作業ログ ― SO-101 から取れるデータを全部確かめる計画（依頼258）

お手本を何百本も撮り始めてから、データに欠けや食い違いが見つかると、撮り直しになります。そこで、撮る前に全部を確かめることにしました。相談の始まりはこの発言でした。

> macとカメラ、アームを繋いだら、どんなデータが取れるかを全てチェックします。アームを素早く動かしていいのか？上カメラと爪カメラは同期できているのか？アームの各関節のデータは正確に取得できているのか？アームの動きを修正する場合の仕組みはちゃんと機能するのかなど。どのようなデータをどのような構成になっていればいいのかを全て確認します。

### この記録で使う言葉

| 言葉 | この記録での意味 |
|---|---|
| テレオペ | 人がリーダーアームを手で動かし、フォロワーアームが同じ角度に動くこと |
| action | 記録の中の「リーダーの角度」。学習したあとは、モデルが出す次の角度になる |
| observation.state | 記録の中の「フォロワーの今の角度」 |
| timestamp | 記録の各コマに付く時刻。LeRobot は「コマの番号 ÷ 30」で付ける |
| max_relative_target | LeRobot の設定で、フォロワーが1コマに動ける角度の上限。既定は「上限なし」 |
| Goal_Position | サーボの中にある「目標の角度」。力（トルク）が入ると、サーボはこの角度へ向かう |
| DAgger | 推論の途中で人が割り込んで直し、直した区間をお手本として学ばせるやり方 |

[LeRobot](https://github.com/huggingface/lerobot) は Hugging Face が配る、ロボットのお手本の記録・学習・推論の道具です。SO-101 は LeRobot が最初から扱えるアームで、`lerobot-record`（記録）・`lerobot-replay`（再生）・`lerobot-rollout`（学習したモデルで動かす）といったコマンドがそろっています。

### 測る順番は、動かさない段階からテレオペへ

アームを動かすのは人（リーダーを手で動かすテレオペ）と、記録の再生のときだけにしました。依頼箱では普段、実機を動かす依頼は自動で始めないので、この依頼は「確認待ち」に置き、カメラとアームをつないだあとで実行に回しました。

| 段階 | 何を測るか | アーム |
|---|---|---|
| 0 | つながり（基板2枚・サーボ12個・カメラ2台） | 動かさない |
| 1 | 机側カメラのピント | 動かさない |
| 2 | 関節とカメラを読む速さ | 動かさない |
| 3 | 爪の開け閉めで、3つの流れの時刻のずれ | テレオペ |
| 4 | ゆっくり・ふつう・速くの3段 | テレオペ |
| 5 | LeRobot の記録の形（10秒×3回） | テレオペ |
| 6 | 記録の1回を2回再生して、関節の正確さ | 再生 |
| 7 | 推論中に人が割り込む仕組み | コードを読むだけ |

同期を確かめる方法は、爪をすばやく閉じる・開くことにしました。爪は手首カメラにも机側カメラにも写り、関節の値（爪の軸）にも出ます。同じ出来事が3つの流れのどこに出るかを比べれば、時刻のずれが ms で出ます。

#### 依頼258 の依頼文（全文）

```markdown
---
作業フォルダ: /Users/shimazueiichi/r2r2r-scripts
上限時間: 150
---
# SO-101 で Mac・カメラ2台・アームから取れるデータを全部確かめる（依頼258）

お手本集めと学習に入る前に、SO-101 の構成で「どんなデータが、どの速さ・どの精度・どのずれで取れるか」を実測する。エイイチは机の前にいて、画面の指示どおりにリーダーアームを動かす。**フォロワーは、エイイチがリーダーで動かすテレオペと、最後の再生（6.）のときだけ動く。それ以外の指令は送らない。**

## 前提（依頼248・257 の結果）
- LeRobot は `~/lerobot`、conda 環境 `lerobot`。キャリブレーション済み（`ptm_follower`・`ptm_leader`）
- ポート：フォロワー `/dev/tty.usbmodem5CBC4321631`、リーダー `/dev/tty.usbmodem5CBC4323581`（変わっていたら電圧で見分け直す）
- カメラ：手首＝「USB HD Camera」（HBVCAM）、机側＝「Innomaker-U20CAM-720P」。番号は決め打ちにせず、`so101/desk_cam_focus_257.py` と同じく名前で突き合わせる。依頼257 では Innomaker がつながっておらず、ピント合わせは済んでいない
- 出力は全部 `/Users/shimazueiichi/r2r2r-scripts/so101/check_258/` に置く。データ・画像・動画は git に入れない。KIOXIA には何も作らない（SO-101 の置き場所はまだ決めていない）

## 進め方
エイイチへの指示は、必ず画面のウィンドウに大きな字で出す（ターミナルは見ない前提）。各段階の前に「何秒、何をするか」を出し、スペースで始める。q でいつでも止める。

### 0. つながりを確かめる（動かさない）
- 2枚の基板・サーボ12個・カメラ2台が見えるか。足りなければここで止めて報告
- iPhone（連係カメラ・Iriun）が見えていたら、そのことを書く

### 1. 机側カメラのピント
- `so101/desk_cam_focus_257.py` を起動。エイイチがピントと置き場所を合わせ、スペースで保存して q で終える
- 保存した画像のピントの数値を、依頼248 の画像（中央 2.6）と並べる

### 2. 読み取りの速さ（動かさない）
- 関節：フォロワーとリーダーの位置を同時に読む（LeRobot の sync_read）のを30秒続け、1回にかかる時間の分布（中央値・95%・最大）と、30Hz に収まるかを出す。フォロワーは電流・負荷・温度・電圧も読めるか、読むと何 ms 増えるかも
- カメラ：2台を 1280x720 と 640x480・MJPG・30fps で同時に開き、30秒、1コマごとに届いた時刻（Mac の時計）を記録。実際の fps、コマの間隔の揺れ、落ちたコマ、2台の届く時刻の差を出す。露出・ホワイトバランスが自動か、自動ならどの値か（書き換えはしない）
- カメラ2台とサーボ読みを同時に回したときに、どれかが遅くならないか

### 3. 時刻のずれ（テレオペ）
- テレオペ中に、エイイチがリーダーの爪をすばやく閉じる・開くを5回する。爪は手首カメラにも机側カメラにも映り、関節（爪の軸）にも出るので、同じ出来事が3つの流れのどこに出るかで、手首カメラ・机側カメラ・関節のずれ（ms）を出す。爪の動き始めは、画像の差分で決める
- あわせて、リーダーの角度（action）に対してフォロワーの角度（state）がどれだけ遅れて追いつくかも出す

### 4. 速く動かしていいか（テレオペ）
- ゆっくり・ふつう・速く、の3段で、それぞれ15秒、エイイチが大きく腕を動かす
- 関節ごとに：最大の速さ（°/秒）、リーダーとの差の最大、電流・負荷の最大、温度の上がり方
- 映像：速い段のコマのぶれ（ピントの数値の下がり方）と、フォロワーがリーダーに追いつけずに離れた区間
- LeRobot の SO-101 のフォロワーに、1回に動ける量の上限（max_relative_target など）がどう設定されているか、今の値を読む（変えない）
- テレオペの始めに、リーダーとフォロワーの姿勢が違うとフォロワーが飛ぶかを、コードで確かめて書く（実機では試さない）

### 5. LeRobot の記録の形（テレオペ）
- `lerobot-record` で、10秒×3回の練習を記録する（root は `so101/check_258/dataset/`。Hugging Face には上げない）。fps 30、カメラ名は `wrist` と `desk`
- 記録された形をそのまま報告する：meta の info.json の features（state・action・画像の名前と形・型）、parquet の列、動画の形式（コーデック・解像度・fps）、timestamp の付き方（カメラの実際の撮影時刻か、コマの番号から作った時刻か）
- 1秒あたり・1回あたりの大きさ（MB）。1回を何秒にすると、100回・1000回でどれだけになるか
- 3.で測った時刻のずれと届いた時刻の揺れが、記録された timestamp にどう現れるか（または現れないか）

### 6. 関節の値は正確か
- 記録した1回を `lerobot-replay` でフォロワーに再生する（速さは記録のまま。始める前にウィンドウで確認を取る）。同じ回を2回再生し、到達した角度を記録と2回目で比べる（繰り返しの差・最大の差を関節ごとに）
- サーボの分解能（1目盛が何度か）と、キャリブレーションのファイルの値から、角度の変換が正しいかを確かめる
- 爪の値（開き具合の数字）と、手首カメラに映る爪の開きが合っているか

### 7. 動きを直す仕組み（コードを読むだけ）
推論の途中で人がリーダーで引き取って直し、その区間をお手本として使う流れを作りたい。今の LeRobot（入っている版）で：
- 方策を動かしながら人が割り込む仕組み（HIL・intervention・teleop の割り込み）があるか、どのコマンド・設定か
- 割り込んだ瞬間、リーダーとフォロワーの姿勢が違うときにどうなるか（飛ぶか、合わせるまで待つか）。SO-101 のリーダーのサーボに、フォロワーの姿勢へ寄せる力を入れられるか
- 人が直したコマと AI が動かしたコマを、記録の中で区別できるか（列があるか）
- 実機では試さない。結果と、足りない所を報告に書くだけ

## 絶対にしないこと
- キャリブレーションのやり直し、サーボの EEPROM・ID・上限値の書き換え、max_relative_target などの安全の値の変更
- テレオペと 6. の再生以外でフォロワーに指令を送ること
- カメラの設定の書き換え
- KIOXIA に新しいフォルダを作ること、Hugging Face への送信
- `git add .`・`git clean`

## 報告に書くこと
- 0〜7 の結果を、表を中心に（数値には測った条件を添える）
- 速く動かすときの目安（どの関節が先に限界に来るか、映像のぶれが出始める速さ）
- 時刻のずれの値と、学習のデータとして問題になる大きさか
- 記録の形の実物（features の一覧）と大きさの見積もり
- 直す仕組みで、今の LeRobot でできること・できないこと
- 書いた・使ったスクリプトは `so101/` に置いて個別に add・commit
- 最後の1行に「判定：合格／止めた（決めてほしいことあり）／失敗」
```


## 作業ログ ― 画面の大きな字の指示どおりに、リーダーを動かして測った

依頼258 は 17:00 に始まり、Claude Code が測るスクリプトを書いたあと、17:07 に Mac に指示のウィンドウが開きました。指示は全部このウィンドウに大きな字で出て、スペースで次へ進み、q でいつでも止められます。

【画像】LOG551_04_connection_ok.png 段階0の画面。フォロワーとリーダーのサーボが6個ずつ、手首カメラは OpenCV の1番、机側カメラは0番、iPhone（Iriun）も見えている

最初のつまずきは、段階0の画面のままピント合わせを待っていたことでした。この画面でスペースを押すと、段階1の説明に進み、もう一度スペースでピント合わせの画面が開く作りでした。

### テレオペの前に、リーダーをフォロワーと同じ姿勢にそろえた

テレオペを始める前の画面には、リーダーとフォロワーの角度の差が関節ごとに出て、関節1〜5 は 10° 以内・爪は 15 以内になるまで始められないようにしてありました。LeRobot は、テレオペの1コマ目からリーダーの角度をそのままフォロワーに送ります。差が大きいまま始めると、フォロワーがその差を一気に動くからです。最初は肩（2つ目の shoulder）が −16.8°、手首（wrist_fl）が +34.6° ずれていて、リーダーを手で動かしてそろえました。

【画像】LOG551_06_teleop_ready.png テレオペの準備の画面。リーダーとフォロワーの角度の差が6か所とも上限の内側（○）になり、スペースで始められる状態

### 速い段の机側カメラの映像

「速く」の段では、15秒のあいだ腕全体を大きく、速く動かしました。机側カメラの映像では、フォロワーが大きく振れているのが分かります。

【動画】LOG551_05_fast_teleop.mp4 「速く」の段の15秒を、机側カメラで写した映像。白いフォロワーアームが大きく振れ、リーダーを動かす手が一瞬写る

### 再生の準備では、フォロワーを手で動かして記録の最初の姿勢に合わせた

段階6の再生の準備で、フォロワーがリーダーについてこない、という場面がありました。これは作りのとおりで、再生ではリーダーを使わず、力の抜けたフォロワーを手で動かして、記録の最初の姿勢に合わせる段階でした。差は手首が −65.4°、肩が −34.1° あり、手でそろえてから再生しました。

【画像】LOG551_08_replay_ready.png 再生の準備の画面。記録の最初の姿勢とフォロワーの差が4か所で大きく（×）、手でフォロワーを動かしてそろえる前の状態

17:51 に段階0〜6 がすべて終わり、17:54 に報告が届きました。


## 作業ログ ― SO-101 と LeRobot から取れるデータは、こうなっていた

### 関節の値は 0.088° 刻みで、記録を再生した差は最大 1.05°

SO-101 のサーボ STS3215 は1回転を 4096 目盛で読むので、1目盛は 0.0879° です。キャリブレーションの値は12個ともサーボの中とファイルで一致し、生の値から角度に直す式も、LeRobot の値と差 0.000 でした。記録の1回を2回再生すると、再生の始め 0.5 秒を除いて、記録との差は最大 0.62°、2回の再生どうしの差は最大 1.05° でした。

角度の 0° は「キャリブレーションで動かした範囲の真ん中」で、物の向きや水平といった物理的な基準ではありません。キャリブレーションをやり直すと、同じ数字が違う姿勢を指すことになるので、校正のファイルはデータと組で残す必要があります。

【画像】LOG551_07_gripper_vs_wrist.png 手首カメラの6コマと、そのときの爪の値。1.0〜1.5 で爪が閉じ、30.7 で開きかけ、98.2 で片側が画面の外まで開く

爪の値は、1 で閉じ、98 で全開でした。手首カメラに写る爪の開きと、向きも大きさも合っていました。ただし記録の3回では爪を動かしていないので、再生での爪の正確さは見ていません。

### 手首カメラと関節のずれは1コマ以内、机側カメラは測れなかった

リーダーの爪が動き始めた時刻を 0 として、ほかの流れに動きが出た時刻を比べました。5回のうち、1回目はリーダーの爪が動いておらず、2回目は合図より前に動いていたので、3回分を使いました。

| 回 | フォロワーの爪（関節） | 手首カメラ | 机側カメラ |
|---|---|---|---|
| 3 | +102ms | +111ms | +124ms |
| 4 | +102ms | +92ms | +43ms |
| 5 | +100ms | +74ms | −44ms |

**手首カメラとフォロワーの関節の差は +9 / −10 / −26ms で、3回とも1コマ（33ms）以内に収まりました。** 机側カメラは、画面の中の爪が小さくて動き始めが決められず、−44〜+124ms とばらつきました。この値は使えません。ただ、カメラ2台のコマが Mac に届く時刻の差は、中央値で 1.7〜7.5ms でした。机側カメラも大きくずれてはいないとみていますが、本番のお手本を撮る前に、大きく写る物で測り直します。

【図解】LOG551_so101_data_check.html

### 記録の時刻は「コマの番号 ÷ 30」で、カメラが撮った時刻は残らない

LeRobot の記録（`lerobot-record`）の中身は、action と observation.state（どちらも6つの角度）、2本の動画（av1・640x480・30fps）、timestamp などの番号です。timestamp は3回とも「コマの番号 ÷ 30」と完全に一致し、間隔は 33.33ms で揺れが 0 でした。

一方、カメラから実際にコマが届く間隔は、95% で 35〜36ms と揺れていて、30秒で 4〜13 コマ落ちていました。LeRobot は毎回、各カメラの「その時点の最新のコマ」を取り込むので、コマが落ちると前のコマがそのまま入り、時刻は等間隔のままです。記録だけを見ても、どのコマが落ちたかは分かりません。今の落ち方（1% 前後）なら学習への害は小さいとみていますが、落ちた数は別に数えておく必要があります。

大きさは1秒あたり 0.227MB でした。1回30秒なら 100回で 681MB、1000回で 6.8GB です。

### フォロワーはリーダーより約0.1秒遅れ、150°/s を超えると手首カメラがぶれる

フォロワーは、関節ごとに 100〜130ms 遅れてリーダーについてきました（爪だけ 170ms）。「速く」の段では、根元の回転が最大 203°/s、手首が 183°/s で、リーダーとの差は最大 33° でした。差はほぼ「速さ × 0.1秒」で、サーボの速さが頭打ちになったわけではありません。温度の上がりは全体で 1〜2℃ でした。

手首カメラの映像は、関節の速さが 150°/s を超えると、止まっているときよりピントの数値が約15% 下がりました。お手本は 150°/s より遅く動かして撮ります。

| 関節 | ゆっくり 速さ/差の最大 | ふつう | 速く | 速く 電流の最大/負荷の最大 |
|---|---|---|---|---|
| shoulder_pan（根元の回転） | 106°/s / 14.4° | 101 / 13.7 | 203 / 33.1 | 260mA / 82% |
| shoulder_lift（肩） | 86 / 11.4 | 114 / 16.1 | 147 / 24.8 | 559mA / 75% |
| elbow_flex（ひじ） | 111 / 16.5 | 121 / 17.9 | 170 / 24.0 | 130mA / 61% |
| wrist_flex（手首の曲げ） | 107 / 14.2 | 154 / 21.1 | 183 / 26.7 | 214mA / 68% |
| wrist_roll（手首の回転） | 10 / 3.6 | 0 / 0.4 | 60 / 8.7 | 39mA / 28% |

### 再生の始めに、フォロワーの肩とひじが 35〜42° 飛んだ

再生の前の確認では、記録の最初の姿勢との差は 10° 以内でした。ところが再生1の最初のコマで、肩は −103° → −68.5°、ひじは 91° → 49.8° と、35〜42° 動いていました。動いた向きは、記録の最後（3回目の終わりの、腕を上げた姿勢）と同じです。サーボの中に前の記録の終わりの目標の角度（Goal_Position）が残っていて、再生でサーボに力が入った瞬間、新しい指令より先にそこへ動いたとみています。2回目の再生では起きておらず、原因はまだ確定していません。

記録の3回は、どれも腕を上げた姿勢で終わっていました。記録の終わりにはサーボの力が抜けるので、フォロワーは落ちたはずです。記録を休みの姿勢で終える決まりが要ります。

LeRobot の設定で、フォロワーが1コマに動ける量の上限（max_relative_target）は、既定では「上限なし」でした。今回の記録と再生も、上限なしで動いていました。

### LeRobot 0.7.1 には、推論の途中で人が割り込む DAgger の仕組みがある

学習したモデルで動かしている途中で失敗したら、人がリーダーで引き取って直し、その区間をお手本に足して学ばせたい。この流れは、LeRobot 0.7.1 の `lerobot-rollout --strategy.type=dagger` でできることが分かりました（コードを読んだだけで、実機では試していない）。

- space で一時停止と再開、tab で直す区間の始めと終わり
- 一時停止したとき、リーダーに力を入れて、フォロワーの姿勢へ2秒かけて寄せてから人に渡す。割り込む瞬間に姿勢が食い違って飛ぶことはない
- 人が直したコマには `intervention` の列で印が付き、AI が動かしたコマと分けられる
- 方策の最初の動きをならす仕組みがあるかは確かめられていない。再生で起きた「前の目標へ飛ぶ」問題は、この仕組みでも起きるはず

mechArm 270 では、推論を止めてゲームパッドで直す道具を自分で作っていました。SO-101 では、リーダーアームそのものが直す道具になります。


## 作業ログ ― お手本を撮る前に決めたことと、次の依頼259

報告の「決めてほしいこと」は6つありました。それぞれにおすすめを付けて出し、6つともおすすめどおりで進めることになりました。

| 決めること | 決めた答え | 理由 |
|---|---|---|
| 再生の始めに飛ぶ対策 | A（力を入れる前に、サーボの目標を今の位置に書く）と B（1コマに動ける量を 10° 前後に制限）の両方 | A で原因を消し、B を柵にする。速い段でも1コマの動きは 7° 程度なので、B はふだんの操作を止めない |
| テレオペ前に Claude Code が足した一手 | 認める | 依頼に書いていない操作だったが、A と同じ考え方で、アームは動かない |
| 記録の終わりの姿勢 | 休みの姿勢で終える決まりにする | 記録の終わりに落ちるのを防ぐ |
| 机側カメラの同期の測り直し | 後回し（本番前に1回） | 手首カメラは関節と1コマ以内で、カメラ2台の届く時刻もほぼそろっている |
| お手本の解像度 | 640x480・30fps | Physical Intelligence の π0.5 は画像を 224×224 ほどに縮めて使うので、1280x720 は重くなるだけ |
| 露出・ホワイトバランス | 本番前に固定する | 自動のままだと、お手本ごとに明るさが揺れる。Mac の OpenCV では値を読めなかったので、別の道具を探す |

- ねらい：お手本を撮り始めてから、飛び・落下・明るさの揺れで撮り直しにならないようにする
- 変わったこと：LeRobot の記録・再生・テレオペ・割り込みを、こちらで作る共通の入口から呼ぶ形にする。入口で、A・B・休みの姿勢・カメラの設定を必ず通す
- 見込める効果：再生や推論の始めの飛びがなくなる見込み。次の実機の確かめで、わざと前の目標を残した状態から再生して確かめる

関節の制御に関わる変更なので、依頼259 は実装と codex のレビューまでにとどめ、アームは動かしません。実機での確かめは、その次の依頼で人が机の前にいるときに行います。LeRobot 本体のコードは書き換えず、外側から包む形にしたので、LeRobot の版を上げても対策は消えません。依頼259 の結果は次の記録に書きます。

#### 依頼259 の依頼文（全文）

```markdown
---
作業フォルダ: /Users/shimazueiichi/r2r2r-scripts
上限時間: 150
---
# SO-101 の「力を入れた瞬間に飛ぶ」の対策と、カメラの露出の固定を作り、レビューまで通す（依頼259）

依頼258（報告：`so101/check_258/REPORT.md`、作業の続きは `claude --resume 629cc0d1-6706-4407-9693-4151d50f1ae7`）の「決めてほしいこと」に、エイイチが次のとおり決めた。**この依頼ではアームを動かさない。**関節制御に関わる変更なので、実装と外部レビューまでにとどめ、実機での確かめは次の依頼（確認待ち）で行う。

## 決まったこと
1. 飛び止めは A と B の両方を入れる
   - A：フォロワーに力（トルク）を入れる前に、各サーボの目標位置（Goal_Position）を今の位置（Present_Position）に書いておく。依頼258 のテレオペで足した一手と同じ考え方。電源を切ると消える領域だけに書く（EEPROM には書かない）
   - B：`max_relative_target` を設定する。値は 1コマ（30Hz）あたり 10° を基本にする。依頼258 の「速く」の段の1コマあたりの最大の動き（関節ごと）を check_258 のデータから出し、10° でふだんのテレオペを妨げないかを数字で確かめて報告する。妨げる関節があれば値の案を出して止める（勝手に大きくしない）
2. 依頼258 で足した A の一手は認める
3. 記録は休みの姿勢で終える、を決まりにする
4. 机側カメラの同期の測り直しは後回し（この依頼ではしない）
5. お手本の解像度は 640x480・30fps・MJPG
6. 露出・ホワイトバランスは本番の前に固定する

## 作るもの
- `so101/` に、LeRobot の record・replay・teleoperate・rollout（dagger）を呼ぶときの共通の入口（ラッパー）を作る。`~/lerobot` のコードは書き換えない（版を上げても消えないように、こちら側で包む）
  - 力を入れる前に A を必ず通す。LeRobot の中で力が入る所（connect・configure など）を読み、どこに差し込めば確実かを報告に書く
  - B の値と、カメラの設定（wrist・desk、名前で見分ける、640x480・30fps・MJPG）を既定値として持つ。番号の決め打ちはしない
  - 記録の各回の終わりに、フォロワーが休みの姿勢の近く（関節ごとの許容の幅は休みの姿勢の記録から決める）に戻るまで力を抜かない。戻っていなければウィンドウに大きな字で「リーダーで休みの姿勢へ」と出して待つ。休みの姿勢の値は、依頼258 のデータ（テレオペを始める前のフォロワーの姿勢）から作り、ファイルにして置く
- 露出・ホワイトバランスの固定
  - Mac で UVC カメラの露出・ホワイトバランス・ゲインを読み書きできる道具を探して入れる（uvc-util など。入れたものと版を報告に書く）
  - 2台のカメラで、今の自動の値を読む。その値の近くで手動に固定し、10秒撮って明るさ（画面の平均の明るさ）の揺れが自動のときより小さいかを比べる
  - 固定に使った値は、カメラごとに設定ファイルにして `so101/` に置き、ラッパーが記録の前に必ず当てる。カメラを抜き差しすると設定が戻るかも確かめて書く
  - 固定できない場合（道具が動かない・カメラが対応していない）は、そこで止めて報告する
- テスト：アームにつながずに確かめられる所（A を通る順番・B の値の受け渡し・休みの姿勢の判定・設定ファイルの読み込み）を、偽のモーターでテストする

## 外部レビュー
- 実装のあと、codex にレビューを頼む（テンプレートは `code_review_request_template.md` の形。物理的リスクのある変更として、力を入れる順番・飛びが残る道・B が効かない道を重点に）
- 指摘のうち必須のものは直し、推奨・据え置きは報告に分けて書く

## 絶対にしないこと
- フォロワーに力を入れる・動かすこと（サーボを読むのは可）
- EEPROM・ID・上限値の書き換え、キャリブレーションのやり直し
- `~/lerobot` のコードの書き換え
- KIOXIA に新しいフォルダを作ること、Hugging Face への送信
- `git add .`・`git clean`

## 報告に書くこと
- A を差し込んだ場所と、それで飛びが止まる理由。止まらない道が残っていればそれも
- B の値と、依頼258 のデータでの確かめ（関節ごとの1コマあたりの最大の動き）
- 露出の固定に使った道具と値、固定前後の明るさの揺れの比べ
- テストの結果、codex の指摘と直したもの
- 次の実機の確かめ（確認待ちで出す依頼）でやるべき手順の案：わざと目標を残した状態で再生しても飛ばないか、など
- 変えたファイル（個別に add・commit）
- 最後の1行に「判定：合格／止めた（決めてほしいことあり）／失敗」
```


## 作業ログ ― この記録の数字を、LeRobot でデータ収集を始める人向けのガイドにした

この記録の実測を、検索から初めて来た人が使えるチェックリストに並べ直し、ガイド「[LeRobot の lerobot-record でデータ収集する前に確かめること](https://pixelstomotors.com/guide/lerobot-data-collection-checklist)」として公開しました。記録（LOG）は日付つきの作業の記録で、ガイドは版や数字が変わったら書き直す手順書です。

### 検索されているのは「データ収集」ではなく、コマンド名と機体名だった

Google 広告のキーワードプランナーで、日本の月の検索回数を調べました。日本語の「LeRobot データ収集」「模倣学習 データ収集」「ロボット カメラ 同期」などは、どれもデータなしでした。人が打っているのは、`lerobot record`・`lerobot dataset`・`lerobot replay` のようなコマンドの名前と、SO-101・SO-ARM101 のような機体の名前でした。そこで、ガイドの主の語を `lerobot record` にし、題の頭に検索の多い「LeRobot」を置きました。`lerobot replay` は前の年に検索がなく、出てきたばかりの語です。

検索の上位は、販売元の Seeed の日本語のページ、クラスメソッドの技術ブログ、海外のサイトの機械翻訳などでした。同期については「サポートしている」「タイムスタンプで整列する」と書くだけで、ずれを ms で測った値はありませんでした。測った値・記録の時刻の正体・再生の飛び・動かす速さの上限・データの大きさを、ガイドの柱にしました。

- ねらい：この記録の数字を、LeRobot でお手本を撮り始める人が検索で見つけられる形にする
- 変わったこと：記録の中に散らばっていた数字を、13項目のチェック表と、検索で打たれる問いの形の見出し（「lerobot-replay でアームが飛ぶのはなぜ？」など）に並べ直した
- 見込める効果：`lerobot record`・`lerobot replay` での検索の表示とクリックが出る見込み。公開から約4週間後に Search Console で確かめる

#### キーワードと検索結果の下調べ guide_lerobot-data-collection_keywords_20261122.md（全文）

```markdown
# ガイド「LeRobot の lerobot-record でデータ収集する前に確かめること」の下調べ（2026-11-22）

## キーワードプランナー（日本・月の平均検索回数。studio@adaptdesign.jp のアカウントで 2026-11-22 に取得）

| 語 | 月の平均検索回数 | 前年比 | 競合性 | このガイドでの扱い |
|---|---|---|---|---|
| LeRobot | 1000〜1万 | 0% | 低 | 既存のガイド「LeRobot で SO-101 を動かす始め方」の主。ここでは題の頭に置くだけ |
| SO-101（so 101） | 1000〜1万 | 0% | 中 | 同上 |
| lerobot so 101 | 100〜1000 | 0% | 中 | 同上 |
| SO-ARM101 | 100〜1000 | 0% | 高 | タグ |
| テレオペ | 100〜1000 | 0% | 低 | 本文・タグ |
| 模倣学習 | 100〜1000 | 0% | 低 | 本文・タグ |
| ロボットアーム 自作 | 100〜1000 | 0% | 中 | 使わない（中身が違う） |
| **lerobot record（主）** | 10〜100 | 0% | 低 | 題・冒頭の答え・タグ |
| lerobot dataset（副） | 10〜100 | 0% | 低 | 見出し「LeRobot のデータセットの大きさは？」・タグ |
| lerobot replay（副） | 10〜100 | 前年比 +∞ | 低 | 見出し「lerobot-replay でアームが飛ぶのはなぜ？」・タグ |
| SO-101 カメラ（副） | 10〜100 | 0% | 低 | 見出し「確かめること1：SO-101 のカメラは…」・タグ |
| so arm101 lerobot | 10〜100 | 0% | 高 | タグ |
| ACT 模倣学習 | 10〜100 | 0% | 低 | 使わない（ACT は試していない） |
| テレオペレーション | 10〜100 | 0% | 低 | ― |
| 模倣学習 ロボット | 10〜100 | 0% | 低 | ― |
| 遠隔操作 ロボットアーム | 10〜100 | 0% | 低 | ― |
| フィジカルAI 個人 | 10〜100 | +∞ | 低 | タグ |
| dagger | 1000〜1万 | 0% | 低 | 短剣の意味の検索が中心とみて、主にしない。本文の言葉として使う |
| LeRobot データ収集・LeRobot データセット・LeRobot 使い方・LeRobot カメラ・LeRobot テレオペ・SO-101 データ収集・テレオペ 遅延・模倣学習 データ・模倣学習 データセット・模倣学習 データ収集・模倣学習 やり方・ロボット データ収集・ロボット 学習データ・ロボット カメラ 同期・手首カメラ・ロボットアーム 模倣学習 | データなし | | | ― |

読み取り：日本語の「データ収集」側の語はどれもデータなし。人が打つのはコマンド名（lerobot record・lerobot replay）と機体名（SO-101・SO-ARM101）。主の語をコマンド名の「lerobot record」にし、題の頭に検索の多い「LeRobot」を置く。lerobot replay は前年比 +∞ で、出てきたばかりの語。

## 検索結果の上位（「LeRobot データ収集 SO-101」「SO-ARM101 lerobot-record やってみた」で検索）

| ページ | だれ | 中身 |
|---|---|---|
| wiki.seeedstudio.com/ja/robotics/soarm_physical_ai_course_chapter_12/ | 販売元の Seeed（日本語のコース） | lerobot-record の手順。ループはタイムスタンプで整列する、640×480 MJPG 30fps が安全、と説明 |
| wiki.seeedstudio.com/ja/robotics/hands_on_camera_recording/ | Seeed | カメラの番号は再接続で変わる。毎回 lerobot-find-cameras で確かめる |
| wiki.seeedstudio.com/ja/robotics/hands_on_task_design/ | Seeed | エピソード・開始と終了の条件・固定した初期姿勢 |
| roboticscenter.ai/ja/hardware/so-101/data-collection | 海外のサイトの機械翻訳 | 録画のつなぎ方。LeRobot はマルチカメラ同期をサポート、と書く |
| zenn.dev（karaage0703） | 個人 | SO-101 のテレオペから学習データ取得まで（Jetson） |
| dev.classmethod.jp（アヒルを掴む・ACT で模倣学習） | クラスメソッドの技術ブログ | 640×480・15fps、30〜50 エピソード、ACT の学習と成功率 |
| nvidia.github.io/IsaacCapture（Data Collection in Real） | NVIDIA（英語） | SO-101 の記録のスクリプト |

## 上位にないこと（ガイドの柱にする）

- 手首カメラ・机側カメラ・関節のずれを ms で測った値（手首カメラと関節は1コマ以内）。上位は「同期をサポート」「タイムスタンプで整列」と書くだけで、測った値がない
- timestamp が「コマの番号 ÷ 30」で、撮影時刻が残らないこと。コマ落ち（30秒で 4〜13 コマ）が記録から見えないこと
- 速く動かしたときのフォロワーの遅れ（約0.1秒）と、映像がぶれ始める速さ（150°/s）
- lerobot-replay の始めに 35〜42° 飛んだことと、その対策（目標の角度の書き直し・max_relative_target）
- 記録を腕を上げたまま終えるとフォロワーが落ちること
- データの大きさ（1秒 0.227MB、30秒×1000回で 6.8GB）
- DAgger（lerobot-rollout）で人が割り込める作り

## 重なりの確認

- 「LeRobot で SO-101 を動かす始め方」（lerobot-so101-getting-started）：テレオペまで。このガイドはその次の段（お手本を撮る前）。互いにリンクする
- 「ロボットアームの模倣学習、お手本は何本・どう集めるか」（robot-arm-demonstration-data）：お手本の本数と集め方。このガイドは記録の中身と機体の確かめ。互いにリンクする
- 中身はすべて LOG551（依頼258 の実測）から
```

### サムネイルの絵は、手首カメラの付き方で3回直した

ガイドのサムネイルは、決まりどおり ChatGPT に絵を描かせ、網点の仕上げと題の文字は Claude が入れました。最初の絵は、前の SO-101 のガイドとアームの並びも見る角度もほぼ同じだったので、作業台を真上から見下ろす構図に変えました。

真上からの絵には手首カメラが描かれておらず、足してもらうと、爪の付け根の真ん中に上向きのレンズが付きました。実物の手首カメラは、爪の固定側の付け根から L 字の台が立ち上がり、爪の上に張り出した四角い枠にはまっています。実物の写真を見せて直すと、今度はレンズが爪の付け根の方を向きました。手首カメラは爪の先とつかむ物を見るための物なので、レンズが爪の先を向くように、もう一度直しました。

【画像】LOG551_09_thumbnail_drafts.jpg ChatGPT に描かせた4つの版。1は前のガイドと構図が似ていた。2は手首カメラが爪の付け根の真ん中に付いた。3はレンズが爪の付け根の方を向いた。4でレンズが爪の先を向いた

もう1つつまずいたのは、網点の仕上げでした。白いフォロワーと白っぽい天板が同じ明るさの紙の白になり、アームが影だけになりました。天板を灰色で描き直してもらうとアームは浮きましたが、そのままでは題の下まで網点で埋まります。網点にする前に、灰色の天板だけを明るく寄せる手順を足し、白いアームが輪郭ごと残るようにしました。

【画像】LOG551_10_guide_thumbnail.jpg 仕上げたガイドのサムネイル。真上から見た白いフォロワーが赤いブロックをつかもうとし、爪の上の手首カメラのレンズが爪の先を向いている。右上に題

#### 天板を明るく寄せる関数 lighten_table（tools/guide_thumbs/make.py の一部）

```python
def lighten_table(src):
    """灰色の天板（白いアームを浮かせるため ChatGPT に灰色で描かせた）を明るく寄せ、題の下の網点を薄くする。
    白いアーム(>175)・黒(<60)・赤は変えない。2026-11-22 lerobot_record で使った"""
    import cv2
    a=np.asarray(Image.open(src).convert("RGB")).astype(float); v=a.mean(2)
    sat=cv2.cvtColor(a.astype(np.uint8),cv2.COLOR_RGB2HSV)[...,1]/255
    m=(sat<0.25)&(v>=60)&(v<=175)
    k=np.where(m,np.interp(v,[60,125,175],[120,200,215])/np.maximum(v,1),1.0)
    out=src.replace(".png","_light.png"); Image.fromarray(np.clip(a*k[...,None],0,255).astype(np.uint8)).save(out); return out
```

#### このガイドのサムネイルを書き出す1行（tools/guide_thumbs/make.py）

```python
"lerobot_record": lambda: card(lighten_table("g/gd_lerobot_record.png"),"gd_lerobot_record.jpg",["データ収集の","前に確かめる"],"LeRobot・SO-101 で測った",accent="red",tx=1810,ty=110,align="r",ts=96,ss=38,gamma=1.0),
```


## 作業ログ ― 依頼258 の報告・コード・データ（全量）

ここから下は、依頼258 で Claude Code が書いた報告、測ったスクリプト、出力のデータです。データ・画像・動画は git に入れず、Mac の `/Users/shimazueiichi/r2r2r-scripts/so101/check_258/` に置いています（KIOXIA と Hugging Face には何も作っていない）。

### 依頼258 の報告（全文）

```markdown
# 結果：20261122_258_SO101でMacとカメラとアームから取れるデータを全部確かめる

- 状態：完了
- 始めた時刻：2026-11-22 17:00
- 終わった時刻：2026-11-22 17:54（54分）
- 作業フォルダ：/Users/shimazueiichi/r2r2r-scripts
- この続きを Claude Code で話すとき：作業フォルダで `claude --resume 629cc0d1-6706-4407-9693-4151d50f1ae7`

## Claude Code の報告

やったこと：机の前のエイイチがウィンドウの大きな字の指示どおりに操作し、段階0〜6を順に計測しました（17:07〜17:51、6段階とも最後まで終了）。段階7はコードを読むだけにしました。
- 段階0：つながりの確認
- 段階1：机側カメラのピント合わせ
- 段階2：読み取りの速さ（動かさない）
- 段階3・4：テレオペ（爪の開け閉め5回と、ゆっくり・ふつう・速くの3段）
- 段階5：lerobot-record で10秒×3回の記録
- 段階6：lerobot-replay で記録の1回を2回再生

結果：
- **0. つながり**：フォロワーもリーダーもサーボ6個ずつ見えました。カメラは手首が OpenCV 1、机側が OpenCV 0 です。iPhone（Iriun）も見えていました。
- **1. 机側カメラのピント**：中央の数値は、依頼248 の画像の 2.6 から 1286〜1330 に上がりました（1280x720 で測定）。
- **2. 読み取りの速さ**
  - 関節：フォロワーとリーダーを両方読んで、1回あたり中央値 2.3ms・95% 3.9ms・最大 8.1ms。30Hz の1コマ（33ms）を超えた回は 900回中 0 回です。
  - 電流・負荷・温度・電圧も読めました。1つあたり約 1ms で、4つ足すと1回あたり約 +4ms です。
  - カメラ：2台とも、1280x720 でも 640x480 でも約 30fps でした。コマの間隔は 95% で 35〜36ms、落ちたコマは30秒で 4〜9 です。
  - カメラ2台と関節を同時に回すと、手首カメラに 150ms の穴が1回、関節の1回が 33ms を超えたのが2回ありました。
  - 露出・ホワイトバランスは、Mac の OpenCV では全部 0 が返り、自動かどうか・その値は読めませんでした。
- **3. 時刻のずれ**
  - フォロワーはリーダーより約 100〜130ms 遅れて追いつきます（爪だけは 170ms）。
  - 手首カメラとフォロワーの関節は、爪の動き始めの差が +9 / −10 / −26ms で、1コマ以内に揃っています。
  - 机側カメラは画面の中の爪が小さく、−145〜+22ms とばらついて信用できません。
  - 5回のうち1回目はリーダーの爪が動いておらず、2回目は合図より前に動きがあったため、使えたのは3回分です。
- **4. 速く動かしていいか**
  - 「速く」の段の最大の速さは、shoulder_pan 203°/s、wrist_flex 183°/s です。そのときリーダーとの差は最大 33° でした。
  - 差はほぼ「速さ × 約0.1秒」で、サーボが速さの上限で頭打ちになった形ではありません。
  - 先に苦しくなるのは shoulder_pan と wrist_flex です。電流がいちばん大きいのは shoulder_lift（559mA、負荷 75%）でした。温度は全体で +1〜2℃ です。
  - 手首カメラのぶれは、150°/s を超えると約15% 出始めます。
  - max_relative_target は既定のまま None（制限なし）でした。姿勢が違うままテレオペを始めると、ならす仕組みがないのでフォロワーが飛ぶことをコードで確かめました。
- **5. LeRobot の記録の形**
  - 中身は、action と observation.state（どちらも float32 で6つ）と、動画2本（wrist・desk：av1、640x480、30fps）です。
  - timestamp は「コマの番号 ÷ 30」で、実際の撮影時刻は保存されません。そのため、上で測ったずれや揺れは timestamp には一切現れません。コマが落ちると前のコマがそのまま入ります。
  - 大きさは毎秒 0.227MB です。1回30秒なら 100回で 681MB、1000回で 6.8GB になります。
- **6. 関節の値は正確か**
  - 再生の始め 0.5 秒を除くと、記録との差は最大 0.62°、2回の再生どうしの差は最大 1.05° でした。
  - キャリブレーションの値は12個ともサーボの中と一致し、角度の変換も式と差 0 でした。1目盛は 0.0879° です。
  - 爪の値と手首カメラの映像は、向きも大きさも合っていました（1 で閉じ、98 で全開）。ただし記録した3回では爪を動かしていないので、再生で爪の精度は見ていません。
  - **再生1回目の始めに、フォロワーが 35〜42° 飛びました。** 再生前の確認では、記録の最初の姿勢との差は 10° 以内でした。動いた向きが記録の最後の姿勢と同じなので、サーボに残っていた前の目標の角度へ、力が入った瞬間に動いたと考えています。2回目では起きておらず、原因は確定していません。
  - 記録3回とも、腕を上げた姿勢で終わっていました。終わりに力が抜けた時点で、フォロワーは落ちたはずです。
- **7. 動きを直す仕組み**
  - 方策を動かしながら人が割り込むことはできます。`lerobot-rollout --strategy.type=dagger` で、tab で直し始め・終わりです。
  - 割り込む瞬間は、リーダーに力を入れてフォロワーの姿勢へ2秒かけて寄せてから人に渡すので、飛びません。
  - 人が直したコマと AI が動かしたコマは、`intervention` の列で区別できます。
  - 足りない所：方策の最初の動きをならす仕組みがあるかは確かめられていません。最初の段落の「前の目標に飛ぶ」問題は、この仕組みでも同じように起きるはずです。

判定：止めた（決めてほしいことあり）。計測そのものは6段階すべて終わっています。

変えたファイル：
- 新しく足して、個別に add・commit したもの（4d79b10）
  - `so101/check_258.py`
  - `so101/check_258_analyze.py`
  - `so101/replay_logged_258.py`
  - `so101/verify_calibration_258.py`
- git に入れていないもの
  - データ一式 `so101/check_258/`（報告の本体は `so101/check_258/REPORT.md`）
  - 作業記録 `logs/20261122_1753.md`
- KIOXIA と Hugging Face には何も作っていません。

決めてほしいこと：
1. 再生1回目の始めに飛んだ件の対策です。
   - 案A：lerobot-record・replay の前に、サーボの目標を今の位置に書いておく一手を足す
   - 案B：max_relative_target を設定する（安全の値の変更になるので、私からは変えていません）
2. 私のテレオペ（段階3・4）では、フォロワーに力を入れる前に、サーボの目標を今の位置に書いておく一手を加えていました（電源を切ると消える領域で、動きは出ません）。依頼には書かれていない操作なので、このやり方でよいか確認してください。
3. 記録の終わりは休みの姿勢で終えることを、決まりにするかどうか。
4. 机側カメラのずれは信用できる値が取れませんでした。爪が大きく写る置き方で測り直すかどうか。
5. お手本を集めるときの解像度（640x480 にするか 1280x720 にするか）。
6. 露出・ホワイトバランスを OpenCV 以外の道具で読むかどうか。
```

### 依頼258 の報告の本体 REPORT.md（全文）

```markdown
# 依頼258 SO-101 で取れるデータの実測 報告（2026-11-22 17:07〜17:51）

数字の元は `so101/check_258/analysis.json`・`calibration_check.json`。

## 0. つながり
| 項目 | 結果 |
|---|---|
| フォロワー 5CBC4321631 | STS3215 ×6（11.8〜11.9V） |
| リーダー 5CBC4323581 | STS3215 ×6（4.9V） |
| 手首カメラ USB HD Camera | OpenCV 1 |
| 机側カメラ Innomaker-U20CAM-720P | OpenCV 0 |
| iPhone（Iriun Camera） | 見えている（ffmpeg 0・OpenCV 3） |

## 1. 机側カメラのピント（ラプラシアンの分散）
条件：1280x720、中央の領域は幅・高さの20%。

| 画像 | 中央 | 左上 | 右上 | 左下 | 右下 |
|---|---|---|---|---|---|
| 依頼248 desk_opencv1.png | 2.6 | 13.0 | 3.5 | 16.9 | 13.6 |
| 今回 17:16（合わせる前） | 1.4 | 6.3 | 4.4 | 5.8 | 5.9 |
| 今回 17:25〜（4枚） | 1286〜1330 | 58〜66 | 2.2〜2.5 | 23〜27 | 6.8〜7.7 |

中央は約500倍になった。右上・右下は低いままで、机の何もない面が写っているためとみられる。

## 2. 読み取りの速さ（動かさない）
関節（30Hz で回し、読むだけのポートで計測）：

| 条件 | フォロワー位置 中央値/95%/最大 | リーダー位置 | 1周の合計 | 33ms を超えた周 |
|---|---|---|---|---|
| 位置だけ 30秒（900周） | 1.23 / 2.09 / 5.4 ms | 1.07 / 1.95 / 4.3 ms | 2.3 / 3.9 / 8.1 ms | 0 |
| ＋電流・負荷・温度・電圧 15秒 | 1.16 / 1.68 / 4.6 | 1.06 / 1.85 / 3.5 | 6.3 / 10.0 / 14.9 | 0 |
| ＋カメラ2台を同時に 30秒 | 1.13 / 1.59 / 10.2 | 1.05 / 1.30 / 4.6 | 6.2 / 8.4 / 36.9 | 2 |

電流・負荷・温度・電圧は、どれも1つあたり約 1.0ms（中央値）で読める。4つ足すと1周が約 +4ms。

カメラ（MJPG を頼んで 30fps、2台同時、開いた直後の1秒を除く）：

| 条件 | カメラ | 実際の fps | 間隔 中央値/95%/最大 | 落ちたコマ（推定） | 2台の届く時刻の差 中央値/95%/最大 |
|---|---|---|---|---|---|
| 1280x720 | 手首 | 30.03 | 33.0 / 35.4 / 65.9 ms | 8 | 1.7 / 3.7 / 31 ms |
| 1280x720 | 机側 | 30.17 | 33.0 / 35.1 / 66.3 | 4 | |
| 640x480 | 手首 | 30.00 | 33.1 / 36.3 / 65.7 | 9 | 7.5 / 9.5 / 31 |
| 640x480 | 机側 | 30.11 | 33.1 / 35.5 / 84.3 | 6 | |
| 640x480＋関節 | 手首 | 29.90 | 33.1 / 35.1 / 150.4 | 13 | 15.5 / 16.9 / 134 |
| 640x480＋関節 | 机側 | 30.17 | 33.0 / 34.9 / 68.4 | 5 | |

- 開いた直後の1秒は、間隔が最大 0.5〜1秒あく。
- 2台はつながっていないので、届く時刻の差（位相）は開くたびに変わる。
- 同時に回すと、手首カメラに 150ms の穴が1回出た。関節の周も 33ms を2回超えた。
- 露出・ホワイトバランス・ゲイン・FOURCC は、macOS の OpenCV（AVFoundation）では全部 0 が返る。自動かどうか・その値は、この方法では読めない（書き換えはしていない）。

## 3. 時刻のずれ（テレオペ、爪の開け閉め）
- 1回目はリーダーの爪が動いておらず（最大 0.8）、数えていない。
- 2回目は合図の前に動きがあり、外れ値として扱う。
- 3〜5回目の結果（リーダーの爪が動き始めた時刻を 0 とした ms）：

| 回 | フォロワーの爪（関節） | 手首カメラ | 机側カメラ |
|---|---|---|---|
| 3 | +102 | +111 | +124 |
| 4 | +102 | +92 | +43 |
| 5 | +100 | +74 | −44 |

- 手首カメラ − フォロワーの関節：+9 / −10 / −26 ms。1コマ（33ms）以内で揃っている。
- 机側カメラは画面の中の爪が小さく、+22〜−145 ms とばらついた。信用できない。
- リーダー（action）に対するフォロワー（state）の遅れ（s34 全体の相互相関）：

| 関節 | 遅れ | 相関 |
|---|---|---|
| shoulder_pan | 130ms | 0.99 |
| shoulder_lift | 110ms | 0.99 |
| elbow_flex | 105ms | 0.98 |
| wrist_flex | 105ms | 0.99 |
| wrist_roll | 100ms | 0.97 |
| gripper | 170ms | 0.86 |

## 4. 速く動かしていいか（テレオペ、各15秒）
単位：速さ °/s（99パーセンタイル）、差 °、電流 mA、負荷 %。

| 関節 | ゆっくり 速さ/差最大 | ふつう | 速く | 速く 電流最大/負荷最大 | 温度（全体） |
|---|---|---|---|---|---|
| shoulder_pan | 106 / 14.4 | 101 / 13.7 | 203 / 33.1 | 260 / 82 | 27→28 |
| shoulder_lift | 86 / 11.4 | 114 / 16.1 | 147 / 24.8 | 559 / 75 | 27→28 |
| elbow_flex | 111 / 16.5 | 121 / 17.9 | 170 / 24.0 | 130 / 61 | 26→28 |
| wrist_flex | 107 / 14.2 | 154 / 21.1 | 183 / 26.7 | 214 / 68 | 28→29 |
| wrist_roll | 10 / 3.6 | 0 / 0.4 | 60 / 8.7 | 39 / 28 | 28 |

- 差（リーダー − フォロワー）は、ほぼ「速さ × 約0.1秒」で説明できる。サーボが速さの上限で頭打ちになった形ではない。
- 速い段で差が 10° 以上のまま 0.1 秒以上続いた区間の数：shoulder_pan 7・wrist_flex 9・shoulder_lift 1・elbow_flex 1。
- 先に限界に来るのは shoulder_pan と wrist_flex（差が大きい・離れる回数が多い）。電流がいちばん大きいのは shoulder_lift（559mA、腕を持ち上げる軸）。
- 温度は全体で +1〜2℃。
- 映像のぶれ（手首カメラ、中央の領域のピント、関節1〜5 の速さの最大で区切った中央値）：

| 速さ | ピントの数値 |
|---|---|
| 0〜10°/s | 89.7 |
| 60〜100°/s | 90.3 |
| 100〜150°/s | 104.7 |
| 150〜200°/s | 76.4 |

  150°/s を超えると、止まっているときより約15% 下がる。それより遅いと、写っているもの（机・箱）の違いのほうが大きく、ぶれは見分けられない。机側カメラは中央に腕が写らない時間が長く、この指標は使えなかった。
- max_relative_target：既定値は None（制限なし）。今回の lerobot-record と lerobot-replay も None で動いた（ログで確認）。
- テレオペの始めに姿勢が違うとき（コードで確認）：
  - lerobot-teleoperate と lerobot-record は、1コマ目からリーダーの角度をそのまま Goal_Position に送る。ならす仕組みはない。
  - max_relative_target が None なので、フォロワーはサーボの最高速・最大加速度（connect で Acceleration=254 を書く）で飛ぶ。

## 5. LeRobot の記録の形
条件：`lerobot-record`、640x480・MJPG・30fps、10秒×3回、root=so101/check_258/dataset、push なし。

- 周期：3回とも 29.98Hz。33.3ms を超えた周は 0、処理時間は平均 2.4ms。
- features（info.json、codebase v3.0、robot_type so_follower）：

| 名前 | 型 | 形 | 中身 |
|---|---|---|---|
| action | float32 | [6] | shoulder_pan.pos, shoulder_lift.pos, elbow_flex.pos, wrist_flex.pos, wrist_roll.pos, gripper.pos |
| observation.state | float32 | [6] | 同じ6つ |
| observation.images.wrist | video | [480,640,3] | av1 / yuv420p / 30fps / g=2 / crf=30 / preset 12 |
| observation.images.desk | video | [480,640,3] | 同上 |
| timestamp | float32 | [1] | |
| frame_index・episode_index・index・task_index | int64 | [1] | |

- parquet の列：action・observation.state（配列）、timestamp、frame_index、episode_index、index、task_index。
- 動画：3回分が1本の mp4 につながる（各 900コマ・30.000秒、av1 640x480 30/1）。
- timestamp：3回とも frame_index / 30 と完全に一致し、間隔は 33.33ms で揺れ 0。カメラの実際の撮影時刻・届いた時刻はどこにも保存されない。
- 大きさ：

| 範囲 | 大きさ |
|---|---|
| 30秒（3回）全体 | 6.8MB（毎秒 0.227MB） |
| └ 手首の動画 | 3.85MB |
| └ 机側の動画 | 2.84MB |
| └ parquet | 0.035MB |

| 1回の長さ | 1回 | 100回 | 1000回 |
|---|---|---|---|
| 10秒 | 2.3MB | 227MB | 2.3GB |
| 30秒 | 6.8MB | 681MB | 6.8GB |
| 60秒 | 13.6MB | 1.36GB | 13.6GB |

  記録の途中は PNG を一度書き出すので、その間は一時的にもっと大きくなる。
- ずれ・揺れの現れ方：2.・3.で測ったものは、記録の timestamp には現れない。
  - コマの間隔の揺れ（95% で約 36ms）
  - 落ちたコマ（30秒で 4〜13コマ）
  - 2台の届く時刻の差（0〜33ms、開くたびに変わる）
  - リーダーに対するフォロワーの遅れ（約100ms）

  LeRobot は各周で各カメラの「その時点の最新のコマ」を取る（read_latest）。そのため、コマが落ちると前のコマがそのまま入り、timestamp は等間隔のまま。action と state の差は、記録の中でも最大 7.5〜14.7° あった（遅れの分）。

## 6. 関節の値は正確か
lerobot-replay で記録の0回目を2回再生した。周期は中央値 33.3ms、最大 43.6ms。

- 再生の始め 0.5 秒を除いた差（°。爪は 0〜100）：

| 関節 | 再生1−記録 平均/最大 | 再生2−記録 平均/最大 | 再生1−再生2 平均/最大 |
|---|---|---|---|
| shoulder_pan | 0.02 / 0.26 | 0.09 / 0.26 | 0.10 / 0.26 |
| shoulder_lift | 0.13 / 0.53 | 0.28 / 0.62 | 0.33 / 1.05 |
| elbow_flex | 0.07 / 0.62 | 0.18 / 0.35 | 0.15 / 0.97 |
| wrist_flex | 0.04 / 0.18 | 0.19 / 0.53 | 0.18 / 0.53 |
| wrist_roll | 0.09 / 0.09 | 0.06 / 0.09 | 0.02 / 0.09 |
| gripper | 0.00 / 0.00 | 0.07 / 0.07 | 0.07 / 0.07 |

- **再生1の始めにフォロワーが飛んだ**：
  - 再生前の確認では、記録の最初の姿勢との差は 10° 以内だった。
  - ところが再生1の最初のコマで、shoulder_lift は −103→−68.5、elbow_flex は 91→49.8 と、35〜42° 動いていた。
  - 動いた向きは、記録の最後（3回目の終わり：shoulder_lift +63・elbow −96）の向きと同じ。
  - 推定：サーボに残っていた前の Goal_Position へ、connect でトルクが入った瞬間に動いた。
  - 再生2では起きていない（最初のコマの差は 7° 以内）。原因は確定できていない。
- **記録の終わりにフォロワーが落ちた**：3回とも、記録の終わりは休みの姿勢ではなかった（shoulder_lift が +63〜+85、腕を上げた状態）。そのため、終わりにトルクが切れた時点でフォロワーが落ちたはず。
- 分解能とキャリブレーション（読むだけ）：
  - STS3215 の 4096 目盛 → 関節1〜5 は 1目盛 0.0879°。
  - 爪の1目盛：フォロワーは範囲 1476 目盛で 0.068（0〜100）、リーダーは 1216 目盛で 0.082。
  - サーボの Homing_Offset・Min/Max_Position_Limit は、12個すべてファイルと一致した。
  - 生の値から式 (raw − (min+max)/2) × 360/4095 で出した値と LeRobot の値の差は、12個すべて 0.000。
  - 角度の 0 は「キャリブレーションした範囲の真ん中」で、物理的な基準の角度ではない。
- 爪の値と手首カメラ：`gripper_vs_wrist.png` で確認した。
  - 1.0〜1.5 で爪が閉じ、30.7 で片側が外へ開きかけ（ぶれている）、98.2 で片側が画面の外まで開く。向きと大きさは合っている。
  - 画像の変化と爪の値の相関は r=0.42 にとどまる（腕の小さな動きも入るため）。
  - 記録の3回では爪を動かしていない（1.6 のまま）ので、再生で爪の精度は見ていない。

## 7. 動きを直す仕組み（コードを読むだけ、LeRobot 0.7.1）
| 項目 | 今の LeRobot |
|---|---|
| 方策を動かしながら人が割り込む | できる：`lerobot-rollout --strategy.type=dagger --policy.path=... --robot.type=so101_follower ... --teleop.type=so101_leader ...`。space=一時停止/再開、tab=修正の開始/終了 |
| 割り込んだ瞬間の姿勢の違い | 一時停止のとき、リーダーのトルクを入れ、フォロワーが最後に指令された姿勢まで2秒で寄せる（`teleop_smooth_move_to`）。そのあとトルクを切って人が動かす → 飛ばない。`--strategy.smooth_handover=false` で無効にできる |
| SO-101 リーダーに寄せる力を入れる | できる：`SOLeader.enable_torque()`・`send_feedback()`（Goal_Position を書く） |
| 人のコマと AI のコマを区別する列 | ある：`intervention`（bool, shape (1,)）。既定（record_autonomous=False）では直した区間だけを記録し、True にすると方策の区間も記録する |
| gym_manipulator・rl の HIL | SO リーダーでは使えない（get_teleop_events を持つのは gamepad と keyboard だけ） |
| lerobot-record で --policy | 0.7.1 にはない（方策の実行は lerobot-rollout に分かれた） |
| 足りない所 | 方策の最初の action に移るときにならす仕組みがあるかは確かめられていない。max_relative_target は既定 None。connect 時の古い Goal_Position の問題（6.）は rollout でも同じはず |
```

### Claude Code の作業の記録 logs/20261122_1753.md（全量）

```markdown
# 依頼258 SO-101 で取れるデータの実測

- 計測: so101/check_258.py（s0〜s6 すべて ok, 17:07〜17:51）
- 解析: so101/check_258_analyze.py → so101/check_258/analysis.json
- 報告の本体: so101/check_258/REPORT.md
- コミット: 4d79b10 （check_258.py / check_258_analyze.py / replay_logged_258.py / verify_calibration_258.py）
- データ・画像・動画は git に入れていない。KIOXIA・Hugging Face には触れていない

# 依頼258 SO-101 で取れるデータの実測 報告（2026-11-22 17:07〜17:51）

数字の元は `so101/check_258/analysis.json`・`calibration_check.json`。

## 0. つながり
| 項目 | 結果 |
|---|---|
| フォロワー 5CBC4321631 | STS3215 ×6（11.8〜11.9V） |
| リーダー 5CBC4323581 | STS3215 ×6（4.9V） |
| 手首カメラ USB HD Camera | OpenCV 1 |
| 机側カメラ Innomaker-U20CAM-720P | OpenCV 0 |
| iPhone（Iriun Camera） | 見えている（ffmpeg 0・OpenCV 3） |

## 1. 机側カメラのピント（ラプラシアンの分散）
条件：1280x720、中央の領域は幅・高さの20%。

| 画像 | 中央 | 左上 | 右上 | 左下 | 右下 |
|---|---|---|---|---|---|
| 依頼248 desk_opencv1.png | 2.6 | 13.0 | 3.5 | 16.9 | 13.6 |
| 今回 17:16（合わせる前） | 1.4 | 6.3 | 4.4 | 5.8 | 5.9 |
| 今回 17:25〜（4枚） | 1286〜1330 | 58〜66 | 2.2〜2.5 | 23〜27 | 6.8〜7.7 |

中央は約500倍になった。右上・右下は低いままで、机の何もない面が写っているためとみられる。

## 2. 読み取りの速さ（動かさない）
関節（30Hz で回し、読むだけのポートで計測）：

| 条件 | フォロワー位置 中央値/95%/最大 | リーダー位置 | 1周の合計 | 33ms を超えた周 |
|---|---|---|---|---|
| 位置だけ 30秒（900周） | 1.23 / 2.09 / 5.4 ms | 1.07 / 1.95 / 4.3 ms | 2.3 / 3.9 / 8.1 ms | 0 |
| ＋電流・負荷・温度・電圧 15秒 | 1.16 / 1.68 / 4.6 | 1.06 / 1.85 / 3.5 | 6.3 / 10.0 / 14.9 | 0 |
| ＋カメラ2台を同時に 30秒 | 1.13 / 1.59 / 10.2 | 1.05 / 1.30 / 4.6 | 6.2 / 8.4 / 36.9 | 2 |

電流・負荷・温度・電圧は、どれも1つあたり約 1.0ms（中央値）で読める。4つ足すと1周が約 +4ms。

カメラ（MJPG を頼んで 30fps、2台同時、開いた直後の1秒を除く）：

| 条件 | カメラ | 実際の fps | 間隔 中央値/95%/最大 | 落ちたコマ（推定） | 2台の届く時刻の差 中央値/95%/最大 |
|---|---|---|---|---|---|
| 1280x720 | 手首 | 30.03 | 33.0 / 35.4 / 65.9 ms | 8 | 1.7 / 3.7 / 31 ms |
| 1280x720 | 机側 | 30.17 | 33.0 / 35.1 / 66.3 | 4 | |
| 640x480 | 手首 | 30.00 | 33.1 / 36.3 / 65.7 | 9 | 7.5 / 9.5 / 31 |
| 640x480 | 机側 | 30.11 | 33.1 / 35.5 / 84.3 | 6 | |
| 640x480＋関節 | 手首 | 29.90 | 33.1 / 35.1 / 150.4 | 13 | 15.5 / 16.9 / 134 |
| 640x480＋関節 | 机側 | 30.17 | 33.0 / 34.9 / 68.4 | 5 | |

- 開いた直後の1秒は、間隔が最大 0.5〜1秒あく。
- 2台はつながっていないので、届く時刻の差（位相）は開くたびに変わる。
- 同時に回すと、手首カメラに 150ms の穴が1回出た。関節の周も 33ms を2回超えた。
- 露出・ホワイトバランス・ゲイン・FOURCC は、macOS の OpenCV（AVFoundation）では全部 0 が返る。自動かどうか・その値は、この方法では読めない（書き換えはしていない）。

## 3. 時刻のずれ（テレオペ、爪の開け閉め）
- 1回目はリーダーの爪が動いておらず（最大 0.8）、数えていない。
- 2回目は合図の前に動きがあり、外れ値として扱う。
- 3〜5回目の結果（リーダーの爪が動き始めた時刻を 0 とした ms）：

| 回 | フォロワーの爪（関節） | 手首カメラ | 机側カメラ |
|---|---|---|---|
| 3 | +102 | +111 | +124 |
| 4 | +102 | +92 | +43 |
| 5 | +100 | +74 | −44 |

- 手首カメラ − フォロワーの関節：+9 / −10 / −26 ms。1コマ（33ms）以内で揃っている。
- 机側カメラは画面の中の爪が小さく、+22〜−145 ms とばらついた。信用できない。
- リーダー（action）に対するフォロワー（state）の遅れ（s34 全体の相互相関）：

| 関節 | 遅れ | 相関 |
|---|---|---|
| shoulder_pan | 130ms | 0.99 |
| shoulder_lift | 110ms | 0.99 |
| elbow_flex | 105ms | 0.98 |
| wrist_flex | 105ms | 0.99 |
| wrist_roll | 100ms | 0.97 |
| gripper | 170ms | 0.86 |

## 4. 速く動かしていいか（テレオペ、各15秒）
単位：速さ °/s（99パーセンタイル）、差 °、電流 mA、負荷 %。

| 関節 | ゆっくり 速さ/差最大 | ふつう | 速く | 速く 電流最大/負荷最大 | 温度（全体） |
|---|---|---|---|---|---|
| shoulder_pan | 106 / 14.4 | 101 / 13.7 | 203 / 33.1 | 260 / 82 | 27→28 |
| shoulder_lift | 86 / 11.4 | 114 / 16.1 | 147 / 24.8 | 559 / 75 | 27→28 |
| elbow_flex | 111 / 16.5 | 121 / 17.9 | 170 / 24.0 | 130 / 61 | 26→28 |
| wrist_flex | 107 / 14.2 | 154 / 21.1 | 183 / 26.7 | 214 / 68 | 28→29 |
| wrist_roll | 10 / 3.6 | 0 / 0.4 | 60 / 8.7 | 39 / 28 | 28 |

- 差（リーダー − フォロワー）は、ほぼ「速さ × 約0.1秒」で説明できる。サーボが速さの上限で頭打ちになった形ではない。
- 速い段で差が 10° 以上のまま 0.1 秒以上続いた区間の数：shoulder_pan 7・wrist_flex 9・shoulder_lift 1・elbow_flex 1。
- 先に限界に来るのは shoulder_pan と wrist_flex（差が大きい・離れる回数が多い）。電流がいちばん大きいのは shoulder_lift（559mA、腕を持ち上げる軸）。
- 温度は全体で +1〜2℃。
- 映像のぶれ（手首カメラ、中央の領域のピント、関節1〜5 の速さの最大で区切った中央値）：

| 速さ | ピントの数値 |
|---|---|
| 0〜10°/s | 89.7 |
| 60〜100°/s | 90.3 |
| 100〜150°/s | 104.7 |
| 150〜200°/s | 76.4 |

  150°/s を超えると、止まっているときより約15% 下がる。それより遅いと、写っているもの（机・箱）の違いのほうが大きく、ぶれは見分けられない。机側カメラは中央に腕が写らない時間が長く、この指標は使えなかった。
- max_relative_target：既定値は None（制限なし）。今回の lerobot-record と lerobot-replay も None で動いた（ログで確認）。
- テレオペの始めに姿勢が違うとき（コードで確認）：
  - lerobot-teleoperate と lerobot-record は、1コマ目からリーダーの角度をそのまま Goal_Position に送る。ならす仕組みはない。
  - max_relative_target が None なので、フォロワーはサーボの最高速・最大加速度（connect で Acceleration=254 を書く）で飛ぶ。

## 5. LeRobot の記録の形
条件：`lerobot-record`、640x480・MJPG・30fps、10秒×3回、root=so101/check_258/dataset、push なし。

- 周期：3回とも 29.98Hz。33.3ms を超えた周は 0、処理時間は平均 2.4ms。
- features（info.json、codebase v3.0、robot_type so_follower）：

| 名前 | 型 | 形 | 中身 |
|---|---|---|---|
| action | float32 | [6] | shoulder_pan.pos, shoulder_lift.pos, elbow_flex.pos, wrist_flex.pos, wrist_roll.pos, gripper.pos |
| observation.state | float32 | [6] | 同じ6つ |
| observation.images.wrist | video | [480,640,3] | av1 / yuv420p / 30fps / g=2 / crf=30 / preset 12 |
| observation.images.desk | video | [480,640,3] | 同上 |
| timestamp | float32 | [1] | |
| frame_index・episode_index・index・task_index | int64 | [1] | |

- parquet の列：action・observation.state（配列）、timestamp、frame_index、episode_index、index、task_index。
- 動画：3回分が1本の mp4 につながる（各 900コマ・30.000秒、av1 640x480 30/1）。
- timestamp：3回とも frame_index / 30 と完全に一致し、間隔は 33.33ms で揺れ 0。カメラの実際の撮影時刻・届いた時刻はどこにも保存されない。
- 大きさ：

| 範囲 | 大きさ |
|---|---|
| 30秒（3回）全体 | 6.8MB（毎秒 0.227MB） |
| └ 手首の動画 | 3.85MB |
| └ 机側の動画 | 2.84MB |
| └ parquet | 0.035MB |

| 1回の長さ | 1回 | 100回 | 1000回 |
|---|---|---|---|
| 10秒 | 2.3MB | 227MB | 2.3GB |
| 30秒 | 6.8MB | 681MB | 6.8GB |
| 60秒 | 13.6MB | 1.36GB | 13.6GB |

  記録の途中は PNG を一度書き出すので、その間は一時的にもっと大きくなる。
- ずれ・揺れの現れ方：2.・3.で測ったものは、記録の timestamp には現れない。
  - コマの間隔の揺れ（95% で約 36ms）
  - 落ちたコマ（30秒で 4〜13コマ）
  - 2台の届く時刻の差（0〜33ms、開くたびに変わる）
  - リーダーに対するフォロワーの遅れ（約100ms）

  LeRobot は各周で各カメラの「その時点の最新のコマ」を取る（read_latest）。そのため、コマが落ちると前のコマがそのまま入り、timestamp は等間隔のまま。action と state の差は、記録の中でも最大 7.5〜14.7° あった（遅れの分）。

## 6. 関節の値は正確か
lerobot-replay で記録の0回目を2回再生した。周期は中央値 33.3ms、最大 43.6ms。

- 再生の始め 0.5 秒を除いた差（°。爪は 0〜100）：

| 関節 | 再生1−記録 平均/最大 | 再生2−記録 平均/最大 | 再生1−再生2 平均/最大 |
|---|---|---|---|
| shoulder_pan | 0.02 / 0.26 | 0.09 / 0.26 | 0.10 / 0.26 |
| shoulder_lift | 0.13 / 0.53 | 0.28 / 0.62 | 0.33 / 1.05 |
| elbow_flex | 0.07 / 0.62 | 0.18 / 0.35 | 0.15 / 0.97 |
| wrist_flex | 0.04 / 0.18 | 0.19 / 0.53 | 0.18 / 0.53 |
| wrist_roll | 0.09 / 0.09 | 0.06 / 0.09 | 0.02 / 0.09 |
| gripper | 0.00 / 0.00 | 0.07 / 0.07 | 0.07 / 0.07 |

- **再生1の始めにフォロワーが飛んだ**：
  - 再生前の確認では、記録の最初の姿勢との差は 10° 以内だった。
  - ところが再生1の最初のコマで、shoulder_lift は −103→−68.5、elbow_flex は 91→49.8 と、35〜42° 動いていた。
  - 動いた向きは、記録の最後（3回目の終わり：shoulder_lift +63・elbow −96）の向きと同じ。
  - 推定：サーボに残っていた前の Goal_Position へ、connect でトルクが入った瞬間に動いた。
  - 再生2では起きていない（最初のコマの差は 7° 以内）。原因は確定できていない。
- **記録の終わりにフォロワーが落ちた**：3回とも、記録の終わりは休みの姿勢ではなかった（shoulder_lift が +63〜+85、腕を上げた状態）。そのため、終わりにトルクが切れた時点でフォロワーが落ちたはず。
- 分解能とキャリブレーション（読むだけ）：
  - STS3215 の 4096 目盛 → 関節1〜5 は 1目盛 0.0879°。
  - 爪の1目盛：フォロワーは範囲 1476 目盛で 0.068（0〜100）、リーダーは 1216 目盛で 0.082。
  - サーボの Homing_Offset・Min/Max_Position_Limit は、12個すべてファイルと一致した。
  - 生の値から式 (raw − (min+max)/2) × 360/4095 で出した値と LeRobot の値の差は、12個すべて 0.000。
  - 角度の 0 は「キャリブレーションした範囲の真ん中」で、物理的な基準の角度ではない。
- 爪の値と手首カメラ：`gripper_vs_wrist.png` で確認した。
  - 1.0〜1.5 で爪が閉じ、30.7 で片側が外へ開きかけ（ぶれている）、98.2 で片側が画面の外まで開く。向きと大きさは合っている。
  - 画像の変化と爪の値の相関は r=0.42 にとどまる（腕の小さな動きも入るため）。
  - 記録の3回では爪を動かしていない（1.6 のまま）ので、再生で爪の精度は見ていない。

## 7. 動きを直す仕組み（コードを読むだけ、LeRobot 0.7.1）
| 項目 | 今の LeRobot |
|---|---|
| 方策を動かしながら人が割り込む | できる：`lerobot-rollout --strategy.type=dagger --policy.path=... --robot.type=so101_follower ... --teleop.type=so101_leader ...`。space=一時停止/再開、tab=修正の開始/終了 |
| 割り込んだ瞬間の姿勢の違い | 一時停止のとき、リーダーのトルクを入れ、フォロワーが最後に指令された姿勢まで2秒で寄せる（`teleop_smooth_move_to`）。そのあとトルクを切って人が動かす → 飛ばない。`--strategy.smooth_handover=false` で無効にできる |
| SO-101 リーダーに寄せる力を入れる | できる：`SOLeader.enable_torque()`・`send_feedback()`（Goal_Position を書く） |
| 人のコマと AI のコマを区別する列 | ある：`intervention`（bool, shape (1,)）。既定（record_autonomous=False）では直した区間だけを記録し、True にすると方策の区間も記録する |
| gym_manipulator・rl の HIL | SO リーダーでは使えない（get_teleop_events を持つのは gamepad と keyboard だけ） |
| lerobot-record で --policy | 0.7.1 にはない（方策の実行は lerobot-rollout に分かれた） |
| 足りない所 | 方策の最初の action に移るときにならす仕組みがあるかは確かめられていない。max_relative_target は既定 None。connect 時の古い Goal_Position の問題（6.）は rollout でも同じはず |
```

### 測るスクリプト check_258.py（全文）

```python
"""SO-101 で Mac・カメラ2台・アームから取れるデータを実測する (依頼 258). 記録だけ. 解析は check_258_analyze.py.

エイイチへの指示はすべてこのウィンドウに大きな字で出す. 各段階はスペースで始め, q でいつでも止める.

段階:
  s0  つながり (2枚の基板・サーボ12個・カメラ2台・iPhone)      動かさない
  s1  机側カメラのピント (desk_cam_focus_257.py を起動)          動かさない
  s2  読み取りの速さ (関節・カメラ・同時)                        動かさない (読むだけのポート)
  s34 テレオペ: 爪の開け閉め5回 → ゆっくり・ふつう・速く 各15秒   フォロワーはリーダーに従って動く
  s5  lerobot-record で 10秒×3回                                  テレオペ
  s6  lerobot-replay で記録の1回を2回再生                          始める前にウィンドウで確認

フォロワーに指令が出るのは s34・s5・s6 だけ. s0〜s2 は connect(handshake=False) で開いて読むだけ
(トルク・EEPROM・キャリブレーション・上限値・カメラの設定には書かない).
テレオペ (s34・s5) の前に, リーダーとフォロワーの姿勢の差が小さくなるまで始められないようにする
(LeRobot のテレオペは1コマ目からリーダーの角度をそのまま送り, ならす仕組みがないため).

使い方 (conda の lerobot 環境で):
    python so101/check_258.py                 # s0 から s6 まで順に
    python so101/check_258.py --only s2 s34   # 一部だけ
"""

import argparse
import csv
import json
import os
import shutil
import signal
import subprocess
import sys
import threading
import time
from datetime import datetime
from pathlib import Path

import cv2
import numpy as np
from PIL import Image, ImageDraw, ImageFont

HERE = Path(__file__).resolve().parent
REPO = HERE.parent
OUT = HERE / "check_258"
FOLLOWER_PORT = "/dev/tty.usbmodem5CBC4321631"
LEADER_PORT = "/dev/tty.usbmodem5CBC4323581"
FOLLOWER_ID, LEADER_ID = "ptm_follower", "ptm_leader"
CAL_DIR = Path.home() / ".cache/huggingface/lerobot/calibration"
CAL_FOLLOWER = CAL_DIR / "robots/so_follower" / f"{FOLLOWER_ID}.json"
CAL_LEADER = CAL_DIR / "teleoperators/so_leader" / f"{LEADER_ID}.json"
BASE_PY = "/opt/homebrew/Caskroom/miniforge/base/bin/python3"  # cv2_enumerate_cameras が入っている python
FONT_PATH = "/System/Library/Fonts/ヒラギノ角ゴシック W6.ttc"
MOTORS = ["shoulder_pan", "shoulder_lift", "elbow_flex", "wrist_flex", "wrist_roll", "gripper"]
CAM_KEYS = {"wrist": "usb hd camera", "desk": "innomaker"}
DATASET_ROOT = OUT / "dataset"
DATASET_REPO = "local/check_258"
FPS = 30
POSE_TOL_DEG = 10.0  # テレオペ・再生を始めてよい姿勢の差 (関節1〜5, 度)
POSE_TOL_GRIP = 15.0  # 爪 (0〜100)
WIN = "SO-101 check 258"


class Abort(Exception):
    pass


# ---- 画面 -------------------------------------------------------------------------

class Screen:
    W, H = 1280, 800

    def __init__(self):
        self.f_big = ImageFont.truetype(FONT_PATH, 60)
        self.f_mid = ImageFont.truetype(FONT_PATH, 40)
        self.f_small = ImageFont.truetype(FONT_PATH, 26)
        cv2.namedWindow(WIN, cv2.WINDOW_NORMAL)
        cv2.resizeWindow(WIN, self.W, self.H)

    def show(self, title, lines=(), small=(), color=(255, 255, 255), previews=()):
        img = Image.new("RGB", (self.W, self.H), (0, 0, 0))
        d = ImageDraw.Draw(img)
        y = 30
        d.text((40, y), title, font=self.f_big, fill=color)
        y += 90
        for ln in lines:
            d.text((40, y), ln, font=self.f_mid, fill=(255, 255, 255))
            y += 56
        y = max(y + 10, self.H - 40 - 32 * len(small))
        for ln in small:
            d.text((40, y), ln, font=self.f_small, fill=(180, 180, 180))
            y += 32
        arr = cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)
        x = self.W - 20
        for p in previews:
            if p is None:
                continue
            th = cv2.resize(p, (320, int(320 * p.shape[0] / p.shape[1])))
            x -= th.shape[1]
            arr[self.H - th.shape[0] - 200:self.H - 200, x:x + th.shape[1]] = th
            x -= 10
        cv2.imshow(WIN, arr)

    def key(self, ms=1):
        k = cv2.waitKey(ms) & 0xFF
        if k == ord("q"):
            raise Abort("q が押された")
        return k

    def wait_space(self, title, lines=(), small=(), color=(0, 255, 255), check=None):
        """スペースを待つ. check() が (ok, 追加の行) を返すときは ok の間だけ始められる."""
        while True:
            extra, ok = [], True
            if check is not None:
                ok, extra = check()
            foot = ["スペース = 始める   q = 止める"] if ok else ["まだ始められない (上の差を小さくする)   q = 止める"]
            self.show(title, list(lines) + list(extra), list(small) + foot, color)
            if self.key(100 if check else 30) == ord(" ") and ok:
                return

    def countdown(self, title, seconds, lines_fn=None, small=(), previews_fn=None, color=(0, 255, 0), tick=None):
        t0 = time.perf_counter()
        while True:
            el = time.perf_counter() - t0
            if el >= seconds:
                return
            lines = lines_fn(el) if lines_fn else []
            self.show(f"{title}   残り {seconds - el:4.1f} 秒", lines, list(small) + ["q = 止める"], color,
                      previews_fn() if previews_fn else ())
            if tick:
                tick(el)
            self.key(80)


# ---- カメラの番号 (名前で突き合わせる) --------------------------------------------

def resolve_cameras():
    sys.path.insert(0, str(HERE))
    import desk_cam_focus_257 as dcf

    exe, ff = dcf.ffmpeg_video_devices()
    code = ("import cv2, json; from cv2_enumerate_cameras import enumerate_cameras;"
            "print(json.dumps([(c.index, c.name or '') for c in enumerate_cameras(cv2.CAP_AVFOUNDATION)]))")
    r = subprocess.run([BASE_PY, "-c", code], capture_output=True, text=True)
    cvd = json.loads(r.stdout) if r.returncode == 0 else []
    found = {}
    for key, needle in CAM_KEYS.items():
        ff_hit = [n for _, n in ff if needle in n.lower()]
        cv_hit = [i for i, n in cvd if needle in n.lower()]
        found[key] = cv_hit[0] if (ff_hit and len(cv_hit) == 1) else None
    return {"ffmpeg": ff, "opencv": cvd, "index": found,
            "iriun": any("iriun" in n.lower() for _, n in ff) or any("iriun" in n.lower() for _, n in cvd)}


# ---- 読むだけのサーボのバス ---------------------------------------------------------

def load_cal(path):
    from lerobot.motors import MotorCalibration
    raw = json.loads(Path(path).read_text())
    return {k: MotorCalibration(**v) for k, v in raw.items()}


def open_ro_bus(port, cal_path):
    """SOFollower/SOLeader と同じ関節名・単位のバスを, 書き込みなしで開く (handshake もしない)."""
    from lerobot.motors import Motor, MotorNormMode, SerialMotorsBus
    motors = {m: Motor(i + 1, "sts3215", MotorNormMode.RANGE_0_100 if m == "gripper" else MotorNormMode.DEGREES)
              for i, m in enumerate(MOTORS)}
    bus = SerialMotorsBus(port, motors, calibration=load_cal(cal_path))
    bus.connect(handshake=False)
    return bus


def close_ro(bus):
    try:
        bus.disconnect(disable_torque=False)  # 既定の True はトルクを切る書き込みをするので使わない
    except Exception as e:
        print("[BUS] disconnect:", e)


def pose_diff(a, b):
    return {m: (a[m] - b[m]) for m in MOTORS}


def pose_ok(diff):
    return all(abs(diff[m]) <= (POSE_TOL_GRIP if m == "gripper" else POSE_TOL_DEG) for m in MOTORS)


def pose_lines(diff, label_a, label_b):
    out = [f"{label_a} − {label_b} の差 (関節1〜5 は {POSE_TOL_DEG:.0f}° 以内, 爪は {POSE_TOL_GRIP:.0f} 以内で開始可)"]
    row = []
    for m in MOTORS:
        tol = POSE_TOL_GRIP if m == "gripper" else POSE_TOL_DEG
        mark = "○" if abs(diff[m]) <= tol else "×"
        row.append(f"{m[:8]} {diff[m]:+6.1f}{mark}")
    out += ["   ".join(row[:3]), "   ".join(row[3:])]
    return out


# ---- カメラを記録するスレッド ---------------------------------------------------------

PROPS = ["CAP_PROP_FRAME_WIDTH", "CAP_PROP_FRAME_HEIGHT", "CAP_PROP_FPS", "CAP_PROP_FOURCC", "CAP_PROP_AUTO_EXPOSURE",
         "CAP_PROP_EXPOSURE", "CAP_PROP_AUTO_WB", "CAP_PROP_WB_TEMPERATURE", "CAP_PROP_GAIN", "CAP_PROP_BRIGHTNESS",
         "CAP_PROP_CONTRAST", "CAP_PROP_SATURATION", "CAP_PROP_AUTOFOCUS", "CAP_PROP_FOCUS"]


class CamRec(threading.Thread):
    """1コマごとに Mac の時計で届いた時刻を記録する. 頼むのは解像度・MJPG・fps だけ (他の設定は読むだけ)."""

    def __init__(self, name, index, w, h, stop, video_path=None, keep_small=False):
        super().__init__(daemon=True)
        self.name_, self.index, self.w, self.h, self.stop = name, index, w, h, stop
        self.video_path, self.keep_small = video_path, keep_small
        self.rows, self.small, self.latest, self.props, self.error = [], [], None, {}, None
        self.ready = threading.Event()

    def run(self):
        cap = cv2.VideoCapture(self.index, cv2.CAP_AVFOUNDATION)
        if not cap.isOpened():
            self.error = f"OpenCV {self.index} を開けない"
            self.ready.set()
            return
        cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*"MJPG"))
        cap.set(cv2.CAP_PROP_FRAME_WIDTH, self.w)
        cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self.h)
        cap.set(cv2.CAP_PROP_FPS, FPS)
        for p in PROPS:
            v = cap.get(getattr(cv2, p))
            if p == "CAP_PROP_FOURCC":
                iv = int(v)
                v = "".join(chr((iv >> 8 * k) & 0xFF) for k in range(4)) if iv > 0 else str(v)
            self.props[p] = v
        writer = None
        self.ready.set()
        n = 0
        try:
            while not self.stop.is_set():
                ok, f = cap.read()
                t = time.perf_counter()
                if not ok:
                    self.rows.append((t, -1, float("nan"), float("nan"), 0, 0))
                    time.sleep(0.005)
                    continue
                gray = cv2.cvtColor(f, cv2.COLOR_BGR2GRAY)
                h, w = gray.shape
                c = gray[int(h * 0.3):int(h * 0.7), int(w * 0.3):int(w * 0.7)]
                blur = float(cv2.Laplacian(c, cv2.CV_64F).var())
                self.rows.append((t, cap.get(cv2.CAP_PROP_POS_MSEC), blur, float(gray.mean()), w, h))
                if self.keep_small:
                    self.small.append(cv2.resize(gray, (160, 120), interpolation=cv2.INTER_AREA))
                if self.video_path is not None:
                    if writer is None:
                        writer = cv2.VideoWriter(str(self.video_path), cv2.VideoWriter_fourcc(*"mp4v"), FPS, (w, h))
                    writer.write(f)
                self.latest = f
                n += 1
        finally:
            if writer is not None:
                writer.release()
            cap.release()

    def save(self, stem):
        with open(f"{stem}.csv", "w", newline="") as fh:
            wr = csv.writer(fh)
            wr.writerow(["t", "pos_msec", "blur_center", "mean", "w", "h"])
            wr.writerows(self.rows)
        if self.keep_small and self.small:
            np.save(f"{stem}_small.npy", np.stack(self.small))
        Path(f"{stem}_props.json").write_text(json.dumps({"index": self.index, "request": [self.w, self.h, FPS, "MJPG"],
                                                          "props": self.props, "error": self.error},
                                                         ensure_ascii=False, indent=2))


def start_cams(idx, w, h, stop, video_dir=None, keep_small=False):
    cams = {}
    for key in CAM_KEYS:
        vp = (video_dir / f"{key}.mp4") if video_dir else None
        cams[key] = CamRec(key, idx[key], w, h, stop, vp, keep_small)
        cams[key].start()
    for c in cams.values():
        c.ready.wait(10)
    return cams


# ---- s0 つながり --------------------------------------------------------------------

def stage0(scr, ctx):
    scr.show("0. つながりを確かめる", ["サーボとカメラを読むだけ. 動かしません."])
    scr.key(30)
    r = subprocess.run([sys.executable, str(HERE / "read_servos_248.py"), "--json", str(OUT / "s0_servos.json")],
                       capture_output=True, text=True)
    servos = json.loads((OUT / "s0_servos.json").read_text()) if (OUT / "s0_servos.json").exists() else {}
    cams = resolve_cameras()
    ctx["cams"] = cams
    n_servo = {p: (len(v) if isinstance(v, list) else 0) for p, v in servos.items()} if isinstance(servos, dict) else {}
    res = {"servo_counts": n_servo, "read_servos_stdout": r.stdout[-3000:], "cameras": cams}
    (OUT / "s0.json").write_text(json.dumps(res, ensure_ascii=False, indent=2))
    ok = n_servo.get(FOLLOWER_PORT) == 6 and n_servo.get(LEADER_PORT) == 6 and all(
        v is not None for v in cams["index"].values())
    lines = [f"フォロワー {n_servo.get(FOLLOWER_PORT)} 個 / リーダー {n_servo.get(LEADER_PORT)} 個",
             f"手首カメラ OpenCV {cams['index']['wrist']} / 机側カメラ OpenCV {cams['index']['desk']}",
             f"iPhone (Iriun) {'見えている' if cams['iriun'] else '見えない'}"]
    if not ok:
        scr.show("0. 足りないものがある. 止めます", lines, color=(0, 0, 255))
        scr.key(4000)
        raise Abort("つながりが足りない: " + " / ".join(lines))
    scr.wait_space("0. つながり OK", lines)


# ---- s1 机側カメラのピント --------------------------------------------------------------

def stage1(scr, ctx):
    scr.wait_space("1. 机側カメラのピント合わせ",
                   ["次に開く画面で, 机側カメラのピントと置き場所を合わせる",
                    "数字 (中央) が大きいほどピントが合っている",
                    "合ったら スペースで保存 → q で終わる"])
    before = set((HERE / "check_257").glob("desk_*.json")) if (HERE / "check_257").exists() else set()
    scr.show("1. ピント合わせの画面を開いています", ["保存はスペース, 終わりは q (その画面で)"])
    scr.key(30)
    cv2.destroyWindow(WIN)
    cv2.waitKey(1)
    subprocess.run([BASE_PY, str(HERE / "desk_cam_focus_257.py")])
    cv2.namedWindow(WIN, cv2.WINDOW_NORMAL)
    cv2.resizeWindow(WIN, Screen.W, Screen.H)
    after = set((HERE / "check_257").glob("desk_*.json")) if (HERE / "check_257").exists() else set()
    new = sorted(after - before)
    dst = OUT / "s1"
    dst.mkdir(exist_ok=True)
    for js in new:
        for p in (js, js.with_suffix(".png")):
            if p.exists():
                shutil.copy2(p, dst / p.name)
    ref = subprocess.run([BASE_PY, str(HERE / "desk_cam_focus_257.py"), "--score-image",
                          str(HERE / "check_248" / "desk_opencv1.png")], capture_output=True, text=True)
    (dst / "ref_248_score.txt").write_text(ref.stdout + ref.stderr)
    scr.wait_space("1. ピント合わせ 終わり", [f"保存した画像 {len(new)} 枚", "次は 2. 読み取りの速さ (触らない)"])


# ---- s2 読み取りの速さ ---------------------------------------------------------------

def joint_loop(stop, rows, extras=False, duration=30.0):
    fb = open_ro_bus(FOLLOWER_PORT, CAL_FOLLOWER)
    lb = open_ro_bus(LEADER_PORT, CAL_LEADER)
    try:
        t_end = time.perf_counter() + duration
        nxt = time.perf_counter()
        while time.perf_counter() < t_end and not stop.is_set():
            t0 = time.perf_counter()
            err = ""
            try:
                fp = fb.sync_read("Present_Position", num_retry=2)
            except Exception as e:
                fp, err = {}, f"F:{e}"
            t1 = time.perf_counter()
            try:
                lp = lb.sync_read("Present_Position", num_retry=2)
            except Exception as e:
                lp, err = {}, err + f" L:{e}"
            t2 = time.perf_counter()
            row = {"t0": t0, "follower_ms": (t1 - t0) * 1e3, "leader_ms": (t2 - t1) * 1e3, "err": err}
            if extras:
                for reg in ["Present_Current", "Present_Load", "Present_Temperature", "Present_Voltage"]:
                    a = time.perf_counter()
                    try:
                        v = fb.sync_read(reg, normalize=False, num_retry=2)
                        row[reg] = json.dumps(v)
                    except Exception as e:
                        row[reg] = f"ERR {e}"
                    row[reg + "_ms"] = (time.perf_counter() - a) * 1e3
            row["total_ms"] = (time.perf_counter() - t0) * 1e3
            rows.append(row)
            nxt += 1 / FPS
            time.sleep(max(0.0, nxt - time.perf_counter()))
    finally:
        close_ro(fb)
        close_ro(lb)


def save_rows(path, rows):
    if not rows:
        return
    keys = list(dict.fromkeys(k for r in rows for k in r))
    with open(path, "w", newline="") as fh:
        wr = csv.DictWriter(fh, keys)
        wr.writeheader()
        wr.writerows(rows)


def run_bg(scr, title, seconds, target, lines=(), cams=None):
    stop = threading.Event()
    th = threading.Thread(target=target, args=(stop,), daemon=True)
    th.start()
    try:
        scr.countdown(title, seconds + 1, lambda el: list(lines),
                      previews_fn=(lambda: [c.latest for c in cams.values()]) if cams else None,
                      small=["アームにもカメラにも触らない"])
        th.join(timeout=seconds + 10)
    finally:
        stop.set()
        th.join(timeout=5)


def stage2(scr, ctx):
    idx = ctx["cams"]["index"]
    d = OUT / "s2"
    d.mkdir(exist_ok=True)
    scr.wait_space("2. 読み取りの速さ (動かさない)",
                   ["約 2分40秒. アームにもカメラにも触らないで待つ",
                    "a) 関節の位置 30秒  b) 位置+電流など 15秒",
                    "c) カメラ 1280x720 30秒  d) 640x480 30秒",
                    "e) カメラ2台+関節 同時 30秒"])
    rows = []
    run_bg(scr, "2a. 関節の位置を読む", 30, lambda s: joint_loop(s, rows, False, 30), ["フォロワーとリーダーを読む"])
    save_rows(d / "a_joints.csv", rows)
    rows = []
    run_bg(scr, "2b. 位置+電流・負荷・温度・電圧", 15, lambda s: joint_loop(s, rows, True, 15))
    save_rows(d / "b_joints_extras.csv", rows)
    for tag, (w, h) in [("c_cam_1280x720", (1280, 720)), ("d_cam_640x480", (640, 480))]:
        stop = threading.Event()
        cams = start_cams(idx, w, h, stop)
        try:
            scr.countdown(f"2. カメラ {w}x{h}", 30, lambda el: ["カメラ2台を同時に開いている"],
                          previews_fn=lambda: [c.latest for c in cams.values()], small=["触らない"])
        finally:
            stop.set()
            for c in cams.values():
                c.join(5)
        for k, c in cams.items():
            c.save(d / f"{tag}_{k}")
    stop = threading.Event()
    cams = start_cams(idx, 640, 480, stop)
    rows = []
    try:
        run_bg(scr, "2e. カメラ2台+関節 同時", 30, lambda s: joint_loop(s, rows, True, 30), cams=cams)
    finally:
        stop.set()
        for c in cams.values():
            c.join(5)
    save_rows(d / "e_joints.csv", rows)
    for k, c in cams.items():
        c.save(d / f"e_cam_{k}")


# ---- テレオペ (s34) --------------------------------------------------------------------

def pose_gate(scr, title, lines, ref_fn, label_a, label_b):
    """読むだけのバスで姿勢の差を出し続け, 差が小さいときだけスペースで進める."""
    fb = open_ro_bus(FOLLOWER_PORT, CAL_FOLLOWER)
    lb = open_ro_bus(LEADER_PORT, CAL_LEADER) if ref_fn is None else None
    try:
        def check():
            f = fb.sync_read("Present_Position", num_retry=2)
            ref = lb.sync_read("Present_Position", num_retry=2) if lb else ref_fn()
            diff = pose_diff(ref, f) if lb else pose_diff(ref, f)
            return pose_ok(diff), pose_lines(diff, label_a, label_b)
        scr.wait_space(title, lines, check=check)
    finally:
        close_ro(fb)
        if lb:
            close_ro(lb)


class Teleop(threading.Thread):
    """lerobot-teleoperate と同じクラス・同じ既定の設定 (max_relative_target=None) で 30Hz のテレオペ.
    毎周: リーダーを読む → send_action → フォロワーの位置・電流・負荷・速さを読む. 温度は1秒ごと.
    フォロワーを connect する前に Goal_Position を今の位置に書いておく (トルクが入った瞬間に飛ばないように. RAM)."""

    def __init__(self, stop):
        super().__init__(daemon=True)
        self.stop, self.rows, self.phase, self.error, self.latest = stop, [], "start", None, {}
        self.ready = threading.Event()

    def run(self):
        from lerobot.robots.so_follower import SO101Follower, SO101FollowerConfig
        from lerobot.teleoperators.so_leader import SO101Leader, SO101LeaderConfig
        leader = robot = None
        try:
            leader = SO101Leader(SO101LeaderConfig(port=LEADER_PORT, id=LEADER_ID))
            leader.connect(calibrate=False)
            robot = SO101Follower(SO101FollowerConfig(port=FOLLOWER_PORT, id=FOLLOWER_ID))
            robot.bus.connect()
            raw = robot.bus.sync_read("Present_Position", normalize=False, num_retry=2)
            robot.bus.sync_write("Goal_Position", raw, normalize=False)
            robot.bus.disconnect(disable_torque=False)
            robot.connect(calibrate=False)
            self.ready.set()
            nxt = time.perf_counter()
            last_temp = 0.0
            while not self.stop.is_set():
                t0 = time.perf_counter()
                act = leader.get_action()
                t1 = time.perf_counter()
                sent = robot.send_action(act)
                t2 = time.perf_counter()
                pos = robot.bus.sync_read("Present_Position", num_retry=2)
                t3 = time.perf_counter()
                cur = robot.bus.sync_read("Present_Current", normalize=False, num_retry=2)
                load = robot.bus.sync_read("Present_Load", normalize=False, num_retry=2)
                vel = robot.bus.sync_read("Present_Velocity", normalize=False, num_retry=2)
                t4 = time.perf_counter()
                row = {"t0": t0, "t_act": t1, "t_sent": t2, "t_pos": t3, "t_extra": t4, "phase": self.phase}
                for m in MOTORS:
                    row[f"act_{m}"] = act[f"{m}.pos"]
                    row[f"sent_{m}"] = sent[f"{m}.pos"]
                    row[f"pos_{m}"] = pos[m]
                    row[f"cur_{m}"] = cur[m]
                    row[f"load_{m}"] = load[m]
                    row[f"vel_{m}"] = vel[m]
                if t0 - last_temp >= 1.0:
                    temp = robot.bus.sync_read("Present_Temperature", normalize=False, num_retry=2)
                    for m in MOTORS:
                        row[f"temp_{m}"] = temp[m]
                    last_temp = t0
                self.rows.append(row)
                self.latest = {m: (act[f"{m}.pos"], pos[m]) for m in MOTORS}
                nxt += 1 / FPS
                dt = nxt - time.perf_counter()
                if dt > 0:
                    time.sleep(dt)
                else:
                    nxt = time.perf_counter()
        except Exception as e:
            self.error = repr(e)
            self.ready.set()
        finally:
            for dev in (robot, leader):
                try:
                    if dev is not None and dev.is_connected:
                        dev.disconnect()
                except Exception as e:
                    print("[TELEOP] disconnect:", e)


def stage34(scr, ctx):
    idx = ctx["cams"]["index"]
    d = OUT / "s34"
    d.mkdir(exist_ok=True)
    pose_gate(scr, "3. テレオペの準備",
              ["フォロワーは休みの姿勢のまま. リーダーをフォロワーと同じ姿勢に合わせる",
               "差が小さくなったらスペース. フォロワーが動き出す"],
              None, "リーダー", "フォロワー")
    stop = threading.Event()
    cams = start_cams(idx, 640, 480, stop, video_dir=d, keep_small=True)
    tele = Teleop(stop)
    tele.start()
    tele.ready.wait(20)
    phases = []

    def set_phase(name):
        tele.phase = name
        phases.append((time.perf_counter(), name))

    def prev():
        return [c.latest for c in cams.values()]

    def status(_el=None):
        if not tele.latest:
            return []
        return ["差 (リーダー−フォロワー) " + "  ".join(f"{m[:5]} {a - p:+5.1f}" for m, (a, p) in tele.latest.items())]

    try:
        if tele.error:
            raise Abort(f"テレオペが始められない: {tele.error}")
        set_phase("free")
        scr.wait_space("3. テレオペ中 (ならし)", ["リーダーを少し動かして, フォロワーがついてくるのを確かめる",
                                             "次は 爪の開け閉め5回. 腕は止めて爪だけ動かす",
                                             "爪が手首カメラと机側カメラに映るようにしておく"])
        set_phase("grip_pre")
        scr.countdown("3. 腕を止めて待つ", 3, lambda el: ["腕も爪も止める"], previews_fn=prev)
        for k in range(5):
            set_phase(f"grip_{k + 1}")
            scr.countdown(f"3. 今! 爪をすばやく閉じて開く ({k + 1}/5)", 2.0,
                          lambda el: ["閉じる → すぐ開く. 腕は止めたまま"], previews_fn=prev, color=(0, 128, 255))
            set_phase(f"grip_{k + 1}_rest")
            scr.countdown(f"3. 止めて待つ ({k + 1}/5)", 3.0, lambda el: ["腕も爪も止める"], previews_fn=prev)
        for name, jp, note in [("slow", "ゆっくり", "1往復 5秒くらい"), ("normal", "ふつう", "1往復 2秒くらい"),
                               ("fast", "速く", "できるだけ速く. ただし物や人に当たらない範囲で")]:
            set_phase(f"{name}_pre")
            scr.wait_space(f"4. 次は「{jp}」15秒", [f"腕全体を大きく動かす ({note})", "肩・ひじ・手首・爪をぜんぶ使う",
                                                 "スペースで始める (テレオペは続いている)"])
            set_phase(name)
            scr.countdown(f"4. {jp}に大きく動かす", 15, lambda el: status(), previews_fn=prev,
                          color=(0, 128, 255) if name == "fast" else (0, 255, 0))
        set_phase("rest")
        scr.wait_space("4. 終わり. リーダーで休みの姿勢へ", ["フォロワーを机の上の休みの姿勢まで下ろす",
                                                      "スペースでテレオペを止める (フォロワーの力が抜ける)"])
    finally:
        stop.set()
        tele.join(10)
        for c in cams.values():
            c.join(5)
        save_rows(d / "teleop.csv", tele.rows)
        for k, c in cams.items():
            c.save(d / f"cam_{k}")
        (d / "phases.json").write_text(json.dumps({"phases": phases, "error": tele.error}, ensure_ascii=False, indent=2))


# ---- s5 lerobot-record ------------------------------------------------------------------

def run_sub(scr, title, cmd, log_path, lines_fn, color=(0, 255, 0)):
    """サブプロセスを動かしながら, ウィンドウに状況を出す. q で SIGINT を送る."""
    log = open(log_path, "w")
    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, cwd=str(REPO))
    buf = []

    def reader():
        for ln in p.stdout:
            log.write(ln)
            log.flush()
            buf.append((time.perf_counter(), ln.rstrip()))
    th = threading.Thread(target=reader, daemon=True)
    th.start()
    t0 = time.perf_counter()
    try:
        while p.poll() is None:
            scr.show(title, lines_fn(buf, time.perf_counter() - t0),
                     [buf[-1][1][-110:] if buf else "", "q = 止める"], color)
            scr.key(100)
    except Abort:
        p.send_signal(signal.SIGINT)
        try:
            p.wait(20)
        except subprocess.TimeoutExpired:
            p.kill()
        raise
    finally:
        th.join(5)
        log.close()
    return p.returncode


def stage5(scr, ctx):
    idx = ctx["cams"]["index"]
    if DATASET_ROOT.exists():
        raise Abort(f"{DATASET_ROOT} がすでにある (上書きしない)")
    cams = (f"{{ wrist: {{type: opencv, index_or_path: {idx['wrist']}, width: 640, height: 480, fps: {FPS}, fourcc: MJPG}}, "
            f"desk: {{type: opencv, index_or_path: {idx['desk']}, width: 640, height: 480, fps: {FPS}, fourcc: MJPG}} }}")
    cmd = [sys.executable, "-m", "lerobot.scripts.lerobot_record",
           "--robot.type=so101_follower", f"--robot.port={FOLLOWER_PORT}", f"--robot.id={FOLLOWER_ID}",
           f"--robot.cameras={cams}",
           "--teleop.type=so101_leader", f"--teleop.port={LEADER_PORT}", f"--teleop.id={LEADER_ID}",
           f"--dataset.repo_id={DATASET_REPO}", f"--dataset.root={DATASET_ROOT}", "--dataset.no_stamp=true",
           "--dataset.push_to_hub=false", f"--dataset.fps={FPS}", "--dataset.single_task=check 258 practice",
           "--dataset.num_episodes=3", "--dataset.episode_time_s=10", "--dataset.reset_time_s=10",
           "--display_data=false", "--play_sounds=false"]
    (OUT / "s5_cmd.json").write_text(json.dumps(cmd, ensure_ascii=False, indent=2))
    pose_gate(scr, "5. LeRobot の記録 (10秒×3回)",
              ["各回: 休みの姿勢から始めて, 腕を動かし, 10秒で休みの姿勢に戻す",
               "回と回の間に10秒の休み (テレオペは続く)",
               "リーダーをフォロワーと同じ姿勢に合わせてスペース"],
              None, "リーダー", "フォロワー")

    def lines_fn(buf, el):
        state = "準備中"
        for _, ln in buf:
            if "Recording episode" in ln:
                state = "記録中: " + ln.split("Recording episode")[-1].strip() + " 回目 (0から)"
            elif "Reset the environment" in ln:
                state = "休み: 休みの姿勢に戻して待つ"
            elif "Stop recording" in ln:
                state = "記録おわり. 書き出し中"
        return [state, "10秒で 休みの姿勢 → 動かす → 休みの姿勢", "最後の回の終わりは必ず休みの姿勢 (力が抜ける)"]
    rc = run_sub(scr, "5. 記録中 (lerobot-record)", cmd, OUT / "s5_record.log", lines_fn)
    if rc != 0:
        raise Abort(f"lerobot-record が {rc} で終わった. s5_record.log を見る")


# ---- s6 lerobot-replay ------------------------------------------------------------------

def episode_first_action(ep):
    import pandas as pd
    files = sorted((DATASET_ROOT / "data").rglob("*.parquet"))
    df = pd.concat([pd.read_parquet(f) for f in files])
    df = df[df["episode_index"] == ep].sort_values("frame_index")
    a = df.iloc[0]["action"]
    return {m: float(a[i]) for i, m in enumerate(MOTORS)}


def stage6(scr, ctx, episode=0):
    first = episode_first_action(episode)
    for k in (1, 2):
        log_csv = OUT / f"s6_replay{k}.csv"
        if log_csv.exists():
            raise Abort(f"{log_csv} がすでにある")
        pose_gate(scr, f"6. 記録の {episode} 回目をフォロワーで再生 ({k}/2)",
                  ["記録と同じ速さでフォロワーが動く (約10秒). リーダーは使わない",
                   "フォロワーのまわりに物や手がないことを確かめる",
                   "差が大きいときは, 力の抜けたフォロワーを手で休みの姿勢に合わせる",
                   "よければスペースで再生を始める"],
                  lambda: first, "記録の最初", "フォロワー")
        cmd = [sys.executable, str(HERE / "replay_logged_258.py"), str(log_csv),
               "--robot.type=so101_follower", f"--robot.port={FOLLOWER_PORT}", f"--robot.id={FOLLOWER_ID}",
               f"--dataset.repo_id={DATASET_REPO}", f"--dataset.root={DATASET_ROOT}", f"--dataset.episode={episode}",
               "--play_sounds=false"]
        rc = run_sub(scr, f"6. 再生中 ({k}/2)", cmd, OUT / f"s6_replay{k}.log",
                     lambda buf, el: ["フォロワーが記録どおりに動いています", f"{el:4.1f} 秒"], color=(0, 128, 255))
        if rc != 0:
            raise Abort(f"再生が {rc} で終わった. s6_replay{k}.log を見る")
        scr.countdown("6. 再生おわり", 2, lambda el: ["フォロワーの力が抜けています"])


# ---- 本体 -------------------------------------------------------------------------------

STAGES = {"s0": stage0, "s1": stage1, "s2": stage2, "s34": stage34, "s5": stage5, "s6": stage6}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--only", nargs="*", choices=list(STAGES), help="行う段階 (省略で全部)")
    args = ap.parse_args()
    OUT.mkdir(parents=True, exist_ok=True)
    todo = args.only or list(STAGES)
    if "s0" not in todo:
        todo = ["s0"] + todo  # カメラの番号は毎回名前で引き直す
    scr = Screen()
    ctx = {}
    done, status = [], "ok"
    try:
        for s in todo:
            print(f"[STAGE] {s} 始め {datetime.now():%H:%M:%S}")
            STAGES[s](scr, ctx)
            done.append(s)
        scr.show("ぜんぶ終わり", ["おつかれさまでした. 何かキーで閉じる"], color=(0, 255, 0))
        cv2.waitKey(10000)
    except Abort as e:
        status = f"止めた: {e}"
        print("[ABORT]", e)
        try:
            scr.show("止めました", [str(e)[:60]], color=(0, 0, 255))
            cv2.waitKey(3000)
        except Exception:
            pass
    finally:
        with open(OUT / "run_log.jsonl", "a") as fh:
            fh.write(json.dumps({"time": datetime.now().isoformat(), "todo": todo, "done": done, "status": status},
                                ensure_ascii=False) + "\n")
        cv2.destroyAllWindows()
    return 0 if status == "ok" else 1


if __name__ == "__main__":
    sys.exit(main())
```

### 集計するスクリプト check_258_analyze.py（全文）

```python
"""check_258.py が so101/check_258/ に残した記録を解析する (依頼 258). アーム・カメラにはつながない.

出力: so101/check_258/analysis.json と, 画面に表のもとになる数字.

使い方 (conda の lerobot 環境で):
    python so101/check_258_analyze.py
"""

import csv
import json
import subprocess
import sys
from pathlib import Path

import cv2
import numpy as np
import pandas as pd

HERE = Path(__file__).resolve().parent
OUT = HERE / "check_258"
MOTORS = ["shoulder_pan", "shoulder_lift", "elbow_flex", "wrist_flex", "wrist_roll", "gripper"]
FPS = 30
DT = 1 / FPS
FFPROBE = "/opt/homebrew/Caskroom/miniforge/base/envs/lerobot/bin/ffprobe"


def stats(x):
    x = np.asarray([v for v in x if np.isfinite(v)], dtype=float)
    if len(x) == 0:
        return None
    return {"n": int(len(x)), "median": round(float(np.median(x)), 2), "p95": round(float(np.percentile(x, 95)), 2),
            "max": round(float(x.max()), 2), "mean": round(float(x.mean()), 2), "std": round(float(x.std()), 2)}


# ---- s1 ------------------------------------------------------------------------------

def s1():
    d = OUT / "s1"
    res = {"saved": []}
    for js in sorted(d.glob("desk_*.json")):
        j = json.loads(js.read_text())
        res["saved"].append({"image": j["image"], "focus": {k: round(v, 1) for k, v in j["focus"].items()},
                             "center_max_so_far": round(j.get("center_max_so_far", 0), 1)})
    ref = d / "ref_248_score.txt"
    res["ref_248"] = ref.read_text().strip() if ref.exists() else None
    return res


# ---- s2 ------------------------------------------------------------------------------

def joints(path):
    df = pd.read_csv(path)
    res = {"n": len(df), "errors": int((df["err"].fillna("") != "").sum()),
           "follower_ms": stats(df["follower_ms"]), "leader_ms": stats(df["leader_ms"]),
           "both_ms": stats(df["follower_ms"] + df["leader_ms"]), "total_ms": stats(df["total_ms"]),
           "over_33ms": int((df["total_ms"] > 1000 / FPS).sum())}
    for reg in ["Present_Current", "Present_Load", "Present_Temperature", "Present_Voltage"]:
        if reg + "_ms" in df:
            res[reg + "_ms"] = stats(df[reg + "_ms"])
            res[reg + "_sample"] = df[reg].iloc[len(df) // 2]
    return res


def cam(stem):
    df = pd.read_csv(f"{stem}.csv")
    props = json.loads(Path(f"{stem}_props.json").read_text())
    ok = df[df["pos_msec"] != -1]
    t = ok["t"].to_numpy()
    if len(t) < 3:
        return {"frames": len(t), "props": props}
    iv = np.diff(t) * 1e3
    drops = int(sum(max(0, round(x / (1000 / FPS)) - 1) for x in iv if x > 1.5 * 1000 / FPS))
    pm = ok["pos_msec"].to_numpy()
    t_ = t[t >= t[0] + 1.0]  # 開いた直後の1秒を除いたもの
    iv1 = np.diff(t_) * 1e3
    after = {"fps": round((len(t_) - 1) / (t_[-1] - t_[0]), 2), "interval_ms": stats(iv1),
             "interval_over_50ms": int((iv1 > 50).sum()),
             "drops_est": int(sum(max(0, round(x / (1000 / FPS)) - 1) for x in iv1 if x > 1.5 * 1000 / FPS))}
    return {"frames": int(len(t)), "read_fail": int(len(df) - len(ok)), "fps": round((len(t) - 1) / (t[-1] - t[0]), 2),
            "interval_ms": stats(iv), "interval_over_50ms": int((iv > 50).sum()), "drops_est": drops, "after_first_1s": after,
            "pos_msec_varies": bool(np.ptp(pm) > 0), "pos_msec_interval_ms": stats(np.diff(pm)) if np.ptp(pm) > 0 else None,
            "resolution": [int(ok["w"].iloc[0]), int(ok["h"].iloc[0])], "blur_center": stats(ok["blur_center"]),
            "props": props["props"], "t": t}


def cam_pair(a, b):
    """手首のコマごとに, いちばん近い机側のコマの届いた時刻の差 (ms). 2台はつながっていないので位相はばらばら."""
    ta, tb = a.get("t"), b.get("t")
    if ta is None or tb is None:
        return None
    j = np.clip(np.searchsorted(tb, ta), 1, len(tb) - 1)
    near = np.where(np.abs(tb[j] - ta) < np.abs(tb[j - 1] - ta), tb[j], tb[j - 1])
    d = (near - ta) * 1e3
    keep = ta >= max(ta[0], tb[0]) + 1.0
    return {"wrist_minus_desk_nearest_ms": stats(np.abs(d)), "after_first_1s": stats(np.abs(d[keep]))}


def s2():
    d = OUT / "s2"
    res = {}
    for k, f in [("a_joints", "a_joints.csv"), ("b_joints_extras", "b_joints_extras.csv"), ("e_joints", "e_joints.csv")]:
        if (d / f).exists():
            res[k] = joints(d / f)
    for tag in ["c_cam_1280x720", "d_cam_640x480", "e_cam"]:
        cams = {k: cam(d / f"{tag}_{k}") for k in ("wrist", "desk") if (d / f"{tag}_{k}.csv").exists()}
        if len(cams) == 2:
            res[tag + "_pair"] = cam_pair(cams["wrist"], cams["desk"])
        for k, v in cams.items():
            v.pop("t", None)
            res[f"{tag}_{k}"] = v
    return res


# ---- s34 -----------------------------------------------------------------------------

def load_cam34(key):
    stem = OUT / "s34" / f"cam_{key}"
    df = pd.read_csv(f"{stem}.csv")
    df = df[df["pos_msec"] != -1].reset_index(drop=True)
    small = np.load(f"{stem}_small.npy").astype(np.float32)
    n = min(len(df), len(small))
    return df.iloc[:n], small[:n]


def onset_series(t, x, t_from, t_to, base_from, base_to, k=6.0, floor=0.0):
    """t_from〜t_to の中で, 基準区間の中央値から k×MAD (かつ floor) を越えた最初の時刻."""
    base = x[(t >= base_from) & (t < base_to)]
    if len(base) < 3:
        return None
    med = np.median(base)
    mad = np.median(np.abs(base - med)) * 1.4826 + 1e-9
    thr = max(k * mad, floor)
    m = (t >= t_from) & (t < t_to) & (np.abs(x - med) > thr)
    idx = np.flatnonzero(m)
    return float(t[idx[0]]) if len(idx) else None


def s34():
    d = OUT / "s34"
    tele = pd.read_csv(d / "teleop.csv")
    phases = json.loads((d / "phases.json").read_text())["phases"]
    ph_t = [(float(t), n) for t, n in phases]

    def span(name):
        for i, (t, n) in enumerate(ph_t):
            if n == name:
                return t, (ph_t[i + 1][0] if i + 1 < len(ph_t) else tele["t0"].iloc[-1])
        return None

    res = {"loops": len(tele), "loop_interval_ms": stats(np.diff(tele["t0"]) * 1e3),
           "loop_work_ms": stats((tele["t_extra"] - tele["t0"]) * 1e3),
           "leader_read_ms": stats((tele["t_act"] - tele["t0"]) * 1e3),
           "send_ms": stats((tele["t_sent"] - tele["t_act"]) * 1e3),
           "follower_pos_read_ms": stats((tele["t_pos"] - tele["t_sent"]) * 1e3),
           "extra_reads_ms": stats((tele["t_extra"] - tele["t_pos"]) * 1e3)}

    # 爪のできごと: リーダーの爪 (action) が動き始めた時刻を基準に, フォロワーの爪 (state)・手首カメラ・机側カメラ.
    # 画像は, 合図の区間で画素ごとの揺れが大きい上位 3% (= 爪が動く場所) だけを見て, 合図の前の平均からの差で決める
    cams = {k: load_cam34(k) for k in ("wrist", "desk")}
    tg = tele["t_pos"].to_numpy()
    ta = tele["t_act"].to_numpy()
    gp = tele["pos_gripper"].to_numpy()
    ga = tele["act_gripper"].to_numpy()

    def first(t, x, t0, t1, base, thr):
        i = np.flatnonzero((t >= t0) & (t < t1) & (np.abs(x - base) > thr))
        return float(t[i[0]]) if len(i) else None

    events = []
    for k in range(1, 6):
        sp = span(f"grip_{k}")
        if sp is None:
            continue
        s0, b0, w1 = sp[0], sp[0] - 1.0, sp[0] + 5.0
        ev = {"event": k, "leader_gripper_max_in_window": round(float(ga[(ta >= s0) & (ta < w1)].max()), 1)}
        la = first(ta, ga, s0 - 0.5, w1, np.median(ga[(ta >= b0) & (ta < s0)]), 3.0)
        ev["leader_action"] = la
        ev["follower_state"] = first(tg, gp, s0 - 0.5, w1, np.median(gp[(tg >= b0) & (tg < s0)]), 3.0)
        for cname, (df, small) in cams.items():
            if la is None:
                ev[f"{cname}_cam"] = None
                continue
            tc = df["t"].to_numpy()
            mw, mb = (tc >= s0 - 0.5) & (tc < w1), (tc >= b0) & (tc < s0)
            sd = small[mw].std(axis=0)
            mask = sd > np.percentile(sd, 97)
            base = small[mb].mean(axis=0)
            sig = np.abs(small[:, mask] - base[mask]).mean(axis=1)
            bs = sig[mb]
            thr = np.median(bs) + 6 * (np.median(np.abs(bs - np.median(bs))) * 1.4826 + 0.3)
            ev[f"{cname}_cam"] = first(tc, sig, la - 0.3, w1, 0.0, thr)
        events.append(ev)
    rel = {}

    def rel_ms(a_, b_):
        return [round((e[a_] - e[b_]) * 1e3) if (e.get(a_) and e.get(b_)) else None for e in events]
    for a_, b_ in [("follower_state", "leader_action"), ("wrist_cam", "leader_action"), ("desk_cam", "leader_action"),
                   ("wrist_cam", "follower_state"), ("desk_cam", "follower_state"), ("wrist_cam", "desk_cam")]:
        rel[f"{a_}_minus_{b_}_ms_per_event"] = rel_ms(a_, b_)
    res["grip_events"] = [{k: (round(v, 4) if isinstance(v, float) else v) for k, v in e.items()} for e in events]
    res["grip_lag"] = rel

    # リーダー (action) に対するフォロワー (state) の遅れ: 速い区間での相互相関 (関節ごと)
    lag = {}
    for m in MOTORS:
        a = np.interp(np.arange(ta[0], ta[-1], 0.005), ta, tele[f"act_{m}"])
        s = np.interp(np.arange(ta[0], ta[-1], 0.005), tg, tele[f"pos_{m}"])
        va, vs = np.diff(a), np.diff(s)
        best, bl = -1, 0
        for L in range(0, 101):  # 0〜500ms
            c = np.corrcoef(va[:len(va) - L], vs[L:])[0, 1] if L else np.corrcoef(va, vs)[0, 1]
            if np.isfinite(c) and c > best:
                best, bl = c, L
        lag[m] = {"lag_ms": bl * 5, "corr": round(float(best), 3)}
    res["follower_lag_xcorr"] = lag

    # 速さ別
    seg = {}
    for name in ["slow", "normal", "fast"]:
        sp = span(name)
        if sp is None:
            continue
        m_ = (tele["t0"] >= sp[0]) & (tele["t0"] < sp[1])
        sub = tele[m_]
        t = sub["t_pos"].to_numpy()
        r = {"seconds": round(sp[1] - sp[0], 1), "joints": {}}
        for mo in MOTORS:
            p = sub[f"pos_{mo}"].to_numpy()
            v = np.abs(np.diff(p) / np.diff(t))
            err = (sub[f"act_{mo}"] - sub[f"pos_{mo}"]).abs().to_numpy()
            # rustypot が符号つきにして返す (負の値が出る). 電流は 6.5mA/目盛, 負荷は 0.1%/目盛, 速さは 目盛/秒
            cur = sub[f"cur_{mo}"].to_numpy()
            load = sub[f"load_{mo}"].to_numpy()
            sv = sub[f"vel_{mo}"].to_numpy()
            temps = sub[f"temp_{mo}"].dropna().to_numpy() if f"temp_{mo}" in sub else np.array([])
            unit = "%" if mo == "gripper" else "deg"
            # 離れた区間: |差| > 10 (deg か %) が 0.1 秒以上続いた区間
            far = err > 10
            runs, start = [], None
            for i, f in enumerate(far):
                if f and start is None:
                    start = i
                if (not f or i == len(far) - 1) and start is not None:
                    end = i if not f else i + 1
                    if t[min(end, len(t) - 1)] - t[start] >= 0.1:
                        runs.append(round(float(t[min(end, len(t) - 1)] - t[start]), 2))
                    start = None
            r["joints"][mo] = {
                f"max_speed_{unit}_s": round(float(np.percentile(v, 99)), 1) if len(v) else None,
                f"peak_speed_{unit}_s": round(float(v.max()), 1) if len(v) else None,
                "servo_velocity_raw_max": int(np.abs(sv).max()),
                "servo_velocity_deg_s_max": round(float(np.abs(sv).max() * 360 / 4096), 1),
                f"max_leader_diff_{unit}": round(float(err.max()), 1),
                f"p95_leader_diff_{unit}": round(float(np.percentile(err, 95)), 1),
                "far_runs_s": runs,
                "current_raw_max": int(np.abs(cur).max()), "current_mA_max": round(float(np.abs(cur).max() * 6.5)),
                "load_raw_max": int(np.abs(load).max()), "load_pct_max": round(float(np.abs(load).max() / 10), 1),
                "temp_start_end": [float(temps[0]), float(temps[-1])] if len(temps) else None,
            }
        for cname, (df, _s) in cams.items():
            mm = (df["t"] >= sp[0]) & (df["t"] < sp[1])
            r[f"{cname}_blur"] = stats(df.loc[mm, "blur_center"])
        seg[name] = r
    res["speed_segments"] = seg

    # ぶれと関節の速さの関係 (s34 の全コマ): 関節1〜5 の速さの最大で区切って, 手首・机側のピントの中央値
    tt = tele["t_pos"].to_numpy()
    body_v = np.zeros(len(tt))
    for mo in MOTORS[:5]:
        p = tele[f"pos_{mo}"].to_numpy()
        v = np.r_[0, np.abs(np.diff(p) / np.maximum(np.diff(tt), 1e-3))]
        body_v = np.maximum(body_v, v)
    bins = [0, 10, 30, 60, 100, 150, 200, 300, 1e9]
    blur_by_speed = {}
    for cname, (df, _s) in cams.items():
        vv = np.interp(df["t"], tt, body_v)
        rows = []
        for lo, hi in zip(bins[:-1], bins[1:]):
            m_ = (vv >= lo) & (vv < hi)
            if m_.sum() >= 5:
                rows.append({"speed_deg_s": f"{lo}-{hi if hi < 1e9 else ''}", "frames": int(m_.sum()),
                             "blur_median": round(float(np.median(df.loc[m_, "blur_center"])), 1)})
        blur_by_speed[cname] = rows
    res["blur_by_body_speed"] = blur_by_speed

    # 爪の値と手首カメラの爪の開き: 爪区間の手首のコマで, 開いた状態 (grip_pre) からの差の大きさと爪の値の相関
    sp0, sp_end = span("grip_pre"), span("grip_5_rest")
    if sp0 and sp_end:
        df, small = cams["wrist"]
        tc = df["t"].to_numpy()
        m_ = (tc >= sp0[0]) & (tc < sp_end[1])
        ref = small[(tc >= sp0[0]) & (tc < sp0[1])].mean(axis=0)
        dev = np.abs(small[m_] - ref).mean(axis=(1, 2))
        g = np.interp(tc[m_], tg, gp)
        res["gripper_vs_wrist_image"] = {"frames": int(m_.sum()),
                                         "pearson_r_gripper_vs_image_change": round(float(np.corrcoef(g, dev)[0, 1]), 3),
                                         "gripper_range_in_events": [round(float(g.min()), 1), round(float(g.max()), 1)]}
        save_gripper_montage(tc, tg, gp, sp0[0], sp_end[1])
    return res


def save_gripper_montage(tc, tg, gp, t0, t1):
    """手首の動画から, 爪の値がちがう6コマを並べた画像を作る (目で合っているか見る用)."""
    cap = cv2.VideoCapture(str(OUT / "s34" / "wrist.mp4"))
    frames = []
    i = 0
    m_idx = set(np.flatnonzero((tc >= t0) & (tc < t1)).tolist())
    while True:
        ok, f = cap.read()
        if not ok:
            break
        if i in m_idx:
            frames.append((i, f))
        i += 1
    cap.release()
    if not frames:
        return
    vals = [(float(np.interp(tc[i], tg, gp)), i, f) for i, f in frames]
    vals.sort(key=lambda x: x[0])
    pick = [vals[int(k * (len(vals) - 1) / 5)] for k in range(6)]
    tiles = []
    for g, i, f in pick:
        im = cv2.resize(f, (320, 240))
        cv2.putText(im, f"gripper {g:.1f}", (8, 28), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 0), 4)
        cv2.putText(im, f"gripper {g:.1f}", (8, 28), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 255), 2)
        tiles.append(im)
    cv2.imwrite(str(OUT / "gripper_vs_wrist.png"), np.vstack([np.hstack(tiles[:3]), np.hstack(tiles[3:])]))


# ---- s5 ------------------------------------------------------------------------------

def s5():
    root = OUT / "dataset"
    if not root.exists():
        return None
    info = json.loads((root / "meta" / "info.json").read_text())
    res = {"info": {k: v for k, v in info.items() if k != "features"}, "features": info["features"]}
    files = sorted((root / "data").rglob("*.parquet"))
    df = pd.concat([pd.read_parquet(f) for f in files])
    res["parquet_files"] = [str(f.relative_to(root)) for f in files]
    res["parquet_columns"] = {c: str(df[c].dtype) for c in df.columns}
    res["parquet_head"] = df.head(3).astype(str).to_dict("records")
    eps = {}
    for ep, g in df.groupby("episode_index"):
        ts = g["timestamp"].to_numpy()
        eps[int(ep)] = {"frames": int(len(g)), "timestamp_first_last": [float(ts[0]), float(ts[-1])],
                        "timestamp_step": stats(np.diff(ts) * 1e3),
                        "timestamp_equals_index_over_fps": bool(np.allclose(ts, g["frame_index"].to_numpy() / FPS, atol=1e-4))}
    res["episodes"] = eps
    vids = sorted((root / "videos").rglob("*.mp4"))
    res["videos"] = []
    for v in vids:
        pr = subprocess.run([FFPROBE, "-v", "error", "-select_streams", "v:0", "-count_frames", "-show_entries",
                             "stream=codec_name,pix_fmt,width,height,r_frame_rate,avg_frame_rate,nb_read_frames,duration",
                             "-of", "json", str(v)], capture_output=True, text=True)
        st = json.loads(pr.stdout).get("streams", [{}])[0] if pr.returncode == 0 else {"err": pr.stderr[-300:]}
        st["file"] = str(v.relative_to(root))
        st["MB"] = round(v.stat().st_size / 1e6, 3)
        res["videos"].append(st)
    total = sum(p.stat().st_size for p in root.rglob("*") if p.is_file())
    secs = sum(e["frames"] for e in eps.values()) / FPS
    res["size"] = {"total_MB": round(total / 1e6, 2), "seconds": round(secs, 1),
                   "MB_per_s": round(total / 1e6 / secs, 3) if secs else None,
                   "video_MB": round(sum(v.stat().st_size for v in vids) / 1e6, 2),
                   "parquet_MB": round(sum(f.stat().st_size for f in files) / 1e6, 3)}
    mbps = res["size"]["MB_per_s"]
    if mbps:
        res["size"]["estimate_MB"] = {f"{sec}s": {"1": round(mbps * sec, 1), "100": round(mbps * sec * 100),
                                                  "1000": round(mbps * sec * 1000)} for sec in (10, 20, 30, 60)}
    return res


# ---- s6 ------------------------------------------------------------------------------

def s6(episode=0):
    root = OUT / "dataset"
    logs = [OUT / f"s6_replay{k}.csv" for k in (1, 2)]
    if not all(p.exists() for p in logs) or not root.exists():
        return None
    files = sorted((root / "data").rglob("*.parquet"))
    df = pd.concat([pd.read_parquet(f) for f in files])
    g = df[df["episode_index"] == episode].sort_values("frame_index")
    rec_state = np.stack(g["observation.state"].to_numpy())
    rec_action = np.stack(g["action"].to_numpy())
    reps = []
    for p in logs:
        r = pd.read_csv(p)
        o = r[r["kind"] == "obs"].sort_values("frame")
        reps.append(o[MOTORS].to_numpy())
    n = min(len(rec_state), *(len(x) for x in reps))
    # replay の obs[i] は i 番目の指令を送る前に読んだ位置. 記録の state[i] も action[i] を送る前に読んだ位置なので同じ並び
    res = {"frames": int(n), "joints": {}}
    for j, m in enumerate(MOTORS):
        d_rec1 = np.abs(reps[0][:n, j] - rec_state[:n, j])
        d_rec2 = np.abs(reps[1][:n, j] - rec_state[:n, j])
        d_12 = np.abs(reps[0][:n, j] - reps[1][:n, j])
        res["joints"][m] = {"replay1_vs_record_mean": round(float(d_rec1.mean()), 2), "replay1_vs_record_max": round(float(d_rec1.max()), 2),
                            "replay2_vs_record_mean": round(float(d_rec2.mean()), 2), "replay2_vs_record_max": round(float(d_rec2.max()), 2),
                            "replay1_vs_replay2_mean": round(float(d_12.mean()), 2), "replay1_vs_replay2_max": round(float(d_12.max()), 2),
                            "final_rec_r1_r2": [round(float(rec_state[n - 1, j]), 2), round(float(reps[0][n - 1, j]), 2), round(float(reps[1][n - 1, j]), 2)],
                            "record_action_vs_state_max": round(float(np.abs(rec_action[:n, j] - rec_state[:n, j]).max()), 2)}
    return res


def main():
    res = {}
    for name, fn in [("s1", s1), ("s2", s2), ("s34", s34), ("s5", s5), ("s6", s6)]:
        try:
            res[name] = fn()
        except FileNotFoundError as e:
            res[name] = {"missing": str(e)}
        except Exception as e:
            res[name] = {"error": repr(e)}
    cal = OUT / "calibration_check.json"
    if cal.exists():
        res["calibration"] = json.loads(cal.read_text())
    (OUT / "analysis.json").write_text(json.dumps(res, ensure_ascii=False, indent=1, default=str))
    print(json.dumps(res, ensure_ascii=False, indent=1, default=str)[:20000])


if __name__ == "__main__":
    sys.exit(main())
```

### 再生を記録するスクリプト replay_logged_258.py（全文）

```python
"""lerobot-replay をそのまま動かし, フォロワーに届いた角度と送った指令を CSV に残す (依頼 258).

lerobot-replay は毎コマ get_observation() を呼ぶが結果を捨てる. ここでは SOFollower の
get_observation と send_action を包んで, 呼ばれた時刻と値を書くだけにする (指令の中身は変えない).

使い方 (conda の lerobot 環境で):
    python so101/replay_logged_258.py OUT.csv --robot.type=so101_follower --robot.port=... --robot.id=... \
        --dataset.repo_id=... --dataset.root=... --dataset.episode=0 --play_sounds=false
"""

import csv
import sys
import time

from lerobot.robots.so_follower import so_follower as sf
from lerobot.scripts import lerobot_replay

MOTORS = ["shoulder_pan", "shoulder_lift", "elbow_flex", "wrist_flex", "wrist_roll", "gripper"]


def main():
    out = sys.argv.pop(1)
    rows = []
    state = {"n": 0}
    orig_obs, orig_send = sf.SOFollower.get_observation, sf.SOFollower.send_action

    def get_observation(self):
        obs = orig_obs(self)
        rows.append(["obs", state["n"], time.perf_counter()] + [obs[f"{m}.pos"] for m in MOTORS])
        return obs

    def send_action(self, action):
        sent = orig_send(self, action)
        rows.append(["sent", state["n"], time.perf_counter()] + [float(sent[f"{m}.pos"]) for m in MOTORS])
        state["n"] += 1
        return sent

    sf.SOFollower.get_observation = get_observation
    sf.SOFollower.send_action = send_action
    try:
        lerobot_replay.main()
    finally:
        with open(out, "w", newline="") as fh:
            wr = csv.writer(fh)
            wr.writerow(["kind", "frame", "t"] + MOTORS)
            wr.writerows(rows)
        print(f"[REPLAY-LOG] {out} に {len(rows)} 行")


if __name__ == "__main__":
    main()
```

### キャリブレーションを確かめるスクリプト verify_calibration_258.py（全文）

```python
"""SO-101 のキャリブレーションのファイルと, サーボの中の値・角度の変換を読むだけで突き合わせる (依頼 258).

書き込みは一切しない (connect(handshake=False), disconnect(disable_torque=False)).
- サーボの Homing_Offset・Min/Max_Position_Limit を読み, ファイルの homing_offset・range_min/max と比べる
- 生の Present_Position と LeRobot の正規化した値を続けて読み, 式 (raw − (min+max)/2) × 360 / 4095 と合うか
- 分解能 (1目盛の角度)

使い方 (conda の lerobot 環境で):
    python so101/verify_calibration_258.py
"""

import json
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
from check_258 import (CAL_FOLLOWER, CAL_LEADER, FOLLOWER_PORT, LEADER_PORT, MOTORS, OUT,  # noqa: E402
                       close_ro, open_ro_bus)


def check(port, cal_path):
    cal = json.loads(Path(cal_path).read_text())
    bus = open_ro_bus(port, cal_path)
    try:
        res_ = bus.resolution("sts3215")
        regs = {}
        for reg in ["Homing_Offset", "Min_Position_Limit", "Max_Position_Limit"]:
            try:
                regs[reg] = bus.sync_read(reg, normalize=False, num_retry=2)
            except Exception as e:
                regs[reg] = f"ERR {e}"
        raw = bus.sync_read("Present_Position", normalize=False, num_retry=2)
        norm = bus.sync_read("Present_Position", num_retry=2)
        raw2 = bus.sync_read("Present_Position", normalize=False, num_retry=2)
    finally:
        close_ro(bus)
    rows = {}
    for m in MOTORS:
        c = cal[m]
        mn, mx = c["range_min"], c["range_max"]
        r = (raw[m] + raw2[m]) / 2
        if m == "gripper":
            expect = (min(mx, max(mn, r)) - mn) / (mx - mn) * 100
        else:
            expect = (r - (mn + mx) / 2) * 360 / (res_ - 1)
        hw = {k: (v[m] if isinstance(v, dict) else v) for k, v in regs.items()}
        rows[m] = {"file": c, "servo": hw,
                   "homing_match": hw.get("Homing_Offset") == c["homing_offset"],
                   "limits_match": hw.get("Min_Position_Limit") == mn and hw.get("Max_Position_Limit") == mx,
                   "raw": [raw[m], raw2[m]], "lerobot_value": round(norm[m], 3), "formula_value": round(expect, 3),
                   "diff": round(norm[m] - expect, 3),
                   "unit": "0-100" if m == "gripper" else "deg",
                   "step": round(100 / (mx - mn), 4) if m == "gripper" else round(360 / (res_ - 1), 4),
                   "range_deg" if m != "gripper" else "range_raw": round((mx - mn) * 360 / (res_ - 1), 1) if m != "gripper" else mx - mn}
    return {"resolution": res_, "motors": rows}


def main():
    out = {"follower": check(FOLLOWER_PORT, CAL_FOLLOWER), "leader": check(LEADER_PORT, CAL_LEADER)}
    (OUT / "calibration_check.json").write_text(json.dumps(out, ensure_ascii=False, indent=2))
    print(json.dumps(out, ensure_ascii=False, indent=1))


if __name__ == "__main__":
    main()
```

### 集計の結果 analysis.json（全量）

```json
{
 "s1": {
  "saved": [
   {
    "image": "desk_20261122_171646.png",
    "focus": {
     "center": 1.4,
     "top_left": 6.3,
     "top_right": 4.4,
     "bottom_left": 5.8,
     "bottom_right": 5.9
    },
    "center_max_so_far": 1.6
   },
   {
    "image": "desk_20261122_172516.png",
    "focus": {
     "center": 1322.9,
     "top_left": 60.8,
     "top_right": 2.4,
     "bottom_left": 27.1,
     "bottom_right": 7.5
    },
    "center_max_so_far": 1575.3
   },
   {
    "image": "desk_20261122_172522.png",
    "focus": {
     "center": 1328.5,
     "top_left": 65.6,
     "top_right": 2.5,
     "bottom_left": 24.3,
     "bottom_right": 7.2
    },
    "center_max_so_far": 1575.3
   },
   {
    "image": "desk_20261122_172527.png",
    "focus": {
     "center": 1286.2,
     "top_left": 59.5,
     "top_right": 2.3,
     "bottom_left": 26.1,
     "bottom_right": 6.8
    },
    "center_max_so_far": 1575.3
   },
   {
    "image": "desk_20261122_172528.png",
    "focus": {
     "center": 1330.4,
     "top_left": 57.8,
     "top_right": 2.2,
     "bottom_left": 23.0,
     "bottom_right": 7.7
    },
    "center_max_so_far": 1575.3
   }
  ],
  "ref_248": "/Users/shimazueiichi/r2r2r-scripts/so101/check_248/desk_opencv1.png 1280x720  center=2.6  top_left=13.0  top_right=3.5  bottom_left=16.9  bottom_right=13.6"
 },
 "s2": {
  "a_joints": {
   "n": 900,
   "errors": 0,
   "follower_ms": {
    "n": 900,
    "median": 1.23,
    "p95": 2.09,
    "max": 5.38,
    "mean": 1.33,
    "std": 0.42
   },
   "leader_ms": {
    "n": 900,
    "median": 1.07,
    "p95": 1.95,
    "max": 4.32,
    "mean": 1.18,
    "std": 0.4
   },
   "both_ms": {
    "n": 900,
    "median": 2.31,
    "p95": 3.86,
    "max": 8.14,
    "mean": 2.51,
    "std": 0.7
   },
   "total_ms": {
    "n": 900,
    "median": 2.31,
    "p95": 3.86,
    "max": 8.14,
    "mean": 2.52,
    "std": 0.7
   },
   "over_33ms": 0
  },
  "b_joints_extras": {
   "n": 450,
   "errors": 0,
   "follower_ms": {
    "n": 450,
    "median": 1.16,
    "p95": 1.68,
    "max": 4.57,
    "mean": 1.24,
    "std": 0.37
   },
   "leader_ms": {
    "n": 450,
    "median": 1.06,
    "p95": 1.85,
    "max": 3.49,
    "mean": 1.16,
    "std": 0.34
   },
   "both_ms": {
    "n": 450,
    "median": 2.23,
    "p95": 3.68,
    "max": 6.15,
    "mean": 2.4,
    "std": 0.57
   },
   "total_ms": {
    "n": 450,
    "median": 6.29,
    "p95": 10.01,
    "max": 14.92,
    "mean": 6.75,
    "std": 1.33
   },
   "over_33ms": 0,
   "Present_Current_ms": {
    "n": 450,
    "median": 1.05,
    "p95": 1.47,
    "max": 3.36,
    "mean": 1.11,
    "std": 0.28
   },
   "Present_Current_sample": "{\"shoulder_pan\": 0, \"shoulder_lift\": 1, \"elbow_flex\": 0, \"wrist_flex\": 0, \"wrist_roll\": 0, \"gripper\": 0}",
   "Present_Load_ms": {
    "n": 450,
    "median": 1.04,
    "p95": 1.69,
    "max": 3.67,
    "mean": 1.12,
    "std": 0.33
   },
   "Present_Load_sample": "{\"shoulder_pan\": 0, \"shoulder_lift\": 0, \"elbow_flex\": 0, \"wrist_flex\": 0, \"wrist_roll\": 0, \"gripper\": 0}",
   "Present_Temperature_ms": {
    "n": 450,
    "median": 0.98,
    "p95": 1.54,
    "max": 3.13,
    "mean": 1.05,
    "std": 0.3
   },
   "Present_Temperature_sample": "{\"shoulder_pan\": 26, \"shoulder_lift\": 25, \"elbow_flex\": 25, \"wrist_flex\": 26, \"wrist_roll\": 26, \"gripper\": 28}",
   "Present_Voltage_ms": {
    "n": 450,
    "median": 0.98,
    "p95": 1.54,
    "max": 4.14,
    "mean": 1.06,
    "std": 0.37
   },
   "Present_Voltage_sample": "{\"shoulder_pan\": 118, \"shoulder_lift\": 118, \"elbow_flex\": 118, \"wrist_flex\": 119, \"wrist_roll\": 119, \"gripper\": 119}"
  },
  "e_joints": {
   "n": 900,
   "errors": 0,
   "follower_ms": {
    "n": 900,
    "median": 1.13,
    "p95": 1.59,
    "max": 10.17,
    "mean": 1.21,
    "std": 0.38
   },
   "leader_ms": {
    "n": 900,
    "median": 1.05,
    "p95": 1.3,
    "max": 4.63,
    "mean": 1.1,
    "std": 0.24
   },
   "both_ms": {
    "n": 900,
    "median": 2.19,
    "p95": 2.96,
    "max": 14.8,
    "mean": 2.31,
    "std": 0.56
   },
   "total_ms": {
    "n": 900,
    "median": 6.23,
    "p95": 8.41,
    "max": 36.88,
    "mean": 6.58,
    "std": 1.83
   },
   "over_33ms": 2,
   "Present_Current_ms": {
    "n": 900,
    "median": 1.03,
    "p95": 1.34,
    "max": 3.55,
    "mean": 1.08,
    "std": 0.23
   },
   "Present_Current_sample": "{\"shoulder_pan\": 0, \"shoulder_lift\": 0, \"elbow_flex\": 0, \"wrist_flex\": 0, \"wrist_roll\": 0, \"gripper\": 0}",
   "Present_Load_ms": {
    "n": 900,
    "median": 1.02,
    "p95": 1.51,
    "max": 15.6,
    "mean": 1.11,
    "std": 0.58
   },
   "Present_Load_sample": "{\"shoulder_pan\": 0, \"shoulder_lift\": 0, \"elbow_flex\": 0, \"wrist_flex\": 0, \"wrist_roll\": 0, \"gripper\": 0}",
   "Present_Temperature_ms": {
    "n": 900,
    "median": 0.96,
    "p95": 1.37,
    "max": 21.65,
    "mean": 1.04,
    "std": 0.73
   },
   "Present_Temperature_sample": "{\"shoulder_pan\": 26, \"shoulder_lift\": 26, \"elbow_flex\": 25, \"wrist_flex\": 26, \"wrist_roll\": 26, \"gripper\": 28}",
   "Present_Voltage_ms": {
    "n": 900,
    "median": 0.96,
    "p95": 1.32,
    "max": 15.95,
    "mean": 1.04,
    "std": 0.58
   },
   "Present_Voltage_sample": "{\"shoulder_pan\": 118, \"shoulder_lift\": 118, \"elbow_flex\": 118, \"wrist_flex\": 119, \"wrist_roll\": 119, \"gripper\": 119}"
  },
  "c_cam_1280x720_pair": {
   "wrist_minus_desk_nearest_ms": {
    "n": 915,
    "median": 1.72,
    "p95": 3.92,
    "max": 427.92,
    "mean": 5.65,
    "std": 33.8
   },
   "after_first_1s": {
    "n": 871,
    "median": 1.71,
    "p95": 3.67,
    "max": 31.07,
    "mean": 1.99,
    "std": 2.09
   }
  },
  "c_cam_1280x720_wrist": {
   "frames": 915,
   "read_fail": 0,
   "fps": 30.04,
   "interval_ms": {
    "n": 914,
    "median": 32.99,
    "p95": 35.47,
    "max": 65.94,
    "mean": 33.29,
    "std": 3.55
   },
   "interval_over_50ms": 9,
   "drops_est": 9,
   "after_first_1s": {
    "fps": 30.03,
    "interval_ms": {
     "n": 883,
     "median": 32.99,
     "p95": 35.38,
     "max": 65.94,
     "mean": 33.3,
     "std": 3.35
    },
    "interval_over_50ms": 8,
    "drops_est": 8
   },
   "pos_msec_varies": false,
   "pos_msec_interval_ms": null,
   "resolution": [
    1280,
    720
   ],
   "blur_center": {
    "n": 915,
    "median": 51.87,
    "p95": 53.24,
    "max": 56.74,
    "mean": 51.9,
    "std": 0.9
   },
   "props": {
    "CAP_PROP_FRAME_WIDTH": 1280.0,
    "CAP_PROP_FRAME_HEIGHT": 720.0,
    "CAP_PROP_FPS": 30.00003,
    "CAP_PROP_FOURCC": "0.0",
    "CAP_PROP_AUTO_EXPOSURE": 0.0,
    "CAP_PROP_EXPOSURE": 0.0,
    "CAP_PROP_AUTO_WB": 0.0,
    "CAP_PROP_WB_TEMPERATURE": 0.0,
    "CAP_PROP_GAIN": 0.0,
    "CAP_PROP_BRIGHTNESS": 0.0,
    "CAP_PROP_CONTRAST": 0.0,
    "CAP_PROP_SATURATION": 0.0,
    "CAP_PROP_AUTOFOCUS": 0.0,
    "CAP_PROP_FOCUS": 0.0
   }
  },
  "c_cam_1280x720_desk": {
   "frames": 905,
   "read_fail": 0,
   "fps": 30.14,
   "interval_ms": {
    "n": 904,
    "median": 33.01,
    "p95": 35.24,
    "max": 66.29,
    "mean": 33.18,
    "std": 2.69
   },
   "interval_over_50ms": 5,
   "drops_est": 5,
   "after_first_1s": {
    "fps": 30.17,
    "interval_ms": {
     "n": 874,
     "median": 33.0,
     "p95": 35.14,
     "max": 66.29,
     "mean": 33.15,
     "std": 2.51
    },
    "interval_over_50ms": 4,
    "drops_est": 4
   },
   "pos_msec_varies": false,
   "pos_msec_interval_ms": null,
   "resolution": [
    1280,
    720
   ],
   "blur_center": {
    "n": 905,
    "median": 487.54,
    "p95": 498.65,
    "max": 507.38,
    "mean": 487.46,
    "std": 6.71
   },
   "props": {
    "CAP_PROP_FRAME_WIDTH": 1280.0,
    "CAP_PROP_FRAME_HEIGHT": 720.0,
    "CAP_PROP_FPS": 30.00003,
    "CAP_PROP_FOURCC": "0.0",
    "CAP_PROP_AUTO_EXPOSURE": 0.0,
    "CAP_PROP_EXPOSURE": 0.0,
    "CAP_PROP_AUTO_WB": 0.0,
    "CAP_PROP_WB_TEMPERATURE": 0.0,
    "CAP_PROP_GAIN": 0.0,
    "CAP_PROP_BRIGHTNESS": 0.0,
    "CAP_PROP_CONTRAST": 0.0,
    "CAP_PROP_SATURATION": 0.0,
    "CAP_PROP_AUTOFOCUS": 0.0,
    "CAP_PROP_FOCUS": 0.0
   }
  },
  "d_cam_640x480_pair": {
   "wrist_minus_desk_nearest_ms": {
    "n": 927,
    "median": 7.58,
    "p95": 10.3,
    "max": 1027.36,
    "mean": 18.1,
    "std": 71.78
   },
   "after_first_1s": {
    "n": 870,
    "median": 7.54,
    "p95": 9.53,
    "max": 31.03,
    "mean": 7.57,
    "std": 2.04
   }
  },
  "d_cam_640x480_wrist": {
   "frames": 927,
   "read_fail": 0,
   "fps": 29.86,
   "interval_ms": {
    "n": 926,
    "median": 33.05,
    "p95": 36.34,
    "max": 532.15,
    "mean": 33.49,
    "std": 17.19
   },
   "interval_over_50ms": 11,
   "drops_est": 25,
   "after_first_1s": {
    "fps": 30.0,
    "interval_ms": {
     "n": 900,
     "median": 33.08,
     "p95": 36.28,
     "max": 65.73,
     "mean": 33.33,
     "std": 3.71
    },
    "interval_over_50ms": 9,
    "drops_est": 9
   },
   "pos_msec_varies": false,
   "pos_msec_interval_ms": null,
   "resolution": [
    640,
    480
   ],
   "blur_center": {
    "n": 927,
    "median": 135.36,
    "p95": 138.74,
    "max": 141.21,
    "mean": 135.25,
    "std": 2.2
   },
   "props": {
    "CAP_PROP_FRAME_WIDTH": 640.0,
    "CAP_PROP_FRAME_HEIGHT": 480.0,
    "CAP_PROP_FPS": 30.00003,
    "CAP_PROP_FOURCC": "0.0",
    "CAP_PROP_AUTO_EXPOSURE": 0.0,
    "CAP_PROP_EXPOSURE": 0.0,
    "CAP_PROP_AUTO_WB": 0.0,
    "CAP_PROP_WB_TEMPERATURE": 0.0,
    "CAP_PROP_GAIN": 0.0,
    "CAP_PROP_BRIGHTNESS": 0.0,
    "CAP_PROP_CONTRAST": 0.0,
    "CAP_PROP_SATURATION": 0.0,
    "CAP_PROP_AUTOFOCUS": 0.0,
    "CAP_PROP_FOCUS": 0.0
   }
  },
  "d_cam_640x480_desk": {
   "frames": 905,
   "read_fail": 0,
   "fps": 30.09,
   "interval_ms": {
    "n": 904,
    "median": 33.06,
    "p95": 35.51,
    "max": 84.33,
    "mean": 33.23,
    "std": 3.42
   },
   "interval_over_50ms": 6,
   "drops_est": 7,
   "after_first_1s": {
    "fps": 30.11,
    "interval_ms": {
     "n": 874,
     "median": 33.06,
     "p95": 35.51,
     "max": 84.33,
     "mean": 33.21,
     "std": 3.31
    },
    "interval_over_50ms": 5,
    "drops_est": 6
   },
   "pos_msec_varies": false,
   "pos_msec_interval_ms": null,
   "resolution": [
    640,
    480
   ],
   "blur_center": {
    "n": 905,
    "median": 1060.44,
    "p95": 1109.53,
    "max": 1186.14,
    "mean": 1062.7,
    "std": 23.6
   },
   "props": {
    "CAP_PROP_FRAME_WIDTH": 640.0,
    "CAP_PROP_FRAME_HEIGHT": 480.0,
    "CAP_PROP_FPS": 30.00003,
    "CAP_PROP_FOURCC": "0.0",
    "CAP_PROP_AUTO_EXPOSURE": 0.0,
    "CAP_PROP_EXPOSURE": 0.0,
    "CAP_PROP_AUTO_WB": 0.0,
    "CAP_PROP_WB_TEMPERATURE": 0.0,
    "CAP_PROP_GAIN": 0.0,
    "CAP_PROP_BRIGHTNESS": 0.0,
    "CAP_PROP_CONTRAST": 0.0,
    "CAP_PROP_SATURATION": 0.0,
    "CAP_PROP_AUTOFOCUS": 0.0,
    "CAP_PROP_FOCUS": 0.0
   }
  },
  "e_cam_pair": {
   "wrist_minus_desk_nearest_ms": {
    "n": 957,
    "median": 15.53,
    "p95": 17.17,
    "max": 976.86,
    "mean": 24.97,
    "std": 67.41
   },
   "after_first_1s": {
    "n": 901,
    "median": 15.49,
    "p95": 16.91,
    "max": 133.71,
    "mean": 15.46,
    "std": 4.14
   }
  },
  "e_cam_wrist": {
   "frames": 957,
   "read_fail": 0,
   "fps": 29.79,
   "interval_ms": {
    "n": 956,
    "median": 33.03,
    "p95": 35.05,
    "max": 509.27,
    "mean": 33.57,
    "std": 16.55
   },
   "interval_over_50ms": 11,
   "drops_est": 27,
   "after_first_1s": {
    "fps": 29.9,
    "interval_ms": {
     "n": 929,
     "median": 33.05,
     "p95": 35.05,
     "max": 150.38,
     "mean": 33.44,
     "std": 5.1
    },
    "interval_over_50ms": 10,
    "drops_est": 13
   },
   "pos_msec_varies": false,
   "pos_msec_interval_ms": null,
   "resolution": [
    640,
    480
   ],
   "blur_center": {
    "n": 957,
    "median": 136.24,
    "p95": 139.06,
    "max": 142.19,
    "mean": 136.22,
    "std": 1.72
   },
   "props": {
    "CAP_PROP_FRAME_WIDTH": 640.0,
    "CAP_PROP_FRAME_HEIGHT": 480.0,
    "CAP_PROP_FPS": 30.00003,
    "CAP_PROP_FOURCC": "0.0",
    "CAP_PROP_AUTO_EXPOSURE": 0.0,
    "CAP_PROP_EXPOSURE": 0.0,
    "CAP_PROP_AUTO_WB": 0.0,
    "CAP_PROP_WB_TEMPERATURE": 0.0,
    "CAP_PROP_GAIN": 0.0,
    "CAP_PROP_BRIGHTNESS": 0.0,
    "CAP_PROP_CONTRAST": 0.0,
    "CAP_PROP_SATURATION": 0.0,
    "CAP_PROP_AUTOFOCUS": 0.0,
    "CAP_PROP_FOCUS": 0.0
   }
  },
  "e_cam_desk": {
   "frames": 935,
   "read_fail": 0,
   "fps": 30.15,
   "interval_ms": {
    "n": 934,
    "median": 33.03,
    "p95": 34.91,
    "max": 68.39,
    "mean": 33.17,
    "std": 2.78
   },
   "interval_over_50ms": 6,
   "drops_est": 6,
   "after_first_1s": {
    "fps": 30.17,
    "interval_ms": {
     "n": 904,
     "median": 33.03,
     "p95": 34.87,
     "max": 68.39,
     "mean": 33.14,
     "std": 2.62
    },
    "interval_over_50ms": 5,
    "drops_est": 5
   },
   "pos_msec_varies": false,
   "pos_msec_interval_ms": null,
   "resolution": [
    640,
    480
   ],
   "blur_center": {
    "n": 935,
    "median": 1053.67,
    "p95": 1082.3,
    "max": 1143.38,
    "mean": 1054.56,
    "std": 17.0
   },
   "props": {
    "CAP_PROP_FRAME_WIDTH": 640.0,
    "CAP_PROP_FRAME_HEIGHT": 480.0,
    "CAP_PROP_FPS": 30.00003,
    "CAP_PROP_FOURCC": "0.0",
    "CAP_PROP_AUTO_EXPOSURE": 0.0,
    "CAP_PROP_EXPOSURE": 0.0,
    "CAP_PROP_AUTO_WB": 0.0,
    "CAP_PROP_WB_TEMPERATURE": 0.0,
    "CAP_PROP_GAIN": 0.0,
    "CAP_PROP_BRIGHTNESS": 0.0,
    "CAP_PROP_CONTRAST": 0.0,
    "CAP_PROP_SATURATION": 0.0,
    "CAP_PROP_AUTOFOCUS": 0.0,
    "CAP_PROP_FOCUS": 0.0
   }
  }
 },
 "s34": {
  "loops": 5607,
  "loop_interval_ms": {
   "n": 5606,
   "median": 33.29,
   "p95": 37.18,
   "max": 63.08,
   "mean": 33.34,
   "std": 2.11
  },
  "loop_work_ms": {
   "n": 5607,
   "median": 5.48,
   "p95": 7.03,
   "max": 62.99,
   "mean": 5.69,
   "std": 0.96
  },
  "leader_read_ms": {
   "n": 5607,
   "median": 1.12,
   "p95": 1.66,
   "max": 17.26,
   "mean": 1.18,
   "std": 0.3
  },
  "send_ms": {
   "n": 5607,
   "median": 0.05,
   "p95": 0.34,
   "max": 1.89,
   "mean": 0.08,
   "std": 0.16
  },
  "follower_pos_read_ms": {
   "n": 5607,
   "median": 1.27,
   "p95": 1.63,
   "max": 4.22,
   "mean": 1.3,
   "std": 0.16
  },
  "extra_reads_ms": {
   "n": 5607,
   "median": 3.01,
   "p95": 3.87,
   "max": 43.96,
   "mean": 3.12,
   "std": 0.64
  },
  "grip_events": [
   {
    "event": 1,
    "leader_gripper_max_in_window": 0.8,
    "leader_action": null,
    "follower_state": null,
    "wrist_cam": null,
    "desk_cam": null
   },
   {
    "event": 2,
    "leader_gripper_max_in_window": 100.0,
    "leader_action": 91278.0681,
    "follower_state": 91278.2036,
    "wrist_cam": 91277.9853,
    "desk_cam": 91277.7698
   },
   {
    "event": 3,
    "leader_gripper_max_in_window": 100.0,
    "leader_action": 91282.0673,
    "follower_state": 91282.1694,
    "wrist_cam": 91282.178,
    "desk_cam": 91282.1911
   },
   {
    "event": 4,
    "leader_gripper_max_in_window": 100.0,
    "leader_action": 91287.034,
    "follower_state": 91287.1361,
    "wrist_cam": 91287.1261,
    "desk_cam": 91287.077
   },
   {
    "event": 5,
    "leader_gripper_max_in_window": 100.0,
    "leader_action": 91292.3341,
    "follower_state": 91292.4345,
    "wrist_cam": 91292.4084,
    "desk_cam": 91292.2898
   }
  ],
  "grip_lag": {
   "follower_state_minus_leader_action_ms_per_event": [
    null,
    136,
    102,
    102,
    100
   ],
   "wrist_cam_minus_leader_action_ms_per_event": [
    null,
    -83,
    111,
    92,
    74
   ],
   "desk_cam_minus_leader_action_ms_per_event": [
    null,
    -298,
    124,
    43,
    -44
   ],
   "wrist_cam_minus_follower_state_ms_per_event": [
    null,
    -218,
    9,
    -10,
    -26
   ],
   "desk_cam_minus_follower_state_ms_per_event": [
    null,
    -434,
    22,
    -59,
    -145
   ],
   "wrist_cam_minus_desk_cam_ms_per_event": [
    null,
    215,
    -13,
    49,
    119
   ]
  },
  "follower_lag_xcorr": {
   "shoulder_pan": {
    "lag_ms": 130,
    "corr": 0.993
   },
   "shoulder_lift": {
    "lag_ms": 110,
    "corr": 0.992
   },
   "elbow_flex": {
    "lag_ms": 105,
    "corr": 0.98
   },
   "wrist_flex": {
    "lag_ms": 105,
    "corr": 0.989
   },
   "wrist_roll": {
    "lag_ms": 100,
    "corr": 0.972
   },
   "gripper": {
    "lag_ms": 170,
    "corr": 0.855
   }
  },
  "speed_segments": {
   "slow": {
    "seconds": 15.0,
    "joints": {
     "shoulder_pan": {
      "max_speed_deg_s": 105.5,
      "peak_speed_deg_s": 113.1,
      "servo_velocity_raw_max": 1300,
      "servo_velocity_deg_s_max": 114.3,
      "max_leader_diff_deg": 14.4,
      "p95_leader_diff_deg": 9.3,
      "far_runs_s": [
       0.57
      ],
      "current_raw_max": 9,
      "current_mA_max": 58,
      "load_raw_max": 424,
      "load_pct_max": 42.4,
      "temp_start_end": [
       27.0,
       28.0
      ]
     },
     "shoulder_lift": {
      "max_speed_deg_s": 85.6,
      "peak_speed_deg_s": 87.9,
      "servo_velocity_raw_max": 1000,
      "servo_velocity_deg_s_max": 87.9,
      "max_leader_diff_deg": 11.4,
      "p95_leader_diff_deg": 9.6,
      "far_runs_s": [
       0.47
      ],
      "current_raw_max": 51,
      "current_mA_max": 332,
      "load_raw_max": 416,
      "load_pct_max": 41.6,
      "temp_start_end": [
       27.0,
       27.0
      ]
     },
     "elbow_flex": {
      "max_speed_deg_s": 111.3,
      "peak_speed_deg_s": 116.0,
      "servo_velocity_raw_max": 1300,
      "servo_velocity_deg_s_max": 114.3,
      "max_leader_diff_deg": 16.5,
      "p95_leader_diff_deg": 9.5,
      "far_runs_s": [
       0.67
      ],
      "current_raw_max": 38,
      "current_mA_max": 247,
      "load_raw_max": 520,
      "load_pct_max": 52.0,
      "temp_start_end": [
       26.0,
       26.0
      ]
     },
     "wrist_flex": {
      "max_speed_deg_s": 107.0,
      "peak_speed_deg_s": 117.2,
      "servo_velocity_raw_max": 1350,
      "servo_velocity_deg_s_max": 118.7,
      "max_leader_diff_deg": 14.2,
      "p95_leader_diff_deg": 12.1,
      "far_runs_s": [
       0.3,
       0.44,
       0.2,
       0.46,
       0.13
      ],
      "current_raw_max": 14,
      "current_mA_max": 91,
      "load_raw_max": 420,
      "load_pct_max": 42.0,
      "temp_start_end": [
       28.0,
       28.0
      ]
     },
     "wrist_roll": {
      "max_speed_deg_s": 9.6,
      "peak_speed_deg_s": 37.1,
      "servo_velocity_raw_max": 400,
      "servo_velocity_deg_s_max": 35.2,
      "max_leader_diff_deg": 3.6,
      "p95_leader_diff_deg": 0.5,
      "far_runs_s": [],
      "current_raw_max": 2,
      "current_mA_max": 13,
      "load_raw_max": 152,
      "load_pct_max": 15.2,
      "temp_start_end": [
       28.0,
       28.0
      ]
     },
     "gripper": {
      "max_speed_%_s": 0.0,
      "peak_speed_%_s": 0.0,
      "servo_velocity_raw_max": 0,
      "servo_velocity_deg_s_max": 0.0,
      "max_leader_diff_%": 0.1,
      "p95_leader_diff_%": 0.1,
      "far_runs_s": [],
      "current_raw_max": 2,
      "current_mA_max": 13,
      "load_raw_max": 24,
      "load_pct_max": 2.4,
      "temp_start_end": [
       30.0,
       30.0
      ]
     }
    },
    "wrist_blur": {
     "n": 450,
     "median": 67.48,
     "p95": 212.11,
     "max": 296.03,
     "mean": 81.1,
     "std": 64.35
    },
    "desk_blur": {
     "n": 452,
     "median": 11.14,
     "p95": 935.5,
     "max": 1094.84,
     "mean": 232.86,
     "std": 336.67
    }
   },
   "normal": {
    "seconds": 15.0,
    "joints": {
     "shoulder_pan": {
      "max_speed_deg_s": 101.4,
      "peak_speed_deg_s": 111.1,
      "servo_velocity_raw_max": 1250,
      "servo_velocity_deg_s_max": 109.9,
      "max_leader_diff_deg": 13.7,
      "p95_leader_diff_deg": 10.8,
      "far_runs_s": [
       0.8,
       0.36
      ],
      "current_raw_max": 11,
      "current_mA_max": 72,
      "load_raw_max": 412,
      "load_pct_max": 41.2,
      "temp_start_end": [
       28.0,
       28.0
      ]
     },
     "shoulder_lift": {
      "max_speed_deg_s": 114.0,
      "peak_speed_deg_s": 121.7,
      "servo_velocity_raw_max": 1350,
      "servo_velocity_deg_s_max": 118.7,
      "max_leader_diff_deg": 16.1,
      "p95_leader_diff_deg": 11.1,
      "far_runs_s": [
       0.97,
       0.3
      ],
      "current_raw_max": 35,
      "current_mA_max": 228,
      "load_raw_max": 492,
      "load_pct_max": 49.2,
      "temp_start_end": [
       27.0,
       28.0
      ]
     },
     "elbow_flex": {
      "max_speed_deg_s": 121.0,
      "peak_speed_deg_s": 126.4,
      "servo_velocity_raw_max": 1450,
      "servo_velocity_deg_s_max": 127.4,
      "max_leader_diff_deg": 17.9,
      "p95_leader_diff_deg": 13.1,
      "far_runs_s": [
       0.7,
       0.53
      ],
      "current_raw_max": 38,
      "current_mA_max": 247,
      "load_raw_max": 544,
      "load_pct_max": 54.4,
      "temp_start_end": [
       26.0,
       28.0
      ]
     },
     "wrist_flex": {
      "max_speed_deg_s": 153.6,
      "peak_speed_deg_s": 159.2,
      "servo_velocity_raw_max": 1800,
      "servo_velocity_deg_s_max": 158.2,
      "max_leader_diff_deg": 21.1,
      "p95_leader_diff_deg": 16.7,
      "far_runs_s": [
       0.53,
       0.6,
       0.4,
       0.8
      ],
      "current_raw_max": 20,
      "current_mA_max": 130,
      "load_raw_max": 560,
      "load_pct_max": 56.0,
      "temp_start_end": [
       28.0,
       29.0
      ]
     },
     "wrist_roll": {
      "max_speed_deg_s": 0.0,
      "peak_speed_deg_s": 2.7,
      "servo_velocity_raw_max": 50,
      "servo_velocity_deg_s_max": 4.4,
      "max_leader_diff_deg": 0.4,
      "p95_leader_diff_deg": 0.4,
      "far_runs_s": [],
      "current_raw_max": 1,
      "current_mA_max": 6,
      "load_raw_max": 36,
      "load_pct_max": 3.6,
      "temp_start_end": [
       28.0,
       28.0
      ]
     },
     "gripper": {
      "max_speed_%_s": 0.0,
      "peak_speed_%_s": 0.0,
      "servo_velocity_raw_max": 0,
      "servo_velocity_deg_s_max": 0.0,
      "max_leader_diff_%": 0.1,
      "p95_leader_diff_%": 0.1,
      "far_runs_s": [],
      "current_raw_max": 1,
      "current_mA_max": 6,
      "load_raw_max": 24,
      "load_pct_max": 2.4,
      "temp_start_end": [
       30.0,
       30.0
      ]
     }
    },
    "wrist_blur": {
     "n": 451,
     "median": 83.75,
     "p95": 348.49,
     "max": 460.67,
     "mean": 119.58,
     "std": 110.05
    },
    "desk_blur": {
     "n": 452,
     "median": 1.67,
     "p95": 567.01,
     "max": 863.03,
     "mean": 67.67,
     "std": 192.85
    }
   },
   "fast": {
    "seconds": 15.1,
    "joints": {
     "shoulder_pan": {
      "max_speed_deg_s": 203.2,
      "peak_speed_deg_s": 217.2,
      "servo_velocity_raw_max": 2450,
      "servo_velocity_deg_s_max": 215.3,
      "max_leader_diff_deg": 33.1,
      "p95_leader_diff_deg": 23.2,
      "far_runs_s": [
       0.33,
       1.0,
       0.83,
       0.4,
       0.56,
       0.9,
       0.56
      ],
      "current_raw_max": 40,
      "current_mA_max": 260,
      "load_raw_max": 820,
      "load_pct_max": 82.0,
      "temp_start_end": [
       28.0,
       28.0
      ]
     },
     "shoulder_lift": {
      "max_speed_deg_s": 147.0,
      "peak_speed_deg_s": 156.5,
      "servo_velocity_raw_max": 1750,
      "servo_velocity_deg_s_max": 153.8,
      "max_leader_diff_deg": 24.8,
      "p95_leader_diff_deg": 14.4,
      "far_runs_s": [
       1.0
      ],
      "current_raw_max": 86,
      "current_mA_max": 559,
      "load_raw_max": 748,
      "load_pct_max": 74.8,
      "temp_start_end": [
       28.0,
       28.0
      ]
     },
     "elbow_flex": {
      "max_speed_deg_s": 169.8,
      "peak_speed_deg_s": 181.8,
      "servo_velocity_raw_max": 2050,
      "servo_velocity_deg_s_max": 180.2,
      "max_leader_diff_deg": 24.0,
      "p95_leader_diff_deg": 8.3,
      "far_runs_s": [
       0.7
      ],
      "current_raw_max": 20,
      "current_mA_max": 130,
      "load_raw_max": 608,
      "load_pct_max": 60.8,
      "temp_start_end": [
       26.0,
       27.0
      ]
     },
     "wrist_flex": {
      "max_speed_deg_s": 182.8,
      "peak_speed_deg_s": 192.6,
      "servo_velocity_raw_max": 2100,
      "servo_velocity_deg_s_max": 184.6,
      "max_leader_diff_deg": 26.7,
      "p95_leader_diff_deg": 22.8,
      "far_runs_s": [
       0.1,
       0.9,
       0.6,
       0.27,
       0.43,
       0.44,
       0.6,
       0.54,
       0.84
      ],
      "current_raw_max": 33,
      "current_mA_max": 214,
      "load_raw_max": 680,
      "load_pct_max": 68.0,
      "temp_start_end": [
       28.0,
       29.0
      ]
     },
     "wrist_roll": {
      "max_speed_deg_s": 59.8,
      "peak_speed_deg_s": 76.4,
      "servo_velocity_raw_max": 850,
      "servo_velocity_deg_s_max": 74.7,
      "max_leader_diff_deg": 8.7,
      "p95_leader_diff_deg": 4.6,
      "far_runs_s": [],
      "current_raw_max": 6,
      "current_mA_max": 39,
      "load_raw_max": 276,
      "load_pct_max": 27.6,
      "temp_start_end": [
       28.0,
       28.0
      ]
     },
     "gripper": {
      "max_speed_%_s": 0.0,
      "peak_speed_%_s": 0.0,
      "servo_velocity_raw_max": 0,
      "servo_velocity_deg_s_max": 0.0,
      "max_leader_diff_%": 0.1,
      "p95_leader_diff_%": 0.1,
      "far_runs_s": [],
      "current_raw_max": 1,
      "current_mA_max": 6,
      "load_raw_max": 0,
      "load_pct_max": 0.0,
      "temp_start_end": [
       30.0,
       30.0
      ]
     }
    },
    "wrist_blur": {
     "n": 452,
     "median": 83.08,
     "p95": 301.75,
     "max": 457.9,
     "mean": 102.17,
     "std": 93.66
    },
    "desk_blur": {
     "n": 454,
     "median": 1.83,
     "p95": 455.46,
     "max": 835.92,
     "mean": 74.55,
     "std": 154.44
    }
   }
  },
  "blur_by_body_speed": {
   "wrist": [
    {
     "speed_deg_s": "0-10",
     "frames": 3049,
     "blur_median": 89.7
    },
    {
     "speed_deg_s": "10-30",
     "frames": 566,
     "blur_median": 86.3
    },
    {
     "speed_deg_s": "30-60",
     "frames": 745,
     "blur_median": 85.6
    },
    {
     "speed_deg_s": "60-100",
     "frames": 821,
     "blur_median": 90.3
    },
    {
     "speed_deg_s": "100-150",
     "frames": 375,
     "blur_median": 104.7
    },
    {
     "speed_deg_s": "150-200",
     "frames": 97,
     "blur_median": 76.4
    },
    {
     "speed_deg_s": "200-300",
     "frames": 6,
     "blur_median": 95.9
    }
   ],
   "desk": [
    {
     "speed_deg_s": "0-10",
     "frames": 3035,
     "blur_median": 3.8
    },
    {
     "speed_deg_s": "10-30",
     "frames": 569,
     "blur_median": 3.3
    },
    {
     "speed_deg_s": "30-60",
     "frames": 750,
     "blur_median": 3.4
    },
    {
     "speed_deg_s": "60-100",
     "frames": 825,
     "blur_median": 15.5
    },
    {
     "speed_deg_s": "100-150",
     "frames": 377,
     "blur_median": 1.3
    },
    {
     "speed_deg_s": "150-200",
     "frames": 100,
     "blur_median": 1.5
    },
    {
     "speed_deg_s": "200-300",
     "frames": 5,
     "blur_median": 34.0
    }
   ]
  },
  "gripper_vs_wrist_image": {
   "frames": 860,
   "pearson_r_gripper_vs_image_change": 0.423,
   "gripper_range_in_events": [
    1.0,
    98.2
   ]
  }
 },
 "s5": {
  "info": {
   "codebase_version": "v3.0",
   "fps": 30,
   "total_episodes": 3,
   "total_frames": 900,
   "total_tasks": 1,
   "chunks_size": 1000,
   "data_files_size_in_mb": 100,
   "video_files_size_in_mb": 200,
   "data_path": "data/chunk-{chunk_index:03d}/file-{file_index:03d}.parquet",
   "video_path": "videos/{video_key}/chunk-{chunk_index:03d}/file-{file_index:03d}.mp4",
   "robot_type": "so_follower",
   "splits": {
    "train": "0:3"
   }
  },
  "features": {
   "action": {
    "dtype": "float32",
    "names": [
     "shoulder_pan.pos",
     "shoulder_lift.pos",
     "elbow_flex.pos",
     "wrist_flex.pos",
     "wrist_roll.pos",
     "gripper.pos"
    ],
    "shape": [
     6
    ]
   },
   "observation.state": {
    "dtype": "float32",
    "names": [
     "shoulder_pan.pos",
     "shoulder_lift.pos",
     "elbow_flex.pos",
     "wrist_flex.pos",
     "wrist_roll.pos",
     "gripper.pos"
    ],
    "shape": [
     6
    ]
   },
   "observation.images.wrist": {
    "dtype": "video",
    "shape": [
     480,
     640,
     3
    ],
    "names": [
     "height",
     "width",
     "channels"
    ],
    "info": {
     "is_depth_map": false,
     "video.height": 480,
     "video.width": 640,
     "video.codec": "av1",
     "video.pix_fmt": "yuv420p",
     "video.fps": 30,
     "video.channels": 3,
     "has_audio": false,
     "video.g": 2,
     "video.crf": 30,
     "video.preset": 12,
     "video.fast_decode": 0,
     "video.video_backend": "pyav",
     "video.extra_options": {}
    }
   },
   "observation.images.desk": {
    "dtype": "video",
    "shape": [
     480,
     640,
     3
    ],
    "names": [
     "height",
     "width",
     "channels"
    ],
    "info": {
     "is_depth_map": false,
     "video.height": 480,
     "video.width": 640,
     "video.codec": "av1",
     "video.pix_fmt": "yuv420p",
     "video.fps": 30,
     "video.channels": 3,
     "has_audio": false,
     "video.g": 2,
     "video.crf": 30,
     "video.preset": 12,
     "video.fast_decode": 0,
     "video.video_backend": "pyav",
     "video.extra_options": {}
    }
   },
   "timestamp": {
    "dtype": "float32",
    "shape": [
     1
    ],
    "names": null
   },
   "frame_index": {
    "dtype": "int64",
    "shape": [
     1
    ],
    "names": null
   },
   "episode_index": {
    "dtype": "int64",
    "shape": [
     1
    ],
    "names": null
   },
   "index": {
    "dtype": "int64",
    "shape": [
     1
    ],
    "names": null
   },
   "task_index": {
    "dtype": "int64",
    "shape": [
     1
    ],
    "names": null
   }
  },
  "parquet_files": [
   "data/chunk-000/file-000.parquet"
  ],
  "parquet_columns": {
   "action": "object",
   "observation.state": "object",
   "timestamp": "float32",
   "frame_index": "int64",
   "episode_index": "int64",
   "index": "int64",
   "task_index": "int64"
  },
  "parquet_head": [
   {
    "action": "[  -5.7582417 -103.82417     96.13187      4.1318684   -3.6483517\n    1.6447369]",
    "observation.state": "[  -5.4505496 -103.42857     91.07692      4.5274725   -3.2967033\n    1.6260163]",
    "timestamp": "0.0",
    "frame_index": "0",
    "episode_index": "0",
    "index": "0",
    "task_index": "0"
   },
   {
    "action": "[  -5.7582417 -103.82417     96.13187      4.1318684   -3.6483517\n    1.6447369]",
    "observation.state": "[  -5.4505496 -103.42857     91.07692      4.5274725   -3.2967033\n    1.6260163]",
    "timestamp": "0.033333335",
    "frame_index": "1",
    "episode_index": "0",
    "index": "1",
    "task_index": "0"
   },
   {
    "action": "[  -5.7582417 -103.82417     96.13187      4.1318684   -3.6483517\n    1.6447369]",
    "observation.state": "[  -5.4505496 -103.42857     91.07692      4.5274725   -3.2967033\n    1.6260163]",
    "timestamp": "0.06666667",
    "frame_index": "2",
    "episode_index": "0",
    "index": "2",
    "task_index": "0"
   }
  ],
  "episodes": {
   "0": {
    "frames": 300,
    "timestamp_first_last": [
     0.0,
     9.966666221618652
    ],
    "timestamp_step": {
     "n": 299,
     "median": 33.33,
     "p95": 33.33,
     "max": 33.33,
     "mean": 33.33,
     "std": 0.0
    },
    "timestamp_equals_index_over_fps": true
   },
   "1": {
    "frames": 300,
    "timestamp_first_last": [
     0.0,
     9.966666221618652
    ],
    "timestamp_step": {
     "n": 299,
     "median": 33.33,
     "p95": 33.33,
     "max": 33.33,
     "mean": 33.33,
     "std": 0.0
    },
    "timestamp_equals_index_over_fps": true
   },
   "2": {
    "frames": 300,
    "timestamp_first_last": [
     0.0,
     9.966666221618652
    ],
    "timestamp_step": {
     "n": 299,
     "median": 33.33,
     "p95": 33.33,
     "max": 33.33,
     "mean": 33.33,
     "std": 0.0
    },
    "timestamp_equals_index_over_fps": true
   }
  },
  "videos": [
   {
    "codec_name": "av1",
    "width": 640,
    "height": 480,
    "pix_fmt": "yuv420p",
    "r_frame_rate": "30/1",
    "avg_frame_rate": "30/1",
    "duration": "30.000000",
    "nb_read_frames": "900",
    "file": "videos/observation.images.desk/chunk-000/file-000.mp4",
    "MB": 2.84
   },
   {
    "codec_name": "av1",
    "width": 640,
    "height": 480,
    "pix_fmt": "yuv420p",
    "r_frame_rate": "30/1",
    "avg_frame_rate": "30/1",
    "duration": "30.000000",
    "nb_read_frames": "900",
    "file": "videos/observation.images.wrist/chunk-000/file-000.mp4",
    "MB": 3.85
   }
  ],
  "size": {
   "total_MB": 6.8,
   "seconds": 30.0,
   "MB_per_s": 0.227,
   "video_MB": 6.69,
   "parquet_MB": 0.035,
   "estimate_MB": {
    "10s": {
     "1": 2.3,
     "100": 227,
     "1000": 2270
    },
    "20s": {
     "1": 4.5,
     "100": 454,
     "1000": 4540
    },
    "30s": {
     "1": 6.8,
     "100": 681,
     "1000": 6810
    },
    "60s": {
     "1": 13.6,
     "100": 1362,
     "1000": 13620
    }
   }
  }
 },
 "s6": {
  "frames": 300,
  "joints": {
   "shoulder_pan": {
    "replay1_vs_record_mean": 0.02,
    "replay1_vs_record_max": 0.26,
    "replay2_vs_record_mean": 0.19,
    "replay2_vs_record_max": 6.77,
    "replay1_vs_replay2_mean": 0.2,
    "replay1_vs_replay2_max": 6.86,
    "final_rec_r1_r2": [
     9.49,
     9.41,
     9.58
    ],
    "record_action_vs_state_max": 7.52
   },
   "shoulder_lift": {
    "replay1_vs_record_mean": 0.99,
    "replay1_vs_record_max": 35.52,
    "replay2_vs_record_mean": 0.3,
    "replay2_vs_record_max": 1.14,
    "replay1_vs_replay2_mean": 1.21,
    "replay1_vs_replay2_max": 36.57,
    "final_rec_r1_r2": [
     89.71,
     89.71,
     89.71
    ],
    "record_action_vs_state_max": 14.73
   },
   "elbow_flex": {
    "replay1_vs_record_mean": 1.16,
    "replay1_vs_record_max": 41.76,
    "replay2_vs_record_mean": 0.19,
    "replay2_vs_record_max": 0.35,
    "replay1_vs_replay2_mean": 1.25,
    "replay1_vs_replay2_max": 42.11,
    "final_rec_r1_r2": [
     -88.18,
     -88.09,
     -88.09
    ],
    "record_action_vs_state_max": 11.91
   },
   "wrist_flex": {
    "replay1_vs_record_mean": 0.06,
    "replay1_vs_record_max": 0.97,
    "replay2_vs_record_mean": 0.3,
    "replay2_vs_record_max": 6.86,
    "replay1_vs_replay2_mean": 0.29,
    "replay1_vs_replay2_max": 6.07,
    "final_rec_r1_r2": [
     18.59,
     18.59,
     18.59
    ],
    "record_action_vs_state_max": 10.77
   },
   "wrist_roll": {
    "replay1_vs_record_mean": 0.17,
    "replay1_vs_record_max": 4.84,
    "replay2_vs_record_mean": 0.1,
    "replay2_vs_record_max": 2.99,
    "replay1_vs_replay2_mean": 0.07,
    "replay1_vs_replay2_max": 2.29,
    "final_rec_r1_r2": [
     3.3,
     3.38,
     3.38
    ],
    "record_action_vs_state_max": 9.05
   },
   "gripper": {
    "replay1_vs_record_mean": 0.0,
    "replay1_vs_record_max": 0.0,
    "replay2_vs_record_mean": 0.07,
    "replay2_vs_record_max": 0.07,
    "replay1_vs_replay2_mean": 0.07,
    "replay1_vs_replay2_max": 0.07,
    "final_rec_r1_r2": [
     1.63,
     1.63,
     1.56
    ],
    "record_action_vs_state_max": 0.06
   }
  }
 },
 "calibration": {
  "follower": {
   "resolution": 4096,
   "motors": {
    "shoulder_pan": {
     "file": {
      "id": 1,
      "drive_mode": 0,
      "homing_offset": 1668,
      "range_min": 710,
      "range_max": 3326
     },
     "servo": {
      "Homing_Offset": 1668,
      "Min_Position_Limit": 710,
      "Max_Position_Limit": 3326
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      2027,
      2027
     ],
     "lerobot_value": 0.791,
     "formula_value": 0.791,
     "diff": 0.0,
     "unit": "deg",
     "step": 0.0879,
     "range_deg": 230.0
    },
    "shoulder_lift": {
     "file": {
      "id": 2,
      "drive_mode": 0,
      "homing_offset": 1393,
      "range_min": 846,
      "range_max": 3227
     },
     "servo": {
      "Homing_Offset": 1393,
      "Min_Position_Limit": 846,
      "Max_Position_Limit": 3227
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      926,
      926
     ],
     "lerobot_value": -97.626,
     "formula_value": -97.626,
     "diff": 0.0,
     "unit": "deg",
     "step": 0.0879,
     "range_deg": 209.3
    },
    "elbow_flex": {
     "file": {
      "id": 3,
      "drive_mode": 0,
      "homing_offset": 1743,
      "range_min": 954,
      "range_max": 3022
     },
     "servo": {
      "Homing_Offset": 1743,
      "Min_Position_Limit": 954,
      "Max_Position_Limit": 3022
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      3031,
      3031
     ],
     "lerobot_value": 91.692,
     "formula_value": 91.692,
     "diff": 0.0,
     "unit": "deg",
     "step": 0.0879,
     "range_deg": 181.8
    },
    "wrist_flex": {
     "file": {
      "id": 4,
      "drive_mode": 0,
      "homing_offset": 1477,
      "range_min": 911,
      "range_max": 3210
     },
     "servo": {
      "Homing_Offset": 1477,
      "Min_Position_Limit": 911,
      "Max_Position_Limit": 3210
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      2532,
      2532
     ],
     "lerobot_value": 41.451,
     "formula_value": 41.451,
     "diff": 0.0,
     "unit": "deg",
     "step": 0.0879,
     "range_deg": 202.1
    },
    "wrist_roll": {
     "file": {
      "id": 5,
      "drive_mode": 0,
      "homing_offset": 1276,
      "range_min": 0,
      "range_max": 4095
     },
     "servo": {
      "Homing_Offset": 1276,
      "Min_Position_Limit": 0,
      "Max_Position_Limit": 4095
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      2167,
      2167
     ],
     "lerobot_value": 10.505,
     "formula_value": 10.505,
     "diff": 0.0,
     "unit": "deg",
     "step": 0.0879,
     "range_deg": 360.0
    },
    "gripper": {
     "file": {
      "id": 6,
      "drive_mode": 0,
      "homing_offset": 978,
      "range_min": 2046,
      "range_max": 3522
     },
     "servo": {
      "Homing_Offset": 978,
      "Min_Position_Limit": 2046,
      "Max_Position_Limit": 3522
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      2069,
      2069
     ],
     "lerobot_value": 1.558,
     "formula_value": 1.558,
     "diff": 0.0,
     "unit": "0-100",
     "step": 0.0678,
     "range_raw": 1476
    }
   }
  },
  "leader": {
   "resolution": 4096,
   "motors": {
    "shoulder_pan": {
     "file": {
      "id": 1,
      "drive_mode": 0,
      "homing_offset": -574,
      "range_min": 714,
      "range_max": 3429
     },
     "servo": {
      "Homing_Offset": -574,
      "Min_Position_Limit": 714,
      "Max_Position_Limit": 3429
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      2052,
      2052
     ],
     "lerobot_value": -1.714,
     "formula_value": -1.714,
     "diff": 0.0,
     "unit": "deg",
     "step": 0.0879,
     "range_deg": 238.7
    },
    "shoulder_lift": {
     "file": {
      "id": 2,
      "drive_mode": 0,
      "homing_offset": -1984,
      "range_min": 815,
      "range_max": 3191
     },
     "servo": {
      "Homing_Offset": -1984,
      "Min_Position_Limit": 815,
      "Max_Position_Limit": 3191
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      825,
      825
     ],
     "lerobot_value": -103.56,
     "formula_value": -103.56,
     "diff": 0.0,
     "unit": "deg",
     "step": 0.0879,
     "range_deg": 208.9
    },
    "elbow_flex": {
     "file": {
      "id": 3,
      "drive_mode": 0,
      "homing_offset": 1405,
      "range_min": 921,
      "range_max": 3114
     },
     "servo": {
      "Homing_Offset": 1405,
      "Min_Position_Limit": 921,
      "Max_Position_Limit": 3114
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      3111,
      3111
     ],
     "lerobot_value": 96.132,
     "formula_value": 96.132,
     "diff": 0.0,
     "unit": "deg",
     "step": 0.0879,
     "range_deg": 192.8
    },
    "wrist_flex": {
     "file": {
      "id": 4,
      "drive_mode": 0,
      "homing_offset": -1853,
      "range_min": 908,
      "range_max": 3230
     },
     "servo": {
      "Homing_Offset": -1853,
      "Min_Position_Limit": 908,
      "Max_Position_Limit": 3230
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      2671,
      2671
     ],
     "lerobot_value": 52.923,
     "formula_value": 52.923,
     "diff": 0.0,
     "unit": "deg",
     "step": 0.0879,
     "range_deg": 204.1
    },
    "wrist_roll": {
     "file": {
      "id": 5,
      "drive_mode": 0,
      "homing_offset": -1831,
      "range_min": 0,
      "range_max": 4095
     },
     "servo": {
      "Homing_Offset": -1831,
      "Min_Position_Limit": 0,
      "Max_Position_Limit": 4095
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      2060,
      2060
     ],
     "lerobot_value": 1.099,
     "formula_value": 1.099,
     "diff": 0.0,
     "unit": "deg",
     "step": 0.0879,
     "range_deg": 360.0
    },
    "gripper": {
     "file": {
      "id": 6,
      "drive_mode": 0,
      "homing_offset": 1768,
      "range_min": 1995,
      "range_max": 3211
     },
     "servo": {
      "Homing_Offset": 1768,
      "Min_Position_Limit": 1995,
      "Max_Position_Limit": 3211
     },
     "homing_match": true,
     "limits_match": true,
     "raw": [
      2014,
      2014
     ],
     "lerobot_value": 1.562,
     "formula_value": 1.562,
     "diff": 0.0,
     "unit": "0-100",
     "step": 0.0822,
     "range_raw": 1216
    }
   }
  }
 }
}
```

### キャリブレーションの確かめの結果 calibration_check.json（全量）

```json
{
  "follower": {
    "resolution": 4096,
    "motors": {
      "shoulder_pan": {
        "file": {
          "id": 1,
          "drive_mode": 0,
          "homing_offset": 1668,
          "range_min": 710,
          "range_max": 3326
        },
        "servo": {
          "Homing_Offset": 1668,
          "Min_Position_Limit": 710,
          "Max_Position_Limit": 3326
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          2027,
          2027
        ],
        "lerobot_value": 0.791,
        "formula_value": 0.791,
        "diff": 0.0,
        "unit": "deg",
        "step": 0.0879,
        "range_deg": 230.0
      },
      "shoulder_lift": {
        "file": {
          "id": 2,
          "drive_mode": 0,
          "homing_offset": 1393,
          "range_min": 846,
          "range_max": 3227
        },
        "servo": {
          "Homing_Offset": 1393,
          "Min_Position_Limit": 846,
          "Max_Position_Limit": 3227
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          926,
          926
        ],
        "lerobot_value": -97.626,
        "formula_value": -97.626,
        "diff": 0.0,
        "unit": "deg",
        "step": 0.0879,
        "range_deg": 209.3
      },
      "elbow_flex": {
        "file": {
          "id": 3,
          "drive_mode": 0,
          "homing_offset": 1743,
          "range_min": 954,
          "range_max": 3022
        },
        "servo": {
          "Homing_Offset": 1743,
          "Min_Position_Limit": 954,
          "Max_Position_Limit": 3022
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          3031,
          3031
        ],
        "lerobot_value": 91.692,
        "formula_value": 91.692,
        "diff": 0.0,
        "unit": "deg",
        "step": 0.0879,
        "range_deg": 181.8
      },
      "wrist_flex": {
        "file": {
          "id": 4,
          "drive_mode": 0,
          "homing_offset": 1477,
          "range_min": 911,
          "range_max": 3210
        },
        "servo": {
          "Homing_Offset": 1477,
          "Min_Position_Limit": 911,
          "Max_Position_Limit": 3210
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          2532,
          2532
        ],
        "lerobot_value": 41.451,
        "formula_value": 41.451,
        "diff": 0.0,
        "unit": "deg",
        "step": 0.0879,
        "range_deg": 202.1
      },
      "wrist_roll": {
        "file": {
          "id": 5,
          "drive_mode": 0,
          "homing_offset": 1276,
          "range_min": 0,
          "range_max": 4095
        },
        "servo": {
          "Homing_Offset": 1276,
          "Min_Position_Limit": 0,
          "Max_Position_Limit": 4095
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          2167,
          2167
        ],
        "lerobot_value": 10.505,
        "formula_value": 10.505,
        "diff": 0.0,
        "unit": "deg",
        "step": 0.0879,
        "range_deg": 360.0
      },
      "gripper": {
        "file": {
          "id": 6,
          "drive_mode": 0,
          "homing_offset": 978,
          "range_min": 2046,
          "range_max": 3522
        },
        "servo": {
          "Homing_Offset": 978,
          "Min_Position_Limit": 2046,
          "Max_Position_Limit": 3522
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          2069,
          2069
        ],
        "lerobot_value": 1.558,
        "formula_value": 1.558,
        "diff": 0.0,
        "unit": "0-100",
        "step": 0.0678,
        "range_raw": 1476
      }
    }
  },
  "leader": {
    "resolution": 4096,
    "motors": {
      "shoulder_pan": {
        "file": {
          "id": 1,
          "drive_mode": 0,
          "homing_offset": -574,
          "range_min": 714,
          "range_max": 3429
        },
        "servo": {
          "Homing_Offset": -574,
          "Min_Position_Limit": 714,
          "Max_Position_Limit": 3429
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          2052,
          2052
        ],
        "lerobot_value": -1.714,
        "formula_value": -1.714,
        "diff": 0.0,
        "unit": "deg",
        "step": 0.0879,
        "range_deg": 238.7
      },
      "shoulder_lift": {
        "file": {
          "id": 2,
          "drive_mode": 0,
          "homing_offset": -1984,
          "range_min": 815,
          "range_max": 3191
        },
        "servo": {
          "Homing_Offset": -1984,
          "Min_Position_Limit": 815,
          "Max_Position_Limit": 3191
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          825,
          825
        ],
        "lerobot_value": -103.56,
        "formula_value": -103.56,
        "diff": 0.0,
        "unit": "deg",
        "step": 0.0879,
        "range_deg": 208.9
      },
      "elbow_flex": {
        "file": {
          "id": 3,
          "drive_mode": 0,
          "homing_offset": 1405,
          "range_min": 921,
          "range_max": 3114
        },
        "servo": {
          "Homing_Offset": 1405,
          "Min_Position_Limit": 921,
          "Max_Position_Limit": 3114
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          3111,
          3111
        ],
        "lerobot_value": 96.132,
        "formula_value": 96.132,
        "diff": 0.0,
        "unit": "deg",
        "step": 0.0879,
        "range_deg": 192.8
      },
      "wrist_flex": {
        "file": {
          "id": 4,
          "drive_mode": 0,
          "homing_offset": -1853,
          "range_min": 908,
          "range_max": 3230
        },
        "servo": {
          "Homing_Offset": -1853,
          "Min_Position_Limit": 908,
          "Max_Position_Limit": 3230
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          2671,
          2671
        ],
        "lerobot_value": 52.923,
        "formula_value": 52.923,
        "diff": 0.0,
        "unit": "deg",
        "step": 0.0879,
        "range_deg": 204.1
      },
      "wrist_roll": {
        "file": {
          "id": 5,
          "drive_mode": 0,
          "homing_offset": -1831,
          "range_min": 0,
          "range_max": 4095
        },
        "servo": {
          "Homing_Offset": -1831,
          "Min_Position_Limit": 0,
          "Max_Position_Limit": 4095
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          2060,
          2060
        ],
        "lerobot_value": 1.099,
        "formula_value": 1.099,
        "diff": 0.0,
        "unit": "deg",
        "step": 0.0879,
        "range_deg": 360.0
      },
      "gripper": {
        "file": {
          "id": 6,
          "drive_mode": 0,
          "homing_offset": 1768,
          "range_min": 1995,
          "range_max": 3211
        },
        "servo": {
          "Homing_Offset": 1768,
          "Min_Position_Limit": 1995,
          "Max_Position_Limit": 3211
        },
        "homing_match": true,
        "limits_match": true,
        "raw": [
          2014,
          2014
        ],
        "lerobot_value": 1.562,
        "formula_value": 1.562,
        "diff": 0.0,
        "unit": "0-100",
        "step": 0.0822,
        "range_raw": 1216
      }
    }
  }
}
```

### 段階0 つながり s0.json（全量）

```json
{
  "servo_counts": {
    "/dev/tty.usbmodem5CBC4321631": 6,
    "/dev/tty.usbmodem5CBC4323581": 6
  },
  "read_servos_stdout": "\n== /dev/tty.usbmodem5CBC4321631\n  サーボ 6 個, 電圧の平均 11.9 V\n  ID  型番  FW    位置  電圧V  温度C  トルク  Lock\n   1  777  3.10   1952   11.8     22       0     1\n   2  777  3.10   1047   11.8     22       0     1\n   3  777  3.10   3031   11.8     21       0     1\n   4  777  3.10   2284   11.9     22       0     1\n   5  777  3.10   2066   11.9     22       0     1\n   6  777  3.10   2061   11.9     24       0     1\n\n== /dev/tty.usbmodem5CBC4323581\n  サーボ 6 個, 電圧の平均 4.9 V\n  ID  型番  FW    位置  電圧V  温度C  トルク  Lock\n   1  777  3.10   1962    4.9     19       0     1\n   2  777  3.10    822    4.9     18       0     1\n   3  777  3.10   3111    4.9     19       0     1\n   4  777  3.10   2686    4.9     18       0     1\n   5  777  3.10   2101    4.9     18       0     1\n   6  777  3.10   2005    4.9     17       0     1\n",
  "cameras": {
    "ffmpeg": [
      [
        0,
        "Iriun Camera"
      ],
      [
        1,
        "FaceTime HDカメラ"
      ],
      [
        2,
        "Innomaker-U20CAM-720P"
      ],
      [
        3,
        "USB HD Camera"
      ],
      [
        4,
        "Capture screen 0"
      ]
    ],
    "opencv": [
      [
        0,
        "Innomaker-U20CAM-720P  "
      ],
      [
        1,
        "USB HD Camera"
      ],
      [
        2,
        "FaceTime HDカメラ"
      ],
      [
        3,
        "Iriun Camera"
      ]
    ],
    "index": {
      "wrist": 1,
      "desk": 0
    },
    "iriun": true
  }
}
```

### 段階0 サーボの読み取り s0_servos.json（全量）

```json
{
  "/dev/tty.usbmodem5CBC4321631": [
    {
      "id": 1,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 1952,
      "Present_Voltage": 118,
      "Present_Temperature": 22,
      "Torque_Enable": 0,
      "Lock": 1
    },
    {
      "id": 2,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 1047,
      "Present_Voltage": 118,
      "Present_Temperature": 22,
      "Torque_Enable": 0,
      "Lock": 1
    },
    {
      "id": 3,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 3031,
      "Present_Voltage": 118,
      "Present_Temperature": 21,
      "Torque_Enable": 0,
      "Lock": 1
    },
    {
      "id": 4,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 2284,
      "Present_Voltage": 119,
      "Present_Temperature": 22,
      "Torque_Enable": 0,
      "Lock": 1
    },
    {
      "id": 5,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 2066,
      "Present_Voltage": 119,
      "Present_Temperature": 22,
      "Torque_Enable": 0,
      "Lock": 1
    },
    {
      "id": 6,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 2061,
      "Present_Voltage": 119,
      "Present_Temperature": 24,
      "Torque_Enable": 0,
      "Lock": 1
    }
  ],
  "/dev/tty.usbmodem5CBC4323581": [
    {
      "id": 1,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 1962,
      "Present_Voltage": 49,
      "Present_Temperature": 19,
      "Torque_Enable": 0,
      "Lock": 1
    },
    {
      "id": 2,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 822,
      "Present_Voltage": 49,
      "Present_Temperature": 18,
      "Torque_Enable": 0,
      "Lock": 1
    },
    {
      "id": 3,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 3111,
      "Present_Voltage": 49,
      "Present_Temperature": 19,
      "Torque_Enable": 0,
      "Lock": 1
    },
    {
      "id": 4,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 2686,
      "Present_Voltage": 49,
      "Present_Temperature": 18,
      "Torque_Enable": 0,
      "Lock": 1
    },
    {
      "id": 5,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 2101,
      "Present_Voltage": 49,
      "Present_Temperature": 18,
      "Torque_Enable": 0,
      "Lock": 1
    },
    {
      "id": 6,
      "model_number_scan": 777,
      "Model_Number": 777,
      "Firmware_Major_Version": 3,
      "Firmware_Minor_Version": 10,
      "Present_Position": 2005,
      "Present_Voltage": 49,
      "Present_Temperature": 17,
      "Torque_Enable": 0,
      "Lock": 1
    }
  ]
}
```

### 段階1 ピント合わせの前の1枚 desk_20261122_171646.json

```json
{
  "image": "desk_20261122_171646.png",
  "opencv_index": 0,
  "shape": [
    720,
    1280,
    3
  ],
  "focus": {
    "center": 1.351562311619888,
    "top_left": 6.271048651801215,
    "top_right": 4.439381104192616,
    "bottom_left": 5.7525487358187455,
    "bottom_right": 5.927598705262314
  },
  "center_max_so_far": 1.5881074946603657
}
```

### 段階1 ピント合わせの最後の1枚 desk_20261122_172528.json

```json
{
  "image": "desk_20261122_172528.png",
  "opencv_index": 0,
  "shape": [
    720,
    1280,
    3
  ],
  "focus": {
    "center": 1330.426684247123,
    "top_left": 57.76244878106647,
    "top_right": 2.197617265177362,
    "bottom_left": 22.96727767917845,
    "bottom_right": 7.701762481236163
  },
  "center_max_so_far": 1575.324957529704
}
```

### 段階1 依頼248 の画像のピントの数値 ref_248_score.txt

```text
/Users/shimazueiichi/r2r2r-scripts/so101/check_248/desk_opencv1.png 1280x720  center=2.6  top_left=13.0  top_right=3.5  bottom_left=16.9  bottom_right=13.6
```

### 段階3・4 テレオペの区切りの時刻 phases.json（全量）

```json
{
  "phases": [
    [
      91214.028653041,
      "free"
    ],
    [
      91268.143170416,
      "grip_pre"
    ],
    [
      91271.186670041,
      "grip_1"
    ],
    [
      91273.253262958,
      "grip_1_rest"
    ],
    [
      91276.292229083,
      "grip_2"
    ],
    [
      91278.375624333,
      "grip_2_rest"
    ],
    [
      91281.432314333,
      "grip_3"
    ],
    [
      91283.509261833,
      "grip_3_rest"
    ],
    [
      91286.553356666,
      "grip_4"
    ],
    [
      91288.621229791,
      "grip_4_rest"
    ],
    [
      91291.680964041,
      "grip_5"
    ],
    [
      91293.763979333,
      "grip_5_rest"
    ],
    [
      91296.803042291,
      "slow_pre"
    ],
    [
      91314.733419583,
      "slow"
    ],
    [
      91329.736349375,
      "normal_pre"
    ],
    [
      91354.961105083,
      "normal"
    ],
    [
      91369.980725333,
      "fast_pre"
    ],
    [
      91374.222217333,
      "fast"
    ],
    [
      91389.287027791,
      "rest"
    ]
  ],
  "error": null
}
```

### 段階5 lerobot-record に渡したコマンド s5_cmd.json

```json
[
  "/opt/homebrew/Caskroom/miniforge/base/envs/lerobot/bin/python",
  "-m",
  "lerobot.scripts.lerobot_record",
  "--robot.type=so101_follower",
  "--robot.port=/dev/tty.usbmodem5CBC4321631",
  "--robot.id=ptm_follower",
  "--robot.cameras={ wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30, fourcc: MJPG}, desk: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: MJPG} }",
  "--teleop.type=so101_leader",
  "--teleop.port=/dev/tty.usbmodem5CBC4323581",
  "--teleop.id=ptm_leader",
  "--dataset.repo_id=local/check_258",
  "--dataset.root=/Users/shimazueiichi/r2r2r-scripts/so101/check_258/dataset",
  "--dataset.no_stamp=true",
  "--dataset.push_to_hub=false",
  "--dataset.fps=30",
  "--dataset.single_task=check 258 practice",
  "--dataset.num_episodes=3",
  "--dataset.episode_time_s=10",
  "--dataset.reset_time_s=10",
  "--display_data=false",
  "--play_sounds=false"
]
```

### 段階5 lerobot-record の出力 s5_record.log（全量）

```text
W1122 17:46:10.678000 81452 site-packages/torch/distributed/elastic/multiprocessing/redirects.py:35] NOTE: Redirects are currently not supported in MacOs.
objc[81452]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x105da43a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x130d803a8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81452]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x105da43f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x130d803f8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
INFO 2026-11-22 17:46:14 t_record.py:401 {'dataset': {'depth_encoder': {'crf': 30,
                               'depth_max': 10.0,
                               'depth_min': 0.01,
                               'extra_options': {'x265-params': 'lossless=1'},
                               'fast_decode': 0,
                               'g': 2,
                               'pix_fmt': 'gray12le',
                               'preset': None,
                               'shift': 3.5,
                               'use_log': True,
                               'vcodec': 'hevc',
                               'video_backend': 'pyav'},
             'encoder_queue_maxsize': 30,
             'encoder_threads': None,
             'episode_time_s': 10,
             'fps': 30,
             'no_stamp': True,
             'num_episodes': 3,
             'num_image_writer_processes': 0,
             'num_image_writer_threads_per_camera': 4,
             'private': None,
             'push_to_hub': False,
             'repo_id': 'local/check_258',
             'reset_time_s': 10,
             'rgb_encoder': {'crf': 30,
                             'extra_options': {},
                             'fast_decode': 0,
                             'g': 2,
                             'pix_fmt': 'yuv420p',
                             'preset': 12,
                             'vcodec': 'libsvtav1',
                             'video_backend': 'pyav'},
             'root': '/Users/shimazueiichi/r2r2r-scripts/so101/check_258/dataset',
             'single_task': 'check 258 practice',
             'streaming_encoding': False,
             'tags': None,
             'video': True,
             'video_encoding_batch_size': 1},
 'display_compressed_images': False,
 'display_data': False,
 'display_ip': None,
 'display_mode': 'rerun',
 'display_port': None,
 'play_sounds': False,
 'resume': False,
 'robot': {'calibration_dir': None,
           'cameras': {'desk': {'backend': <Cv2Backends.ANY: 0>,
                                'color_mode': <ColorMode.RGB: 'rgb'>,
                                'fourcc': 'MJPG',
                                'fps': 30,
                                'height': 480,
                                'index_or_path': 0,
                                'rotation': <Cv2Rotation.NO_ROTATION: 0>,
                                'warmup_s': 1,
                                'width': 640},
                       'wrist': {'backend': <Cv2Backends.ANY: 0>,
                                 'color_mode': <ColorMode.RGB: 'rgb'>,
                                 'fourcc': 'MJPG',
                                 'fps': 30,
                                 'height': 480,
                                 'index_or_path': 1,
                                 'rotation': <Cv2Rotation.NO_ROTATION: 0>,
                                 'warmup_s': 1,
                                 'width': 640}},
           'disable_torque_on_disconnect': True,
           'id': 'ptm_follower',
           'max_relative_target': None,
           'num_read_retries': 2,
           'port': '/dev/tty.usbmodem5CBC4321631',
           'position_d_coefficient': 32,
           'position_i_coefficient': 0,
           'position_p_coefficient': 16,
           'use_degrees': True},
 'teleop': {'calibration_dir': None,
            'id': 'ptm_leader',
            'num_read_retries': 2,
            'port': '/dev/tty.usbmodem5CBC4323581',
            'use_degrees': True}}
objc[81452]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x105da43a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/libavdevice.59.7.100.dylib (0x1592c8778). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81452]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x105da43f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/libavdevice.59.7.100.dylib (0x1592c87c8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
INFO 2026-11-22 17:46:18 so_leader.py:95 ptm_leader SOLeader connected.
WARNING 2026-11-22 17:46:18 a_opencv.py:284 OpenCVCamera(1) failed to set fourcc=MJPG (actual=    , success=False). Continuing with default format.
INFO 2026-11-22 17:46:20 a_opencv.py:198 OpenCVCamera(1) connected.
WARNING 2026-11-22 17:46:21 a_opencv.py:284 OpenCVCamera(0) failed to set fourcc=MJPG (actual=    , success=False). Continuing with default format.
INFO 2026-11-22 17:46:23 a_opencv.py:198 OpenCVCamera(0) connected.
INFO 2026-11-22 17:46:23 follower.py:128 ptm_follower SOFollower connected.
INFO 2026-11-22 17:46:23 rd_input.py:375 Keyboard listener started (Right/Left/Esc, or n=next, r=re-record, q=quit).
INFO 2026-11-22 17:46:23 t_record.py:504 Streaming encoding is disabled. If you have capable hardware, consider enabling it for way faster episode saving. --dataset.streaming_encoding=true --dataset.encoder_threads=2 # --dataset.rgb_encoder.vcodec=auto. More info in the documentation: https://huggingface.co/docs/lerobot/streaming_video_encoding
INFO 2026-11-22 17:46:23 ls/utils.py:151 Recording episode 0
INFO 2026-11-22 17:46:33 ls/utils.py:151 Reset the environment

Map:   0%|          | 0/300 [00:00<?, ? examples/s]
Map: 100%|██████████| 300/300 [00:00<00:00, 4028.65 examples/s]
W1122 17:46:47.825000 81618 site-packages/torch/distributed/elastic/multiprocessing/redirects.py:35] NOTE: Redirects are currently not supported in MacOs.
W1122 17:46:47.825000 81617 site-packages/torch/distributed/elastic/multiprocessing/redirects.py:35] NOTE: Redirects are currently not supported in MacOs.
objc[81617]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x1028243a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x12df743a8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81617]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x1028243f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x12df743f8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81618]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x1065783a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1462f03a8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81618]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x1065783f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1462f03f8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
Svt[info]: Svt[info]: -------------------------------------------
-------------------------------------------
Svt[info]: Svt[info]: SVT [version]:	SVT-AV1 Encoder Lib v3.0.0
SVT [version]:	SVT-AV1 Encoder Lib v3.0.0
Svt[info]: Svt[info]: SVT [build]  :	Apple LLVM 15.0.0 (clang-1500.3.9.4)	 64 bit
SVT [build]  :	Apple LLVM 15.0.0 (clang-1500.3.9.4)	 64 bit
Svt[info]: Svt[info]: LIB Build date: Jul  3 2025 03:06:26
LIB Build date: Jul  3 2025 03:06:26
Svt[info]: Svt[info]: -------------------------------------------
-------------------------------------------
Svt[warn]: Preset M12 is mapped to M10.
Svt[warn]: Preset M12 is mapped to M10.
Svt[info]: Level of Parallelism: 4
Svt[info]: Svt[info]: Level of Parallelism: 4
Svt[info]: Number of PPCS 59
Number of PPCS 59
Svt[info]: [asm level on system : up to neon_dotprod]
Svt[info]: [asm level selected : up to neon_dotprod]
Svt[info]: [asm level on system : up to neon_dotprod]
Svt[info]: [asm level selected : up to neon_dotprod]
Svt[info]: -------------------------------------------
Svt[info]: Svt[info]: SVT [config]: main profile	tier (auto)	level (auto)
-------------------------------------------
Svt[info]: Svt[info]: SVT [config]: width / height / fps numerator / fps denominator 		: 640 / 480 / 30 / 1
SVT [config]: main profile	tier (auto)	level (auto)
Svt[info]: Svt[info]: SVT [config]: bit-depth / color format 					: 8 / YUV420
SVT [config]: width / height / fps numerator / fps denominator 		: 640 / 480 / 30 / 1
Svt[info]: Svt[info]: SVT [config]: preset / tune / pred struct 					: 10 / PSNR / random access
SVT [config]: bit-depth / color format 					: 8 / YUV420
Svt[info]: Svt[info]: SVT [config]: gop size / mini-gop size / key-frame type 			: 2 / 16 / key frame
SVT [config]: preset / tune / pred struct 					: 10 / PSNR / random access
Svt[info]: Svt[info]: SVT [config]: BRC mode / rate factor 					: CRF / 30 
SVT [config]: gop size / mini-gop size / key-frame type 			: 2 / 16 / key frame
Svt[info]: Svt[info]: SVT [config]: AQ mode / variance boost 					: 2 / 0
SVT [config]: BRC mode / rate factor 					: CRF / 30 
Svt[info]: SVT [config]: AQ mode / variance boost 					: 2 / 0
Svt[info]: SVT [config]: sharpness / luminance-based QP bias 			: 0 / 0
Svt[info]: Svt[info]: -------------------------------------------
Svt[info]: SVT [config]: sharpness / luminance-based QP bias 			: 0 / 0
Svt[info]: Svt[info]: -------------------------------------------
INFO 2026-11-22 17:46:54 ls/utils.py:151 Recording episode 1
INFO 2026-11-22 17:46:54 le_timer.py:570 Cadence (episode 0): 29.98 Hz vs 30 Hz target · 300 ticks, 10.0 s measured · 0/299 ticks over the 33.3 ms budget (work mean 2.4 ms, worst 3.3 ms)
INFO 2026-11-22 17:47:04 ls/utils.py:151 Reset the environment

Map:   0%|          | 0/300 [00:00<?, ? examples/s]
Map: 100%|██████████| 300/300 [00:00<00:00, 4442.54 examples/s]
W1122 17:47:17.880000 81807 site-packages/torch/distributed/elastic/multiprocessing/redirects.py:35] NOTE: Redirects are currently not supported in MacOs.
W1122 17:47:17.881000 81806 site-packages/torch/distributed/elastic/multiprocessing/redirects.py:35] NOTE: Redirects are currently not supported in MacOs.
objc[81806]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x1069803a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1314103a8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81807]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x103fb43a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1593983a8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81806]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x1069803f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1314103f8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81807]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x103fb43f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1593983f8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
Svt[info]: -------------------------------------------
Svt[info]: SVT [version]:	SVT-AV1 Encoder Lib v3.0.0
Svt[info]: SVT [build]  :	Apple LLVM 15.0.0 (clang-1500.3.9.4)	 64 bit
Svt[info]: LIB Build date: Jul  3 2025 03:06:26
Svt[info]: -------------------------------------------
Svt[warn]: Preset M12 is mapped to M10.
Svt[info]: Level of Parallelism: 4
Svt[info]: Number of PPCS 59
Svt[info]: [asm level on system : up to neon_dotprod]
Svt[info]: [asm level selected : up to neon_dotprod]
Svt[info]: -------------------------------------------
Svt[info]: SVT [config]: main profile	tier (auto)	level (auto)
Svt[info]: SVT [config]: width / height / fps numerator / fps denominator 		: 640 / 480 / 30 / 1
Svt[info]: SVT [config]: bit-depth / color format 					: 8 / YUV420
Svt[info]: SVT [config]: preset / tune / pred struct 					: 10 / PSNR / random access
Svt[info]: SVT [config]: gop size / mini-gop size / key-frame type 			: 2 / 16 / key frame
Svt[info]: SVT [config]: BRC mode / rate factor 					: CRF / 30 
Svt[info]: SVT [config]: AQ mode / variance boost 					: 2 / 0
Svt[info]: SVT [config]: sharpness / luminance-based QP bias 			: 0 / 0
Svt[info]: Svt[info]: -------------------------------------------
Svt[info]: -------------------------------------------
Svt[info]: SVT [version]:	SVT-AV1 Encoder Lib v3.0.0
Svt[info]: SVT [build]  :	Apple LLVM 15.0.0 (clang-1500.3.9.4)	 64 bit
Svt[info]: LIB Build date: Jul  3 2025 03:06:26
Svt[info]: -------------------------------------------
Svt[warn]: Preset M12 is mapped to M10.
Svt[info]: Level of Parallelism: 4
Svt[info]: Number of PPCS 59
Svt[info]: [asm level on system : up to neon_dotprod]
Svt[info]: [asm level selected : up to neon_dotprod]
Svt[info]: -------------------------------------------
Svt[info]: SVT [config]: main profile	tier (auto)	level (auto)
Svt[info]: SVT [config]: width / height / fps numerator / fps denominator 		: 640 / 480 / 30 / 1
Svt[info]: SVT [config]: bit-depth / color format 					: 8 / YUV420
Svt[info]: SVT [config]: preset / tune / pred struct 					: 10 / PSNR / random access
Svt[info]: SVT [config]: gop size / mini-gop size / key-frame type 			: 2 / 16 / key frame
Svt[info]: SVT [config]: BRC mode / rate factor 					: CRF / 30 
Svt[info]: SVT [config]: AQ mode / variance boost 					: 2 / 0
Svt[info]: SVT [config]: sharpness / luminance-based QP bias 			: 0 / 0
Svt[info]: Svt[info]: -------------------------------------------
[mp4 @ 0x17ec40960] Starting second pass: moving the moov atom to the beginning of the file
[mp4 @ 0x14011c0b0] Starting second pass: moving the moov atom to the beginning of the file
INFO 2026-11-22 17:47:23 ls/utils.py:151 Recording episode 2
INFO 2026-11-22 17:47:23 le_timer.py:570 Cadence (episode 1): 29.98 Hz vs 30 Hz target · 300 ticks, 10.0 s measured · 0/299 ticks over the 33.3 ms budget (work mean 2.4 ms, worst 3.4 ms)

Map:   0%|          | 0/300 [00:00<?, ? examples/s]
Map: 100%|██████████| 300/300 [00:00<00:00, 4372.60 examples/s]
W1122 17:47:38.033000 81946 site-packages/torch/distributed/elastic/multiprocessing/redirects.py:35] NOTE: Redirects are currently not supported in MacOs.
W1122 17:47:38.033000 81947 site-packages/torch/distributed/elastic/multiprocessing/redirects.py:35] NOTE: Redirects are currently not supported in MacOs.
objc[81947]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x1026783a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1451b83a8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81946]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x103eec3a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x12e7b83a8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81947]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x1026783f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1451b83f8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[81946]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x103eec3f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x12e7b83f8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
Svt[info]: -------------------------------------------
Svt[info]: SVT [version]:	SVT-AV1 Encoder Lib v3.0.0
Svt[info]: SVT [build]  :	Apple LLVM 15.0.0 (clang-1500.3.9.4)	 64 bit
Svt[info]: LIB Build date: Jul  3 2025 03:06:26
Svt[info]: -------------------------------------------
Svt[warn]: Preset M12 is mapped to M10.
Svt[info]: Level of Parallelism: 4
Svt[info]: Number of PPCS 59
Svt[info]: [asm level on system : up to neon_dotprod]
Svt[info]: [asm level selected : up to neon_dotprod]
Svt[info]: -------------------------------------------
Svt[info]: SVT [config]: main profile	tier (auto)	level (auto)
Svt[info]: SVT [config]: width / height / fps numerator / fps denominator 		: 640 / 480 / 30 / 1
Svt[info]: SVT [config]: bit-depth / color format 					: 8 / YUV420
Svt[info]: SVT [config]: preset / tune / pred struct 					: 10 / PSNR / random access
Svt[info]: SVT [config]: gop size / mini-gop size / key-frame type 			: 2 / 16 / key frame
Svt[info]: SVT [config]: BRC mode / rate factor 					: CRF / 30 
Svt[info]: SVT [config]: AQ mode / variance boost 					: 2 / 0
Svt[info]: SVT [config]: sharpness / luminance-based QP bias 			: 0 / 0
Svt[info]: Svt[info]: -------------------------------------------
Svt[info]: -------------------------------------------
Svt[info]: SVT [version]:	SVT-AV1 Encoder Lib v3.0.0
Svt[info]: SVT [build]  :	Apple LLVM 15.0.0 (clang-1500.3.9.4)	 64 bit
Svt[info]: LIB Build date: Jul  3 2025 03:06:26
Svt[info]: -------------------------------------------
Svt[warn]: Preset M12 is mapped to M10.
Svt[info]: Level of Parallelism: 4
Svt[info]: Number of PPCS 59
Svt[info]: [asm level on system : up to neon_dotprod]
Svt[info]: [asm level selected : up to neon_dotprod]
Svt[info]: -------------------------------------------
Svt[info]: SVT [config]: main profile	tier (auto)	level (auto)
Svt[info]: SVT [config]: width / height / fps numerator / fps denominator 		: 640 / 480 / 30 / 1
Svt[info]: SVT [config]: bit-depth / color format 					: 8 / YUV420
Svt[info]: SVT [config]: preset / tune / pred struct 					: 10 / PSNR / random access
Svt[info]: SVT [config]: gop size / mini-gop size / key-frame type 			: 2 / 16 / key frame
Svt[info]: SVT [config]: BRC mode / rate factor 					: CRF / 30 
Svt[info]: SVT [config]: AQ mode / variance boost 					: 2 / 0
Svt[info]: SVT [config]: sharpness / luminance-based QP bias 			: 0 / 0
Svt[info]: Svt[info]: -------------------------------------------
[mp4 @ 0x166656550] Starting second pass: moving the moov atom to the beginning of the file
[mp4 @ 0x33800aec0] Starting second pass: moving the moov atom to the beginning of the file
INFO 2026-11-22 17:47:44 le_timer.py:570 Cadence (episode 2): 29.98 Hz vs 30 Hz target · 300 ticks, 10.0 s measured · 0/299 ticks over the 33.3 ms budget (work mean 2.4 ms, worst 2.8 ms)
INFO 2026-11-22 17:47:44 le_timer.py:617 Cadence summary — whole run, 3 episodes · target 30 Hz (33.3 ms budget per tick): 900 ticks, 897 judged
  effective cadence: 29.98 Hz over 29.9 s measured
  ticks over the 33.3 ms work budget: 0/897 (0.0%) — work mean 2.4 ms, worst 3.4 ms
  ticks whose cadence slipped outside the loop body (sleep overshoot / CPU starvation while pacing): 1
  loop-body steps (share of measured work):
    observe      mean   1.20 ms · worst   2.06 ms ·  49.1% of work · 900 calls
    process_obs  mean   0.02 ms · worst   0.11 ms ·   0.9% of work · 900 calls
    teleop       mean   1.04 ms · worst   1.81 ms ·  42.9% of work · 900 calls
    send         mean   0.04 ms · worst   0.17 ms ·   1.7% of work · 900 calls
    record       mean   0.10 ms · worst   0.76 ms ·   4.2% of work · 900 calls
  pacing headroom: 30.9 ms slept per tick on average (max 31.3 ms) — near zero means the loop is saturated
INFO 2026-11-22 17:47:44 ls/utils.py:151 Stop recording
INFO 2026-11-22 17:47:44 a_opencv.py:637 OpenCVCamera(1) disconnected.
INFO 2026-11-22 17:47:44 a_opencv.py:637 OpenCVCamera(0) disconnected.
INFO 2026-11-22 17:47:44 follower.py:221 ptm_follower SOFollower disconnected.
INFO 2026-11-22 17:47:44 o_leader.py:144 ptm_leader SOLeader disconnected.
INFO 2026-11-22 17:47:44 ls/utils.py:151 Exiting
```

### 段階5 記録の形 dataset/meta/info.json（全量）

```json
{
    "codebase_version": "v3.0",
    "fps": 30,
    "features": {
        "action": {
            "dtype": "float32",
            "names": [
                "shoulder_pan.pos",
                "shoulder_lift.pos",
                "elbow_flex.pos",
                "wrist_flex.pos",
                "wrist_roll.pos",
                "gripper.pos"
            ],
            "shape": [
                6
            ]
        },
        "observation.state": {
            "dtype": "float32",
            "names": [
                "shoulder_pan.pos",
                "shoulder_lift.pos",
                "elbow_flex.pos",
                "wrist_flex.pos",
                "wrist_roll.pos",
                "gripper.pos"
            ],
            "shape": [
                6
            ]
        },
        "observation.images.wrist": {
            "dtype": "video",
            "shape": [
                480,
                640,
                3
            ],
            "names": [
                "height",
                "width",
                "channels"
            ],
            "info": {
                "is_depth_map": false,
                "video.height": 480,
                "video.width": 640,
                "video.codec": "av1",
                "video.pix_fmt": "yuv420p",
                "video.fps": 30,
                "video.channels": 3,
                "has_audio": false,
                "video.g": 2,
                "video.crf": 30,
                "video.preset": 12,
                "video.fast_decode": 0,
                "video.video_backend": "pyav",
                "video.extra_options": {}
            }
        },
        "observation.images.desk": {
            "dtype": "video",
            "shape": [
                480,
                640,
                3
            ],
            "names": [
                "height",
                "width",
                "channels"
            ],
            "info": {
                "is_depth_map": false,
                "video.height": 480,
                "video.width": 640,
                "video.codec": "av1",
                "video.pix_fmt": "yuv420p",
                "video.fps": 30,
                "video.channels": 3,
                "has_audio": false,
                "video.g": 2,
                "video.crf": 30,
                "video.preset": 12,
                "video.fast_decode": 0,
                "video.video_backend": "pyav",
                "video.extra_options": {}
            }
        },
        "timestamp": {
            "dtype": "float32",
            "shape": [
                1
            ],
            "names": null
        },
        "frame_index": {
            "dtype": "int64",
            "shape": [
                1
            ],
            "names": null
        },
        "episode_index": {
            "dtype": "int64",
            "shape": [
                1
            ],
            "names": null
        },
        "index": {
            "dtype": "int64",
            "shape": [
                1
            ],
            "names": null
        },
        "task_index": {
            "dtype": "int64",
            "shape": [
                1
            ],
            "names": null
        }
    },
    "total_episodes": 3,
    "total_frames": 900,
    "total_tasks": 1,
    "chunks_size": 1000,
    "data_files_size_in_mb": 100,
    "video_files_size_in_mb": 200,
    "data_path": "data/chunk-{chunk_index:03d}/file-{file_index:03d}.parquet",
    "video_path": "videos/{video_key}/chunk-{chunk_index:03d}/file-{file_index:03d}.mp4",
    "robot_type": "so_follower",
    "splits": {
        "train": "0:3"
    }
}
```

### 段階6 再生1の出力 s6_replay1.log（全量）

```text
objc[82531]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1298983a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x13b4e03a8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[82531]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1298983f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x13b4e03f8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
INFO 2026-11-22 17:49:15 t_replay.py:108 {'dataset': {'episode': 0,
             'fps': 30,
             'repo_id': 'local/check_258',
             'root': '/Users/shimazueiichi/r2r2r-scripts/so101/check_258/dataset'},
 'play_sounds': False,
 'robot': {'calibration_dir': None,
           'cameras': {},
           'disable_torque_on_disconnect': True,
           'id': 'ptm_follower',
           'max_relative_target': None,
           'num_read_retries': 2,
           'port': '/dev/tty.usbmodem5CBC4321631',
           'position_d_coefficient': 32,
           'position_i_coefficient': 0,
           'position_p_coefficient': 16,
           'use_degrees': True}}
objc[82531]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1298983a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/libavdevice.59.7.100.dylib (0x165db8778). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[82531]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1298983f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/libavdevice.59.7.100.dylib (0x165db87c8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
INFO 2026-11-22 17:49:16 follower.py:128 ptm_follower SOFollower connected.
INFO 2026-11-22 17:49:16 ls/utils.py:151 Replaying episode
INFO 2026-11-22 17:49:26 le_timer.py:617 Cadence summary — whole run · target 30 Hz (33.3 ms budget per tick): 300 ticks, 299 judged
  effective cadence: 29.86 Hz over 10.0 s measured
  ticks over the 33.3 ms work budget: 0/299 (0.0%) — work mean 2.0 ms, worst 8.1 ms
  ticks whose cadence slipped outside the loop body (sleep overshoot / CPU starvation while pacing): 12
  loop-body steps (share of measured work):
    read_frame  mean   0.29 ms · worst   4.31 ms ·  13.7% of work · 300 calls
    observe     mean   1.36 ms · worst   6.99 ms ·  65.3% of work · 300 calls
    send        mean   0.38 ms · worst   7.03 ms ·  18.4% of work · 300 calls
  pacing headroom: 31.4 ms slept per tick on average (max 41.5 ms) — near zero means the loop is saturated
INFO 2026-11-22 17:49:26 follower.py:221 ptm_follower SOFollower disconnected.
[REPLAY-LOG] /Users/shimazueiichi/r2r2r-scripts/so101/check_258/s6_replay1.csv に 600 行
```

### 段階6 再生2の出力 s6_replay2.log（全量）

```text
objc[83018]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1223ec3a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x136d083a8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[83018]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1223ec3f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/cv2/.dylibs/libavdevice.61.3.100.dylib (0x136d083f8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
INFO 2026-11-22 17:50:49 t_replay.py:108 {'dataset': {'episode': 0,
             'fps': 30,
             'repo_id': 'local/check_258',
             'root': '/Users/shimazueiichi/r2r2r-scripts/so101/check_258/dataset'},
 'play_sounds': False,
 'robot': {'calibration_dir': None,
           'cameras': {},
           'disable_torque_on_disconnect': True,
           'id': 'ptm_follower',
           'max_relative_target': None,
           'num_read_retries': 2,
           'port': '/dev/tty.usbmodem5CBC4321631',
           'position_d_coefficient': 32,
           'position_i_coefficient': 0,
           'position_p_coefficient': 16,
           'use_degrees': True}}
objc[83018]: Class AVFFrameReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1223ec3a8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/libavdevice.59.7.100.dylib (0x147658778). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
objc[83018]: Class AVFAudioReceiver is implemented in both /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/python3.12/site-packages/av/.dylibs/libavdevice.61.3.100.dylib (0x1223ec3f8) and /opt/homebrew/Caskroom/miniforge/base/envs/lerobot/lib/libavdevice.59.7.100.dylib (0x1476587c8). This may cause spurious casting failures and mysterious crashes. One of the duplicates must be removed or renamed.
INFO 2026-11-22 17:50:49 follower.py:128 ptm_follower SOFollower connected.
INFO 2026-11-22 17:50:49 ls/utils.py:151 Replaying episode
INFO 2026-11-22 17:50:59 le_timer.py:617 Cadence summary — whole run · target 30 Hz (33.3 ms budget per tick): 300 ticks, 299 judged
  effective cadence: 29.94 Hz over 10.0 s measured
  ticks over the 33.3 ms work budget: 0/299 (0.0%) — work mean 1.9 ms, worst 5.1 ms
  ticks whose cadence slipped outside the loop body (sleep overshoot / CPU starvation while pacing): 8
  loop-body steps (share of measured work):
    read_frame  mean   0.23 ms · worst   1.17 ms ·  12.2% of work · 300 calls
    observe     mean   1.31 ms · worst   3.57 ms ·  69.4% of work · 300 calls
    send        mean   0.30 ms · worst   2.30 ms ·  15.8% of work · 300 calls
  pacing headroom: 31.5 ms slept per tick on average (max 33.4 ms) — near zero means the loop is saturated
INFO 2026-11-22 17:50:59 follower.py:221 ptm_follower SOFollower disconnected.
[REPLAY-LOG] /Users/shimazueiichi/r2r2r-scripts/so101/check_258/s6_replay2.csv に 600 行
```

### 段階ごとの完了の記録 run_log.jsonl

```json
{"time": "2026-11-22T17:51:05.104060", "todo": ["s0", "s1", "s2", "s34", "s5", "s6"], "done": ["s0", "s1", "s2", "s34", "s5", "s6"], "status": "ok"}
```

### 1コマごとの生のデータの置き場所

1コマごとの CSV（合わせて約5MB）は、記事には入れず、Mac の同じフォルダに置いています。上の analysis.json は、これらから check_258_analyze.py で集計したものです。

| ファイル | 大きさ | 行数 | 列 |
|---|---|---|---|
| `s2/a_joints.csv` | 66330 バイト | 900 | `t0,follower_ms,leader_ms,err,total_ms` |
| `s2/b_joints_extras.csv` | 289232 バイト | 450 | `t0,follower_ms,leader_ms,err,Present_Current,Present_Current_ms,Present_Load,Present_Load_ms,…（全 13 列）` |
| `s2/c_cam_1280x720_desk.csv` | 60293 バイト | 905 | `t,pos_msec,blur_center,mean,w,h` |
| `s2/c_cam_1280x720_wrist.csv` | 60778 バイト | 915 | `t,pos_msec,blur_center,mean,w,h` |
| `s2/d_cam_640x480_desk.csv` | 59282 バイト | 905 | `t,pos_msec,blur_center,mean,w,h` |
| `s2/d_cam_640x480_wrist.csv` | 60650 バイト | 927 | `t,pos_msec,blur_center,mean,w,h` |
| `s2/e_cam_desk.csv` | 61293 バイト | 935 | `t,pos_msec,blur_center,mean,w,h` |
| `s2/e_cam_wrist.csv` | 62594 バイト | 957 | `t,pos_msec,blur_center,mean,w,h` |
| `s2/e_joints.csv` | 578398 バイト | 900 | `t0,follower_ms,leader_ms,err,Present_Current,Present_Current_ms,Present_Load,Present_Load_ms,…（全 13 列）` |
| `s34/cam_desk.csv` | 368704 バイト | 5661 | `t,pos_msec,blur_center,mean,w,h` |
| `s34/cam_wrist.csv` | 368209 バイト | 5659 | `t,pos_msec,blur_center,mean,w,h` |
| `s34/teleop.csv` | 2655403 バイト | 5607 | `t0,t_act,t_sent,t_pos,t_extra,phase,act_shoulder_pan,sent_shoulder_pan,…（全 48 列）` |
| `s6_replay1.csv` | 81238 バイト | 600 | `kind,frame,t,shoulder_pan,shoulder_lift,elbow_flex,wrist_flex,wrist_roll,gripper` |
| `s6_replay2.csv` | 81453 バイト | 600 | `kind,frame,t,shoulder_pan,shoulder_lift,elbow_flex,wrist_flex,wrist_roll,gripper` |

動画は `s34/wrist.mp4`（28,518,372 バイト）と `s34/desk.mp4`（27,793,407 バイト）、記録の動画 `dataset/videos/` の2本です。手首カメラの動画には、速く動かしたときに人が写っているので、記事には机側カメラの映像だけを使いました。

