# フィジカルAI研究室を作る Log#35 | mechArm 270 の推論の待ちを削り、144秒が54秒に - 記録: LOG505（フィジカルAI研究室） - 公開: 2026/11/14 - 記事のページ: https://pixelstomotors.com/record/mecharm-270-inference-waits-cut-144s-to-54s - サイト: Pixels to Motors（ADAPT DESIGN / 島津 栄一） https://pixelstomotors.com/ - 要約: 小型ロボットアーム mechArm 270 で π0.5 にブロックを箱へ入れさせる1回は、待ちを削ると144秒から54〜95秒に縮んだ。効いたのは最初の推論の57秒と人の Enter 待ち。止めずに流す送り方や速さ30は、1回分の動きを縮めなかった。 > AI が読むための記事の全文です（コード・実行ログを含む）。引用するときは上の「記事のページ」の住所を使ってください。 --- **小型ロボットアーム mechArm 270 で、Physical Intelligence の π0.5 にブロックをつかんで箱へ入れさせる1回は、待ちを削ると144秒から54〜95秒に縮んだ。縮んだのは、最初の推論にかかっていた57秒と、人が Enter を押すまでの待ち（1回で約32秒）で、アームを止めずに流す送り方や動く速さを20から30に上げることは、1回分の動きの時間（2.2〜2.4秒）をほとんど変えなかった。** 実物のアームで、Runpod の GPU に置いた π0.5 を動かした8回の記録から分かったことです。 この回の直しで、次のことが変わりました。 - 1回の試行が短くなった：直す前の1回は144秒。直したあとは、置いたあとに動き続けた1回を除いて54〜105秒（中央90秒） - 人が付きっきりで Enter を押さなくてよくなった：前は1回の中で15回ほど押していた。直したあとは、1回目の試行の始めに1回だけ。補正や巻き戻しをしたいときは、スペースキーを押せば止まる - 置いたあとに動き続ける問題が見つかり、自動で終わる形を足した：1回は、箱に置いたあとも π0.5 が動き続け、何もない所で爪を閉じて箱まで運んだ。置き終えたら HOME に戻って終わる形を足し、記録の上ではこの空振りの前に終わることを確かめた（実機ではまだ試していない） - 費用：この回の GPU（Runpod の A40）は39分で約61円 前の回（[LOG504](https://pixelstomotors.com/record/mecharm-270-5a-adapter-stops-dropping-block)）で、電源を12V・5A に替えると、π0.5 は位置5 のブロックを5回とも箱に入れました。ただ、その1回の記録を時間で分けると、アームが動いていたのは全体の46%だけでした。[LOG490](https://pixelstomotors.com/record/measure-mecharm-270-waits-decide-claude-fable-5-2-role) でも、20本の実機の記録で動いていたのは44%と測っています。残りは、AI が考えている時間と、人が「進めて」の合図を出すまでの時間でした。試す回数を増やすほど、この待ちが積み重なります。 そこで、待ちを1つずつ削り、実機で比べました。 | やったこと | なぜ | 結果 | |---|---|---| | 最初の推論を、アームを動かす前に1回空打ちする（依頼176） | 最初の推論だけ57秒かかっていた | 2回目以降と同じ0.6〜1.2秒になった | | 途中の点で止まらずに次を送る `--flow` と、速さ `--speed` を足す（依頼176） | 1回分（お手本で1秒の動き）に2〜4秒かかっていた | 1回分の動きは2.2〜2.4秒のまま。速さ30でも同じ | | 始めの Enter を、1回目の試行だけにする（依頼177） | 1回目の推論のあとの Enter 待ちが20.9秒 | 2回目からは待たずに始まる | | 推論ごとの Enter をやめ、スペースで止める（依頼178） | 1回分ごとの Enter 待ちが合わせて約11秒 | 1回の中の Enter 待ちは、始めと止めるときだけになった | | 実機で8回比べる | どれが効いたかを分ける | 144秒が54〜95秒に。動いた時間の割合は46%から70%前後に | | 置き終えたら自動で終わる（依頼181） | 1回、置いたあとに空振りした | 記録の上で、置いてから5〜7回分で終わると確かめた | | 1回分を送る点の数を変えられるようにする（依頼182） | 時間は点を送る間隔で決まっていた | 点を4つから2つにする設定を足した（実機はまだ） | 試行の記録は KIOXIA の `runs/pi05_policy/pi05_20261114_*`、ターミナルの出力とこの回の材料は `lab/Log35/` に入れています。 GPU を買うか借りるかの判断は、Runpod で実際に借りて学習させた費用をもとに、別のページにまとめています。この回の推論も、同じ借り方で動かしました。 [ロボットAIの学習用GPU、買うか借りるか](https://pixelstomotors.com/gpu-buy-or-rent) [図解: LOG505_inference_time_breakdown.html](https://pixelstomotors.com/embeds/LOG505_inference_time_breakdown.html) ## 作業ログ ― 推論の1回の待ちを測り、4つの依頼で削って実機で比べるまで ここから下は作業の記録です。依頼文・報告・コードの差分・ターミナルの出力は全量で載せます。効果を書いた所のうち、数字で書いたものは測った値、「見込み」と書いたものはまだ確かめていない値です。 この回で何度も出てくる言葉を先に言い換えておきます。 - π0.5：[Physical Intelligence](https://www.physicalintelligence.company/blog/pi05) が公開しているロボット用の AI。上カメラの画像と関節の角度を見て、次の動きを出す。この回は、位置ごとに10本そろえた50本のお手本で学習したモデル deep1 を使った - 推論：π0.5 に今の画像と角度を渡して、次の動きを答えさせること。答えは [Runpod](https://www.runpod.io/) で借りた GPU のマシン（Pod）の上で出し、Mac から通信で受け取る - チャンク：π0.5 が1回の推論で出す、この先の動きのひとまとまり。0.1秒ごとの姿勢が並んでいて、この回は10個（お手本で1秒ぶん）を1チャンクとして動かした - 中継点：1チャンクの動きを、アームに送るためにいくつかの姿勢に分けたもの。今までは4つ（10個の姿勢のうち3番目・6番目・9番目・10番目）に分け、1つ送るたびに着くまで待っていた - Enter 待ち：推論のたびに出る入力欄で、人が Enter を押すまでの時間。この入力欄は、ゲームパッドでの補正（p）・巻き戻し（b）・爪の締め直し（r）・HOME（h）・終わる（q）の入口も兼ねている - 依頼箱：Claude Code への依頼をファイルで置いておく Mac のフォルダ。置くと見張り係が順に Claude Code に渡し、結果を書き戻す - 位置5：赤いブロックを置く5つの場所のうちの1つ。この回は全部この場所で動かした ## 1回の推論の144秒を、推論・Enter 待ち・動きに分けた LOG504 の推論のうち1回（`pi05_20261113_193254`）のターミナルを読み直し、1チャンクごとに時間を足し合わせました。 | 中身 | 秒 | 見えたこと | |---|---|---| | 推論 | 70.3 | 1回目だけ57.5秒。2回目からは0.6〜1.8秒 | | 人の Enter 待ち | 31.7 | チャンク0 のあとが20.9秒。ほかは1回0.5〜1.6秒 | | アームが動いた | 40.8 | 1チャンクに2.0〜2.6秒。お手本では1秒の動き | | そのほか | 1.6 | 角度の読み取りと撮影 | | 合計 | 144.4 | 動いていたのは全体の28%（チャンク0 の推論を含む） | 1チャンクの動きに2秒以上かかるのは、4つの中継点を1つずつ送り、着いたのを確かめてから次を送っていたからです。アームは中継点ごとに止まり、カクカクと動いていました。 ここから、待ちを削る手を3つ考えました。 1. 最初の推論の57秒をなくす：Pod を立てた直後に1回だけ空打ちしておけば、本番の1回目も速く返るはず 2. 中継点で止まらずに流す：途中の中継点は、着くのを待たずに近づいたら次を送る。速さも上げられるようにする 3. 推論しながら動く：今の動きの間に次を推論しておく。2より作りが大きいので、2の結果を見てから 1と2を依頼176として依頼箱に入れました。0.1秒ごとに次々と送る形は、前にアームのコントローラーに無視された記録があるので使わず、1つずつ送る今の形のまま、着くのを待つ所だけをなくすように頼んでいます。 ## 依頼176：最初の推論を空打ちし、中継点で止まらずに流す ### 依頼176 の依頼文 ```markdown --- 作業フォルダ: /Users/shimazueiichi/r2r2r-scripts 上限時間: 120 --- # 依頼176：実機推論の最初の待ちをなくし、チャンクの中で止まらずに流す 実機は動かさない（実装・テスト・レビューまで）。実機での試しはエイイチが行う。Log35。 ## なぜ LOG504（Log34）の推論 pi05_20261113_193254（位置5・deep1・閉じる値25・12V 5A）の log.jsonl を見ると、87 秒のうち - 1 回目の推論が 57.5 秒（2 回目からは 0.6〜1.8 秒）。チャンク 0 から 1 までは 28.7 秒かかっている - 1 チャンク（お手本で 1 秒ぶん・中継点 4 つ）を動かすのに 3〜4 秒。中継点ごとに _send_and_wait_arrival で 3° に入るまで止まって待つため、カクカクして遅い - 推論の 0.6 秒ほどはアームが止まっている 12V 5A に替えてアームの動きがキビキビしたので（2026-11-13）、速さと滑らかさを上げたい。 ## やること 1. **最初の待ちをなくす（既定で入れる）** - lab_start.sh：サーバーが 8000 番で待ったあと、アームを動かす前に、お手本と同じ形の観測（上カメラの画像の大きさ・state 7 つ・prompt）で 1 回だけ空の推論を投げて捨てる。かかった秒を [WARM ] の行に出す。失敗しても止めずに 1 行出して続ける - --serve-only のときも空打ちまで行う - チャンク 0 から 1 までの 28.7 秒のうち、推論 57.5 秒が終わってから動き終わるまでの 26.9 秒に何が入っているか（HOME・爪・位置合わせ・録画の立ち上げなど）を log と lab_start のターミナル（KIOXIA lab/Log34/lab_start_20261113_192747.txt）から調べて報告に書く。直せるものは案だけ書く（直さない） 2. **チャンクの中で止まらずに流す（--flow。既定は今までどおり）** - run_policy_client.py に --flow を足す。中継点（--via-stride）の途中の点は、3° に入るまで待たず、次の点へ進める条件（たとえば 今の点まで --flow-tol 度以内に近づいた・または見込みの時間がたった）で次を送る。チャンクの最後の点は今までどおり 3° の到着確認をしてから次の推論へ - 送り方は今の単発の send_angles のまま（0.1 秒ごとの連打は DAY287 以前にコントローラーに無視された記録があるので使わない）。送る間隔の下限をどこに置いたかと理由を報告に書く - --speed N を足す（既定 20 のまま）。log.jsonl の頭（type=model）に flow・flow_tol・speed を残す - 中継点ごとに、送った時刻と次を送った時刻（または着いた時刻）を log.jsonl に残す（あとで比べるため） - 補正（ゲームパッド・巻き戻し）の送り方は変えない - 今ある守り（max_move・関節の範囲・安全範囲）は変えない。新しい確認や停止条件は足さない 3. **チャンクごとの時間の内訳を出す道具** - pi05/chunk_timing.py <試行のフォルダ> [<試行のフォルダ> ...]：チャンクごとに 推論の秒・動いた秒・合計 と、試行全体の合計・中央値を表で出す（読むだけ・何も書き出さない）。flow の試行なら中継点ごとの待ちも出す - 実データで pi05_20261113_193254 を流した結果を報告に貼る 4. **お手本の再生の速さ** - record_teach_demo.py の再生がどの速さ（speed）・どの待ちで動いているかを調べて報告に書く。推論の --speed を上げたとき、お手本の速さとどれくらいずれるかの見込みも書く（変えない） 5. テスト：--flow なしで今までと同じ送り方・同じ log になること、--flow で途中の点を待たずに次へ進むこと（daemon をまねたもので）、空打ちが失敗しても lab_start が続くこと。既存のテスト（test_lab_start.sh・pi05/ のもの）も通す 6. codex で差分を見てもらう。指摘を直して通るまで 7. 変えたファイルだけを指定して git add・commit（git add . と git clean は使わない） ## 報告 - エイイチが実機で比べるためのコマンド（位置5・閉じる値25で、今まで／--flow／--flow --speed 30 を 1 回ずつ）と、比べ方（chunk_timing.py） - 1 の 26.9 秒の中身と直し方の案、4 の調べた結果 ``` ### 依頼176 で Claude Code が返した報告 依頼箱は11月13日21:15に始め、22:01に終えました（46分）。 ``` 依頼176 報告：実機推論の最初の待ちをなくし、チャンクの中で止まらずに流す（Log35） ■ やったこと 1. 空打ち（既定で入れた） - pi05/policy_warmup.py を新しく作った。お手本（lab_start の $RAW_RANGE）の最初のエピソードの 1 枚目（384x216）・state[0]（7 つ）・prompt で 1 回だけ推論させて、答えを捨てる。 - lab_start.sh では、トンネル（5）のあと・デーモンやアームより前に「5b. 空打ち」として流す。--serve-only のときも行う。 - かかった秒は [WARM ] の行に出す。時間の上限は、つなぐところから合わせて 300 秒。 - 失敗・答えない・Ctrl-C のときは [WARM ] を 1 行出して、そのまま続ける（lab_start は止まらない）。 2. --flow / --flow-tol / --speed（run_policy_client.py。lab_start.sh にも --flow・--speed N を足し、そのまま渡す） - 途中の点：単発の send_angles を 1 回送る。そのあとは関節角を読みながら待ち、次のどちらかで次の点を送る。 - --flow-tol（既定 5°）以内に近づいた - 見込みの時間（0.15 秒＋角度÷(25°/秒×speed/20)。0.4〜1.5 秒）がたった - チャンクの最後の点は今までどおり 3° の到着を確かめてから、次の推論へ進む。 - 送る直前の関節角の読み直し・max_move・関節の範囲・安全範囲は変えていない。新しい停止条件も足していない。 - --speed は推論のチャンク（と settle の送り直し）だけに効く。補正（キー・ゲームパッド）・巻き戻し・HOME は 20 のまま。 - log.jsonl の頭（type=model）に flow・flow_tol・speed を残す。--flow のときは中継点ごとに vias[].flow を残す（送った時刻 t_send・次へ進むと決めた時刻 t_next・次を実際に送った時刻 t_next_sent と send_gap_s・進んだわけ advance・残りの角度 err_deg）。最後の点は送った時刻と着いた時刻。 - --flow なし・速さ 20 では、送り方・log の中身・画面の出力は今までと同じ（git HEAD の版と比べるテストで確かめた）。 3. pi05/chunk_timing.py（読むだけ・何も書き出さない） - チャンクごとに 推論・確認待ち・動いた・その他・合計 を出し、試行全体の合計・中央値も出す。 - 中継点ごとの間は、--flow の試行なら log の flow から、今までの試行なら recording/states.csv の送った時刻から出す。 - 試行を 2 つ以上渡すと、最後に比べる表を出す。 4. テスト：新しく足したもの・既存のものとも全部通った。数は次のとおり。 - 新しく足したもの：test_flow_send 16 件・test_chunk_timing 6 件 - 既存：test_lab_start.sh 210、test_rewind_correct 81（新しい 3 項目だけ比べる対象から外した）、pi05/ のほかのテスト全部、tools/test_gamepad_teleop 93 - test_power_ab は、最後の一括実行で 2 件落ちた。単独で流し直すと 20 件とも通った（1 回目の一括実行でも通っていた。今回の変更とは関係のない時間の揺れ）。 5. codex：4 回。 - 1 回目：必須 2 件（待つ間に読んだ値を送る前の守りに使っていた／空打ちが metadata 待ちで止まりうる）と推奨 3 件。全部直した。 - 2 回目・3 回目：推奨を直した。 - 4 回目：指摘なし。 6. コミット 0383893（8 ファイルを個別に add）。 ■ 結果 pi05_20261113_193254 を chunk_timing.py で流した表（秒）： == pi05_20261113_193254 (/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261113_193254) 送り方: 記録なし (依頼 176 より前 = --flow なし・速さ 20) 速さ 20 モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 閉じる値 25 チャンク 推論 確認待ち 動いた その他 合計 中継点ごと (秒) メモ 0 57.53 20.93 5.81 0.13 84.40 0.50 0.92 0.94 0.32 始めに爪を開いた 1 1.84 0.59 2.46 0.14 5.03 0.52 0.66 0.82 0.32 2 0.63 0.56 2.33 0.16 3.68 0.48 0.74 0.64 0.32 3 0.64 0.52 2.41 0.13 3.70 0.64 0.64 0.62 0.34 4 0.59 0.55 2.03 0.10 3.26 0.64 0.64 0.40 0.14 5 0.66 1.17 2.56 0.07 4.47 0.46 0.40 0.52 0.95 爪→閉 6 1.62 0.60 2.35 0.10 4.67 0.56 0.64 0.60 0.30 7 0.62 1.32 2.47 0.13 4.53 0.48 0.76 0.64 0.32 8 0.61 1.31 2.33 0.05 4.31 0.62 0.62 0.64 0.30 9 1.54 1.10 2.30 0.12 5.06 0.62 0.62 0.56 0.32 10 0.55 0.50 2.97 0.14 4.17 0.94 0.86 0.72 0.24 11 0.56 0.48 5.35 0.09 6.47 0.82 0.82 0.52 3.08 爪→開 12 0.86 1.56 2.33 0.12 4.87 0.64 0.64 0.62 0.28 13 1.49 0.48 3.11 0.13 5.20 0.82 0.72 1.02 0.34 14 0.59 - - 0.00 0.59 HOME 合計 70.30 31.68 40.81 1.60 144.40 中央値 0.64 0.60 2.44 0.12 4.53 推論: 1 回目 57.53 秒 / 2 回目からの中央値 0.63 秒 中継点の間の中央値 0.62 秒 (states.csv の送った時刻) そのほかの行: framing 1 tilt_fix 1 1 の 26.9 秒（チャンク 0 の推論が終わってから、チャンク 1 の推論を始めるまで）の中身 - 20.9 秒：確認の Enter 待ち（--auto でないため。--auto なしで進めている） - 3.1 秒：開始時に爪を開く。内訳は次のとおり。 - daemon の set_gripper の 2.0 秒（DAY175 対策で、開け閉めの前に必ず sleep(2) している。GRIP_OPEN_DAEMON_WAIT=0 でも、この 2 秒は残る） - Mac 側の 0.8 秒 - 0.3 秒ほど - 2.7 秒：中継点 4 点を動かす（送り間隔 0.50・0.92・0.94 秒＋最後 0.3 秒） - 0.13 秒：次の推論の前の、角度の読み取りと撮影 - HOME・位置合わせ・録画の立ち上げは、チャンク 0 の推論より前に済んでいる（録画の開始から推論の開始まで 0.3 秒）。なので 26.9 秒には入っていない。 - チャンク 11（爪を開く）が 5.35 秒かかったのも、同じ daemon の 2 秒のため。 直し方の案（どれも直していない） - (a) 確認待ち：--auto で流す。または、1 回目だけ確認して以降は自動にする。 - (b) daemon の set_gripper の前の 2 秒：開くときは短くする（Pi 側の変更。DAY175 の不具合が戻らないかの確かめが要る）。 - (c) 開始時に爪を開く：lab_start の 7 ですでに開いている。なので「開いている」と分かっているときは開くのを省く（3.1 秒減る）。 4 の調べた結果（record_teach_demo.py。変えていない） - 送り方：区間ごとに単発の send_angles を 1 回送る。speed は SPEED_SINGLE=20。daemon の送ったあとの待ちは SEND_WAIT_SEC=1.0 秒。 - 到着の確かめ：区間ごとの許容（2〜3°。run_pick_place と同じ）で、0.3 秒おきに読む。上限は 8 秒以上。 - 爪の待ち：閉じたあと 2.0 秒。開くときは daemon 2 秒＋Mac 2 秒。 - 止まっている区間は、学習データを作るとき（build_demo_episodes の idle の詰め）に詰めている。なので、お手本は「speed 20 で途切れずに動く」データになっている。 - お手本 deep_even10_v1（50 本）：動いている間の速さは中央 25.6°/秒、上位 5% で 30.6°/秒。お手本の 1 チャンク（1 秒）は、その速さで 1 秒ぶん動いた量。 - 193254（speed 20・12V 5A）の実行中：上位 5% は 27.3°/秒で、お手本とほぼ同じ。ただし、動いているのは実行時間の 46% だけ。1 チャンクに 2.0〜2.6 秒かかっている（お手本の約 2.4 倍）。 - --flow（speed 20）の見込み： - 途中の点 3 つ × 0.4〜0.5 秒＋最後の点 0.3〜0.5 秒で、1 チャンクあたり約 1.5〜2.0 秒。 - アームの速さはお手本と同じで、止まる時間が減る分だけ速くなる。 - --speed 30 の見込み： - speed に比例するなら約 38°/秒で、お手本の 1.5 倍の速さで動く（比例かどうかは測っていない）。 - ただし送る間隔の下限 0.4 秒があるので、1 チャンクは約 1.3〜1.6 秒より縮まない。 - 「速く動いて少し止まる」形になり、お手本（一定の速さ）とは動きの形がずれる。 - 重さで j1 が遅れる分（今は 2〜3°）が、速いと増える見込み。 送る間隔の下限を 0.4 秒にしたわけ - 0.1 秒ごとの連打は、DAY287 以前にコントローラーに無視された。 - 193254 の単発の送り間隔（どれも着いた）の最短が 0.40 秒だった。なので、実機で通った最短の値を下限にした。 - ゲームパッドで「動いている途中に次の目標を送ると無視されて手前で止まる」ことがあった（11/5）。なので --flow では、途中の点が無視されることがありうる。最後の点は今までどおりの到着確認（動かなければ 1 回だけ再送）で拾う。 ■ 実機で比べるコマンド（位置5・閉じる値25。Log35 の Pod につなぎ直すので、2 回目からは空打ちが短い） 1. 今まで: ./lab_start.sh --model deep1 --log Log35 --grip-value 25 2. --flow: ./lab_start.sh --model deep1 --log Log35 --grip-value 25 --flow 3. --flow --speed 30: ./lab_start.sh --model deep1 --log Log35 --grip-value 25 --flow --speed 30 比べ方: python3 pi05/chunk_timing.py <1 の試行> <2 の試行> <3 の試行> （試行は runs/pi05_policy/pi05_日時。最後の「比べる」表の 動いた中央・中継点中央・合計 を見る。確認の Enter の時間は 確認待ち の列に分けて出る） ■ 変えたファイル - 修正：pi05/run_policy_client.py、lab_start.sh、test_lab_start.sh、pi05/test_rewind_correct.py - 新規：pi05/policy_warmup.py、pi05/chunk_timing.py、pi05/test_flow_send.py、pi05/test_chunk_timing.py ■ 決めてほしいこと 1. --flow-tol の既定 5° と、送る間隔の下限 0.4 秒（上限 1.5 秒）は、こちらで決めた仮の値です。実機で比べたあとに、このままでよいか決めてください。 2. 26.9 秒の直し方の案 (a)〜(c) のうち、どれをやるか。(b) は Pi の daemon を変えることになります。 3. lab_start.sh に --flow / --speed N を足しました（比べるコマンドを打てるようにするため。依頼の文にはない追加です）。残してよいか決めてください。 ``` 報告で分かったことのうち、大きかったのはチャンク0 のあとの26.9秒の中身でした。20.9秒は人が Enter を押すまでの待ちで、機械の待ちではありませんでした。3.1秒は始めに爪を開く時間で、案の1つに「すでに開いているなら省く」がありました。これは採らず、毎回開くことにしています。爪が開いていない、アームが HOME にいない、ということが実際にあるからです。案の (b)（Pi のデーモンの2秒の待ちを短くする）は、前に起きた不具合（DAY175）が戻るおそれがあるので見送りました。 `--flow` で途中の中継点から次へ進む決まり（5° まで近づいた・送る間隔は0.4〜1.5秒）は、Claude Code が仮に決めた値です。実機で比べてから決めることにしました。 ### 依頼176 のコードの差分（コミット 0383893） ```diff commit 0383893682aaa5e56e618ff6be55c67431d00304 Author: Eiichi Shimazu Date: Fri Nov 13 22:00:26 2026 +0900 実機推論の最初の待ちをなくし, チャンクの中の途中の点で止まらずに流せるようにする (依頼 176・Log35). lab_start.sh はトンネル (5) のあと・アームの前に 5b で pi05/policy_warmup.py を流し, お手本 ($RAW_RANGE) の 1 枚目と state[0] と prompt で 1 回だけ推論させて捨てる (つなぐところから --timeout 300 秒. かかった秒を [WARM ] に. 失敗・Ctrl-C でも 1 行出して続ける. --serve-only でも行う). run_policy_client.py に --flow (途中の点は単発の send_angles を 1 回送り, --flow-tol (既定 5°) 以内に近づくか見込みの時間 (0.15 秒 + 角度 ÷ 25°/秒×speed/20) で次を送る. 送る間隔は 0.4 秒以上・1.5 秒まで. 最後の点は今までどおり 3° の到着確認. 送る直前の読み直しと守りは今までどおり) と --speed N (既定 20. チャンクと settle だけ. 補正・巻き戻し・HOME は 20 のまま) を足す. log.jsonl の頭に flow・flow_tol・speed, --flow の中継点ごとに送った時刻・次を送った時刻・進んだわけ. 既定では送り方・log の中身・出力は今までと同じ. lab_start.sh に --flow / --speed N を足しクライアントに渡す. チャンクごとの 推論・確認待ち・動いた・合計 を表で出す pi05/chunk_timing.py (読むだけ) を足す. テストを足す (test_flow_send 16・test_chunk_timing 6・lab_start 210. test_rewind_correct は新しい 3 項目を比べる対象から外す) (依頼 176. codex 4 回) Co-Authored-By: Claude Opus 5.5 --- lab_start.sh | 30 +++- pi05/chunk_timing.py | 229 ++++++++++++++++++++++++++++ pi05/policy_warmup.py | 131 ++++++++++++++++ pi05/run_policy_client.py | 185 +++++++++++++++++++++-- pi05/test_chunk_timing.py | 195 ++++++++++++++++++++++++ pi05/test_flow_send.py | 359 ++++++++++++++++++++++++++++++++++++++++++++ pi05/test_rewind_correct.py | 3 +- test_lab_start.sh | 31 +++- 8 files changed, 1146 insertions(+), 17 deletions(-) diff --git a/lab_start.sh b/lab_start.sh index 606745f..a4dd15f 100755 --- a/lab_start.sh +++ b/lab_start.sh @@ -32,10 +32,12 @@ # --serve-only Pod を作ってサーバーを 8000 番で待たせ, Mac の 8000 番へのトンネルを張るところ (1〜5) までだけ行い, # デーモン・HOME・爪・位置合わせ・推論 (6〜8) には進まない. トンネルを張ったまま待ち, Ctrl-C か TERM で # トンネルを閉じて終わる (Pod は消さない. 片付けは ./lab_stop.sh). 録画の画像で答えを出させる -# pi05/tilt_ab_test.py などのため (依頼 146) +# pi05/tilt_ab_test.py などのため (依頼 146). 5b の空打ちまでは行う (依頼 176) # --no-tilt-fix 傾きをソフトでそろえない (camera_align.py と run_policy_client.py に --no-tilt-fix を渡す. 依頼 144) # --grip-value N 爪の閉じる値 (0〜100. run_policy_client.py に --grip-value を渡す. 付けなければ今までどおり # run_policy_client.py の既定 20. 起動時に [GRIP ] で使う値を出す. 依頼 152) +# --flow / --speed N run_policy_client.py にそのまま渡す (中継点を止まらずに流す / チャンクを送る速さ 1〜100. +# 付けなければ今までどおり. 依頼 176. 起動時に [FLOW ] で出す) # つなぎ直しで, 残っている Pod のサーバーが別のモデルで動いていれば, そのことを出して止まる # # 1. Pod を作る (A40×1・Runpod Pytorch 2.8.0・コンテナのディスク 200GB・22/tcp を外へ出す) @@ -52,6 +54,8 @@ # → addon・設定・assets → serve_policy.py を tmux の中で起動し /workspace/logs/serve.log に残す) # 4. serve.log に「server listening on 0.0.0.0:8000」が出るまで待つ # 5. Mac の 8000 番へのトンネルを裏で張る (このスクリプトが終わるときに閉じる) +# 5b. 空打ち: pi05/policy_warmup.py でお手本と同じ形の観測を 1 回だけ推論させて捨てる (1 回目の推論のコンパイル +# 57.5 秒をアームを動かす前に済ませる. 依頼 176). かかった秒を [WARM ] に出す. 失敗・Ctrl-C でも止めずに続ける # 6. tools/daemon_ctl.sh status で 5555 の LISTEN を見る. なければ start # 7. HOME → 爪を開く → camera_align.py (q で閉じる) # 8. run_policy_client.py (LOG407 と同じ引数). 終わったら, もう1回やるかを聞く (y なら 7 へ) @@ -79,6 +83,7 @@ MODEL=trim TILT_FIX_ARGS=() # 依頼 144: 既定は傾きをソフトでそろえる. --no-tilt-fix で回さない GRIP_ARGS=() # 依頼 152: --grip-value N のときだけ run_policy_client.py に --grip-value N を渡す GRIP_VALUE_SHOWN="20 (既定. run_policy_client.py の GRIP_VALUE)" +FLOW_ARGS=() # 依頼 176: --flow / --speed N のときだけ run_policy_client.py に渡す while [ $# -gt 0 ]; do case "$1" in --gpu) lab_need_val A40 "$@"; GPU="$2"; shift 2 ;; @@ -92,9 +97,14 @@ while [ $# -gt 0 ]; do # 桁数を先に見る (大きな数は算術展開であふれて小さな値になる. codex R1) [ ${#2} -le 3 ] && [ "$((10#$2))" -le 100 ] || { echo "[ERROR] --grip-value は 0〜100 の整数: $2" >&2; exit 2; } GRIP_ARGS=(--grip-value "$((10#$2))"); GRIP_VALUE_SHOWN="$((10#$2)) (--grip-value)"; shift 2 ;; + --flow) FLOW_ARGS+=(--flow); shift ;; + --speed) [ $# -ge 2 ] || { echo "[ERROR] --speed には 1〜100 の整数を付ける" >&2; exit 2; } + case "$2" in ''|*[!0-9]*) echo "[ERROR] --speed は 1〜100 の整数: $2" >&2; exit 2 ;; esac + [ ${#2} -le 3 ] && [ "$((10#$2))" -ge 1 ] && [ "$((10#$2))" -le 100 ] || { echo "[ERROR] --speed は 1〜100 の整数: $2" >&2; exit 2; } + FLOW_ARGS+=(--speed "$((10#$2))"); shift 2 ;; --model) [ $# -ge 2 ] || { echo "[ERROR] --model には ${LAB_MODELS// / か } を付ける" >&2; exit 2; } # 値がないと shift 2 が失敗して回り続ける (codex R1) MODEL="$2"; shift 2 ;; - -h|--help) sed -n '2,54p' "$0"; exit 0 ;; + -h|--help) sed -n '2,58p' "$0"; exit 0 ;; *) echo "[ERROR] 知らない引数: $1 (./lab_start.sh --help)" >&2; exit 2 ;; esac done @@ -143,6 +153,7 @@ else echo "[TILT ] 上カメラの傾きのお手本 (各エピソードの 1 枚目の中央値) は $RAW_RANGE から (安全範囲と同じ. --no-tilt-fix なので回さない. 依頼 142)" fi echo "[GRIP ] 爪の閉じる値は $GRIP_VALUE_SHOWN. 締め直し r はこの値−3 とこの値を交互に送る (依頼 152)" +[ ${#FLOW_ARGS[@]} = 0 ] || echo "[FLOW ] 推論の送り方: ${FLOW_ARGS[*]} (依頼 176)" # 付けなければ今までと同じ出力 lab_ssh_opts HF_REPO=$MODEL_REPO # --model で選んだモデル (lab_lib.sh の lab_model_def) @@ -453,6 +464,17 @@ stage_done cd "$HERE" || fail "$HERE に移れない" +# ---- 5b. 空打ち (依頼 176): 1 回目の推論のコンパイルをアームを動かす前に済ませる. 失敗しても止めない ---- +# 観測の形は安全範囲と同じお手本 ($RAW_RANGE) の 1 枚目と state[0]. この間の Ctrl-C は空打ちだけをやめる +stage "5b. 空打ち (1 回目の推論の待ちを先に済ませる)" +trap ':' INT +python3 pi05/policy_warmup.py --port "$TUNNEL_PORT" --raw-dir "$RAW_RANGE" +rc=$? +# 1 は policy_warmup.py が失敗の 1 行を出したとき. それ以外 (落ちた・読み込めない) はここで 1 行出す +[ $rc = 0 ] || [ $rc = 1 ] || echo "[WARM ] 空打ちが終了コード $rc で終わりました. 止めずに続けます (1 回目の推論が長くなる)" +trap 'fail "Ctrl-C で止めました"' INT +stage_done + # ---- --serve-only: ここで止まり, トンネルを張ったまま待つ (6〜8 に進まない. 依頼 146) ---- if [ $SERVE_ONLY = 1 ]; then serve_only_end() { @@ -503,13 +525,13 @@ while :; do stage "8. 実機推論 ($round 回目)" python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride 3 \ --settle-retries 0 --state-from-target --execute --ignore-framing --model "$MODEL_TAG" --framing-raw-dir "$RAW" \ - --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} + --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} rc=$? else stage "8. 推論のクライアント (ドライラン・--dry-keys. アームには触らない)" python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride 3 \ --settle-retries 0 --state-from-target --dry-keys --ignore-framing --model "$MODEL_TAG" --framing-raw-dir "$RAW" \ - --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} + --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} rc=$? fi echo "[CLIENT] run_policy_client.py が終わった (終了コード $rc. モデル $MODEL_TAG)" diff --git a/pi05/chunk_timing.py b/pi05/chunk_timing.py new file mode 100644 index 0000000..8650f14 --- /dev/null +++ b/pi05/chunk_timing.py @@ -0,0 +1,229 @@ +#!/usr/bin/env python3 +"""chunk_timing.py — 実機推論の試行のチャンクごとの時間の内訳を表で出す (依頼 176. 読むだけ・何も書き出さない). + + python3 pi05/chunk_timing.py <試行のフォルダ> [<試行のフォルダ> ...] + 例: python3 pi05/chunk_timing.py /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261113_193254 + +試行のフォルダ = run_policy_client.py の記録 (log.jsonl があるフォルダ). フォルダ名だけ (pi05_20261113_193254) なら +/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/ の下を探す. + +チャンクごとの列 (秒. log.jsonl の時刻から. 推論を始めた時刻は t − latency_s の近似 (t は計画・画像の保存のあとに +書くので, その分 (ふつう 0.01 秒ほど) 確認待ちが短く, 推論の始まりが遅めに出る)): + 推論 latency_s (π0.5 が答えるまで) + 確認待ち 推論が終わってから送り始めるまで (Enter の確認. --auto なら 0 に近い). 送っていないチャンクは - + 動いた 送り始めてから送り終わるまで (t_exec_start → t_exec_end. 爪の開け閉めを含む) + その他 合計 − 推論 − 確認待ち − 動いた (関節角の読み取り・撮影など. 巻き戻し・補正・送らずに次へ のチャンクは + 確認待ちもここに入る) + 合計 このチャンクの推論を始めてから次のチャンクの推論を始めるまで (最後のチャンクは記録の終わりまで) +試行全体の 合計 と 中央値 (推論は 2 回目からの中央値も) を出す. + +中継点ごと: + --flow の試行 log.jsonl の vias[].flow から, 送ってから次を実際に送るまで (send_gap_s. 最後の点は着くまで) の秒と + 進んだわけ + --flow でない試行 recording/states.csv の send_angles の時刻から, 送ってから次を送るまで (最後の点は送り終わりまで) の秒 + (どちらも 1 チャンク 1 行. 2 つ以上の試行を渡すと, 最後に試行ごとの比べる表を出す) +""" +import argparse +import csv +import json +import statistics +import sys +from pathlib import Path + +RUNS_ROOT = Path("/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy") +ADVANCE_TEXT = {"near": "近", "time": "時", "arrived": "着", "not_arrived": "未", "send_failed": "失"} + + +def resolve_dir(arg: str) -> Path: + p = Path(arg) + if (p / "log.jsonl").exists(): + return p + q = RUNS_ROOT / arg + if (q / "log.jsonl").exists(): + return q + raise FileNotFoundError(f"log.jsonl がない: {arg}") + + +def load_log(run_dir: Path): + """log.jsonl → (頭の model 行 or {}, 推論の行の並び, そのほかの行の数 {type: n}).""" + model, chunks, others = {}, [], {} + for line in (run_dir / "log.jsonl").read_text().splitlines(): + if not line.strip(): + continue + try: + r = json.loads(line) + except json.JSONDecodeError: + others["(読めない行)"] = others.get("(読めない行)", 0) + 1 + continue + if r.get("type") == "model": + model = r + elif r.get("type") is None and "chunk" in r and "latency_s" in r: + chunks.append(r) + else: + k = r.get("type") or "?" + others[k] = others.get(k, 0) + 1 + return model, chunks, others + + +def load_sends(run_dir: Path): + """recording/states.csv の send_angles の時刻 (並べたもの). なければ [].""" + p = run_dir / "recording" / "states.csv" + if not p.exists(): + return [] + out = [] + with p.open(newline="") as f: + for r in csv.DictReader(f): + if r.get("event_type") == "send_angles": + try: + out.append(float(r["ts"])) + except (TypeError, ValueError): + pass + return sorted(out) + + +def last_time(chunks): + """最後のチャンクの記録の終わり (推論の行を書いた時刻か送り終わりの遅い方).""" + r = chunks[-1] + ts = [r.get("t"), r.get("t_exec_end")] + return max(x for x in ts if x is not None) + + +def chunk_rows(chunks): + """チャンクごとの {chunk, infer, confirm, moved, other, total, note}. 時刻のない値は None.""" + rows = [] + for n, r in enumerate(chunks): + start = r["t"] - r["latency_s"] + nxt = chunks[n + 1]["t"] - chunks[n + 1]["latency_s"] if n + 1 < len(chunks) else last_time(chunks) + total = nxt - start + infer = float(r["latency_s"]) + if r.get("t_exec_start") is not None and r.get("t_exec_end") is not None: + confirm = max(0.0, r["t_exec_start"] - r["t"]) + moved = r["t_exec_end"] - r["t_exec_start"] + else: + confirm = moved = None + other = total - infer - (confirm or 0.0) - (moved or 0.0) + note = [] + if r.get("grip_cmd") is not None: + note.append("爪→" + ("閉" if r["grip_cmd"] == 1 else "開")) + if r.get("initial_gripper_open"): + note.append("始めに爪を開いた") + for k, t in (("rewind_requested", "巻き戻し"), ("correction_requested", "補正"), + ("home_requested", "HOME"), ("unsafe", "安全停止")): + if r.get(k): + note.append(t) + if not r.get("executed") and moved is None and not note: + note.append("送っていない") + rows.append({"chunk": r["chunk"], "infer": infer, "confirm": confirm, "moved": moved, + "other": other, "total": total, "note": " ".join(note)}) + return rows + + +def via_waits(r, sends): + """1 チャンクの中継点ごとの (step, 秒, わけ). flow の記録があればそれ, なければ states.csv の送った時刻.""" + vias = r.get("vias") or [] + if any("flow" in v for v in vias): + out = [] + for v in vias: + fl = v.get("flow") + if fl: + # 次を実際に送った時刻があればそれまで (send_gap_s), なければ次へ進むと決めた時刻まで (wait_s) + w = fl.get("send_gap_s", fl.get("wait_s")) + out.append((v["step"], w, ADVANCE_TEXT.get(fl.get("advance"), fl.get("advance")))) + elif v.get("called"): + out.append((v["step"], None, "?")) + else: + out.append((v["step"], None, "送らず")) + return out, "flow" + a, b = r.get("t_exec_start"), r.get("t_exec_end") + if a is None or b is None or not sends: + return [], None + ts = [t for t in sends if a <= t <= b] + if not ts: + return [], None + marks = ts + [b] + return [(None, marks[k + 1] - marks[k], "") for k in range(len(ts))], "states" + + +def fmt(x, w=7): + return f"{'-':>{w}}" if x is None else f"{x:>{w}.2f}" + + +def med(xs): + xs = [x for x in xs if x is not None] + return statistics.median(xs) if xs else None + + +def report(run_dir: Path): + model, chunks, others = load_log(run_dir) + print(f"== {run_dir.name} ({run_dir})") + if model: + flow = model.get("flow") + how = ("記録なし (依頼 176 より前 = --flow なし・速さ 20)" if flow is None else + (f"--flow (近づく {model.get('flow_tol')}°)" if flow else "--flow なし")) + print(f" 送り方: {how} 速さ {model.get('speed', 20)} モデル {model.get('model')} 閉じる値 {model.get('grip_value')}") + if not chunks: + print(" 推論の行がない") + return None + rows = chunk_rows(chunks) + sends = load_sends(run_dir) + print(f" {'チャンク':>6} {'推論':>7} {'確認待ち':>7} {'動いた':>7} {'その他':>7} {'合計':>7} 中継点ごと (秒) メモ") + flow_seen = False + for r, row in zip(chunks, rows): + waits, src = via_waits(r, sends) + if src == "flow": + flow_seen = True + vtxt = " ".join(f"{'-' if s is None else s}:{fmt(w, 0) if w is not None else '-'}{m}" for s, w, m in waits) + elif src == "states": + vtxt = " ".join(f"{w:.2f}" for _, w, _ in waits) + else: + vtxt = "" + print(f" {row['chunk']:>6} {fmt(row['infer'])} {fmt(row['confirm'])} {fmt(row['moved'])} " + f"{fmt(row['other'])} {fmt(row['total'])} {vtxt} {row['note']}") + tot = {k: sum(x[k] for x in rows if x[k] is not None) for k in ("infer", "confirm", "moved", "other", "total")} + mid = {k: med([x[k] for x in rows]) for k in ("infer", "confirm", "moved", "other", "total")} + print(f" {'合計':>6} {fmt(tot['infer'])} {fmt(tot['confirm'])} {fmt(tot['moved'])} {fmt(tot['other'])} {fmt(tot['total'])}") + print(f" {'中央値':>5} {fmt(mid['infer'])} {fmt(mid['confirm'])} {fmt(mid['moved'])} {fmt(mid['other'])} {fmt(mid['total'])}") + infer2 = med([x["infer"] for x in rows[1:]]) + all_waits = [] + for r in chunks: + w, src = via_waits(r, sends) + all_waits += [x[1] for x in w if x[1] is not None] + print(f" 推論: 1 回目 {rows[0]['infer']:.2f} 秒 / 2 回目からの中央値 {fmt(infer2, 0)} 秒 " + f"中継点の間の中央値 {fmt(med(all_waits), 0)} 秒 ({'log.jsonl の flow' if flow_seen else 'states.csv の送った時刻' if all_waits else '記録なし'})") + if flow_seen: + print(" 中継点ごと: step:秒+わけ (近=近づいた 時=見込みの時間 着=最後の点が着いた 未=着かなかった 失=送れなかった)") + if others: + print(" そのほかの行: " + " ".join(f"{k} {v}" for k, v in sorted(others.items()))) + return {"name": run_dir.name, "flow": model.get("flow"), "speed": model.get("speed", 20), "n": len(rows), + "tot": tot, "mid": mid, "infer1": rows[0]["infer"], "infer2": infer2, "via": med(all_waits)} + + +def main(argv=None): + ap = argparse.ArgumentParser(description="実機推論の試行のチャンクごとの時間の内訳 (読むだけ)") + ap.add_argument("runs", nargs="+", help="試行のフォルダ (log.jsonl があるところ) かフォルダ名") + args = ap.parse_args(argv) + res = [] + for a in args.runs: + try: + d = resolve_dir(a) + except FileNotFoundError as e: + print(f"[ERROR] {e}") + return 1 + r = report(d) + print() + if r: + res.append(r) + if len(res) >= 2: + print("== 比べる (秒)") + print(f" {'試行':<22} {'送り方':<10} {'速さ':>4} {'チャンク':>6} {'推論計':>7} {'確認待ち計':>7} {'動いた計':>7} " + f"{'動いた中央':>7} {'中継点中央':>7} {'合計':>7}") + for r in res: + how = "記録なし" if r["flow"] is None else ("flow" if r["flow"] else "今まで") + print(f" {r['name']:<22} {how:<10} {r['speed']:>4} {r['n']:>6} {fmt(r['tot']['infer'])} " + f"{fmt(r['tot']['confirm'])} {fmt(r['tot']['moved'])} {fmt(r['mid']['moved'])} {fmt(r['via'])} " + f"{fmt(r['tot']['total'])}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/pi05/policy_warmup.py b/pi05/policy_warmup.py new file mode 100644 index 0000000..2be519d --- /dev/null +++ b/pi05/policy_warmup.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +"""policy_warmup.py — π0.5 のサーバーに空の推論を 1 回だけ投げて捨てる (依頼 176. lab_start.sh の 5b). + +openpi のサーバーは最初の推論のときにコンパイルするので, 1 回目の推論が長い +(2026-11-13 の pi05_20261113_193254 で 57.5 秒. 2 回目からは 0.6〜1.8 秒). アームを動かす前に, +お手本と同じ形の観測 (上カメラの画像の大きさ・state 7 つ・prompt) で 1 回答えさせて, その待ちを先に済ませる. +答え (actions) は使わない・何も書き出さない・アームにも daemon にも触らない. + +観測: + image --raw-dir の最初のエピソードの frames/000000.jpg (お手本の 1 枚目. 学習画像と同じ大きさ) を RGB で + state そのエピソードの episode.npz の state[0] (7 つ. float32) + prompt --prompt (既定 run_policy_client.py の TASK) + +かかった秒を [WARM ] の 1 行で出す. 失敗したら (つながらない・答えがおかしい・つなぐところから --timeout 秒で +答えない・Ctrl-C) [WARM ] の 1 行を出して終了コード 1 (lab_start.sh は止めずに続ける. ほかの終了コードのときだけ +lab_start.sh が 1 行出す). + +Usage: + python3 pi05/policy_warmup.py --raw-dir /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes +""" +import argparse +import sys +import threading +import time +from pathlib import Path + +_HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(_HERE)) + +try: + import cv2 + import numpy as np + + import policy_ws + from policy_ws import PolicyClient +except Exception as _e: # 読み込めなくても [WARM ] の 1 行と終了コード 1 にする (codex R2) + _msg = " / ".join(x.strip() for x in f"{type(_e).__name__}: {_e}".splitlines() if x.strip())[:300] + print(f"[WARM ] 空打ちに失敗 (読み込めない): {_msg}. 止めずに続けます (1 回目の推論が長くなる)", flush=True) + sys.exit(1) + +TASK = "put the red block in the white box" # run_policy_client.py の TASK と同じ +TIMEOUT_SEC = 300.0 # 答えを待つ上限 (1 回目は 57.5 秒だった. コンパイルは数分かかることもある) +CONNECT_WAIT_SEC = 30.0 # サーバーにつながるまで待つ上限 (トンネルは 5 で張れている) + + +def warm_observation(raw_dir: Path, prompt: str) -> dict: + """お手本の最初のエピソードの 1 枚目と state[0] で観測を作る. 作れなければ例外.""" + eps = sorted(p.parent for p in Path(raw_dir).glob("*/episode.npz")) + if not eps: + raise FileNotFoundError(f"お手本のエピソードがない: {raw_dir}") + ep = eps[0] + bgr = cv2.imread(str(ep / "frames" / "000000.jpg")) + if bgr is None: + raise FileNotFoundError(f"お手本の 1 枚目を読めない: {ep / 'frames' / '000000.jpg'}") + state = np.asarray(np.load(ep / "episode.npz")["state"][0], dtype=np.float32) + if state.shape != (7,): + raise ValueError(f"state の形が 7 つでない: {state.shape} ({ep})") + rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB) + return {"observation/image": rgb, "observation/state": state, "prompt": prompt}, ep + + +def connect_and_infer(host, port, obs, timeout): + """つなぐ (metadata を受け取るまで)・推論させる・閉じる を別のスレッドで行い, 全部で timeout 秒を超えたら + TimeoutError (スレッドは捨てる. daemon スレッドなので終わるときに残らない. codex R1: つないだあと metadata が + 来ないときも止まらない). 戻り値 (答え, 推論だけの秒).""" + box = {} + + def _run(): + policy = None + try: + policy = PolicyClient(host, port, wait_sec=CONNECT_WAIT_SEC) + t1 = time.time() + box["out"] = policy.infer(obs) + box["infer_s"] = time.time() - t1 + except BaseException as e: # noqa: BLE001 落ちたわけを本体へ渡す + box["err"] = e + finally: + if policy is not None: + policy.close() + th = threading.Thread(target=_run, daemon=True, name="warmup_infer") + th.start() + th.join(timeout) + if th.is_alive(): + raise TimeoutError(f"{timeout:.0f} 秒待っても答えない (つなぐところから)") + if "err" in box: + raise box["err"] + return box["out"], box["infer_s"] + + +def one_line(e): + """例外を 1 行に (サーバー側のエラーは改行を含む).""" + return " / ".join(x.strip() for x in f"{type(e).__name__}: {e}".splitlines() if x.strip())[:300] + + +def main(argv=None): + ap = argparse.ArgumentParser() + ap.add_argument("--host", default="localhost") + ap.add_argument("--port", type=int, default=8000) + ap.add_argument("--raw-dir", required=True, help="観測の形を取るお手本 (学習に使った raw_episodes)") + ap.add_argument("--prompt", default=TASK) + ap.add_argument("--timeout", type=float, default=TIMEOUT_SEC, help=f"答えを待つ上限の秒 (既定 {TIMEOUT_SEC:.0f})") + args = ap.parse_args(argv) + t0 = time.time() + # PolicyClient の「サーバー待ち」の行は出さない (失敗しても [WARM ] の 1 行だけにする. codex R1) + policy_ws.print = lambda *a, **k: None + try: + obs, ep = warm_observation(Path(args.raw_dir), args.prompt) + print(f"[WARM ] 空打ち: {args.host}:{args.port} に観測 (画像 {obs['observation/image'].shape[1]}x" + f"{obs['observation/image'].shape[0]}・state 7 つ・prompt) を 1 回投げて捨てます (お手本 {ep.name} の 1 枚目)", + flush=True) + out, infer_s = connect_and_infer(args.host, args.port, obs, args.timeout) + acts = np.asarray(out["actions"], dtype=float) + if acts.ndim != 2 or acts.shape[1] < 7 or not np.all(np.isfinite(acts)): + raise ValueError(f"答えの actions の形がおかしい: {acts.shape}") + print(f"[WARM ] 空打ち {infer_s:.1f} 秒 (つなぐまで含めて {time.time() - t0:.1f} 秒. " + f"答え {acts.shape[0]}x{acts.shape[1]} は捨てた)", flush=True) + return 0 + except KeyboardInterrupt: + print(f"[WARM ] 空打ちを Ctrl-C でやめました ({time.time() - t0:.1f} 秒). 止めずに続けます " + "(1 回目の推論が長くなる)", flush=True) + return 1 + except Exception as e: + print(f"[WARM ] 空打ちに失敗 ({time.time() - t0:.1f} 秒): {one_line(e)}. 止めずに続けます " + "(1 回目の推論が長くなる)", flush=True) + return 1 + finally: + del policy_ws.print + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/pi05/run_policy_client.py b/pi05/run_policy_client.py index e92eaed..0e20e4c 100644 --- a/pi05/run_policy_client.py +++ b/pi05/run_policy_client.py @@ -94,6 +94,19 @@ 巻き戻し・ゲームパッドの補正の閉じる指令はすべてこの値. log.jsonl の頭 (type=model) に grip_value を残す. 推論の終わりに, 閉じて 1 秒後の爪の電流 (recording/currents.csv の gripper_current の中央値) を 1 行で出す (表示だけ) +中継点を止まらずに流す (2026-11-13 依頼 176. --flow. 既定は今までどおり 1 点ごとに 3° の到着を待つ): + --via-stride の途中の点は 3° に入るまで待たず, 単発の send_angles を 1 回送ったあと関節角を読みながら + 「その点まで --flow-tol 度以内に近づいた」か「見込みの時間 (flow_expect_sec) がたった」で次の点を送る. + どちらでも送る間隔は FLOW_MIN_INTERVAL_SEC (0.4 秒) より短くしない (0.1 秒ごとの連打は DAY287 以前に + コントローラーに無視された. 実機で通った単発の送り間隔の最短が 0.40 秒 = 2026-11-13 の 193254). + チャンクの最後の点は今までどおり _send_and_wait_arrival (3° の到着確認) をしてから次の推論へ. + 途中の点は着いたかを見ないので, 途中の点の「未到達」で止まることはない (送信が失敗したときだけ今までどおり). + log.jsonl の中継点ごとに flow (送った時刻 t_send・次へ進むと決めた時刻 t_next (最後の点は着いた時刻)・ + 次を実際に送った時刻 t_next_sent と send_gap_s・進んだわけ advance・待った秒 wait_s) を残す. + 送る直前の関節角は今までどおり毎回読み直す (待つ間に読んだ値で apply_limits をかけない). + --speed N: 推論のチャンクを送る速さ (既定 20 = 今までと同じ. settle の送り直しも同じ速さ). + 補正 (キー・ゲームパッド)・巻き戻し・HOME の送り方と速さは変えない. log.jsonl の頭 (type=model) に flow・flow_tol・speed + 待ち時間 (2026-10-30 依頼 35. エイイチの判断で縮めた. 本線と共有の定数は変えず, ここで上書きする): --send-wait 0.0 (前 1.0) / --grip-wait 0.8 (前 2.0) / --grip-open-wait 0.0 (前 2.0) / --settle-wait 0.8 (前 2.0) 前の値に戻すには --send-wait 1.0 --grip-wait 2.0 --grip-open-wait 2.0 --settle-wait 2.0 @@ -149,6 +162,7 @@ if "pymycobot" not in sys.modules: sys.modules["pymycobot"] = _pkg; sys.modules["pymycobot.mycobot"] = _mod import camera_resolver # noqa: E402 +import j0_sweep_scan # noqa: E402 --speed のときだけ _send_and_wait_arrival の SPEED をその間だけ替える (依頼 176) import waypoint_replay as wr # noqa: E402 from camera_align import ( # noqa: E402 FRAMING_MAX_DX, FRAMING_MAX_DY, FRAMING_MIN_RESPONSE, framing_verdict, load_reference, measure_framing, @@ -199,6 +213,16 @@ SETTLE_WAIT_SEC = 0.8 # 止まらなくてもここで待つのをや # --state-from-target で「直前に送った目標」を渡すのをやめる差 (LOG359). # 腕がどこかに当たって止まっているときに, 目標だけが先へ進むのを防ぐ. STATE_TARGET_MAX_GAP_DEG = 6.0 +# ---- 中継点を止まらずに流す (--flow. 依頼 176) ---- +CHUNK_SPEED = SPEED # 推論のチャンクを送る速さ (--speed. 既定 20 = 今までと同じ. 補正・巻き戻し・HOME は SPEED のまま) +SPEED_RANGE = (1, 100) # --speed に受ける値 (send_angles の速さの範囲) +FLOW_TOL_DEFAULT = 5.0 # 途中の点にこれだけ近づいたら次を送る (度). 中継点 1 つの動きは 3〜9° (193254) なので半分ほど +FLOW_MIN_INTERVAL_SEC = 0.4 # 途中の点を送ってから次を送るまでの下限. 0.1 秒ごとの連打は DAY287 以前に無視された. + # 193254 の単発の送り間隔 (どれも着いた) の最短が 0.40 秒 +FLOW_MAX_WAIT_SEC = 1.5 # 見込みの時間の上限 (近づかなくてもここで次を送る) +FLOW_START_SEC = 0.15 # 送ってから動き始めるまで (193254 で 0.13〜0.14 秒) +FLOW_DEG_PER_SEC_AT_20 = 25.0 # speed 20 で動いている間の速さ (お手本 deep_even10_v1 の中央 25.6°/秒). speed に比例すると見込む +FLOW_POLL_SEC = 0.1 # 待つ間に関節角を読む間隔 (読む 1 回に 0.1 秒ほどかかる) DATA_ROOT = Path("/Volumes/KIOXIA/r2r2r-data") LOG_ROOT = DATA_ROOT / "runs" / "pi05_policy" RECORDER = ("127.0.0.1", 5556) @@ -412,7 +436,7 @@ def settle_target(target, label, tol, retries): retries は **settle で送る送信回数の上限** (codex A5). 送り直しは _send_and_wait_arrival ではなく, その中で使っている 1 回だけ送る層 - daemon_send_angles(..., speed=SPEED, wait=SEND_WAIT) を直接呼ぶ. + daemon_send_angles(..., speed=CHUNK_SPEED, wait=SEND_WAIT) を直接呼ぶ (速さはチャンクと同じ --speed. 依頼 176). 中で再送しないので送信回数を正確に数えられる (上限を超えない). 送ったあとは read_until_still() で止まるのを待ってから測る. チャンク本体の送信は今までどおり _send_and_wait_arrival のまま. @@ -456,7 +480,7 @@ def settle_target(target, label, tol, retries): "sent": True, "still": None, "max_err_after": None, "actual": None} sends += 1 try: - daemon_send_angles(tgt.tolist(), speed=SPEED, wait=SEND_WAIT) + daemon_send_angles(tgt.tolist(), speed=CHUNK_SPEED, wait=SEND_WAIT) except Exception as e: entry["sent"] = False entry["error"] = f"{type(e).__name__}: {e}" @@ -499,6 +523,66 @@ def settle_target(target, label, tol, retries): return out, sends +def send_chunk_arrival(target, tag, observer=None): + """推論のチャンクの 1 点を送って 3° の到着を待つ (_send_and_wait_arrival. 依頼 176). + 速さが今までと同じ (CHUNK_SPEED == SPEED) なら今までと同じ呼び方. --speed で違うときだけ, + _send_and_wait_arrival が使う j0_sweep_scan.SPEED をこの 1 回の間だけ替えて戻す (送り方・再送・判定は同じ). + observer は --flow のときだけ渡す (送った時刻と着いた時刻を受け取る).""" + kw = {} if observer is None else {"observer": observer} + if CHUNK_SPEED == SPEED: + return _send_and_wait_arrival(target, tag, 3.0, send_wait_sec=SEND_WAIT, **kw) + old = j0_sweep_scan.SPEED + j0_sweep_scan.SPEED = CHUNK_SPEED + try: + return _send_and_wait_arrival(target, tag, 3.0, send_wait_sec=SEND_WAIT, **kw) + finally: + j0_sweep_scan.SPEED = old + + +def flow_expect_sec(max_delta_deg, speed): + """--flow で途中の点を送ってから次を送るまでの見込みの時間 (依頼 176). + 動き始めるまで FLOW_START_SEC + 一番大きく動く関節の角度 ÷ 速さ (speed 20 で FLOW_DEG_PER_SEC_AT_20, speed に比例). + FLOW_MIN_INTERVAL_SEC より短くせず, FLOW_MAX_WAIT_SEC より長くしない.""" + rate = FLOW_DEG_PER_SEC_AT_20 * float(speed) / float(SPEED) + est = FLOW_START_SEC + abs(float(max_delta_deg)) / rate + return min(FLOW_MAX_WAIT_SEC, max(FLOW_MIN_INTERVAL_SEC, est)) + + +def flow_wait(target, t_send, expect_s, tol, read_fn=None): + """--flow: 途中の点を送ったあと, 次の点を送ってよくなるまで関節角を読みながら待つ (依頼 176. 送らない・止めない). + + 次へ進むのは (送ってから FLOW_MIN_INTERVAL_SEC がたっている) かつ + near: 最後に読めた角度が target から tol 度以内 / time: 送ってから expect_s 秒たった + 読めない回は数えるだけ (古い値で near にしない). 戻り値は log.jsonl の中継点の flow に入れる dict と, + 最後に読めた角度 (ndarray or None) と読んだ時刻.""" + read_fn = read_fn or read_angles_once + tgt = np.asarray(target, dtype=float)[:6] + reads = fails = 0 + err = last = last_t = None + while True: + a = read_fn() + now = time.time() + if a is None or not wr._is_valid_angles(a): + fails += 1 + err = None # 読めなかった回は near にしない (前の値で決めない) + else: + reads += 1 + last, last_t = np.asarray([float(x) for x in a[:6]]), now + err = float(np.max(np.abs(tgt - last))) + el = now - t_send + if el >= FLOW_MIN_INTERVAL_SEC and err is not None and err <= tol: + advance = "near" + break + if el >= expect_s: + advance = "time" + break + time.sleep(FLOW_POLL_SEC) + info = {"t_send": t_send, "t_next": now, "wait_s": round(now - t_send, 3), "advance": advance, + "expect_s": round(float(expect_s), 3), "tol": tol, + "err_deg": None if err is None else round(err, 2), "reads": reads, "read_fails": fails} + return info, last, last_t + + def note_close_value(value): """最後に送った閉じる値を覚える (締め直し r が次に送る値を決める. 依頼 152).""" global LAST_CLOSE_VALUE @@ -1197,6 +1281,25 @@ def apply_grip_args(args): f"締め直し r も {GRIP_VALUE} のまま (0 より下にしないので値を変えられない)")) +def apply_flow_args(args): + """--flow / --flow-tol / --speed を確かめて CHUNK_SPEED へ入れる (依頼 176). 送り方の 1 行を出す.""" + global CHUNK_SPEED + if not (SPEED_RANGE[0] <= args.speed <= SPEED_RANGE[1]): + sys.exit(f"[ERROR] --speed は {SPEED_RANGE[0]}〜{SPEED_RANGE[1]} の整数で指定する (指定: {args.speed})") + if not np.isfinite(args.flow_tol) or args.flow_tol <= 0: + sys.exit(f"[ERROR] --flow-tol は 0 より大きい数で指定する (指定: {args.flow_tol})") + CHUNK_SPEED = int(args.speed) + sp = f"速さ {CHUNK_SPEED}" + (" (既定)" if CHUNK_SPEED == SPEED else f" (--speed. 補正・巻き戻し・HOME は {SPEED} のまま)") + if not args.flow: + if CHUNK_SPEED != SPEED: # 既定 (--flow なし・速さ 20) では何も出さない (今までと同じ出力. codex R1) + print(f"[FLOW ] 中継点ごとに 3° の到着を待つ (今までどおり) {sp}") + elif args.via_stride <= 0: + print(f"[FLOW ] --flow だが --via-stride 0 なので途中の点がない (1 点を送って到着を待つ) {sp}") + else: + print(f"[FLOW ] --flow: 途中の点は {args.flow_tol:.1f}° 以内に近づくか見込みの時間で次を送る " + f"(間隔 {FLOW_MIN_INTERVAL_SEC:.1f}〜{FLOW_MAX_WAIT_SEC:.1f} 秒). 最後の点は 3° の到着を待つ {sp}") + + def decide_tilt_fix(frames, tilt_dir: Path, enabled: bool) -> dict: """始めの数コマ (生の画像) から, AI に渡す画像を回す角度を決める (依頼 144. 落ちない). @@ -1295,11 +1398,20 @@ def main(): ap.add_argument("--grip-value", type=int, default=None, help=f"爪の閉じる値 (既定 {GRIP_VALUE_DEFAULT}. 推論・補正の g / r / R・巻き戻し・ゲームパッドの閉じる指令に使う. " "依頼 152)") + ap.add_argument("--flow", action="store_true", + help="中継点 (--via-stride) の途中の点は 3° に入るまで待たず, 近づいたか見込みの時間がたったら次を送る. " + "チャンクの最後の点は今までどおり到着を確かめる (既定 off = 今までどおり. 依頼 176)") + ap.add_argument("--flow-tol", type=float, default=FLOW_TOL_DEFAULT, + help=f"--flow で途中の点にこれだけ近づいたら次を送る (度. 既定 {FLOW_TOL_DEFAULT:.0f}. " + f"送る間隔は {FLOW_MIN_INTERVAL_SEC:.1f} 秒より短くしない)") + ap.add_argument("--speed", type=int, default=SPEED, + help=f"推論のチャンクを送る速さ (既定 {SPEED} = 今までと同じ. 補正・巻き戻し・HOME は {SPEED} のまま. 依頼 176)") args = ap.parse_args() if args.dry_keys and (args.execute or args.auto): sys.exit("[ERROR] --dry-keys はドライラン用 (--execute / --auto と一緒には使えない)") apply_wait_args(args) apply_grip_args(args) + apply_flow_args(args) if not DATA_ROOT.exists(): sys.exit(f"[ERROR] SSD 未マウント: {DATA_ROOT}") @@ -1321,7 +1433,8 @@ def main(): log_f.write(json.dumps({"type": "model", "model": args.model, "raw_dir": str(args.raw_dir), "framing_raw_dir": str(framing_raw_dir(args)), "tilt_raw_dir": str(tilt_raw_dir(args)), "tilt_fix": not args.no_tilt_fix, - "grip_value": GRIP_VALUE, "host": args.host, "port": args.port, "t": time.time()}, + "grip_value": GRIP_VALUE, "flow": bool(args.flow), "flow_tol": args.flow_tol, + "speed": CHUNK_SPEED, "host": args.host, "port": args.port, "t": time.time()}, ensure_ascii=False) + "\n") log_f.flush() @@ -1724,6 +1837,7 @@ def main(): grip_opened = True rec["initial_gripper_open"] = True broke, final_target, final_sent, sent_any = False, None, False, False + flow_prev = None # --flow: 直前に送った途中の点の flow (次を実際に送った時刻を足す. 依頼 176) for vi, v in enumerate(plan): v_last = vi == len(plan) - 1 tag = (f"pi05_chunk{i:03d}" if args.via_stride <= 0 @@ -1732,6 +1846,7 @@ def main(): if args.via_stride > 0: # 送る直前に実測角を読み, そこから apply_limits と check_send_safe を # かけ直す (codex A2: 1 点だけ送る従来の方式と同じ基準にそろえる). + # --flow でも同じ (待つ間に読んだ値は使わない. 依頼 176 codex R1) qa = read_angles() if qa is None: print(" [WARN] 送る直前の関節角を読めない. " @@ -1761,15 +1876,65 @@ def main(): print(f" [VIA ] step {v['step']:2d} Δ=" + " ".join(f"{d:+5.1f}" for d in vdelta) + " 送らず (0.5° 以下)") continue - ok, retried = _send_and_wait_arrival(tgt.tolist(), tag, 3.0, send_wait_sec=SEND_WAIT) - sent_any = True - sent_targets.append(np.asarray(tgt, dtype=float).copy()) - if args.via_stride > 0: - rec["vias"][vi].update(called=True, success=bool(ok), retried=bool(retried), - actual_after=_fmt6(read_angles())) + # 前の途中の点の flow に「次を実際に送った時刻」を足す (送った瞬間に. 依頼 176 codex R1・R2) + prev_fl, flow_prev = flow_prev, None + + def mark_next_sent(ts, prev_fl=prev_fl): + if prev_fl is not None and "t_next_sent" not in prev_fl: + prev_fl["t_next_sent"] = ts + prev_fl["send_gap_s"] = round(ts - prev_fl["t_send"], 3) + if args.flow and args.via_stride > 0 and not v_last: + # --flow の途中の点 (依頼 176): 単発の send_angles を 1 回送り, 着いたかは見ずに + # 近づいたか見込みの時間がたったら次の点へ (送る間隔は FLOW_MIN_INTERVAL_SEC 以上) + t_send = time.time() + mark_next_sent(t_send) + try: + daemon_send_angles(tgt.tolist(), speed=CHUNK_SPEED, wait=SEND_WAIT) + ok = True + except Exception as e: + print(f" [WARN] {tag} の送信に失敗: {type(e).__name__}: {e}") + ok = False + sent_any = True + sent_targets.append(np.asarray(tgt, dtype=float).copy()) + if ok: + fl, seen_q, _seen_t = flow_wait(tgt, t_send, flow_expect_sec(np.max(np.abs(vdelta)), + CHUNK_SPEED), args.flow_tol) + flow_prev = fl + else: + fl = {"t_send": t_send, "t_next": time.time(), "advance": "send_failed"} + fl["wait_s"] = round(fl["t_next"] - t_send, 3) + rec["vias"][vi].update(called=True, success=None if ok else False, retried=False, + actual_after=_fmt6(seen_q) if ok else None, flow=fl) + how = {"near": f"近づいた (残り {fl.get('err_deg')}°)", "time": "見込みの時間がたった" + + ("" if fl.get("err_deg") is None else f" (残り {fl['err_deg']}°)"), + "send_failed": "送れなかった"}[fl["advance"]] print(f" [VIA ] step {v['step']:2d} Δ=" + " ".join(f"{d:+5.1f}" for d in vdelta) - + (" 着いた" if ok else " 未到達")) + + f" 流した {fl['wait_s']:.2f} 秒で次へ: {how}") + else: + flow_obs = None + if args.flow and args.via_stride > 0: + # 最後の点 (--flow): 送った時刻と着いた時刻を残す (送り方は今までと同じ) + fl = {"advance": "not_arrived", "t_send": None, "t_next": None, "wait_s": None} + + def flow_obs(ts_send, ts_arrival, attempt, arrived, fl=fl): + mark_next_sent(ts_send) # 1 回目に送った時刻 (送る前の読み取りのあと) + fl.update(t_send=fl["t_send"] or ts_send, attempt=attempt, + advance="arrived" if arrived else "not_arrived", + t_next=ts_arrival if arrived else time.time()) + if fl["t_send"] is not None: + fl["wait_s"] = round(fl["t_next"] - fl["t_send"], 3) + ok, retried = send_chunk_arrival(tgt.tolist(), tag, observer=flow_obs) + sent_any = True + sent_targets.append(np.asarray(tgt, dtype=float).copy()) + if args.via_stride > 0: + rec["vias"][vi].update(called=True, success=bool(ok), retried=bool(retried), + actual_after=_fmt6(read_angles())) + if flow_obs is not None: + rec["vias"][vi]["flow"] = fl + print(f" [VIA ] step {v['step']:2d} Δ=" + + " ".join(f"{d:+5.1f}" for d in vdelta) + + (" 着いた" if ok else " 未到達")) if v_last: rec["arrived"] = bool(ok) final_sent = True diff --git a/pi05/test_chunk_timing.py b/pi05/test_chunk_timing.py new file mode 100644 index 0000000..3e046f7 --- /dev/null +++ b/pi05/test_chunk_timing.py @@ -0,0 +1,195 @@ +#!/usr/bin/env python3 +"""test_chunk_timing.py — chunk_timing.py と policy_warmup.py の確かめ (依頼 176. アームなし・サーバーなし). + + python3 pi05/test_chunk_timing.py # 全部 + python3 pi05/test_chunk_timing.py -v + +中身: + - chunk_timing: 作った log.jsonl で 推論・確認待ち・動いた・その他・合計 と合計・中央値を出す. --flow の試行は + 中継点ごとの待ち (vias[].flow), そうでない試行は states.csv の送った時刻から. 何も書き出さない + - policy_warmup: お手本の 1 枚目と state[0] で観測を作る. 答えれば終了コード 0 と [WARM ] の秒, + つながらない・落ちる・答えない (--timeout) は終了コード 1 と [WARM ] の 1 行 +一時フォルダだけを使う. +""" +import io +import json +import sys +import tempfile +import time +import unittest +from pathlib import Path +from unittest import mock + +import cv2 +import numpy as np + +_HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(_HERE)) + +import chunk_timing as ct # noqa: E402 +import policy_warmup as pw # noqa: E402 + +T0 = 1794566000.0 + + +def chunk(i, start, latency, exec_start=None, exec_end=None, vias=None, **kw): + r = {"chunk": i, "t": start + latency, "latency_s": latency, "executed": exec_start is not None} + if exec_start is not None: + r.update(t_exec_start=exec_start, t_exec_end=exec_end) + if vias is not None: + r["vias"] = vias + r.update(kw) + return r + + +def write_run(d: Path, lines, sends=None): + d.mkdir(parents=True) + (d / "log.jsonl").write_text("".join(json.dumps(x) + "\n" for x in lines)) + if sends is not None: + (d / "recording").mkdir() + rows = ["ts,event_type,stage,j0,j1,j2,j3,j4,j5,speed,gripper_state,ts_send,ts_arrival,attempt,arrived,note"] + rows += [f"{t:.6f},send_angles,model,0,0,0,0,0,-30,20,,{t:.6f},,,,rpc_sec=0.1" for t in sends] + rows += [f"{T0:.6f},actual,model,0,0,0,0,0,-30,,,,,,,"] + (d / "recording" / "states.csv").write_text("\n".join(rows) + "\n") + + +def flow_via(step, t_send, wait, adv): + return {"step": step, "called": True, "flow": {"t_send": t_send, "t_next": t_send + wait, "wait_s": wait, + "advance": adv}} + + +class TestChunkTiming(unittest.TestCase): + def setUp(self): + self.td = Path(tempfile.mkdtemp()) + + def run_main(self, *dirs): + before = sorted(p for p in self.td.rglob("*")) + with mock.patch("sys.stdout", new=io.StringIO()) as out: + code = ct.main([str(d) for d in dirs]) + self.assertEqual(sorted(p for p in self.td.rglob("*")), before) # 何も書き出さない + return code, out.getvalue() + + def test_plain_run_uses_states_csv(self): + d = self.td / "pi05_20261113_000001" + write_run(d, [{"type": "model", "model": "m", "grip_value": 25, "t": T0}, + chunk(0, T0, 50.0, T0 + 60.0, T0 + 63.0, initial_gripper_open=True), + chunk(1, T0 + 63.5, 1.0, T0 + 65.0, T0 + 67.0), + chunk(2, T0 + 67.2, 0.5, home_requested=True)], + sends=[T0 + 61.0, T0 + 61.5, T0 + 62.0, T0 + 65.0, T0 + 66.0]) + rows = ct.chunk_rows(ct.load_log(d)[1]) + self.assertAlmostEqual(rows[0]["infer"], 50.0) + self.assertAlmostEqual(rows[0]["confirm"], 10.0) + self.assertAlmostEqual(rows[0]["moved"], 3.0) + self.assertAlmostEqual(rows[0]["total"], 63.5) + self.assertAlmostEqual(rows[0]["other"], 0.5) + self.assertAlmostEqual(rows[1]["total"], 3.7) + self.assertIsNone(rows[2]["moved"]) + waits, src = ct.via_waits(ct.load_log(d)[1][0], ct.load_sends(d)) + self.assertEqual(src, "states") + np.testing.assert_allclose([w for _, w, _ in waits], [0.5, 0.5, 1.0]) + code, out = self.run_main(d) + self.assertEqual(code, 0) + self.assertIn("記録なし (依頼 176 より前", out) + self.assertIn("1 回目 50.00 秒", out) + self.assertIn("始めに爪を開いた", out) + self.assertIn("HOME", out) + + def test_flow_run_and_compare(self): + a = self.td / "pi05_20261113_000002" + write_run(a, [{"type": "model", "flow": True, "flow_tol": 5.0, "speed": 30, "t": T0}, + chunk(0, T0, 1.0, T0 + 1.5, T0 + 3.0, + vias=[flow_via(2, T0 + 1.5, 0.41, "near"), flow_via(5, T0 + 1.91, 0.6, "time"), + {"step": 8, "called": False}, flow_via(9, T0 + 2.6, 0.3, "arrived")]), + chunk(1, T0 + 3.1, 0.6)]) + b = self.td / "pi05_20261113_000003" + write_run(b, [{"type": "model", "flow": False, "flow_tol": 5.0, "speed": 20, "t": T0}, + chunk(0, T0, 1.0, T0 + 1.5, T0 + 4.0), chunk(1, T0 + 4.1, 0.6)]) + code, out = self.run_main(a, b) + self.assertEqual(code, 0) + self.assertIn("--flow (近づく 5.0°)", out) + self.assertIn("2:0.41近 5:0.60時 8:-送らず 9:0.30着", out) + self.assertIn("== 比べる (秒)", out) + self.assertIn("flow", out.split("== 比べる")[1]) + self.assertIn("今まで", out.split("== 比べる")[1]) + + def test_missing_dir(self): + with mock.patch("sys.stdout", new=io.StringIO()) as out: + self.assertEqual(ct.main([str(self.td / "nothing")]), 1) + self.assertIn("log.jsonl がない", out.getvalue()) + + +class FakePolicy: + calls = [] + mode = "ok" + + def __init__(self, host, port, wait_sec=60.0): + if FakePolicy.mode == "refused": + raise ConnectionRefusedError("refused") + if FakePolicy.mode == "hang_connect": # つないだが metadata が来ない (codex R1) + time.sleep(5) + self.closed = False + + def infer(self, obs): + FakePolicy.calls.append(obs) + if FakePolicy.mode == "error": + raise RuntimeError("ポリシーサーバー側のエラー:\nTraceback ...\n ValueError: bad") + if FakePolicy.mode == "hang": + time.sleep(5) + return {"actions": np.zeros((10, 7))} + + def close(self): + self.closed = True + + +class TestWarmup(unittest.TestCase): + def setUp(self): + self.td = Path(tempfile.mkdtemp()) + ep = self.td / "raw" / "ep_b" + (ep / "frames").mkdir(parents=True) + cv2.imwrite(str(ep / "frames" / "000000.jpg"), np.full((216, 384, 3), 80, np.uint8)) + st = np.arange(14, dtype=np.float32).reshape(2, 7) + np.savez(ep / "episode.npz", state=st, actions=st) + FakePolicy.calls = [] + + def run_main(self, mode, extra=()): + FakePolicy.mode = mode + with mock.patch.object(pw, "PolicyClient", FakePolicy), \ + mock.patch("sys.stdout", new=io.StringIO()) as out: + code = pw.main(["--raw-dir", str(self.td / "raw")] + list(extra)) + return code, out.getvalue() + + def test_ok(self): + code, out = self.run_main("ok") + self.assertEqual(code, 0) + self.assertRegex(out, r"\[WARM \] 空打ち [0-9.]+ 秒") + obs = FakePolicy.calls[0] + self.assertEqual(obs["observation/image"].shape, (216, 384, 3)) + self.assertEqual(obs["observation/state"].dtype, np.float32) + np.testing.assert_allclose(obs["observation/state"], np.arange(7)) + self.assertEqual(obs["prompt"], "put the red block in the white box") + + def test_failures_return_1(self): + for mode in ("refused", "error"): + code, out = self.run_main(mode) + self.assertEqual(code, 1, mode) + fail = [x for x in out.splitlines() if "空打ちに失敗" in x] + self.assertEqual(len(fail), 1, out) # 失敗は 1 行 (改行を含むエラーも 1 行に) + self.assertIn("続けます", fail[0]) + self.assertEqual(len(out.splitlines()), 2, out) # 始めの 1 行 + 失敗の 1 行 + for mode in ("hang", "hang_connect"): # つないだあと metadata が来ないときも止まらない + t0 = time.time() + code, out = self.run_main(mode, ["--timeout", "0.5"]) + self.assertEqual(code, 1, mode) + self.assertLess(time.time() - t0, 3.0, mode) + self.assertIn("答えない", out) + + def test_no_episode(self): + with mock.patch.object(pw, "PolicyClient", FakePolicy), \ + mock.patch("sys.stdout", new=io.StringIO()) as out: + code = pw.main(["--raw-dir", str(self.td / "none")]) + self.assertEqual(code, 1) + self.assertIn("お手本のエピソードがない", out.getvalue()) + + +if __name__ == "__main__": + unittest.main() diff --git a/pi05/test_flow_send.py b/pi05/test_flow_send.py new file mode 100644 index 0000000..e66cee3 --- /dev/null +++ b/pi05/test_flow_send.py @@ -0,0 +1,359 @@ +#!/usr/bin/env python3 +"""test_flow_send.py — 中継点を止まらずに流す (--flow) と --speed の確かめ (依頼 176. アームなし). + + python3 pi05/test_flow_send.py # 全部 + python3 pi05/test_flow_send.py -v + +中身: + - flow_expect_sec (見込みの時間) と flow_wait (近づいた / 時間がたった / 読めない回 / 送る間隔の下限) + - run_policy_client を, 時間とともに目標へ動く偽の daemon で通す: + --flow なし: 中継点はどれも _send_and_wait_arrival (3° の到着を待つ). 途中の点を daemon_send_angles で送らない. + 中継点の記録に flow がない + --flow: 途中の点は daemon_send_angles を 1 回ずつ送り, 着くのを待たずに次へ (間隔は 0.4 秒以上). + 最後の点だけ _send_and_wait_arrival. 中継点ごとに送った時刻・次を送った時刻を残す + --speed 30: 途中の点は speed=30. 最後の点の _send_and_wait_arrival の間だけ j0_sweep_scan.SPEED が 30 (終われば 20) + log.jsonl の頭 (type=model) に flow・flow_tol・speed + - --flow なしで今までと同じ送り方・同じ log になることは test_rewind_correct.py の test_unchanged_without_b_c + (git HEAD の版と比べる) で見る +KIOXIA にもアームにも触らない (一時フォルダだけ). +""" +import builtins +import io +import json +import sys +import tempfile +import threading +import time +import unittest +from pathlib import Path +from unittest import mock + +import numpy as np + +_HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(_HERE)) + +import run_policy_client as rpc # noqa: E402 +from test_rewind_correct import FakeCap, FakePolicy # noqa: E402 + + +class MovingArm: + """送られた目標へ rate 度/秒で (一番大きく動く関節に合わせて) 動く偽のアーム. + + daemon_send_angles: その時の位置から新しい目標へ動き始める (待たない) + send_wait (_send_and_wait_arrival の代わり): 送って, 着くまで待ってから (True, False). observer に時刻を渡す + """ + + def __init__(self, rate=25.0): + self.rate = rate + self.lock = threading.Lock() + self.start = np.array([0.0, 0, 0, 0, 0, -30]) + self.goal = self.start.copy() + self.t0 = time.time() + self.fast_sends = [] # (時刻, 目標, speed) daemon_send_angles + self.wait_sends = [] # (時刻, ラベル, 目標, その時の j0_sweep_scan.SPEED) _send_and_wait_arrival + + def pos(self, now=None): + now = time.time() if now is None else now + with self.lock: + d = self.goal - self.start + m = float(np.max(np.abs(d))) + if m <= 1e-9: + return self.goal.copy() + f = min(1.0, (now - self.t0) * self.rate / m) + return self.start + d * f + + def _go(self, target): + now = time.time() + p = self.pos(now) + with self.lock: + self.start, self.goal, self.t0 = p, np.asarray(target, dtype=float)[:6].copy(), now + + fail_reads = False # True の間は読めない (None) + + def get_angles(self, *a, **k): + if self.fail_reads: + return None + return [float(v) for v in self.pos()] + + def send_angles(self, angles, speed=20, wait=0, *a, **k): + self.fast_sends.append((time.time(), [round(float(v), 3) for v in angles], speed)) + self._go(angles) + return {"ok": True, "elapsed_ms": 1.0} + + def send_wait(self, target, label, tol, *a, observer=None, **k): + ts = time.time() + self.wait_sends.append((ts, label, [round(float(v), 3) for v in target], rpc.j0_sweep_scan.SPEED)) + self._go(target) + while float(np.max(np.abs(self.pos() - np.asarray(target, dtype=float)))) > tol: + time.sleep(0.01) + if observer is not None: + observer(ts, time.time(), 1, True) + return True, False + + +def run_flow(argv, td, arm, inputs=()): + raw = td / "raw" + if not raw.exists(): + (raw / "ep0").mkdir(parents=True) + st = np.zeros((20, 7), np.float32) + st[:, 0] = np.linspace(-40, 40, 20); st[:, 1] = np.linspace(0, 60, 20) + st[:, 4] = np.linspace(-80, 0, 20); st[:, 5] = -30 + np.savez(raw / "ep0" / "episode.npz", state=st, actions=st) + log_root = td / "runs" + it = iter(inputs) + patches = [ + mock.patch.object(rpc, "DATA_ROOT", td), mock.patch.object(rpc, "LOG_ROOT", log_root), + mock.patch.object(rpc.camera_resolver, "resolve_cameras", lambda **k: {"top": 0}), + mock.patch.object(rpc.cv2, "VideoCapture", FakeCap), + mock.patch.object(rpc, "load_reference", lambda p: (np.zeros((216, 384, 3), np.uint8), "ref")), + mock.patch.object(rpc, "measure_framing", lambda a, b: (0.0, 0.0, 0.9)), + mock.patch.object(rpc, "PolicyClient", FakePolicy), + mock.patch.object(rpc, "get_daemon_socket", lambda *a, **k: None), + mock.patch.object(rpc, "close_daemon_socket", lambda *a, **k: None), + mock.patch.object(rpc, "daemon_get_angles", arm.get_angles), + mock.patch.object(rpc, "daemon_send_angles", arm.send_angles), + mock.patch.object(rpc, "daemon_set_gripper", lambda *a, **k: None), + mock.patch.object(rpc, "daemon_set_gripper_value", lambda *a, **k: None), + mock.patch.object(rpc, "_send_and_wait_arrival", arm.send_wait), + mock.patch.object(rpc, "GRIPPER_SLEEP", 0.0), + mock.patch.object(builtins, "input", lambda *a: next(it)), + mock.patch.object(sys, "argv", ["run_policy_client.py", "--raw-dir", str(raw)] + list(argv)), + ] + for p in patches: + p.start() + try: + with mock.patch("sys.stdout", new=io.StringIO()) as out: + code = rpc.main() + finally: + for p in reversed(patches): + p.stop() + run = sorted(log_root.glob("pi05_*"))[-1] + lines = [json.loads(x) for x in (run / "log.jsonl").read_text().splitlines()] + return code, lines, out.getvalue() + + +BASE = ["--execute", "--auto", "--steps-per-chunk", "10", "--via-stride", "3", "--settle-retries", "0", + "--ignore-framing", "--max-chunks", "2"] + + +class TestFlowParts(unittest.TestCase): + def test_expect_sec(self): + self.assertAlmostEqual(rpc.flow_expect_sec(0.5, 20), rpc.FLOW_MIN_INTERVAL_SEC) # 下限 + self.assertAlmostEqual(rpc.flow_expect_sec(10.0, 20), 0.15 + 10.0 / 25.0) + self.assertAlmostEqual(rpc.flow_expect_sec(15.0, 30), 0.15 + 15.0 / 37.5) # speed に比例 + self.assertAlmostEqual(rpc.flow_expect_sec(200.0, 20), rpc.FLOW_MAX_WAIT_SEC) # 上限 + + def test_wait_near_respects_floor(self): + """着いていても送ってから 0.4 秒たつまでは次へ進まない.""" + t0 = time.time() + fl, q, tq = rpc.flow_wait([1, 0, 0, 0, 0, -30], t0, 1.0, 5.0, read_fn=lambda: [1, 0, 0, 0, 0, -30]) + self.assertEqual(fl["advance"], "near") + self.assertGreaterEqual(fl["wait_s"], rpc.FLOW_MIN_INTERVAL_SEC) + self.assertLess(fl["wait_s"], rpc.FLOW_MIN_INTERVAL_SEC + 0.3) + self.assertEqual(fl["err_deg"], 0.0) + np.testing.assert_allclose(q, [1, 0, 0, 0, 0, -30]) + + def test_wait_time_when_far(self): + t0 = time.time() + fl, q, _ = rpc.flow_wait([30, 0, 0, 0, 0, -30], t0, 0.6, 5.0, read_fn=lambda: [0, 0, 0, 0, 0, -30]) + self.assertEqual(fl["advance"], "time") + self.assertGreaterEqual(fl["wait_s"], 0.6) + self.assertEqual(fl["err_deg"], 30.0) + + def test_wait_failed_reads_are_not_near(self): + """読めない回は near にしない (時間で進む). 読めた角度もない.""" + t0 = time.time() + fl, q, tq = rpc.flow_wait([0, 0, 0, 0, 0, -30], t0, 0.5, 5.0, read_fn=lambda: None) + self.assertEqual(fl["advance"], "time") + self.assertIsNone(fl["err_deg"]) + self.assertIsNone(q) + self.assertEqual(fl["reads"], 0) + self.assertGreater(fl["read_fails"], 0) + + +class TestFlowClient(unittest.TestCase): + def setUp(self): + self.td = Path(tempfile.mkdtemp()) + time.sleep(1.1) # run のフォルダ名は秒単位なので重ならないように + + def tearDown(self): + rpc.CHUNK_SPEED = rpc.SPEED + self.assertEqual(rpc.j0_sweep_scan.SPEED, 20) # 替えた速さが残っていない + + def test_without_flow_waits_every_via(self): + arm = MovingArm(rate=200.0) + code, lines, out = run_flow(BASE, self.td, arm) + self.assertEqual(code, 0) + self.assertEqual(arm.fast_sends, []) # 途中の点を待たずに送ることはない + self.assertEqual([s[1] for s in arm.wait_sends[:4]], + ["pi05_chunk000_via02", "pi05_chunk000_via05", "pi05_chunk000_via08", "pi05_chunk000_via09"]) + self.assertTrue(all(s[3] == 20 for s in arm.wait_sends)) + model = lines[0] + self.assertEqual((model["type"], model["flow"], model["flow_tol"], model["speed"]), + ("model", False, rpc.FLOW_TOL_DEFAULT, 20)) + ch = [x for x in lines if x.get("type") is None and "chunk" in x] + self.assertTrue(all("flow" not in v for x in ch for v in x["vias"])) + self.assertNotIn("[FLOW ]", out) # 既定では今までと同じ出力 (何も足さない) + + def test_flow_does_not_wait_for_mid_vias(self): + """遅いアーム (5°/秒) で途中の点が 3° に入る前に次を送る. 最後の点だけ到着を待つ.""" + arm = MovingArm(rate=5.0) + code, lines, out = run_flow(BASE + ["--flow", "--flow-tol", "0.5", "--max-chunks", "1"], self.td, arm) + self.assertEqual(code, 0) + self.assertEqual([s[1] for s in arm.fast_sends], [[3.0, 1.5, 0.0, 0.0, 0.0, -30.0], + [6.0, 3.0, 0.0, 0.0, 0.0, -30.0], + [9.0, 4.5, 0.0, 0.0, 0.0, -30.0]]) + self.assertEqual([s[1] for s in arm.wait_sends], ["pi05_chunk000_via09"]) + times = [s[0] for s in arm.fast_sends] + [arm.wait_sends[0][0]] + gaps = np.diff(times) + self.assertTrue(np.all(gaps >= rpc.FLOW_MIN_INTERVAL_SEC - 1e-3), gaps) # 送る間隔の下限 + self.assertTrue(np.all(gaps < rpc.FLOW_MIN_INTERVAL_SEC + 0.25), gaps) # 見込みの時間 (下限 0.4 秒) で次へ + ch = [x for x in lines if x.get("type") is None and "chunk" in x][0] + mids, last = ch["vias"][:3], ch["vias"][3] + for v in mids: + self.assertEqual(v["flow"]["advance"], "time") # 0.5° には近づかないので見込みの時間で進む + self.assertIsNone(v["success"]) # 着いたかは見ていない + self.assertTrue(v["called"]) + self.assertGreater(v["flow"]["t_next"], v["flow"]["t_send"]) + self.assertIsNotNone(v["flow"]["err_deg"]) + for v in mids: + self.assertGreaterEqual(v["flow"]["t_next_sent"], v["flow"]["t_next"]) # 次を実際に送った時刻 + self.assertGreaterEqual(v["flow"]["send_gap_s"], rpc.FLOW_MIN_INTERVAL_SEC - 1e-3) + # 最後の途中の点の「次を送った時刻」は, 最後の点を実際に送った時刻 (observer の ts_send) (codex R2) + self.assertEqual(mids[-1]["flow"]["t_next_sent"], last["flow"]["t_send"]) + self.assertEqual(last["flow"]["advance"], "arrived") + self.assertTrue(last["success"]) + self.assertGreaterEqual(last["flow"]["t_send"], mids[-1]["flow"]["t_next"]) + self.assertTrue(ch["arrived"] and ch["executed"]) + self.assertEqual(lines[0]["flow"], True) + self.assertEqual(lines[0]["flow_tol"], 0.5) + + def test_flow_near_with_fast_arm(self): + arm = MovingArm(rate=200.0) + code, lines, out = run_flow(BASE + ["--flow"], self.td, arm) + self.assertEqual(code, 0) + ch = [x for x in lines if x.get("type") is None and "chunk" in x] + adv = [v["flow"]["advance"] for x in ch for v in x["vias"]] + self.assertEqual(adv, ["near", "near", "near", "arrived"] * 2) + self.assertEqual(len(arm.fast_sends), 6) + self.assertEqual(len(arm.wait_sends), 2) + self.assertIn("流した", out) + + def test_speed(self): + arm = MovingArm(rate=200.0) + code, lines, out = run_flow(BASE + ["--flow", "--speed", "30", "--max-chunks", "1"], self.td, arm) + self.assertEqual(code, 0) + self.assertEqual({s[2] for s in arm.fast_sends}, {30}) + self.assertEqual([s[3] for s in arm.wait_sends], [30]) # 最後の点を送る間だけ 30 + self.assertEqual(rpc.j0_sweep_scan.SPEED, 20) + self.assertEqual(lines[0]["speed"], 30) + + def test_speed_without_flow(self): + arm = MovingArm(rate=200.0) + code, lines, out = run_flow(BASE + ["--speed", "30", "--max-chunks", "1"], self.td, arm) + self.assertEqual(code, 0) + self.assertEqual(arm.fast_sends, []) + self.assertEqual([s[3] for s in arm.wait_sends], [30, 30, 30, 30]) + + def test_speed_does_not_reach_home(self): + """--speed 30 で動かしたあとの h (HOME) は今までどおり速さ 20 (補正・巻き戻しも SPEED のまま).""" + arm = MovingArm(rate=200.0) + code, lines, out = run_flow(["--execute", "--steps-per-chunk", "10", "--via-stride", "3", + "--settle-retries", "0", "--ignore-framing", "--max-chunks", "3", + "--flow", "--speed", "30"], self.td, arm, inputs=["", "h", ""]) + self.assertEqual(code, 0) + self.assertEqual([(s[1], s[3]) for s in arm.wait_sends], [("pi05_chunk000_via09", 30), ("pi05_home", 20)]) + + def test_flow_read_failure_before_send_stops_like_before(self): + """送る直前の読み取りに失敗したら, 待つ間に読めた値を使わず, 今までどおり残りの点を送らない.""" + arm = MovingArm(rate=200.0) + calls = {"n": 0} + orig_wait = rpc.flow_wait + + def wait_then_break(*a, **k): + out = orig_wait(*a, **k) + calls["n"] += 1 + if calls["n"] == 1: + arm.fail_reads = True # 1 つ目の途中の点を待ったあとから読めない + return out + with mock.patch.object(rpc, "flow_wait", wait_then_break): + code, lines, out = run_flow(BASE + ["--flow", "--max-chunks", "1"], self.td, arm) + self.assertEqual(code, 1) # --auto では今までどおり止まる + self.assertEqual(len(arm.fast_sends), 1) + self.assertEqual(arm.wait_sends, []) + self.assertIn("送る直前の関節角を読めない", out) + + def test_next_sent_kept_from_first_attempt(self): + """最後の点が再送になっても, 前の点の「次を送った時刻」は 1 回目に送った時刻のまま (codex R3).""" + arm = MovingArm(rate=200.0) + + def retry_wait(target, label, tol, *a, observer=None, **k): + t1 = time.time() + arm.send_angles(target) + if observer is not None: + observer(t1, None, 1, False) + time.sleep(0.05) + observer(time.time(), time.time(), 2, True) + return True, True + with mock.patch.object(arm, "send_wait", retry_wait): + code, lines, out = run_flow(BASE + ["--flow", "--max-chunks", "1"], self.td, arm) + ch = [x for x in lines if x.get("type") is None and "chunk" in x][0] + mid, last = ch["vias"][2], ch["vias"][3] + self.assertEqual(mid["flow"]["t_next_sent"], last["flow"]["t_send"]) + self.assertEqual(last["flow"]["attempt"], 2) + self.assertEqual(last["flow"]["advance"], "arrived") + + def test_next_sent_absent_when_not_sent(self): + """送る直前に読めず最後の点を送らなかったら, 前の点に「次を送った時刻」は付かない.""" + arm = MovingArm(rate=200.0) + orig_wait = rpc.flow_wait + n = {"k": 0} + + def wait_then_break(*a, **k): + out = orig_wait(*a, **k) + n["k"] += 1 + if n["k"] == 3: + arm.fail_reads = True # 3 つ目の途中の点のあとから読めない + return out + with mock.patch.object(rpc, "flow_wait", wait_then_break): + code, lines, out = run_flow(BASE + ["--flow", "--max-chunks", "1"], self.td, arm) + ch = [x for x in lines if x.get("type") is None and "chunk" in x][0] + self.assertNotIn("t_next_sent", ch["vias"][2]["flow"]) + self.assertIn("t_next_sent", ch["vias"][1]["flow"]) + self.assertEqual(arm.wait_sends, []) + + def test_speed_restored_on_error(self): + def boom(*a, **k): + self.assertEqual(rpc.j0_sweep_scan.SPEED, 30) + raise RuntimeError("x") + rpc.CHUNK_SPEED = 30 + with mock.patch.object(rpc, "_send_and_wait_arrival", boom): + with self.assertRaises(RuntimeError): + rpc.send_chunk_arrival([0, 0, 0, 0, 0, -30], "t") + + def test_bad_args(self): + for argv in (["--speed", "0"], ["--speed", "101"], ["--flow-tol", "0"], ["--flow-tol", "nan"]): + with self.assertRaises(SystemExit, msg=argv): + run_flow(BASE + argv, self.td, MovingArm()) + + +class TestSettleSpeed(unittest.TestCase): + def tearDown(self): + rpc.CHUNK_SPEED = rpc.SPEED + + def test_settle_uses_chunk_speed(self): + sent = [] + reads = iter([[0, 0, 0, 0, 0, -30]] * 2 + [[5, 0, 0, 0, 0, -30]] * 2) + rpc.CHUNK_SPEED = 30 + with mock.patch.object(rpc, "read_angles", lambda: np.array(next(reads), dtype=float)), \ + mock.patch.object(rpc, "SETTLE_POLL_SEC", 0.0), \ + mock.patch.object(rpc, "daemon_send_angles", lambda a, speed, wait: sent.append(speed)), \ + mock.patch("sys.stdout", new=io.StringIO()): + out, n = rpc.settle_target([5, 0, 0, 0, 0, -30], "x", 1.0, 1) + self.assertEqual(sent, [30]) + self.assertEqual(out["reason"], "converged") + + +if __name__ == "__main__": + unittest.main() diff --git a/pi05/test_rewind_correct.py b/pi05/test_rewind_correct.py index fbe945f..ad59e3e 100644 --- a/pi05/test_rewind_correct.py +++ b/pi05/test_rewind_correct.py @@ -604,7 +604,8 @@ class TestClientFlow(unittest.TestCase): self.assertEqual(len(l_old), len(l_new)) new_keys = ("t_exec_start", "t_exec_end", "sent_targets", "framing_raw_dir", # framing_raw_dir は依頼 137 "tilt_raw_dir", "tilt_fix", "measured_on", "rotate_deg", # 依頼 144 - "grip_value") # 依頼 152 + "grip_value", # 依頼 152 + "flow", "flow_tol", "speed") # 依頼 176 (type=model の頭) # HEAD が依頼 25 より前なら new_keys は新しい方にだけある. 依頼 25 以降なら両方にある (両方から外す) drop = ("t", "latency_s", "reference") + new_keys so, sn = strip(l_old, drop=drop), strip(l_new, drop=drop) diff --git a/test_lab_start.sh b/test_lab_start.sh index e15f0bd..d3addf6 100755 --- a/test_lab_start.sh +++ b/test_lab_start.sh @@ -595,11 +595,38 @@ sleep 1 check "待っている間は終わらない" 'kill -0 $SPID 2>/dev/null' kill -TERM $SPID; wait $SPID; RC=$? check "TERM で終了コード 0" '[ $RC = 0 ]' -check "デーモン・HOME・爪・位置合わせ・推論の段に進まない (python3 を呼ばない)" '! has out.txt "=== 6." && ! has out.txt "=== 7." && ! has out.txt "=== 8." && [ ! -s "$T/py.log" ]' +check "デーモン・HOME・爪・位置合わせ・推論の段に進まない (python3 は空打ちだけ)" '! has out.txt "=== 6." && ! has out.txt "=== 7." && ! has out.txt "=== 8." && [ "$(grep -vc "^python3 pi05/policy_warmup.py " "$T/py.log")" = 0 ]' +check "--serve-only でも空打ちまで行う (依頼 176)" 'has out.txt "=== 5b. 空打ち" && [ "$(grep -c "^python3 pi05/policy_warmup.py --port 8000 --raw-dir $T/data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes$" "$T/py.log")" = 1 ] && [ $(grep -n "=== 5b. 空打ち" "$T/out.txt" | cut -d: -f1) -lt $(grep -n "\[SERVE \] --serve-only" "$T/out.txt" | cut -d: -f1) ]' check "Pod は消さない (DELETE を呼ばない) で, かかった時間と片付け方を出す" '[ $(n_call DELETE) = 0 ] && has out.txt "=== かかった時間" && has out.txt "Pod は残しています (id $ID_NEW). 片付けは ./lab_stop.sh --log LogT"' check "記録 lab_start_*.txt に残る・始めの行に --serve-only と出る" 'grep -qF "サーバーとトンネルだけ (--serve-only" "$T/data/lab/LogT"/lab_start_*.txt' rm -rf "$T" -check "--help に --serve-only・--grip-value の説明が入る (2〜54 行)" 'sed -n "2,54p" "$HERE/lab_start.sh" | grep -qF -- "--serve-only Pod を作って" && sed -n "2,54p" "$HERE/lab_start.sh" | grep -qF -- "--no-tilt-fix 傾きを" && sed -n "2,54p" "$HERE/lab_start.sh" | grep -qF -- "--grip-value N 爪の閉じる値"' +check "--help に --serve-only・--grip-value・--flow / --speed・5b の空打ちの説明が入る (2〜58 行)" 'sed -n "2,58p" "$HERE/lab_start.sh" | grep -qF -- "--serve-only Pod を作って" && sed -n "2,58p" "$HERE/lab_start.sh" | grep -qF -- "--no-tilt-fix 傾きを" && sed -n "2,58p" "$HERE/lab_start.sh" | grep -qF -- "--grip-value N 爪の閉じる値" && sed -n "2,58p" "$HERE/lab_start.sh" | grep -qF -- "--flow / --speed N run_policy_client.py に" && sed -n "2,58p" "$HERE/lab_start.sh" | grep -qF -- "# 5b. 空打ち" && grep -qF "sed -n '"'"'2,58p'"'"'" "$HERE/lab_start.sh"' + +echo "== 空打ち (依頼 176): トンネルのあと・アームの前に 1 回. 失敗しても止めずに続ける" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run +check "空打ちを安全範囲と同じお手本で 1 回呼び, そのあとで推論のクライアント" '[ "$(grep -c "^python3 pi05/policy_warmup.py --port 8000 --raw-dir $T/data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes$" "$T/py.log")" = 1 ] && [ "$(sed -n 1p "$T/py.log" | cut -d" " -f2)" = pi05/policy_warmup.py ] && [ "$(sed -n 2p "$T/py.log" | cut -d" " -f2)" = pi05/run_policy_client.py ]' +check "空打ちはトンネル (5) のあと" '[ $(grep -n "=== 5. Mac の 8000 番" "$T/out.txt" | cut -d: -f1) -lt $(grep -n "=== 5b. 空打ち" "$T/out.txt" | cut -d: -f1) ] && has out.txt "5b. 空打ち (1 回目の推論の待ちを先に済ませる)"' +check "--flow・--speed を付けなければクライアントに渡さない" '! grep -q -- "--flow\|--speed" "$T/py.log" && ! has out.txt "[FLOW ]"' +rm -rf "$T" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1 +printf '#!/bin/bash\necho "python3 $*" >> "%s/py.log"\ncase "$1" in pi05/policy_warmup.py) echo "[WARM ] 空打ちに失敗 (偽物)"; exit 1 ;; esac\n' "$T" > "$T/bin/python3" +run +check "空打ちが失敗しても終了コード 0 で推論のクライアントまで進む" '[ $RC = 0 ] && has py.log "pi05/run_policy_client.py" && has out.txt "Pod は残しています"' +check "失敗の行は空打ちが出した 1 行だけ (lab_start.sh は重ねない)" '[ "$(grep -c "^\[WARM \]" "$T/out.txt")" = 1 ] && has out.txt "[WARM ] 空打ちに失敗 (偽物)"' +rm -rf "$T" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1 +printf '#!/bin/bash\necho "python3 $*" >> "%s/py.log"\ncase "$1" in pi05/policy_warmup.py) exit 3 ;; esac\n' "$T" > "$T/bin/python3" +run +check "空打ちが何も出さずに落ちた (終了コード 3) ら lab_start.sh が 1 行出して続ける" '[ $RC = 0 ] && has py.log "pi05/run_policy_client.py" && has out.txt "[WARM ] 空打ちが終了コード 3 で終わりました. 止めずに続けます"' +rm -rf "$T" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run --flow --speed 030 +check "--flow --speed 30 をクライアントにそのまま渡す" '[ $RC = 0 ] && grep -q -- "pi05/run_policy_client.py .* --flow --speed 30$" "$T/py.log" && has out.txt "[FLOW ] 推論の送り方: --flow --speed 30"' +rm -rf "$T" +for bad in 0 101 abc 1000 ""; do + setup; run --speed "$bad" + check "--speed '$bad' は受けない (終了コード 2・API を呼ばない)" '[ $RC = 2 ] && [ ! -s "$T/calls.log" ] && has out.txt "--speed"' + rm -rf "$T" +done echo echo "OK $OK / NG $NG" ``` ## Claude の障害で、Mac への接続と Claude Code のログインが切れた 依頼176 が終わったころ、Anthropic の側で Claude の障害が起きていました。11月13日の日本時間22時ごろから、claude.ai・Claude の API・Claude Code でエラーが増え、claude.ai は大きな障害と出ていました。 この作業をしていた Claude のチャットでは、22時27分から Mac につながらなくなりました。Mac は「接続済み」と出ていて、ほかのチャットからは使えていました。チャットの作業場所を調べると、22時27分に作業場所が作り直されたあと、Mac やほかのつなぎ先へ渡す中継だけが立ち上がらず、どのつなぎ先にも同じエラーを返していました。ウェブにつなぐ道は正常でした。その夜は作業を止め、翌朝4時すぎに同じチャットからつなぎ直すと、Mac に届くようになっていました。 ただ、依頼箱に入れた依頼177は、始まってすぐ止まりました。Mac の Claude Code のログインが切れていたためです。 ### 依頼177 の1回目（04:18）の結果 ```markdown # 結果：20261114_177_実機推論の確かめのEnterを1回目だけにする - 状態：失敗 - 始めた時刻：2026-11-14 04:18 - 終わった時刻：2026-11-14 04:18（0分） - 作業フォルダ：/Users/shimazueiichi/r2r2r-scripts - この続きを Claude Code で話すとき：作業フォルダで `claude --resume 9875e223-00a2-49ee-8914-099e6c088673` ## Claude Code の報告 Failed to authenticate: OAuth session expired and could not be refreshed ``` Mac のターミナルで、いつもの作業フォルダ（`~/r2r2r-scripts`）で `claude` を起動し、`/login` でログインし直しました。ホームのフォルダで起動すると、ホーム全体を信用するかを聞かれるので、そこでは開かずに作業フォルダへ移ってから起動しています。ログインは、契約しているプランのアカウント（1番の「Claude account with subscription」）を選びました。ログインし直したあと、同じ依頼を入れ直すと04:23に動き始めました。 ## 依頼177：始めの Enter を、1回目の試行だけにする 依頼176 の報告で、チャンク0 のあとの20.9秒が人の Enter 待ちだと分かったので、`lab_start.sh` を1回起動した中で、1回目の試行だけ始めの Enter を待ち、2回目からは待たずに始める形にしました。HOME へ戻る・爪を開く・上カメラの位置合わせは、毎回これまでどおり行います。 ### 依頼177 の依頼文 ```markdown --- 作業フォルダ: /Users/shimazueiichi/r2r2r-scripts 上限時間: 60 --- # 依頼177：実機推論の始めの確かめ（Enter）を、lab_start の1回目の試行だけにする 実機は動かさない（実装・テスト・レビューまで）。Log35。 ## なぜ 依頼176 の報告で、Log34 の pi05_20261113_193254 のチャンク0 のあと 20.9 秒が確かめの Enter 待ちだった。エイイチの決め（2026-11-13）：1回目だけ確かめて、2回目からは自動で進む。 ## やること 1. lab_start.sh を1回起動した中で、1回目の試行の始めの確かめは今までどおり Enter を待つ。2回目からの試行は、その確かめを待たずに進む 2. 始めに爪を開く・HOME へ動かすのは、今までどおり毎回行う（省かない。開いていない・HOME にいないことがあるため） 3. 確かめを飛ばしたときは、画面に1行出し、log.jsonl の頭にも残す 4. 補正（ゲームパッド・キー）・巻き戻し・止める操作は変えない。ほかの動きも変えない 5. テストを足し、既存のテスト（test_lab_start.sh・pi05/ のもの）も通す。codex で差分を見てもらい、直して通るまで 6. 変えたファイルだけを指定して git add・commit（git add . と git clean は使わない） ## 報告 どこを変えたか、2回目からどう出るかの画面の例 ``` ### 依頼177 で Claude Code が返した報告 04:23に始め、04:46に終えました（24分）。 ``` 依頼177 報告：実機推論の始めの確かめ（Enter）を、lab_start の1回目の試行だけにする（Log35） ■ やったこと 1. run_policy_client.py に --skip-first-confirm を足した。 - 最初に実行する推論（チャンク0）の前の確かめだけを待たずに実行する。 - 2回目からの推論の確かめ・補正（キー・ゲームパッド）・巻き戻し・止める操作（q / h）は今までどおり。 - 始めに爪を開く（[GRIP ] 開始時にグリッパーを開く）は今までどおり行う。 - 飛ばしたときは画面に [CONFIRM] の1行を出す。log.jsonl の頭（type=model）に skip_first_confirm（true / false）、飛ばしたチャンクの行に confirm_skipped: true を残す。 - --auto のときは、もともと確かめがないので何も出さない。 2. lab_start.sh：1回の起動の中で、2回目からの試行（もう1回やりますか? で y のあと）にだけ --skip-first-confirm を渡す。 - 7 の HOME・爪を開く・位置合わせは毎回行う（変えていない）。 - --dry-run のときも同じ（2回目から渡す）。 3. テスト - 新しく足したもの：pi05/test_skip_first_confirm.py 6件（1回目だけ飛ばす・付けなければ今までどおり・飛ばしたあとの c と b・2回目の確かめで q・--dry-keys・--auto） - test_lab_start.sh：4項目を足した（1回だけなら渡さない／端末を作って y・y・n で3回まわし、2回目・3回目だけに渡す／実機の 8 にも渡す・7 は毎回）。全部で OK 214 / NG 0。 - pi05/ のテスト：全部通った（test_rewind_correct 81 は、頭の新しい1項目 skip_first_confirm を比べる対象から外した）。 4. codex：1回。指摘なし（必須・推奨とも）。 5. コミット 2da2f61（5ファイルを個別に add）。 ■ 2回目からの画面の例（偽のアームで流したもの） [000] 推論 0ms 10ステップ先 Δ=+10.0 +5.0 +0.0 +0.0 +0.0 +0.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [CONFIRM] 2 回目からの試行なので始めの確かめ (Enter) を待たずに実行します (次の推論からは今までどおり確かめます) [GRIP ] 開始時にグリッパーを開く [VIA ] step 2 …… 着いた …… [001] 推論 …… Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / …… ← ここからは今までどおり待つ lab_start.sh の 8 で渡す引数は、2回目から最後に --skip-first-confirm が付く（ほかは1回目と同じ）。 ■ 変えたファイル - 修正：pi05/run_policy_client.py、lab_start.sh、test_lab_start.sh、pi05/test_rewind_correct.py - 新規：pi05/test_skip_first_confirm.py ■ 決めてほしいこと なし ``` ### 依頼177 のコードの差分（コミット 2da2f61） ```diff commit 2da2f61bc875e51d5b4c790147fb558fbde63a41 Author: Eiichi Shimazu Date: Sat Nov 14 04:46:33 2026 +0900 実機推論の始めの確かめ (Enter) を, lab_start の 1 回目の試行だけにする (依頼 177・Log35). run_policy_client.py に --skip-first-confirm を足す (最初に実行する推論の前の確かめだけ待たずに実行し, 画面に [CONFIRM] の 1 行・そのチャンクの行に confirm_skipped. 2 回目からの確かめ・補正 (キー・ゲームパッド)・巻き戻し・止める操作・開始時に爪を開くのは今までどおり). log.jsonl の頭 (type=model) に skip_first_confirm. lab_start.sh は 1 回の起動の中の 2 回目からの試行 (round 2 から) にだけ --skip-first-confirm を渡す (7 の HOME・爪を開く・位置合わせは毎回). テストを足す (test_skip_first_confirm 6・lab_start 214. test_rewind_correct は新しい 1 項目を比べる対象から外す) (依頼 177. codex 1 回) Co-Authored-By: Claude Opus 5.5 --- lab_start.sh | 10 +++- pi05/run_policy_client.py | 19 +++++- pi05/test_rewind_correct.py | 3 +- pi05/test_skip_first_confirm.py | 125 ++++++++++++++++++++++++++++++++++++++++ test_lab_start.sh | 24 ++++++++ 5 files changed, 176 insertions(+), 5 deletions(-) diff --git a/lab_start.sh b/lab_start.sh index a4dd15f..4e9371c 100755 --- a/lab_start.sh +++ b/lab_start.sh @@ -59,6 +59,8 @@ # 6. tools/daemon_ctl.sh status で 5555 の LISTEN を見る. なければ start # 7. HOME → 爪を開く → camera_align.py (q で閉じる) # 8. run_policy_client.py (LOG407 と同じ引数). 終わったら, もう1回やるかを聞く (y なら 7 へ) +# 2 回目からは --skip-first-confirm を渡し, 始めの確かめ (最初の推論の前の Enter) を待たずに進む (依頼 177. +# 7 の HOME・爪を開く・位置合わせは毎回行う. 2 回目からの確かめ・補正・巻き戻し・止める操作は今までどおり) # 9. Pod は消さない. 片付けは ./lab_stop.sh # # Pod の情報 (id・GPU・1時間の料金・作った時刻・サーバーを起動したモデル) は /pod/lab_pod.json に残す (IP とポートは残さない). @@ -513,6 +515,8 @@ trap ':' INT round=0 while :; do round=$((round + 1)) + CONFIRM_ARGS=() # 依頼 177: 1 回目の試行だけ始めの確かめを待つ. 2 回目からは飛ばす + [ $round -ge 2 ] && CONFIRM_ARGS=(--skip-first-confirm) if [ $DRY_RUN = 0 ]; then stage "7. HOME → 爪を開く → 位置合わせ ($round 回目)" python3 dynamic_tracking_limits/place/place_modules/08_home_from_anywhere.py || fail "HOME に戻せない" @@ -525,13 +529,15 @@ while :; do stage "8. 実機推論 ($round 回目)" python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride 3 \ --settle-retries 0 --state-from-target --execute --ignore-framing --model "$MODEL_TAG" --framing-raw-dir "$RAW" \ - --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} + --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ + ${CONFIRM_ARGS[@]+"${CONFIRM_ARGS[@]}"} rc=$? else stage "8. 推論のクライアント (ドライラン・--dry-keys. アームには触らない)" python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride 3 \ --settle-retries 0 --state-from-target --dry-keys --ignore-framing --model "$MODEL_TAG" --framing-raw-dir "$RAW" \ - --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} + --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ + ${CONFIRM_ARGS[@]+"${CONFIRM_ARGS[@]}"} rc=$? fi echo "[CLIENT] run_policy_client.py が終わった (終了コード $rc. モデル $MODEL_TAG)" diff --git a/pi05/run_policy_client.py b/pi05/run_policy_client.py index 0e20e4c..cc6149a 100644 --- a/pi05/run_policy_client.py +++ b/pi05/run_policy_client.py @@ -12,6 +12,9 @@ 安全策: - 既定はドライラン (アームに送らない). 送るには --execute - --execute でも既定は 1 チャンクごとに Enter で確認 (--auto で連続) + --skip-first-confirm を付けると始めの確かめ (最初に実行する推論の前) だけ待たずに実行し, 画面に [CONFIRM] の 1 行・ + log.jsonl の頭 (type=model) に skip_first_confirm・そのチャンクの行に confirm_skipped を残す. 2 回目からの確かめは + 今までどおり (lab_start.sh が 1 回の起動の中の 2 回目からの試行に付ける. 依頼 177) - 学習データで通った関節範囲 ±ENVELOPE_MARGIN_DEG の外へは出さない (クランプ) - 肩 j1 の上限は J1_SAFE_MAX (88°) で更に切る. これを超える指令はアームが黙って捨てる (LOG352) - 送る直前に最終検査. 6 関節のどれかが安全範囲の外か非有限値なら, 送信もグリッパー操作もせず @@ -1404,6 +1407,9 @@ def main(): ap.add_argument("--flow-tol", type=float, default=FLOW_TOL_DEFAULT, help=f"--flow で途中の点にこれだけ近づいたら次を送る (度. 既定 {FLOW_TOL_DEFAULT:.0f}. " f"送る間隔は {FLOW_MIN_INTERVAL_SEC:.1f} 秒より短くしない)") + ap.add_argument("--skip-first-confirm", action="store_true", + help="始めの確かめ (最初に実行する推論の前の Enter) だけを待たずに実行する. 2 回目からの確かめと " + "補正・巻き戻し・止める操作は今までどおり (lab_start.sh が 2 回目からの試行に付ける. 依頼 177)") ap.add_argument("--speed", type=int, default=SPEED, help=f"推論のチャンクを送る速さ (既定 {SPEED} = 今までと同じ. 補正・巻き戻し・HOME は {SPEED} のまま. 依頼 176)") args = ap.parse_args() @@ -1434,7 +1440,8 @@ def main(): "framing_raw_dir": str(framing_raw_dir(args)), "tilt_raw_dir": str(tilt_raw_dir(args)), "tilt_fix": not args.no_tilt_fix, "grip_value": GRIP_VALUE, "flow": bool(args.flow), "flow_tol": args.flow_tol, - "speed": CHUNK_SPEED, "host": args.host, "port": args.port, "t": time.time()}, + "speed": CHUNK_SPEED, "skip_first_confirm": bool(args.skip_first_confirm), + "host": args.host, "port": args.port, "t": time.time()}, ensure_ascii=False) + "\n") log_f.flush() @@ -1450,6 +1457,7 @@ def main(): history = [] # 巻き戻せる区間 (推論 1 回分 / 補正 1 回分). 新しいものが後ろ n_rewinds = n_corrections = 0 end_reason, outcome = None, None + skip_confirm = bool(args.skip_first_confirm) # 依頼 177: 始めの確かめを 1 回だけ飛ばす (使ったら False) try: cams = camera_resolver.resolve_cameras(require_top=True, require_side=False, verbose=False) cap = cv2.VideoCapture(cams["top"]) @@ -1636,7 +1644,14 @@ def main(): # 実測を渡すために None のままにする (--state-from-target 用). last_sent_target = None grasp = None # つかんだ区間を巻き戻すときの答え (GRASP_PLACED / GRASP_DROPPED) - if not args.auto: + skip_now, skip_confirm = skip_confirm and not args.auto, False + if skip_now: + # 依頼 177: lab_start.sh の 2 回目からの試行は, 始めの確かめ (Enter) を待たずに実行する. + # 2 回目からの確かめ・補正・巻き戻し・止める操作は今までどおり + print(" [CONFIRM] 2 回目からの試行なので始めの確かめ (Enter) を待たずに実行します " + "(次の推論からは今までどおり確かめます)") + rec["confirm_skipped"] = True + elif not args.auto: # 入力を待っている間は wait (人が手でブロックを置き直す. 学習データに使わない. 依頼 27) if recorder is not None: recorder.set_mode(MODE_WAIT) diff --git a/pi05/test_rewind_correct.py b/pi05/test_rewind_correct.py index ad59e3e..f20e313 100644 --- a/pi05/test_rewind_correct.py +++ b/pi05/test_rewind_correct.py @@ -605,7 +605,8 @@ class TestClientFlow(unittest.TestCase): new_keys = ("t_exec_start", "t_exec_end", "sent_targets", "framing_raw_dir", # framing_raw_dir は依頼 137 "tilt_raw_dir", "tilt_fix", "measured_on", "rotate_deg", # 依頼 144 "grip_value", # 依頼 152 - "flow", "flow_tol", "speed") # 依頼 176 (type=model の頭) + "flow", "flow_tol", "speed", # 依頼 176 (type=model の頭) + "skip_first_confirm") # 依頼 177 (type=model の頭) # HEAD が依頼 25 より前なら new_keys は新しい方にだけある. 依頼 25 以降なら両方にある (両方から外す) drop = ("t", "latency_s", "reference") + new_keys so, sn = strip(l_old, drop=drop), strip(l_new, drop=drop) diff --git a/pi05/test_skip_first_confirm.py b/pi05/test_skip_first_confirm.py new file mode 100644 index 0000000..ede6f39 --- /dev/null +++ b/pi05/test_skip_first_confirm.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 +"""test_skip_first_confirm.py — 始めの確かめ (Enter) を飛ばす --skip-first-confirm の確かめ (依頼 177. アームなし). + + python3 pi05/test_skip_first_confirm.py # 全部 + python3 pi05/test_skip_first_confirm.py -v + +lab_start.sh は 1 回の起動の中の 2 回目からの試行に --skip-first-confirm を付ける (test_lab_start.sh で確かめる). +ここでは run_policy_client を test_rewind_correct.run_client (偽の daemon / カメラ / モデル) で通し, + - 最初に実行する推論だけ Enter を待たずに実行し, 画面に [CONFIRM] の 1 行, log.jsonl の頭に skip_first_confirm + - 2 回目からの確かめ・b / c・q / h は今までどおり + - 開始時に爪を開くのは今までどおり行う + - 付けなければ今までと同じ (頭の skip_first_confirm は false) +を見る. KIOXIA にもアームにも触らない (一時フォルダだけ). +""" +import sys +import tempfile +import time +import unittest +from pathlib import Path + +_HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(_HERE)) + +import run_policy_client as rpc # noqa: E402 +from test_rewind_correct import run_client # noqa: E402 + +EXEC = ["--execute", "--steps-per-chunk", "10", "--via-stride", "3", "--settle-retries", "0", + "--state-from-target", "--ignore-framing", "--max-chunks", "6"] +SKIP_LINE = "[CONFIRM] 2 回目からの試行なので始めの確かめ (Enter) を待たずに実行します" + + +def chunks(lines): + return [x for x in lines if x.get("type") is None and "chunk" in x] + + +def model_head(lines): + return lines[0] + + +class TestSkipFirstConfirm(unittest.TestCase): + def setUp(self): + self.td = Path(tempfile.mkdtemp()) + time.sleep(1.1) # run のフォルダ名は秒単位なので重ならないように + + def test_execute_skips_only_first(self): + # 推論 0 は待たずに実行 → 推論 1 は Enter で実行 → 推論 2 で q → 結果は記録しない + code, world, run, lines, out = run_client(rpc, EXEC + ["--skip-first-confirm"], ["", "q", ""], self.td) + self.assertEqual(code, 0) + head = model_head(lines) + self.assertEqual(head["type"], "model") + self.assertIs(head["skip_first_confirm"], True) + ch = chunks(lines) + self.assertEqual([x["chunk"] for x in ch], [0, 1, 2]) + self.assertEqual([bool(x.get("executed")) for x in ch], [True, True, False]) + self.assertIs(ch[0].get("confirm_skipped"), True) + self.assertNotIn("confirm_skipped", ch[1]) + self.assertEqual(out.count(SKIP_LINE), 1) + self.assertEqual(out.count("[CONFIRM]"), 1) + # 開始時に爪を開くのは今までどおり (推論 0 の送信より前) + self.assertIs(ch[0].get("initial_gripper_open"), True) + self.assertEqual(world.grips[0], 0) + self.assertEqual(world.events[0], ("grip", 0)) + labels = [s[0] for s in world.sends] + self.assertEqual(labels[:4], ["pi05_chunk000_via02", "pi05_chunk000_via05", + "pi05_chunk000_via08", "pi05_chunk000_via09"]) + self.assertTrue(any(lb.startswith("pi05_chunk001") for lb in labels)) + self.assertFalse(any(lb.startswith("pi05_chunk002") for lb in labels)) + # 飛ばした推論 0 の間は wait にしない. 推論 1 の前からは今までどおり wait + stages = [l.split(",")[2] for l in (run / "recording" / "states.csv").read_text().splitlines()[1:] + if l.split(",")[1] == "stage"] + self.assertEqual(stages[:3], ["model", "wait", "model"]) + + def test_without_flag_waits_first(self): + # 同じ入力で付けなければ, 推論 0 を Enter で実行 → 推論 1 で q (今までどおり) + code, world, run, lines, out = run_client(rpc, EXEC, ["", "q", ""], self.td) + self.assertEqual(code, 0) + self.assertIs(model_head(lines)["skip_first_confirm"], False) + ch = chunks(lines) + self.assertEqual([bool(x.get("executed")) for x in ch], [True, False]) + self.assertFalse(any("confirm_skipped" in x for x in ch)) + self.assertNotIn("[CONFIRM]", out) + self.assertIs(ch[0].get("initial_gripper_open"), True) + + def test_correction_and_rewind_unchanged_after_skip(self): + # 推論 0 は待たずに実行 → 推論 1 の確かめで c (j1 を + 2 刻み) → Enter で戻る → 推論 2 で b (補正を巻き戻す) + # → 推論 3 で h → 結果 y + code, world, run, lines, out = run_client(rpc, EXEC + ["--skip-first-confirm"], + ["c", "b", "h", "y"], self.td, keys="1++\n") + self.assertEqual(code, 0) + corr = [x for x in lines if x.get("type") == "correction"] + self.assertEqual([x["action"] for x in corr], ["move", "move", "accept"]) + rw = [x for x in lines if x.get("type") == "rewind"] + self.assertEqual(len(rw), 1) + self.assertTrue(rw[0]["finished"]) + self.assertEqual([s[0] for s in world.sends][-1], "pi05_home") + self.assertEqual(out.count("[CONFIRM]"), 1) + + def test_q_on_second_confirm(self): + # 2 回目の確かめで止められる (推論 0 だけ実行) + code, world, run, lines, out = run_client(rpc, EXEC + ["--skip-first-confirm"], ["q", ""], self.td) + self.assertEqual(code, 0) + self.assertEqual([bool(x.get("executed")) for x in chunks(lines)], [True, False]) + + def test_dry_keys(self): + code, world, run, lines, out = run_client( + rpc, ["--dry-keys", "--steps-per-chunk", "10", "--via-stride", "3", "--max-chunks", "5", + "--skip-first-confirm"], ["", "q"], self.td) + self.assertEqual(code, 0) + self.assertEqual(world.sends, []) + ch = chunks(lines) + self.assertEqual([bool(x.get("simulated")) for x in ch], [True, True, False]) + self.assertIs(ch[0].get("confirm_skipped"), True) + self.assertEqual(out.count(SKIP_LINE), 1) + + def test_auto_has_nothing_to_skip(self): + code, world, run, lines, out = run_client( + rpc, EXEC[:-1] + ["2", "--auto", "--skip-first-confirm"], [""], self.td) + self.assertEqual(code, 0) + self.assertNotIn("[CONFIRM]", out) + self.assertFalse(any("confirm_skipped" in x for x in chunks(lines))) + self.assertIs(model_head(lines)["skip_first_confirm"], True) + + +if __name__ == "__main__": + unittest.main() diff --git a/test_lab_start.sh b/test_lab_start.sh index d3addf6..626f1eb 100755 --- a/test_lab_start.sh +++ b/test_lab_start.sh @@ -628,6 +628,30 @@ for bad in 0 101 abc 1000 ""; do rm -rf "$T" done +echo "== 始めの確かめは 1 回目の試行だけ (依頼 177): 2 回目からは --skip-first-confirm を渡す" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run +check "1 回だけの試行には --skip-first-confirm を渡さない" '[ "$(grep -c "pi05/run_policy_client.py" "$T/py.log")" = 1 ] && ! has py.log "--skip-first-confirm"' +rm -rf "$T" +# 「もう1回やりますか?」は端末のときだけ聞くので, script で端末を作って y・y・n を打つ (LAB_LOGGED=1 で記録の script は飛ばす) +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1 +# 偽物の pod_ssh は標準入力を読み捨てる. 端末では終わりが来ず止まり y を食べるので, この場合だけ端末のときは読まない +sed -i '' 's#^ cat > /dev/null$# [ -t 0 ] || cat > /dev/null#' "$T/fakes.sh" +# 先に打つと端末が待つ前に入力が尽きて script が終わるので, 問いが出るたびに 1 つずつ打つ (問いが出なければ 60 秒であきらめる) +feed() { + local n k + for n in 1 2 3; do + for k in $(seq 1 300); do [ "$(grep -ac "もう1回やりますか" "$T/out.txt" 2>/dev/null)" -ge $n ] && break; sleep 0.2; done + if [ $n -lt 3 ]; then printf 'y\n'; else printf 'n\n'; fi + done + sleep 1 +} +(cd "$T" && feed | PATH="$T/bin:$PATH" LAB_LOGGED=1 script -q /dev/null ./lab_start.sh --log LogT --dry-run --flow > "$T/out.txt" 2>&1); RC=$? +grep "pi05/run_policy_client.py" "$T/py.log" > "$T/client.log" +check "3 回の試行でクライアントを 3 回呼ぶ (終了コード 0)" '[ $RC = 0 ] && [ "$(grep -c . "$T/client.log")" = 3 ] && [ "$(grep -ac "=== 8. " "$T/out.txt")" = 3 ]' +check "1 回目には付けず, 2 回目・3 回目の終わりに --skip-first-confirm を付ける (ほかの引数は同じ)" '! sed -n 1p "$T/client.log" | grep -q -- "--skip-first-confirm" && sed -n 2p "$T/client.log" | grep -q -- "--flow --skip-first-confirm$" && sed -n 3p "$T/client.log" | grep -q -- "--flow --skip-first-confirm$" && [ "$(sed -n 2p "$T/client.log" | sed "s/ --skip-first-confirm$//")" = "$(sed -n 1p "$T/client.log")" ]' +rm -rf "$T" +check "実機の 8 も 2 回目からは --skip-first-confirm を渡し, 7 の HOME・爪を開くは毎回流す" '[ "$(grep -c '"'"'${CONFIRM_ARGS\[@\]+"${CONFIRM_ARGS\[@\]}"}'"'"' "$HERE/lab_start.sh")" = 2 ] && grep -qF "[ \$round -ge 2 ] && CONFIRM_ARGS=(--skip-first-confirm)" "$HERE/lab_start.sh" && [ "$(awk "/^while :; do/,/^done/" "$HERE/lab_start.sh" | grep -c "08_home_from_anywhere.py\|daemon_set_gripper(0)")" = 2 ]' + echo echo "OK $OK / NG $NG" [ $NG = 0 ] ``` ## 依頼178：推論ごとの Enter をやめ、スペースを押したときだけ止める 依頼177 の報告にあった画面の例で、2回目以降の推論でも、1チャンクごとに Enter を待つ作りになっていることに気づきました。依頼176 の表でも、1チャンクごとに0.5〜1.5秒の Enter 待ちがあり、チャンク0 を除いても合わせて約11秒でした。 この Enter をなくす案を出したとき、先に Claude が「止めたいときは q や h で止める形になります」と説明していました。確かめるとこれは間違いで、推論ごとの入力欄が、ゲームパッドでの補正（p）・巻き戻し（b）・爪の締め直し（r）・HOME（h）・終わる（q）の入口そのものでした。Enter 待ちをただなくすと、途中で補正に入る入口もなくなります。補正を入れた試行も学習のお手本に使っているので、入口は残す必要があります。 そこで2つの案を出しました。 | 案 | 中身 | よいところ | 気になるところ | |---|---|---|---| | A. 今のまま | 1チャンクごとに Enter を押す | 補正・巻き戻しはそのまま | 待ちが約11秒残る | | B. 止まらずに進み、キーを押したときだけ止まる | 動いている間にスペースを押すと、今のチャンクを最後まで動かしてから、次の推論のあとで今までの入力欄を出す | 待ちがなくなり、補正の入口も残る | 作り直しが要る | B を選び、依頼178 にしました。物理的なリスクのある変更なので、codex のレビューを必ず通す依頼にしています。 - ねらい：人が付きっきりで Enter を押さなくても、π0.5 の試行が最後まで流れるようにする - 変わったこと：推論ごとの入力欄が出なくなり、スペースを押したときだけ、次の推論のあと（送る前）で入力欄を出す。始めの Enter・補正・巻き戻しは今までどおり - 見込める効果：Enter 待ちは、直す前の1回で31.7秒あった。直したあとの7回では、始めの Enter と止めるときを合わせて0〜28.4秒（中央2.2秒）になった ### 依頼178 の依頼文 ```markdown --- 作業フォルダ: /Users/shimazueiichi/r2r2r-scripts 上限時間: 120 --- # 依頼178：実機推論をチャンクごとの Enter で止めず、キーを押したときだけ止める 実機は動かさない（実装・テスト・レビューまで）。Log35。物理的なリスクのある変更なので codex を必ず通す。 ## なぜ 依頼176 の表（pi05_20261113_193254）で、チャンクごとの確かめ待ちが 0.5〜1.5 秒あり、最初の 1 回を除いても合わせて約 11 秒あった。 エイイチの決め（2026-11-14）：止まらずに進み、キーを押したときだけ止まる形にする（案B）。 チャンクごとの入力欄（CONFIRM_PROMPT）は Enter だけでなく、補正 p・c、巻き戻し b、締め直し r、HOME h、終わる q などの入口でもある。補正入りの試行は学習データに使うので、この入口は必ず残す。 ## やること 1. run_policy_client.py に --no-step-confirm を足す（付けなければ今までどおり） - チャンク 0 の始めの確かめは今までどおり（1 回目の試行は Enter を待つ。依頼177 の --skip-first-confirm もそのまま効く） - チャンク 1 からは入力欄を出さずに次の推論・実行へ進む - 推論中・中継点を送って待っている間・到着の確かめの間に、端末でスペースキー（Enter も可）が押されたら「止める予約」をし、今のチャンクを最後まで動かしたあと、次の推論の前で止めて、今までと同じ入力欄（CONFIRM_PROMPT）を出す。そこからの p・c・b・r・h・q・Enter の動きは今までと同じ。Enter で進めば、また止まらずに進む形に戻る - 動いている途中では止めない（今のチャンクを送り終えるまで待つ）。キーを読むのは、ブロックしない読み方（termios の cbreak と select など）で行い、入力欄を出す前・終わったあとに端末の設定を必ず元に戻す（Ctrl-C・例外のときも） - 未到達・関節角が読めない・安全範囲の外 などのときの扱いは、今の --auto なしのときと同じにする（--auto のように終了コード 1 で止める形にはしない。入力欄を出して人に任せる） - 止める予約が入ったとき・入力欄を出したときに 1 行出し、log.jsonl に type=pause の行（何を押したか・どのチャンクのあとか・時刻）を残す - 待っている間の recorder のモードは今までどおり wait にする - ゲームパッドのボタンでも止められるようにできるかを調べ、案と手間を報告に書く（今回は作らない。補正の pygame は別のプロセスに分けてあるので無理に足さない） 2. lab_start.sh：既定で --no-step-confirm を渡す。--step-confirm で今までどおりチャンクごとに確かめる形に戻せるようにする。起動時に [CONFIRM] の行でどちらかを出す 3. chunk_timing.py：止める予約で止まった時間は「確認待ち」の列に入るようにする（今の表と比べられるように） 4. テスト：--no-step-confirm なしで今までと同じ送り方・同じ log になること（git HEAD の版と比べる）、キーなしで最後まで入力欄が出ないこと、途中でスペースが押されたら次の推論の前で入力欄が出て p・b・q が今までどおり動くこと、端末の設定が元に戻ること。既存のテスト（test_lab_start.sh・pi05/ のもの・tools/test_gamepad_teleop）も通す 5. codex で差分を見てもらい、指摘を直して通るまで 6. 変えたファイルだけを指定して git add・commit（git add . と git clean は使わない） ## 報告 - 画面の例（キーなしで流れるとき・途中でスペースを押したとき） - ゲームパッドのボタンで止める案 - エイイチが実機で比べるときのコマンド ``` ### 依頼178 で Claude Code が返した報告 07:01に始め、07:44に終えました（43分）。 ``` 依頼178 報告：実機推論をチャンクごとの Enter で止めず、スペースを押したときだけ止める（Log35） ■ やったこと 1. run_policy_client.py に --no-step-confirm を足した（付けなければ今までと同じ）。 - 始めの確かめ（1回目の推論の前の Enter）は今までどおり。--skip-first-confirm もそのまま効く。 - そのあとは入力欄を出さずに次の推論・実行へ進む。 - 推論中・中継点を送って待つ間・到着の確かめの間にスペース（Enter も可）を押すと「止める予約」になる。今のチャンクは最後まで送り、次の推論を出したところ（送る前）で今までと同じ入力欄を出す。推論中に押したときは、その推論を送らずに入力欄を出す。 - 入力欄からの p・c・b・r・h・q・s・Enter は今までどおり。Enter で実行すると、また止まらずに進む。s・b・c・p のあとは止めたままにし、次の推論でも入力欄を出す（始めの確かめで s・b・c・p を選んだときも同じ）。 - キーは termios の cbreak と select で待たずに読む。入力欄の前と、終わるとき（Ctrl-C・例外も）に端末の設定を元に戻す。Ctrl-C はそのまま効く。 - 未到達・関節角が読めない（最後の中継点を送らなかった経路も含む）ときは、終了コード 1 にせず止める予約を入れて入力欄を出す。安全範囲の外は今までどおり。推論の始めに関節角が読めないときの終了コード 1 は、今の --auto なしと同じなので変えていない。 - 止める予約のときと入力欄を出すときに 1 行出す。log.jsonl に type=pause の行（event=requested：押したキー・わけ・どの推論の間か・どのチャンクのあとか・時刻／event=prompt／event=resume）を残す。入力欄を出した推論の行に paused と prompt_t（入力欄を出した・閉じた時刻）、頭（type=model）に step_confirm を残す。 - 入力欄で待つ間の recorder のモードは今までどおり wait。 - --auto とは一緒に使えない（引数の確かめで止める）。 2. lab_start.sh：既定で --no-step-confirm を渡す。--step-confirm を付けると今までどおりチャンクごとに確かめる。起動時に [CONFIRM] の行でどちらかを出す。--help にも書いた。 3. chunk_timing.py：止めて入力欄で待った時間は「確認待ち」の列に入る（送ったチャンクは今までどおりの計算で入り、送らなかったチャンクも prompt_t から入れる）。メモに「止めた(スペース)」などを出し、頭に確かめの形（毎チャンク／止めたときだけ）を出す。 4. テスト - 新しく足したもの：pi05/test_no_step_confirm.py 17件（キーなしで最後まで入力欄なし／途中でスペース→次の推論のあとで入力欄→p・b・Enter／スペースのあと q／Enter で止めて s／推論中に押したら送らない／ほかのキーでは止めない／未到達・読めない・最後の中継点を送らなかった経路で入力欄／Ctrl-C で端末を戻す／入力欄のときは必ず端末が元に戻っている／pty で本物の端末の設定が cbreak になり元に戻る／戻すのに失敗してももう一度戻せる／付けなければ git HEAD の版と同じ送り方・同じ log） - test_chunk_timing 7件、test_lab_start.sh OK 218 / NG 0。 - pi05/ のテストと tools/test_gamepad_teleop は全部通った。test_power_ab は全部まとめて流したときに 1 件落ちたが、単独では通った。計測の時刻に左右されるテストで、今回変えたファイルは使っていない。test_teach_currents も 1 回目に 1 件落ちたが、2 回目は通った。 5. codex：3回。1回目に必須4件・推奨1件。R1（始めの確かめで s・b・c・p を選んだあとに止まらない）、R3（最後の中継点を送らなかった経路の未到達）、R4（端末の設定を戻すのに失敗したとき）、R5（送らなかったチャンクの待ち）を直した。R2（推論の始めに関節角が読めないと終了コード 1）は今の --auto なしと同じ動きなので据え置いた。2回目で R5 の続き（最後のチャンクの合計）を直し、3回目は指摘なし。 6. コミット 047e472（7ファイルを個別に add）。 ■ 画面の例（偽のアームで流したもの） キーなしで流れるとき（始めの Enter のあとは入力欄なし）： [PAUSE ] --no-step-confirm: 始めの確かめのあとは入力欄を出さずに進みます. 止めるときはスペース (Enter も可). 今のチャンクを送り終えてから, 次の推論のあと (送る前) で入力欄を出します [000] 推論 …… （始めの確かめの入力欄 → Enter） [VIA ] step 2 …… 着いた …… step 9 …… 着いた [001] 推論 0ms 10ステップ先 Δ=+10.0 +5.0 …… [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 …… 着いた …… step 9 …… 着いた [002] 推論 …… （そのまま進む） 途中でスペースを押したとき： [001] 推論 0ms 10ステップ先 Δ=+10.0 +5.0 …… [VIA ] step 2 …… 着いた [VIA ] step 5 …… 着いた [PAUSE ] 止める予約 (スペース). 推論 1 を送り終えてから, 次の推論のあと (送る前) で止めます [VIA ] step 8 …… 着いた [VIA ] step 9 …… 着いた [002] 推論 0ms 10ステップ先 Δ=+10.0 +5.0 …… [VIA ] 中継点 4 点: step 2, 5, 8, 9 [PAUSE ] 止めました (推論 2 はまだ送っていません). Enter で実行すると, また止まらずに進みます Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > （推論中に押したときは「止める予約 (スペース). 推論 N は送らずに入力欄を出します」） 「止める予約」の行は、押したあとの次の区切り（中継点を送り終えたとき・推論のあと・チャンクの送り終わり）で出る。1 つの中継点の到着を待っている間に押すと、その中継点が終わってから出る。 ■ ゲームパッドのボタンで止める案（今回は作っていない） - 案：推論のあいだ、gamepad_teleop.py を別のプロセスで「見張りだけ」の形（例：--pad-watch。決めた 1 ボタン（OPTIONS か ○ など）を押したら 1 行の JSON を出すだけ。送る仕事はしない）で起動しておく。推論のプロセスは、スペースを読むのと同じ所（check_pause）で、その子の出力を select で待たずに読み、届いたら同じ「止める予約」にする（key=pad）。 - 補正 p でゲームパッドの子を起動する前に見張りの子を止め、補正を抜けたら起こし直す（同じコントローラーを 2 つのプロセスで同時に開かないため）。cv2 と pygame は今までどおり別のプロセスのまま。 - 手間：gamepad_teleop に見張りの形を足す・子の起動と止めと落ちたときの扱い・つながらないときは黙ってキーだけにする・テスト（偽の子）で、半日〜1日ほど。見張りの子が止まらないときの扱い（依頼145 と同じく kill して進む）を決める必要がある。 ■ エイイチが実機で比べるときのコマンド - 新しい形（既定）：./lab_start.sh --log Log35 --model <いつものモデル> --flow - 今までの形：./lab_start.sh --log Log35 --model <いつものモデル> --flow --step-confirm - 比べる：python3 pi05/chunk_timing.py pi05_20261113_193254 <今回の試行のフォルダ名> （--flow・--speed は依頼176 と同じく好みで。止めるときはスペースを 1 回押す。動いている途中では止まらず、次の推論のあとで入力欄が出る） ■ 変えたファイル - 修正：pi05/run_policy_client.py、lab_start.sh、test_lab_start.sh、pi05/chunk_timing.py、pi05/test_chunk_timing.py、pi05/test_rewind_correct.py - 新規：pi05/test_no_step_confirm.py ■ 決めてほしいこと 1. 止める場所：依頼文は「次の推論の前で止める」だが、今までと同じ入力欄（Enter=表示した推論を実行・s=送らず次へ）をそのまま使うため、「次の推論を出したあと・送る前」で止めた（アームは送る前なので動かない。待ち時間は今までどおり確認待ちの列に入る）。推論の前で止める形がよければ直す。 2. 推論中にスペースを押したときは、その推論を送らずに入力欄を出すようにした（依頼文の「今のチャンクを最後まで」は動いている途中の話と読んだ）。それでよいか。 3. 推論の始めに関節角が読めないときは、今の --auto なしと同じく終了コード 1 で止まる（何も送らない）。入力欄を出す形にするか。 ``` 報告の「決めてほしいこと」の3つは、どれもそのままにしました。止まる場所は「次の推論を出したあと、送る前」で、どちらの位置でもアームは止まっています。推論の途中でスペースを押したときは、その推論を送らずに入力欄を出します。推論の始めに関節の角度が読めないときは、今までどおり止まって終わります。 ### 依頼178 のコードの差分（コミット 047e472） ```diff commit 047e472e7ebbfec537aa3eb5e08c3b1e15571deb Author: Eiichi Shimazu Date: Sat Nov 14 07:43:14 2026 +0900 実機推論をチャンクごとの Enter で止めず, スペースを押したときだけ止める (依頼 178・Log35). run_policy_client.py に --no-step-confirm を足す (始めの確かめは今までどおり・--skip-first-confirm もそのまま. そのあとは入力欄を出さずに次の推論・実行へ進む. 推論中・中継点を送って待つ間・到着の確かめの間に端末でスペース (Enter も可) が押されたら止める予約をし, 今のチャンクを送り終えてから次の推論のあと (送る前) で今までと同じ入力欄を出す. 推論中に押せばその推論は送らない. p・c・b・r・h・q・s・Enter は今までどおりで, Enter で実行するとまた止まらずに進む. s・b・c・p のあとは止めたまま (codex R1). キーは termios の cbreak と select で待たずに読み, 入力欄の前・終わり・Ctrl-C・例外で端末の設定を戻す (戻せてから保存を消す. codex R4). 未到達・関節角を読めない (最後の中継点を送らなかった経路も. codex R3) ときは終了コード 1 にせず入力欄を出す. log.jsonl に type=pause (requested・prompt・resume), 入力欄を出した推論の行に paused と prompt_t, 頭に step_confirm. --auto とは一緒に使えない). lab_start.sh は既定で --no-step-confirm を渡し, --step-confirm で今までどおり. 起動時に [CONFIRM] の行. chunk_timing.py は止めた待ちを確認待ちに入れ (送らなかったチャンクも prompt_t から. 最後のチャンクの終わりにも. codex R5), メモに「止めた(スペース)」・頭に確かめの形. テストを足す (test_no_step_confirm 17・test_chunk_timing 7・lab_start 218. test_rewind_correct は頭の step_confirm を比べる対象から外す) (依頼 178. codex 3 回) Co-Authored-By: Claude Opus 5.5 --- lab_start.sh | 18 +- pi05/chunk_timing.py | 30 +++- pi05/run_policy_client.py | 161 ++++++++++++++++- pi05/test_chunk_timing.py | 33 ++++ pi05/test_no_step_confirm.py | 416 +++++++++++++++++++++++++++++++++++++++++++ pi05/test_rewind_correct.py | 3 +- test_lab_start.sh | 12 +- 7 files changed, 661 insertions(+), 12 deletions(-) diff --git a/lab_start.sh b/lab_start.sh index 4e9371c..9dfafaf 100755 --- a/lab_start.sh +++ b/lab_start.sh @@ -38,6 +38,9 @@ # run_policy_client.py の既定 20. 起動時に [GRIP ] で使う値を出す. 依頼 152) # --flow / --speed N run_policy_client.py にそのまま渡す (中継点を止まらずに流す / チャンクを送る速さ 1〜100. # 付けなければ今までどおり. 依頼 176. 起動時に [FLOW ] で出す) +# --step-confirm 実機推論でチャンクごとに確かめ (Enter) を待つ今までの形に戻す. 付けなければ (既定) run_policy_client.py に +# --no-step-confirm を渡し, 始めの確かめのあとは止まらずに進み, スペース (Enter も可) を押したときだけ次の推論の +# あとで入力欄を出す (依頼 178). 起動時に [CONFIRM] の行でどちらかを出す # つなぎ直しで, 残っている Pod のサーバーが別のモデルで動いていれば, そのことを出して止まる # # 1. Pod を作る (A40×1・Runpod Pytorch 2.8.0・コンテナのディスク 200GB・22/tcp を外へ出す) @@ -61,6 +64,8 @@ # 8. run_policy_client.py (LOG407 と同じ引数). 終わったら, もう1回やるかを聞く (y なら 7 へ) # 2 回目からは --skip-first-confirm を渡し, 始めの確かめ (最初の推論の前の Enter) を待たずに進む (依頼 177. # 7 の HOME・爪を開く・位置合わせは毎回行う. 2 回目からの確かめ・補正・巻き戻し・止める操作は今までどおり) +# 既定で --no-step-confirm を渡す (始めの確かめのあとはチャンクごとに確かめず, スペースを押したときだけ止める. +# --step-confirm で今までどおり. 依頼 178) # 9. Pod は消さない. 片付けは ./lab_stop.sh # # Pod の情報 (id・GPU・1時間の料金・作った時刻・サーバーを起動したモデル) は /pod/lab_pod.json に残す (IP とポートは残さない). @@ -86,6 +91,7 @@ TILT_FIX_ARGS=() # 依頼 144: 既定は傾きをソフトでそろえる. - GRIP_ARGS=() # 依頼 152: --grip-value N のときだけ run_policy_client.py に --grip-value N を渡す GRIP_VALUE_SHOWN="20 (既定. run_policy_client.py の GRIP_VALUE)" FLOW_ARGS=() # 依頼 176: --flow / --speed N のときだけ run_policy_client.py に渡す +STEP_ARGS=(--no-step-confirm) # 依頼 178: 既定はチャンクごとに確かめない. --step-confirm で今までどおり while [ $# -gt 0 ]; do case "$1" in --gpu) lab_need_val A40 "$@"; GPU="$2"; shift 2 ;; @@ -100,13 +106,14 @@ while [ $# -gt 0 ]; do [ ${#2} -le 3 ] && [ "$((10#$2))" -le 100 ] || { echo "[ERROR] --grip-value は 0〜100 の整数: $2" >&2; exit 2; } GRIP_ARGS=(--grip-value "$((10#$2))"); GRIP_VALUE_SHOWN="$((10#$2)) (--grip-value)"; shift 2 ;; --flow) FLOW_ARGS+=(--flow); shift ;; + --step-confirm) STEP_ARGS=(); shift ;; --speed) [ $# -ge 2 ] || { echo "[ERROR] --speed には 1〜100 の整数を付ける" >&2; exit 2; } case "$2" in ''|*[!0-9]*) echo "[ERROR] --speed は 1〜100 の整数: $2" >&2; exit 2 ;; esac [ ${#2} -le 3 ] && [ "$((10#$2))" -ge 1 ] && [ "$((10#$2))" -le 100 ] || { echo "[ERROR] --speed は 1〜100 の整数: $2" >&2; exit 2; } FLOW_ARGS+=(--speed "$((10#$2))"); shift 2 ;; --model) [ $# -ge 2 ] || { echo "[ERROR] --model には ${LAB_MODELS// / か } を付ける" >&2; exit 2; } # 値がないと shift 2 が失敗して回り続ける (codex R1) MODEL="$2"; shift 2 ;; - -h|--help) sed -n '2,58p' "$0"; exit 0 ;; + -h|--help) sed -n '2,61p' "$0"; exit 0 ;; *) echo "[ERROR] 知らない引数: $1 (./lab_start.sh --help)" >&2; exit 2 ;; esac done @@ -156,6 +163,11 @@ else fi echo "[GRIP ] 爪の閉じる値は $GRIP_VALUE_SHOWN. 締め直し r はこの値−3 とこの値を交互に送る (依頼 152)" [ ${#FLOW_ARGS[@]} = 0 ] || echo "[FLOW ] 推論の送り方: ${FLOW_ARGS[*]} (依頼 176)" # 付けなければ今までと同じ出力 +if [ ${#STEP_ARGS[@]} = 0 ]; then + echo "[CONFIRM] チャンクごとに確かめる (--step-confirm. 推論のたびに Enter を待つ)" +else + echo "[CONFIRM] チャンクごとには確かめない (--no-step-confirm. 始めの確かめのあとは止まらずに進む. 止めるときはスペース. 依頼 178)" +fi lab_ssh_opts HF_REPO=$MODEL_REPO # --model で選んだモデル (lab_lib.sh の lab_model_def) @@ -529,14 +541,14 @@ while :; do stage "8. 実機推論 ($round 回目)" python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride 3 \ --settle-retries 0 --state-from-target --execute --ignore-framing --model "$MODEL_TAG" --framing-raw-dir "$RAW" \ - --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ + --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${STEP_ARGS[@]+"${STEP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ ${CONFIRM_ARGS[@]+"${CONFIRM_ARGS[@]}"} rc=$? else stage "8. 推論のクライアント (ドライラン・--dry-keys. アームには触らない)" python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride 3 \ --settle-retries 0 --state-from-target --dry-keys --ignore-framing --model "$MODEL_TAG" --framing-raw-dir "$RAW" \ - --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ + --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${STEP_ARGS[@]+"${STEP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ ${CONFIRM_ARGS[@]+"${CONFIRM_ARGS[@]}"} rc=$? fi diff --git a/pi05/chunk_timing.py b/pi05/chunk_timing.py index 8650f14..0f98f90 100644 --- a/pi05/chunk_timing.py +++ b/pi05/chunk_timing.py @@ -11,6 +11,9 @@ 書くので, その分 (ふつう 0.01 秒ほど) 確認待ちが短く, 推論の始まりが遅めに出る)): 推論 latency_s (π0.5 が答えるまで) 確認待ち 推論が終わってから送り始めるまで (Enter の確認. --auto なら 0 に近い). 送っていないチャンクは - + --no-step-confirm (依頼 178) では, 止める予約 (スペース) で入力欄を出したチャンクの待ちがここに入り + (今までのチャンクごとの確かめと同じ所), 止めなかったチャンクは 0 に近い. メモに「止めた(スペース)」など. + 送らなかったチャンク (s・b・c・p・q・h) も log の prompt_t から入力欄を閉じるまでを確認待ちに入れる 動いた 送り始めてから送り終わるまで (t_exec_start → t_exec_end. 爪の開け閉めを含む) その他 合計 − 推論 − 確認待ち − 動いた (関節角の読み取り・撮影など. 巻き戻し・補正・送らずに次へ のチャンクは 確認待ちもここに入る) @@ -84,7 +87,7 @@ def load_sends(run_dir: Path): def last_time(chunks): """最後のチャンクの記録の終わり (推論の行を書いた時刻か送り終わりの遅い方).""" r = chunks[-1] - ts = [r.get("t"), r.get("t_exec_end")] + ts = [r.get("t"), r.get("t_exec_end"), (r.get("prompt_t") or [None, None])[1]] # prompt_t は依頼 178 codex R5 return max(x for x in ts if x is not None) @@ -101,12 +104,22 @@ def chunk_rows(chunks): moved = r["t_exec_end"] - r["t_exec_start"] else: confirm = moved = None + if r.get("prompt_t"): + # 依頼 178 codex R5: --no-step-confirm で入力欄を出して送らなかったチャンク (s・b・c・p・q・h) も, + # 入力欄を閉じるまでを確認待ちに入れる (補正・巻き戻しの時間はその他) + confirm = max(0.0, r["prompt_t"][1] - r["t"]) other = total - infer - (confirm or 0.0) - (moved or 0.0) note = [] if r.get("grip_cmd") is not None: note.append("爪→" + ("閉" if r["grip_cmd"] == 1 else "開")) if r.get("initial_gripper_open"): note.append("始めに爪を開いた") + if r.get("paused"): + # 依頼 178: --no-step-confirm で止める予約 (スペース・Enter・未到達など) から入力欄を出したチャンク + p = r["paused"] + note.append("止めた(" + ({"space": "スペース", "enter": "Enter"}.get(p.get("key")) + or {"not_arrived": "未到達", "read_failed": "読めない"}.get(p.get("reason"), + str(p.get("reason")))) + ")") for k, t in (("rewind_requested", "巻き戻し"), ("correction_requested", "補正"), ("home_requested", "HOME"), ("unsafe", "安全停止")): if r.get(k): @@ -144,6 +157,12 @@ def via_waits(r, sends): return [(None, marks[k + 1] - marks[k], "") for k in range(len(ts))], "states" +def step_text(model): + """頭の step_confirm (依頼 178) を短く. 記録がなければ依頼 178 より前 = チャンクごとに確かめる.""" + sc = model.get("step_confirm") + return "毎チャンク(記録なし)" if sc is None else ("毎チャンク" if sc else "止めたときだけ") + + def fmt(x, w=7): return f"{'-':>{w}}" if x is None else f"{x:>{w}.2f}" @@ -160,7 +179,8 @@ def report(run_dir: Path): flow = model.get("flow") how = ("記録なし (依頼 176 より前 = --flow なし・速さ 20)" if flow is None else (f"--flow (近づく {model.get('flow_tol')}°)" if flow else "--flow なし")) - print(f" 送り方: {how} 速さ {model.get('speed', 20)} モデル {model.get('model')} 閉じる値 {model.get('grip_value')}") + print(f" 送り方: {how} 速さ {model.get('speed', 20)} モデル {model.get('model')} 閉じる値 {model.get('grip_value')}" + f" 確かめ {step_text(model)}") if not chunks: print(" 推論の行がない") return None @@ -194,7 +214,7 @@ def report(run_dir: Path): print(" 中継点ごと: step:秒+わけ (近=近づいた 時=見込みの時間 着=最後の点が着いた 未=着かなかった 失=送れなかった)") if others: print(" そのほかの行: " + " ".join(f"{k} {v}" for k, v in sorted(others.items()))) - return {"name": run_dir.name, "flow": model.get("flow"), "speed": model.get("speed", 20), "n": len(rows), + return {"name": run_dir.name, "flow": model.get("flow"), "step": step_text(model) if model else "-", "speed": model.get("speed", 20), "n": len(rows), "tot": tot, "mid": mid, "infer1": rows[0]["infer"], "infer2": infer2, "via": med(all_waits)} @@ -215,11 +235,11 @@ def main(argv=None): res.append(r) if len(res) >= 2: print("== 比べる (秒)") - print(f" {'試行':<22} {'送り方':<10} {'速さ':>4} {'チャンク':>6} {'推論計':>7} {'確認待ち計':>7} {'動いた計':>7} " + print(f" {'試行':<22} {'送り方':<10} {'確かめ':<12} {'速さ':>4} {'チャンク':>6} {'推論計':>7} {'確認待ち計':>7} {'動いた計':>7} " f"{'動いた中央':>7} {'中継点中央':>7} {'合計':>7}") for r in res: how = "記録なし" if r["flow"] is None else ("flow" if r["flow"] else "今まで") - print(f" {r['name']:<22} {how:<10} {r['speed']:>4} {r['n']:>6} {fmt(r['tot']['infer'])} " + print(f" {r['name']:<22} {how:<10} {r['step']:<12} {r['speed']:>4} {r['n']:>6} {fmt(r['tot']['infer'])} " f"{fmt(r['tot']['confirm'])} {fmt(r['tot']['moved'])} {fmt(r['mid']['moved'])} {fmt(r['via'])} " f"{fmt(r['tot']['total'])}") return 0 diff --git a/pi05/run_policy_client.py b/pi05/run_policy_client.py index cc6149a..41eff0c 100644 --- a/pi05/run_policy_client.py +++ b/pi05/run_policy_client.py @@ -15,6 +15,15 @@ --skip-first-confirm を付けると始めの確かめ (最初に実行する推論の前) だけ待たずに実行し, 画面に [CONFIRM] の 1 行・ log.jsonl の頭 (type=model) に skip_first_confirm・そのチャンクの行に confirm_skipped を残す. 2 回目からの確かめは 今までどおり (lab_start.sh が 1 回の起動の中の 2 回目からの試行に付ける. 依頼 177) + --no-step-confirm を付けると (依頼 178. lab_start.sh が既定で付ける) 始めの確かめのあとは入力欄を出さずに次の推論・ + 実行へ進む. 推論中・中継点を送って待つ間・到着の確かめの間に端末でスペース (Enter も可) が押されたら止める予約をし, + 今のチャンクを送り終えてから, 次の推論のあと (送る前) で今までと同じ入力欄 (CONFIRM_PROMPT) を出す (推論中に押せば, + その推論は送らずに入力欄). そこからの p・c・b・r・h・q・s・Enter は今までどおりで, Enter で実行すればまた止まらずに + 進む (s・b・c・p のあとは止めたまま次の推論でも入力欄を出す). 動いている途中では止めない. キーは termios の cbreak と + select で待たずに読み, 入力欄の前・終わり (Ctrl-C・例外も) に端末の設定を戻す. 未到達・関節角を読めないときは + 止める予約を入れて入力欄を出す (--auto のように終了コード 1 にはしない). log.jsonl に type=pause の行 + (event=requested: key・reason・chunk・where・after_chunk・t / event=prompt / event=resume), 入力欄を出した推論の行に + paused, 頭 (type=model) に step_confirm. --auto とは一緒に使えない - 学習データで通った関節範囲 ±ENVELOPE_MARGIN_DEG の外へは出さない (クランプ) - 肩 j1 の上限は J1_SAFE_MAX (88°) で更に切る. これを超える指令はアームが黙って捨てる (LOG352) - 送る直前に最終検査. 6 関節のどれかが安全範囲の外か非有限値なら, 送信もグリッパー操作もせず @@ -724,6 +733,70 @@ class KeyReader: return False +class PauseKeys: + """--no-step-confirm (依頼 178): 推論・送っている間に押されたスペース (Enter も可) を, 待たずに読む. + + arm() で端末を termios の cbreak にし (Ctrl-C はそのまま効く), poll() は select で待たずに溜まったバイトを + 全部読んで, スペースなら "space"・Enter なら "enter"・ほかのキーだけなら "other"・何もなければ None を返す. + 入力欄 (input) を出す前・終わるとき (Ctrl-C・例外も) は disarm() で元の設定に必ず戻す. + 端末でないとき (テストでパイプから流すとき) は端末の設定に触らず何も読まない (_read_pending を差し替えて試す). + """ + KEYS = {" ": "space", "\n": "enter", "\r": "enter"} + + def __init__(self, enabled): + self.enabled = bool(enabled) + self.fd = None + self.old = None + + def arm(self): + if not self.enabled or self.old is not None: + return + try: + if not sys.stdin.isatty(): + return + fd = sys.stdin.fileno() + except Exception: + return + import termios + import tty + self.old = termios.tcgetattr(fd) + self.fd = fd + try: + tty.setcbreak(fd) + except Exception: + self.disarm() + raise + + def disarm(self): + if self.old is None: + return + import termios + termios.tcsetattr(self.fd, termios.TCSADRAIN, self.old) + self.old = None # 戻せてから消す (失敗したら finally でもう一度戻せる. codex R4) + + def _read_pending(self): + if self.old is None: + return "" + import os + import select + buf = b"" + while select.select([self.fd], [], [], 0)[0]: + b = os.read(self.fd, 64) + if not b: + break + buf += b + return buf.decode("utf-8", errors="ignore") + + def poll(self): + if not self.enabled: + return None + s = self._read_pending() + for ch in s: + if ch in self.KEYS: + return self.KEYS[ch] + return "other" if s else None + + def plan_correction_step(cur, joint, sign, step, q, lo, hi, max_move): """補正の 1 刻み. cur (今の補正目標) の joint を sign*step 動かし, 推論と同じ apply_limits (実測 q から) と check_send_safe を通す. 戻り値: (目標, notes, unsafe).""" @@ -1410,11 +1483,17 @@ def main(): ap.add_argument("--skip-first-confirm", action="store_true", help="始めの確かめ (最初に実行する推論の前の Enter) だけを待たずに実行する. 2 回目からの確かめと " "補正・巻き戻し・止める操作は今までどおり (lab_start.sh が 2 回目からの試行に付ける. 依頼 177)") + ap.add_argument("--no-step-confirm", action="store_true", + help="2 回目からの推論は確かめ (Enter) を待たずに実行し, 推論中・送っている間にスペース (Enter も可) を " + "押したときだけ, 今のチャンクを送り終えてから次の推論のあとで止めて今までと同じ入力欄を出す. " + "始めの確かめは今までどおり (既定 off = 1 チャンクごとに確かめる. 依頼 178)") ap.add_argument("--speed", type=int, default=SPEED, help=f"推論のチャンクを送る速さ (既定 {SPEED} = 今までと同じ. 補正・巻き戻し・HOME は {SPEED} のまま. 依頼 176)") args = ap.parse_args() if args.dry_keys and (args.execute or args.auto): sys.exit("[ERROR] --dry-keys はドライラン用 (--execute / --auto と一緒には使えない)") + if args.no_step_confirm and args.auto: + sys.exit("[ERROR] --no-step-confirm は --auto と一緒には使えない (--auto はもともと確かめない)") apply_wait_args(args) apply_grip_args(args) apply_flow_args(args) @@ -1441,6 +1520,7 @@ def main(): "tilt_raw_dir": str(tilt_raw_dir(args)), "tilt_fix": not args.no_tilt_fix, "grip_value": GRIP_VALUE, "flow": bool(args.flow), "flow_tol": args.flow_tol, "speed": CHUNK_SPEED, "skip_first_confirm": bool(args.skip_first_confirm), + "step_confirm": not args.no_step_confirm, "host": args.host, "port": args.port, "t": time.time()}, ensure_ascii=False) + "\n") log_f.flush() @@ -1458,6 +1538,38 @@ def main(): n_rewinds = n_corrections = 0 end_reason, outcome = None, None skip_confirm = bool(args.skip_first_confirm) # 依頼 177: 始めの確かめを 1 回だけ飛ばす (使ったら False) + # 依頼 178: --no-step-confirm. 始めの確かめのあとは入力欄を出さずに進み, スペース (Enter) で止める予約をする + step_pause = PauseKeys(args.no_step_confirm) # --auto とは一緒に使えない (引数の確かめで止める) + first_confirm = True # まだ一度も確かめの分かれ目に来ていない (始めの確かめは今までどおり) + pause_req = None # 止める予約 (log.jsonl の type=pause / event=requested の行). Enter で進めば None + hold_confirm = False # 入力欄で s・b・c・p を選んだ. 次の推論でも入力欄を出す (Enter で実行すれば False. codex R1) + last_exec_chunk = None # 最後に送り始めた推論の番号 (止める予約の「どのチャンクのあとか」) + if args.no_step_confirm: + print("[PAUSE ] --no-step-confirm: 始めの確かめのあとは入力欄を出さずに進みます. 止めるときはスペース " + "(Enter も可). 今のチャンクを送り終えてから, 次の推論のあと (送る前) で入力欄を出します") + + def request_pause(key, chunk, where, reason="key"): + """止める予約を 1 回だけ入れる (1 行出して log.jsonl に type=pause / event=requested). 依頼 178.""" + nonlocal pause_req + if not args.no_step_confirm or pause_req is not None: + return + pause_req = {"type": "pause", "event": "requested", "key": key, "reason": reason, "chunk": chunk, + "where": where, "after_chunk": last_exec_chunk, "t": time.time()} + log_f.write(json.dumps(pause_req) + "\n"); log_f.flush() + why = {"space": "スペース", "enter": "Enter"}.get(key) or { + "not_arrived": "未到達", "read_failed": "関節角を読めない"}.get(reason, reason) + if where == "infer": + print(f" [PAUSE ] 止める予約 ({why}). 推論 {chunk} は送らずに入力欄を出します") + else: + print(f" [PAUSE ] 止める予約 ({why}). 推論 {chunk} を送り終えてから, 次の推論のあと (送る前) で止めます") + + def check_pause(chunk, where): + """溜まったキーを待たずに読む. スペース / Enter なら止める予約 (依頼 178).""" + k = step_pause.poll() + if k in ("space", "enter"): + request_pause(k, chunk, where) + elif k == "other" and pause_req is None: + print(" [PAUSE ] 止めるのはスペース (Enter も可) です (ほかのキーは使いません)") try: cams = camera_resolver.resolve_cameras(require_top=True, require_side=False, verbose=False) cap = cv2.VideoCapture(cams["top"]) @@ -1560,6 +1672,7 @@ def main(): end_reason = "max_chunks" for i in range(args.max_chunks): + step_pause.arm() # 依頼 178: 推論・送っている間はスペースを待たずに読む (入力欄の前で戻す) q = arm.read() if args.dry_keys else read_angles() if q is None: print("[ERROR] 関節角を読めない (daemon を確認). 停止"); exit_code = 1; end_reason = "error"; break @@ -1645,16 +1758,32 @@ def main(): last_sent_target = None grasp = None # つかんだ区間を巻き戻すときの答え (GRASP_PLACED / GRASP_DROPPED) skip_now, skip_confirm = skip_confirm and not args.auto, False - if skip_now: + # 依頼 178: --no-step-confirm は始めの確かめと, 止める予約が入ったときだけ入力欄を出す + check_pause(i, "infer") + need_confirm = ((not args.no_step_confirm) or first_confirm or pause_req is not None + or hold_confirm) + first_confirm = False + if skip_now and pause_req is None: # 依頼 177: lab_start.sh の 2 回目からの試行は, 始めの確かめ (Enter) を待たずに実行する. # 2 回目からの確かめ・補正・巻き戻し・止める操作は今までどおり print(" [CONFIRM] 2 回目からの試行なので始めの確かめ (Enter) を待たずに実行します " "(次の推論からは今までどおり確かめます)") rec["confirm_skipped"] = True - elif not args.auto: + elif not args.auto and need_confirm: + step_pause.disarm() # 依頼 178: 入力欄の前に端末の設定を元に戻す + if pause_req is not None: + rec["paused"] = {"key": pause_req["key"], "reason": pause_req["reason"], + "requested_chunk": pause_req["chunk"], "requested_t": pause_req["t"]} + log_f.write(json.dumps({"type": "pause", "event": "prompt", "key": pause_req["key"], + "reason": pause_req["reason"], "chunk": i, + "after_chunk": last_exec_chunk, "t": time.time()}) + "\n") + log_f.flush() + print(f" [PAUSE ] 止めました (推論 {i} はまだ送っていません). " + "Enter で実行すると, また止まらずに進みます") # 入力を待っている間は wait (人が手でブロックを置き直す. 学習データに使わない. 依頼 27) if recorder is not None: recorder.set_mode(MODE_WAIT) + t_prompt0 = time.time() while True: grasp = None # 依頼 40: たまっているキー (位置合わせを閉じたキー・押しっぱなし) で先へ進まない @@ -1731,6 +1860,16 @@ def main(): break if recorder is not None and ans not in ("q", "h"): recorder.set_mode(MODE_MODEL) + if args.no_step_confirm: + # 依頼 178: 入力欄を出していた時刻 (送らなかったチャンクも chunk_timing の確認待ちに入れる. codex R5) + rec["prompt_t"] = [t_prompt0, time.time()] + # Enter で進めば, また止まらずに進む形に戻る. s・b・c・p のあとは止めたまま (codex R1) + hold_confirm = ans != "" + if ans == "" and pause_req is not None: + log_f.write(json.dumps({"type": "pause", "event": "resume", "chunk": i, + "t": time.time()}) + "\n") + log_f.flush() + pause_req = None if ans == "q": end_reason = "q" log_f.write(json.dumps(rec) + "\n"); log_f.flush() @@ -1827,6 +1966,9 @@ def main(): end_reason = "error" break continue + if not unsafe and (args.execute or args.dry_keys): + step_pause.arm() # 依頼 178: 入力欄のあと, 送っている間もスペースを読む + last_exec_chunk = i if not unsafe and args.dry_keys: # --dry-keys の Enter: 送らずに仮の姿勢を目標へ移す (b / c の流れを試すため) t_ex0 = time.time() @@ -1873,6 +2015,9 @@ def main(): exit_code = 1 log_f.write(json.dumps(rec) + "\n") stopped = True + else: + # 依頼 178: --no-step-confirm でも次の推論のあとで入力欄を出して人に任せる + request_pause(None, i, "send", reason="read_failed") break tgt, notes_now = apply_limits(v["raw"], qa, lo, hi, args.max_move_deg) if notes_now != v["notes"]: @@ -1961,6 +2106,9 @@ def main(): stopped = True broke = True break + # 依頼 178: --no-step-confirm でも次の推論のあとで入力欄を出して人に任せる (今のチャンクは続ける) + request_pause(None, i, "send", reason="not_arrived") + check_pause(i, "send") # 依頼 178: 送っている途中でも読む (止めるのはチャンクのあと) if v_last: # 残ったずれを同じ目標の送り直しで詰める (LOG359). 止める条件は増やさない. rec["settle"], rec["settle_retries_used"] = settle_target( @@ -1971,6 +2119,9 @@ def main(): qa = read_angles() rec["arrived"] = bool(qa is not None and float(np.max(np.abs(final_target - qa[:6]))) <= 3.0) + if not rec["arrived"] and not args.auto: + # 依頼 178 codex R3: --no-step-confirm でも次の推論のあとで入力欄を出して人に任せる + request_pause(None, i, "send", reason="read_failed" if qa is None else "not_arrived") rec["settle"], rec["settle_retries_used"] = settle_target( final_target, f"pi05_chunk{i:03d}", args.settle_tol, args.settle_retries) if not broke: @@ -1989,6 +2140,7 @@ def main(): # 残さないと次の b が 1 つ古い区間を巻き戻してしまう) t_exec_end = time.time() rec["t_exec_start"], rec["t_exec_end"] = t_exec_start, t_exec_end + check_pause(i, "send") rec["sent_targets"] = [_fmt6(x) for x in sent_targets] grip_moved = (not broke) and grip_cmd is not None if sent_targets or grip_moved: @@ -2014,6 +2166,7 @@ def main(): # Ctrl-C でこのチャンクの unsafe / envelope が消えないように). log_f.write(json.dumps(rec) + "\n"); log_f.flush() exit_code = 1 + step_pause.disarm() # 依頼 178: 入力欄の前に端末の設定を元に戻す if args.execute and not args.auto: if recorder is not None: recorder.set_mode(MODE_WAIT) # 入力待ちは wait (codex 依頼 27 P3) @@ -2034,6 +2187,10 @@ def main(): print("\n[STOP ] Ctrl-C") end_reason = "ctrl_c" finally: + try: + step_pause.disarm() # 依頼 178: Ctrl-C・例外でも端末の設定を必ず元に戻す + except Exception as e: + print(f"[WARN ] 端末の設定を元に戻せない: {type(e).__name__}: {e}") # finally ではアームを動かさない (HOME 復帰もサーボ解放もしない). 止まった姿勢は # そのまま保つ: 未知の姿勢から勝手に動かす方が危ない. 戻すときは h で明示的に送る. if recorder is not None: diff --git a/pi05/test_chunk_timing.py b/pi05/test_chunk_timing.py index 3e046f7..b9d2a8b 100644 --- a/pi05/test_chunk_timing.py +++ b/pi05/test_chunk_timing.py @@ -69,6 +69,39 @@ class TestChunkTiming(unittest.TestCase): self.assertEqual(sorted(p for p in self.td.rglob("*")), before) # 何も書き出さない return code, out.getvalue() + def test_no_step_confirm_pause_goes_to_confirm(self): + # 依頼 178: 止めなかったチャンクの確認待ちは 0 に近く, 止める予約で入力欄を出したチャンクの待ちは確認待ちに入る + d = self.td / "pi05_20261114_000001" + write_run(d, [{"type": "model", "model": "m", "grip_value": 20, "step_confirm": False, "t": T0}, + chunk(0, T0, 0.5, T0 + 3.0, T0 + 5.0), + chunk(1, T0 + 5.0, 0.5, T0 + 5.51, T0 + 7.0), + {"type": "pause", "event": "requested", "key": "space", "reason": "key", "chunk": 1, + "where": "send", "after_chunk": 1, "t": T0 + 6.0}, + {"type": "pause", "event": "prompt", "key": "space", "chunk": 2, "t": T0 + 7.5}, + chunk(2, T0 + 7.0, 0.5, T0 + 12.5, T0 + 14.0, + paused={"key": "space", "reason": "key", "requested_chunk": 1}), + {"type": "pause", "event": "resume", "chunk": 2, "t": T0 + 12.5}]) + rows = ct.chunk_rows(ct.load_log(d)[1]) + self.assertAlmostEqual(rows[1]["confirm"], 0.01, places=6) + self.assertAlmostEqual(rows[2]["confirm"], 5.0, places=6) + self.assertIn("止めた(スペース)", rows[2]["note"]) + self.assertEqual(rows[1]["note"], "") + # codex R5: 止めて送らなかったチャンク (c など) も入力欄を閉じるまでが確認待ち + rows2 = ct.chunk_rows([chunk(3, T0 + 20.0, 0.5, prompt_t=[T0 + 20.5, T0 + 24.5], correction_requested=True, + paused={"key": "space", "reason": "key"}), + chunk(4, T0 + 40.0, 0.5)]) + self.assertAlmostEqual(rows2[0]["confirm"], 4.0, places=6) + self.assertIsNone(rows2[0]["moved"]) + # 最後のチャンクを止めて送らずに終えたときも, 入力欄を閉じるまでを合計に入れる (その他が負にならない) + last = ct.chunk_rows([chunk(5, T0 + 50.0, 0.5, prompt_t=[T0 + 50.5, T0 + 55.5])])[0] + self.assertAlmostEqual(last["confirm"], 5.0, places=6) + self.assertAlmostEqual(last["total"], 5.5, places=6) + self.assertAlmostEqual(last["other"], 0.0, places=6) + code, out = self.run_main(d) + self.assertEqual(code, 0) + self.assertIn("確かめ 止めたときだけ", out) + self.assertIn("pause 3", out) + def test_plain_run_uses_states_csv(self): d = self.td / "pi05_20261113_000001" write_run(d, [{"type": "model", "model": "m", "grip_value": 25, "t": T0}, diff --git a/pi05/test_no_step_confirm.py b/pi05/test_no_step_confirm.py new file mode 100644 index 0000000..0b115f6 --- /dev/null +++ b/pi05/test_no_step_confirm.py @@ -0,0 +1,416 @@ +#!/usr/bin/env python3 +"""test_no_step_confirm.py — チャンクごとの確かめをやめ, スペースを押したときだけ止める --no-step-confirm の確かめ +(依頼 178. アームなし). + + python3 pi05/test_no_step_confirm.py # 全部 + python3 pi05/test_no_step_confirm.py -v + +run_policy_client を test_rewind_correct.run_client (偽の daemon / カメラ / モデル) で通し, + - キーなしなら始めの確かめのあと最後まで入力欄が出ない (止めずに進む) + - 送っている途中でスペースが押されたら, そのチャンクを送り終えてから次の推論のあと (送る前) で入力欄が出て, + p・b・q・s が今までどおり動く. Enter で実行するとまた止まらずに進む + - 推論中に押されたら, その推論は送らずに入力欄 + - 未到達・関節角を読めないときは終了コード 1 にせず入力欄を出す + - 入力欄の前には必ず端末の設定を戻し, Ctrl-C でも戻す (PauseKeys を偽物にして数える. 本物は pty で確かめる) + - 付けなければ git HEAD の版と同じ送り方・同じ log (頭の step_confirm だけ増える) +を見る. KIOXIA にもアームにも触らない (一時フォルダだけ). +""" +import importlib.util +import os +import subprocess +import sys +import tempfile +import termios +import time +import unittest +from pathlib import Path +from unittest import mock + +_HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(_HERE)) + +import run_policy_client as rpc # noqa: E402 +import test_rewind_correct # noqa: E402 +from test_rewind_correct import FakePolicy, run_client, strip # noqa: E402 + +EXEC = ["--execute", "--steps-per-chunk", "10", "--via-stride", "3", "--settle-retries", "0", + "--state-from-target", "--ignore-framing", "--max-chunks", "6"] +NSC = EXEC + ["--no-step-confirm"] +# 1 チャンクを送るときの読み取り (poll) の順: 推論のあと 1 → 中継点 4 点 (via02/05/08/09) の送信ごと 1 → 送り終わり 1 + + +class FakeKeys(rpc.PauseKeys): + """端末の代わり. arm / disarm を数え, press に入れた番号の poll でスペース (などの文字) を返す.""" + instances = [] + press = {} + + def __init__(self, enabled): + super().__init__(enabled) + self.calls = [] + self.n_poll = 0 + FakeKeys.instances.append(self) + + def arm(self): + if self.enabled and self.old is None: + self.old = "armed" + self.calls.append("arm") + + def disarm(self): + if self.old is not None: + self.old = None + self.calls.append("disarm") + + def _read_pending(self): + self.n_poll += 1 + return FakeKeys.press.get(self.n_poll, "") + + +class CheckedInputs: + """input() が呼ばれた瞬間に端末の設定が戻っている (偽の PauseKeys が armed でない) ことを確かめる.""" + def __init__(self, values): + self.values, self.k, self.armed_at_input = list(values), 0, [] + + def __iter__(self): + return self + + def __next__(self): + if self.k >= len(self.values): + raise AssertionError(f"入力欄が {self.k + 1} 回目も出た (用意した入力は {len(self.values)} 個)") + self.armed_at_input.append(any(x.old is not None for x in FakeKeys.instances)) + v = self.values[self.k] + self.k += 1 + return v + + +def chunks(lines): + return [x for x in lines if x.get("type") is None and "chunk" in x] + + +def pauses(lines, ev=None): + return [x for x in lines if x.get("type") == "pause" and (ev is None or x["event"] == ev)] + + +def stages(run): + return [l.split(",")[2] for l in (run / "recording" / "states.csv").read_text().splitlines()[1:] + if l.split(",")[1] == "stage"] + + +class Base(unittest.TestCase): + def setUp(self): + self.td = Path(tempfile.mkdtemp()) + time.sleep(1.1) # run のフォルダ名は秒単位なので重ならないように + FakeKeys.instances = [] + FakeKeys.press = {} + self.p = mock.patch.object(rpc, "PauseKeys", FakeKeys) + self.p.start() + + def tearDown(self): + self.p.stop() + + def run_nsc(self, argv, inputs, press=None, **kw): + FakeKeys.press = press or {} + ci = CheckedInputs(inputs) + res = run_client(rpc, argv, ci, self.td, **kw) + self.assertEqual(ci.k, len(inputs), "用意した入力を使い切っていない") + self.assertFalse(any(ci.armed_at_input), "入力欄のときに端末が cbreak のまま") + keys = FakeKeys.instances[-1] + self.assertIsNone(keys.old, "終わったあとに端末の設定が戻っていない") + if keys.calls: + self.assertEqual(keys.calls[-1], "disarm") + return res + (keys,) + + +class TestNoKeys(Base): + def test_runs_to_end_without_prompt(self): + code, world, run, lines, out, keys = self.run_nsc(NSC, [""]) # 始めの確かめ (Enter) の 1 回だけ + self.assertEqual(code, 0) + self.assertIs(lines[0]["step_confirm"], False) + ch = chunks(lines) + self.assertEqual([x["chunk"] for x in ch], list(range(6))) + self.assertTrue(all(x.get("executed") for x in ch)) + self.assertEqual(pauses(lines), []) + self.assertNotIn("止める予約", out) + self.assertIn("[PAUSE ] --no-step-confirm", out) + self.assertEqual(stages(run)[:3], ["model", "wait", "model"]) + self.assertEqual(stages(run).count("wait"), 1) # 待ったのは始めの確かめだけ + self.assertTrue(any(s[0].startswith("pi05_chunk005") for s in world.sends)) + self.assertIn("arm", keys.calls) + + def test_with_skip_first_confirm_no_input_at_all(self): + code, world, run, lines, out, keys = self.run_nsc(NSC + ["--skip-first-confirm"], []) + self.assertEqual(code, 0) + self.assertTrue(all(x.get("executed") for x in chunks(lines))) + self.assertIs(chunks(lines)[0].get("confirm_skipped"), True) + + def test_dry_keys(self): + code, world, run, lines, out, keys = self.run_nsc( + ["--dry-keys", "--steps-per-chunk", "10", "--via-stride", "3", "--max-chunks", "4", + "--no-step-confirm"], [""]) + self.assertEqual(code, 0) + self.assertEqual(world.sends, []) + self.assertEqual([bool(x.get("simulated")) for x in chunks(lines)], [True] * 4) + + def test_auto_rejected(self): + with self.assertRaises(SystemExit): + run_client(rpc, EXEC + ["--auto", "--no-step-confirm"], [], self.td) + + +class TestSpace(Base): + def test_first_prompt_s_keeps_asking(self): + # codex R1: 始めの入力欄で s → 次の推論でも入力欄 → c (補正) → 次も入力欄 → Enter で実行 → あとは止めずに進む + code, world, run, lines, out, keys = self.run_nsc(NSC, ["s", "c", ""], keys="1+\n") + self.assertEqual(code, 0) + ch = chunks(lines) + self.assertEqual([bool(x.get("executed")) for x in ch], [False, False, True, True, True, True]) + self.assertEqual(pauses(lines), []) # スペースは押していない + self.assertTrue(all(len(x["prompt_t"]) == 2 for x in ch[:3])) + self.assertTrue(all("prompt_t" not in x for x in ch[3:])) + + def test_space_while_sending_then_p_b_enter(self): + # 推論 1 の via05 の送信のあと (poll 9) にスペース → 推論 1 は最後まで送る → 推論 2 のあとで入力欄 → p + # → 推論 3 で b (推論 1 を巻き戻す) → 推論 4 で Enter (実行・止めずに進む形に戻る) → 推論 5 は入力欄なし + calls = [] + + def fake_pad(arm, grip, corr_id, chunk, log_f, recorder, lo, hi): + calls.append(chunk) + return None, grip + with mock.patch.object(rpc, "run_pad_correction", fake_pad): + code, world, run, lines, out, keys = self.run_nsc(NSC, ["", "p", "b", ""], press={9: " "}) + self.assertEqual(code, 0) + self.assertEqual(calls, [2]) + ch = chunks(lines) + self.assertEqual([x["chunk"] for x in ch], [0, 1, 2, 3, 4, 5]) + self.assertEqual([bool(x.get("executed")) for x in ch], [True, True, False, False, True, True]) + labels = [s[0] for s in world.sends] + c1 = [lb for lb in labels if lb.startswith("pi05_chunk001")] + self.assertEqual(c1, ["pi05_chunk001_via02", "pi05_chunk001_via05", "pi05_chunk001_via08", + "pi05_chunk001_via09"]) # 押したあとも推論 1 は最後まで + self.assertFalse(any(lb.startswith("pi05_chunk002") or lb.startswith("pi05_chunk003") for lb in labels)) + req = pauses(lines, "requested") + self.assertEqual(len(req), 1) + self.assertEqual((req[0]["key"], req[0]["reason"], req[0]["chunk"], req[0]["where"], req[0]["after_chunk"]), + ("space", "key", 1, "send", 1)) + self.assertEqual([x["chunk"] for x in pauses(lines, "prompt")], [2, 3, 4]) + self.assertEqual([x["chunk"] for x in pauses(lines, "resume")], [4]) + self.assertEqual(ch[2]["paused"]["key"], "space") + self.assertTrue(ch[2].get("correction_requested")) + self.assertTrue(ch[3].get("rewind_requested")) + rw = [x for x in lines if x.get("type") == "rewind"] + self.assertEqual([x["chunk"] for x in rw], [1]) + self.assertTrue(rw[0]["finished"]) + self.assertNotIn("paused", ch[5]) + self.assertIn("[PAUSE ] 止める予約 (スペース). 推論 1 を送り終えてから", out) + self.assertIn("[PAUSE ] 止めました (推論 2 はまだ送っていません)", out) + # 入力欄の間は wait. 推論 5 (入力欄なし) のまわりには wait がない + st = stages(run) + self.assertEqual(st.count("wait"), 4) + self.assertEqual(st[-1], "model") + + def test_space_then_q(self): + code, world, run, lines, out, keys = self.run_nsc(NSC, ["", "q", ""], press={12: " "}) + self.assertEqual(code, 0) + ch = chunks(lines) + self.assertEqual([bool(x.get("executed")) for x in ch], [True, True, False]) + self.assertEqual(pauses(lines, "requested")[0]["where"], "send") # 送り終わりの読み取り + self.assertFalse(any(s[0].startswith("pi05_chunk002") for s in world.sends)) + + def test_enter_also_pauses_and_s(self): + # Enter でも止まる. s は送らずに次へ (止めたまま) → Enter で実行 + code, world, run, lines, out, keys = self.run_nsc(NSC, ["", "s", ""], press={8: "\n"}) + self.assertEqual(code, 0) + ch = chunks(lines) + self.assertEqual([bool(x.get("executed")) for x in ch], [True, True, False, True, True, True]) + self.assertEqual(pauses(lines, "requested")[0]["key"], "enter") + self.assertEqual([x["chunk"] for x in pauses(lines, "prompt")], [2, 3]) + + def test_space_during_inference_does_not_send(self): + # 推論 1 の直後の読み取り (poll 7) で押されていたら, 推論 1 は送らずに入力欄 → q + code, world, run, lines, out, keys = self.run_nsc(NSC, ["", "q", ""], press={7: " "}) + self.assertEqual(code, 0) + ch = chunks(lines) + self.assertEqual([bool(x.get("executed")) for x in ch], [True, False]) + self.assertEqual(pauses(lines, "requested")[0]["where"], "infer") + self.assertFalse(any(s[0].startswith("pi05_chunk001") for s in world.sends)) + self.assertIn("推論 1 は送らずに入力欄を出します", out) + + def test_other_key_does_not_pause(self): + code, world, run, lines, out, keys = self.run_nsc(NSC, [""], press={8: "x"}) + self.assertEqual(code, 0) + self.assertEqual(pauses(lines), []) + self.assertIn("止めるのはスペース", out) + + +class TestFailures(Base): + def test_not_arrived_prompts_instead_of_exit(self): + code, world, run, lines, out, keys = self.run_nsc(NSC, ["", "q", ""], stuck_prefix="pi05_chunk002_via05") + self.assertEqual(code, 0) # --auto のように 1 にはしない + req = pauses(lines, "requested") + self.assertEqual((req[0]["key"], req[0]["reason"], req[0]["chunk"]), (None, "not_arrived", 2)) + ch = chunks(lines) + self.assertIs(ch[2]["arrived"], True) # 最後の点は着いた (途中の点の未到達でも続けるのは今までどおり) + self.assertEqual([bool(x.get("executed")) for x in ch], [True, True, True, False]) + self.assertEqual([x["chunk"] for x in pauses(lines, "prompt")], [3]) + + def test_read_failed_prompts(self): + # 推論 1 の via05 のあと 10 回読めない (送ったあとの読み取り 5 回 + via08 を送る直前の 5 回) → via08 から送らない + orig = test_rewind_correct.FakeWorld.send_wait + + def send_wait(world, target, label, tol, *a, **k): + r = orig(world, target, label, tol, *a, **k) + if label == "pi05_chunk001_via05": + world.fail_main_reads = 10 + return r + with mock.patch.object(test_rewind_correct.FakeWorld, "send_wait", send_wait): + code, world, run, lines, out, keys = self.run_nsc(NSC, ["", "q", ""]) + self.assertFalse(any(s[0] == "pi05_chunk001_via08" for s in world.sends)) + self.assertEqual(code, 0) + req = pauses(lines, "requested") + self.assertEqual((req[0]["reason"], req[0]["chunk"]), ("read_failed", 1)) + self.assertEqual([x["chunk"] for x in pauses(lines, "prompt")], [2]) + + def test_skipped_final_via_not_arrived_prompts(self): + # codex R3: 最後の中継点が「0.5° 以下で送らない」になり, そのあとの到着の読み取りができない → 入力欄 + class Flat(FakePolicy): + def infer(self, obs): + out = super().infer(obs) + out["actions"][6:] = out["actions"][5] # step 5 のあとは動かない (via08・via09 は送らない) + return out + orig_send, orig_read = test_rewind_correct.FakeWorld.send_wait, rpc.read_angles + st = {"armed": False, "n": 0} + + def send_wait(world, target, label, tol, *a, **k): + r = orig_send(world, target, label, tol, *a, **k) + if label == "pi05_chunk001_via05": + st["armed"] = True + return r + + def read_angles(): + if st["armed"]: + st["n"] += 1 + if st["n"] == 4: # 送ったあと・via08 の前・via09 の前 のあと = 最後の到着の読み取り + st["armed"] = False + return None + return orig_read() + with mock.patch.object(test_rewind_correct.FakeWorld, "send_wait", send_wait), \ + mock.patch.object(rpc, "read_angles", read_angles): + code, world, run, lines, out, keys = self.run_nsc(NSC, ["", "q", ""], policy_cls=Flat) + self.assertEqual(code, 0) + ch = chunks(lines) + self.assertIs(ch[1]["arrived"], False) + self.assertIs(ch[1]["executed"], True) # 途中で止まった (broke) のではない + self.assertFalse(any(x[0] in ("pi05_chunk001_via08", "pi05_chunk001_via09") for x in world.sends)) + req = pauses(lines, "requested") + self.assertEqual((req[0]["reason"], req[0]["chunk"]), ("read_failed", 1)) + self.assertEqual([x["chunk"] for x in pauses(lines, "prompt")], [2]) + + def test_ctrl_c_restores_terminal(self): + class Boom(FakePolicy): + n = 0 + + def infer(self, obs): + Boom.n += 1 + if Boom.n == 3: + raise KeyboardInterrupt + return super().infer(obs) + code, world, run, lines, out, keys = self.run_nsc(NSC, [""], policy_cls=Boom) + self.assertEqual(code, 0) + self.assertIn("Ctrl-C", out) + self.assertEqual(keys.calls[-1], "disarm") + + +class TestRealTerminal(unittest.TestCase): + """本物の PauseKeys を pty で: cbreak になり, スペースを待たずに読み, 元の設定に戻る.""" + @staticmethod + def norm(a): + a = list(a) + a[3] &= ~getattr(termios, "PENDIN", 0) + return a + + def test_pty(self): + master, slave = os.openpty() + f = os.fdopen(slave, "r") + try: + before = termios.tcgetattr(slave) + with mock.patch.object(sys, "stdin", f): + k = rpc.PauseKeys(True) + k.arm() + now = termios.tcgetattr(slave) + self.assertFalse(now[3] & termios.ICANON) + self.assertFalse(now[3] & termios.ECHO) + self.assertTrue(now[3] & termios.ISIG) # Ctrl-C は効く + self.assertIsNone(k.poll()) # 何もなければ待たずに None + os.write(master, b"x") + time.sleep(0.05) + self.assertEqual(k.poll(), "other") + os.write(master, b"ab ") + time.sleep(0.05) + self.assertEqual(k.poll(), "space") + os.write(master, b"\r") + time.sleep(0.05) + self.assertEqual(k.poll(), "enter") + k.disarm() + # PENDIN (読み残しの打ち直し) は端末が自分で立てる印なので比べない + self.assertEqual(self.norm(termios.tcgetattr(slave)), self.norm(before)) + k.disarm() # 2 回呼んでもよい + off = rpc.PauseKeys(False) + off.arm() + self.assertEqual(self.norm(termios.tcgetattr(slave)), self.norm(before)) # 付けなければ触らない + self.assertIsNone(off.poll()) + finally: + f.close() + os.close(master) + + +class TestDisarmRetry(unittest.TestCase): + def test_restore_failure_can_retry(self): + # codex R4: 戻すのに失敗しても保存した設定は消さず, もう一度 disarm で戻せる + k = rpc.PauseKeys(True) + k.fd, k.old = 99, ["saved"] + calls = [] + + def bad(fd, when, attrs): + calls.append(attrs) + if len(calls) == 1: + raise termios.error("busy") + with mock.patch.object(termios, "tcsetattr", bad): + with self.assertRaises(termios.error): + k.disarm() + self.assertEqual(k.old, ["saved"]) + k.disarm() + self.assertIsNone(k.old) + self.assertEqual(calls, [["saved"], ["saved"]]) + + +class TestUnchangedWithoutFlag(unittest.TestCase): + """付けなければ git HEAD の版と同じ送り方・同じ log (頭の step_confirm だけ増える).""" + def test_same_as_head(self): + src = subprocess.run(["git", "show", "HEAD:pi05/run_policy_client.py"], cwd=_HERE, + capture_output=True, text=True) + if src.returncode != 0: + self.skipTest("git HEAD の版が読めない") + td = Path(tempfile.mkdtemp()) + p = td / "run_policy_client_head.py" + p.write_text(src.stdout) + spec = importlib.util.spec_from_file_location("run_policy_client_head", p) + old = importlib.util.module_from_spec(spec) + spec.loader.exec_module(old) + for argv, inputs, kw in ( + (EXEC + ["--skip-first-confirm"], ["", "c", "b", "s", "", "h", "y"], {"keys": "1++\n"}), + (EXEC, ["", "", "", "q", ""], {"stuck_prefix": "pi05_chunk001_via05"}), + (EXEC, ["", "", "q", ""], {"fail_after_label": "pi05_chunk001_via05"})): + time.sleep(1.1) + c_old, w_old, _, l_old, o_old = run_client(old, argv, inputs, td, **kw) + time.sleep(1.1) + c_new, w_new, _, l_new, o_new = run_client(rpc, argv, inputs, td, **kw) + self.assertEqual(c_old, c_new, argv) + self.assertEqual(w_old.sends, w_new.sends, argv) + self.assertEqual(w_old.grips, w_new.grips, argv) + drop = ("t", "latency_s", "reference", "step_confirm", "t_start", "t_end", "t_exec_start", "t_exec_end", + "ended_at", "segment_t") + self.assertEqual(strip(l_old, drop=drop), strip(l_new, drop=drop), argv) + self.assertNotIn("[PAUSE ]", o_new) + self.assertTrue(all("step_confirm" not in x for x in l_new[1:])) + + +if __name__ == "__main__": + unittest.main() diff --git a/pi05/test_rewind_correct.py b/pi05/test_rewind_correct.py index f20e313..1847f12 100644 --- a/pi05/test_rewind_correct.py +++ b/pi05/test_rewind_correct.py @@ -606,7 +606,8 @@ class TestClientFlow(unittest.TestCase): "tilt_raw_dir", "tilt_fix", "measured_on", "rotate_deg", # 依頼 144 "grip_value", # 依頼 152 "flow", "flow_tol", "speed", # 依頼 176 (type=model の頭) - "skip_first_confirm") # 依頼 177 (type=model の頭) + "skip_first_confirm", # 依頼 177 (type=model の頭) + "step_confirm") # 依頼 178 (type=model の頭) # HEAD が依頼 25 より前なら new_keys は新しい方にだけある. 依頼 25 以降なら両方にある (両方から外す) drop = ("t", "latency_s", "reference") + new_keys so, sn = strip(l_old, drop=drop), strip(l_new, drop=drop) diff --git a/test_lab_start.sh b/test_lab_start.sh index 626f1eb..df1279f 100755 --- a/test_lab_start.sh +++ b/test_lab_start.sh @@ -600,7 +600,7 @@ check "--serve-only でも空打ちまで行う (依頼 176)" 'has out.txt "=== check "Pod は消さない (DELETE を呼ばない) で, かかった時間と片付け方を出す" '[ $(n_call DELETE) = 0 ] && has out.txt "=== かかった時間" && has out.txt "Pod は残しています (id $ID_NEW). 片付けは ./lab_stop.sh --log LogT"' check "記録 lab_start_*.txt に残る・始めの行に --serve-only と出る" 'grep -qF "サーバーとトンネルだけ (--serve-only" "$T/data/lab/LogT"/lab_start_*.txt' rm -rf "$T" -check "--help に --serve-only・--grip-value・--flow / --speed・5b の空打ちの説明が入る (2〜58 行)" 'sed -n "2,58p" "$HERE/lab_start.sh" | grep -qF -- "--serve-only Pod を作って" && sed -n "2,58p" "$HERE/lab_start.sh" | grep -qF -- "--no-tilt-fix 傾きを" && sed -n "2,58p" "$HERE/lab_start.sh" | grep -qF -- "--grip-value N 爪の閉じる値" && sed -n "2,58p" "$HERE/lab_start.sh" | grep -qF -- "--flow / --speed N run_policy_client.py に" && sed -n "2,58p" "$HERE/lab_start.sh" | grep -qF -- "# 5b. 空打ち" && grep -qF "sed -n '"'"'2,58p'"'"'" "$HERE/lab_start.sh"' +check "--help に --serve-only・--grip-value・--flow / --speed・5b の空打ちの説明が入る (2〜61 行)" 'sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "--serve-only Pod を作って" && sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "--no-tilt-fix 傾きを" && sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "--grip-value N 爪の閉じる値" && sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "--flow / --speed N run_policy_client.py に" && sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "# 5b. 空打ち" && grep -qF "sed -n '"'"'2,61p'"'"'" "$HERE/lab_start.sh"' echo "== 空打ち (依頼 176): トンネルのあと・アームの前に 1 回. 失敗しても止めずに続ける" setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run @@ -652,6 +652,16 @@ check "1 回目には付けず, 2 回目・3 回目の終わりに --skip-first- rm -rf "$T" check "実機の 8 も 2 回目からは --skip-first-confirm を渡し, 7 の HOME・爪を開くは毎回流す" '[ "$(grep -c '"'"'${CONFIRM_ARGS\[@\]+"${CONFIRM_ARGS\[@\]}"}'"'"' "$HERE/lab_start.sh")" = 2 ] && grep -qF "[ \$round -ge 2 ] && CONFIRM_ARGS=(--skip-first-confirm)" "$HERE/lab_start.sh" && [ "$(awk "/^while :; do/,/^done/" "$HERE/lab_start.sh" | grep -c "08_home_from_anywhere.py\|daemon_set_gripper(0)")" = 2 ]' +echo "== チャンクごとの確かめ (依頼 178): 既定は --no-step-confirm を渡す. --step-confirm で今までどおり" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run +check "既定ではクライアントに --no-step-confirm を渡し, [CONFIRM] で出す" '[ $RC = 0 ] && [ "$(grep -c -- "pi05/run_policy_client.py .* --no-step-confirm" "$T/py.log")" = 1 ] && has out.txt "[CONFIRM] チャンクごとには確かめない (--no-step-confirm"' +rm -rf "$T" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run --step-confirm --flow +check "--step-confirm なら --no-step-confirm を渡さず (ほかの引数は同じ), [CONFIRM] で出す" '[ $RC = 0 ] && has py.log "pi05/run_policy_client.py" && ! has py.log "--no-step-confirm" && grep -q -- "pi05/run_policy_client.py .* --flow$" "$T/py.log" && has out.txt "[CONFIRM] チャンクごとに確かめる (--step-confirm"' +rm -rf "$T" +check "実機の 8 にも既定で --no-step-confirm を渡す (8 の 2 か所)" '[ "$(grep -c '"'"'${STEP_ARGS\[@\]+"${STEP_ARGS\[@\]}"}'"'"' "$HERE/lab_start.sh")" = 2 ] && grep -qF "STEP_ARGS=(--no-step-confirm)" "$HERE/lab_start.sh" && grep -qF -- "--step-confirm) STEP_ARGS=(); shift ;;" "$HERE/lab_start.sh"' +check "--help に --step-confirm の説明が入る" 'sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "--step-confirm 実機推論で"' + echo echo "OK $OK / NG $NG" [ $NG = 0 ] ``` ## Runpod の A40 で π0.5 を動かし、送り方を変えて7回比べた 11月14日の夕方、位置5 にブロックを置いて、3回 `lab_start.sh` を起動しました。Pod は1回目に作り、2回目と3回目はそのままつなぎ直しています。閉じる値はどれも25、モデルは deep1 です。 | 起動 | 送り方 | 試行 | 結果 | 推論 | Enter 待ち | 動いた | 1チャンクの動き（中央） | 合計 | |---|---|---|---|---|---|---|---|---| | 直す前（LOG504） | 今まで・速さ20・毎回 Enter | 193254 | 成功 | 70.3 | 31.7 | 40.8 | 2.44 | 144.4 | | 1回目 | `--flow`・速さ20 | 180457 | 成功 | 21.2 | 4.4 | 66.6 | 2.23 | 95.2 | | 1回目 | `--flow`・速さ20 | 180704 | 成功 | 15.2 | 2.1 | 44.3 | 2.34 | 63.4 | | 2回目 | 今まで・速さ20 | 181057 | 失敗 | 19.1 | 28.4 | 55.1 | 2.46 | 104.9 | | 2回目 | 今まで・速さ20 | 181300 | 成功 | 22.9 | 2.2 | 62.7 | 2.37 | 90.4 | | 3回目 | `--flow`・速さ30 | 182039 | 成功 | 13.9 | 11.0 | 42.0 | 2.29 | 68.6 | | 3回目 | `--flow`・速さ30 | 182211 | 成功 | 13.0 | 1.7 | 38.0 | 2.35 | 54.1 | | 3回目 | `--flow`・速さ30 | 182327 | 置いたあと空振り | 54.5 | 0.0 | 137.0 | 2.19 | 198.5 | （秒。`chunk_timing.py` の比べる表から。2回目の起動では、2つ目の試行の始めの Enter を飛ばしている） ### 縮んだのは待ちで、1チャンクの動きは縮まなかった - 空打ちは効いた：1回目の起動の空打ちは52.6秒かかり、本番の1回目の推論は0.69秒で返った。2回目・3回目の起動では、同じ Pod なので空打ちは0.9秒と1.2秒だった - Enter 待ちはほぼ消えた：残っているのは、1回目の試行の始めと、止めるときに押した分だけ - `--flow` の差は小さかった：1チャンクの動きは、`--flow` ありで2.23・2.34秒、なしで2.46・2.37秒。差は0.1〜0.2秒 - 速さ30も効かなかった：2.19〜2.35秒で、速さ20と変わらない `--flow` のログを見ると、途中の中継点はどれも0.4〜0.6秒で「近づいた」として次へ進んでいました。送る間隔の下限を0.4秒にしてあるので、4つの中継点を送ると、それだけで2秒近くになります。アームが速く動いても、次を送るまでの間隔が時間を決めていた、と読んでいます。 ### `--flow` のときに関節の角度が読めないことが増えた `--flow` ありの試行では、関節の角度が読めない警告（`daemon_get_angles failed`）が、1回目の起動の2つの試行で4回、3回目の起動で3回出ました。読めないと「見込みの時間」が過ぎるまで次を送れず、180457 のチャンク2 では6.36秒、チャンク12 では3.50秒止まっています。`--flow` なしの2回目の起動では1回でした。途中で角度を読む回数が増えた分、読み取りが失敗しやすくなっているのかもしれません。ここはまだ推測で、回数を重ねて見ます。 ### 上カメラの傾きは、ソフトでそろえて足りていた LOG504 では、上カメラの傾きが -6.5° あり、記事の終わりに「iPhone の付け方を見直す」と書いていました。手で ±0.5° に合わせるのは11月10日に試して難しいと分かり、そのあと傾きはソフトで回してそろえる形にしてあります（依頼144）。なので、この回は付け方をやり直さず、大きく傾いていないかだけを見ました。3回の起動とも、推論に渡す前の傾きは -1.87〜-1.99° で、+1.25〜+1.38° 回してそろえています。位置合わせの画面で -10° 前後と出たコマは、アームや手がマットの角を隠したときのものです。 ### `chunk_timing.py` で8回を並べた出力 ``` == pi05_20261113_193254 (/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261113_193254) 送り方: 記録なし (依頼 176 より前 = --flow なし・速さ 20) 速さ 20 モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 閉じる値 25 確かめ 毎チャンク(記録なし) チャンク 推論 確認待ち 動いた その他 合計 中継点ごと (秒) メモ 0 57.53 20.93 5.81 0.13 84.40 0.50 0.92 0.94 0.32 始めに爪を開いた 1 1.84 0.59 2.46 0.14 5.03 0.52 0.66 0.82 0.32 2 0.63 0.56 2.33 0.16 3.68 0.48 0.74 0.64 0.32 3 0.64 0.52 2.41 0.13 3.70 0.64 0.64 0.62 0.34 4 0.59 0.55 2.03 0.10 3.26 0.64 0.64 0.40 0.14 5 0.66 1.17 2.56 0.07 4.47 0.46 0.40 0.52 0.95 爪→閉 6 1.62 0.60 2.35 0.10 4.67 0.56 0.64 0.60 0.30 7 0.62 1.32 2.47 0.13 4.53 0.48 0.76 0.64 0.32 8 0.61 1.31 2.33 0.05 4.31 0.62 0.62 0.64 0.30 9 1.54 1.10 2.30 0.12 5.06 0.62 0.62 0.56 0.32 10 0.55 0.50 2.97 0.14 4.17 0.94 0.86 0.72 0.24 11 0.56 0.48 5.35 0.09 6.47 0.82 0.82 0.52 3.08 爪→開 12 0.86 1.56 2.33 0.12 4.87 0.64 0.64 0.62 0.28 13 1.49 0.48 3.11 0.13 5.20 0.82 0.72 1.02 0.34 14 0.59 - - 0.00 0.59 HOME 合計 70.30 31.68 40.81 1.60 144.40 中央値 0.64 0.60 2.44 0.12 4.53 推論: 1 回目 57.53 秒 / 2 回目からの中央値 0.63 秒 中継点の間の中央値 0.62 秒 (states.csv の送った時刻) 終わり方: 人が止めた (h で HOME) そのほかの行: framing 1 tilt_fix 1 == pi05_20261114_180457 (/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_180457) 送り方: --flow (近づく 5.0°) 速さ 20 モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 閉じる値 25 確かめ 止めたときだけ チャンク 推論 確認待ち 動いた その他 合計 中継点ごと (秒) メモ 0 0.69 2.23 5.02 0.12 8.06 2:0.59近 5:0.59近 8:0.52近 9:0.30着 始めに爪を開いた 1 0.55 0.00 2.30 0.12 2.97 2:0.54近 5:0.62近 8:0.70近 9:0.30着 2 1.54 0.00 8.00 0.13 9.66 2:0.55近 5:6.36時 8:0.64近 9:0.30着 3 0.62 0.00 2.17 0.15 2.94 2:0.52近 5:0.51近 8:0.70近 9:0.30着 4 0.55 0.00 2.30 0.14 2.99 2:0.51近 5:0.60近 8:0.68近 9:0.30着 5 0.79 0.00 1.92 0.12 2.83 2:0.60近 4:0.28着 爪→閉 6 1.49 0.00 2.17 0.13 3.80 2:0.42近 5:0.54近 8:0.72近 9:0.30着 7 0.64 0.00 2.25 0.15 3.03 2:0.52近 5:0.54近 8:0.70近 9:0.30着 8 0.60 0.00 2.19 0.14 2.93 2:0.52近 5:0.52近 8:0.70近 9:0.30着 9 1.82 0.00 1.98 0.14 3.93 2:0.50近 5:0.54近 8:0.59近 9:0.22着 10 0.72 0.00 2.30 0.14 3.17 2:0.58近 5:0.60近 8:0.70近 9:0.28着 11 0.56 0.00 4.69 0.11 5.37 2:0.52近 5:0.54近 8:0.60近 9:0.12着 爪→開 12 0.56 0.00 5.11 0.10 5.77 2:0.60近 5:0.59近 8:3.50時 9:0.30着 13 1.49 0.00 2.41 0.14 4.04 2:0.50近 5:0.61近 8:0.76近 9:0.32着 14 0.55 0.00 2.25 0.13 2.93 2:0.60近 5:0.53近 8:0.61近 9:0.32着 15 0.59 0.00 2.06 0.12 2.76 2:0.52近 5:0.52近 8:0.59近 9:0.22着 16 0.60 0.00 2.11 0.16 2.87 2:0.54近 5:0.52近 8:0.59近 9:0.29着 17 0.74 0.00 2.14 0.12 3.00 2:0.53近 5:0.54近 8:0.63近 9:0.32着 18 1.45 0.00 2.21 0.14 3.80 2:0.51近 5:0.56近 8:0.70近 9:0.30着 19 0.56 0.00 2.16 0.12 2.84 2:0.52近 5:0.53近 8:0.60近 9:0.30着 20 0.68 0.00 2.10 0.11 2.90 2:0.44近 5:0.50近 8:0.68近 9:0.30着 21 1.50 0.00 2.28 0.11 3.90 2:0.52近 5:0.60近 8:0.70近 9:0.30着 22 0.54 0.00 2.25 0.11 2.90 2:0.52近 5:0.58近 8:0.70近 9:0.30着 23 0.60 0.00 2.19 0.12 2.90 2:0.50近 5:0.52近 8:0.70近 9:0.30着 24 0.73 2.21 - 0.00 2.93 止めた(Enter) HOME 合計 21.16 4.44 66.56 3.06 95.23 中央値 0.64 0.00 2.23 0.12 2.99 推論: 1 回目 0.69 秒 / 2 回目からの中央値 0.63 秒 中継点の間の中央値 0.53 秒 (log.jsonl の flow) 中継点ごと: step:秒+わけ (近=近づいた 時=見込みの時間 着=最後の点が着いた 未=着かなかった 失=送れなかった) 終わり方: 人が止めた (h で HOME) そのほかの行: framing 1 pause 2 tilt_fix 1 == pi05_20261114_180704 (/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_180704) 送り方: --flow (近づく 5.0°) 速さ 20 モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 閉じる値 25 確かめ 止めたときだけ チャンク 推論 確認待ち 動いた その他 合計 中継点ごと (秒) メモ 0 1.68 0.00 5.03 0.14 6.85 2:0.57近 5:0.54近 8:0.64近 9:0.30着 始めに爪を開いた 1 0.74 0.00 2.18 0.14 3.06 2:0.50近 5:0.60近 8:0.62近 9:0.34着 2 1.39 0.00 8.04 0.12 9.54 2:0.52近 5:0.54近 8:6.50時 9:0.32着 3 0.72 0.00 2.22 0.06 3.00 2:0.62近 5:0.55近 8:0.62近 9:0.32着 4 0.55 0.00 2.60 0.10 3.24 2:0.58近 5:0.70近 8:0.30着 爪→閉 5 0.59 0.00 2.17 0.10 2.86 2:0.52近 5:0.52近 8:0.64近 9:0.30着 6 1.56 0.00 2.35 0.16 4.07 2:0.70近 5:0.60近 8:0.62近 9:0.31着 7 0.64 0.00 2.34 0.12 3.10 2:0.54近 5:0.51近 8:0.79近 9:0.30着 8 0.56 0.00 2.35 0.11 3.03 2:0.54近 5:0.49近 8:0.79近 9:0.32着 9 0.83 0.00 2.18 0.13 3.14 2:0.52近 5:0.52近 8:0.70近 9:0.30着 10 1.55 0.00 3.95 0.09 5.60 2:0.62近 3:0.22着 爪→開 11 0.63 0.00 2.06 0.14 2.83 2:0.44近 5:0.53近 8:0.63近 9:0.30着 12 1.69 0.00 2.11 0.14 3.93 2:0.44近 5:0.52近 8:0.70近 9:0.30着 13 0.73 0.00 2.19 0.15 3.07 2:0.50近 5:0.52近 8:0.64近 9:0.30着 14 0.78 0.00 2.53 0.12 3.43 2:0.60近 5:0.54近 8:0.82近 9:0.40着 15 0.55 2.09 - 0.00 2.64 止めた(Enter) HOME 合計 15.18 2.09 44.30 1.83 63.41 中央値 0.74 0.00 2.34 0.12 3.12 推論: 1 回目 1.68 秒 / 2 回目からの中央値 0.73 秒 中継点の間の中央値 0.53 秒 (log.jsonl の flow) 中継点ごと: step:秒+わけ (近=近づいた 時=見込みの時間 着=最後の点が着いた 未=着かなかった 失=送れなかった) 終わり方: 人が止めた (h で HOME) そのほかの行: framing 1 pause 2 tilt_fix 1 == pi05_20261114_181057 (/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_181057) 送り方: --flow なし 速さ 20 モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 閉じる値 25 確かめ 止めたときだけ チャンク 推論 確認待ち 動いた その他 合計 中継点ごと (秒) メモ 0 0.79 25.48 5.50 0.16 31.93 0.64 0.52 0.96 0.32 始めに爪を開いた 1 0.64 0.00 2.98 0.15 3.77 0.72 0.72 0.90 0.46 2 1.48 0.00 2.40 0.11 4.00 0.62 0.62 0.72 0.32 3 0.58 0.00 5.30 0.05 5.93 0.54 3.62 0.64 0.32 4 0.57 0.00 2.42 0.04 3.04 0.64 0.64 0.64 0.32 5 1.54 0.00 1.85 0.14 3.53 0.62 1.12 爪→閉 6 0.75 0.00 2.40 0.22 3.37 0.62 0.60 0.74 0.34 7 1.71 0.00 2.47 0.12 4.30 0.80 0.64 0.54 0.34 8 0.94 0.00 2.20 0.09 3.24 0.52 0.62 0.62 0.32 9 0.78 0.00 2.33 0.12 3.23 0.64 0.64 0.62 0.32 10 0.75 0.00 2.36 0.11 3.23 0.62 0.62 0.60 0.30 11 0.60 0.00 2.27 0.14 3.00 0.62 0.62 0.60 0.32 12 0.56 0.00 2.52 0.12 3.20 0.62 0.64 0.72 0.34 13 1.55 0.00 2.54 0.13 4.23 0.62 0.74 0.64 0.32 14 0.62 0.00 3.03 0.12 3.77 爪→開 15 0.56 0.00 2.58 0.03 3.17 0.62 0.84 0.64 0.30 16 0.56 0.00 2.25 0.12 2.93 0.52 0.62 0.64 0.36 17 1.49 0.00 2.75 0.13 4.37 0.64 0.82 0.80 0.34 18 0.58 0.00 2.45 0.14 3.17 0.62 0.62 0.62 0.32 19 0.56 0.00 2.46 0.11 3.14 0.60 0.72 0.64 0.34 20 1.48 2.91 - -0.00 4.39 止めた(Enter) HOME 合計 19.11 28.40 55.09 2.34 104.93 中央値 0.75 0.00 2.46 0.12 3.37 推論: 1 回目 0.79 秒 / 2 回目からの中央値 0.70 秒 中継点の間の中央値 0.62 秒 (states.csv の送った時刻) 終わり方: 人が止めた (h で HOME) そのほかの行: framing 1 pause 2 tilt_fix 1 == pi05_20261114_181300 (/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_181300) 送り方: --flow なし 速さ 20 モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 閉じる値 25 確かめ 止めたときだけ チャンク 推論 確認待ち 動いた その他 合計 中継点ごと (秒) メモ 0 0.60 0.00 5.51 0.05 6.16 0.90 0.74 0.64 0.32 始めに爪を開いた 1 0.56 0.00 2.73 0.04 3.33 0.64 0.64 0.96 0.30 2 0.56 0.00 2.35 0.16 3.06 0.62 0.62 0.60 0.30 3 0.78 0.00 2.34 0.13 3.24 0.64 0.62 0.48 0.32 4 1.55 0.00 2.42 0.12 4.10 0.60 0.72 0.66 0.32 5 0.78 0.00 1.32 0.13 2.23 1.14 爪→閉 6 1.72 0.00 2.33 0.12 4.17 0.52 0.62 0.74 0.34 7 0.82 0.00 2.53 0.15 3.50 0.62 0.62 0.82 0.36 8 0.74 0.00 2.25 0.13 3.13 0.52 0.52 0.62 0.32 9 0.56 0.00 2.81 0.14 3.50 0.64 0.94 0.72 0.32 10 0.69 0.00 2.19 0.15 3.03 0.62 0.62 0.48 0.32 11 1.54 0.00 2.41 0.12 4.07 0.60 0.72 0.64 0.34 12 0.56 0.00 2.51 0.13 3.20 0.48 0.76 0.64 0.34 13 0.56 0.00 2.37 0.04 2.97 0.50 0.70 0.64 0.32 14 0.76 0.00 4.74 0.10 5.60 0.80 0.62 3.12 爪→開 15 1.56 0.00 2.52 0.13 4.21 0.64 0.80 0.64 0.34 16 0.56 0.00 3.13 0.13 3.83 1.02 0.72 0.84 0.34 17 0.56 0.00 2.89 0.13 3.57 0.64 1.02 0.72 0.32 18 0.82 0.00 2.22 0.13 3.16 0.82 0.30 0.62 0.34 19 1.53 0.00 2.01 0.14 3.67 0.52 0.52 0.62 0.24 20 0.79 0.00 2.21 0.13 3.13 0.62 0.62 0.50 0.34 21 1.54 0.00 2.19 0.04 3.77 0.52 0.62 0.62 0.32 22 0.56 0.00 2.36 0.05 2.97 0.60 0.62 0.62 0.32 23 0.69 0.00 2.34 0.03 3.06 0.62 0.62 0.62 0.30 24 1.52 2.25 - -0.00 3.77 止めた(Enter) HOME 合計 22.90 2.25 62.70 2.59 90.44 中央値 0.76 0.00 2.37 0.13 3.50 推論: 1 回目 0.60 秒 / 2 回目からの中央値 0.77 秒 中継点の間の中央値 0.62 秒 (states.csv の送った時刻) 終わり方: 人が止めた (h で HOME) そのほかの行: framing 1 pause 2 tilt_fix 1 == pi05_20261114_182039 (/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182039) 送り方: --flow (近づく 5.0°) 速さ 30 モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 閉じる値 25 確かめ 止めたときだけ チャンク 推論 確認待ち 動いた その他 合計 中継点ごと (秒) メモ 0 0.57 3.82 7.72 0.12 12.23 2:0.46近 5:3.32時 8:0.66近 9:0.24着 始めに爪を開いた 1 0.59 0.00 2.37 0.11 3.06 2:0.58近 5:0.60近 8:0.68近 9:0.34着 2 1.57 0.00 2.26 0.13 3.97 2:0.60近 5:0.54近 8:0.70近 9:0.30着 3 0.87 0.00 2.16 0.15 3.17 2:0.52近 5:0.53近 8:0.63近 9:0.30着 4 0.85 0.00 2.55 0.11 3.50 2:0.52近 5:0.68近 7:0.24着 爪→閉 5 0.65 0.00 2.31 0.11 3.07 2:0.53近 5:0.60近 8:0.72近 9:0.30着 6 0.57 0.00 2.08 0.11 2.76 2:0.52近 5:0.50近 8:0.62近 9:0.32着 7 1.63 0.00 2.16 0.11 3.90 2:0.50近 5:0.54近 8:0.64近 9:0.32着 8 0.56 0.00 2.31 0.13 3.00 2:0.51近 5:0.62近 8:0.72近 9:0.32着 9 0.57 0.00 5.03 0.09 5.70 2:0.60近 5:0.54近 8:0.62近 9:0.20着 爪→開 10 0.61 0.00 2.40 0.13 3.13 2:0.58近 5:0.62近 8:0.72近 9:0.30着 11 0.61 0.00 2.10 0.12 2.83 2:0.42近 5:0.52近 8:0.72近 9:0.30着 12 1.49 0.00 2.29 0.09 3.87 2:0.54近 5:0.60近 8:0.70近 9:0.28着 13 0.69 0.00 2.11 0.12 2.93 2:0.46近 5:0.55近 8:0.70近 9:0.29着 14 0.56 0.00 2.15 0.12 2.83 2:0.52近 5:0.52近 8:0.70近 9:0.30着 15 1.49 7.15 - 0.00 8.64 止めた(Enter) HOME 合計 13.89 10.97 41.98 1.76 68.60 中央値 0.63 0.00 2.29 0.11 3.15 推論: 1 回目 0.57 秒 / 2 回目からの中央値 0.65 秒 中継点の間の中央値 0.54 秒 (log.jsonl の flow) 中継点ごと: step:秒+わけ (近=近づいた 時=見込みの時間 着=最後の点が着いた 未=着かなかった 失=送れなかった) 終わり方: 人が止めた (h で HOME) そのほかの行: framing 1 pause 2 tilt_fix 1 == pi05_20261114_182211 (/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182211) 送り方: --flow (近づく 5.0°) 速さ 30 モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 閉じる値 25 確かめ 止めたときだけ チャンク 推論 確認待ち 動いた その他 合計 中継点ごと (秒) メモ 0 0.68 0.00 5.30 0.13 6.11 2:0.54近 5:0.58近 8:0.72近 9:0.42着 始めに爪を開いた 1 1.55 0.00 7.15 0.10 8.80 2:0.54近 5:0.58近 8:5.60時 9:0.32着 2 0.80 0.00 2.44 0.10 3.34 2:0.66近 5:0.62近 8:0.69近 9:0.28着 3 0.76 0.00 2.27 0.14 3.17 2:0.60近 5:0.52近 8:0.70近 9:0.28着 4 1.60 0.00 2.75 0.11 4.47 2:0.64近 5:0.76近 8:0.30着 爪→閉 5 0.81 0.00 2.31 0.11 3.23 2:0.41近 5:0.61近 8:0.80近 9:0.30着 6 1.77 0.00 2.19 0.11 4.07 2:0.52近 5:0.54近 8:0.64近 9:0.30着 7 0.75 0.00 2.12 0.10 2.97 2:0.46近 5:0.54近 8:0.70近 9:0.29着 8 0.76 0.00 4.82 0.09 5.66 2:0.46近 5:0.54近 8:0.70近 9:0.18着 爪→開 9 0.64 0.00 2.18 0.12 2.94 2:0.52近 5:0.54近 8:0.64近 9:0.32着 10 0.56 0.00 2.12 0.12 2.80 2:0.54近 5:0.54近 8:0.62近 9:0.30着 11 0.65 0.00 2.39 0.12 3.16 2:0.61近 5:0.62近 8:0.72近 9:0.30着 12 1.66 1.68 - 0.00 3.34 止めた(Enter) HOME 合計 12.98 1.69 38.05 1.35 54.06 中央値 0.76 0.00 2.35 0.11 3.34 推論: 1 回目 0.68 秒 / 2 回目からの中央値 0.78 秒 中継点の間の中央値 0.54 秒 (log.jsonl の flow) 中継点ごと: step:秒+わけ (近=近づいた 時=見込みの時間 着=最後の点が着いた 未=着かなかった 失=送れなかった) 終わり方: 人が止めた (h で HOME) そのほかの行: framing 1 pause 2 tilt_fix 1 == pi05_20261114_182327 (/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182327) 送り方: --flow (近づく 5.0°) 速さ 30 モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 閉じる値 25 確かめ 止めたときだけ チャンク 推論 確認待ち 動いた その他 合計 中継点ごと (秒) メモ 0 0.75 0.00 5.32 0.14 6.21 2:0.52近 5:0.68近 8:0.68近 9:0.39着 始めに爪を開いた 1 0.66 0.00 2.36 0.12 3.14 2:0.52近 5:0.54近 8:0.72近 9:0.38着 2 1.55 0.00 2.09 0.16 3.80 2:0.52近 5:0.60近 8:0.51近 9:0.29着 3 0.56 0.00 2.38 0.16 3.10 2:0.62近 5:0.68近 8:0.67近 9:0.29着 4 0.60 0.00 2.06 0.04 2.70 2:0.52近 5:0.62近 8:0.68近 9:0.12着 5 0.56 0.00 1.44 0.10 2.10 2:0.30着 爪→閉 6 0.68 0.00 2.23 0.13 3.03 2:0.59近 5:0.60近 8:0.62近 9:0.30着 7 1.65 0.00 2.22 0.13 4.00 2:0.62近 5:0.60近 8:0.59近 9:0.29着 8 0.83 0.00 2.10 0.14 3.07 2:0.51近 5:0.52近 8:0.61近 9:0.28着 9 1.77 0.00 2.27 0.13 4.17 2:0.52近 5:0.52近 8:0.72近 9:0.30着 10 1.09 0.00 4.42 0.09 5.60 2:0.42近 5:0.64近 8:0.30着 爪→開 11 0.76 0.00 2.20 0.11 3.07 2:0.50近 5:0.53近 8:0.72近 9:0.30着 12 0.75 0.00 2.30 0.12 3.17 2:0.57近 5:0.57近 8:0.70近 9:0.34着 13 0.63 0.00 2.13 0.11 2.87 2:0.49近 5:0.55近 8:0.62近 9:0.30着 14 0.56 0.00 2.23 0.14 2.93 2:0.59近 5:0.58近 8:0.62近 9:0.32着 15 0.75 0.00 2.31 0.11 3.17 2:0.57近 5:0.52近 8:0.70近 9:0.30着 16 1.63 0.00 2.19 0.12 3.94 2:0.52近 5:0.52近 8:0.70近 9:0.30着 17 0.65 0.00 2.16 0.12 2.93 2:0.44近 5:0.52近 8:0.70近 9:0.30着 18 0.82 0.00 2.13 0.12 3.07 2:0.50近 5:0.52近 8:0.62近 9:0.32着 19 1.69 0.00 2.23 0.12 4.04 2:0.60近 5:0.50近 8:0.62近 9:0.32着 20 0.58 0.00 2.06 0.13 2.76 2:0.51近 5:0.51近 8:0.60近 9:0.22着 21 0.80 0.00 2.03 0.13 2.96 2:0.50近 5:0.52近 8:0.60近 9:0.22着 22 1.54 0.00 2.23 0.13 3.90 2:0.60近 5:0.56近 8:0.62近 9:0.30着 23 0.57 0.00 2.20 0.13 2.90 2:0.60近 5:0.42近 8:0.70近 9:0.30着 24 0.85 0.00 2.32 0.13 3.30 2:0.59近 5:0.52近 8:0.70近 9:0.30着 25 0.62 0.00 2.16 0.12 2.91 2:0.52近 5:0.51近 8:0.70近 9:0.30着 26 0.71 0.00 2.09 0.13 2.93 2:0.51近 5:0.51近 8:0.62近 9:0.30着 27 1.61 0.00 2.21 0.12 3.94 2:0.62近 5:0.52近 8:0.62近 9:0.30着 28 0.66 0.00 2.18 0.12 2.96 2:0.52近 5:0.52近 8:0.70近 9:0.30着 29 1.56 0.00 2.26 0.12 3.94 2:0.52近 5:0.59近 8:0.64近 9:0.32着 30 0.58 0.00 2.01 0.13 2.73 2:0.44近 5:0.52近 8:0.59近 9:0.29着 31 0.62 0.00 2.06 0.15 2.83 2:0.52近 5:0.52近 8:0.61近 9:0.29着 32 0.60 0.00 2.09 0.04 2.73 2:0.53近 5:0.51近 8:0.68近 9:0.22着 33 0.67 0.00 2.31 0.02 3.00 2:0.52近 5:0.61近 8:0.70近 9:0.31着 34 1.57 0.00 2.05 0.12 3.74 2:0.51近 5:0.58近 8:0.54近 9:0.30着 35 0.75 0.00 2.23 0.12 3.10 2:0.60近 5:0.52近 8:0.68近 9:0.30着 36 1.56 0.00 2.15 0.13 3.83 2:0.50近 5:0.52近 8:0.62近 9:0.32着 37 0.83 0.00 2.34 0.13 3.30 2:0.59近 5:0.60近 8:0.70近 9:0.30着 38 0.82 0.00 2.15 0.13 3.10 2:0.58近 5:0.50近 8:0.62近 9:0.33着 39 0.68 0.00 2.13 0.12 2.92 2:0.52近 5:0.50近 8:0.62近 9:0.32着 40 0.58 0.00 2.23 0.14 2.94 2:0.58近 5:0.50近 8:0.62近 9:0.33着 41 0.62 0.00 2.16 0.12 2.90 2:0.58近 5:0.50近 8:0.62近 9:0.32着 42 0.67 0.00 2.14 0.12 2.93 2:0.58近 5:0.50近 8:0.62近 9:0.33着 43 1.56 0.00 2.23 0.04 3.83 2:0.60近 5:0.50近 8:0.62近 9:0.32着 44 0.56 0.00 2.17 0.10 2.84 2:0.52近 5:0.52近 8:0.71近 9:0.30着 45 0.66 0.00 2.18 0.09 2.93 2:0.52近 5:0.52近 8:0.70近 9:0.30着 46 1.58 0.00 2.13 0.16 3.87 2:0.52近 5:0.59近 8:0.60近 9:0.30着 47 0.56 0.00 2.12 0.12 2.80 2:0.52近 5:0.54近 8:0.57近 9:0.31着 48 0.56 0.00 2.16 0.12 2.84 2:0.58近 5:0.52近 8:0.61近 9:0.29着 49 0.65 0.00 2.07 0.14 2.86 2:0.43近 5:0.54近 8:0.69近 9:0.29着 50 0.64 0.00 1.38 0.11 2.13 2:0.92近 5:-送らず 8:-送らず 9:0.35着 51 1.57 0.00 2.63 0.06 4.27 2:0.60近 5:0.62近 8:0.32着 爪→閉 52 0.64 0.00 2.44 0.13 3.20 2:0.53近 5:0.60近 8:0.77近 9:0.40着 53 0.64 0.00 2.29 0.13 3.06 2:0.54近 5:0.52近 8:0.80近 9:0.30着 54 0.75 0.00 2.41 0.12 3.27 2:0.61近 5:0.56近 8:0.71近 9:0.38着 55 1.67 0.00 2.24 0.12 4.03 2:0.52近 5:0.56近 8:0.65近 9:0.32着 56 0.56 0.00 2.31 0.13 3.00 2:0.64近 5:0.54近 8:0.64近 9:0.30着 57 0.56 0.00 3.41 0.10 4.07 1:0.32着 爪→開 58 0.69 0.00 1.97 0.14 2.80 2:0.52近 5:0.54近 8:0.62近 9:0.12着 59 1.66 0.00 2.35 -0.00 4.00 2:0.49近 5:0.52近 8:0.72近 9:0.40着 合計 54.49 0.01 137.03 6.94 198.47 中央値 0.68 0.00 2.19 0.12 3.07 推論: 1 回目 0.75 秒 / 2 回目からの中央値 0.68 秒 中継点の間の中央値 0.52 秒 (log.jsonl の flow) 中継点ごと: step:秒+わけ (近=近づいた 時=見込みの時間 着=最後の点が着いた 未=着かなかった 失=送れなかった) 終わり方: 上限 (--max-chunks) そのほかの行: framing 1 tilt_fix 1 == 比べる (秒) 試行 送り方 確かめ 速さ チャンク 推論計 確認待ち計 動いた計 動いた中央 中継点中央 合計 終わり方 pi05_20261113_193254 記録なし 毎チャンク(記録なし) 20 15 70.30 31.68 40.81 2.44 0.62 144.40 人(h) pi05_20261114_180457 flow 止めたときだけ 20 25 21.16 4.44 66.56 2.23 0.53 95.23 人(h) pi05_20261114_180704 flow 止めたときだけ 20 16 15.18 2.09 44.30 2.34 0.53 63.41 人(h) pi05_20261114_181057 今まで 止めたときだけ 20 21 19.11 28.40 55.09 2.46 0.62 104.93 人(h) pi05_20261114_181300 今まで 止めたときだけ 20 25 22.90 2.25 62.70 2.37 0.62 90.44 人(h) pi05_20261114_182039 flow 止めたときだけ 30 16 13.89 10.97 41.98 2.29 0.54 68.60 人(h) pi05_20261114_182211 flow 止めたときだけ 30 13 12.98 1.69 38.05 2.35 0.54 54.06 人(h) pi05_20261114_182327 flow 止めたときだけ 30 60 54.49 0.01 137.03 2.19 0.52 198.47 上限 ``` ### 1回目の起動（`--flow`・速さ20）のターミナル ``` [RANGE ] 安全範囲 (学習データ ±10°) は /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes から (--model deep1) [FRAME ] 写り方の確かめの基準画像は /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes の最初のエピソードから (位置合わせと同じ trim2. 依頼 137) [TILT ] 上カメラの傾きのお手本 (各エピソードの 1 枚目の中央値) は /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes から (安全範囲と同じ. 差だけ画像を回して AI に渡す. 依頼 144) [GRIP ] 爪の閉じる値は 25 (--grip-value). 締め直し r はこの値−3 とこの値を交互に送る (依頼 152) [FLOW ] 推論の送り方: --flow (依頼 176) [CONFIRM] チャンクごとには確かめない (--no-step-confirm. 始めの確かめのあとは止まらずに進む. 止めるときはスペース. 依頼 178) [LAB ] 2026-11-14 17:58:31 GPU=NVIDIA A40 episode=run_0001_20261019_194818 log=/Volumes/KIOXIA/r2r2r-data/lab/Log35 [MODEL ] --model deep1: π0.5 base から deep_even10_v1 で新しく学習した 2999 (依頼 133. decay_steps 5000) PixelstoMotors/pi05-mecharm-deep-even10-lora-v1 → /workspace/ckpt/deep_v1_2999 設定 pi05_mecharm_deep_even10_lora assets local/mecharm_redblock_box_deep_even10_v1 === 1. Pod を作る [POD ] 作った: id 9wypmq2uhnx2et GPU=NVIDIA A40 1時間 0.59 ドル (記録 /Volumes/KIOXIA/r2r2r-data/lab/Log35/pod/lab_pod.json) (2 秒) === 2. Pod が立ち上がるまで待つ [POD ] SSH の IP とポートを API から受け取った (:) [POD ] 入れた: 7711f98bf50a NVIDIA A40, 46068 MiB (38 秒) === 3a. スクリプトを送る (101 秒) === 3b. huggingface_hub を入れ, 鍵を渡す WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning. Hint: The `hf-cli` skill is not installed. Run `hf skills add -g` to teach your AI agents how to use the `hf` CLI. ✓ Logged in user: PixelstoMotors (10 秒) === 3c. モデルを取る (hf download PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) Fetching 34 files: 0%| | 0/34 [00:00 20) 傾き -2.22° → -0.61° にソフトでそろえる (+1.61° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +14.0 dx= +32.8 response=0.154 → 測れない (相関が弱く dx/dy が当てにならない (response=0.154 < 0.20)) 傾き -2.18° → -0.61° にソフトでそろえる (+1.57° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +12.8 dx= +30.0 response=0.466 → ずれ (|dx|=30.0 > 20) 傾き -2.18° → -0.61° にソフトでそろえる (+1.57° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +14.0 dx= +32.9 response=0.154 → 測れない (相関が弱く dx/dy が当てにならない (response=0.154 < 0.20)) 傾き -2.18° → -0.61° にソフトでそろえる (+1.57° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +12.9 dx= +29.5 response=0.690 → ずれ (|dx|=29.5 > 20) 傾き -2.18° → -0.61° にソフトでそろえる (+1.57° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +14.1 dx= +32.9 response=0.180 → 測れない (相関が弱く dx/dy が当てにならない (response=0.180 < 0.20)) 傾き -2.19° → -0.61° にソフトでそろえる (+1.57° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +12.9 dx= +29.5 response=0.685 → ずれ (|dx|=29.5 > 20) 傾き -2.18° → -0.61° にソフトでそろえる (+1.57° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +13.9 dx= +32.9 response=0.177 → 測れない (相関が弱く dx/dy が当てにならない (response=0.177 < 0.20)) 傾き -2.18° → -0.61° にソフトでそろえる (+1.57° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +11.9 dx= +29.8 response=0.464 → ずれ (|dx|=29.8 > 20) 傾き -2.22° → -0.61° にソフトでそろえる (+1.61° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +13.0 dx= +33.0 response=0.204 → ずれ (|dx|=33.0 > 20) 傾き -2.18° → -0.61° にソフトでそろえる (+1.57° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +14.0 dx= +32.9 response=0.180 → 測れない (相関が弱く dx/dy が当てにならない (response=0.180 < 0.20)) 傾き -2.22° → -0.61° にソフトでそろえる (+1.61° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +12.9 dx= +29.6 response=0.669 → ずれ (|dx|=29.6 > 20) 傾き -2.22° → -0.61° にソフトでそろえる (+1.61° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +15.8 dx= +29.8 response=0.499 → ずれ (|dx|=29.8 > 20) 傾き -2.18° → -0.61° にソフトでそろえる (+1.57° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +18.7 dx= +33.5 response=0.555 → ずれ (|dx|=33.5 > 20) 傾き -2.18° → -0.61° にソフトでそろえる (+1.57° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +21.4 dx= +37.5 response=0.119 → 測れない (相関が弱く dx/dy が当てにならない (response=0.119 < 0.20)) 傾き -2.17° → -0.61° にソフトでそろえる (+1.56° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +17.7 dx= +32.7 response=0.543 → ずれ (|dx|=32.7 > 20) 傾き -2.14° → -0.61° にソフトでそろえる (+1.53° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +16.7 dx= +31.8 response=0.489 → ずれ (|dx|=31.8 > 20) 傾き -2.30° → -0.61° にソフトでそろえる (+1.69° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +18.7 dx= +36.3 response=0.163 → 測れない (相関が弱く dx/dy が当てにならない (response=0.163 < 0.20)) 傾き -2.18° → -0.61° にソフトでそろえる (+1.56° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +22.5 dx= +32.6 response=0.551 → ずれ (|dy|=22.5 > 20 / |dx|=32.6 > 20) 傾き -2.18° → -0.61° にソフトでそろえる (+1.56° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +31.7 dx= +36.6 response=0.084 → 測れない (相関が弱く dx/dy が当てにならない (response=0.084 < 0.20)) 傾き -2.18° → -0.61° にソフトでそろえる (+1.56° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +37.2 dx= +40.9 response=0.093 → 測れない (相関が弱く dx/dy が当てにならない (response=0.093 < 0.20)) 傾き -2.01° → -0.61° にソフトでそろえる (+1.39° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +41.9 dx= +43.5 response=0.232 → ずれ (|dy|=41.9 > 20 / |dx|=43.5 > 20) 傾き -1.75° → -0.61° にソフトでそろえる (+1.14° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +45.9 dx= +47.8 response=0.120 → 測れない (相関が弱く dx/dy が当てにならない (response=0.120 < 0.20)) 傾き -0.78° → -0.61° にソフトでそろえる (+0.16° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +44.8 dx= +42.3 response=0.109 → 測れない (相関が弱く dx/dy が当てにならない (response=0.109 < 0.20)) 傾き -0.53° → -0.61° にソフトでそろえる (-0.08° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +40.6 dx= +40.2 response=0.098 → 測れない (相関が弱く dx/dy が当てにならない (response=0.098 < 0.20)) 傾き -0.53° → -0.61° にソフトでそろえる (-0.08° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +32.5 dx= +41.1 response=0.144 → 測れない (相関が弱く dx/dy が当てにならない (response=0.144 < 0.20)) 傾き -0.65° → -0.61° にソフトでそろえる (+0.04° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +29.6 dx= +39.8 response=0.144 → 測れない (相関が弱く dx/dy が当てにならない (response=0.144 < 0.20)) 傾き -0.66° → -0.61° にソフトでそろえる (+0.04° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +24.0 dx= +41.1 response=0.229 → ずれ (|dy|=24.0 > 20 / |dx|=41.1 > 20) 傾き -0.70° → -0.61° にソフトでそろえる (+0.09° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +16.9 dx= +32.6 response=0.628 → ずれ (|dx|=32.6 > 20) 傾き -0.78° → -0.61° にソフトでそろえる (+0.17° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +11.7 dx= +29.8 response=0.733 → ずれ (|dx|=29.8 > 20) 傾き -0.78° → -0.61° にソフトでそろえる (+0.17° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +8.1 dx= +29.8 response=0.583 → ずれ (|dx|=29.8 > 20) 傾き -1.40° → -0.61° にソフトでそろえる (+0.79° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +6.6 dx= +32.9 response=0.189 → 測れない (相関が弱く dx/dy が当てにならない (response=0.189 < 0.20)) 傾き -1.73° → -0.61° にソフトでそろえる (+1.11° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +5.6 dx= +28.8 response=0.625 → ずれ (|dx|=28.8 > 20) 傾き -1.77° → -0.61° にソフトでそろえる (+1.15° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +5.1 dx= +36.0 response=0.229 → ずれ (|dx|=36.0 > 20) 傾き -1.60° → -0.61° にソフトでそろえる (+0.99° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +3.7 dx= +31.6 response=0.567 → ずれ (|dx|=31.6 > 20) 傾き -1.56° → -0.61° にソフトでそろえる (+0.95° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +5.4 dx= +36.2 response=0.238 → ずれ (|dx|=36.2 > 20) 傾き -1.56° → -0.61° にソフトでそろえる (+0.95° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +4.4 dx= +31.6 response=0.709 → ずれ (|dx|=31.6 > 20) 傾き -1.56° → -0.61° にソフトでそろえる (+0.95° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +6.1 dx= +34.9 response=0.191 → 測れない (相関が弱く dx/dy が当てにならない (response=0.191 < 0.20)) 傾き -1.64° → -0.61° にソフトでそろえる (+1.03° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +7.7 dx= +26.7 response=0.587 → ずれ (|dx|=26.7 > 20) 傾き -1.64° → -0.61° にソフトでそろえる (+1.03° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +11.6 dx= +24.3 response=0.110 → 測れない (相関が弱く dx/dy が当てにならない (response=0.110 < 0.20)) 傾き -1.56° → -0.61° にソフトでそろえる (+0.95° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +11.3 dx= +19.1 response=0.122 → 測れない (相関が弱く dx/dy が当てにならない (response=0.122 < 0.20)) 傾き -1.27° → -0.61° にソフトでそろえる (+0.66° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +8.7 dx= +18.4 response=0.071 → 測れない (相関が弱く dx/dy が当てにならない (response=0.071 < 0.20)) 傾き -1.10° → -0.61° にソフトでそろえる (+0.49° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +4.4 dx= +12.5 response=0.905 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.02° → -0.61° にソフトでそろえる (+0.41° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +9.9 dx= +12.0 response=0.061 → 測れない (相関が弱く dx/dy が当てにならない (response=0.061 < 0.20)) 傾き -0.86° → -0.61° にソフトでそろえる (+0.24° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +13.4 dx= +10.3 response=0.106 → 測れない (相関が弱く dx/dy が当てにならない (response=0.106 < 0.20)) 傾き -0.85° → -0.61° にソフトでそろえる (+0.24° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +9.8 dx= +7.8 response=0.622 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.81° → -0.61° にソフトでそろえる (+0.20° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +5.8 dx= +7.8 response=0.851 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.82° → -0.61° にソフトでそろえる (+0.20° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +3.6 dx= +5.7 response=0.958 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.82° → -0.61° にソフトでそろえる (+0.20° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +5.7 dx= +7.3 response=0.072 → 測れない (相関が弱く dx/dy が当てにならない (response=0.072 < 0.20)) 傾き -0.85° → -0.61° にソフトでそろえる (+0.24° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +4.5 dx= +3.3 response=0.760 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.90° → -0.61° にソフトでそろえる (+0.29° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +5.7 dx= +1.5 response=0.784 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.02° → -0.61° にソフトでそろえる (+0.41° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +5.7 dx= +1.5 response=0.643 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.27° → -0.61° にソフトでそろえる (+0.65° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +7.7 dx= +4.8 response=0.161 → 測れない (相関が弱く dx/dy が当てにならない (response=0.161 < 0.20)) 傾き -1.35° → -0.61° にソフトでそろえる (+0.73° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +5.7 dx= +4.5 response=0.836 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.10° → -0.61° にソフトでそろえる (+0.49° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +4.6 dx= +5.4 response=0.912 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.10° → -0.61° にソフトでそろえる (+0.49° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +3.1 dx= +6.6 response=0.907 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.02° → -0.61° にソフトでそろえる (+0.40° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -0.6 dx= +8.7 response=0.921 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.90° → -0.61° にソフトでそろえる (+0.28° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -0.7 dx= +8.5 response=0.995 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.69° → -0.61° にソフトでそろえる (+0.08° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -0.7 dx= +8.6 response=0.970 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.37° → -0.61° にソフトでそろえる (-0.25° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.4 dx= +11.3 response=0.943 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.29° → -0.61° にソフトでそろえる (-0.33° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +2.3 dx= +11.5 response=0.139 → 測れない (相関が弱く dx/dy が当てにならない (response=0.139 < 0.20)) 傾き +0.04° → -0.61° にソフトでそろえる (-0.65° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +5.5 dx= +8.8 response=0.811 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き +0.08° → -0.61° にソフトでそろえる (-0.70° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +10.7 dx= +10.8 response=0.111 → 測れない (相関が弱く dx/dy が当てにならない (response=0.111 < 0.20)) 傾き +0.29° → -0.61° にソフトでそろえる (-0.90° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +12.0 dx= +8.4 response=0.875 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き +0.29° → -0.61° にソフトでそろえる (-0.90° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +8.5 dx= +7.3 response=0.729 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き +0.29° → -0.61° にソフトでそろえる (-0.90° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +2.4 dx= +6.8 response=0.871 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き +0.28° → -0.61° にソフトでそろえる (-0.90° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -2.5 dx= +6.4 response=1.013 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き +0.20° → -0.61° にソフトでそろえる (-0.82° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -4.1 dx= +0.4 response=0.914 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き +0.16° → -0.61° にソフトでそろえる (-0.78° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -4.5 dx= -0.4 response=1.048 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.61° → -0.61° にソフトでそろえる (-0.00° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -4.4 dx= -3.0 response=1.021 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.82° → -0.61° にソフトでそろえる (+0.20° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -3.6 dx= -3.7 response=1.063 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.11° → -0.61° にソフトでそろえる (+0.49° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -5.4 dx= +1.4 response=1.060 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.98° → -0.61° にソフトでそろえる (+0.36° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -8.6 dx= +3.4 response=1.028 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.69° → -0.61° にソフトでそろえる (+0.08° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -11.3 dx= +5.4 response=0.965 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.65° → -0.61° にソフトでそろえる (+0.04° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -12.6 dx= +6.5 response=0.930 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.33° → -0.61° にソフトでそろえる (-0.29° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -12.4 dx= +5.6 response=0.950 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.08° → -0.61° にソフトでそろえる (-0.53° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -10.2 dx= +2.1 response=0.996 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.08° → -0.61° にソフトでそろえる (-0.53° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -6.2 dx= -1.5 response=0.922 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.08° → -0.61° にソフトでそろえる (-0.53° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -4.4 dx= -2.3 response=1.003 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -0.53° → -0.61° にソフトでそろえる (-0.08° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -4.4 dx= -2.4 response=1.073 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.06° → -0.61° にソフトでそろえる (+0.45° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -3.4 dx= -3.6 response=1.080 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.31° → -0.61° にソフトでそろえる (+0.69° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -1.4 dx= -5.5 response=0.827 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.31° → -0.61° にソフトでそろえる (+0.69° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.5 dx= -6.3 response=0.881 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.55° → -0.61° にソフトでそろえる (+0.94° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.4 dx= -6.1 response=0.918 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.80° → -0.61° にソフトでそろえる (+1.19° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.5 dx= -7.8 response=0.985 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.96° → -0.61° にソフトでそろえる (+1.35° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -0.6 dx= -8.6 response=0.779 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -2.09° → -0.61° にソフトでそろえる (+1.47° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +1.3 dx= -9.3 response=0.912 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -2.04° → -0.61° にソフトでそろえる (+1.43° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.2 dx= -9.5 response=0.773 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.96° → -0.61° にソフトでそろえる (+1.35° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -1.5 dx= -9.3 response=0.761 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.88° → -0.61° にソフトでそろえる (+1.26° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -0.7 dx= -4.2 response=0.775 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.67° → -0.61° にソフトでそろえる (+1.06° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.3 dx= -3.1 response=0.955 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.67° → -0.61° にソフトでそろえる (+1.05° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -1.7 dx= +3.1 response=0.932 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.58° → -0.61° にソフトでそろえる (+0.97° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -2.7 dx= +2.2 response=0.836 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.50° → -0.61° にソフトでそろえる (+0.89° 回して重ねる. プラス=右下がり) [ALIGN ] dy= -1.6 dx= +0.4 response=1.035 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.54° → -0.61° にソフトでそろえる (+0.93° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.4 dx= -2.8 response=0.971 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.79° → -0.61° にソフトでそろえる (+1.17° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.3 dx= -3.4 response=0.761 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.99° → -0.61° にソフトでそろえる (+1.38° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +1.3 dx= -1.1 response=0.981 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.91° → -0.61° にソフトでそろえる (+1.29° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.3 dx= -1.7 response=0.785 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.87° → -0.61° にソフトでそろえる (+1.25° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +1.3 dx= -1.1 response=0.984 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.91° → -0.61° にソフトでそろえる (+1.30° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.3 dx= -1.6 response=0.808 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.91° → -0.61° にソフトでそろえる (+1.30° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +1.3 dx= -1.1 response=0.935 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.91° → -0.61° にソフトでそろえる (+1.30° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +8.0 dx= +5.4 response=0.032 → 測れない (相関が弱く dx/dy が当てにならない (response=0.032 < 0.20)) 傾き -7.96° → -0.61° にソフトでそろえる (+7.34° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +1.4 dx= -1.2 response=0.894 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.99° → -0.61° にソフトでそろえる (+1.38° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +9.0 dx= +3.4 response=0.046 → 測れない (相関が弱く dx/dy が当てにならない (response=0.046 < 0.20)) 傾き -10.36° → -0.61° にソフトでそろえる (+9.75° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +9.8 dx= +1.6 response=0.077 → 測れない (相関が弱く dx/dy が当てにならない (response=0.077 < 0.20)) 傾き -12.59° → -0.61° にソフトでそろえる (+11.98° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +9.0 dx= +1.0 response=0.108 → 測れない (相関が弱く dx/dy が当てにならない (response=0.108 < 0.20)) 傾き -13.15° → -0.61° にソフトでそろえる (+12.54° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +9.0 dx= +1.0 response=0.120 → 測れない (相関が弱く dx/dy が当てにならない (response=0.120 < 0.20)) 傾き -13.36° → -0.61° にソフトでそろえる (+12.75° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +8.9 dx= +1.3 response=0.111 → 測れない (相関が弱く dx/dy が当てにならない (response=0.111 < 0.20)) 傾き -13.08° → -0.61° にソフトでそろえる (+12.47° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +7.7 dx= +2.9 response=0.073 → 測れない (相関が弱く dx/dy が当てにならない (response=0.073 < 0.20)) 傾き -8.57° → -0.61° にソフトでそろえる (+7.96° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= -2.3 dx= -7.4 response=-0.012 → 測れない (相関が弱く dx/dy が当てにならない (response=-0.012 < 0.20)) 傾き -8.57° → -0.61° にソフトでそろえる (+7.96° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +8.5 dx= +2.9 response=0.056 → 測れない (相関が弱く dx/dy が当てにならない (response=0.056 < 0.20)) 傾き -10.53° → -0.61° にソフトでそろえる (+9.92° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +9.1 dx= +1.5 response=0.077 → 測れない (相関が弱く dx/dy が当てにならない (response=0.077 < 0.20)) 傾き -12.42° → -0.61° にソフトでそろえる (+11.81° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +10.1 dx= +2.0 response=0.071 → 測れない (相関が弱く dx/dy が当てにならない (response=0.071 < 0.20)) 傾き -12.42° → -0.61° にソフトでそろえる (+11.81° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +10.4 dx= +3.5 response=0.029 → 測れない (相関が弱く dx/dy が当てにならない (response=0.029 < 0.20)) 傾き -10.59° → -0.61° にソフトでそろえる (+9.98° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +8.3 dx= +4.4 response=0.029 → 測れない (相関が弱く dx/dy が当てにならない (response=0.029 < 0.20)) 傾き -9.07° → -0.61° にソフトでそろえる (+8.46° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +0.2 dx= -1.6 response=0.780 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.95° → -0.61° にソフトでそろえる (+1.33° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +1.3 dx= -1.5 response=1.002 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.91° → -0.61° にソフトでそろえる (+1.30° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.2 dx= -1.7 response=0.761 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.91° → -0.61° にソフトでそろえる (+1.30° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +1.3 dx= -1.4 response=1.000 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.87° → -0.61° にソフトでそろえる (+1.26° 回して重ねる. プラス=右下がり) [DONE ] 終了 (何も書いていません) (65 秒) === 8. 実機推論 (1 回目) [WAIT ] 送ったあと 0.0s / 爪のあと 0.8s (開くときの daemon 0.0s) / 止まるのを待つ目安 0.8s [GRIP ] 閉じる値 25 締め直し r は 22 と 25 を交互に送る [FLOW ] --flow: 途中の点は 5.0° 以内に近づくか見込みの時間で次を送る (間隔 0.4〜1.5 秒). 最後の点は 3° の到着を待つ 速さ 20 (既定) [SAFE ] 安全範囲 (学習 50 本 ±10°): j0[-72,+55] j1[-9,+88] j2[-45,+52] j3[-18,+27] j4[-87,+10] j5[-51,-15] [SAFE ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352) 元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes [MODE ] EXECUTE steps/chunk=10 max_move=20.0° log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_180457 [MODEL ] deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) [PAUSE ] --no-step-confirm: 始めの確かめのあとは入力欄を出さずに進みます. 止めるときはスペース (Enter も可). 今のチャンクを送り終えてから, 次の推論のあと (送る前) で入力欄を出します [CAMERA] 写り方 dy=-5.4 dx=+5.3 response=0.493 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 回したあとの画像で測った [CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg [CAMERA] 傾き -1.87° → -0.61° にそろえて渡す (+1.26° 回す. プラス=右下がり) (お手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 測れた 50/50 本・今 5/5 コマ) [POLICY] 接続 ws://localhost:8000 metadata={} [RECORD] 上カメラと実測角を 1 秒 10 コマで記録します → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_180457/recording [GRIP ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく) [STATE ] 実測を渡す (直前に送った目標がない) [000] 推論 691ms 10ステップ先 Δ= +3.5 +14.4 +8.5 -0.6 -17.5 +0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > [GRIP ] 開始時にグリッパーを開く [Pi] GRIPPER: OPEN result= None [VIA ] step 2 Δ= +0.7 +3.5 +2.0 +0.5 -3.7 -0.1 流した 0.57 秒で次へ: 近づいた (残り 1.82°) [VIA ] step 5 Δ= +1.3 +3.7 +1.5 +0.2 -7.4 -0.0 流した 0.51 秒で次へ: 近づいた (残り 1.44°) [VIA ] step 8 Δ= +1.3 +3.9 +2.4 -0.8 -7.8 +0.3 流した 0.40 秒で次へ: 近づいた (残り 1.62°) [SEND] pi05_chunk000_via09: send_angles (single) [ +3.41, +15.64, +9.37, -0.85, -17.78, -29.27] speed=20 wait=0.0s (pre max|Δ|=3.37°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.93° (tol 3.0°) [VIA ] step 9 Δ= +0.5 +0.5 -0.1 -0.9 -3.5 +0.6 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.93°（関節 j3） [001] 推論 547ms 10ステップ先 Δ= +3.8 +10.5 +6.3 -2.7 -16.3 +2.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.5 +2.4 +1.1 -1.5 -4.6 +1.1 流した 0.44 秒で次へ: 近づいた (残り 1.06°) [VIA ] step 5 Δ= +1.5 +2.5 +1.5 -1.2 -5.5 +1.1 流した 0.52 秒で次へ: 近づいた (残り 1.0°) [VIA ] step 8 Δ= +1.2 +3.0 +2.0 -0.9 -6.7 +0.9 流した 0.50 秒で次へ: 近づいた (残り 1.0°) [SEND] pi05_chunk001_via09: send_angles (single) [ +6.65, +27.05, +16.39, -2.58, -33.23, -27.82] speed=20 wait=0.0s (pre max|Δ|=2.30°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.89° (tol 3.0°) [VIA ] step 9 Δ= +0.3 -0.1 -0.3 -0.6 -2.3 +0.6 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.89°（関節 j1） [002] 推論 1536ms 10ステップ先 Δ= +3.6 +8.8 +4.7 -0.7 -14.8 +0.8 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.6 +2.6 +1.3 -0.7 -5.5 +0.5 流した 0.47 秒で次へ: 近づいた (残り 0.88°) [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [VIA ] step 5 Δ= +1.1 +1.9 +1.1 -0.2 -4.9 +0.4 流した 2.17 秒で次へ: 見込みの時間がたった [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [VIA ] step 8 Δ= +0.9 +1.5 +0.8 -0.1 -4.0 +0.2 流した 0.44 秒で次へ: 近づいた (残り 1.0°) [SEND] pi05_chunk002_via09: send_angles (single) [ +9.88, +36.72, +21.65, -2.67, -47.30, -27.52] speed=20 wait=0.0s (pre max|Δ|=1.43°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.98° (tol 3.0°) [VIA ] step 9 Δ= +0.3 -0.0 -0.1 -0.0 -1.4 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.98°（関節 j1） [003] 推論 621ms 10ステップ先 Δ= +1.6 +8.7 +3.4 +0.4 -11.5 +0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.0 +2.9 +1.6 +0.3 -5.3 +0.3 流した 0.51 秒で次へ: 近づいた (残り 0.94°) [VIA ] step 5 Δ= +0.9 +2.7 +1.0 +0.2 -4.9 +0.3 流した 0.41 秒で次へ: 近づいた (残り 0.94°) [VIA ] step 8 Δ= -0.3 +0.7 +0.2 +0.1 -1.7 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.02°) [SEND] pi05_chunk003_via09: send_angles (single) [ +11.23, +46.40, +25.19, -2.25, -58.34, -27.38] speed=20 wait=0.0s (pre max|Δ|=0.53°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.88° (tol 3.0°) [VIA ] step 9 Δ= -0.2 -0.5 +0.1 +0.1 -0.5 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.88°（関節 j1） [004] 推論 554ms 10ステップ先 Δ= +2.7 +11.7 -4.3 -0.2 -5.3 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.8 +2.2 +1.3 +0.1 -2.7 +0.3 流した 0.42 秒で次へ: 近づいた (残り 1.1°) [VIA ] step 5 Δ= +1.2 +4.6 -0.7 -0.4 -1.7 -0.4 流した 0.50 秒で次へ: 近づいた (残り 0.97°) [VIA ] step 8 Δ= +0.8 +2.4 -4.6 -0.6 -0.2 -0.5 流した 0.48 秒で次へ: 近づいた (残り 0.8°) [SEND] pi05_chunk004_via09: send_angles (single) [ +14.15, +59.01, +20.76, -2.56, -63.17, -27.42] speed=20 wait=0.0s (pre max|Δ|=1.56°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.16° (tol 3.0°) [VIA ] step 9 Δ= +0.2 +0.0 -1.6 -0.6 +0.8 -0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.16°（関節 j4） [005] 推論 794ms 5ステップ先 Δ= +0.3 +1.2 -2.2 -0.5 +0.5 -0.4 グリッパー→閉 [VIA ] 中継点 2 点: step 2, 4 [VIA ] step 2 Δ= +0.3 +1.2 -2.1 -0.4 +0.6 -0.4 流した 0.48 秒で次へ: 近づいた (残り 1.36°) [SEND] pi05_chunk005_via04: send_angles (single) [ +14.31, +60.98, +19.50, -2.46, -63.83, -27.54] speed=20 wait=0.0s (pre max|Δ|=1.29°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.29° (tol 3.0°) [VIA ] step 4 Δ= +0.3 -0.6 -0.7 -0.4 +1.3 -0.1 着いた [Pi] GRIPPER: VALUE=25 speed=100 result= None [STATE ] 目標を渡す 目標と実測の最大差 2.79°（関節 j4） [006] 推論 1493ms 10ステップ先 Δ= +1.0 -8.7 +8.0 -1.4 +4.3 +1.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.7 -3.9 +2.4 -1.1 +4.9 +0.8 流した 0.40 秒で次へ: 近づいた (残り 1.71°) [VIA ] step 5 Δ= +0.9 -4.2 +4.4 -0.8 +2.5 +0.8 流した 0.44 秒で次へ: 近づいた (残り 1.58°) [VIA ] step 8 Δ= +0.6 -2.6 +2.8 -0.5 +0.6 +0.5 流した 0.52 秒で次へ: 近づいた (残り 1.24°) [SEND] pi05_chunk006_via09: send_angles (single) [ +14.82, +52.92, +28.22, -3.11, -62.31, -26.68] speed=20 wait=0.0s (pre max|Δ|=1.30°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.30° (tol 3.0°) [VIA ] step 9 Δ= +0.6 -1.3 +0.7 -0.1 +0.5 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.30°（関節 j1） [007] 推論 636ms 10ステップ先 Δ= +9.2 -2.3 -7.3 +2.1 +2.4 -2.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.6 -2.5 +1.7 +0.1 -0.2 +0.3 流した 0.50 秒で次へ: 近づいた (残り 1.34°) [VIA ] step 5 Δ= +3.7 -1.5 -2.5 +0.8 +0.1 -0.5 流した 0.44 秒で次へ: 近づいた (残り 1.49°) [VIA ] step 8 Δ= +4.4 -1.4 -5.4 +1.7 +0.3 -2.0 流した 0.48 秒で次へ: 近づいた (残り 1.5°) [SEND] pi05_chunk007_via09: send_angles (single) [ +23.38, +51.94, +20.18, -0.88, -60.39, -28.97] speed=20 wait=0.0s (pre max|Δ|=2.14°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.29° (tol 3.0°) [VIA ] step 9 Δ= +0.9 -1.1 -2.1 +0.9 -1.0 -1.7 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.29°（関節 j5） [008] 推論 605ms 10ステップ先 Δ= +3.9 -0.5 -7.0 +2.4 +0.5 -2.9 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.2 -1.3 -2.1 +1.2 -0.9 -1.5 流した 0.50 秒で次へ: 近づいた (残り 1.32°) [VIA ] step 5 Δ= +1.2 -1.1 -3.2 +1.0 -0.3 -1.5 流した 0.42 秒で次へ: 近づいた (残り 1.08°) [VIA ] step 8 Δ= +1.3 -0.8 -3.0 +0.8 -0.3 -1.4 流した 0.50 秒で次へ: 近づいた (残り 0.97°) [SEND] pi05_chunk008_via09: send_angles (single) [ +27.12, +52.53, +14.31, +0.77, -58.68, -30.54] speed=20 wait=0.0s (pre max|Δ|=1.68°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.68° (tol 3.0°) [VIA ] step 9 Δ= +0.2 -0.7 -1.7 +0.2 -0.8 -0.9 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.68°（関節 j2） [009] 推論 1822ms 10ステップ先 Δ= +0.5 -2.3 -9.6 +0.5 +0.7 -0.8 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.3 -1.5 -3.9 +0.2 -0.2 -0.6 流した 0.40 秒で次へ: 近づいた (残り 1.49°) [VIA ] step 5 Δ= +0.4 -1.8 -3.8 -0.0 +0.4 -0.6 流した 0.52 秒で次へ: 近づいた (残り 1.81°) [VIA ] step 8 Δ= +0.6 -2.2 -3.4 +0.1 +0.7 -0.5 流した 0.43 秒で次へ: 近づいた (残り 2.16°) [SEND] pi05_chunk009_via09: send_angles (single) [ +27.41, +51.28, +6.44, +1.08, -57.22, -30.57] speed=20 wait=0.0s (pre max|Δ|=2.33°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.33° (tol 3.0°) [VIA ] step 9 Δ= +0.6 -2.3 -1.4 +0.2 +0.3 -0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.33°（関節 j1） [010] 推論 724ms 10ステップ先 Δ=+11.1 -0.8 -7.5 +1.1 +1.6 -1.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +3.6 -2.5 -4.8 +0.2 +1.6 -0.5 流した 0.56 秒で次へ: 近づいた (残り 2.45°) [VIA ] step 5 Δ= +4.7 -1.9 -3.4 +0.7 +0.8 -1.0 流した 0.48 秒で次へ: 近づいた (残り 1.92°) [VIA ] step 8 Δ= +2.5 -1.3 -1.8 +0.5 +0.2 -0.4 流した 0.58 秒で次へ: 近づいた (残り 1.75°) [SEND] pi05_chunk010_via09: send_angles (single) [ +37.93, +52.79, +0.34, +2.02, -55.90, -31.29] speed=20 wait=0.0s (pre max|Δ|=1.50°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.50° (tol 3.0°) [VIA ] step 9 Δ= +0.2 -0.8 -1.5 +0.5 -0.4 -0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.50°（関節 j2） [011] 推論 561ms 10ステップ先 Δ= +2.7 +9.3 -3.5 +2.4 -5.9 -1.8 グリッパー→開 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +3.2 +2.1 -3.4 +1.3 -0.7 -1.1 流した 0.42 秒で次へ: 近づいた (残り 1.26°) [VIA ] step 5 Δ= -0.3 +3.7 -1.3 +0.5 -3.7 -0.6 流した 0.52 秒で次へ: 近づいた (残り 1.82°) [VIA ] step 8 Δ= -0.6 +1.2 -1.4 +1.2 -4.0 -0.3 流した 0.42 秒で次へ: 近づいた (残り 1.23°) [SEND] pi05_chunk011_via09: send_angles (single) [ +40.39, +62.98, -1.66, +3.78, -61.39, -32.69] speed=20 wait=0.0s (pre max|Δ|=1.23°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.23° (tol 3.0°) [VIA ] step 9 Δ= -0.6 -0.9 -1.2 +0.9 -0.6 +0.6 着いた [Pi] GRIPPER: OPEN result= None [STATE ] 目標を渡す 目標と実測の最大差 1.23°（関節 j2） [012] 推論 557ms 10ステップ先 Δ= -1.8 -13.5 -1.0 -0.1 +12.3 +0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.5 -5.0 -1.3 -0.1 +4.0 +0.6 流した 0.49 秒で次へ: 近づいた (残り 2.05°) [VIA ] step 5 Δ= -0.6 -6.1 -1.3 -0.4 +5.5 +0.5 流した 0.49 秒で次へ: 近づいた (残り 1.93°) [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [VIA ] step 8 Δ= -1.3 -5.5 -1.1 -0.4 +4.3 +0.5 流した 2.14 秒で次へ: 見込みの時間がたった [SEND] pi05_chunk012_via09: send_angles (single) [ +39.06, +50.45, -1.47, +3.80, -48.50, -32.76] speed=20 wait=0.0s (pre max|Δ|=3.07°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.19° (tol 3.0°) [VIA ] step 9 Δ= -0.7 -3.1 -1.0 -0.8 +1.2 +0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.19°（関節 j1） [013] 推論 1488ms 10ステップ先 Δ=-16.8 -22.6 +0.9 -3.1 +19.6 +1.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -2.1 -6.1 -0.5 -0.8 +4.2 +0.4 流した 0.48 秒で次へ: 近づいた (残り 1.84°) [VIA ] step 5 Δ= -5.7 -7.9 +0.1 -0.9 +5.2 +0.5 流した 0.51 秒で次へ: 近づいた (残り 1.97°) [VIA ] step 8 Δ= -7.0 -9.7 +0.2 -1.5 +8.0 +0.6 流した 0.56 秒で次へ: 近づいた (残り 1.82°) [SEND] pi05_chunk013_via09: send_angles (single) [ +22.93, +30.00, +0.42, +1.37, -29.18, -31.89] speed=20 wait=0.0s (pre max|Δ|=4.45°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.72° (tol 3.0°) [VIA ] step 9 Δ= -2.6 -4.4 -0.4 -0.5 +3.4 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.72°（関節 j1） [014] 推論 552ms 10ステップ先 Δ=-18.8 -24.7 +0.5 -1.6 +22.8 +1.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -6.1 -9.8 -0.0 -1.2 +8.7 +0.8 流した 0.52 秒で次へ: 近づいた (残り 1.85°) [VIA ] step 5 Δ= -6.4 -9.8 -0.2 -0.8 +8.2 +0.4 流した 0.52 秒で次へ: 近づいた (残り 1.64°) [VIA ] step 8 Δ= -6.1 -7.9 -0.4 -0.4 +6.2 +0.3 流した 0.49 秒で次へ: 近づいた (残り 1.5°) [SEND] pi05_chunk014_via09: send_angles (single) [ +4.33, +7.00, +1.29, -0.19, -6.79, -31.11] speed=20 wait=0.0s (pre max|Δ|=2.22°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.52° (tol 3.0°) [VIA ] step 9 Δ= -0.8 -2.2 -0.5 -0.0 +0.8 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.52°（関節 j1） [015] 推論 587ms 10ステップ先 Δ= -3.2 -4.0 -0.4 +0.0 +2.4 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -2.9 -4.2 -0.5 +0.0 +2.6 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.19°) [VIA ] step 5 Δ= -0.2 -1.3 -0.5 +0.0 +0.4 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.32°) [VIA ] step 8 Δ= +0.1 -1.1 -0.5 +0.0 +0.2 +0.2 流した 0.49 秒で次へ: 近づいた (残り 1.08°) [SEND] pi05_chunk015_via09: send_angles (single) [ +1.30, +4.54, +1.40, -0.24, -4.62, -31.06] speed=20 wait=0.0s (pre max|Δ|=0.99°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.99° (tol 3.0°) [VIA ] step 9 Δ= +0.1 -1.0 -0.4 +0.0 +0.1 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.99°（関節 j1） [016] 推論 600ms 10ステップ先 Δ= -1.9 -2.0 -0.5 -0.0 +0.6 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.9 -2.1 -0.4 +0.0 +0.9 +0.3 流した 0.52 秒で次へ: 近づいた (残り 1.38°) [VIA ] step 5 Δ= +0.1 -1.3 -0.5 +0.1 +0.2 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.34°) [VIA ] step 8 Δ= +0.3 -1.4 -0.4 +0.1 +0.1 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.35°) [SEND] pi05_chunk016_via09: send_angles (single) [ -0.71, +3.51, +1.37, -0.28, -4.09, -31.01] speed=20 wait=0.0s (pre max|Δ|=1.32°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.32° (tol 3.0°) [VIA ] step 9 Δ= +0.2 -1.3 -0.5 +0.1 +0.1 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.32°（関節 j1） [017] 推論 737ms 10ステップ先 Δ= -0.0 -1.5 -0.4 +0.2 -0.1 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.1 -1.3 -0.4 +0.1 +0.2 +0.2 流した 0.51 秒で次へ: 近づいた (残り 1.29°) [VIA ] step 5 Δ= -0.0 -1.4 -0.4 +0.1 +0.2 +0.2 流した 0.52 秒で次へ: 近づいた (残り 1.37°) [VIA ] step 8 Δ= -0.1 -1.5 -0.4 +0.1 +0.0 +0.2 流した 0.47 秒で次へ: 近づいた (残り 1.48°) [SEND] pi05_chunk017_via09: send_angles (single) [ -0.99, +3.36, +1.43, -0.17, -4.26, -30.96] speed=20 wait=0.0s (pre max|Δ|=1.47°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.47° (tol 3.0°) [VIA ] step 9 Δ= -0.0 -1.5 -0.4 +0.2 -0.1 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.47°（関節 j1） [018] 推論 1451ms 10ステップ先 Δ= +0.0 -1.2 -0.3 +0.2 -0.2 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.1 -1.4 -0.4 +0.2 +0.2 +0.3 流した 0.41 秒で次へ: 近づいた (残り 1.42°) [VIA ] step 5 Δ= -0.1 -1.4 -0.4 +0.2 +0.0 +0.3 流した 0.48 秒で次へ: 近づいた (残り 1.39°) [VIA ] step 8 Δ= -0.0 -1.2 -0.3 +0.2 -0.2 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.21°) [SEND] pi05_chunk018_via09: send_angles (single) [ -0.95, +3.65, +1.52, -0.16, -4.42, -30.96] speed=20 wait=0.0s (pre max|Δ|=1.18°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.18° (tol 3.0°) [VIA ] step 9 Δ= +0.0 -1.2 -0.3 +0.2 -0.2 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.18°（関節 j1） [019] 推論 556ms 10ステップ先 Δ= -0.2 -1.3 -0.7 +0.2 -0.2 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.4 -1.2 -0.6 +0.2 +0.1 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.21°) [VIA ] step 5 Δ= -0.3 -1.2 -0.7 +0.2 -0.1 +0.2 流した 0.52 秒で次へ: 近づいた (残り 1.19°) [VIA ] step 8 Δ= -0.3 -1.4 -0.7 +0.2 -0.0 +0.3 流した 0.41 秒で次へ: 近づいた (残り 1.39°) [SEND] pi05_chunk019_via09: send_angles (single) [ -1.20, +3.57, +1.50, -0.19, -4.43, -30.85] speed=20 wait=0.0s (pre max|Δ|=1.26°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.26° (tol 3.0°) [VIA ] step 9 Δ= -0.2 -1.3 -0.7 +0.2 -0.2 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.26°（関節 j1） [020] 推論 684ms 10ステップ先 Δ= -0.6 -1.7 -0.6 +0.2 +0.2 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.3 -1.5 -0.6 +0.2 +0.3 +0.3 流した 0.42 秒で次へ: 近づいた (残り 1.54°) [VIA ] step 5 Δ= -0.5 -1.6 -0.6 +0.2 +0.2 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.56°) [VIA ] step 8 Δ= -0.5 -1.7 -0.6 +0.2 +0.3 +0.2 流した 0.48 秒で次へ: 近づいた (残り 1.48°) [SEND] pi05_chunk020_via09: send_angles (single) [ -1.56, +3.09, +1.55, -0.18, -3.99, -30.85] speed=20 wait=0.0s (pre max|Δ|=1.48°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.48° (tol 3.0°) [VIA ] step 9 Δ= -0.6 -1.5 -0.6 +0.2 +0.2 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.48°（関節 j1） [021] 推論 1500ms 10ステップ先 Δ= -0.9 -1.5 -0.5 +0.2 +0.3 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.9 -1.3 -0.6 +0.2 +0.4 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.31°) [VIA ] step 5 Δ= +0.0 -1.5 -0.6 +0.2 +0.3 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.45°) [VIA ] step 8 Δ= -0.1 -1.5 -0.6 +0.2 +0.3 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.46°) [SEND] pi05_chunk021_via09: send_angles (single) [ -1.91, +3.07, +1.64, -0.13, -3.95, -30.81] speed=20 wait=0.0s (pre max|Δ|=1.50°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.50° (tol 3.0°) [VIA ] step 9 Δ= +0.0 -1.5 -0.5 +0.2 +0.3 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.50°（関節 j1） [022] 推論 543ms 10ステップ先 Δ= -1.0 -1.9 -0.5 +0.3 +0.8 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.0 -1.6 -0.5 +0.2 +0.6 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.63°) [VIA ] step 5 Δ= +0.2 -1.7 -0.5 +0.3 +0.3 +0.2 流した 0.48 秒で次へ: 近づいた (残り 1.52°) [VIA ] step 8 Δ= +0.0 -1.7 -0.5 +0.3 +0.4 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.72°) [SEND] pi05_chunk022_via09: send_angles (single) [ -2.88, +2.69, +1.67, -0.10, -3.45, -30.81] speed=20 wait=0.0s (pre max|Δ|=1.70°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.70° (tol 3.0°) [VIA ] step 9 Δ= +0.1 -1.7 -0.5 +0.3 +0.4 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.70°（関節 j1） [023] 推論 598ms 10ステップ先 Δ= -0.1 -1.5 -0.5 +0.2 +0.2 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.2 -1.7 -0.5 +0.3 +0.6 +0.2 流した 0.40 秒で次へ: 近づいた (残り 1.44°) [VIA ] step 5 Δ= -0.2 -1.4 -0.5 +0.3 -0.1 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.37°) [VIA ] step 8 Δ= -0.2 -1.2 -0.5 +0.3 -0.2 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.23°) [SEND] pi05_chunk023_via09: send_angles (single) [ -3.10, +2.90, +1.70, -0.11, -3.68, -30.78] speed=20 wait=0.0s (pre max|Δ|=1.23°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.23° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -1.2 -0.5 +0.2 -0.3 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.23°（関節 j1） [024] 推論 726ms 10ステップ先 Δ= -2.6 -2.0 -0.5 +0.3 +0.4 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [PAUSE ] 止める予約 (Enter). 推論 24 は送らずに入力欄を出します [PAUSE ] 止めました (推論 24 はまだ送っていません). Enter で実行すると, また止まらずに進みます Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > h [SEND] pi05_home: send_angles (single) [ +0.00, +0.00, +0.00, +0.00, +0.00, -30.00] speed=20 wait=0.0s (pre max|Δ|=4.13°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.19° (tol 2.5°) [RECORD] 記録終了 コマ 854 (8.905 fps) 実測角 707 回 (7.37 Hz) 電流 715 行 (read_servo) → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_180457/recording 結果: y=成功 / n=失敗 / Enter=記録しない > y [GRIP ] 閉じて 1 秒後の爪の電流 (中央値): 1 回目 750 (10 行) (閉じる値 25) [DONE ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_180457 [CLIENT] run_policy_client.py が終わった (終了コード 0. モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1)) (101 秒) もう1回やりますか? y=やる / 他=終わる > y === 7. HOME → 爪を開く → 位置合わせ (2 回目) [INIT] daemon 接続中... [Pi] fresh_mode=1 [INIT] fresh_mode=1 [PRE] 現在姿勢: [0.08, 1.23, 2.19, -0.35, 0.00, -30.23] [SEND] HOME へ移動指令 [WAIT] t=0.6s max_err=2.19° [DONE] HOME 到達 max_err=2.19° [POST] 最終姿勢: [0.08, 1.23, 2.19, -0.35, 0.00, -30.23] [Pi] fresh_mode=0 [EXIT] fresh_mode=0, socket close [Pi] GRIPPER: OPEN result= None [REF ] 基準画像: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_194818/frames/000000.jpg [REF ] お手本 run_0001_20261019_194818 (つかんだ瞬間の j0 = +13.2°) [REF ] 重なった画像のブロックに実物のブロックを合わせると, お手本と同じ位置に置ける [TILT ] 傾きのお手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 中央値 -0.61° (測れた 50/50 本. プラス=右下がり) [TILT ] 傾きはソフトでそろえる: ライブをお手本の中央値との差だけ回して重ねる (AI に渡す画像と同じ. 回す角度が 3° を超えたら画面の色を変える. 止めない) [ALIGN ] |dy| <= 20 なら OK. アームは HOME に置いた状態で合わせる. q または Esc で終了 (ファイルには何も書かない) [ALIGN ] dy= +0.5 dx= -1.6 response=0.828 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.99° → -0.61° にソフトでそろえる (+1.38° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +8.5 dx= +1.3 response=0.062 → 測れない (相関が弱く dx/dy が当てにならない (response=0.062 < 0.20)) 傾き -11.12° → -0.61° にソフトでそろえる (+10.51° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +8.1 dx= +1.6 response=0.109 → 測れない (相関が弱く dx/dy が当てにならない (response=0.109 < 0.20)) 傾き -12.17° → -0.61° にソフトでそろえる (+11.55° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +0.6 dx= -1.7 response=0.858 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.95° → -0.61° にソフトでそろえる (+1.34° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +6.3 dx= +1.2 response=0.091 → 測れない (相関が弱く dx/dy が当てにならない (response=0.091 < 0.20)) 傾き -7.46° → -0.61° にソフトでそろえる (+6.84° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +10.8 dx= +5.0 response=0.021 → 測れない (相関が弱く dx/dy が当てにならない (response=0.021 < 0.20)) 傾き -8.26° → -0.61° にソフトでそろえる (+7.65° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +8.8 dx= +2.9 response=0.026 → 測れない (相関が弱く dx/dy が当てにならない (response=0.026 < 0.20)) 傾き -8.26° → -0.61° にソフトでそろえる (+7.65° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +4.9 dx= +0.2 response=0.114 → 測れない (相関が弱く dx/dy が当てにならない (response=0.114 < 0.20)) 傾き -7.46° → -0.61° にソフトでそろえる (+6.84° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +0.7 dx= -1.8 response=0.841 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.91° → -0.61° にソフトでそろえる (+1.30° 回して重ねる. プラス=右下がり) [DONE ] 終了 (何も書いていません) (22 秒) === 8. 実機推論 (2 回目) [WAIT ] 送ったあと 0.0s / 爪のあと 0.8s (開くときの daemon 0.0s) / 止まるのを待つ目安 0.8s [GRIP ] 閉じる値 25 締め直し r は 22 と 25 を交互に送る [FLOW ] --flow: 途中の点は 5.0° 以内に近づくか見込みの時間で次を送る (間隔 0.4〜1.5 秒). 最後の点は 3° の到着を待つ 速さ 20 (既定) [SAFE ] 安全範囲 (学習 50 本 ±10°): j0[-72,+55] j1[-9,+88] j2[-45,+52] j3[-18,+27] j4[-87,+10] j5[-51,-15] [SAFE ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352) 元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes [MODE ] EXECUTE steps/chunk=10 max_move=20.0° log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_180704 [MODEL ] deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) [PAUSE ] --no-step-confirm: 始めの確かめのあとは入力欄を出さずに進みます. 止めるときはスペース (Enter も可). 今のチャンクを送り終えてから, 次の推論のあと (送る前) で入力欄を出します [CAMERA] 写り方 dy=-6.0 dx=+4.9 response=0.526 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 回したあとの画像で測った [CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg [CAMERA] 傾き -1.87° → -0.61° にそろえて渡す (+1.26° 回す. プラス=右下がり) (お手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 測れた 50/50 本・今 5/5 コマ) [POLICY] 接続 ws://localhost:8000 metadata={} [RECORD] 上カメラと実測角を 1 秒 10 コマで記録します → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_180704/recording [GRIP ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく) [STATE ] 実測を渡す (直前に送った目標がない) [000] 推論 1681ms 10ステップ先 Δ= +4.0 +12.8 +8.9 -1.4 -19.2 +2.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [CONFIRM] 2 回目からの試行なので始めの確かめ (Enter) を待たずに実行します (次の推論からは今までどおり確かめます) [GRIP ] 開始時にグリッパーを開く [Pi] GRIPPER: OPEN result= None [VIA ] step 2 Δ= +0.7 +2.9 +2.4 -0.1 -4.4 +0.3 流した 0.47 秒で次へ: 近づいた (残り 1.78°) [VIA ] step 5 Δ= +1.2 +3.4 +2.0 -0.6 -8.7 +0.9 流した 0.44 秒で次へ: 近づいた (残り 1.51°) [VIA ] step 8 Δ= +2.1 +3.5 +2.0 -1.2 -7.8 +1.3 流した 0.42 秒で次へ: 近づいた (残り 1.3°) [SEND] pi05_chunk000_via09: send_angles (single) [ +3.93, +14.07, +11.11, -1.66, -19.20, -27.83] speed=20 wait=0.0s (pre max|Δ|=2.86°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.19° (tol 3.0°) [VIA ] step 9 Δ= +0.7 +0.3 -0.2 -1.1 -2.9 +0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.19°（関節 j4） [001] 推論 744ms 10ステップ先 Δ= +4.9 +12.2 +8.0 -1.7 -23.4 +1.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.7 +3.2 +1.8 -1.7 -8.1 +0.8 流した 0.48 秒で次へ: 近づいた (残り 1.3°) [VIA ] step 5 Δ= +1.6 +2.8 +1.5 -0.4 -7.4 +0.4 流した 0.50 秒で次へ: 近づいた (残り 1.17°) [VIA ] step 8 Δ= +1.6 +3.4 +2.2 -0.1 -8.3 +0.4 流した 0.42 秒で次へ: 近づいた (残り 1.48°) [SEND] pi05_chunk001_via09: send_angles (single) [ +8.29, +27.25, +19.77, -2.32, -41.43, -26.99] speed=20 wait=0.0s (pre max|Δ|=3.20°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.87° (tol 3.0°) [VIA ] step 9 Δ= +0.7 +0.4 +0.3 -0.0 -3.2 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.96°（関節 j1） [002] 推論 1386ms 10ステップ先 Δ= +3.1 +8.6 +6.6 +0.0 -15.1 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.2 +2.3 +2.2 -0.1 -6.0 +0.2 流した 0.42 秒で次へ: 近づいた (残り 0.96°) [VIA ] step 5 Δ= +1.0 +1.4 +1.4 +0.1 -4.5 +0.2 流した 0.52 秒で次へ: 近づいた (残り 0.92°) [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [VIA ] step 8 Δ= +0.8 +2.2 +1.6 +0.1 -4.8 +0.3 流した 2.28 秒で次へ: 見込みの時間がたった [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [SEND] pi05_chunk002_via09: send_angles (single) [ +11.31, +36.76, +26.22, -2.24, -55.73, -26.90] speed=20 wait=0.0s (pre max|Δ|=1.07°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.94° (tol 3.0°) [VIA ] step 9 Δ= +0.2 -0.3 -0.1 -0.1 -1.1 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.94°（関節 j1） [003] 推論 725ms 10ステップ先 Δ= +2.5 +12.1 +1.0 +0.1 -9.7 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.1 +1.5 +1.0 -0.0 -3.3 +0.1 流した 0.52 秒で次へ: 近づいた (残り 0.84°) [VIA ] step 5 Δ= +1.1 +3.2 +0.5 +0.0 -3.1 +0.1 流した 0.44 秒で次へ: 近づいた (残り 0.89°) [VIA ] step 8 Δ= +0.4 +4.2 -0.4 -0.1 -3.0 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.03°) [SEND] pi05_chunk003_via09: send_angles (single) [ +13.70, +49.78, +27.32, -2.09, -65.01, -26.89] speed=20 wait=0.0s (pre max|Δ|=1.03°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.93° (tol 3.0°) [VIA ] step 9 Δ= +0.4 +0.5 -0.6 -0.2 -1.0 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.93°（関節 j1） [004] 推論 545ms 9ステップ先 Δ= +0.7 +8.8 -8.2 -0.3 +1.1 -0.1 グリッパー→閉 [VIA ] 中継点 3 点: step 2, 5, 8 [VIA ] step 2 Δ= +0.7 +3.2 -3.9 -0.3 +0.7 +0.1 流した 0.48 秒で次へ: 近づいた (残り 1.01°) [VIA ] step 5 Δ= +0.1 +3.6 -4.2 -0.4 +1.2 -0.0 流した 0.48 秒で次へ: 近づいた (残り 1.16°) [SEND] pi05_chunk004_via08: send_angles (single) [ +13.94, +59.56, +19.77, -2.16, -63.79, -27.19] speed=20 wait=0.0s (pre max|Δ|=2.02°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.16° (tol 3.0°) [VIA ] step 8 Δ= -0.0 +0.2 -2.0 -0.4 +1.2 -0.1 着いた [Pi] GRIPPER: VALUE=25 speed=100 result= None [STATE ] 目標を渡す 目標と実測の最大差 1.95°（関節 j4） [005] 推論 590ms 10ステップ先 Δ= +1.1 -10.5 +8.1 -1.4 +3.3 +0.8 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.3 -4.3 +2.0 -1.2 +3.3 +0.4 流した 0.42 秒で次へ: 近づいた (残り 1.72°) [VIA ] step 5 Δ= +0.6 -6.3 +4.7 -0.7 +2.5 +0.9 流した 0.42 秒で次へ: 近づいた (残り 1.84°) [VIA ] step 8 Δ= +0.9 -3.6 +2.1 -0.5 +0.1 +0.3 流した 0.44 秒で次へ: 近づいた (残り 1.61°) [SEND] pi05_chunk005_via09: send_angles (single) [ +14.89, +49.97, +28.65, -2.67, -62.39, -26.49] speed=20 wait=0.0s (pre max|Δ|=1.44°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.44° (tol 3.0°) [VIA ] step 9 Δ= +0.1 -1.4 -1.0 -0.4 -0.2 +0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.44°（関節 j1） [006] 推論 1556ms 10ステップ先 Δ=+16.9 +0.5 -16.2 +3.1 +4.8 -4.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +5.8 -1.3 -5.8 +0.8 +0.9 -1.5 流した 0.60 秒で次へ: 近づいた (残り 1.32°) [VIA ] step 5 Δ= +5.2 -0.5 -6.4 +1.8 +2.8 -2.6 流した 0.52 秒で次へ: 近づいた (残り 1.2°) [VIA ] step 8 Δ= +4.6 -0.2 -5.1 +1.4 +2.5 -2.4 流した 0.40 秒で次へ: 近づいた (残り 1.04°) [SEND] pi05_chunk006_via09: send_angles (single) [ +31.70, +51.93, +13.37, +0.83, -57.37, -30.70] speed=20 wait=0.0s (pre max|Δ|=1.92°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.57° (tol 3.0°) [VIA ] step 9 Δ= +1.2 -0.5 -1.9 +0.5 +0.7 -1.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.57°（関節 j2） [007] 推論 637ms 10ステップ先 Δ= +0.8 -0.6 -9.1 +0.4 +0.6 -1.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.4 -0.9 -2.7 +0.1 +0.4 -0.9 流した 0.52 秒で次へ: 近づいた (残り 1.06°) [VIA ] step 5 Δ= +0.5 -0.8 -4.3 -0.3 +0.8 -0.8 流した 0.50 秒で次へ: 近づいた (残り 1.01°) [VIA ] step 8 Δ= +0.6 -0.9 -3.3 -0.1 +0.3 -0.7 流した 0.59 秒で次へ: 近づいた (残り 1.07°) [SEND] pi05_chunk007_via09: send_angles (single) [ +32.17, +52.23, +5.87, +1.24, -57.39, -30.70] speed=20 wait=0.0s (pre max|Δ|=1.86°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.77° (tol 3.0°) [VIA ] step 9 Δ= +0.8 -0.8 -1.9 +0.0 +0.1 -0.7 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.77°（関節 j2） [008] 推論 565ms 10ステップ先 Δ= +5.7 -1.1 -6.5 +0.7 +0.6 -0.7 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.3 -1.2 -4.1 +0.0 +0.9 -0.6 流した 0.52 秒で次へ: 近づいた (残り 1.17°) [VIA ] step 5 Δ= +1.3 -1.4 -2.4 +0.2 +0.1 -0.6 流した 0.48 秒で次へ: 近づいた (残り 1.38°) [VIA ] step 8 Δ= +2.2 -1.2 -2.2 +0.4 +0.0 -0.5 流した 0.59 秒で次へ: 近づいた (残り 1.41°) [SEND] pi05_chunk008_via09: send_angles (single) [ +37.51, +52.07, +1.12, +1.74, -56.83, -30.80] speed=20 wait=0.0s (pre max|Δ|=1.60°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.60° (tol 3.0°) [VIA ] step 9 Δ= +0.7 -1.1 -1.6 +0.5 -0.2 -0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.60°（関節 j2） [009] 推論 827ms 10ステップ先 Δ= +5.2 +8.3 -3.9 +1.8 -3.9 -1.6 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +3.9 -0.9 -3.2 +0.7 +2.0 -0.8 流した 0.50 秒で次へ: 近づいた (残り 1.4°) [VIA ] step 5 Δ= +2.1 +2.1 -2.2 +0.5 -0.5 -0.9 流した 0.42 秒で次へ: 近づいた (残り 1.49°) [VIA ] step 8 Δ= -0.4 +3.9 -1.4 +0.7 -4.6 -0.5 流した 0.48 秒で次へ: 近づいた (残り 1.73°) [SEND] pi05_chunk009_via09: send_angles (single) [ +42.62, +61.43, -1.20, +3.02, -60.55, -32.02] speed=20 wait=0.0s (pre max|Δ|=2.55°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.28° (tol 3.0°) [VIA ] step 9 Δ= -0.5 -0.0 -1.3 +0.9 -2.5 -0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.28°（関節 j2） [010] 推論 1552ms 4ステップ先 Δ= -0.5 +0.5 -1.3 +1.0 -2.4 -0.0 グリッパー→開 [VIA ] 中継点 2 点: step 2, 3 [VIA ] step 2 Δ= -0.5 +0.5 -1.3 +0.9 -2.3 -0.0 流した 0.42 秒で次へ: 近づいた (残り 1.31°) [SEND] pi05_chunk010_via03: send_angles (single) [ +42.44, +62.83, -1.23, +3.25, -61.84, -32.10] speed=20 wait=0.0s (pre max|Δ|=1.31°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.31° (tol 3.0°) [VIA ] step 3 Δ= -0.5 -0.9 -1.3 +0.6 +0.1 +0.5 着いた [Pi] GRIPPER: OPEN result= None [STATE ] 目標を渡す 目標と実測の最大差 1.31°（関節 j2） [011] 推論 628ms 10ステップ先 Δ= -0.2 -12.6 -1.2 -0.1 +12.6 +0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.3 -5.4 -1.4 -0.4 +5.4 +0.3 流した 0.42 秒で次へ: 近づいた (残り 2.03°) [VIA ] step 5 Δ= -0.2 -5.5 -1.4 -0.4 +5.2 +0.1 流した 0.52 秒で次へ: 近づいた (残り 1.93°) [VIA ] step 8 Δ= -0.2 -4.9 -1.2 -0.2 +3.9 +0.0 流した 0.43 秒で次へ: 近づいた (残り 1.95°) [SEND] pi05_chunk011_via09: send_angles (single) [ +42.73, +51.10, -1.10, +3.45, -49.37, -32.31] speed=20 wait=0.0s (pre max|Δ|=2.68°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.51° (tol 3.0°) [VIA ] step 9 Δ= -0.2 -2.7 -1.2 -0.4 +1.6 +0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.51°（関節 j1） [012] 推論 1687ms 10ステップ先 Δ= -1.9 -3.7 -0.8 -0.3 +2.7 -0.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.5 -4.1 -1.0 -0.3 +2.8 -0.0 流した 0.42 秒で次へ: 近づいた (残り 1.99°) [VIA ] step 5 Δ= -1.2 -1.6 -0.9 -0.2 +0.2 -0.0 流した 0.42 秒で次へ: 近づいた (残り 1.62°) [VIA ] step 8 Δ= -0.5 -1.6 -0.8 -0.9 +0.2 -0.1 流した 0.50 秒で次へ: 近づいた (残り 1.62°) [SEND] pi05_chunk012_via09: send_angles (single) [ +41.01, +49.91, -0.72, +3.55, -47.63, -32.37] speed=20 wait=0.0s (pre max|Δ|=1.59°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.59° (tol 3.0°) [VIA ] step 9 Δ= -0.4 -1.6 -0.8 -0.8 +0.2 -0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.59°（関節 j1） [013] 推論 731ms 10ステップ先 Δ= -4.4 -10.1 +0.1 -1.4 +8.7 -0.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.1 -4.9 -0.6 -0.9 +3.4 -0.1 流した 0.40 秒で次へ: 近づいた (残り 1.9°) [VIA ] step 5 Δ= -0.5 -3.3 -0.4 -0.8 +1.9 -0.1 流した 0.50 秒で次へ: 近づいた (残り 2.11°) [VIA ] step 8 Δ= -2.0 -4.4 -0.0 -0.9 +2.7 -0.1 流した 0.44 秒で次へ: 近づいた (残り 1.96°) [SEND] pi05_chunk013_via09: send_angles (single) [ +36.96, +41.44, +0.16, +2.98, -39.16, -32.29] speed=20 wait=0.0s (pre max|Δ|=3.47°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.06° (tol 3.0°) [VIA ] step 9 Δ= -1.4 -3.5 -0.4 -0.4 +2.1 -0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.06°（関節 j1） [014] 推論 780ms 10ステップ先 Δ=-21.4 -26.3 +0.9 -3.8 +26.8 +1.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -6.1 -9.1 -0.1 -1.5 +7.3 +0.4 流した 0.50 秒で次へ: 近づいた (残り 1.93°) [VIA ] step 5 Δ= -6.5 -9.6 +0.1 -1.5 +8.3 +0.8 流した 0.44 秒で次へ: 近づいた (残り 1.73°) [VIA ] step 8 Δ= -7.2 -9.2 -0.2 -1.6 +9.4 +0.8 流した 0.62 秒で次へ: 近づいた (残り 1.53°) [PAUSE ] 止める予約 (Enter). 推論 14 を送り終えてから, 次の推論のあと (送る前) で止めます [SEND] pi05_chunk014_via09: send_angles (single) [ +15.65, +17.25, +1.63, -0.35, -12.61, -31.15] speed=20 wait=0.0s (pre max|Δ|=3.66°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.64° (tol 3.0°) [VIA ] step 9 Δ= -2.2 -3.7 -0.6 -0.9 +3.1 +0.8 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.64°（関節 j1） [015] 推論 549ms 10ステップ先 Δ=-12.6 -14.0 -0.6 -0.5 +8.1 +1.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [PAUSE ] 止めました (推論 15 はまだ送っていません). Enter で実行すると, また止まらずに進みます Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > h [SEND] pi05_home: send_angles (single) [ +0.00, +0.00, +0.00, +0.00, +0.00, -30.00] speed=20 wait=0.0s (pre max|Δ|=18.89°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.19° (tol 2.5°) [RECORD] 記録終了 コマ 574 (8.901 fps) 実測角 447 回 (6.93 Hz) 電流 455 行 (read_servo) → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_180704/recording 結果: y=成功 / n=失敗 / Enter=記録しない > y [GRIP ] 閉じて 1 秒後の爪の電流 (中央値): 1 回目 798 (9 行) (閉じる値 25) [DONE ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_180704 [CLIENT] run_policy_client.py が終わった (終了コード 0. モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1)) (82 秒) もう1回やりますか? y=やる / 他=終わる > n === かかった時間 モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 1. Pod を作る 2 秒 2. Pod が立ち上がるまで待つ 38 秒 3a. スクリプトを送る 101 秒 3b. huggingface_hub を入れ, 鍵を渡す 10 秒 3c. モデルを取る (hf download PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 23 秒 3d. openpi を取る (215abfb) 15 秒 3e. uv sync 27 秒 3f. addon・設定・assets (pi05_mecharm_deep_even10_lora) 3 秒 4. サーバーの起動 43 秒 5. Mac の 8000 番へのトンネル 2 秒 5b. 空打ち (1 回目の推論の待ちを先に済ませる) 55 秒 6. デーモンの状態 2 秒 7. HOME → 爪を開く → 位置合わせ (1 回目) 65 秒 8. 実機推論 (1 回目) 101 秒 7. HOME → 爪を開く → 位置合わせ (2 回目) 22 秒 8. 実機推論 (2 回目) 82 秒 [LAB ] Pod は残しています (id 9wypmq2uhnx2et). 片付けは ./lab_stop.sh --log Log35 [TUNNEL] 8000 番のトンネルを閉じました ``` ### 2回目の起動（今までの送り方・速さ20）のターミナル ``` [RANGE ] 安全範囲 (学習データ ±10°) は /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes から (--model deep1) [FRAME ] 写り方の確かめの基準画像は /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes の最初のエピソードから (位置合わせと同じ trim2. 依頼 137) [TILT ] 上カメラの傾きのお手本 (各エピソードの 1 枚目の中央値) は /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes から (安全範囲と同じ. 差だけ画像を回して AI に渡す. 依頼 144) [GRIP ] 爪の閉じる値は 25 (--grip-value). 締め直し r はこの値−3 とこの値を交互に送る (依頼 152) [CONFIRM] チャンクごとには確かめない (--no-step-confirm. 始めの確かめのあとは止まらずに進む. 止めるときはスペース. 依頼 178) [LAB ] 2026-11-14 18:08:39 GPU=NVIDIA A40 episode=run_0001_20261019_194818 log=/Volumes/KIOXIA/r2r2r-data/lab/Log35 [MODEL ] --model deep1: π0.5 base から deep_even10_v1 で新しく学習した 2999 (依頼 133. decay_steps 5000) PixelstoMotors/pi05-mecharm-deep-even10-lora-v1 → /workspace/ckpt/deep_v1_2999 設定 pi05_mecharm_deep_even10_lora assets local/mecharm_redblock_box_deep_even10_v1 === 1. Pod を作る [POD ] Log35 の Pod (id 9wypmq2uhnx2et) につなぎ直します (状態 RUNNING GPU=NVIDIA A40 1時間 0.59 ドル 作った時刻 2026-11-14 17:58:33) [POD ] 記録の最後のモデル: deep1 今回: --model deep1 (2 秒) === 2. Pod が立ち上がるまで待つ [POD ] SSH の IP とポートを API から取り直した (:) [POD ] 入れた: 7711f98bf50a NVIDIA A40, 46068 MiB (5 秒) === 3. Pod の中を確かめる (つなぎ直し) [POD ] serve_policy.py のプロセス: ある 8000 番の LISTEN: ある [POD ] モデル (/workspace/ckpt/deep_v1_2999): ある openpi (215abfb): ある .venv: ある [POD ] 動いているサーバーのモデル: --policy.dir=/workspace/ckpt/deep_v1_2999 (--model deep1 と同じ) [POD ] サーバーは 8000 番で待っています. 3b〜4 を飛ばします INFO:websockets.server:server listening on 0.0.0.0:8000 (8 秒) === 3a. スクリプトを送る (101 秒) === 3b〜4. 準備とサーバーの起動 → 飛ばす (サーバーが 8000 番で待っている) === 5. Mac の 8000 番へのトンネル [TUNNEL] localhost:8000 → Pod の 8000 番 (pid 60964. このスクリプトが終わると閉じる) (2 秒) === 5b. 空打ち (1 回目の推論の待ちを先に済ませる) [WARM ] 空打ち: localhost:8000 に観測 (画像 384x216・state 7 つ・prompt) を 1 回投げて捨てます (お手本 pi05_20261031_175527 の 1 枚目) [WARM ] 空打ち 0.9 秒 (つなぐまで含めて 2.1 秒. 答え 10x7 は捨てた) (3 秒) === 6. デーモンの状態 --- process 514 /usr/bin/python3 -u /home/ubuntu/mecharm_daemon.py --- 5555 LISTEN 0 1 0.0.0.0:5555 0.0.0.0:* --- systemd enabled: enabled active: active (2 秒) === 7. HOME → 爪を開く → 位置合わせ (1 回目) [INIT] daemon 接続中... [Pi] fresh_mode=1 [INIT] fresh_mode=1 [PRE] 現在姿勢: [0.17, 1.40, 2.19, -0.26, -0.26, -30.23] [SEND] HOME へ移動指令 [WAIT] t=0.6s max_err=2.19° [DONE] HOME 到達 max_err=2.19° [POST] 最終姿勢: [0.17, 1.40, 2.19, -0.26, -0.26, -30.23] [Pi] fresh_mode=0 [EXIT] fresh_mode=0, socket close [Pi] GRIPPER: OPEN result= None [REF ] 基準画像: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_194818/frames/000000.jpg [REF ] お手本 run_0001_20261019_194818 (つかんだ瞬間の j0 = +13.2°) [REF ] 重なった画像のブロックに実物のブロックを合わせると, お手本と同じ位置に置ける [TILT ] 傾きのお手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 中央値 -0.61° (測れた 50/50 本. プラス=右下がり) [TILT ] 傾きはソフトでそろえる: ライブをお手本の中央値との差だけ回して重ねる (AI に渡す画像と同じ. 回す角度が 3° を超えたら画面の色を変える. 止めない) [ALIGN ] |dy| <= 20 なら OK. アームは HOME に置いた状態で合わせる. q または Esc で終了 (ファイルには何も書かない) [ALIGN ] dy= +0.6 dx= -1.6 response=0.829 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.95° → -0.61° にソフトでそろえる (+1.34° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +13.1 dx= +1.4 response=0.021 → 測れない (相関が弱く dx/dy が当てにならない (response=0.021 < 0.20)) 傾き -10.82° → -0.61° にソフトでそろえる (+10.21° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +7.2 dx= +3.4 response=0.055 → 測れない (相関が弱く dx/dy が当てにならない (response=0.055 < 0.20)) 傾き -10.82° → -0.61° にソフトでそろえる (+10.21° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +16.8 dx= +4.6 response=0.010 → 測れない (相関が弱く dx/dy が当てにならない (response=0.010 < 0.20)) 傾き -10.82° → -0.61° にソフトでそろえる (+10.21° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +9.8 dx= +2.8 response=0.036 → 測れない (相関が弱く dx/dy が当てにならない (response=0.036 < 0.20)) 傾き -10.65° → -0.61° にソフトでそろえる (+10.03° 回して重ねる. プラス=右下がり) → 回す角度が 3° を超える (TILT DIFFERS. iPhone の付け方を見直す) [ALIGN ] dy= +0.6 dx= -1.2 response=0.794 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.95° → -0.61° にソフトでそろえる (+1.34° 回して重ねる. プラス=右下がり) [DONE ] 終了 (何も書いていません) (15 秒) === 8. 実機推論 (1 回目) [WAIT ] 送ったあと 0.0s / 爪のあと 0.8s (開くときの daemon 0.0s) / 止まるのを待つ目安 0.8s [GRIP ] 閉じる値 25 締め直し r は 22 と 25 を交互に送る [SAFE ] 安全範囲 (学習 50 本 ±10°): j0[-72,+55] j1[-9,+88] j2[-45,+52] j3[-18,+27] j4[-87,+10] j5[-51,-15] [SAFE ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352) 元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes [MODE ] EXECUTE steps/chunk=10 max_move=20.0° log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_181057 [MODEL ] deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) [PAUSE ] --no-step-confirm: 始めの確かめのあとは入力欄を出さずに進みます. 止めるときはスペース (Enter も可). 今のチャンクを送り終えてから, 次の推論のあと (送る前) で入力欄を出します [CAMERA] 写り方 dy=-5.8 dx=+5.6 response=0.540 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 回したあとの画像で測った [CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg [CAMERA] 傾き -1.99° → -0.61° にそろえて渡す (+1.38° 回す. プラス=右下がり) (お手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 測れた 50/50 本・今 5/5 コマ) [POLICY] 接続 ws://localhost:8000 metadata={} [RECORD] 上カメラと実測角を 1 秒 10 コマで記録します → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_181057/recording [GRIP ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく) [STATE ] 実測を渡す (直前に送った目標がない) [000] 推論 790ms 10ステップ先 Δ= +3.0 +12.5 +7.9 -1.8 -16.3 +1.7 [VIA ] 中継点 4 点: step 2, 5, 8, 9 Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > [GRIP ] 開始時にグリッパーを開く [Pi] GRIPPER: OPEN result= None [SEND] pi05_chunk000_via02: send_angles (single) [ +0.83, +4.45, +4.36, -0.38, -4.03, -30.01] speed=20 wait=0.0s (pre max|Δ|=3.77°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.93° (tol 3.0°) [VIA ] step 2 Δ= +0.8 +3.1 +2.2 -0.1 -3.8 +0.2 着いた [SEND] pi05_chunk000_via05: send_angles (single) [ +1.85, +8.73, +6.90, -1.03, -9.65, -29.52] speed=20 wait=0.0s (pre max|Δ|=7.55°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.36° (tol 3.0°) [VIA ] step 5 Δ= +0.8 +3.4 +1.5 -0.8 -7.6 +0.7 着いた [SEND] pi05_chunk000_via08: send_angles (single) [ +2.80, +12.98, +9.59, -1.89, -15.27, -28.70] speed=20 wait=0.0s (pre max|Δ|=7.01°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.39° (tol 3.0°) [VIA ] step 8 Δ= +1.3 +3.2 +1.7 -1.6 -7.0 +0.9 着いた [SEND] pi05_chunk000_via09: send_angles (single) [ +3.22, +13.88, +10.04, -2.07, -16.55, -28.51] speed=20 wait=0.0s (pre max|Δ|=2.67°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.26° (tol 3.0°) [VIA ] step 9 Δ= +0.6 -0.1 -0.4 -1.1 -2.7 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.26°（関節 j4） [001] 推論 641ms 10ステップ先 Δ= +4.9 +16.1 +9.6 -2.1 -25.9 +1.7 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk001_via02: send_angles (single) [ +4.54, +18.56, +12.59, -2.66, -22.88, -27.71] speed=20 wait=0.0s (pre max|Δ|=7.50°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.03° (tol 3.0°) [VIA ] step 2 Δ= +1.3 +3.8 +2.0 -1.5 -7.5 +1.0 着いた [SEND] pi05_chunk001_via05: send_angles (single) [ +5.78, +23.16, +15.41, -2.87, -29.66, -27.30] speed=20 wait=0.0s (pre max|Δ|=7.60°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.84° (tol 3.0°) [VIA ] step 5 Δ= +1.4 +3.6 +2.0 -0.5 -7.6 +0.6 着いた [SEND] pi05_chunk001_via08: send_angles (single) [ +7.43, +28.67, +18.83, -3.06, -38.00, -27.13] speed=20 wait=0.0s (pre max|Δ|=9.00°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.94° (tol 3.0°) [VIA ] step 8 Δ= +1.8 +4.6 +2.6 -0.5 -9.0 +0.3 着いた [SEND] pi05_chunk001_via09: send_angles (single) [ +8.18, +30.81, +20.21, -3.15, -41.24, -27.16] speed=20 wait=0.0s (pre max|Δ|=4.16°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.91° (tol 3.0°) [VIA ] step 9 Δ= +1.2 +1.2 +0.7 -0.3 -4.2 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.91°（関節 j1） [002] 推論 1483ms 10ステップ先 Δ= +1.7 +3.9 +1.1 +0.3 -7.2 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk002_via02: send_angles (single) [ +8.82, +31.54, +20.52, -3.07, -42.16, -27.12] speed=20 wait=0.0s (pre max|Δ|=1.56°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.89° (tol 3.0°) [VIA ] step 2 Δ= +0.7 -0.2 -0.1 -0.2 -1.6 +0.2 着いた [SEND] pi05_chunk002_via05: send_angles (single) [ +9.24, +32.94, +20.71, -2.89, -44.10, -27.12] speed=20 wait=0.0s (pre max|Δ|=2.18°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.98° (tol 3.0°) [VIA ] step 5 Δ= +0.5 +0.5 +0.1 +0.2 -2.2 +0.2 着いた [SEND] pi05_chunk002_via08: send_angles (single) [ +9.66, +34.88, +21.45, -2.66, -46.69, -27.09] speed=20 wait=0.0s (pre max|Δ|=2.93°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.97° (tol 3.0°) [VIA ] step 8 Δ= +0.9 +1.0 +0.8 +0.3 -2.9 +0.2 着いた [SEND] pi05_chunk002_via09: send_angles (single) [ +9.77, +35.60, +21.74, -2.59, -47.82, -27.09] speed=20 wait=0.0s (pre max|Δ|=1.24°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.96° (tol 3.0°) [VIA ] step 9 Δ= +0.2 -0.2 -0.1 +0.3 -1.2 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.96°（関節 j1） [003] 推論 583ms 10ステップ先 Δ= +2.0 +11.4 +2.6 +1.0 -12.6 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk003_via02: send_angles (single) [ +10.62, +39.53, +23.37, -2.21, -53.21, -27.07] speed=20 wait=0.0s (pre max|Δ|=5.75°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.83° (tol 3.0°) [VIA ] step 2 Δ= +1.0 +2.9 +1.1 +0.7 -5.7 +0.3 着いた [SEND] pi05_chunk003_via05: send_angles (single) [ +11.13, +43.69, +24.72, -1.94, -57.49, -27.05] speed=20 wait=0.0s (pre max|Δ|=4.94°, post-send timeout 8.0s) [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [SEND] arrival OK: max|Δ|=1.04° (tol 3.0°) [VIA ] step 5 Δ= +0.4 +3.4 +1.0 +1.0 -4.9 +0.2 着いた [SEND] pi05_chunk003_via08: send_angles (single) [ +11.48, +47.24, +25.02, -1.87, -59.91, -27.03] speed=20 wait=0.0s (pre max|Δ|=2.79°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.01° (tol 3.0°) [VIA ] step 8 Δ= +0.8 +2.5 -0.1 +0.4 -2.8 +0.2 着いた [SEND] pi05_chunk003_via09: send_angles (single) [ +11.59, +47.91, +24.84, -1.85, -60.02, -27.03] speed=20 wait=0.0s (pre max|Δ|=0.61°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.95° (tol 3.0°) [VIA ] step 9 Δ= -0.0 -0.4 -0.3 -0.0 -0.6 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.95°（関節 j1） [004] 推論 571ms 10ステップ先 Δ= +0.5 +10.1 -4.7 -0.6 -2.1 +0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk004_via02: send_angles (single) [ +12.05, +50.89, +24.95, -1.94, -60.91, -27.01] speed=20 wait=0.0s (pre max|Δ|=2.03°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.05° (tol 3.0°) [VIA ] step 2 Δ= +0.4 +2.0 -0.2 -0.1 -1.4 +0.2 着いた [SEND] pi05_chunk004_via05: send_angles (single) [ +12.37, +56.30, +22.14, -2.27, -61.46, -27.02] speed=20 wait=0.0s (pre max|Δ|=4.36°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.94° (tol 3.0°) [VIA ] step 5 Δ= +0.8 +4.4 -3.0 -0.4 -0.7 +0.2 着いた [SEND] pi05_chunk004_via08: send_angles (single) [ +12.21, +58.81, +20.59, -2.38, -61.55, -27.09] speed=20 wait=0.0s (pre max|Δ|=2.52°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.64° (tol 3.0°) [VIA ] step 8 Δ= +0.1 +1.7 -2.5 -0.9 +0.5 +0.1 着いた [SEND] pi05_chunk004_via09: send_angles (single) [ +12.08, +58.92, +20.39, -2.39, -61.60, -27.11] speed=20 wait=0.0s (pre max|Δ|=1.68°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.68° (tol 3.0°) [VIA ] step 9 Δ= -0.0 -0.6 -1.0 -0.9 +1.7 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.68°（関節 j4） [005] 推論 1545ms 4ステップ先 Δ= +0.2 +0.7 -2.5 -0.9 +1.6 +0.2 グリッパー→閉 [VIA ] 中継点 2 点: step 2, 3 [SEND] pi05_chunk005_via02: send_angles (single) [ +12.32, +60.28, +18.76, -2.35, -61.63, -27.18] speed=20 wait=0.0s (pre max|Δ|=2.50°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.65° (tol 3.0°) [VIA ] step 2 Δ= +0.3 +0.7 -2.5 -0.8 +1.6 +0.2 着いた [SEND] pi05_chunk005_via03: send_angles (single) [ +12.32, +60.28, +18.76, -2.35, -61.63, -27.18] speed=20 wait=0.0s (pre max|Δ|=1.65°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.65° (tol 3.0°) [VIA ] step 3 Δ= +0.3 -0.6 -0.6 -0.7 +1.6 +0.2 着いた [Pi] GRIPPER: VALUE=25 speed=100 result= None [STATE ] 目標を渡す 目標と実測の最大差 2.44°（関節 j4） [006] 推論 750ms 10ステップ先 Δ= +1.0 -7.3 +9.4 -1.0 -0.4 +1.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk006_via02: send_angles (single) [ +12.53, +58.53, +20.69, -2.63, -61.88, -27.07] speed=20 wait=0.0s (pre max|Δ|=2.37°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.66° (tol 3.0°) [VIA ] step 2 Δ= +0.6 -2.4 +1.4 -0.9 +2.2 +0.5 着いた [SEND] pi05_chunk006_via05: send_angles (single) [ +12.61, +55.86, +24.93, -2.80, -62.19, -26.51] speed=20 wait=0.0s (pre max|Δ|=4.90°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.64° (tol 3.0°) [VIA ] step 5 Δ= +0.7 -3.9 +4.9 -0.8 +1.3 +1.0 着いた [SEND] pi05_chunk006_via08: send_angles (single) [ +12.89, +54.01, +28.19, -2.75, -63.76, -26.40] speed=20 wait=0.0s (pre max|Δ|=4.11°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.09° (tol 3.0°) [VIA ] step 8 Δ= +0.9 -2.9 +4.1 -0.1 -0.3 +0.5 着いた [SEND] pi05_chunk006_via09: send_angles (single) [ +12.99, +53.56, +28.70, -2.69, -64.48, -26.42] speed=20 wait=0.0s (pre max|Δ|=1.54°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.37° (tol 3.0°) [VIA ] step 9 Δ= +0.4 -1.5 +1.4 -0.2 -0.2 +0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.37°（関節 j1） [007] 推論 1714ms 10ステップ先 Δ=+12.4 -1.4 -9.6 +2.5 +3.9 -2.9 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk007_via02: send_angles (single) [ +17.65, +53.08, +25.70, -1.81, -63.41, -27.44] speed=20 wait=0.0s (pre max|Δ|=5.09°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.58° (tol 3.0°) [VIA ] step 2 Δ= +5.1 -1.8 -2.2 +0.7 +1.0 -0.7 着いた [SEND] pi05_chunk007_via05: send_angles (single) [ +22.12, +53.44, +21.02, -0.81, -62.11, -28.68] speed=20 wait=0.0s (pre max|Δ|=5.34°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.09° (tol 3.0°) [VIA ] step 5 Δ= +4.4 -1.2 -5.3 +0.9 +0.9 -1.9 着いた [SEND] pi05_chunk007_via08: send_angles (single) [ +24.64, +53.50, +18.36, -0.06, -60.71, -29.54] speed=20 wait=0.0s (pre max|Δ|=3.61°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.42° (tol 3.0°) [VIA ] step 8 Δ= +2.6 -1.2 -3.6 +1.4 +0.0 -2.5 着いた [SEND] pi05_chunk007_via09: send_angles (single) [ +25.01, +53.49, +18.31, +0.05, -60.57, -29.61] speed=20 wait=0.0s (pre max|Δ|=1.49°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.40° (tol 3.0°) [VIA ] step 9 Δ= +0.3 -1.2 -0.9 +1.0 -1.2 -1.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.40°（関節 j5） [008] 推論 942ms 10ステップ先 Δ= +3.2 +1.1 -6.8 +1.6 -0.3 -2.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk008_via02: send_angles (single) [ +26.28, +53.48, +16.56, +0.48, -59.94, -29.93] speed=20 wait=0.0s (pre max|Δ|=2.68°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.18° (tol 3.0°) [VIA ] step 2 Δ= +1.6 -1.2 -2.7 +1.1 -0.5 -1.4 着いた [SEND] pi05_chunk008_via05: send_angles (single) [ +27.13, +53.81, +14.49, +0.67, -59.39, -30.20] speed=20 wait=0.0s (pre max|Δ|=3.17°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.06° (tol 3.0°) [VIA ] step 5 Δ= +0.9 -0.9 -3.2 +0.7 -0.1 -0.9 着いた [SEND] pi05_chunk008_via08: send_angles (single) [ +27.85, +55.08, +12.74, +0.88, -59.44, -30.48] speed=20 wait=0.0s (pre max|Δ|=2.72°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.25° (tol 3.0°) [VIA ] step 8 Δ= +0.7 +0.3 -2.7 +0.8 -0.6 -1.0 着いた [SEND] pi05_chunk008_via09: send_angles (single) [ +27.89, +55.75, +12.45, +0.98, -59.72, -30.50] speed=20 wait=0.0s (pre max|Δ|=1.43°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.43° (tol 3.0°) [VIA ] step 9 Δ= +0.4 -0.6 -1.4 +0.4 -0.9 -0.7 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.43°（関節 j2） [009] 推論 776ms 10ステップ先 Δ= +0.6 -0.9 -8.2 +0.8 -0.8 -0.8 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk009_via02: send_angles (single) [ +27.99, +55.75, +10.29, +1.03, -59.62, -30.55] speed=20 wait=0.0s (pre max|Δ|=3.59°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.02° (tol 3.0°) [VIA ] step 2 Δ= +0.5 -0.9 -3.6 +0.5 -0.8 -0.8 着いた [SEND] pi05_chunk009_via05: send_angles (single) [ +27.89, +55.64, +8.05, +1.07, -59.59, -30.57] speed=20 wait=0.0s (pre max|Δ|=3.20°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.13° (tol 3.0°) [VIA ] step 5 Δ= +0.4 -1.1 -3.2 +0.0 -0.8 -0.6 着いた [SEND] pi05_chunk009_via08: send_angles (single) [ +28.10, +55.63, +5.99, +1.21, -59.51, -30.61] speed=20 wait=0.0s (pre max|Δ|=3.15°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.21° (tol 3.0°) [VIA ] step 8 Δ= +0.6 -1.1 -3.2 -0.1 -0.7 -0.6 着いた [SEND] pi05_chunk009_via09: send_angles (single) [ +28.14, +55.75, +5.65, +1.28, -59.63, -30.62] speed=20 wait=0.0s (pre max|Δ|=1.46°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.46° (tol 3.0°) [VIA ] step 9 Δ= +0.6 -1.0 -1.5 -0.3 -0.8 -0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.46°（関節 j2） [010] 推論 754ms 10ステップ先 Δ= +7.8 -1.7 -2.7 +0.4 -0.2 -0.7 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk010_via02: send_angles (single) [ +28.38, +55.68, +5.54, +1.34, -59.67, -30.60] speed=20 wait=0.0s (pre max|Δ|=1.57°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.57° (tol 3.0°) [VIA ] step 2 Δ= +0.9 -1.1 -1.6 -0.2 -0.9 -0.4 着いた [SEND] pi05_chunk010_via05: send_angles (single) [ +29.29, +55.28, +5.39, +1.56, -59.46, -30.62] speed=20 wait=0.0s (pre max|Δ|=1.72°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.72° (tol 3.0°) [VIA ] step 5 Δ= +1.3 -1.5 -1.7 -0.2 -0.7 -0.4 着いた [SEND] pi05_chunk010_via08: send_angles (single) [ +33.77, +55.06, +4.61, +1.93, -59.09, -30.78] speed=20 wait=0.0s (pre max|Δ|=4.60°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.13° (tol 3.0°) [VIA ] step 8 Δ= +4.6 -1.7 -2.5 -0.3 -0.3 -0.5 着いた [SEND] pi05_chunk010_via09: send_angles (single) [ +35.29, +55.08, +4.40, +2.02, -59.03, -30.88] speed=20 wait=0.0s (pre max|Δ|=1.69°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.69° (tol 3.0°) [VIA ] step 9 Δ= +1.2 -1.7 -1.5 +0.4 -0.2 -0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.69°（関節 j1） [011] 推論 596ms 10ステップ先 Δ= +0.8 +4.2 -2.8 +1.1 -3.6 -0.7 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk011_via02: send_angles (single) [ +35.55, +55.74, +3.61, +2.19, -59.42, -30.90] speed=20 wait=0.0s (pre max|Δ|=2.19°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.19° (tol 3.0°) [VIA ] step 2 Δ= +0.1 -1.0 -2.2 +0.5 -0.6 -0.4 着いた [SEND] pi05_chunk011_via05: send_angles (single) [ +35.89, +57.76, +3.22, +2.47, -60.29, -31.01] speed=20 wait=0.0s (pre max|Δ|=2.58°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.08° (tol 3.0°) [VIA ] step 5 Δ= +0.4 +1.0 -2.6 +0.8 -1.5 -0.5 着いた [SEND] pi05_chunk011_via08: send_angles (single) [ +36.23, +60.57, +3.06, +2.80, -61.90, -31.15] speed=20 wait=0.0s (pre max|Δ|=1.96°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.38° (tol 3.0°) [VIA ] step 8 Δ= +0.7 +1.8 -1.2 +0.1 -2.0 -0.5 着いた [SEND] pi05_chunk011_via09: send_angles (single) [ +36.28, +61.02, +3.04, +2.89, -62.34, -31.16] speed=20 wait=0.0s (pre max|Δ|=1.09°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.38° (tol 3.0°) [VIA ] step 9 Δ= +0.7 -0.3 -1.1 -0.9 +1.0 -0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.38°（関節 j4） [012] 推論 561ms 10ステップ先 Δ= +0.5 -8.3 -1.5 -0.6 +6.3 -0.6 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk012_via02: send_angles (single) [ +36.68, +61.49, +2.77, +3.00, -62.77, -31.34] speed=20 wait=0.0s (pre max|Δ|=1.36°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.39° (tol 3.0°) [VIA ] step 2 Δ= +1.1 -0.3 -1.4 -0.8 +0.9 -0.6 着いた [SEND] pi05_chunk012_via05: send_angles (single) [ +36.51, +59.28, +2.72, +3.01, -61.61, -31.34] speed=20 wait=0.0s (pre max|Δ|=2.94°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.97° (tol 3.0°) [VIA ] step 5 Δ= +0.4 -2.9 -1.0 -0.8 +2.6 -0.3 着いた [SEND] pi05_chunk012_via08: send_angles (single) [ +36.24, +54.38, +2.65, +3.07, -58.22, -31.36] speed=20 wait=0.0s (pre max|Δ|=6.87°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.04° (tol 3.0°) [VIA ] step 8 Δ= +0.1 -6.9 -1.0 -0.5 +4.4 -0.3 着いた [SEND] pi05_chunk012_via09: send_angles (single) [ +36.10, +53.44, +2.63, +3.13, -57.39, -31.37] speed=20 wait=0.0s (pre max|Δ|=2.98°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.10° (tol 3.0°) [VIA ] step 9 Δ= -0.4 -3.0 -1.1 +0.2 +1.4 -0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.10°（関節 j1） [013] 推論 1555ms 10ステップ先 Δ= +2.9 +6.2 -3.1 +1.3 -3.7 -1.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk013_via02: send_angles (single) [ +36.88, +54.35, +1.66, +3.37, -57.46, -31.65] speed=20 wait=0.0s (pre max|Δ|=2.03°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.59° (tol 3.0°) [VIA ] step 2 Δ= +0.4 -1.2 -2.0 +0.5 +0.3 -0.4 着いた [SEND] pi05_chunk013_via05: send_angles (single) [ +38.35, +57.55, +0.98, +3.73, -58.90, -32.10] speed=20 wait=0.0s (pre max|Δ|=2.27°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.39° (tol 3.0°) [VIA ] step 5 Δ= +1.9 +2.0 -2.3 +0.8 -1.2 -0.8 着いた [SEND] pi05_chunk013_via08: send_angles (single) [ +39.25, +60.76, +0.66, +4.05, -60.74, -32.37] speed=20 wait=0.0s (pre max|Δ|=2.91°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.92° (tol 3.0°) [VIA ] step 8 Δ= +1.0 +2.2 -1.7 +0.9 -2.9 -0.5 着いた [SEND] pi05_chunk013_via09: send_angles (single) [ +39.32, +61.71, +0.61, +4.17, -61.45, -32.38] speed=20 wait=0.0s (pre max|Δ|=0.92°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.21° (tol 3.0°) [VIA ] step 9 Δ= +0.1 +0.2 -0.8 +0.9 -0.0 -0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.21°（関節 j4） [014] 推論 620ms 1ステップ先 Δ= +0.0 +0.0 +0.0 +0.0 +0.0 +0.0 グリッパー→開 [VIA ] 中継点 1 点: step 0 [VIA ] step 0 Δ= +0.0 +0.0 +0.0 -0.1 +0.0 +0.0 送らず (0.5° 以下) [Pi] GRIPPER: OPEN result= None [STATE ] 実測を渡す (直前に送った目標がない) [015] 推論 564ms 10ステップ先 Δ= -0.1 -11.1 +0.3 -0.2 +12.5 -0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk015_via02: send_angles (single) [ +39.17, +62.14, +1.23, +5.02, -59.81, -32.09] speed=20 wait=0.0s (pre max|Δ|=0.74°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.78° (tol 3.0°) [VIA ] step 2 Δ= +0.1 -0.6 -0.2 -0.2 +0.7 -0.0 着いた [SEND] pi05_chunk015_via05: send_angles (single) [ +39.08, +56.95, +1.38, +4.90, -53.47, -32.15] speed=20 wait=0.0s (pre max|Δ|=6.73°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.28° (tol 3.0°) [VIA ] step 5 Δ= -0.0 -6.0 -0.0 -0.5 +6.7 -0.2 着いた [SEND] pi05_chunk015_via08: send_angles (single) [ +39.13, +52.65, +1.60, +4.81, -48.94, -32.23] speed=20 wait=0.0s (pre max|Δ|=6.58°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.72° (tol 3.0°) [VIA ] step 8 Δ= +0.0 -6.6 +0.2 -1.0 +4.0 -0.1 着いた [SEND] pi05_chunk015_via09: send_angles (single) [ +39.01, +51.66, +1.68, +4.80, -48.04, -32.26] speed=20 wait=0.0s (pre max|Δ|=2.92°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.30° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -2.9 -0.5 -0.7 +0.3 -0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.30°（関節 j1） [016] 推論 561ms 10ステップ先 Δ= -2.5 -8.0 -0.2 -1.0 +3.4 -0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk016_via02: send_angles (single) [ +38.94, +50.54, +1.63, +4.82, -46.80, -32.36] speed=20 wait=0.0s (pre max|Δ|=3.42°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.10° (tol 3.0°) [VIA ] step 2 Δ= -0.2 -3.4 -0.6 -0.6 +0.7 -0.2 着いた [SEND] pi05_chunk016_via05: send_angles (single) [ +38.74, +50.40, +1.59, +5.03, -47.39, -32.45] speed=20 wait=0.0s (pre max|Δ|=2.24°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.24° (tol 3.0°) [VIA ] step 5 Δ= -0.4 -2.2 -0.6 -0.3 -1.0 -0.3 着いた [SEND] pi05_chunk016_via08: send_angles (single) [ +37.72, +48.29, +1.76, +4.79, -45.94, -32.41] speed=20 wait=0.0s (pre max|Δ|=4.35°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.89° (tol 3.0°) [VIA ] step 8 Δ= -1.4 -4.3 -0.4 -0.6 +0.5 -0.2 着いた [SEND] pi05_chunk016_via09: send_angles (single) [ +36.59, +46.00, +1.95, +4.46, -44.08, -32.33] speed=20 wait=0.0s (pre max|Δ|=4.18°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.90° (tol 3.0°) [VIA ] step 9 Δ= -1.5 -4.2 -0.2 -0.7 +2.0 -0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.90°（関節 j1） [017] 推論 1493ms 10ステップ先 Δ=-15.4 -21.8 -0.1 -3.4 +19.7 +0.7 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk017_via02: send_angles (single) [ +33.17, +41.60, +1.89, +3.85, -39.92, -32.02] speed=20 wait=0.0s (pre max|Δ|=6.30°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.34° (tol 3.0°) [VIA ] step 2 Δ= -3.6 -6.3 -0.7 -1.0 +4.3 +0.2 着いた [SEND] pi05_chunk017_via05: send_angles (single) [ +28.17, +35.25, +2.01, +2.92, -33.99, -31.71] speed=20 wait=0.0s (pre max|Δ|=8.25°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.92° (tol 3.0°) [VIA ] step 5 Δ= -5.1 -8.2 -0.6 -1.2 +6.2 +0.5 着いた [SEND] pi05_chunk017_via08: send_angles (single) [ +22.58, +27.90, +2.37, +1.84, -26.82, -31.51] speed=20 wait=0.0s (pre max|Δ|=9.27°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.42° (tol 3.0°) [VIA ] step 8 Δ= -5.6 -9.3 -0.4 -1.4 +7.4 +0.6 着いた [SEND] pi05_chunk017_via09: send_angles (single) [ +21.29, +26.05, +2.50, +1.51, -24.51, -31.50] speed=20 wait=0.0s (pre max|Δ|=3.65°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.72° (tol 3.0°) [VIA ] step 9 Δ= -1.6 -3.6 -0.2 -0.5 +2.6 +0.6 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.72°（関節 j1） [018] 推論 576ms 10ステップ先 Δ= -0.4 -2.1 -0.4 +0.2 -0.4 +0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk018_via02: send_angles (single) [ +21.23, +25.48, +2.57, +1.54, -24.02, -31.50] speed=20 wait=0.0s (pre max|Δ|=2.29°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.11° (tol 3.0°) [VIA ] step 2 Δ= -0.1 -2.3 -0.5 -0.0 +0.8 +0.5 着いた [SEND] pi05_chunk018_via05: send_angles (single) [ +21.15, +25.72, +2.62, +1.61, -24.61, -31.50] speed=20 wait=0.0s (pre max|Δ|=1.87°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.87° (tol 3.0°) [VIA ] step 5 Δ= -0.2 -1.9 -0.5 +0.0 -0.4 +0.5 着いた [SEND] pi05_chunk018_via08: send_angles (single) [ +21.06, +25.69, +2.67, +1.70, -24.95, -31.47] speed=20 wait=0.0s (pre max|Δ|=1.90°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.90° (tol 3.0°) [VIA ] step 8 Δ= -0.3 -1.9 -0.6 +0.1 -0.7 +0.5 着いた [SEND] pi05_chunk018_via09: send_angles (single) [ +21.13, +25.67, +2.66, +1.75, -25.16, -31.47] speed=20 wait=0.0s (pre max|Δ|=1.92°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.92° (tol 3.0°) [VIA ] step 9 Δ= -0.2 -1.9 -0.6 +0.2 -0.9 +0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.92°（関節 j1） [019] 推論 559ms 10ステップ先 Δ= +3.2 +12.2 -0.7 +1.2 -14.2 +0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk019_via02: send_angles (single) [ +22.54, +29.39, +2.99, +2.30, -29.30, -31.54] speed=20 wait=0.0s (pre max|Δ|=5.05°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.53° (tol 3.0°) [VIA ] step 2 Δ= +1.3 +1.8 -0.3 +0.7 -5.1 +0.4 着いた [SEND] pi05_chunk019_via05: send_angles (single) [ +23.62, +34.70, +3.09, +2.72, -34.92, -31.59] speed=20 wait=0.0s (pre max|Δ|=6.98°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.91° (tol 3.0°) [VIA ] step 5 Δ= +1.1 +4.2 -0.6 +1.2 -7.0 +0.4 着いた [SEND] pi05_chunk019_via08: send_angles (single) [ +24.23, +39.10, +2.73, +2.79, -38.26, -31.61] speed=20 wait=0.0s (pre max|Δ|=4.25°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.35° (tol 3.0°) [VIA ] step 8 Δ= +0.7 +3.2 -1.0 +1.0 -4.2 +0.4 着いた [SEND] pi05_chunk019_via09: send_angles (single) [ +24.52, +39.80, +2.55, +2.81, -38.49, -31.63] speed=20 wait=0.0s (pre max|Δ|=1.49°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.14° (tol 3.0°) [VIA ] step 9 Δ= +0.3 -0.3 -1.1 +0.9 -1.5 +0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.14°（関節 j2） [020] 推論 1478ms 10ステップ先 Δ= +7.2 +14.8 -1.5 +1.9 -15.3 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [PAUSE ] 止める予約 (Enter). 推論 20 は送らずに入力欄を出します [PAUSE ] 止めました (推論 20 はまだ送っていません). Enter で実行すると, また止まらずに進みます Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > h [SEND] pi05_home: send_angles (single) [ +0.00, +0.00, +0.00, +0.00, +0.00, -30.00] speed=20 wait=0.0s (pre max|Δ|=40.69°, post-send timeout 8.1s) [SEND] arrival OK: max|Δ|=2.19° (tol 2.5°) [RECORD] 記録終了 コマ 946 (8.878 fps) 実測角 890 回 (8.35 Hz) 電流 895 行 (read_servo) → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_181057/recording 結果: y=成功 / n=失敗 / Enter=記録しない > n [GRIP ] 閉じて 1 秒後の爪の電流 (中央値): 1 回目 758 (9 行) (閉じる値 25) [DONE ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_181057 [CLIENT] run_policy_client.py が終わった (終了コード 0. モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1)) (111 秒) もう1回やりますか? y=やる / 他=終わる > y === 7. HOME → 爪を開く → 位置合わせ (2 回目) [INIT] daemon 接続中... [Pi] fresh_mode=1 [INIT] fresh_mode=1 [PRE] 現在姿勢: [-0.17, 1.31, 2.19, 0.52, -0.87, -30.32] [SEND] HOME へ移動指令 [WAIT] t=0.6s max_err=2.19° [DONE] HOME 到達 max_err=2.19° [POST] 最終姿勢: [-0.17, 1.31, 2.19, 0.43, -0.79, -30.32] [Pi] fresh_mode=0 [EXIT] fresh_mode=0, socket close [Pi] GRIPPER: OPEN result= None [REF ] 基準画像: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_194818/frames/000000.jpg [REF ] お手本 run_0001_20261019_194818 (つかんだ瞬間の j0 = +13.2°) [REF ] 重なった画像のブロックに実物のブロックを合わせると, お手本と同じ位置に置ける [TILT ] 傾きのお手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 中央値 -0.61° (測れた 50/50 本. プラス=右下がり) [TILT ] 傾きはソフトでそろえる: ライブをお手本の中央値との差だけ回して重ねる (AI に渡す画像と同じ. 回す角度が 3° を超えたら画面の色を変える. 止めない) [ALIGN ] |dy| <= 20 なら OK. アームは HOME に置いた状態で合わせる. q または Esc で終了 (ファイルには何も書かない) [ALIGN ] dy= +0.4 dx= -2.3 response=0.819 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.95° → -0.61° にソフトでそろえる (+1.34° 回して重ねる. プラス=右下がり) [DONE ] 終了 (何も書いていません) (9 秒) === 8. 実機推論 (2 回目) [WAIT ] 送ったあと 0.0s / 爪のあと 0.8s (開くときの daemon 0.0s) / 止まるのを待つ目安 0.8s [GRIP ] 閉じる値 25 締め直し r は 22 と 25 を交互に送る [SAFE ] 安全範囲 (学習 50 本 ±10°): j0[-72,+55] j1[-9,+88] j2[-45,+52] j3[-18,+27] j4[-87,+10] j5[-51,-15] [SAFE ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352) 元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes [MODE ] EXECUTE steps/chunk=10 max_move=20.0° log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_181300 [MODEL ] deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) [PAUSE ] --no-step-confirm: 始めの確かめのあとは入力欄を出さずに進みます. 止めるときはスペース (Enter も可). 今のチャンクを送り終えてから, 次の推論のあと (送る前) で入力欄を出します [CAMERA] 写り方 dy=-6.0 dx=+4.7 response=0.540 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 回したあとの画像で測った [CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg [CAMERA] 傾き -1.87° → -0.61° にそろえて渡す (+1.25° 回す. プラス=右下がり) (お手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 測れた 50/50 本・今 5/5 コマ) [POLICY] 接続 ws://localhost:8000 metadata={} [RECORD] 上カメラと実測角を 1 秒 10 コマで記録します → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_181300/recording [GRIP ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく) [STATE ] 実測を渡す (直前に送った目標がない) [000] 推論 601ms 10ステップ先 Δ= +3.3 +13.4 +9.4 -2.1 -18.9 +2.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [CONFIRM] 2 回目からの試行なので始めの確かめ (Enter) を待たずに実行します (次の推論からは今までどおり確かめます) [GRIP ] 開始時にグリッパーを開く [Pi] GRIPPER: OPEN result= None [SEND] pi05_chunk000_via02: send_angles (single) [ +0.57, +4.99, +4.58, +0.09, -4.65, -29.84] speed=20 wait=0.0s (pre max|Δ|=4.39°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.93° (tol 3.0°) [VIA ] step 2 Δ= +0.7 +3.7 +2.4 -0.2 -4.4 +0.4 着いた [SEND] pi05_chunk000_via05: send_angles (single) [ +1.82, +9.61, +7.77, -0.69, -11.14, -29.02] speed=20 wait=0.0s (pre max|Δ|=8.42°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.39° (tol 3.0°) [VIA ] step 5 Δ= +1.5 +3.7 +2.1 -1.0 -8.4 +1.0 着いた [SEND] pi05_chunk000_via08: send_angles (single) [ +2.83, +13.58, +10.75, -1.63, -17.47, -28.09] speed=20 wait=0.0s (pre max|Δ|=7.63°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.62° (tol 3.0°) [VIA ] step 8 Δ= +1.2 +3.1 +2.0 -0.9 -7.6 +1.1 着いた [SEND] pi05_chunk000_via09: send_angles (single) [ +3.18, +14.71, +11.55, -1.88, -19.21, -27.82] speed=20 wait=0.0s (pre max|Δ|=3.39°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.11° (tol 3.0°) [VIA ] step 9 Δ= +0.8 +0.2 -0.1 -0.0 -3.4 +0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.11°（関節 j4） [001] 推論 561ms 10ステップ先 Δ= +3.8 +11.2 +8.3 -0.5 -22.1 +1.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk001_via02: send_angles (single) [ +4.12, +17.74, +13.73, -2.29, -24.38, -27.38] speed=20 wait=0.0s (pre max|Δ|=6.28°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.36° (tol 3.0°) [VIA ] step 2 Δ= +1.1 +2.1 +1.5 -0.0 -6.3 +0.6 着いた [SEND] pi05_chunk001_via05: send_angles (single) [ +5.24, +21.46, +16.28, -2.53, -30.50, -27.11] speed=20 wait=0.0s (pre max|Δ|=7.21°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.68° (tol 3.0°) [VIA ] step 5 Δ= +1.4 +2.9 +1.7 +0.0 -7.2 +0.4 着いた [SEND] pi05_chunk001_via08: send_angles (single) [ +6.70, +25.90, +19.79, -2.84, -38.43, -26.96] speed=20 wait=0.0s (pre max|Δ|=8.82°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.82° (tol 3.0°) [VIA ] step 8 Δ= +1.6 +3.5 +2.7 -0.1 -8.8 +0.4 着いた [SEND] pi05_chunk001_via09: send_angles (single) [ +6.88, +26.82, +20.51, -2.82, -40.22, -26.93] speed=20 wait=0.0s (pre max|Δ|=2.61°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.95° (tol 3.0°) [VIA ] step 9 Δ= +0.5 +0.1 +0.0 +0.2 -2.6 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.95°（関節 j1） [002] 推論 556ms 10ステップ先 Δ= +3.5 +13.4 +6.9 +0.5 -20.9 +0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk002_via02: send_angles (single) [ +7.90, +31.55, +22.56, -2.82, -46.97, -26.85] speed=20 wait=0.0s (pre max|Δ|=7.51°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.50° (tol 3.0°) [VIA ] step 2 Δ= +1.5 +3.8 +2.1 +0.3 -7.5 +0.3 着いた [SEND] pi05_chunk002_via05: send_angles (single) [ +8.79, +36.02, +24.76, -2.64, -53.55, -26.77] speed=20 wait=0.0s (pre max|Δ|=7.32°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.67° (tol 3.0°) [VIA ] step 5 Δ= +1.1 +3.6 +1.7 +0.5 -7.3 +0.3 着いた [SEND] pi05_chunk002_via08: send_angles (single) [ +9.61, +39.93, +26.94, -2.61, -59.09, -26.75] speed=20 wait=0.0s (pre max|Δ|=6.36°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.44° (tol 3.0°) [VIA ] step 8 Δ= +0.8 +3.0 +1.8 +0.6 -6.4 +0.2 着いた [SEND] pi05_chunk002_via09: send_angles (single) [ +9.88, +41.22, +27.37, -2.55, -60.34, -26.73] speed=20 wait=0.0s (pre max|Δ|=1.99°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.87° (tol 3.0°) [VIA ] step 9 Δ= +0.1 +0.5 +0.0 +0.5 -2.0 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.87°（関節 j1） [003] 推論 776ms 10ステップ先 Δ= +1.7 +4.4 +1.3 +0.3 -8.3 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk003_via02: send_angles (single) [ +10.64, +44.20, +29.11, -2.55, -65.16, -26.70] speed=20 wait=0.0s (pre max|Δ|=5.31°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.83° (tol 3.0°) [VIA ] step 2 Δ= +1.0 +2.1 +1.8 +0.4 -5.3 +0.3 着いた [SEND] pi05_chunk003_via05: send_angles (single) [ +11.09, +44.73, +28.90, -2.55, -66.53, -26.68] speed=20 wait=0.0s (pre max|Δ|=2.11°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.88° (tol 3.0°) [VIA ] step 5 Δ= +0.4 -0.3 -0.4 +0.3 -2.1 +0.2 着いた [SEND] pi05_chunk003_via08: send_angles (single) [ +11.26, +46.06, +28.70, -2.57, -67.90, -26.66] speed=20 wait=0.0s (pre max|Δ|=1.64°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.96° (tol 3.0°) [VIA ] step 8 Δ= +0.5 +0.5 -0.6 +0.2 -1.6 +0.2 着いた [SEND] pi05_chunk003_via09: send_angles (single) [ +11.36, +46.48, +28.65, -2.58, -68.17, -26.65] speed=20 wait=0.0s (pre max|Δ|=0.64°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.89° (tol 3.0°) [VIA ] step 9 Δ= +0.6 -0.5 -0.6 +0.2 -0.6 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.89°（関節 j1） [004] 推論 1550ms 10ステップ先 Δ= -0.4 +12.9 -11.2 +0.1 +0.6 +0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk004_via02: send_angles (single) [ +11.49, +51.11, +24.80, -2.60, -67.60, -26.62] speed=20 wait=0.0s (pre max|Δ|=4.46°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.53° (tol 3.0°) [VIA ] step 2 Δ= +0.1 +3.7 -4.5 +0.0 -0.0 +0.3 着いた [SEND] pi05_chunk004_via05: send_angles (single) [ +11.27, +56.37, +20.56, -2.64, -67.03, -26.70] speed=20 wait=0.0s (pre max|Δ|=5.27°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.06° (tol 3.0°) [VIA ] step 5 Δ= -0.2 +4.3 -5.3 -0.0 +0.7 +0.1 着いた [SEND] pi05_chunk004_via08: send_angles (single) [ +11.14, +59.86, +18.07, -2.64, -66.86, -26.77] speed=20 wait=0.0s (pre max|Δ|=3.46°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.00° (tol 3.0°) [VIA ] step 8 Δ= -0.3 +2.6 -3.5 -0.0 +0.9 +0.0 着いた [SEND] pi05_chunk004_via09: send_angles (single) [ +11.06, +60.25, +18.08, -2.62, -67.03, -26.78] speed=20 wait=0.0s (pre max|Δ|=0.90°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.92° (tol 3.0°) [VIA ] step 9 Δ= -0.4 -0.6 -1.0 +0.0 +0.7 +0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.92°（関節 j1） [005] 推論 782ms 3ステップ先 Δ= -0.2 -0.7 -0.9 +0.1 +1.0 +0.0 グリッパー→閉 [VIA ] 中継点 1 点: step 2 [SEND] pi05_chunk005_via02: send_angles (single) [ +11.20, +60.50, +18.05, -2.52, -66.80, -26.79] speed=20 wait=0.0s (pre max|Δ|=0.96°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.96° (tol 3.0°) [VIA ] step 2 Δ= -0.2 -0.7 -0.9 +0.1 +1.0 +0.0 着いた [Pi] GRIPPER: VALUE=25 speed=100 result= None [STATE ] 目標を渡す 目標と実測の最大差 0.96°（関節 j4） [006] 推論 1720ms 10ステップ先 Δ= +0.4 -5.5 +0.9 -0.8 +2.4 +0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk006_via02: send_angles (single) [ +11.40, +60.35, +18.07, -2.55, -66.88, -26.95] speed=20 wait=0.0s (pre max|Δ|=0.99°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.99° (tol 3.0°) [VIA ] step 2 Δ= -0.0 -1.0 -0.9 +0.2 +1.0 -0.1 着いた [SEND] pi05_chunk006_via05: send_angles (single) [ +11.58, +59.29, +18.61, -3.30, -66.35, -26.82] speed=20 wait=0.0s (pre max|Δ|=2.05°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.96° (tol 3.0°) [VIA ] step 5 Δ= +0.2 -2.0 -0.4 -0.6 +1.5 -0.0 着いた [SEND] pi05_chunk006_via08: send_angles (single) [ +11.82, +56.33, +19.56, -3.55, -65.29, -26.73] speed=20 wait=0.0s (pre max|Δ|=4.92°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.94° (tol 3.0°) [VIA ] step 8 Δ= +0.4 -4.9 +0.6 -0.7 +2.6 +0.1 着いた [SEND] pi05_chunk006_via09: send_angles (single) [ +11.79, +55.85, +19.86, -3.47, -65.34, -26.73] speed=20 wait=0.0s (pre max|Δ|=2.42°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.42° (tol 3.0°) [VIA ] step 9 Δ= +0.4 -2.4 +0.4 -0.4 +0.8 -0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.42°（関節 j1） [007] 推論 824ms 10ステップ先 Δ= +1.2 -3.4 -4.4 -1.0 +1.7 +0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk007_via02: send_angles (single) [ +11.85, +54.00, +21.84, -3.46, -65.80, -26.71] speed=20 wait=0.0s (pre max|Δ|=4.27°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.63° (tol 3.0°) [VIA ] step 2 Δ= +0.4 -4.3 +2.2 -0.4 +0.4 -0.0 着いた [SEND] pi05_chunk007_via05: send_angles (single) [ +11.90, +53.20, +22.61, -3.45, -66.16, -26.71] speed=20 wait=0.0s (pre max|Δ|=2.43°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.34° (tol 3.0°) [VIA ] step 5 Δ= +0.6 -2.4 +0.1 -0.4 -0.1 +0.0 着いた [SEND] pi05_chunk007_via08: send_angles (single) [ +12.16, +54.09, +17.47, -3.93, -65.08, -26.44] speed=20 wait=0.0s (pre max|Δ|=5.03°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.45° (tol 3.0°) [VIA ] step 8 Δ= +0.8 -1.5 -5.0 -0.9 +1.0 +0.3 着いた [SEND] pi05_chunk007_via09: send_angles (single) [ +12.64, +54.87, +15.32, -4.12, -64.52, -26.35] speed=20 wait=0.0s (pre max|Δ|=3.04°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.11° (tol 3.0°) [VIA ] step 9 Δ= +0.6 -0.7 -3.0 -0.5 +1.2 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.11°（関節 j1） [008] 推論 744ms 10ステップ先 Δ= +1.3 -1.9 -7.3 -0.7 +0.2 +0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk008_via02: send_angles (single) [ +12.66, +54.77, +13.98, -4.15, -64.63, -26.38] speed=20 wait=0.0s (pre max|Δ|=2.36°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.22° (tol 3.0°) [VIA ] step 2 Δ= +0.6 -1.2 -2.4 -0.5 +0.2 +0.2 着いた [SEND] pi05_chunk008_via05: send_angles (single) [ +12.90, +54.75, +11.97, -4.28, -64.62, -26.42] speed=20 wait=0.0s (pre max|Δ|=3.23°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.88° (tol 3.0°) [VIA ] step 5 Δ= +0.9 -1.2 -3.2 -0.4 +0.2 +0.1 着いた [SEND] pi05_chunk008_via08: send_angles (single) [ +13.20, +54.29, +9.85, -4.36, -64.74, -26.42] speed=20 wait=0.0s (pre max|Δ|=3.15°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.69° (tol 3.0°) [VIA ] step 8 Δ= +0.1 -1.7 -3.1 +0.0 +0.1 +0.1 着いた [SEND] pi05_chunk008_via09: send_angles (single) [ +13.34, +54.08, +9.05, -4.41, -64.69, -26.44] speed=20 wait=0.0s (pre max|Δ|=1.93°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.90° (tol 3.0°) [VIA ] step 9 Δ= +0.3 -1.9 -1.9 -0.0 +0.2 +0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.90°（関節 j1） [009] 推論 556ms 10ステップ先 Δ= +0.2 -14.4 -2.5 -0.2 +2.1 -0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk009_via02: send_angles (single) [ +13.55, +50.74, +8.18, -4.47, -64.18, -26.59] speed=20 wait=0.0s (pre max|Δ|=5.24°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.17° (tol 3.0°) [VIA ] step 2 Δ= +0.6 -5.2 -2.3 -0.1 +0.7 -0.0 着いた [SEND] pi05_chunk009_via05: send_angles (single) [ +13.57, +43.93, +8.53, -4.44, -63.29, -26.65] speed=20 wait=0.0s (pre max|Δ|=8.71°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.94° (tol 3.0°) [VIA ] step 5 Δ= +0.6 -8.7 -0.9 +0.0 +1.4 -0.1 着いた [SEND] pi05_chunk009_via08: send_angles (single) [ +13.37, +41.40, +8.20, -4.51, -62.84, -26.66] speed=20 wait=0.0s (pre max|Δ|=4.47°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.93° (tol 3.0°) [VIA ] step 8 Δ= +0.4 -4.5 -1.2 -0.0 +0.8 -0.1 着いた [SEND] pi05_chunk009_via09: send_angles (single) [ +13.24, +41.63, +7.94, -4.56, -62.77, -26.67] speed=20 wait=0.0s (pre max|Δ|=1.70°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.70° (tol 3.0°) [VIA ] step 9 Δ= +0.2 -1.7 -1.5 +0.0 +0.4 -0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.70°（関節 j1） [010] 推論 693ms 10ステップ先 Δ= +4.7 -8.9 -2.9 +0.4 +3.7 -0.7 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk010_via02: send_angles (single) [ +13.80, +40.25, +8.15, -4.38, -62.68, -26.74] speed=20 wait=0.0s (pre max|Δ|=3.08°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.11° (tol 3.0°) [VIA ] step 2 Δ= +0.8 -3.1 -1.2 +0.2 +0.5 -0.2 着いた [SEND] pi05_chunk010_via05: send_angles (single) [ +13.95, +37.35, +7.69, -4.36, -62.09, -26.80] speed=20 wait=0.0s (pre max|Δ|=5.01°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.76° (tol 3.0°) [VIA ] step 5 Δ= +0.2 -5.0 -1.7 +0.9 +0.9 -0.3 着いた [SEND] pi05_chunk010_via08: send_angles (single) [ +15.65, +35.37, +6.72, -4.38, -60.38, -27.04] speed=20 wait=0.0s (pre max|Δ|=3.65°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.89° (tol 3.0°) [VIA ] step 8 Δ= +1.9 -3.7 -2.7 +0.9 +1.9 -0.5 着いた [SEND] pi05_chunk010_via09: send_angles (single) [ +17.67, +34.42, +6.46, -4.19, -59.50, -27.20] speed=20 wait=0.0s (pre max|Δ|=2.84°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.05° (tol 3.0°) [VIA ] step 9 Δ= +2.2 -2.8 -1.7 +0.6 +0.7 -0.7 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.05°（関節 j1） [011] 推論 1541ms 10ステップ先 Δ= +9.4 +1.4 -2.0 +1.9 +1.5 -1.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk011_via02: send_angles (single) [ +19.56, +34.38, +6.39, -3.82, -58.51, -27.37] speed=20 wait=0.0s (pre max|Δ|=2.09°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.09° (tol 3.0°) [VIA ] step 2 Δ= +2.1 -2.1 -1.7 +1.1 +1.2 -0.7 着いた [SEND] pi05_chunk011_via05: send_angles (single) [ +22.71, +34.34, +6.15, -3.32, -57.38, -27.57] speed=20 wait=0.0s (pre max|Δ|=3.29°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.13° (tol 3.0°) [VIA ] step 5 Δ= +3.3 -2.1 -1.9 +0.8 +1.2 -0.9 着いた [SEND] pi05_chunk011_via08: send_angles (single) [ +26.40, +36.75, +6.10, -2.84, -57.81, -27.74] speed=20 wait=0.0s (pre max|Δ|=3.64°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.98° (tol 3.0°) [VIA ] step 8 Δ= +3.6 +0.3 -2.0 +0.8 -0.2 -1.1 着いた [SEND] pi05_chunk011_via09: send_angles (single) [ +26.88, +37.82, +6.13, -2.82, -58.18, -27.73] speed=20 wait=0.0s (pre max|Δ|=1.95°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.95° (tol 3.0°) [VIA ] step 9 Δ= +0.4 -0.1 -2.0 -0.1 -0.5 -0.9 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.95°（関節 j2） [012] 推論 556ms 10ステップ先 Δ= +9.0 +5.3 -4.7 +2.2 -1.3 -2.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk012_via02: send_angles (single) [ +30.45, +38.41, +4.47, -2.02, -57.21, -28.55] speed=20 wait=0.0s (pre max|Δ|=3.91°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.03° (tol 3.0°) [VIA ] step 2 Δ= +3.9 -0.7 -3.6 +1.2 +0.4 -1.7 着いた [SEND] pi05_chunk012_via05: send_angles (single) [ +33.91, +39.62, +3.27, -1.46, -56.67, -29.03] speed=20 wait=0.0s (pre max|Δ|=3.50°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.65° (tol 3.0°) [VIA ] step 5 Δ= +3.5 +0.3 -2.6 +1.0 +1.0 -1.2 着いた [SEND] pi05_chunk012_via08: send_angles (single) [ +35.53, +43.08, +3.35, -1.19, -58.22, -29.18] speed=20 wait=0.0s (pre max|Δ|=2.48°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.48° (tol 3.0°) [VIA ] step 8 Δ= +1.7 +2.5 -1.6 +0.5 -1.3 -0.7 着いた [SEND] pi05_chunk012_via09: send_angles (single) [ +35.51, +44.38, +3.41, -1.07, -58.95, -29.19] speed=20 wait=0.0s (pre max|Δ|=2.00°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.39° (tol 3.0°) [VIA ] step 9 Δ= -0.3 -0.0 -1.3 +0.2 -2.0 -0.6 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.39°（関節 j4） [013] 推論 558ms 10ステップ先 Δ= +3.5 +11.2 -4.6 +2.2 -3.2 -1.8 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk013_via02: send_angles (single) [ +37.87, +45.51, +2.51, -0.54, -57.52, -29.72] speed=20 wait=0.0s (pre max|Δ|=2.23°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.70° (tol 3.0°) [VIA ] step 2 Δ= +2.1 -0.0 -2.2 +0.9 +0.0 -1.1 着いた [SEND] pi05_chunk013_via05: send_angles (single) [ +39.84, +49.18, +1.18, +0.10, -57.27, -30.27] speed=20 wait=0.0s (pre max|Δ|=3.03°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.63° (tol 3.0°) [VIA ] step 5 Δ= +2.0 +2.3 -3.0 +0.5 +0.3 -0.8 着いた [SEND] pi05_chunk013_via08: send_angles (single) [ +39.39, +55.12, +0.35, +0.64, -59.68, -30.50] speed=20 wait=0.0s (pre max|Δ|=4.85°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.03° (tol 3.0°) [VIA ] step 8 Δ= -0.3 +4.8 -2.4 +0.4 -2.1 -0.6 着いた [SEND] pi05_chunk013_via09: send_angles (single) [ +39.28, +56.68, +0.11, +0.78, -60.73, -30.50] speed=20 wait=0.0s (pre max|Δ|=2.90°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.91° (tol 3.0°) [VIA ] step 9 Δ= -0.5 +0.3 -1.9 +0.4 -2.9 -0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.91°（関節 j2） [014] 推論 758ms 7ステップ先 Δ= -0.5 +4.4 -2.4 +1.2 -5.1 -0.6 グリッパー→開 [VIA ] 中継点 3 点: step 2, 5, 6 [SEND] pi05_chunk014_via02: send_angles (single) [ +39.25, +61.16, -0.30, +1.33, -63.39, -30.59] speed=20 wait=0.0s (pre max|Δ|=3.72°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.44° (tol 3.0°) [VIA ] step 2 Δ= -0.6 +3.3 -2.3 +0.9 -3.7 -0.5 着いた [SEND] pi05_chunk014_via05: send_angles (single) [ +39.27, +62.21, -0.40, +1.64, -64.75, -30.63] speed=20 wait=0.0s (pre max|Δ|=2.44°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.54° (tol 3.0°) [VIA ] step 5 Δ= -0.5 -0.1 -1.5 +0.6 -2.4 -0.5 着いた [SEND] pi05_chunk014_via06: send_angles (single) [ +39.27, +62.21, -0.40, +1.64, -64.75, -30.63] speed=20 wait=0.0s (pre max|Δ|=1.54°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.54° (tol 3.0°) [VIA ] step 6 Δ= -0.5 -1.1 -1.5 +0.2 -0.8 -0.4 着いた [Pi] GRIPPER: OPEN result= None [STATE ] 目標を渡す 目標と実測の最大差 1.54°（関節 j2） [015] 推論 1557ms 10ステップ先 Δ= -1.2 -16.1 -1.2 +0.4 +15.2 -0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk015_via02: send_angles (single) [ +39.48, +58.42, -0.36, +1.71, -61.27, -30.69] speed=20 wait=0.0s (pre max|Δ|=4.86°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.71° (tol 3.0°) [VIA ] step 2 Δ= -0.3 -4.9 -1.5 +0.3 +2.7 -0.4 着いた [SEND] pi05_chunk015_via05: send_angles (single) [ +39.46, +53.68, -0.21, +1.79, -56.36, -30.75] speed=20 wait=0.0s (pre max|Δ|=7.62°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.43° (tol 3.0°) [VIA ] step 5 Δ= -0.3 -6.6 -1.3 +0.3 +7.6 -0.4 着いた [SEND] pi05_chunk015_via08: send_angles (single) [ +39.07, +48.75, -0.09, +1.80, -50.62, -30.79] speed=20 wait=0.0s (pre max|Δ|=8.17°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.81° (tol 3.0°) [VIA ] step 8 Δ= -0.7 -6.9 -1.1 +0.2 +8.2 -0.4 着いた [SEND] pi05_chunk015_via09: send_angles (single) [ +38.58, +47.13, -0.05, +1.79, -48.79, -30.79] speed=20 wait=0.0s (pre max|Δ|=3.76°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.17° (tol 3.0°) [VIA ] step 9 Δ= -0.5 -3.7 -1.1 -0.2 +3.8 -0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.17°（関節 j1） [016] 推論 560ms 10ステップ先 Δ=-19.0 -25.3 -1.1 -1.7 +26.1 -0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk016_via02: send_angles (single) [ +35.16, +41.38, -0.12, +1.59, -42.55, -30.87] speed=20 wait=0.0s (pre max|Δ|=7.92°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.12° (tol 3.0°) [VIA ] step 2 Δ= -3.9 -7.9 -1.2 -0.2 +7.9 -0.4 着いた [SEND] pi05_chunk016_via05: send_angles (single) [ +29.36, +34.25, -0.14, +0.98, -35.03, -30.88] speed=20 wait=0.0s (pre max|Δ|=9.25°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.04° (tol 3.0°) [VIA ] step 5 Δ= -6.4 -9.3 -1.2 -1.0 +8.9 -0.3 着いた [SEND] pi05_chunk016_via08: send_angles (single) [ +22.24, +26.29, -0.02, +0.27, -26.98, -30.87] speed=20 wait=0.0s (pre max|Δ|=9.92°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.83° (tol 3.0°) [VIA ] step 8 Δ= -7.2 -9.9 -1.1 -1.5 +9.1 -0.3 着いた [SEND] pi05_chunk016_via09: send_angles (single) [ +20.12, +23.99, -0.06, +0.07, -24.39, -30.88] speed=20 wait=0.0s (pre max|Δ|=4.13°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.67° (tol 3.0°) [VIA ] step 9 Δ= -2.5 -4.1 -1.2 -1.2 +3.5 -0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.67°（関節 j1） [017] 推論 559ms 10ステップ先 Δ=-11.4 -14.6 -0.8 -0.7 +14.8 -0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk017_via02: send_angles (single) [ +16.86, +19.08, +0.06, -0.13, -18.68, -30.84] speed=20 wait=0.0s (pre max|Δ|=6.63°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.80° (tol 3.0°) [VIA ] step 2 Δ= -3.0 -6.6 -1.1 -0.6 +6.6 -0.2 着いた [SEND] pi05_chunk017_via05: send_angles (single) [ +10.89, +12.35, +0.22, -0.28, -11.85, -30.85] speed=20 wait=0.0s (pre max|Δ|=8.39°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.53° (tol 3.0°) [VIA ] step 5 Δ= -6.2 -8.4 -0.9 -0.7 +7.5 -0.1 着いた [SEND] pi05_chunk017_via08: send_angles (single) [ +8.40, +10.75, +0.31, -0.26, -10.26, -30.86] speed=20 wait=0.0s (pre max|Δ|=3.13°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.46° (tol 3.0°) [VIA ] step 8 Δ= -2.6 -3.1 -0.8 -0.7 +2.3 -0.1 着いた [SEND] pi05_chunk017_via09: send_angles (single) [ +8.84, +11.07, +0.35, -0.30, -10.51, -30.86] speed=20 wait=0.0s (pre max|Δ|=1.14°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.14° (tol 3.0°) [VIA ] step 9 Δ= +0.7 -1.1 -0.8 -0.2 +0.3 -0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.14°（関節 j1） [018] 推論 816ms 10ステップ先 Δ= -7.0 -8.3 -0.5 -0.3 +7.4 +0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk018_via02: send_angles (single) [ +2.14, +4.20, +0.50, -0.40, -3.72, -30.80] speed=20 wait=0.0s (pre max|Δ|=8.01°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.33° (tol 3.0°) [VIA ] step 2 Δ= -6.1 -8.0 -0.6 -0.3 +7.1 +0.0 着いた [SEND] pi05_chunk018_via05: send_angles (single) [ +1.30, +3.82, +0.53, -0.42, -3.58, -30.77] speed=20 wait=0.0s (pre max|Δ|=1.71°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.71° (tol 3.0°) [VIA ] step 5 Δ= -1.0 -1.7 -0.6 -0.3 +0.7 +0.1 着いた [SEND] pi05_chunk018_via08: send_angles (single) [ +1.33, +4.00, +0.57, -0.37, -3.46, -30.75] speed=20 wait=0.0s (pre max|Δ|=1.53°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.53° (tol 3.0°) [VIA ] step 8 Δ= +0.1 -1.5 -0.6 -0.3 +0.7 +0.1 着いた [SEND] pi05_chunk018_via09: send_angles (single) [ +1.27, +3.91, +0.61, -0.37, -3.42, -30.74] speed=20 wait=0.0s (pre max|Δ|=1.53°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.53° (tol 3.0°) [VIA ] step 9 Δ= +0.0 -1.5 -0.5 -0.3 +0.6 +0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.53°（関節 j1） [019] 推論 1529ms 10ステップ先 Δ= -1.2 -2.0 -0.6 -0.2 +0.7 +0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk019_via02: send_angles (single) [ -0.40, +3.46, +0.56, -0.35, -2.99, -30.75] speed=20 wait=0.0s (pre max|Δ|=1.98°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.46° (tol 3.0°) [VIA ] step 2 Δ= -1.6 -2.0 -0.6 -0.3 +0.9 +0.1 着いた [SEND] pi05_chunk019_via05: send_angles (single) [ -0.22, +3.45, +0.57, -0.37, -3.21, -30.75] speed=20 wait=0.0s (pre max|Δ|=1.47°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.47° (tol 3.0°) [VIA ] step 5 Δ= +0.5 -1.5 -0.6 -0.3 -0.1 +0.1 着いた [SEND] pi05_chunk019_via08: send_angles (single) [ -0.08, +3.43, +0.55, -0.30, -3.23, -30.75] speed=20 wait=0.0s (pre max|Δ|=1.49°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.49° (tol 3.0°) [VIA ] step 8 Δ= +0.6 -1.5 -0.6 -0.2 -0.1 +0.1 着いた [SEND] pi05_chunk019_via09: send_angles (single) [ -0.01, +3.43, +0.52, -0.32, -3.20, -30.74] speed=20 wait=0.0s (pre max|Δ|=1.49°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.49° (tol 3.0°) [VIA ] step 9 Δ= +0.2 -1.5 -0.6 -0.2 -0.0 +0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.49°（関節 j1） [020] 推論 786ms 10ステップ先 Δ= -0.1 -1.5 -0.6 -0.3 +0.2 +0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk020_via02: send_angles (single) [ -0.42, +3.41, +0.57, -0.27, -3.02, -30.71] speed=20 wait=0.0s (pre max|Δ|=1.51°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.51° (tol 3.0°) [VIA ] step 2 Δ= -0.2 -1.5 -0.6 -0.2 +0.1 +0.1 着いた [SEND] pi05_chunk020_via05: send_angles (single) [ -0.44, +3.36, +0.49, -0.31, -2.90, -30.71] speed=20 wait=0.0s (pre max|Δ|=1.56°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.56° (tol 3.0°) [VIA ] step 5 Δ= -0.2 -1.6 -0.6 -0.2 +0.3 +0.1 着いた [SEND] pi05_chunk020_via08: send_angles (single) [ -0.39, +3.31, +0.50, -0.35, -2.93, -30.69] speed=20 wait=0.0s (pre max|Δ|=1.61°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.52° (tol 3.0°) [VIA ] step 8 Δ= -0.1 -1.6 -0.6 -0.3 +0.2 +0.1 着いた [SEND] pi05_chunk020_via09: send_angles (single) [ -0.41, +3.39, +0.52, -0.36, -2.96, -30.70] speed=20 wait=0.0s (pre max|Δ|=1.44°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.44° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -1.4 -0.6 -0.3 +0.2 +0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.44°（関節 j1） [021] 推論 1540ms 10ステップ先 Δ= -0.8 -1.5 -0.6 -0.3 +0.1 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk021_via02: send_angles (single) [ -0.93, +3.37, +0.51, -0.37, -2.81, -30.68] speed=20 wait=0.0s (pre max|Δ|=1.46°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.46° (tol 3.0°) [VIA ] step 2 Δ= -0.7 -1.5 -0.6 -0.3 +0.3 +0.2 着いた [SEND] pi05_chunk021_via05: send_angles (single) [ -1.01, +3.36, +0.52, -0.38, -2.89, -30.69] speed=20 wait=0.0s (pre max|Δ|=1.47°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.47° (tol 3.0°) [VIA ] step 5 Δ= -0.8 -1.5 -0.6 -0.3 +0.3 +0.2 着いた [SEND] pi05_chunk021_via08: send_angles (single) [ -1.08, +3.33, +0.55, -0.40, -3.04, -30.68] speed=20 wait=0.0s (pre max|Δ|=1.50°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.50° (tol 3.0°) [VIA ] step 8 Δ= -0.4 -1.5 -0.6 -0.3 +0.1 +0.2 着いた [SEND] pi05_chunk021_via09: send_angles (single) [ -1.07, +3.34, +0.54, -0.40, -3.02, -30.68] speed=20 wait=0.0s (pre max|Δ|=1.49°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.49° (tol 3.0°) [VIA ] step 9 Δ= -0.3 -1.5 -0.6 -0.3 +0.1 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.49°（関節 j1） [022] 推論 558ms 10ステップ先 Δ= -1.1 -1.6 -0.5 -0.3 +0.8 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk022_via02: send_angles (single) [ -2.09, +3.17, +0.57, -0.41, -2.61, -30.67] speed=20 wait=0.0s (pre max|Δ|=1.66°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.40° (tol 3.0°) [VIA ] step 2 Δ= -1.3 -1.7 -0.6 -0.3 +0.5 +0.2 着いた [SEND] pi05_chunk022_via05: send_angles (single) [ -2.02, +3.21, +0.58, -0.39, -2.55, -30.67] speed=20 wait=0.0s (pre max|Δ|=1.36°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.36° (tol 3.0°) [VIA ] step 5 Δ= +0.3 -1.4 -0.6 -0.3 +0.3 +0.2 着いた [SEND] pi05_chunk022_via08: send_angles (single) [ -2.01, +3.21, +0.59, -0.43, -2.43, -30.66] speed=20 wait=0.0s (pre max|Δ|=1.36°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.36° (tol 3.0°) [VIA ] step 8 Δ= +0.2 -1.4 -0.6 -0.3 +0.5 +0.2 着いた [SEND] pi05_chunk022_via09: send_angles (single) [ -1.93, +3.19, +0.63, -0.42, -2.39, -30.66] speed=20 wait=0.0s (pre max|Δ|=1.38°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.38° (tol 3.0°) [VIA ] step 9 Δ= +0.3 -1.4 -0.5 -0.3 +0.4 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.38°（関節 j1） [023] 推論 691ms 10ステップ先 Δ= -0.5 -1.6 -0.5 -0.3 +0.5 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [SEND] pi05_chunk023_via02: send_angles (single) [ -2.53, +3.19, +0.65, -0.44, -2.27, -30.64] speed=20 wait=0.0s (pre max|Δ|=1.38°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.38° (tol 3.0°) [VIA ] step 2 Δ= -0.3 -1.4 -0.5 -0.4 +0.5 +0.2 着いた [SEND] pi05_chunk023_via05: send_angles (single) [ -2.53, +3.06, +0.62, -0.41, -2.17, -30.64] speed=20 wait=0.0s (pre max|Δ|=1.51°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.51° (tol 3.0°) [VIA ] step 5 Δ= -0.3 -1.5 -0.5 -0.3 +0.4 +0.2 着いた [SEND] pi05_chunk023_via08: send_angles (single) [ -2.77, +2.92, +0.60, -0.40, -2.26, -30.62] speed=20 wait=0.0s (pre max|Δ|=1.65°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.65° (tol 3.0°) [VIA ] step 8 Δ= -0.6 -1.7 -0.5 -0.3 +0.3 +0.2 着いた [PAUSE ] 止める予約 (Enter). 推論 23 を送り終えてから, 次の推論のあと (送る前) で止めます [SEND] pi05_chunk023_via09: send_angles (single) [ -2.68, +2.98, +0.62, -0.39, -2.36, -30.63] speed=20 wait=0.0s (pre max|Δ|=1.59°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.59° (tol 3.0°) [VIA ] step 9 Δ= -0.5 -1.6 -0.5 -0.3 +0.2 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.59°（関節 j1） [024] 推論 1524ms 10ステップ先 Δ= -1.1 -1.8 -0.4 -0.3 +0.3 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [PAUSE ] 止めました (推論 24 はまだ送っていません). Enter で実行すると, また止まらずに進みます Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > h [SEND] pi05_home: send_angles (single) [ +0.00, +0.00, +0.00, +0.00, +0.00, -30.00] speed=20 wait=0.0s (pre max|Δ|=4.57°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.23° (tol 2.5°) [RECORD] 記録終了 コマ 809 (8.867 fps) 実測角 747 回 (8.19 Hz) 電流 754 行 (read_servo) → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_181300/recording 結果: y=成功 / n=失敗 / Enter=記録しない > y [GRIP ] 閉じて 1 秒後の爪の電流 (中央値): 1 回目 787 (10 行) (閉じる値 25) [DONE ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_181300 [CLIENT] run_policy_client.py が終わった (終了コード 0. モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1)) (98 秒) もう1回やりますか? y=やる / 他=終わる > n === かかった時間 (Log35 の Pod (id 9wypmq2uhnx2et) につなぎ直し) モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 1. Pod につなぎ直す 2 秒 2. Pod が立ち上がるまで待つ 5 秒 3. Pod の中を確かめる (つなぎ直し) 8 秒 3a. スクリプトを送る 101 秒 3b〜4. 準備とサーバーの起動 (飛ばした) 0 秒 5. Mac の 8000 番へのトンネル 2 秒 5b. 空打ち (1 回目の推論の待ちを先に済ませる) 3 秒 6. デーモンの状態 2 秒 7. HOME → 爪を開く → 位置合わせ (1 回目) 15 秒 8. 実機推論 (1 回目) 111 秒 7. HOME → 爪を開く → 位置合わせ (2 回目) 9 秒 8. 実機推論 (2 回目) 98 秒 [LAB ] Pod は残しています (id 9wypmq2uhnx2et). 片付けは ./lab_stop.sh --log Log35 [TUNNEL] 8000 番のトンネルを閉じました ``` ### 3回目の起動（`--flow`・速さ30）のターミナル ``` [RANGE ] 安全範囲 (学習データ ±10°) は /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes から (--model deep1) [FRAME ] 写り方の確かめの基準画像は /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes の最初のエピソードから (位置合わせと同じ trim2. 依頼 137) [TILT ] 上カメラの傾きのお手本 (各エピソードの 1 枚目の中央値) は /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes から (安全範囲と同じ. 差だけ画像を回して AI に渡す. 依頼 144) [GRIP ] 爪の閉じる値は 25 (--grip-value). 締め直し r はこの値−3 とこの値を交互に送る (依頼 152) [FLOW ] 推論の送り方: --flow --speed 30 (依頼 176) [CONFIRM] チャンクごとには確かめない (--no-step-confirm. 始めの確かめのあとは止まらずに進む. 止めるときはスペース. 依頼 178) [LAB ] 2026-11-14 18:17:34 GPU=NVIDIA A40 episode=run_0001_20261019_194818 log=/Volumes/KIOXIA/r2r2r-data/lab/Log35 [MODEL ] --model deep1: π0.5 base から deep_even10_v1 で新しく学習した 2999 (依頼 133. decay_steps 5000) PixelstoMotors/pi05-mecharm-deep-even10-lora-v1 → /workspace/ckpt/deep_v1_2999 設定 pi05_mecharm_deep_even10_lora assets local/mecharm_redblock_box_deep_even10_v1 === 1. Pod を作る [POD ] Log35 の Pod (id 9wypmq2uhnx2et) につなぎ直します (状態 RUNNING GPU=NVIDIA A40 1時間 0.59 ドル 作った時刻 2026-11-14 17:58:33) [POD ] 記録の最後のモデル: deep1 今回: --model deep1 (1 秒) === 2. Pod が立ち上がるまで待つ [POD ] SSH の IP とポートを API から取り直した (:) [POD ] 入れた: 7711f98bf50a NVIDIA A40, 46068 MiB (6 秒) === 3. Pod の中を確かめる (つなぎ直し) [POD ] serve_policy.py のプロセス: ある 8000 番の LISTEN: ある [POD ] モデル (/workspace/ckpt/deep_v1_2999): ある openpi (215abfb): ある .venv: ある [POD ] 動いているサーバーのモデル: --policy.dir=/workspace/ckpt/deep_v1_2999 (--model deep1 と同じ) [POD ] サーバーは 8000 番で待っています. 3b〜4 を飛ばします INFO:websockets.server:server listening on 0.0.0.0:8000 (8 秒) === 3a. スクリプトを送る (99 秒) === 3b〜4. 準備とサーバーの起動 → 飛ばす (サーバーが 8000 番で待っている) === 5. Mac の 8000 番へのトンネル [TUNNEL] localhost:8000 → Pod の 8000 番 (pid 61377. このスクリプトが終わると閉じる) (2 秒) === 5b. 空打ち (1 回目の推論の待ちを先に済ませる) [WARM ] 空打ち: localhost:8000 に観測 (画像 384x216・state 7 つ・prompt) を 1 回投げて捨てます (お手本 pi05_20261031_175527 の 1 枚目) [WARM ] 空打ち 1.2 秒 (つなぐまで含めて 2.3 秒. 答え 10x7 は捨てた) (2 秒) === 6. デーモンの状態 --- process 514 /usr/bin/python3 -u /home/ubuntu/mecharm_daemon.py --- 5555 LISTEN 0 1 0.0.0.0:5555 0.0.0.0:* --- systemd enabled: enabled active: active (3 秒) === 7. HOME → 爪を開く → 位置合わせ (1 回目) [INIT] daemon 接続中... [Pi] fresh_mode=1 [INIT] fresh_mode=1 [PRE] 現在姿勢: [0.00, 1.23, 1.14, -0.08, -0.17, -30.23] [SEND] HOME へ移動指令 [WAIT] t=0.6s max_err=1.23° [DONE] HOME 到達 max_err=1.23° [POST] 最終姿勢: [0.00, 1.23, 1.14, -0.08, -0.17, -30.23] [Pi] fresh_mode=0 [EXIT] fresh_mode=0, socket close [Pi] GRIPPER: OPEN result= None [REF ] 基準画像: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_194818/frames/000000.jpg [REF ] お手本 run_0001_20261019_194818 (つかんだ瞬間の j0 = +13.2°) [REF ] 重なった画像のブロックに実物のブロックを合わせると, お手本と同じ位置に置ける [TILT ] 傾きのお手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 中央値 -0.61° (測れた 50/50 本. プラス=右下がり) [TILT ] 傾きはソフトでそろえる: ライブをお手本の中央値との差だけ回して重ねる (AI に渡す画像と同じ. 回す角度が 3° を超えたら画面の色を変える. 止めない) [ALIGN ] |dy| <= 20 なら OK. アームは HOME に置いた状態で合わせる. q または Esc で終了 (ファイルには何も書かない) [ALIGN ] dy= +0.5 dx= -1.7 response=0.992 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -2.03° → -0.61° にソフトでそろえる (+1.42° 回して重ねる. プラス=右下がり) [ALIGN ] dy= +0.5 dx= -1.7 response=1.027 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.87° → -0.61° にソフトでそろえる (+1.25° 回して重ねる. プラス=右下がり) [DONE ] 終了 (何も書いていません) (63 秒) === 8. 実機推論 (1 回目) [WAIT ] 送ったあと 0.0s / 爪のあと 0.8s (開くときの daemon 0.0s) / 止まるのを待つ目安 0.8s [GRIP ] 閉じる値 25 締め直し r は 22 と 25 を交互に送る [FLOW ] --flow: 途中の点は 5.0° 以内に近づくか見込みの時間で次を送る (間隔 0.4〜1.5 秒). 最後の点は 3° の到着を待つ 速さ 30 (--speed. 補正・巻き戻し・HOME は 20 のまま) [SAFE ] 安全範囲 (学習 50 本 ±10°): j0[-72,+55] j1[-9,+88] j2[-45,+52] j3[-18,+27] j4[-87,+10] j5[-51,-15] [SAFE ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352) 元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes [MODE ] EXECUTE steps/chunk=10 max_move=20.0° log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182039 [MODEL ] deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) [PAUSE ] --no-step-confirm: 始めの確かめのあとは入力欄を出さずに進みます. 止めるときはスペース (Enter も可). 今のチャンクを送り終えてから, 次の推論のあと (送る前) で入力欄を出します [CAMERA] 写り方 dy=-5.8 dx=+5.2 response=0.524 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 回したあとの画像で測った [CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg [CAMERA] 傾き -1.91° → -0.61° にそろえて渡す (+1.29° 回す. プラス=右下がり) (お手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 測れた 50/50 本・今 5/5 コマ) [POLICY] 接続 ws://localhost:8000 metadata={} [RECORD] 上カメラと実測角を 1 秒 10 コマで記録します → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182039/recording [GRIP ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく) [STATE ] 実測を渡す (直前に送った目標がない) [000] 推論 566ms 10ステップ先 Δ= +4.8 +12.2 +8.3 -1.6 -18.1 +2.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > [GRIP ] 開始時にグリッパーを開く [Pi] GRIPPER: OPEN result= None [VIA ] step 2 Δ= +0.5 +2.2 +1.8 -0.0 -3.2 +0.4 流した 0.44 秒で次へ: 近づいた (残り 1.43°) [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [VIA ] step 5 Δ= +2.3 +3.3 +1.9 -0.7 -8.0 +1.0 流した 2.09 秒で次へ: 見込みの時間がたった [VIA ] step 8 Δ= +2.2 +3.7 +2.0 -1.5 -7.5 +1.0 流した 0.48 秒で次へ: 近づいた (残り 1.01°) [SEND] pi05_chunk000_via09: send_angles (single) [ +4.72, +13.44, +9.42, -1.72, -18.24, -28.07] speed=30 wait=0.0s (pre max|Δ|=1.90°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.88° (tol 3.0°) [VIA ] step 9 Δ= +1.0 +0.2 -0.4 -0.1 -2.0 +0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.88°（関節 j1） [001] 推論 586ms 10ステップ先 Δ= +4.3 +13.2 +10.0 -1.0 -22.3 +1.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.4 +3.0 +2.2 -0.5 -6.2 +0.8 流した 0.56 秒で次へ: 近づいた (残り 0.97°) [VIA ] step 5 Δ= +1.6 +3.8 +2.6 -0.1 -7.6 +0.5 流した 0.48 秒で次へ: 近づいた (残り 0.93°) [VIA ] step 8 Δ= +1.4 +3.7 +3.0 -0.1 -8.1 +0.3 流した 0.49 秒で次へ: 近づいた (残り 0.99°) [SEND] pi05_chunk001_via09: send_angles (single) [ +8.79, +27.48, +19.86, -2.71, -40.10, -27.12] speed=30 wait=0.0s (pre max|Δ|=1.78°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.90° (tol 3.0°) [VIA ] step 9 Δ= +0.5 -0.2 -0.3 +0.0 -1.8 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.90°（関節 j1） [002] 推論 1572ms 10ステップ先 Δ= +3.3 +10.8 +5.4 +0.7 -16.6 +0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.6 +3.6 +1.9 +0.2 -7.4 +0.3 流した 0.50 秒で次へ: 近づいた (残り 0.95°) [VIA ] step 5 Δ= +1.3 +3.0 +1.3 +0.5 -5.6 +0.4 流した 0.44 秒で次へ: 近づいた (残り 1.0°) [VIA ] step 8 Δ= +0.8 +1.4 +0.7 +0.5 -3.3 +0.3 流した 0.56 秒で次へ: 近づいた (残り 0.8°) [SEND] pi05_chunk002_via09: send_angles (single) [ +11.56, +39.16, +25.50, -2.16, -56.10, -26.87] speed=30 wait=0.0s (pre max|Δ|=1.09°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.91° (tol 3.0°) [VIA ] step 9 Δ= +0.1 +0.0 -0.1 +0.6 -1.1 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.91°（関節 j1） [003] 推論 871ms 10ステップ先 Δ= +2.7 +11.8 -0.8 +0.5 -5.4 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.4 +3.5 +1.6 +0.6 -4.0 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.13°) [VIA ] step 5 Δ= +0.9 +0.8 -0.2 +0.1 -0.4 +0.2 流した 0.51 秒で次へ: 近づいた (残り 1.12°) [VIA ] step 8 Δ= +0.4 +3.4 -1.9 +0.1 -0.7 +0.3 流した 0.41 秒で次へ: 近づいた (残り 1.52°) [SEND] pi05_chunk003_via09: send_angles (single) [ +14.08, +51.90, +24.74, -2.20, -61.17, -26.82] speed=30 wait=0.0s (pre max|Δ|=2.50°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.09° (tol 3.0°) [VIA ] step 9 Δ= +0.5 +0.8 -2.5 -0.0 -0.5 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.09°（関節 j2） [004] 推論 846ms 8ステップ先 Δ= +0.8 +5.5 -6.1 -0.5 +2.1 -0.2 グリッパー→閉 [VIA ] 中継点 3 点: step 2, 5, 7 [VIA ] step 2 Δ= +0.7 +3.2 -4.6 -0.3 +1.1 +0.1 流した 0.50 秒で次へ: 近づいた (残り 1.43°) [VIA ] step 5 Δ= +0.1 +1.2 -2.5 -0.4 +2.5 -0.1 流した 0.58 秒で次へ: 近づいた (残り 2.44°) [SEND] pi05_chunk004_via07: send_angles (single) [ +14.43, +58.28, +19.71, -2.56, -58.65, -27.27] speed=30 wait=0.0s (pre max|Δ|=2.34°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.34° (tol 3.0°) [VIA ] step 7 Δ= +0.0 -0.6 -0.7 -0.5 +2.3 +0.1 着いた [Pi] GRIPPER: VALUE=25 speed=100 result= None [STATE ] 目標を渡す 目標と実測の最大差 3.04°（関節 j4） [005] 推論 650ms 10ステップ先 Δ= +1.7 -9.6 +7.5 -0.5 +0.7 +0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.5 -2.1 +0.7 -0.5 +2.1 +0.1 流した 0.43 秒で次へ: 近づいた (残り 2.06°) [VIA ] step 5 Δ= +0.6 -5.4 +4.4 -0.8 +1.4 +0.4 流した 0.51 秒で次へ: 近づいた (残り 1.59°) [VIA ] step 8 Δ= +1.2 -4.9 +3.3 -0.2 -0.8 +0.4 流した 0.52 秒で次へ: 近づいた (残り 1.78°) [SEND] pi05_chunk005_via09: send_angles (single) [ +15.67, +49.24, +27.66, -2.38, -61.01, -27.21] speed=30 wait=0.0s (pre max|Δ|=2.17°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.17° (tol 3.0°) [VIA ] step 9 Δ= +0.6 -2.2 -0.1 -0.2 -0.9 -0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.17°（関節 j1） [006] 推論 572ms 10ステップ先 Δ=+12.5 -0.3 -13.2 +2.9 +4.4 -3.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +7.1 -1.4 -6.9 +1.4 +1.7 -1.8 流した 0.43 秒で次へ: 近づいた (残り 1.46°) [VIA ] step 5 Δ= +3.8 -0.7 -5.7 +1.6 +2.5 -2.5 流した 0.40 秒で次へ: 近づいた (残り 1.1°) [VIA ] step 8 Δ= +1.4 -0.7 -2.4 +1.0 +0.4 -1.5 流した 0.50 秒で次へ: 近づいた (残り 1.3°) [SEND] pi05_chunk006_via09: send_angles (single) [ +28.23, +51.14, +14.59, +0.76, -55.72, -30.29] speed=30 wait=0.0s (pre max|Δ|=1.20°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.20° (tol 3.0°) [VIA ] step 9 Δ= -0.2 -0.7 -1.1 +0.4 -0.3 -1.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.14°（関節 j2） [007] 推論 1630ms 10ステップ先 Δ= +0.4 -1.4 -9.6 +0.7 +0.6 -1.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.1 -1.1 -2.8 +0.5 -0.1 -0.9 流した 0.48 秒で次へ: 近づいた (残り 1.21°) [VIA ] step 5 Δ= -0.0 -1.4 -4.4 +0.4 +0.3 -0.7 流した 0.52 秒で次へ: 近づいた (残り 1.38°) [VIA ] step 8 Δ= +0.5 -1.4 -4.0 +0.1 +0.7 -0.5 流した 0.52 秒で次へ: 近づいた (残り 1.42°) [SEND] pi05_chunk007_via09: send_angles (single) [ +28.90, +50.74, +6.17, +1.07, -54.85, -30.22] speed=30 wait=0.0s (pre max|Δ|=1.74°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.74° (tol 3.0°) [VIA ] step 9 Δ= +0.6 -1.4 -1.7 +0.3 -0.5 -0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.74°（関節 j2） [008] 推論 563ms 10ステップ先 Δ=+12.8 +1.6 -10.9 +1.2 +1.4 -1.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +3.1 -1.0 -5.6 +0.3 +0.9 -0.6 流した 0.41 秒で次へ: 近づいた (残り 1.12°) [VIA ] step 5 Δ= +4.1 -0.7 -4.2 +0.6 +1.3 -0.8 流した 0.52 秒で次へ: 近づいた (残り 1.11°) [VIA ] step 8 Δ= +4.5 +0.4 -2.9 +0.6 -0.5 -0.7 流した 0.52 秒で次へ: 近づいた (残り 1.33°) [SEND] pi05_chunk008_via09: send_angles (single) [ +41.07, +53.68, -2.97, +1.96, -52.87, -30.97] speed=30 wait=0.0s (pre max|Δ|=1.48°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.48° (tol 3.0°) [VIA ] step 9 Δ= +1.2 -0.6 -1.5 +0.2 -0.8 -0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.48°（関節 j2） [009] 推論 568ms 10ステップ先 Δ= -0.5 +7.9 -1.8 +1.6 -9.9 -0.7 グリッパー→開 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.1 +4.2 -1.6 +1.1 -5.4 -0.5 流した 0.50 秒で次へ: 近づいた (残り 2.0°) [VIA ] step 5 Δ= -0.2 +2.1 -1.7 +1.0 -5.4 -0.5 流した 0.52 秒で次へ: 近づいた (残り 1.47°) [VIA ] step 8 Δ= -0.4 -0.9 -1.5 +0.7 -2.5 +0.1 流した 0.42 秒で次へ: 近づいた (残り 2.48°) [SEND] pi05_chunk009_via09: send_angles (single) [ +40.50, +62.72, -3.26, +3.11, -61.98, -31.27] speed=30 wait=0.0s (pre max|Δ|=2.48°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.52° (tol 3.0°) [VIA ] step 9 Δ= -0.4 -1.0 -1.5 +0.6 -2.5 +0.2 着いた [Pi] GRIPPER: OPEN result= None [STATE ] 目標を渡す 目標と実測の最大差 1.51°（関節 j2） [010] 推論 607ms 10ステップ先 Δ= -1.2 -17.5 -1.2 +0.4 +16.6 -0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.3 -6.7 -1.5 +0.3 +5.8 +0.1 流した 0.48 秒で次へ: 近づいた (残り 2.44°) [VIA ] step 5 Δ= -0.1 -7.2 -1.3 +0.3 +7.4 -0.1 流した 0.52 秒で次へ: 近づいた (残り 2.09°) [VIA ] step 8 Δ= -0.7 -6.2 -1.1 +0.3 +6.9 -0.2 流した 0.52 秒で次へ: 近づいた (残り 1.93°) [SEND] pi05_chunk010_via09: send_angles (single) [ +39.62, +46.26, -2.93, +3.21, -46.10, -31.68] speed=30 wait=0.0s (pre max|Δ|=3.04°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.25° (tol 3.0°) [VIA ] step 9 Δ= -0.5 -3.0 -1.1 +0.2 +2.8 -0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.25°（関節 j1） [011] 推論 615ms 10ステップ先 Δ=-21.4 -26.8 +0.2 -2.8 +28.2 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -5.7 -8.9 -0.7 -0.6 +8.9 -0.1 流した 0.40 秒で次へ: 近づいた (残り 1.84°) [VIA ] step 5 Δ= -6.0 -9.1 -0.3 -2.1 +8.7 +0.1 流した 0.42 秒で次へ: 近づいた (残り 1.67°) [VIA ] step 8 Δ= -7.5 -10.1 +0.1 -1.8 +9.8 +0.3 流した 0.52 秒で次へ: 近づいた (残り 1.56°) [SEND] pi05_chunk011_via09: send_angles (single) [ +18.71, +21.68, -1.64, +0.19, -19.55, -31.25] speed=30 wait=0.0s (pre max|Δ|=3.89°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.61° (tol 3.0°) [VIA ] step 9 Δ= -2.5 -3.9 -0.8 -0.8 +3.8 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.61°（関節 j1） [012] 推論 1491ms 10ステップ先 Δ= -5.1 -10.0 -0.5 -0.9 +8.7 +0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -4.6 -9.2 -0.4 -0.8 +8.0 +0.5 流した 0.44 秒で次へ: 近づいた (残り 1.31°) [VIA ] step 5 Δ= -1.1 -3.0 -0.3 -0.9 +2.1 +0.4 流した 0.50 秒で次へ: 近づいた (残り 1.5°) [VIA ] step 8 Δ= +0.8 -0.6 -0.8 -0.8 -0.4 +0.3 流した 0.50 秒で次へ: 近づいた (残り 0.88°) [SEND] pi05_chunk012_via09: send_angles (single) [ +13.49, +13.28, -1.38, -0.25, -11.86, -31.13] speed=30 wait=0.0s (pre max|Δ|=0.87°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.87° (tol 3.0°) [VIA ] step 9 Δ= +0.2 -0.9 -0.9 -0.7 -0.5 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.87°（関節 j1） [013] 推論 695ms 10ステップ先 Δ=-10.4 -11.0 -0.6 -0.7 +8.0 +0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -6.0 -7.5 -0.8 -0.8 +6.2 +0.5 流した 0.44 秒で次へ: 近づいた (残り 1.23°) [VIA ] step 5 Δ= -3.5 -4.1 -0.7 -0.6 +2.8 +0.5 流した 0.44 秒で次へ: 近づいた (残り 1.18°) [VIA ] step 8 Δ= -0.6 -1.7 -0.6 -0.4 +0.2 +0.5 流した 0.50 秒で次へ: 近づいた (残り 1.32°) [SEND] pi05_chunk013_via09: send_angles (single) [ +2.84, +3.15, -1.15, -0.28, -3.35, -30.92] speed=30 wait=0.0s (pre max|Δ|=1.42°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.42° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -1.4 -0.6 -0.4 +0.3 +0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.42°（関節 j1） [014] 推論 564ms 10ステップ先 Δ= -1.0 -1.8 -0.8 -0.3 +0.5 +0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.3 -1.8 -0.6 -0.4 +0.8 +0.5 流した 0.50 秒で次へ: 近づいた (残り 1.61°) [VIA ] step 5 Δ= +0.3 -1.7 -0.7 -0.3 +0.6 +0.5 流した 0.42 秒で次へ: 近づいた (残り 1.73°) [VIA ] step 8 Δ= +0.4 -1.7 -0.7 -0.3 +0.4 +0.5 流した 0.50 秒で次へ: 近づいた (残り 1.69°) [SEND] pi05_chunk014_via09: send_angles (single) [ +1.96, +2.76, -1.28, -0.26, -3.14, -30.93] speed=30 wait=0.0s (pre max|Δ|=1.63°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.63° (tol 3.0°) [VIA ] step 9 Δ= +0.5 -1.6 -0.8 -0.3 +0.4 +0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.63°（関節 j1） [015] 推論 1490ms 10ステップ先 Δ= -0.9 -2.0 -0.7 -0.4 +0.4 +0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [PAUSE ] 止める予約 (Enter). 推論 15 は送らずに入力欄を出します [PAUSE ] 止めました (推論 15 はまだ送っていません). Enter で実行すると, また止まらずに進みます Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > h [SEND] pi05_home: send_angles (single) [ +0.00, +0.00, +0.00, +0.00, +0.00, -30.00] speed=20 wait=0.0s (pre max|Δ|=4.39°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.23° (tol 2.5°) [RECORD] 記録終了 コマ 621 (8.946 fps) 実測角 538 回 (7.75 Hz) 電流 542 行 (read_servo) → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182039/recording 結果: y=成功 / n=失敗 / Enter=記録しない > y [GRIP ] 閉じて 1 秒後の爪の電流 (中央値): 1 回目 734 (9 行) (閉じる値 25) [DONE ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182039 [CLIENT] run_policy_client.py が終わった (終了コード 0. モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1)) (76 秒) もう1回やりますか? y=やる / 他=終わる > y === 7. HOME → 爪を開く → 位置合わせ (2 回目) [INIT] daemon 接続中... [Pi] fresh_mode=1 [INIT] fresh_mode=1 [PRE] 現在姿勢: [-0.35, 1.23, 0.96, 0.08, -0.17, -30.14] [SEND] HOME へ移動指令 [WAIT] t=0.7s max_err=1.23° [DONE] HOME 到達 max_err=1.23° [POST] 最終姿勢: [-0.35, 1.23, 0.96, 0.08, -0.17, -30.14] [Pi] fresh_mode=0 [EXIT] fresh_mode=0, socket close [Pi] GRIPPER: OPEN result= None [REF ] 基準画像: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_194818/frames/000000.jpg [REF ] お手本 run_0001_20261019_194818 (つかんだ瞬間の j0 = +13.2°) [REF ] 重なった画像のブロックに実物のブロックを合わせると, お手本と同じ位置に置ける [TILT ] 傾きのお手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 中央値 -0.61° (測れた 50/50 本. プラス=右下がり) [TILT ] 傾きはソフトでそろえる: ライブをお手本の中央値との差だけ回して重ねる (AI に渡す画像と同じ. 回す角度が 3° を超えたら画面の色を変える. 止めない) [ALIGN ] |dy| <= 20 なら OK. アームは HOME に置いた状態で合わせる. q または Esc で終了 (ファイルには何も書かない) [ALIGN ] dy= +0.6 dx= -2.9 response=0.849 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.95° → -0.61° にソフトでそろえる (+1.33° 回して重ねる. プラス=右下がり) [DONE ] 終了 (何も書いていません) (15 秒) === 8. 実機推論 (2 回目) [WAIT ] 送ったあと 0.0s / 爪のあと 0.8s (開くときの daemon 0.0s) / 止まるのを待つ目安 0.8s [GRIP ] 閉じる値 25 締め直し r は 22 と 25 を交互に送る [FLOW ] --flow: 途中の点は 5.0° 以内に近づくか見込みの時間で次を送る (間隔 0.4〜1.5 秒). 最後の点は 3° の到着を待つ 速さ 30 (--speed. 補正・巻き戻し・HOME は 20 のまま) [SAFE ] 安全範囲 (学習 50 本 ±10°): j0[-72,+55] j1[-9,+88] j2[-45,+52] j3[-18,+27] j4[-87,+10] j5[-51,-15] [SAFE ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352) 元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes [MODE ] EXECUTE steps/chunk=10 max_move=20.0° log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182211 [MODEL ] deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) [PAUSE ] --no-step-confirm: 始めの確かめのあとは入力欄を出さずに進みます. 止めるときはスペース (Enter も可). 今のチャンクを送り終えてから, 次の推論のあと (送る前) で入力欄を出します [CAMERA] 写り方 dy=-5.7 dx=+4.4 response=0.571 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 回したあとの画像で測った [CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg [CAMERA] 傾き -1.99° → -0.61° にそろえて渡す (+1.37° 回す. プラス=右下がり) (お手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 測れた 50/50 本・今 5/5 コマ) [POLICY] 接続 ws://localhost:8000 metadata={} [RECORD] 上カメラと実測角を 1 秒 10 コマで記録します → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182211/recording [GRIP ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく) [STATE ] 実測を渡す (直前に送った目標がない) [000] 推論 678ms 10ステップ先 Δ= +3.8 +14.0 +9.1 -1.6 -21.2 +2.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [CONFIRM] 2 回目からの試行なので始めの確かめ (Enter) を待たずに実行します (次の推論からは今までどおり確かめます) [GRIP ] 開始時にグリッパーを開く [Pi] GRIPPER: OPEN result= None [VIA ] step 2 Δ= +0.7 +2.9 +2.2 +0.1 -3.9 +0.2 流した 0.44 秒で次へ: 近づいた (残り 1.53°) [VIA ] step 5 Δ= +1.3 +3.5 +1.8 -0.4 -8.6 +0.9 流した 0.48 秒で次へ: 近づいた (残り 1.73°) [VIA ] step 8 Δ= +1.6 +3.9 +2.1 -1.3 -9.5 +1.3 流した 0.53 秒で次へ: 近づいた (残り 1.31°) [SEND] pi05_chunk000_via09: send_angles (single) [ +3.44, +15.21, +10.10, -1.59, -21.32, -27.88] speed=30 wait=0.0s (pre max|Δ|=3.75°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.11° (tol 3.0°) [VIA ] step 9 Δ= +0.8 +0.9 +0.0 -0.4 -3.8 +0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.11°（関節 j4） [001] 推論 1549ms 10ステップ先 Δ= +4.3 +13.0 +7.4 -1.2 -22.8 +1.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.0 +2.7 +1.0 -0.8 -6.8 +0.8 流した 0.44 秒で次へ: 近づいた (残り 1.1°) [VIA ] step 5 Δ= +1.5 +3.4 +2.0 -0.2 -7.7 +0.5 流した 0.48 秒で次へ: 近づいた (残り 1.04°) [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [VIA ] step 8 Δ= +1.7 +3.5 +2.3 +0.1 -7.9 +0.3 流した 2.24 秒で次へ: 見込みの時間がたった [WARN] daemon_get_angles failed: daemon error: get_angles returned empty/invalid after 12 retries [SEND] pi05_chunk001_via09: send_angles (single) [ +7.66, +29.13, +18.30, -2.56, -43.00, -27.03] speed=30 wait=0.0s (pre max|Δ|=2.58°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.01° (tol 3.0°) [VIA ] step 9 Δ= +0.6 +0.2 -0.1 -0.0 -2.6 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.01°（関節 j1） [002] 推論 799ms 10ステップ先 Δ= +3.8 +9.6 +5.2 +0.6 -16.1 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.6 +2.3 +1.1 +0.1 -4.8 +0.2 流した 0.56 秒で次へ: 近づいた (残り 0.92°) [VIA ] step 5 Δ= +1.0 +2.7 +1.3 +0.6 -5.7 +0.3 流した 0.52 秒で次へ: 近づいた (残り 0.98°) [VIA ] step 8 Δ= +1.1 +2.1 +1.3 +0.6 -4.4 +0.2 流した 0.50 秒で次へ: 近づいた (残り 0.95°) [SEND] pi05_chunk002_via09: send_angles (single) [ +10.92, +39.73, +23.99, -1.90, -59.50, -26.92] speed=30 wait=0.0s (pre max|Δ|=0.79°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.87° (tol 3.0°) [VIA ] step 9 Δ= +0.4 -0.4 -0.1 +0.6 -0.8 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.87°（関節 j1） [003] 推論 757ms 10ステップ先 Δ= +2.1 +7.3 +1.5 +0.5 -7.9 +0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.3 +0.8 +0.7 +0.6 -3.4 +0.3 流した 0.58 秒で次へ: 近づいた (残り 0.93°) [VIA ] step 5 Δ= +0.8 +1.4 +1.3 +0.3 -2.5 +0.2 流した 0.42 秒で次へ: 近づいた (残り 0.98°) [VIA ] step 8 Δ= +0.2 +1.9 -1.1 +0.2 -1.2 +0.3 流した 0.52 秒で次へ: 近づいた (残り 1.1°) [SEND] pi05_chunk003_via09: send_angles (single) [ +12.60, +47.90, +25.55, -1.93, -66.64, -26.77] speed=30 wait=0.0s (pre max|Δ|=1.25°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.16° (tol 3.0°) [VIA ] step 9 Δ= +0.2 +0.3 -1.2 +0.2 -0.3 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.16°（関節 j2） [004] 推論 1603ms 9ステップ先 Δ= +0.4 +8.8 -7.6 -0.3 +2.7 +0.1 グリッパー→閉 [VIA ] 中継点 3 点: step 2, 5, 8 [VIA ] step 2 Δ= +0.3 +3.6 -4.1 -0.0 +1.2 +0.2 流した 0.54 秒で次へ: 近づいた (残り 1.31°) [VIA ] step 5 Δ= +0.4 +2.8 -3.4 -0.1 +2.3 +0.1 流した 0.54 秒で次へ: 近づいた (残り 2.25°) [SEND] pi05_chunk004_via08: send_angles (single) [ +12.82, +57.67, +19.08, -2.28, -64.06, -26.91] speed=30 wait=0.0s (pre max|Δ|=2.73°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.68° (tol 3.0°) [VIA ] step 8 Δ= +0.4 +0.4 -2.3 -0.4 +2.7 +0.1 着いた [Pi] GRIPPER: VALUE=25 speed=100 result= None [STATE ] 目標を渡す 目標と実測の最大差 1.68°（関節 j4） [005] 推論 807ms 10ステップ先 Δ= +1.5 -11.5 +6.1 -0.5 +2.3 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.5 -4.7 +1.6 -0.5 +2.5 +0.2 流した 0.40 秒で次へ: 近づいた (残り 1.76°) [VIA ] step 5 Δ= +1.0 -5.7 +2.8 -0.8 +0.7 +0.3 流した 0.51 秒で次へ: 近づいた (残り 1.72°) [VIA ] step 8 Δ= +0.5 -4.4 +1.1 -0.5 +0.5 +0.1 流した 0.60 秒で次へ: 近づいた (残り 1.6°) [SEND] pi05_chunk005_via09: send_angles (single) [ +13.90, +47.17, +26.21, -2.50, -63.41, -26.67] speed=30 wait=0.0s (pre max|Δ|=1.87°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.87° (tol 3.0°) [VIA ] step 9 Δ= +0.6 -1.9 -0.6 -0.3 +0.3 +0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.87°（関節 j1） [006] 推論 1772ms 10ステップ先 Δ=+13.7 -0.3 -14.6 +3.2 +6.4 -4.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +3.5 -1.8 -3.5 +0.5 +1.3 -1.0 流した 0.50 秒で次へ: 近づいた (残り 1.76°) [VIA ] step 5 Δ= +5.6 -1.1 -6.5 +1.4 +2.8 -2.6 流した 0.52 秒で次へ: 近づいた (残り 1.32°) [VIA ] step 8 Δ= +3.9 -0.5 -5.6 +1.1 +3.0 -2.6 流した 0.44 秒で次へ: 近づいた (残り 1.23°) [SEND] pi05_chunk006_via09: send_angles (single) [ +27.66, +48.70, +12.16, +1.00, -57.35, -30.86] speed=30 wait=0.0s (pre max|Δ|=1.81°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.72° (tol 3.0°) [VIA ] step 9 Δ= +0.6 -0.8 -1.8 +0.1 +0.6 -1.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.72°（関節 j2） [007] 推論 749ms 10ステップ先 Δ=+18.4 +5.3 -19.6 +3.9 +7.0 -4.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +7.0 +0.0 -9.1 +1.7 +4.0 -2.4 流した 0.44 秒で次へ: 近づいた (残り 1.02°) [VIA ] step 5 Δ= +6.8 +0.4 -8.0 +1.5 +4.0 -2.3 流した 0.45 秒で次へ: 近づいた (残り 1.15°) [VIA ] step 8 Δ= +4.0 +1.6 -4.2 +0.8 +0.4 -1.5 流した 0.50 秒で次へ: 近づいた (残り 1.32°) [SEND] pi05_chunk007_via09: send_angles (single) [ +45.59, +55.00, -5.71, +4.40, -50.91, -34.37] speed=30 wait=0.0s (pre max|Δ|=1.67°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.67° (tol 3.0°) [VIA ] step 9 Δ= +0.7 -0.2 -1.7 +0.2 -0.4 -0.8 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.67°（関節 j2） [008] 推論 755ms 10ステップ先 Δ= +0.2 +10.9 -2.4 +1.5 -8.3 -0.9 グリッパー→開 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.2 +4.5 -2.0 +0.7 -3.8 -0.8 流した 0.44 秒で次へ: 近づいた (残り 1.63°) [VIA ] step 5 Δ= +0.2 +3.4 -1.8 +0.6 -4.2 -0.6 流した 0.44 秒で次へ: 近づいた (残り 1.15°) [VIA ] step 8 Δ= +0.3 +1.2 -0.9 +0.8 -0.5 -0.8 流した 0.50 秒で次へ: 近づいた (残り 2.39°) [SEND] pi05_chunk008_via09: send_angles (single) [ +45.44, +67.16, -6.44, +5.88, -58.78, -34.53] speed=30 wait=0.0s (pre max|Δ|=2.39°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.39° (tol 3.0°) [VIA ] step 9 Δ= +0.1 -0.6 -0.6 +0.6 +2.4 -0.8 着いた [Pi] GRIPPER: OPEN result= None [STATE ] 目標を渡す 目標と実測の最大差 1.23°（関節 j3） [009] 推論 635ms 10ステップ先 Δ= -0.3 -14.4 +0.3 -0.9 +14.0 +0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.3 -4.0 -0.6 -0.8 +3.4 +0.3 流した 0.50 秒で次へ: 近づいた (残り 1.75°) [VIA ] step 5 Δ= +0.2 -6.2 -0.4 -0.5 +3.1 +0.4 流した 0.52 秒で次へ: 近づいた (残り 2.04°) [VIA ] step 8 Δ= -0.0 -6.6 -0.0 -0.7 +2.9 +0.4 流した 0.52 秒で次へ: 近づいた (残り 1.86°) [SEND] pi05_chunk009_via09: send_angles (single) [ +44.90, +53.40, -5.55, +6.16, -45.96, -34.89] speed=30 wait=0.0s (pre max|Δ|=3.28°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.14° (tol 3.0°) [VIA ] step 9 Δ= -0.3 -3.3 -0.4 -0.6 -0.4 +0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.14°（関節 j1） [010] 推論 564ms 10ステップ先 Δ=-18.8 -27.1 +3.3 -4.8 +21.5 +2.8 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -4.1 -8.7 +0.5 -1.5 +4.7 +1.0 流した 0.52 秒で次へ: 近づいた (残り 1.87°) [VIA ] step 5 Δ= -5.8 -9.6 +0.7 -1.1 +5.7 +1.7 流した 0.44 秒で次へ: 近づいた (残り 1.89°) [VIA ] step 8 Δ= -6.8 -9.9 +0.6 -1.3 +6.5 +1.9 流した 0.41 秒で次へ: 近づいた (残り 1.82°) [SEND] pi05_chunk010_via09: send_angles (single) [ +26.42, +28.41, -1.91, +2.04, -22.69, -32.49] speed=30 wait=0.0s (pre max|Δ|=4.37°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.73° (tol 3.0°) [VIA ] step 9 Δ= -2.2 -4.4 -0.3 -1.0 +1.4 +1.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.73°（関節 j1） [011] 推論 651ms 10ステップ先 Δ=-22.1 -27.3 +1.2 -1.9 +24.4 +2.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -6.5 -10.0 +0.5 -1.1 +6.9 +1.7 流した 0.51 秒で次へ: 近づいた (残り 1.54°) [VIA ] step 5 Δ= -7.0 -10.0 +0.0 -1.1 +7.7 +1.3 流した 0.52 秒で次へ: 近づいた (残り 1.42°) [PAUSE ] 止める予約 (Enter). 推論 11 を送り終えてから, 次の推論のあと (送る前) で止めます [VIA ] step 8 Δ= -6.7 -8.6 -0.6 -0.6 +6.7 +0.8 流した 0.52 秒で次へ: 近づいた (残り 1.16°) [SEND] pi05_chunk011_via09: send_angles (single) [ +4.55, +2.85, -0.06, +0.01, +2.79, -30.87] speed=30 wait=0.0s (pre max|Δ|=2.77°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.28° (tol 3.0°) [VIA ] step 9 Δ= -1.9 -2.8 -0.8 -0.4 +1.0 +0.6 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.28°（関節 j1） [012] 推論 1660ms 10ステップ先 Δ= -1.5 -2.1 -0.9 -0.2 +0.2 +0.6 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [PAUSE ] 止めました (推論 12 はまだ送っていません). Enter で実行すると, また止まらずに進みます Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > h [SEND] pi05_home: send_angles (single) [ +0.00, +0.00, +0.00, +0.00, +0.00, -30.00] speed=20 wait=0.0s (pre max|Δ|=4.30°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.46° (tol 2.5°) [RECORD] 記録終了 コマ 493 (8.998 fps) 実測角 384 回 (7.01 Hz) 電流 389 行 (read_servo) → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182211/recording 結果: y=成功 / n=失敗 / Enter=記録しない > y [GRIP ] 閉じて 1 秒後の爪の電流 (中央値): 1 回目 777.5 (10 行) (閉じる値 25) [DONE ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182211 [CLIENT] run_policy_client.py が終わった (終了コード 0. モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1)) (60 秒) もう1回やりますか? y=やる / 他=終わる > y === 7. HOME → 爪を開く → 位置合わせ (3 回目) [INIT] daemon 接続中... [Pi] fresh_mode=1 [INIT] fresh_mode=1 [PRE] 現在姿勢: [-0.17, 1.31, 0.70, 0.17, 1.40, -30.23] [SEND] HOME へ移動指令 [WAIT] t=0.7s max_err=1.31° [DONE] HOME 到達 max_err=1.31° [POST] 最終姿勢: [-0.17, 1.31, 0.70, 0.17, -0.70, -30.23] [Pi] fresh_mode=0 [EXIT] fresh_mode=0, socket close [Pi] GRIPPER: OPEN result= None [REF ] 基準画像: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_194818/frames/000000.jpg [REF ] お手本 run_0001_20261019_194818 (つかんだ瞬間の j0 = +13.2°) [REF ] 重なった画像のブロックに実物のブロックを合わせると, お手本と同じ位置に置ける [TILT ] 傾きのお手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 中央値 -0.61° (測れた 50/50 本. プラス=右下がり) [TILT ] 傾きはソフトでそろえる: ライブをお手本の中央値との差だけ回して重ねる (AI に渡す画像と同じ. 回す角度が 3° を超えたら画面の色を変える. 止めない) [ALIGN ] |dy| <= 20 なら OK. アームは HOME に置いた状態で合わせる. q または Esc で終了 (ファイルには何も書かない) [ALIGN ] dy= +1.4 dx= -2.0 response=0.998 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 傾き -1.95° → -0.61° にソフトでそろえる (+1.33° 回して重ねる. プラス=右下がり) [DONE ] 終了 (何も書いていません) (14 秒) === 8. 実機推論 (3 回目) [WAIT ] 送ったあと 0.0s / 爪のあと 0.8s (開くときの daemon 0.0s) / 止まるのを待つ目安 0.8s [GRIP ] 閉じる値 25 締め直し r は 22 と 25 を交互に送る [FLOW ] --flow: 途中の点は 5.0° 以内に近づくか見込みの時間で次を送る (間隔 0.4〜1.5 秒). 最後の点は 3° の到着を待つ 速さ 30 (--speed. 補正・巻き戻し・HOME は 20 のまま) [SAFE ] 安全範囲 (学習 50 本 ±10°): j0[-72,+55] j1[-9,+88] j2[-45,+52] j3[-18,+27] j4[-87,+10] j5[-51,-15] [SAFE ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352) 元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes [MODE ] EXECUTE steps/chunk=10 max_move=20.0° log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182327 [MODEL ] deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) [PAUSE ] --no-step-confirm: 始めの確かめのあとは入力欄を出さずに進みます. 止めるときはスペース (Enter も可). 今のチャンクを送り終えてから, 次の推論のあと (送る前) で入力欄を出します [CAMERA] 写り方 dy=-5.2 dx=+4.5 response=0.539 → OK (|dy|<=20 / |dx|<=20 / response>=0.20) 回したあとの画像で測った [CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg [CAMERA] 傾き -1.95° → -0.61° にそろえて渡す (+1.34° 回す. プラス=右下がり) (お手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_deep_even10_v1/raw_episodes 測れた 50/50 本・今 5/5 コマ) [POLICY] 接続 ws://localhost:8000 metadata={} [RECORD] 上カメラと実測角を 1 秒 10 コマで記録します → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182327/recording [GRIP ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく) [STATE ] 実測を渡す (直前に送った目標がない) [000] 推論 753ms 10ステップ先 Δ= +3.6 +14.8 +8.0 -1.4 -19.3 +1.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [CONFIRM] 2 回目からの試行なので始めの確かめ (Enter) を待たずに実行します (次の推論からは今までどおり確かめます) [GRIP ] 開始時にグリッパーを開く [Pi] GRIPPER: OPEN result= None [VIA ] step 2 Δ= +0.8 +3.6 +2.1 -0.1 -4.0 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.78°) [VIA ] step 5 Δ= +1.3 +3.7 +1.3 -0.5 -8.0 +0.7 流した 0.58 秒で次へ: 近づいた (残り 1.5°) [VIA ] step 8 Δ= +1.2 +4.0 +1.8 -1.0 -8.5 +0.9 流した 0.46 秒で次へ: 近づいた (残り 1.62°) [SEND] pi05_chunk000_via09: send_angles (single) [ +3.43, +16.11, +8.70, -1.20, -19.55, -28.72] speed=30 wait=0.0s (pre max|Δ|=3.73°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.94° (tol 3.0°) [VIA ] step 9 Δ= +0.8 +0.6 -0.1 -0.2 -3.7 +0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.94°（関節 j1） [001] 推論 658ms 10ステップ先 Δ= +3.8 +12.8 +6.5 -0.9 -22.4 +1.6 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.1 +2.2 +0.9 -0.5 -6.0 +0.7 流した 0.50 秒で次へ: 近づいた (残り 1.02°) [VIA ] step 5 Δ= +1.5 +3.1 +1.5 -0.1 -7.3 +0.6 流した 0.44 秒で次へ: 近づいた (残り 1.01°) [VIA ] step 8 Δ= +1.4 +4.0 +1.9 -0.0 -8.5 +0.5 流した 0.52 秒で次へ: 近づいた (残り 1.1°) [SEND] pi05_chunk001_via09: send_angles (single) [ +7.10, +29.83, +15.89, -2.00, -40.99, -27.35] speed=30 wait=0.0s (pre max|Δ|=3.03°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.93° (tol 3.0°) [VIA ] step 9 Δ= +0.5 +0.3 -0.1 +0.1 -3.0 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.93°（関節 j1） [002] 推論 1546ms 10ステップ先 Δ= +3.3 +9.3 +3.1 +0.8 -14.2 +0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.3 +1.2 -0.1 +0.4 -3.6 +0.3 流した 0.50 秒で次へ: 近づいた (残り 1.04°) [VIA ] step 5 Δ= +1.1 +2.9 +1.3 +0.8 -5.5 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.07°) [VIA ] step 8 Δ= +1.2 +2.6 +1.0 +1.0 -5.0 +0.3 流した 0.41 秒で次へ: 近づいた (残り 0.94°) [SEND] pi05_chunk002_via09: send_angles (single) [ +9.91, +40.03, +19.57, -1.30, -54.39, -27.25] speed=30 wait=0.0s (pre max|Δ|=0.87°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.92° (tol 3.0°) [VIA ] step 9 Δ= +0.3 -0.4 -0.4 +0.7 -0.9 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.92°（関節 j1） [003] 推論 562ms 10ステップ先 Δ= +4.0 +6.2 +2.7 +0.9 -6.7 +0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.3 +0.5 +0.7 +0.7 -3.3 +0.3 流した 0.52 秒で次へ: 近づいた (残り 0.97°) [VIA ] step 5 Δ= +1.3 +1.3 +0.9 +0.3 -2.3 +0.2 流した 0.58 秒で次へ: 近づいた (残り 0.98°) [VIA ] step 8 Δ= +1.3 +1.3 +0.1 +0.5 -1.2 +0.2 流した 0.58 秒で次へ: 近づいた (残り 1.06°) [SEND] pi05_chunk003_via09: send_angles (single) [ +13.57, +47.19, +22.61, -0.99, -60.38, -27.07] speed=30 wait=0.0s (pre max|Δ|=0.80°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.06° (tol 3.0°) [VIA ] step 9 Δ= +0.6 +0.1 +0.1 +0.3 -0.8 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.06°（関節 j1） [004] 推論 603ms 10ステップ先 Δ= +0.9 +10.1 -6.5 +0.1 -0.8 +0.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.0 +0.4 +0.4 +0.3 -0.9 +0.1 流した 0.42 秒で次へ: 近づいた (残り 1.0°) [VIA ] step 5 Δ= +0.3 +4.0 -3.4 +0.2 -0.4 +0.1 流した 0.52 秒で次へ: 近づいた (残り 1.19°) [VIA ] step 8 Δ= +0.2 +3.1 -4.1 -0.1 +0.1 -0.3 流した 0.50 秒で次へ: 近づいた (残り 1.0°) [SEND] pi05_chunk004_via09: send_angles (single) [ +13.88, +58.32, +15.98, -1.17, -60.89, -27.21] speed=30 wait=0.0s (pre max|Δ|=1.59°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.51° (tol 3.0°) [VIA ] step 9 Δ= +0.1 -0.3 -1.6 -0.2 +0.2 -0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.42°（関節 j2） [005] 推論 561ms 3ステップ先 Δ= +0.1 +0.6 -1.8 -0.0 -0.0 -0.4 グリッパー→閉 [VIA ] 中継点 1 点: step 2 [SEND] pi05_chunk005_via02: send_angles (single) [ +13.87, +59.91, +15.56, -1.10, -61.22, -27.30] speed=30 wait=0.0s (pre max|Δ|=1.75°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.05° (tol 3.0°) [VIA ] step 2 Δ= +0.1 +0.6 -1.8 -0.1 -0.0 -0.4 着いた [Pi] GRIPPER: VALUE=25 speed=100 result= None [STATE ] 目標を渡す 目標と実測の最大差 1.53°（関節 j4） [006] 推論 675ms 10ステップ先 Δ= +1.9 -6.0 -0.3 -0.7 +1.5 -0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.6 -1.3 -1.3 -0.5 +1.3 -0.7 流した 0.49 秒で次へ: 近づいた (残り 1.3°) [VIA ] step 5 Δ= +0.7 -2.0 -1.0 -0.9 +1.3 -0.1 流した 0.50 秒で次へ: 近づいた (残り 1.92°) [VIA ] step 8 Δ= +1.0 -4.6 -0.3 -0.7 +1.7 +0.2 流した 0.40 秒で次へ: 近づいた (残り 1.8°) [SEND] pi05_chunk006_via09: send_angles (single) [ +15.66, +54.85, +16.29, -1.01, -61.23, -27.16] speed=30 wait=0.0s (pre max|Δ|=3.15°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.01° (tol 3.0°) [VIA ] step 9 Δ= +0.4 -3.1 -0.3 -0.2 +1.1 -0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.01°（関節 j1） [007] 推論 1647ms 10ステップ先 Δ= +3.2 -2.2 -6.6 +0.3 +2.0 -1.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +1.7 -1.7 -3.6 +0.0 +1.4 -0.6 流した 0.52 秒で次へ: 近づいた (残り 1.73°) [VIA ] step 5 Δ= +0.2 -1.7 -2.2 +0.4 +0.5 -0.8 流した 0.50 秒で次へ: 近づいた (残り 1.66°) [VIA ] step 8 Δ= +1.2 -1.9 -2.7 +0.2 +0.8 -0.9 流した 0.50 秒で次へ: 近づいた (残り 1.93°) [SEND] pi05_chunk007_via09: send_angles (single) [ +18.35, +54.65, +9.99, -0.50, -60.29, -28.18] speed=30 wait=0.0s (pre max|Δ|=2.21°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.21° (tol 3.0°) [VIA ] step 9 Δ= +0.4 -2.2 -1.3 +0.4 +0.7 -1.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.21°（関節 j1） [008] 推論 827ms 10ステップ先 Δ= +4.8 -2.9 -9.1 +1.2 +3.2 -2.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +3.9 -2.4 -5.4 +0.9 +2.5 -1.5 流した 0.40 秒で次へ: 近づいた (残り 2.45°) [VIA ] step 5 Δ= +1.6 -2.8 -3.3 +0.4 +1.1 -1.1 流した 0.49 秒で次へ: 近づいた (残り 2.46°) [VIA ] step 8 Δ= -0.4 -2.4 -2.4 +0.2 -0.0 -1.0 流した 0.43 秒で次へ: 近づいた (残り 2.42°) [SEND] pi05_chunk008_via09: send_angles (single) [ +22.76, +53.97, +2.18, +0.36, -57.81, -29.21] speed=30 wait=0.0s (pre max|Δ|=2.54°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.54° (tol 3.0°) [VIA ] step 9 Δ= -0.4 -2.5 -1.3 +0.4 -0.1 -0.7 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.54°（関節 j1） [009] 推論 1773ms 10ステップ先 Δ=+13.4 -2.1 -5.4 +1.8 +2.9 -2.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +4.1 -3.5 -2.3 +0.8 +1.3 -0.9 流した 0.50 秒で次へ: 近づいた (残り 2.36°) [VIA ] step 5 Δ= +4.4 -2.4 -2.5 +0.4 +1.5 -0.5 流した 0.42 秒で次へ: 近づいた (残り 2.38°) [VIA ] step 8 Δ= +3.8 -1.5 -2.9 +0.1 +0.7 -1.0 流した 0.52 秒で次へ: 近づいた (残り 1.5°) [SEND] pi05_chunk009_via09: send_angles (single) [ +36.47, +54.45, -1.84, +1.77, -54.82, -30.53] speed=30 wait=0.0s (pre max|Δ|=1.76°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.67° (tol 3.0°) [VIA ] step 9 Δ= +0.9 -0.9 -1.8 +0.0 +0.3 -0.6 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.67°（関節 j2） [010] 推論 1086ms 9ステップ先 Δ= +2.1 +8.5 -2.3 +1.3 -6.6 -1.7 グリッパー→開 [VIA ] 中継点 3 点: step 2, 5, 8 [VIA ] step 2 Δ= +1.4 +3.2 -2.2 +0.7 -1.6 -0.7 流した 0.40 秒で次へ: 近づいた (残り 1.59°) [VIA ] step 5 Δ= +0.8 +3.3 -1.8 +0.7 -5.3 -0.7 流した 0.42 秒で次へ: 近づいた (残り 0.93°) [SEND] pi05_chunk010_via08: send_angles (single) [ +38.78, +64.09, -2.50, +2.96, -61.72, -31.83] speed=30 wait=0.0s (pre max|Δ|=1.52°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.94° (tol 3.0°) [VIA ] step 8 Δ= -0.2 -0.1 -0.8 +0.9 -1.5 +0.3 着いた [Pi] GRIPPER: OPEN result= None [STATE ] 目標を渡す 目標と実測の最大差 0.94°（関節 j1） [011] 推論 759ms 10ステップ先 Δ= -0.9 -15.5 -0.5 -0.2 +14.4 +0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.3 -4.5 -0.8 -0.4 +3.4 +0.6 流した 0.48 秒で次へ: 近づいた (残り 2.17°) [VIA ] step 5 Δ= -0.3 -7.7 -0.9 -0.5 +6.6 +0.4 流した 0.45 秒で次へ: 近づいた (残り 1.89°) [VIA ] step 8 Δ= -0.4 -6.2 -0.7 -0.4 +4.5 +0.3 流した 0.52 秒で次へ: 近づいた (残り 1.88°) [SEND] pi05_chunk011_via09: send_angles (single) [ +38.14, +49.53, -2.29, +3.21, -47.22, -32.03] speed=30 wait=0.0s (pre max|Δ|=3.11°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.50° (tol 3.0°) [VIA ] step 9 Δ= -0.8 -3.1 -0.6 -0.4 +1.7 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.50°（関節 j1） [012] 推論 746ms 10ステップ先 Δ=-17.1 -24.8 +0.5 -3.4 +23.5 +0.9 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -3.0 -8.2 -0.6 -1.4 +6.4 +0.4 流した 0.56 秒で次へ: 近づいた (残り 1.85°) [VIA ] step 5 Δ= -5.1 -8.1 -0.3 -1.2 +6.3 +0.4 流した 0.45 秒で次へ: 近づいた (残り 1.7°) [VIA ] step 8 Δ= -6.9 -9.5 +0.2 -1.3 +8.6 +0.5 流した 0.50 秒で次へ: 近づいた (残り 1.65°) [SEND] pi05_chunk012_via09: send_angles (single) [ +20.93, +27.28, -1.18, +0.77, -24.17, -31.48] speed=30 wait=0.0s (pre max|Δ|=4.18°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.81° (tol 3.0°) [VIA ] step 9 Δ= -2.5 -4.2 -0.5 -1.2 +3.5 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.81°（関節 j1） [013] 推論 628ms 10ステップ先 Δ= -9.5 -14.1 +0.3 -1.2 +11.6 +0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -4.7 -8.6 -0.1 -1.2 +7.1 +0.5 流した 0.47 秒で次へ: 近づいた (残り 1.43°) [VIA ] step 5 Δ= -5.2 -7.4 -0.3 -0.8 +5.7 +0.3 流した 0.45 秒で次へ: 近づいた (残り 1.36°) [VIA ] step 8 Δ= -0.6 -2.0 -0.7 -0.4 +0.3 +0.2 流した 0.42 秒で次へ: 近づいた (残り 2.03°) [SEND] pi05_chunk013_via09: send_angles (single) [ +11.61, +14.95, -0.36, +0.13, -12.94, -31.19] speed=30 wait=0.0s (pre max|Δ|=0.95°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.95° (tol 3.0°) [VIA ] step 9 Δ= +0.8 -1.0 -0.7 -0.4 -0.6 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.95°（関節 j1） [014] 推論 560ms 10ステップ先 Δ= -8.6 -10.8 -0.3 -0.5 +8.0 +0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -6.3 -8.6 -0.5 -0.5 +6.4 +0.4 流した 0.47 秒で次へ: 近づいた (残り 1.19°) [VIA ] step 5 Δ= -3.3 -4.3 -0.4 -0.7 +2.7 +0.3 流した 0.56 秒で次へ: 近づいた (残り 1.2°) [VIA ] step 8 Δ= +1.2 -0.4 -0.7 -0.5 -0.5 +0.3 流した 0.50 秒で次へ: 近づいた (残り 0.72°) [SEND] pi05_chunk014_via09: send_angles (single) [ +2.84, +5.14, +0.01, -0.11, -4.36, -30.91] speed=30 wait=0.0s (pre max|Δ|=0.78°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.83° (tol 3.0°) [VIA ] step 9 Δ= +0.3 -0.5 -0.8 -0.5 -0.3 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.83°（関節 j1） [015] 推論 748ms 10ステップ先 Δ= -2.8 -2.2 -0.9 -0.4 +0.5 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -2.9 -2.3 -0.8 -0.5 +0.7 +0.2 流した 0.49 秒で次へ: 近づいた (残り 1.37°) [VIA ] step 5 Δ= -0.1 -1.4 -0.9 -0.4 +0.7 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.37°) [VIA ] step 8 Δ= +0.2 -1.4 -0.9 -0.4 +0.6 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.42°) [SEND] pi05_chunk015_via09: send_angles (single) [ -0.31, +3.76, -0.09, -0.08, -3.53, -30.89] speed=30 wait=0.0s (pre max|Δ|=1.33°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.33° (tol 3.0°) [VIA ] step 9 Δ= +0.3 -1.3 -0.9 -0.4 +0.4 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.33°（関節 j1） [016] 推論 1631ms 10ステップ先 Δ= -0.5 -1.7 -1.0 -0.4 +0.9 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.5 -1.5 -0.9 -0.4 +0.7 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.46°) [VIA ] step 5 Δ= -0.4 -1.5 -0.9 -0.4 +0.4 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.52°) [VIA ] step 8 Δ= -0.6 -1.7 -0.9 -0.4 +0.4 +0.3 流した 0.51 秒で次へ: 近づいた (残り 1.58°) [SEND] pi05_chunk016_via09: send_angles (single) [ -1.12, +3.43, -0.16, -0.01, -3.09, -30.86] speed=30 wait=0.0s (pre max|Δ|=1.57°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.57° (tol 3.0°) [VIA ] step 9 Δ= -0.5 -1.6 -1.0 -0.4 +0.5 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.57°（関節 j1） [017] 推論 649ms 10ステップ先 Δ= -0.4 -1.5 -0.7 -0.2 +0.5 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.3 -1.5 -0.9 -0.2 +0.6 +0.3 流した 0.42 秒で次へ: 近づいた (残り 1.5°) [VIA ] step 5 Δ= -0.4 -1.6 -0.9 -0.3 +0.2 +0.3 流した 0.42 秒で次へ: 近づいた (残り 1.56°) [VIA ] step 8 Δ= -0.3 -1.5 -0.8 -0.3 +0.1 +0.3 流した 0.50 秒で次へ: 近づいた (残り 1.49°) [SEND] pi05_chunk017_via09: send_angles (single) [ -1.01, +3.48, +0.07, +0.03, -3.12, -30.83] speed=30 wait=0.0s (pre max|Δ|=1.52°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.52° (tol 3.0°) [VIA ] step 9 Δ= -0.4 -1.5 -0.7 -0.2 +0.1 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.52°（関節 j1） [018] 推論 819ms 10ステップ先 Δ= -0.8 -1.5 -0.7 -0.2 +0.5 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.7 -1.5 -0.7 -0.2 +0.4 +0.2 流した 0.48 秒で次へ: 近づいた (残り 1.55°) [VIA ] step 5 Δ= -0.8 -1.6 -0.7 -0.2 +0.5 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.56°) [VIA ] step 8 Δ= -0.3 -1.6 -0.7 -0.2 +0.4 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.57°) [SEND] pi05_chunk018_via09: send_angles (single) [ -1.41, +3.46, +0.08, +0.01, -2.74, -30.82] speed=30 wait=0.0s (pre max|Δ|=1.54°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.54° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -1.5 -0.7 -0.2 +0.2 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.54°（関節 j1） [019] 推論 1689ms 10ステップ先 Δ= -0.2 -1.7 -0.7 -0.3 +0.9 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.3 -1.6 -0.7 -0.2 +0.5 +0.2 流した 0.48 秒で次へ: 近づいた (残り 1.56°) [VIA ] step 5 Δ= -0.3 -1.6 -0.7 -0.2 +0.4 +0.2 流した 0.48 秒で次へ: 近づいた (残り 1.61°) [VIA ] step 8 Δ= -0.2 -1.6 -0.7 -0.3 +0.4 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.61°) [SEND] pi05_chunk019_via09: send_angles (single) [ -1.56, +3.32, +0.07, +0.01, -2.13, -30.82] speed=30 wait=0.0s (pre max|Δ|=1.68°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.68° (tol 3.0°) [VIA ] step 9 Δ= -0.2 -1.7 -0.7 -0.3 +0.3 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.68°（関節 j1） [020] 推論 577ms 10ステップ先 Δ= -0.2 -1.5 -0.6 -0.3 -0.0 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.3 -1.5 -0.7 -0.2 +0.3 +0.2 流した 0.48 秒で次へ: 近づいた (残り 1.51°) [VIA ] step 5 Δ= -0.2 -1.4 -0.6 -0.3 -0.0 +0.2 流した 0.49 秒で次へ: 近づいた (残り 1.44°) [VIA ] step 8 Δ= -0.2 -1.5 -0.5 -0.3 -0.1 +0.3 流した 0.50 秒で次へ: 近づいた (残り 1.52°) [SEND] pi05_chunk020_via09: send_angles (single) [ -1.52, +3.47, +0.20, -0.03, -2.48, -30.76] speed=30 wait=0.0s (pre max|Δ|=1.53°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.53° (tol 3.0°) [VIA ] step 9 Δ= -0.2 -1.5 -0.6 -0.3 -0.0 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.53°（関節 j1） [021] 推論 803ms 10ステップ先 Δ= -0.3 -1.6 -0.6 -0.2 +0.2 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.2 -1.5 -0.5 -0.2 +0.1 +0.2 流した 0.48 秒で次へ: 近づいた (残り 1.51°) [VIA ] step 5 Δ= -0.1 -1.3 -0.5 -0.2 -0.1 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.33°) [VIA ] step 8 Δ= -0.0 -1.5 -0.5 -0.2 -0.1 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.51°) [SEND] pi05_chunk021_via09: send_angles (single) [ -1.62, +3.40, +0.23, +0.01, -2.28, -30.78] speed=30 wait=0.0s (pre max|Δ|=1.60°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.60° (tol 3.0°) [VIA ] step 9 Δ= -0.3 -1.6 -0.6 -0.2 +0.2 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.60°（関節 j1） [022] 推論 1544ms 10ステップ先 Δ= -0.2 -1.8 -0.4 -0.2 +0.8 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.1 -1.6 -0.5 -0.2 +0.5 +0.3 流した 0.51 秒で次へ: 近づいた (残り 1.6°) [VIA ] step 5 Δ= -0.1 -1.6 -0.4 -0.3 +0.3 +0.2 流した 0.46 秒で次へ: 近づいた (残り 1.64°) [VIA ] step 8 Δ= -0.1 -1.8 -0.4 -0.2 +0.5 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.41°) [SEND] pi05_chunk022_via09: send_angles (single) [ -1.53, +3.22, +0.38, +0.02, -1.64, -30.73] speed=30 wait=0.0s (pre max|Δ|=1.43°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.43° (tol 3.0°) [VIA ] step 9 Δ= -0.2 -1.4 -0.4 -0.2 +0.5 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.43°（関節 j1） [023] 推論 569ms 10ステップ先 Δ= -0.0 -1.5 -0.3 -0.3 +0.5 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.0 -1.3 -0.4 -0.2 +0.5 +0.2 流した 0.52 秒で次へ: 近づいた (残り 1.33°) [VIA ] step 5 Δ= -0.0 -1.4 -0.3 -0.2 +0.2 +0.2 流した 0.40 秒で次へ: 近づいた (残り 1.37°) [VIA ] step 8 Δ= +0.0 -1.4 -0.3 -0.2 +0.3 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.44°) [SEND] pi05_chunk023_via09: send_angles (single) [ -1.33, +3.14, +0.46, +0.01, -1.44, -30.69] speed=30 wait=0.0s (pre max|Δ|=1.43°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.43° (tol 3.0°) [VIA ] step 9 Δ= -0.0 -1.4 -0.3 -0.3 +0.3 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.43°（関節 j1） [024] 推論 847ms 10ステップ先 Δ= -0.1 -1.5 -0.3 -0.3 +0.3 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.0 -1.4 -0.3 -0.3 +0.3 +0.2 流した 0.51 秒で次へ: 近づいた (残り 1.35°) [VIA ] step 5 Δ= -0.1 -1.3 -0.7 -0.3 +0.2 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.32°) [VIA ] step 8 Δ= -0.1 -1.4 -0.7 -0.3 +0.3 +0.3 流した 0.50 秒で次へ: 近づいた (残り 1.43°) [SEND] pi05_chunk024_via09: send_angles (single) [ -1.41, +3.10, +0.53, -0.01, -1.45, -30.68] speed=30 wait=0.0s (pre max|Δ|=1.47°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.47° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -1.5 -0.7 -0.3 +0.3 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.47°（関節 j1） [025] 推論 625ms 10ステップ先 Δ= -0.0 -1.5 -0.7 -0.3 +0.5 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.1 -1.4 -0.7 -0.3 +0.3 +0.3 流した 0.50 秒で次へ: 近づいた (残り 1.35°) [VIA ] step 5 Δ= -0.1 -1.4 -0.7 -0.3 +0.3 +0.2 流した 0.41 秒で次へ: 近づいた (残り 1.44°) [VIA ] step 8 Δ= -0.1 -1.4 -0.7 -0.3 +0.4 +0.3 流した 0.50 秒で次へ: 近づいた (残り 1.45°) [SEND] pi05_chunk025_via09: send_angles (single) [ -1.34, +3.10, +0.57, -0.02, -1.18, -30.65] speed=30 wait=0.0s (pre max|Δ|=1.47°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.47° (tol 3.0°) [VIA ] step 9 Δ= -0.0 -1.5 -0.7 -0.3 +0.5 +0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.47°（関節 j1） [026] 推論 711ms 10ステップ先 Δ= -0.2 -1.5 -0.6 -0.2 +0.4 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.1 -1.4 -0.6 -0.2 +0.3 +0.2 流した 0.49 秒で次へ: 近づいた (残り 1.43°) [VIA ] step 5 Δ= -0.0 -1.4 -0.6 -0.3 +0.3 +0.2 流した 0.49 秒で次へ: 近づいた (残り 1.43°) [VIA ] step 8 Δ= -0.1 -1.5 -0.6 -0.3 +0.3 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.49°) [SEND] pi05_chunk026_via09: send_angles (single) [ -1.46, +3.06, +0.66, +0.01, -1.11, -30.63] speed=30 wait=0.0s (pre max|Δ|=1.51°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.51° (tol 3.0°) [VIA ] step 9 Δ= -0.2 -1.5 -0.6 -0.2 +0.3 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.51°（関節 j1） [027] 推論 1608ms 10ステップ先 Δ= -0.1 -1.4 -0.5 -0.3 +0.2 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.1 -1.4 -0.5 -0.3 +0.4 +0.2 流した 0.52 秒で次へ: 近づいた (残り 1.41°) [VIA ] step 5 Δ= -0.0 -1.4 -0.5 -0.3 +0.1 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.38°) [VIA ] step 8 Δ= -0.1 -1.3 -0.5 -0.3 +0.1 +0.2 流した 0.43 秒で次へ: 近づいた (残り 1.33°) [SEND] pi05_chunk027_via09: send_angles (single) [ -1.44, +3.21, +0.76, -0.00, -1.19, -30.59] speed=30 wait=0.0s (pre max|Δ|=1.36°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.36° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -1.4 -0.5 -0.3 +0.1 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.36°（関節 j1） [028] 推論 661ms 10ステップ先 Δ= -0.1 -1.4 -0.5 -0.3 +0.0 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.3 -1.2 -0.4 -0.3 +0.2 +0.3 流した 0.50 秒で次へ: 近づいた (残り 1.17°) [VIA ] step 5 Δ= -0.1 -1.1 -0.5 -0.3 +0.0 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.14°) [VIA ] step 8 Δ= -0.2 -1.3 -0.5 -0.3 +0.0 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.29°) [SEND] pi05_chunk028_via09: send_angles (single) [ -1.42, +3.21, +0.70, -0.04, -1.29, -30.60] speed=30 wait=0.0s (pre max|Δ|=1.36°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.36° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -1.4 -0.5 -0.3 +0.0 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.36°（関節 j1） [029] 推論 1559ms 10ステップ先 Δ= -0.1 -1.4 -0.5 -0.3 -0.0 +0.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.1 -1.3 -0.5 -0.3 +0.2 +0.3 流した 0.42 秒で次へ: 近づいた (残り 1.27°) [VIA ] step 5 Δ= -0.0 -1.4 -0.5 -0.3 -0.0 +0.2 流した 0.49 秒で次へ: 近づいた (残り 1.35°) [VIA ] step 8 Δ= -0.1 -1.4 -0.5 -0.3 +0.0 +0.2 流した 0.48 秒で次へ: 近づいた (残り 1.4°) [SEND] pi05_chunk029_via09: send_angles (single) [ -1.37, +3.15, +0.76, -0.06, -1.35, -30.58] speed=30 wait=0.0s (pre max|Δ|=1.42°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.42° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -1.4 -0.5 -0.3 -0.0 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.42°（関節 j1） [030] 推論 585ms 10ステップ先 Δ= -1.3 -1.1 -0.5 -0.3 -0.3 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.1 -1.2 -0.5 -0.3 -0.1 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.16°) [VIA ] step 5 Δ= -0.1 -1.1 -0.5 -0.3 -0.1 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.1°) [VIA ] step 8 Δ= -0.0 -1.1 -0.5 -0.4 -0.3 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.1°) [SEND] pi05_chunk030_via09: send_angles (single) [ -2.64, +3.45, +0.77, -0.08, -1.65, -30.59] speed=30 wait=0.0s (pre max|Δ|=1.12°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.12° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -1.1 -0.5 -0.3 -0.3 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.12°（関節 j1） [031] 推論 624ms 10ステップ先 Δ= -0.7 -1.0 -0.4 -0.4 -0.3 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.6 -1.1 -0.4 -0.3 -0.3 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.07°) [VIA ] step 5 Δ= -0.5 -1.1 -0.6 -0.3 -0.2 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.12°) [VIA ] step 8 Δ= -0.6 -1.1 -0.6 -0.3 -0.2 +0.2 流した 0.52 秒で次へ: 近づいた (残り 1.14°) [SEND] pi05_chunk031_via09: send_angles (single) [ -3.19, +3.53, +0.80, -0.10, -1.61, -30.58] speed=30 wait=0.0s (pre max|Δ|=1.04°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.04° (tol 3.0°) [VIA ] step 9 Δ= -0.7 -1.0 -0.6 -0.4 -0.3 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.04°（関節 j1） [032] 推論 600ms 10ステップ先 Δ= -1.3 -1.4 -0.6 -0.3 -0.0 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.1 -1.1 -0.6 -0.3 -0.2 +0.2 流した 0.52 秒で次へ: 近づいた (残り 1.1°) [VIA ] step 5 Δ= -0.2 -1.3 -0.6 -0.3 -0.2 +0.2 流した 0.41 秒で次へ: 近づいた (残り 1.26°) [VIA ] step 8 Δ= -0.3 -1.4 -0.6 -0.4 -0.0 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.36°) [SEND] pi05_chunk032_via09: send_angles (single) [ -3.81, +3.13, +0.77, -0.09, -1.36, -30.57] speed=30 wait=0.0s (pre max|Δ|=1.44°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.44° (tol 3.0°) [VIA ] step 9 Δ= -0.3 -1.4 -0.6 -0.3 -0.0 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.44°（関節 j1） [033] 推論 669ms 10ステップ先 Δ= -1.0 -1.5 -0.7 -0.2 +0.0 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.8 -1.4 -0.6 -0.2 +0.1 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.4°) [VIA ] step 5 Δ= -0.3 -1.4 -0.7 -0.2 +0.0 +0.2 流した 0.51 秒で次へ: 近づいた (残り 1.39°) [VIA ] step 8 Δ= -0.3 -1.5 -0.7 -0.2 +0.0 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.48°) [SEND] pi05_chunk033_via09: send_angles (single) [ -4.51, +3.10, +0.66, -0.01, -1.27, -30.54] speed=30 wait=0.0s (pre max|Δ|=1.47°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.47° (tol 3.0°) [VIA ] step 9 Δ= -0.3 -1.5 -0.7 -0.2 +0.0 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.47°（関節 j1） [034] 推論 1571ms 10ステップ先 Δ= -0.5 -1.4 -0.8 -0.1 -0.0 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.6 -1.4 -0.7 -0.1 +0.2 +0.2 流した 0.41 秒で次へ: 近づいた (残り 1.4°) [VIA ] step 5 Δ= -0.5 -1.3 -0.8 -0.0 -0.1 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.35°) [VIA ] step 8 Δ= -0.6 -1.4 -0.8 -0.0 +0.0 +0.2 流した 0.40 秒で次へ: 近づいた (残り 1.37°) [SEND] pi05_chunk034_via09: send_angles (single) [ -4.70, +3.19, +0.64, +0.12, -1.33, -30.55] speed=30 wait=0.0s (pre max|Δ|=1.38°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.38° (tol 3.0°) [VIA ] step 9 Δ= -0.5 -1.4 -0.8 -0.1 -0.0 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.38°（関節 j1） [035] 推論 751ms 10ステップ先 Δ= -2.5 -1.7 -0.7 +0.0 -0.3 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.5 -1.7 -0.8 -0.1 +0.2 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.73°) [VIA ] step 5 Δ= -0.3 -1.8 -0.8 -0.1 -0.0 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.59°) [VIA ] step 8 Δ= -0.8 -1.6 -0.7 -0.0 -0.2 +0.2 流した 0.47 秒で次へ: 近づいた (残り 1.61°) [SEND] pi05_chunk035_via09: send_angles (single) [ -6.69, +2.87, +0.66, +0.17, -1.60, -30.55] speed=30 wait=0.0s (pre max|Δ|=1.52°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.52° (tol 3.0°) [VIA ] step 9 Δ= -0.3 -1.5 -0.7 +0.0 -0.3 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.52°（関節 j1） [036] 推論 1556ms 10ステップ先 Δ= -1.8 -1.9 -0.8 -0.0 -0.2 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.6 -1.9 -0.8 -0.0 -0.1 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.35°) [VIA ] step 5 Δ= +0.0 -1.3 -0.8 -0.0 -0.1 +0.2 流した 0.42 秒で次へ: 近づいた (残り 1.28°) [VIA ] step 8 Δ= +0.1 -1.4 -0.8 -0.0 -0.2 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.39°) [SEND] pi05_chunk036_via09: send_angles (single) [ -8.16, +2.45, +0.55, +0.15, -1.49, -30.53] speed=30 wait=0.0s (pre max|Δ|=1.41°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.41° (tol 3.0°) [VIA ] step 9 Δ= +0.1 -1.4 -0.8 -0.0 -0.2 +0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.41°（関節 j1） [037] 推論 829ms 10ステップ先 Δ= -2.0 -1.6 -0.9 -0.1 +0.1 +0.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.6 -1.7 -0.9 -0.1 +0.1 +0.2 流した 0.49 秒で次へ: 近づいた (残り 1.66°) [VIA ] step 5 Δ= -0.1 -1.7 -0.9 +0.0 +0.1 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.67°) [VIA ] step 8 Δ= -0.4 -1.7 -0.9 +0.0 +0.1 +0.2 流した 0.50 秒で次へ: 近づいた (残り 1.72°) [SEND] pi05_chunk037_via09: send_angles (single) [ -10.25, +2.21, +0.48, +0.06, -1.17, -30.56] speed=30 wait=0.0s (pre max|Δ|=1.65°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.65° (tol 3.0°) [VIA ] step 9 Δ= -0.4 -1.6 -0.9 -0.0 +0.1 +0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.65°（関節 j1） [038] 推論 821ms 10ステップ先 Δ= -3.2 -2.1 -1.0 -0.1 +0.3 +0.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -2.1 -2.1 -1.0 -0.1 +0.5 +0.1 流した 0.46 秒で次へ: 近づいた (残り 1.39°) [VIA ] step 5 Δ= -0.3 -1.4 -1.0 +0.0 +0.2 +0.1 流した 0.48 秒で次へ: 近づいた (残り 1.37°) [VIA ] step 8 Δ= -0.5 -1.4 -1.0 -0.0 +0.1 +0.0 流した 0.50 秒で次へ: 近づいた (残り 1.4°) [SEND] pi05_chunk038_via09: send_angles (single) [ -13.03, +1.76, +0.40, -0.02, -1.05, -30.63] speed=30 wait=0.0s (pre max|Δ|=1.40°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.40° (tol 3.0°) [VIA ] step 9 Δ= -0.7 -1.4 -1.0 -0.0 +0.1 +0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.40°（関節 j1） [039] 推論 679ms 10ステップ先 Δ= -1.4 -1.6 -1.1 -0.1 +0.1 -0.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.1 -1.5 -1.0 -0.1 +0.1 +0.0 流した 0.40 秒で次へ: 近づいた (残り 1.47°) [VIA ] step 5 Δ= -0.1 -1.5 -1.1 -0.1 +0.0 -0.0 流した 0.48 秒で次へ: 近づいた (残り 1.48°) [VIA ] step 8 Δ= -0.3 -1.6 -1.1 -0.1 +0.1 -0.0 流した 0.50 秒で次へ: 近づいた (残り 1.59°) [SEND] pi05_chunk039_via09: send_angles (single) [ -14.45, +1.59, +0.32, -0.12, -1.09, -30.70] speed=30 wait=0.0s (pre max|Δ|=1.57°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.57° (tol 3.0°) [VIA ] step 9 Δ= -0.4 -1.6 -1.1 -0.1 +0.1 -0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.57°（関節 j1） [040] 推論 577ms 10ステップ先 Δ= -1.7 -1.7 -1.0 -0.2 -0.6 -0.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.6 -1.7 -1.1 -0.1 -0.0 -0.0 流した 0.46 秒で次へ: 近づいた (残り 1.61°) [VIA ] step 5 Δ= -0.1 -1.6 -1.1 -0.2 -0.2 -0.0 流した 0.48 秒で次へ: 近づいた (残り 1.59°) [VIA ] step 8 Δ= +0.0 -1.7 -1.0 -0.2 -0.6 -0.0 流した 0.50 秒で次へ: 近づいた (残り 1.65°) [SEND] pi05_chunk040_via09: send_angles (single) [ -15.78, +1.45, +0.40, -0.23, -1.74, -30.69] speed=30 wait=0.0s (pre max|Δ|=1.62°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.62° (tol 3.0°) [VIA ] step 9 Δ= +0.0 -1.6 -1.0 -0.2 -0.6 -0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.62°（関節 j1） [041] 推論 617ms 10ステップ先 Δ= -1.2 -1.7 -0.9 -0.3 -1.2 -0.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.9 -1.8 -1.0 -0.3 -0.6 -0.0 流した 0.46 秒で次へ: 近づいた (残り 1.82°) [VIA ] step 5 Δ= -0.2 -1.9 -1.0 -0.2 -0.6 -0.0 流した 0.48 秒で次へ: 近づいた (残り 1.44°) [VIA ] step 8 Δ= -0.3 -1.3 -0.9 -0.2 -1.2 -0.0 流した 0.50 秒で次へ: 近づいた (残り 1.28°) [SEND] pi05_chunk041_via09: send_angles (single) [ -16.98, +1.37, +0.49, -0.32, -2.38, -30.70] speed=30 wait=0.0s (pre max|Δ|=1.26°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.26° (tol 3.0°) [VIA ] step 9 Δ= -0.3 -1.3 -0.9 -0.2 -1.2 -0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.26°（関節 j1） [042] 推論 667ms 10ステップ先 Δ= -1.3 -1.4 -0.9 -0.3 -1.2 -0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.4 -1.3 -0.9 -0.3 -1.1 -0.0 流した 0.46 秒で次へ: 近づいた (残り 1.31°) [VIA ] step 5 Δ= -0.1 -1.2 -0.9 -0.3 -1.3 -0.1 流した 0.48 秒で次へ: 近づいた (残り 1.25°) [VIA ] step 8 Δ= -0.2 -1.4 -0.9 -0.3 -1.2 -0.1 流した 0.50 秒で次へ: 近づいた (残り 1.42°) [SEND] pi05_chunk042_via09: send_angles (single) [ -18.03, +1.22, +0.50, -0.37, -2.30, -30.73] speed=30 wait=0.0s (pre max|Δ|=1.41°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.41° (tol 3.0°) [VIA ] step 9 Δ= -0.2 -1.4 -0.9 -0.3 -1.1 -0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.41°（関節 j1） [043] 推論 1562ms 10ステップ先 Δ= -0.9 -1.8 -0.8 -0.3 -1.1 -0.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.9 -1.5 -0.8 -0.3 -0.2 -0.0 流した 0.48 秒で次へ: 近づいた (残り 1.54°) [VIA ] step 5 Δ= -0.0 -1.6 -0.8 -0.3 -0.3 -0.0 流した 0.48 秒で次へ: 近づいた (残り 1.64°) [VIA ] step 8 Δ= +0.0 -1.8 -0.8 -0.3 -0.3 -0.0 流した 0.50 秒で次へ: 近づいた (残り 1.79°) [SEND] pi05_chunk043_via09: send_angles (single) [ -18.77, +0.84, +0.58, -0.38, -2.37, -30.72] speed=30 wait=0.0s (pre max|Δ|=1.79°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.62° (tol 3.0°) [VIA ] step 9 Δ= -0.1 -1.8 -0.8 -0.3 -0.3 -0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.62°（関節 j1） [044] 推論 562ms 10ステップ先 Δ= -0.4 -0.9 -0.9 -0.3 -0.7 -0.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.5 -1.0 -0.9 -0.2 -0.7 -0.0 流した 0.50 秒で次へ: 近づいた (残り 1.03°) [VIA ] step 5 Δ= -0.4 -0.4 -1.0 -0.2 -0.7 -0.0 流した 0.42 秒で次へ: 近づいた (残り 0.96°) [VIA ] step 8 Δ= -0.3 -1.2 -0.9 -0.3 -0.5 -0.0 流した 0.51 秒で次へ: 近づいた (残り 1.18°) [SEND] pi05_chunk044_via09: send_angles (single) [ -19.13, +1.59, +0.47, -0.35, -2.76, -30.71] speed=30 wait=0.0s (pre max|Δ|=1.13°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.13° (tol 3.0°) [VIA ] step 9 Δ= -0.4 -1.1 -0.9 -0.3 -0.5 -0.0 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.13°（関節 j1） [045] 推論 659ms 10ステップ先 Δ= -1.6 -1.0 -0.9 -0.3 -2.0 -0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.5 -1.0 -0.9 -0.3 -1.2 -0.0 流した 0.50 秒で次へ: 近づいた (残り 1.01°) [VIA ] step 5 Δ= +0.2 -1.0 -0.8 -0.3 +0.4 -0.1 流した 0.42 秒で次へ: 近づいた (残り 0.97°) [VIA ] step 8 Δ= +0.3 -0.9 -0.8 -0.4 +0.3 -0.1 流した 0.50 秒で次へ: 近づいた (残り 0.91°) [SEND] pi05_chunk045_via09: send_angles (single) [ -20.35, +1.76, +0.53, -0.42, -4.29, -30.74] speed=30 wait=0.0s (pre max|Δ|=0.96°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.96° (tol 3.0°) [VIA ] step 9 Δ= +0.2 -1.0 -0.9 -0.3 +0.3 -0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.96°（関節 j1） [046] 推論 1577ms 10ステップ先 Δ= -0.6 -0.3 -0.7 -0.6 -1.8 -0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.3 -0.6 -0.8 -0.4 -0.6 -0.2 流した 0.42 秒で次へ: 近づいた (残り 0.79°) [VIA ] step 5 Δ= -0.5 -0.1 -0.7 -0.5 -0.7 -0.2 流した 0.49 秒で次へ: 近づいた (残り 0.89°) [VIA ] step 8 Δ= -0.8 -1.0 -0.6 -0.4 +0.3 -0.2 流した 0.50 秒で次へ: 近づいた (残り 0.97°) [SEND] pi05_chunk046_via09: send_angles (single) [ -21.18, +2.46, +0.73, -0.72, -6.34, -30.75] speed=30 wait=0.0s (pre max|Δ|=1.05°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.05° (tol 3.0°) [VIA ] step 9 Δ= +0.4 -1.0 -0.7 -0.3 +0.5 -0.2 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.05°（関節 j1） [047] 推論 561ms 10ステップ先 Δ= -4.5 +12.6 -0.7 +0.1 -17.0 -0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -1.7 +1.2 -0.7 -0.4 -2.8 -0.2 流した 0.50 秒で次へ: 近づいた (残り 0.84°) [VIA ] step 5 Δ= -1.6 +3.7 -0.8 +0.1 -5.0 -0.3 流した 0.44 秒で次へ: 近づいた (残り 1.0°) [VIA ] step 8 Δ= -1.4 +4.9 -0.7 +0.7 -7.1 -0.5 流した 0.48 秒で次へ: 近づいた (残り 1.0°) [SEND] pi05_chunk047_via09: send_angles (single) [ -26.05, +16.11, +0.74, -0.30, -23.85, -31.00] speed=30 wait=0.0s (pre max|Δ|=1.44°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.94° (tol 3.0°) [VIA ] step 9 Δ= -0.4 +0.0 -0.7 +0.8 -1.4 -0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 0.94°（関節 j1） [048] 推論 562ms 10ステップ先 Δ=-15.4 +21.5 +0.5 +1.6 -26.3 -0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -6.5 +6.4 -0.0 +1.0 -8.3 -0.5 流した 0.48 秒で次へ: 近づいた (残り 1.15°) [VIA ] step 5 Δ= -5.3 +6.2 -0.4 +0.6 -9.4 -0.4 流した 0.49 秒で次へ: 近づいた (残り 1.17°) [VIA ] step 8 Δ= -3.0 +4.9 -0.1 -0.1 -7.2 -0.4 流した 0.52 秒で次へ: 近づいた (残り 1.18°) [SEND] pi05_chunk048_via09: send_angles (single) [ -41.18, +38.57, +1.94, +0.44, -50.27, -31.00] speed=30 wait=0.0s (pre max|Δ|=1.85°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.15° (tol 3.0°) [VIA ] step 9 Δ= -1.1 +0.5 -0.9 +0.2 -1.8 -0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.15°（関節 j1） [049] 推論 651ms 10ステップ先 Δ=-11.4 +14.1 -0.4 +1.1 -14.0 -0.4 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -6.6 +5.4 -0.6 +0.0 -7.9 -0.4 流した 0.41 秒で次へ: 近づいた (残り 1.26°) [VIA ] step 5 Δ= -3.7 +3.9 -0.5 -0.3 -5.4 -0.4 流した 0.44 秒で次へ: 近づいた (残り 1.2°) [VIA ] step 8 Δ= -1.2 +1.3 -0.5 +0.6 -0.9 -0.6 流した 0.60 秒で次へ: 近づいた (残り 1.3°) [SEND] pi05_chunk049_via09: send_angles (single) [ -52.63, +53.78, +2.38, +1.72, -64.39, -31.02] speed=30 wait=0.0s (pre max|Δ|=0.59°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.06° (tol 3.0°) [VIA ] step 9 Δ= +0.3 -0.4 -0.4 +0.3 -0.6 -0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.06°（関節 j1） [050] 推論 644ms 10ステップ先 Δ= -0.9 +3.4 -0.4 +0.7 -2.3 -0.5 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -0.7 +1.7 -0.5 +0.3 -1.7 -0.5 流した 0.52 秒で次へ: 近づいた (残り 1.17°) [VIA ] step 5 Δ= +0.2 -0.4 -0.5 +0.2 -0.1 -0.5 送らず (0.5° 以下) [VIA ] step 8 Δ= +0.1 +0.1 -0.4 +0.4 -0.4 -0.5 送らず (0.5° 以下) [SEND] pi05_chunk050_via09: send_angles (single) [ -53.70, +58.22, +2.45, +2.08, -66.22, -31.10] speed=30 wait=0.0s (pre max|Δ|=0.66°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.19° (tol 3.0°) [VIA ] step 9 Δ= +0.0 +0.5 -0.4 +0.6 -0.7 -0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.19°（関節 j1） [051] 推論 1572ms 9ステップ先 Δ= -0.6 +1.9 -0.4 +1.1 +0.6 -0.5 グリッパー→閉 [VIA ] 中継点 3 点: step 2, 5, 8 [VIA ] step 2 Δ= -0.6 +1.3 -0.4 +0.6 +0.1 -0.5 流した 0.58 秒で次へ: 近づいた (残り 1.13°) [VIA ] step 5 Δ= -0.7 -0.8 -0.4 +0.8 +0.8 -0.5 流した 0.50 秒で次へ: 近づいた (残り 1.11°) [SEND] pi05_chunk051_via08: send_angles (single) [ -54.34, +61.28, +2.31, +2.59, -65.85, -31.12] speed=30 wait=0.0s (pre max|Δ|=0.94°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=0.94° (tol 3.0°) [VIA ] step 8 Δ= -0.6 -0.9 -0.4 +0.2 +0.9 -0.5 着いた [Pi] GRIPPER: VALUE=25 speed=100 result= None [STATE ] 目標を渡す 目標と実測の最大差 0.94°（関節 j4） [052] 推論 640ms 10ステップ先 Δ=+17.1 -7.5 +2.4 +3.0 +0.4 -1.3 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +2.3 -2.1 -0.0 +0.8 -0.1 -0.7 流した 0.43 秒で次へ: 近づいた (残り 2.14°) [VIA ] step 5 Δ= +5.2 -4.2 +0.5 +0.7 -0.7 -0.7 流した 0.50 秒で次へ: 近づいた (残り 2.07°) [VIA ] step 8 Δ= +7.3 -4.7 +0.7 +0.4 +0.2 -1.0 流した 0.57 秒で次へ: 近づいた (残り 2.02°) [SEND] pi05_chunk052_via09: send_angles (single) [ -36.69, +54.72, +5.10, +5.41, -66.40, -31.84] speed=30 wait=0.0s (pre max|Δ|=2.67°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.58° (tol 3.0°) [VIA ] step 9 Δ= +2.4 -2.7 -0.3 -0.1 +0.5 -0.8 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.58°（関節 j1） [053] 推論 642ms 10ステップ先 Δ=+28.4 -7.5 +0.7 +2.5 +3.7 -1.7 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +8.8 -4.3 -0.0 +0.7 +1.5 -1.1 流した 0.52 秒で次へ: 近づいた (残り 2.34°) [VIA ] step 5 Δ= +8.3 -4.1 +0.3 +1.0 +2.4 -0.9 流した 0.44 秒で次へ: 近づいた (残り 2.32°) [VIA ] step 8 Δ= +8.9 -3.7 +0.6 +0.9 +3.0 -0.7 流した 0.60 秒で次へ: 近づいた (残り 2.16°) [SEND] pi05_chunk053_via09: send_angles (single) [ -8.41, +49.84, +6.03, +8.22, -63.22, -32.95] speed=30 wait=0.0s (pre max|Δ|=2.27°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.27° (tol 3.0°) [VIA ] step 9 Δ= +2.0 -2.3 -0.5 +0.1 +1.6 -0.5 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.27°（関節 j1） [054] 推論 746ms 10ステップ先 Δ=+29.3 -6.5 -0.1 -0.1 +4.7 -0.8 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +9.0 -3.5 -0.1 -0.2 +2.3 -0.5 流した 0.51 秒で次へ: 近づいた (残り 2.19°) [VIA ] step 5 Δ= +9.2 -3.5 -0.5 -0.0 +2.2 -0.4 流した 0.55 秒で次へ: 近づいた (残り 2.11°) [VIA ] step 8 Δ= +8.8 -3.5 -0.5 +0.2 +1.9 -0.6 流した 0.51 秒で次へ: 近づいた (残り 2.12°) [SEND] pi05_chunk054_via09: send_angles (single) [ +20.88, +45.65, +6.45, +8.45, -59.85, -33.20] speed=30 wait=0.0s (pre max|Δ|=2.33°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.25° (tol 3.0°) [VIA ] step 9 Δ= +2.2 -2.3 -0.5 -0.1 +0.7 -0.3 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.25°（関節 j1） [055] 推論 1668ms 10ステップ先 Δ=+13.7 +3.0 -2.8 -0.3 -1.1 -0.8 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +6.4 -3.3 -0.7 -1.0 +2.3 -0.4 流した 0.50 秒で次へ: 近づいた (残り 2.19°) [VIA ] step 5 Δ= +5.7 -1.8 -1.0 -0.2 +1.0 -0.4 流した 0.46 秒で次へ: 近づいた (残り 1.78°) [VIA ] step 8 Δ= +1.3 +3.0 -2.4 +0.5 -3.0 -0.6 流した 0.45 秒で次へ: 近づいた (残り 2.18°) [SEND] pi05_chunk055_via09: send_angles (single) [ +34.48, +50.90, +4.12, +8.69, -61.70, -33.68] speed=30 wait=0.0s (pre max|Δ|=2.82°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.85° (tol 3.0°) [VIA ] step 9 Δ= -0.1 +0.0 -1.8 +0.3 -2.8 -0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.85°（関節 j4） [056] 推論 561ms 10ステップ先 Δ= +7.8 +9.1 -7.0 +0.2 -3.2 -1.0 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +5.5 -1.2 -2.2 -0.0 -0.7 -0.4 流した 0.54 秒で次へ: 近づいた (残り 1.33°) [VIA ] step 5 Δ= +2.0 +2.3 -3.5 -0.2 -1.2 -0.6 流した 0.52 秒で次へ: 近づいた (残り 1.28°) [VIA ] step 8 Δ= +0.2 +4.2 -3.5 -0.0 -2.7 -0.6 流した 0.44 秒で次へ: 近づいた (残り 1.16°) [SEND] pi05_chunk056_via09: send_angles (single) [ +42.29, +61.15, -1.39, +8.70, -63.02, -34.39] speed=30 wait=0.0s (pre max|Δ|=1.59°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.47° (tol 3.0°) [VIA ] step 9 Δ= +0.3 +0.2 -1.5 -0.2 -1.6 -0.4 着いた [STATE ] 目標を渡す 目標と実測の最大差 1.47°（関節 j2） [057] 推論 565ms 2ステップ先 Δ= +0.4 -0.8 -1.7 -0.2 -1.2 -0.4 グリッパー→開 [VIA ] 中継点 1 点: step 1 [SEND] pi05_chunk057_via01: send_angles (single) [ +42.42, +61.52, -1.61, +8.72, -63.55, -34.48] speed=30 wait=0.0s (pre max|Δ|=1.69°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.69° (tol 3.0°) [VIA ] step 1 Δ= +0.4 -0.8 -1.7 -0.2 -1.2 -0.4 着いた [Pi] GRIPPER: OPEN result= None [STATE ] 目標を渡す 目標と実測の最大差 1.69°（関節 j2） [058] 推論 689ms 10ステップ先 Δ= +0.5 -16.6 +4.4 -0.7 +8.9 -0.1 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= +0.7 -4.6 -0.5 -0.4 +1.4 -0.3 流した 0.42 秒で次へ: 近づいた (残り 2.01°) [VIA ] step 5 Δ= +0.5 -7.5 +2.1 -0.6 +3.9 -0.3 流した 0.52 秒で次へ: 近づいた (残り 2.3°) [VIA ] step 8 Δ= +0.5 -7.1 +1.4 -0.7 +5.9 -0.2 流した 0.44 秒で次へ: 近づいた (残り 2.13°) [SEND] pi05_chunk058_via09: send_angles (single) [ +42.55, +45.82, +4.49, +8.26, -53.98, -34.33] speed=30 wait=0.0s (pre max|Δ|=3.50°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=2.51° (tol 3.0°) [VIA ] step 9 Δ= +0.1 -3.3 -0.3 -0.7 +3.5 -0.1 着いた [STATE ] 目標を渡す 目標と実測の最大差 2.08°（関節 j1） [059] 推論 1658ms 10ステップ先 Δ=-18.1 -24.2 -1.8 -4.6 +29.0 +2.2 [VIA ] 中継点 4 点: step 2, 5, 8, 9 [VIA ] step 2 Δ= -4.3 -8.7 -0.1 -1.5 +8.6 +0.6 流した 0.41 秒で次へ: 近づいた (残り 1.79°) [VIA ] step 5 Δ= -6.0 -8.7 -0.6 -1.3 +10.1 +1.3 流した 0.42 秒で次へ: 近づいた (残り 1.85°) [VIA ] step 8 Δ= -6.3 -8.6 -1.5 -1.7 +9.5 +1.7 流した 0.52 秒で次へ: 近づいた (残り 1.71°) [SEND] pi05_chunk059_via09: send_angles (single) [ +24.36, +23.66, +3.14, +4.14, -26.82, -31.96] speed=30 wait=0.0s (pre max|Δ|=3.58°, post-send timeout 8.0s) [SEND] arrival OK: max|Δ|=1.91° (tol 3.0°) [VIA ] step 9 Δ= -1.8 -3.6 -1.8 -0.7 +3.4 +1.3 着いた [RECORD] 記録終了 コマ 1768 (8.891 fps) 実測角 1648 回 (8.29 Hz) 電流 1652 行 (read_servo) → /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182327/recording [GRIP ] 閉じて 1 秒後の爪の電流 (中央値): 1 回目 783 (9 行) / 2 回目 35.5 (8 行) (閉じる値 25) [DONE ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261114_182327 [CLIENT] run_policy_client.py が終わった (終了コード 0. モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1)) (203 秒) もう1回やりますか? y=やる / 他=終わる > y n === かかった時間 (Log35 の Pod (id 9wypmq2uhnx2et) につなぎ直し) モデル deep1 (PixelstoMotors/pi05-mecharm-deep-even10-lora-v1) 1. Pod につなぎ直す 1 秒 2. Pod が立ち上がるまで待つ 6 秒 3. Pod の中を確かめる (つなぎ直し) 8 秒 3a. スクリプトを送る 99 秒 3b〜4. 準備とサーバーの起動 (飛ばした) 0 秒 5. Mac の 8000 番へのトンネル 2 秒 5b. 空打ち (1 回目の推論の待ちを先に済ませる) 2 秒 6. デーモンの状態 3 秒 7. HOME → 爪を開く → 位置合わせ (1 回目) 63 秒 8. 実機推論 (1 回目) 76 秒 7. HOME → 爪を開く → 位置合わせ (2 回目) 15 秒 8. 実機推論 (2 回目) 60 秒 7. HOME → 爪を開く → 位置合わせ (3 回目) 14 秒 8. 実機推論 (3 回目) 203 秒 [LAB ] Pod は残しています (id 9wypmq2uhnx2et). 片付けは ./lab_stop.sh --log Log35 [TUNNEL] 8000 番のトンネルを閉じました ``` ### Pod を消した lab_stop.sh ``` [STOP ] Log35 の Pod: id 9wypmq2uhnx2et GPU=NVIDIA A40 作った時刻 2026-11-14 17:58:33 [LOG ] serve.log を持ち帰った → /Volumes/KIOXIA/r2r2r-data/lab/Log35/serve.log (48 行) [STOP ] Terminate を送った (18:37:47) [STOP ] Pod (id 9wypmq2uhnx2et) が消えたことを API で確かめた [COST ] 借りていた時間 39 分 14 秒 (0.65 時間) × 1時間 0.59 ドル = 約 0.39 ドル (約 61 円. 1ドル=158円) [TUNNEL] 8000 番のトンネルは残っていません ``` ## 182327：箱に置いたあと、何もない所で爪を閉じて運んだ 3回目の起動の3つ目の試行（`pi05_20261114_182327`）では、π0.5 はチャンク10 でブロックを箱に置きました。そこまでは成功です。 そのあと HOME の近くで、1チャンクごとに各関節が1〜2°ほどの小さな動きを30回ほど続けました。土台の向き j0 は、そのあいだに -1° から -21° まで少しずつ左へずれていきます。チャンク48 から一気に左へ回り、チャンク51 で j0 が -54° の、何もない所で爪を閉じました。閉じて1秒後の爪の電流は35.5 で、何もつかんでいません（ブロックを押しているときは700〜800）。そのまま箱まで運んで開き、上限の60チャンクで終わりました。 ほかの試行でも、置いたあとは HOME の近くで小さな動きが続き、人が Enter で止めていました。止めるまで10〜30秒かかっています。π0.5 は「置いたら終わり」をお手本から学んでいない、と読むのが近いと思います。お手本は、置いて HOME に戻ったところで記録を切っていたので、その先の動きは何も教えていません。 ## 依頼181：箱に置き終えたら自動で終わる 置き終えたら終わる形を、π0.5 の外側（推論を送るプログラム）に足しました。条件は4つで、すべてそろったら終わります。 1. この試行の中で、爪を閉じてから開いた 2. 今、爪が開いている 3. HOME からの差が、各関節 8° 以内 4. 推論の答え（10個先まで）の動きが各関節 3° 以内のチャンクが、2回続いた 終わったら、そのチャンクは送らずに HOME へ戻し、結果の入力へ進みます。置いたあとにまた閉じる答えが出たら、送らずに止めて入力欄を出します（182327 の空振りを防ぐため）。 - ねらい：置き終えたあとの10〜30秒と、182327 のような空振りをなくす - 変わったこと：`lab_start.sh` では最初から自動で終わる形になる。`--no-auto-finish` で今までどおり - 見込める効果：この回の7回の記録にあてはめると、HOME に戻ってから2チャンク目で終わる判定になった。人が止めていた所より早く、182327 は空振りの前（チャンク17）で終わる。実機ではまだ試していない 報告の「決めてほしいこと」のうち、1回目のつかみが空振りで π0.5 がつかみ直そうとしたときも止まる点は、そのままにしました。止まったら Enter で続けられます。 ### 依頼181 の依頼文 ```markdown --- 作業フォルダ: /Users/shimazueiichi/r2r2r-scripts 上限時間: 120 --- # 依頼181：実機推論で、箱に置き終えたら自動で終わる 実機は動かさない（実装・テスト・レビューまで）。Log35。物理的なリスクのある変更なので codex を必ず通す。 ## なぜ Log35（2026-11-14）の推論で、箱に置いて爪を開いたあとも π0.5 は HOME 近くで小さな動き（1 チャンクの Δ が各関節 2° 前後）を出し続け、エイイチが Enter で止めるまで 10〜30 チャンク（30〜60 秒）続いた。 pi05_20261114_182327 では、置き終えた（チャンク 10 で開いた）あと HOME 近くで 35 チャンクほど小さな動きを続けるうちに j0 が −21° まで流れ、チャンク 47〜57 で何もない所（j0 −54°）へ行って爪を閉じ（閉じて 1 秒後の電流 35.5 = 何もつかんでいない）、箱へ運んで開いた。--max-chunks 60 で終わった。 エイイチの決め（2026-11-14）：置き終えたら自動で終わる形にする。 ## やること 1. run_policy_client.py に終わりの判定を足す（--auto-finish。lab_start.sh は既定で付ける。--no-auto-finish で今までどおり） - 条件（すべて満たしたら終わり）： a. この試行の中で爪を閉じ、そのあと爪を開いた（つかんで放した）ことが 1 回以上ある b. 開いたあと、HOME（0,0,0,0,0,-30）からの各関節の差が、すべて N° 以内（既定 8°。--finish-home-tol） c. b の状態で、推論の答え（10 ステップ先までの Δ）が各関節 M° 以内（既定 3°。--finish-still-deg）のチャンクが K 回続いた（既定 2。--finish-chunks） - 値は Log35 の log.jsonl（pi05_20261114_180457・180704・181057・181300・182039・182211・182327）の、開いたあとのチャンクで実際の値を見て、上の既定で「置いたあと 2〜3 チャンクで終わる」「置く前・運ぶ途中では終わらない」ことを確かめてから決める。違えば既定を直し、その根拠（チャンクごとの値の表）を報告に書く - 終わったら、今のチャンクは送らずに HOME へ戻し（今の h と同じ送り方）、結果の入力（y/n/Enter）へ進む。終わったわけを [FINISH] の 1 行で出し、log.jsonl に type=finish の行（どの条件で・何チャンク目で・HOME からの差・Δ）を残す - 爪を閉じて開いたあとに、また閉じる答えが出たら（2 回目のつかみ）、そのチャンクは送らずに止めて入力欄を出す（182327 の空振りを防ぐ）。画面に [FINISH] の 1 行 - 入力欄・スペースで止める・補正・巻き戻しは今までどおり 2. chunk_timing.py：終わり方（自動で終わった・人が止めた・上限）をメモに出す 3. テスト：上の 7 本の log を流して、何チャンク目で終わる判定になるかを表で出す（182327 は 2 回目のつかみの前に終わること）。--no-auto-finish で今までと同じこと。既存のテストも通す 4. codex で差分を見てもらい、指摘を直して通るまで 5. 変えたファイルだけを指定して git add・commit（git add . と git clean は使わない） ## 報告 既定の値と根拠の表、7 本で何チャンク目で終わる判定になるか、画面の例 ``` ### 依頼181 で Claude Code が返した報告 18:30に始め、19:16に終えました（46分）。 ``` 依頼181 報告：実機推論で、箱に置き終えたら自動で終わる（Log35） ■ やったこと 1. run_policy_client.py に --auto-finish を足した（付けなければ今までと同じ。log の頭にも何も足さない） - 終わる条件（すべて）：a. 爪を閉じてから開いた（推論・補正のどちらでも。補正の中の g の閉→開も数える。つかんだ区間を巻き戻して開いたら数え直す）／爪が今開いている／b. 推論の前の実測角と HOME の差が各関節 8° 以内（--finish-home-tol）／c. b の状態で、答えの先頭 10 ステップと実測角の差が各関節 3° 以内（--finish-still-deg）のチャンクが 2 回続いた（--finish-chunks） - 終わったら、そのチャンクは送らずに h と同じ送り方で HOME へ戻し、結果の入力（y/n/Enter）へ進む。[FINISH] の 1 行、log.jsonl に type=finish（event=auto_finish・何チャンク目・条件の値・HOME からの差・Δ）、そのチャンクの行に auto_finish、{run_stem}.json の end_reason=auto_finish（result=completed）。各チャンクの行に finish_check（判定の値） - 放したあとにまた閉じる答え（2 回目のつかみ）が出たら、そのチャンクは送らずに入力欄を出す（[FINISH] の 1 行・type=finish / event=regrasp）。入力欄で Enter を押せば今までどおり送る（人の判断）。--auto のときは入力欄を出せないので送らずに終える（終了コード 1・end_reason=regrasp・アームは動かさない） - スペースで止める予約があるとき・入力欄で s/b/c/p を選んだあと（Enter で実行するまで）は、終わる条件を満たしても入力欄を優先する（勝手に HOME へ動かさない） 2. lab_start.sh：既定で --auto-finish を渡す。--no-auto-finish で今までどおり。起動時に [FINISH] の行。--help の表示を 2〜64 行に広げた 3. chunk_timing.py：「終わり方」の行（自動で終わった／人が止めた (h・q・Ctrl-C)／上限／2 回目のつかみで止めた／エラー）と比べる表の列、チャンクのメモに「自動で終えた」「2回目のつかみ」 4. テスト：pi05/test_auto_finish.py 17 件（Log35 の 7 本の再生・判定の単体・偽のアームでの通し・HEAD と同じか）。python3 pi05/test_auto_finish.py --table で下の表が出る 既存：test_rewind_correct 81・test_no_step_confirm 17・test_skip_first_confirm 6・test_flow_send 16・test_chunk_timing 7・test_pad_correction 24・tools/test_gamepad_teleop 93 すべて OK、test_lab_start.sh OK 222 / NG 0 5. codex：3 回。1 回目 必須 2・軽微 1（R1 答えの全ステップを見ていた→先頭 10 ステップだけ／R2 補正の中の閉→開を数えていなかった→爪の指令を 1 つずつ知らせる。あわせて「爪が開いている」を条件に足した／R3 付けないときも頭に auto_finish:null→付けたときだけ）。2 回目 必須 1（チャンクごとに確かめる形で --finish-chunks 1 だと s/c のあとでも自動で HOME へ→確かめの形によらず止める）。3 回目 指摘なし 6. コミット 68f514a（5 ファイルを個別に add） ■ 既定の値と根拠（Log35 の 7 本。放したあとのチャンク。値は各関節の最大） 既定は依頼のまま（8°・3°・2 回）で、直す必要はなかった。 - HOME に戻って止まっているチャンク：HOME からの差 4.1〜5.5°（どれも j1）、Δ 1.1〜2.7° - HOME へ戻る途中：HOME からの差 6.0〜67.8°、Δ 3.1° 以上（182327 のチャンク 15 は差 6.0°・Δ 3.1° で止まっていない扱い） - 置く前・運ぶ途中（放したチャンクまで）：「放した」が成り立たないので終わらない（運ぶ途中の HOME からの差は 50° 以上） 182327（放したのはチャンク 10） chunk HOMEからの差 Δ10ステップ 続いた 11 65.0 (j1) 15.5 (j1) 0 12 52.0 (j1) 24.8 (j1) 0 13 29.1 (j1) 15.9 (j1) 0 14 15.9 (j1) 11.7 (j1) 0 15 6.0 (j1) 3.1 (j0) 0 16 5.1 (j1) 1.7 (j1) 1 17 5.0 (j1) 1.7 (j1) 2 ← 終わる …（判定しなければ 35 まで同じ形。36〜46 で j0 が −21° へ流れ、HOME からの差 6.4→21.5°） 51 66.4 (j4) 1.9 (j1) ← 2 回目のつかみ（何もない所で閉じた） 180457（放したのは 11）：12 64.0/13.5、13 52.6/22.6、14 31.7/24.7、15 8.5/4.3、16 5.5/2.2 (1)、17 4.8/1.5 (2) ← 終わる 181300（放したのは 14）：15 64.0/16.1、16 50.5/26.1、17 25.7/15.2、18 12.2/8.5、19 5.4/2.0 (1)、20 4.9/1.6 (2) ← 終わる 182039（放したのは 9）：10 63.7/17.5、11 48.5/28.2、12 23.3/11.1、13 14.2/11.0、14 4.6/1.9 (1)、15 4.4/2.0 (2) ← 終わる 182211（放したのは 8）：9 67.8/14.4、10 55.5/27.1、11 30.1/27.3、12 4.3/2.1 (1)（ここで人が止めた） 180704（放したのは 10）：11〜15 で HOME からの差 63.7→18.9°（戻る途中で人が止めた） 181057（放したのは 14）：15〜20 で HOME からの差 27.6° 以上（HOME に戻らないうちに人が止めた） ■ 7 本で何チャンク目で終わる判定になるか 試行 放した 終わる判定 実際に止めたチャンク 180457 11 17 24（人） 180704 10 なし 15（人。HOME に戻る前） 181057 14 なし 20（人。HOME に戻る前） 181300 14 20 24（人） 182039 9 15 15（人） 182211 8 なし 12（人。HOME 近くで 1 回目のところ。次も同じなら 13 で終わる） 182327 10 17 59（上限 60。2 回目のつかみ 51 より前に終わる） HOME に戻ってから 2 チャンク目で終わる。放したチャンクからは 5〜7 チャンクあとで、そのうち 3〜5 チャンクは HOME へ戻る動き。 ■ 画面の例（偽のアームで流したもの） [FINISH] --auto-finish: つかんで放したあと, HOME からの差が各関節 8° 以内で 答えの Δ (10 ステップ先まで) が各関節 3° 以内のチャンクが 2 回続いたら, 送らずに HOME へ戻して終えます. 2 回目のつかみは送らずに止めます [FINISH] 置き終えたので終えます (放したあと HOME 近くで止まったチャンクが 2 回続いた). 推論 6 は送らずに HOME へ戻します HOME からの差 最大 0.0° (j0) Δ (10 ステップ先まで) 最大 0.3° (j0) 結果: y=成功 / n=失敗 / Enter=記録しない > 2 回目のつかみ： [FINISH] 放したあとにまた閉じる答え (2 回目のつかみ). 推論 5 は送らずに止めます HOME からの差 最大 0.0° (j0) Δ (10 ステップ先まで) 最大 0.3° (j0) Enter=実行 / s=送らず次へ / b=巻き戻し / p=ゲームパッドで補正 / c=キーで補正 / r=爪の締め直し / h=HOMEに戻して終了 / q=終了 > 止めているとき： [FINISH] 終わる条件を満たしたが, 止めているので入力欄を出します HOME からの差 … chunk_timing.py： 終わり方: 自動で終わった (置き終えた) 推論 6 で HOME へ (HOME からの差 最大 0.0°・Δ 最大 0.3°・2 回続いた) 終わり方: 人が止めた (h で HOME) (2 回目のつかみで止めた 1 回) ■ 決めてほしいこと 1. 1 回目のつかみが空振りで、AI が開いてつかみ直そうとしたときも「2 回目のつかみ」として止めて入力欄を出す（つかめたかは判定できないため、閉じて開いたあとの閉じる答えはすべて止める）。このままでよいか。補正の R（開いて閉じ直す）のあとの閉じる答えも同じく止まる。 2. --auto のときの 2 回目のつかみは「送らずに終了コード 1 で終える（HOME へは動かさない）」にした。HOME へ戻して終える方がよければ直す。 3. 実機での確かめ（lab_start.sh の既定で --auto-finish が入る）。実機は動かしていない。 ■ 気づいたこと（範囲の外なので変えていない） 既存のテスト用の偽のアーム（test_rewind_correct.run_client）は、--execute のときの記録スレッドの電流の読み取り（daemon_read_servo）を差し替えていないため、Pi の daemon（192.168.2.1:5555）につながって読み取りだけしている。アームは動かさないが、テストが実機の daemon に触れる。 ``` ### 依頼181 のコードの差分（コミット 68f514a） ```diff commit 68f514a41c129b6fbd2663435a366734e3d374e7 Author: Eiichi Shimazu Date: Sat Nov 14 19:15:55 2026 +0900 実機推論で, 箱に置き終えたら自動で終わる (依頼 181・Log35). run_policy_client.py に --auto-finish を足す (つかんで放した (補正の中の g も数える. codex R2) あと, 爪が開いていて, 推論の前の実測角と HOME の差が各関節 --finish-home-tol (既定 8°) 以内, 答えの先頭 10 ステップ (codex R1) と実測角の差が各関節 --finish-still-deg (既定 3°) 以内のチャンクが --finish-chunks (既定 2) 回続いたら, そのチャンクは送らずに h と同じ送り方で HOME へ戻し結果の入力へ. 画面に [FINISH], log.jsonl に type=finish (event=auto_finish), チャンクの行に auto_finish・finish_check, {run_stem}.json の end_reason=auto_finish. 放したあとにまた閉じる答え (2 回目のつかみ) は送らずに入力欄 (type=finish / event=regrasp. --auto なら送らずに終了コード 1). 止める予約・s・b・c・p のあとは入力欄を優先 (確かめの形によらない. codex 2 回目 R1). 付けなければ log の頭も含めて今までと同じ (codex R3)). 既定は Log35 の 7 本で決めた (HOME に戻って止まったチャンクは差 4.1〜5.5°・Δ 1.1〜2.7°. 180457→17・181300→20・182039→15・182327→17 (2 回目のつかみ 51 より前)・180704/181057/182211 は記録の終わりまでに終わらない). lab_start.sh は既定で --auto-finish を渡し, --no-auto-finish で今までどおり (起動時に [FINISH] の行. --help は 2〜64 行). chunk_timing.py に終わり方 (自動・人・上限・2 回目のつかみ) とメモ. テストを足す (test_auto_finish 17・lab_start 222) (依頼 181. codex 3 回) Co-Authored-By: Claude Opus 5.5 --- lab_start.sh | 16 +- pi05/chunk_timing.py | 56 +++++- pi05/run_policy_client.py | 186 ++++++++++++++++++- pi05/test_auto_finish.py | 464 ++++++++++++++++++++++++++++++++++++++++++++++ test_lab_start.sh | 14 +- 5 files changed, 723 insertions(+), 13 deletions(-) diff --git a/lab_start.sh b/lab_start.sh index 9dfafaf..18b1cb0 100755 --- a/lab_start.sh +++ b/lab_start.sh @@ -41,6 +41,9 @@ # --step-confirm 実機推論でチャンクごとに確かめ (Enter) を待つ今までの形に戻す. 付けなければ (既定) run_policy_client.py に # --no-step-confirm を渡し, 始めの確かめのあとは止まらずに進み, スペース (Enter も可) を押したときだけ次の推論の # あとで入力欄を出す (依頼 178). 起動時に [CONFIRM] の行でどちらかを出す +# --no-auto-finish 箱に置き終えたら自動で終わる判定 (run_policy_client.py --auto-finish) を渡さない (今までどおり). 付けなければ +# (既定) --auto-finish を渡し, つかんで放したあと HOME 近くで止まったら送らずに HOME へ戻して結果の入力へ進む. +# 2 回目のつかみは送らずに入力欄を出す (依頼 181). 起動時に [FINISH] の行でどちらかを出す # つなぎ直しで, 残っている Pod のサーバーが別のモデルで動いていれば, そのことを出して止まる # # 1. Pod を作る (A40×1・Runpod Pytorch 2.8.0・コンテナのディスク 200GB・22/tcp を外へ出す) @@ -92,6 +95,7 @@ GRIP_ARGS=() # 依頼 152: --grip-value N のときだけ run_policy_cli GRIP_VALUE_SHOWN="20 (既定. run_policy_client.py の GRIP_VALUE)" FLOW_ARGS=() # 依頼 176: --flow / --speed N のときだけ run_policy_client.py に渡す STEP_ARGS=(--no-step-confirm) # 依頼 178: 既定はチャンクごとに確かめない. --step-confirm で今までどおり +FINISH_ARGS=(--auto-finish) # 依頼 181: 既定は置き終えたら自動で終わる. --no-auto-finish で今までどおり while [ $# -gt 0 ]; do case "$1" in --gpu) lab_need_val A40 "$@"; GPU="$2"; shift 2 ;; @@ -107,13 +111,14 @@ while [ $# -gt 0 ]; do GRIP_ARGS=(--grip-value "$((10#$2))"); GRIP_VALUE_SHOWN="$((10#$2)) (--grip-value)"; shift 2 ;; --flow) FLOW_ARGS+=(--flow); shift ;; --step-confirm) STEP_ARGS=(); shift ;; + --no-auto-finish) FINISH_ARGS=(); shift ;; --speed) [ $# -ge 2 ] || { echo "[ERROR] --speed には 1〜100 の整数を付ける" >&2; exit 2; } case "$2" in ''|*[!0-9]*) echo "[ERROR] --speed は 1〜100 の整数: $2" >&2; exit 2 ;; esac [ ${#2} -le 3 ] && [ "$((10#$2))" -ge 1 ] && [ "$((10#$2))" -le 100 ] || { echo "[ERROR] --speed は 1〜100 の整数: $2" >&2; exit 2; } FLOW_ARGS+=(--speed "$((10#$2))"); shift 2 ;; --model) [ $# -ge 2 ] || { echo "[ERROR] --model には ${LAB_MODELS// / か } を付ける" >&2; exit 2; } # 値がないと shift 2 が失敗して回り続ける (codex R1) MODEL="$2"; shift 2 ;; - -h|--help) sed -n '2,61p' "$0"; exit 0 ;; + -h|--help) sed -n '2,64p' "$0"; exit 0 ;; *) echo "[ERROR] 知らない引数: $1 (./lab_start.sh --help)" >&2; exit 2 ;; esac done @@ -168,6 +173,11 @@ if [ ${#STEP_ARGS[@]} = 0 ]; then else echo "[CONFIRM] チャンクごとには確かめない (--no-step-confirm. 始めの確かめのあとは止まらずに進む. 止めるときはスペース. 依頼 178)" fi +if [ ${#FINISH_ARGS[@]} = 0 ]; then + echo "[FINISH] 置き終えても自動では終わらない (--no-auto-finish. 今までどおり)" +else + echo "[FINISH] 箱に置き終えたら自動で終わる (--auto-finish. つかんで放したあと HOME 近くで止まったら HOME へ戻して結果の入力へ. 2 回目のつかみは送らずに止める. 依頼 181)" +fi lab_ssh_opts HF_REPO=$MODEL_REPO # --model で選んだモデル (lab_lib.sh の lab_model_def) @@ -541,14 +551,14 @@ while :; do stage "8. 実機推論 ($round 回目)" python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride 3 \ --settle-retries 0 --state-from-target --execute --ignore-framing --model "$MODEL_TAG" --framing-raw-dir "$RAW" \ - --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${STEP_ARGS[@]+"${STEP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ + --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FINISH_ARGS[@]+"${FINISH_ARGS[@]}"} ${STEP_ARGS[@]+"${STEP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ ${CONFIRM_ARGS[@]+"${CONFIRM_ARGS[@]}"} rc=$? else stage "8. 推論のクライアント (ドライラン・--dry-keys. アームには触らない)" python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride 3 \ --settle-retries 0 --state-from-target --dry-keys --ignore-framing --model "$MODEL_TAG" --framing-raw-dir "$RAW" \ - --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${STEP_ARGS[@]+"${STEP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ + --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FINISH_ARGS[@]+"${FINISH_ARGS[@]}"} ${STEP_ARGS[@]+"${STEP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ ${CONFIRM_ARGS[@]+"${CONFIRM_ARGS[@]}"} rc=$? fi diff --git a/pi05/chunk_timing.py b/pi05/chunk_timing.py index 0f98f90..d381e14 100644 --- a/pi05/chunk_timing.py +++ b/pi05/chunk_timing.py @@ -19,6 +19,9 @@ 確認待ちもここに入る) 合計 このチャンクの推論を始めてから次のチャンクの推論を始めるまで (最後のチャンクは記録の終わりまで) 試行全体の 合計 と 中央値 (推論は 2 回目からの中央値も) を出す. +終わり方 (依頼 181): 自動で終わった (--auto-finish で置き終えた) / 人が止めた (h・q・Ctrl-C) / 上限 (--max-chunks) / + 2 回目のつかみで止めた (--auto) / エラー を 1 行で出す. {試行名}.json の end_reason を読み, なければ log.jsonl の + type=finish の行と最後のチャンクの HOME から見る. チャンクのメモに「自動で終えた」「2回目のつかみ」 中継点ごと: --flow の試行 log.jsonl の vias[].flow から, 送ってから次を実際に送るまで (send_gap_s. 最後の点は着くまで) の秒と @@ -120,6 +123,10 @@ def chunk_rows(chunks): note.append("止めた(" + ({"space": "スペース", "enter": "Enter"}.get(p.get("key")) or {"not_arrived": "未到達", "read_failed": "読めない"}.get(p.get("reason"), str(p.get("reason")))) + ")") + if r.get("auto_finish"): + note.append("自動で終えた") # 依頼 181: --auto-finish で置き終えたと判定し, 送らずに HOME へ + if r.get("regrasp_stop"): + note.append("2回目のつかみ") # 依頼 181: 放したあとにまた閉じる答え (送らずに入力欄) for k, t in (("rewind_requested", "巻き戻し"), ("correction_requested", "補正"), ("home_requested", "HOME"), ("unsafe", "安全停止")): if r.get(k): @@ -163,6 +170,46 @@ def step_text(model): return "毎チャンク(記録なし)" if sc is None else ("毎チャンク" if sc else "止めたときだけ") +END_TEXT = {"auto_finish": "自動で終わった (置き終えた)", "h": "人が止めた (h で HOME)", "q": "人が止めた (q)", + "ctrl_c": "人が止めた (Ctrl-C)", "max_chunks": "上限 (--max-chunks)", + "regrasp": "2 回目のつかみで止めた (--auto)", "error": "エラーで止まった"} + +END_SHORT = {"auto_finish": "自動", "h": "人(h)", "q": "人(q)", "ctrl_c": "人(Ctrl-C)", "max_chunks": "上限", + "regrasp": "2回目のつかみ", "error": "エラー"} + + +def end_how(run_dir: Path, chunks): + """終わり方 (依頼 181) → (end_reason か None, 1 行の文). {試行名}.json の end_reason を先に見る.""" + reason = None + try: + reason = json.loads((run_dir / f"{run_dir.name}.json").read_text()).get("end_reason") + except (OSError, ValueError, AttributeError): + pass + fins = [] + for line in (run_dir / "log.jsonl").read_text().splitlines(): + try: + r = json.loads(line) + except json.JSONDecodeError: + continue + if isinstance(r, dict) and r.get("type") == "finish": + fins.append(r) + auto = [f for f in fins if f.get("event") == "auto_finish"] + if reason is None: + if auto: + reason = "auto_finish" + elif chunks and chunks[-1].get("home_requested"): + reason = "h" + text = END_TEXT.get(reason, "記録なし" if reason is None else str(reason)) + if reason == "auto_finish" and auto: + f = auto[-1] + text += (f" 推論 {f.get('chunk')} で HOME へ (HOME からの差 最大 {max(f.get('home_err') or [0]):.1f}°・" + f"Δ 最大 {max(f.get('delta_max') or [0]):.1f}°・{f.get('still_run')} 回続いた)") + n_re = sum(1 for f in fins if f.get("event") == "regrasp") + if n_re: + text += f" (2 回目のつかみで止めた {n_re} 回)" + return reason, text + + def fmt(x, w=7): return f"{'-':>{w}}" if x is None else f"{x:>{w}.2f}" @@ -212,10 +259,13 @@ def report(run_dir: Path): f"中継点の間の中央値 {fmt(med(all_waits), 0)} 秒 ({'log.jsonl の flow' if flow_seen else 'states.csv の送った時刻' if all_waits else '記録なし'})") if flow_seen: print(" 中継点ごと: step:秒+わけ (近=近づいた 時=見込みの時間 着=最後の点が着いた 未=着かなかった 失=送れなかった)") + end_reason, end_text = end_how(run_dir, chunks) + print(f" 終わり方: {end_text}") if others: print(" そのほかの行: " + " ".join(f"{k} {v}" for k, v in sorted(others.items()))) return {"name": run_dir.name, "flow": model.get("flow"), "step": step_text(model) if model else "-", "speed": model.get("speed", 20), "n": len(rows), - "tot": tot, "mid": mid, "infer1": rows[0]["infer"], "infer2": infer2, "via": med(all_waits)} + "tot": tot, "mid": mid, "infer1": rows[0]["infer"], "infer2": infer2, "via": med(all_waits), + "end": end_reason} def main(argv=None): @@ -236,12 +286,12 @@ def main(argv=None): if len(res) >= 2: print("== 比べる (秒)") print(f" {'試行':<22} {'送り方':<10} {'確かめ':<12} {'速さ':>4} {'チャンク':>6} {'推論計':>7} {'確認待ち計':>7} {'動いた計':>7} " - f"{'動いた中央':>7} {'中継点中央':>7} {'合計':>7}") + f"{'動いた中央':>7} {'中継点中央':>7} {'合計':>7} 終わり方") for r in res: how = "記録なし" if r["flow"] is None else ("flow" if r["flow"] else "今まで") print(f" {r['name']:<22} {how:<10} {r['step']:<12} {r['speed']:>4} {r['n']:>6} {fmt(r['tot']['infer'])} " f"{fmt(r['tot']['confirm'])} {fmt(r['tot']['moved'])} {fmt(r['mid']['moved'])} {fmt(r['via'])} " - f"{fmt(r['tot']['total'])}") + f"{fmt(r['tot']['total'])} {END_SHORT.get(r['end'], '記録なし' if r['end'] is None else r['end'])}") return 0 diff --git a/pi05/run_policy_client.py b/pi05/run_policy_client.py index 41eff0c..f2db2c8 100644 --- a/pi05/run_policy_client.py +++ b/pi05/run_policy_client.py @@ -119,6 +119,20 @@ --speed N: 推論のチャンクを送る速さ (既定 20 = 今までと同じ. settle の送り直しも同じ速さ). 補正 (キー・ゲームパッド)・巻き戻し・HOME の送り方と速さは変えない. log.jsonl の頭 (type=model) に flow・flow_tol・speed +置き終えたら自動で終わる (2026-11-14 依頼 181. --auto-finish. 既定は off = 今までどおり. lab_start.sh が既定で付ける): + 推論の答えを送る前に, 次の 3 つをすべて満たしたら, そのチャンクは送らずに HOME へ戻し (h と同じ送り方) 結果の入力へ進む: + a. この試行の中で爪を閉じ, そのあと開いた (推論・補正のどちらでも. つかんだ区間を巻き戻して開いたら数え直す) + b. 推論の前の実測角と HOME の差が 6 関節すべて --finish-home-tol (既定 8°) 以内 + c. b の状態で, 答えの 10 ステップ先までと実測角の差が 6 関節すべて --finish-still-deg (既定 3°) 以内のチャンクが + --finish-chunks (既定 2) 回続いた (s・b・c・p を選んだら数え直す) + 既定は Log35 の 7 本の放したあとのチャンクで決めた (HOME に戻って止まっているチャンクは HOME からの差 4.1〜5.5°・Δ 1.1〜2.7°. + 運ぶ途中は HOME からの差 50° 以上. test_auto_finish.py --table). 画面に [FINISH] の 1 行, log.jsonl に type=finish + (event=auto_finish. 条件の値・何チャンク目・HOME からの差・Δ), そのチャンクの行に auto_finish, {run_stem}.json の + end_reason=auto_finish. 止める予約 (スペース) や s・b・c・p のあとで止めているときは, 終わらずに入力欄を出す. + 放したあとにまた閉じる答えが出たら (2 回目のつかみ. 182327 の空振り), そのチャンクは送らずに入力欄を出す + (画面に [FINISH]. log.jsonl に type=finish / event=regrasp. Enter で送るのは今までどおり人の判断. --auto なら送らずに + 終える (終了コード 1・end_reason=regrasp・アームは動かさない)). 各チャンクの行に finish_check (判定の値) + 待ち時間 (2026-10-30 依頼 35. エイイチの判断で縮めた. 本線と共有の定数は変えず, ここで上書きする): --send-wait 0.0 (前 1.0) / --grip-wait 0.8 (前 2.0) / --grip-open-wait 0.0 (前 2.0) / --settle-wait 0.8 (前 2.0) 前の値に戻すには --send-wait 1.0 --grip-wait 2.0 --grip-open-wait 2.0 --settle-wait 2.0 @@ -205,6 +219,7 @@ GRIP_VALUE_DEFAULT = 20 # run_pick_place.py の close 値 (--grip-value GRIP_VALUE = GRIP_VALUE_DEFAULT # 閉じる値 (--grip-value で変える. 依頼 152) GRIP_VALUE_RANGE = (0, 100) # --grip-value に受ける値 (set_gripper_value の範囲) LAST_CLOSE_VALUE = None # 最後に送った閉じる値 (締め直し r で違う値を選ぶため. 依頼 152) +GRIP_OBSERVER = None # 補正・巻き戻しの爪の指令を 1 つずつ知らせる先 (--auto-finish の AutoFinish.on_grip. 依頼 181 codex R2) # ---- 待ち時間 (2026-10-30 依頼 35. エイイチの判断で縮めた. 「time.sleep() を短縮しない」より優先) ---- # 本線 (j0_sweep_scan.py / visual_servo_pick.py) と共有の定数は変えず, この中でだけ上書きする. # コマンドの引数 (--send-wait / --grip-wait / --grip-open-wait / --settle-wait) で前の値に戻せる. @@ -235,6 +250,11 @@ FLOW_MAX_WAIT_SEC = 1.5 # 見込みの時間の上限 (近づかなく FLOW_START_SEC = 0.15 # 送ってから動き始めるまで (193254 で 0.13〜0.14 秒) FLOW_DEG_PER_SEC_AT_20 = 25.0 # speed 20 で動いている間の速さ (お手本 deep_even10_v1 の中央 25.6°/秒). speed に比例すると見込む FLOW_POLL_SEC = 0.1 # 待つ間に関節角を読む間隔 (読む 1 回に 0.1 秒ほどかかる) +# ---- 置き終えたら自動で終わる (--auto-finish. 依頼 181. Log35 の 7 本の放したあとのチャンクで決めた) ---- +FINISH_HOME_TOL_DEFAULT = 8.0 # HOME からの差 (各関節). 戻って止まっているチャンクは 4.1〜5.5° (j1). 運ぶ途中は 50° より大きい +FINISH_STILL_DEG_DEFAULT = 3.0 # 10 ステップ先までの Δ (各関節). HOME 近くの小さな動きは 1.1〜2.7°. 戻る途中は 3.1° 以上 (182327 の 15) +FINISH_CHUNKS_DEFAULT = 2 # 上の 2 つを満たすチャンクがこの回数続いたら終わる +FINISH_LOOK_STEPS = 10 # 答えの先頭この数のステップ (0.1 秒刻みで 1 秒先まで) だけを見る (codex R1) DATA_ROOT = Path("/Volumes/KIOXIA/r2r2r-data") LOG_ROOT = DATA_ROOT / "runs" / "pi05_policy" RECORDER = ("127.0.0.1", 5556) @@ -668,6 +688,7 @@ class ArmIO: def gripper(self, state, value=None): """value は閉じるときの値 (省くと GRIP_VALUE. 締め直し r だけが渡す. 依頼 152).""" + notify_grip(state) if self.recorder is not None: self.recorder.gripper(state) if not self.execute: @@ -678,6 +699,12 @@ class ArmIO: gripper_cmd(state, value) +def notify_grip(state): + """爪の指令を GRIP_OBSERVER へ知らせる (--auto-finish のときだけ入っている. 依頼 181 codex R2).""" + if GRIP_OBSERVER is not None: + GRIP_OBSERVER(int(state)) + + def regrip_tighten(arm): """締め直し (r. 補正の中と外で共通): 開かずに, 前に送った閉じる値と違う値を送る (依頼 152). 戻り値: log.jsonl の regrip_tighten に足す項目 (送った値・閉じる値・前に送った値).""" @@ -797,6 +824,67 @@ class PauseKeys: return "other" if s else None +class AutoFinish: + """--auto-finish (依頼 181): 箱に置き終えたら推論を終える判定. アームには触らない (判定と数えるだけ). + + 終わる条件 (すべて): a. この試行の中で爪を閉じ, そのあと開いた (つかんで放した) / b. 推論の前の実測角と + HOME の差が 6 関節すべて home_tol 以内 / c. b の状態で, 推論の答え (10 ステップ先まで) と実測角の差が + 6 関節すべて still_deg 以内のチャンクが need 回続いた. + 放したあとにまた閉じる答え (2 回目のつかみ) が出たら regrasp (送らずに入力欄). + on_grip で爪の状態 (推論・補正で変わった後の値) を受け, on_rewind_open (つかんだ区間を巻き戻して開いた) で + つかんだこと自体を忘れる (ブロックは元の位置へ戻っている).""" + + def __init__(self, enabled, home_tol=FINISH_HOME_TOL_DEFAULT, still_deg=FINISH_STILL_DEG_DEFAULT, + need=FINISH_CHUNKS_DEFAULT): + self.enabled = bool(enabled) + self.home_tol, self.still_deg, self.need = float(home_tol), float(still_deg), int(need) + self.closed = self.released = False + self.grip = 0 # 今の爪 (知らされた最後の指令) + self.still_run = 0 + + def on_grip(self, grip): + self.grip = grip + if grip == 1: + self.closed = True + elif grip == 0 and self.closed: + self.released = True + + def on_rewind_open(self): + self.closed = self.released = False + self.grip = 0 + self.still_run = 0 + + def reset_still(self): + self.still_run = 0 + + def judge(self, q, acts, grip_cmd): + """推論 1 回分を見る. 戻り値 {action: None / "finish" / "regrasp", home_err, still, ...}.""" + q6 = np.asarray(q, dtype=float)[:6] + home_err = np.abs(q6 - np.asarray(HOME, dtype=float)) + still = np.max(np.abs(np.asarray(acts, dtype=float)[:FINISH_LOOK_STEPS, :6] - q6), axis=0) + near = bool(np.all(home_err <= self.home_tol)) + quiet = bool(np.all(still <= self.still_deg)) + info = {"released": self.released, "grip_open": self.grip == 0, "near_home": near, "still": quiet, + "home_err": [round(float(v), 2) for v in home_err], + "delta_max": [round(float(v), 2) for v in still]} + if self.released and grip_cmd == 1: + self.still_run = 0 + info.update(action="regrasp", still_run=0) + return info + # 爪が開いているときだけ (補正の R で開いて閉じ直したあと, 持ったまま HOME で止まっても終えない) + self.still_run = self.still_run + 1 if (self.released and self.grip == 0 and near and quiet) else 0 + info.update(still_run=self.still_run, + action="finish" if self.still_run >= self.need else None) + return info + + +def finish_text(info): + """[FINISH] の 1 行の中身 (HOME からの差と Δ の最大).""" + he, dm = info["home_err"], info["delta_max"] + return (f"HOME からの差 最大 {max(he):.1f}° (j{int(np.argmax(he))}) " + f"Δ (10 ステップ先まで) 最大 {max(dm):.1f}° (j{int(np.argmax(dm))})") + + def plan_correction_step(cur, joint, sign, step, q, lo, hi, max_move): """補正の 1 刻み. cur (今の補正目標) の joint を sign*step 動かし, 推論と同じ apply_limits (実測 q から) と check_send_safe を通す. 戻り値: (目標, notes, unsafe).""" @@ -1179,6 +1267,7 @@ def run_pad_correction(arm, grip, corr_id, chunk, log_f, recorder, lo, hi): def gripper(self, state, gate): def _send(): + notify_grip(state) # 依頼 181 codex R2: 補正の中の閉→開も --auto-finish に数える if recorder is not None: recorder.gripper(state) if state == 1: @@ -1267,7 +1356,7 @@ def write_trial_json(run_dir, run_stem, args, recorded, end_reason, outcome, his """{run_stem}.json. お手本の試行 JSON と同じキー (recording_enabled / result / judgments) を持つ. 結果 y なら pick / place とも human_verdict=yes (build_demo_episodes の採否と同じ読み方).""" verdict = {"y": "yes", "n": "no"}.get(outcome) - result = ("completed" if end_reason in ("h", "q", "max_chunks") else + result = ("completed" if end_reason in ("h", "q", "max_chunks", "auto_finish") else "interrupted" if end_reason == "ctrl_c" else "aborted") j = {"script": "run_policy_client.py", "source": "pi05_policy", "run_stem": run_stem, "run_dir": str(run_dir), "recording_enabled": bool(recorded), "end_reason": end_reason, @@ -1489,7 +1578,21 @@ def main(): "始めの確かめは今までどおり (既定 off = 1 チャンクごとに確かめる. 依頼 178)") ap.add_argument("--speed", type=int, default=SPEED, help=f"推論のチャンクを送る速さ (既定 {SPEED} = 今までと同じ. 補正・巻き戻し・HOME は {SPEED} のまま. 依頼 176)") + ap.add_argument("--auto-finish", action="store_true", + help="つかんで放したあと, HOME 近く (--finish-home-tol) で答えの Δ が小さい (--finish-still-deg) " + "チャンクが --finish-chunks 回続いたら, そのチャンクは送らずに HOME へ戻して終える. 放したあとに " + "また閉じる答えが出たら送らずに入力欄を出す (既定 off = 今までどおり. lab_start.sh が既定で付ける. 依頼 181)") + ap.add_argument("--finish-home-tol", type=float, default=FINISH_HOME_TOL_DEFAULT, + help=f"--auto-finish: HOME からの差 (各関節. 度. 既定 {FINISH_HOME_TOL_DEFAULT:.0f})") + ap.add_argument("--finish-still-deg", type=float, default=FINISH_STILL_DEG_DEFAULT, + help=f"--auto-finish: 10 ステップ先までの Δ (各関節. 度. 既定 {FINISH_STILL_DEG_DEFAULT:.0f})") + ap.add_argument("--finish-chunks", type=int, default=FINISH_CHUNKS_DEFAULT, + help=f"--auto-finish: 続ける回数 (既定 {FINISH_CHUNKS_DEFAULT})") args = ap.parse_args() + if args.auto_finish and not (np.isfinite(args.finish_home_tol) and args.finish_home_tol > 0 + and np.isfinite(args.finish_still_deg) and args.finish_still_deg > 0 + and args.finish_chunks >= 1): + sys.exit("[ERROR] --finish-home-tol と --finish-still-deg は 0 より大きい数, --finish-chunks は 1 以上で指定する") if args.dry_keys and (args.execute or args.auto): sys.exit("[ERROR] --dry-keys はドライラン用 (--execute / --auto と一緒には使えない)") if args.no_step_confirm and args.auto: @@ -1521,8 +1624,10 @@ def main(): "grip_value": GRIP_VALUE, "flow": bool(args.flow), "flow_tol": args.flow_tol, "speed": CHUNK_SPEED, "skip_first_confirm": bool(args.skip_first_confirm), "step_confirm": not args.no_step_confirm, - "host": args.host, "port": args.port, "t": time.time()}, - ensure_ascii=False) + "\n") + "host": args.host, "port": args.port, "t": time.time()} + | ({"auto_finish": {"home_tol": args.finish_home_tol, "still_deg": args.finish_still_deg, + "chunks": args.finish_chunks}} if args.auto_finish else {}), + ensure_ascii=False) + "\n") # auto_finish は付けたときだけ (付けなければ今までと同じ log. codex R3) log_f.flush() # 以降は try/finally の中だけで資源を触る (codex R3: 途中で終了しても cap / log_f を必ず閉じる). @@ -1544,6 +1649,16 @@ def main(): pause_req = None # 止める予約 (log.jsonl の type=pause / event=requested の行). Enter で進めば None hold_confirm = False # 入力欄で s・b・c・p を選んだ. 次の推論でも入力欄を出す (Enter で実行すれば False. codex R1) last_exec_chunk = None # 最後に送り始めた推論の番号 (止める予約の「どのチャンクのあとか」) + # 依頼 181: --auto-finish. つかんで放したあと HOME 近くで止まったら終える / 2 回目のつかみは送らずに入力欄 + finisher = AutoFinish(args.auto_finish, args.finish_home_tol, args.finish_still_deg, args.finish_chunks) + global GRIP_OBSERVER + GRIP_OBSERVER = finisher.on_grip if finisher.enabled else None # 補正・巻き戻しの爪の指令も 1 つずつ数える (codex R2) + regrasp_hold = False # 2 回目のつかみの答えが出た. このチャンクは入力欄を出す + finish_hold = False # 入力欄で s・b・c・p を選んだ (確かめの形によらず). Enter で実行するまで自動で終えない (codex 2 回目 R1) + if args.auto_finish: + print(f"[FINISH] --auto-finish: つかんで放したあと, HOME からの差が各関節 {args.finish_home_tol:g}° 以内で " + f"答えの Δ (10 ステップ先まで) が各関節 {args.finish_still_deg:g}° 以内のチャンクが " + f"{args.finish_chunks} 回続いたら, 送らずに HOME へ戻して終えます. 2 回目のつかみは送らずに止めます") if args.no_step_confirm: print("[PAUSE ] --no-step-confirm: 始めの確かめのあとは入力欄を出さずに進みます. 止めるときはスペース " "(Enter も可). 今のチャンクを送り終えてから, 次の推論のあと (送る前) で入力欄を出します") @@ -1760,10 +1875,61 @@ def main(): skip_now, skip_confirm = skip_confirm and not args.auto, False # 依頼 178: --no-step-confirm は始めの確かめと, 止める予約が入ったときだけ入力欄を出す check_pause(i, "infer") + # 依頼 181: --auto-finish. 送る前に, 置き終えたか・2 回目のつかみかを見る + regrasp_hold = False + fin = finisher.judge(q, acts, grip_cmd) if finisher.enabled else None + if fin is not None: + rec["finish_check"] = {"still_run": fin["still_run"], "near_home": fin["near_home"], + "still": fin["still"], "released": fin["released"], + "home_err_max": max(fin["home_err"]), "delta_max": max(fin["delta_max"])} + fe = {"type": "finish", "chunk": i, "released": fin["released"], + "home_tol": finisher.home_tol, "still_deg": finisher.still_deg, "chunks": finisher.need, + "still_run": fin["still_run"], "home_err": fin["home_err"], "delta_max": fin["delta_max"]} + if fin is not None and fin["action"] == "regrasp": + # 放したあとにまた閉じる答え (182327 の空振り). このチャンクは送らずに入力欄を出す + rec["regrasp_stop"] = True + log_f.write(json.dumps(dict(fe, event="regrasp", reason="close_after_release", + t=time.time())) + "\n") + log_f.flush() + print(f" [FINISH] 放したあとにまた閉じる答え (2 回目のつかみ). 推論 {i} は送らずに止めます " + + finish_text(fin)) + if args.auto: + # --auto は入力欄を出せないので, 送らずにそのまま終える (アームは動かさない) + end_reason, exit_code = "regrasp", 1 + log_f.write(json.dumps(rec) + "\n"); log_f.flush() + break + regrasp_hold = True + elif fin is not None and fin["action"] == "finish": + if pause_req is not None or hold_confirm or finish_hold: + # 人が止めた (スペース・s・b・c・p のあと) ときは入力欄を優先する (勝手に HOME へ動かさない) + print(f" [FINISH] 終わる条件を満たしたが, 止めているので入力欄を出します {finish_text(fin)}") + else: + end_reason = "auto_finish" + step_pause.disarm() # 結果の入力の前に端末の設定を元に戻す + log_f.write(json.dumps(dict(fe, event="auto_finish", + reason="released_near_home_still", t=time.time())) + "\n") + log_f.flush() + print(f" [FINISH] 置き終えたので終えます (放したあと HOME 近くで止まったチャンクが " + f"{fin['still_run']} 回続いた). 推論 {i} は送らずに HOME へ戻します " + finish_text(fin)) + rec["auto_finish"] = True + if recorder is not None: + recorder.set_mode(MODE_HOME) + if args.dry_keys: + print(" [DRY ] HOME へは送らない (ドライラン)") + else: + # h と同じ送り方 + ok_home, _ = _send_and_wait_arrival(HOME, "pi05_home", 2.5, send_wait_sec=SEND_WAIT) + rec["home_requested"] = True + rec["home_arrived"] = bool(ok_home) + log_f.write(json.dumps(rec) + "\n"); log_f.flush() + if recorder is not None: + recorder.stop() + outcome = ask_outcome() + break need_confirm = ((not args.no_step_confirm) or first_confirm or pause_req is not None - or hold_confirm) + or hold_confirm or regrasp_hold) first_confirm = False - if skip_now and pause_req is None: + if skip_now and pause_req is None and not regrasp_hold: # 依頼 177: lab_start.sh の 2 回目からの試行は, 始めの確かめ (Enter) を待たずに実行する. # 2 回目からの確かめ・補正・巻き戻し・止める操作は今までどおり print(" [CONFIRM] 2 回目からの試行なので始めの確かめ (Enter) を待たずに実行します " @@ -1860,6 +2026,11 @@ def main(): break if recorder is not None and ans not in ("q", "h"): recorder.set_mode(MODE_MODEL) + if ans in ("s", "b", "c", "p"): + finisher.reset_still() # 依頼 181: 人が手を入れたら「続いた」を数え直す + finish_hold = True # Enter で実行するまでは自動で終えずに入力欄を出す (codex 2 回目 R1) + elif ans == "": + finish_hold = False if args.no_step_confirm: # 依頼 178: 入力欄を出していた時刻 (送らなかったチャンクも chunk_timing の確認待ちに入れる. codex R5) rec["prompt_t"] = [t_prompt0, time.time()] @@ -1904,6 +2075,7 @@ def main(): n_rewinds += 1 if rw.get("gripper_opened"): grip = 0 + finisher.on_rewind_open() # 依頼 181: つかんだ区間を戻した (ブロックは元の位置) if grasp == GRASP_DROPPED and entry["kind"] == "chunk": rw["start_frame"] = str(log_dir / "frames" / f"{entry['chunk']:04d}.jpg") if not rw["finished"]: @@ -1935,6 +2107,7 @@ def main(): with KeyReader() as keys: cr, grip = run_correction(arm, keys, lo, hi, args.max_move_deg, grip, n_corrections, i, log_f, recorder) + finisher.on_grip(grip) # 依頼 181: 補正で爪を動かした (g で放したのも数える) if cr is not None: log_f.write(json.dumps(cr) + "\n"); log_f.flush() if cr["grip_used"] or cr.get("regrip_used"): @@ -1977,6 +2150,7 @@ def main(): if grip_cmd is not None: arm.gripper(grip_cmd) grip = grip_cmd + finisher.on_grip(grip) history.append({"kind": "chunk", "chunk": i, "correction_id": None, "start_pose": q[:6].copy(), "sent_targets": sent, "grip_changed": grip_cmd is not None, "grip_cmd": grip_cmd, @@ -2134,6 +2308,7 @@ def main(): recorder.gripper(grip_cmd) gripper_cmd(grip_cmd) grip = grip_cmd + finisher.on_grip(grip) # 依頼 181: つかんだ・放したを数える rec["executed"] = True # 巻き戻し (b) 用に, この推論で実際に送った目標と始めの姿勢 (実測) を残す. # 途中で止まった (broke) 推論も, 1 点でも送っていれば残す (codex R1-3: @@ -2187,6 +2362,7 @@ def main(): print("\n[STOP ] Ctrl-C") end_reason = "ctrl_c" finally: + GRIP_OBSERVER = None # 依頼 181: この試行の判定器を外す try: step_pause.disarm() # 依頼 178: Ctrl-C・例外でも端末の設定を必ず元に戻す except Exception as e: diff --git a/pi05/test_auto_finish.py b/pi05/test_auto_finish.py new file mode 100644 index 0000000..7c9da3d --- /dev/null +++ b/pi05/test_auto_finish.py @@ -0,0 +1,464 @@ +#!/usr/bin/env python3 +"""test_auto_finish.py — 箱に置き終えたら自動で終わる --auto-finish の確かめ (依頼 181. アームなし). + + python3 pi05/test_auto_finish.py # 全部 + python3 pi05/test_auto_finish.py -v + python3 pi05/test_auto_finish.py --table # Log35 の 7 本を流して, チャンクごとの値と何チャンク目で終わるかを表で出す + + - Log35 (2026-11-14) の 7 本の log.jsonl を AutoFinish に流し, 何チャンク目で終わる判定になるかを確かめる + (182327 は 2 回目のつかみ (チャンク 51) の前に終わる. 置く前・運ぶ途中では終わらない). KIOXIA がなければ飛ばす + - run_policy_client を test_rewind_correct.run_client (偽の daemon / カメラ / モデル) で通し, + つかんで放して HOME で止まったら, そのチャンクは送らずに HOME へ (h と同じ送り方)・結果を聞く・type=finish の行 + - 放したあとにまた閉じる答えが出たら送らずに入力欄 (画面に [FINISH]). --auto なら送らずに終える + - 止める予約 (スペース) があるときは入力欄を優先する + - 付けなければ git HEAD の版と同じ送り方・同じ log (項目も増えない) +KIOXIA は読むだけ (書かない). アームには触らない (一時フォルダだけ). +""" +import importlib.util +import json +import subprocess +import sys +import tempfile +import time +import unittest +from pathlib import Path + +import numpy as np + +_HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(_HERE)) + +import chunk_timing as ct # noqa: E402 +import run_policy_client as rpc # noqa: E402 +import test_no_step_confirm as tnsc # noqa: E402 +from test_rewind_correct import FakePolicy, run_client, strip # noqa: E402 + +RUNS = Path("/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy") +# Log35 の 7 本と, 既定 (8°・3°・2 回) で終わる判定になるチャンク (None = 記録の終わりまでに終わらない) +# 181057: 放したあと HOME に戻らないうちに人が止めた (HOME からの差 27.6° 以上) +# 182211: HOME 近くで止まったチャンクが 1 回だけ (チャンク 12) のところで人が止めた +LOG35 = {"pi05_20261114_180457": 17, "pi05_20261114_180704": None, "pi05_20261114_181057": None, + "pi05_20261114_181300": 20, "pi05_20261114_182039": 15, "pi05_20261114_182211": None, + "pi05_20261114_182327": 17} +EXEC = ["--execute", "--steps-per-chunk", "10", "--via-stride", "3", "--settle-retries", "0", + "--state-from-target", "--ignore-framing"] + + +def replay(run_dir, fin=None, stop=True): + """log.jsonl の推論の行を順に AutoFinish に流す. 戻り値 (終わる判定のチャンク or None, 2 回目のつかみのチャンク, 行). + 推論の前の実測角 (measured_state) と答え (actions) で判定し, 実行したチャンクの爪の指令で つかんだ・放した を数える + (client と同じ順). 終わる判定が出たらそこで止める (そのチャンクは送らない).""" + fin = fin or rpc.AutoFinish(True) + rows, regrasp = [], None + for line in (Path(run_dir) / "log.jsonl").read_text().splitlines(): + r = json.loads(line) + if r.get("type") is not None or "actions" not in r: + continue + info = fin.judge(r["measured_state"][:6], np.asarray(r["actions"]), r.get("grip_cmd")) + rows.append(dict(info, chunk=r["chunk"], grip_cmd=r.get("grip_cmd"), executed=r.get("executed"))) + if info["action"] == "finish" and stop: + return r["chunk"], regrasp, rows + if info["action"] == "regrasp" and regrasp is None: + regrasp = r["chunk"] + if r.get("executed") and r.get("grip_cmd") is not None: + fin.on_grip(r["grip_cmd"]) + return None, regrasp, rows + + +def first_release(run_dir): + """最初に閉じたあとで開いたチャンク (実行したもの).""" + closed = False + for line in (Path(run_dir) / "log.jsonl").read_text().splitlines(): + r = json.loads(line) + if r.get("type") is not None or not r.get("executed"): + continue + if r.get("grip_cmd") == 1: + closed = True + elif r.get("grip_cmd") == 0 and closed: + return r["chunk"] + return None + + +def print_table(): + """Log35 の 7 本: 放したあとのチャンクごとの値 (既定の判定. 終わる判定のあとも記録の終わりまで出す).""" + for name in LOG35: + d = RUNS / name + if not (d / "log.jsonl").exists(): + print(f"{name}: log.jsonl がない") + continue + rel = first_release(d) + end, regrasp, _ = replay(d) + _, _, rows = replay(d, stop=False) + print(f"== {name} 放したチャンク {rel} 終わる判定 {end} 2 回目のつかみ {regrasp}") + print(" chunk HOMEからの差(最大) Δ10ステップ(最大) 続いた") + for r in rows: + if rel is None or r["chunk"] <= rel: + continue + print(f" {r['chunk']:>5} {max(r['home_err']):>8.1f} (j{int(np.argmax(r['home_err']))})" + f" {max(r['delta_max']):>8.1f} (j{int(np.argmax(r['delta_max']))}) {r['still_run']:>4}" + + (" ← 終わる" if r["chunk"] == end else "") + + (" ← 2回目のつかみ" if r["action"] == "regrasp" else "")) + + +class TestLog35(unittest.TestCase): + def setUp(self): + if not RUNS.exists(): + self.skipTest("KIOXIA の Log35 の記録がない") + + def test_finish_chunks(self): + for name, want in LOG35.items(): + d = RUNS / name + if not (d / "log.jsonl").exists(): + self.skipTest(f"{name} がない") + end, regrasp, rows = replay(d) + self.assertEqual(end, want, name) + rel = first_release(d) + self.assertIsNotNone(rel, name) + # 置く前・運ぶ途中 (放したチャンクまで) では終わらない + self.assertTrue(end is None or end > rel, name) + # 運ぶ途中は HOME からの差が既定より大きい (つかむ前に HOME 近くにいるのは始めだけ) + for r in rows: + if r["chunk"] <= rel: + self.assertFalse(r["released"], (name, r["chunk"])) + + def test_182327_finishes_before_second_grasp(self): + d = RUNS / "pi05_20261114_182327" + if not (d / "log.jsonl").exists(): + self.skipTest("182327 がない") + end, regrasp, _ = replay(d) + self.assertEqual(end, 17) + self.assertIsNone(regrasp) # 終わったので 2 回目のつかみまで行かない + # 終わる判定を外して流すと, チャンク 51 の閉じる答えを 2 回目のつかみとして止める + _, regrasp2, _ = replay(d, rpc.AutoFinish(True, 1e-9, 1e-9, 10 ** 9)) + self.assertEqual(regrasp2, 51) + + +class TestAutoFinishUnit(unittest.TestCase): + def acts(self, q, d=0.5): + a = np.zeros((10, 7)) + a[:, :6] = np.asarray(q) + d + return a + + def test_needs_grasp_and_release(self): + f = rpc.AutoFinish(True) + home = np.array(rpc.HOME) + for _ in range(5): # まだつかんでいない: HOME で止まっていても終わらない + self.assertIsNone(f.judge(home, self.acts(home), None)["action"]) + f.on_grip(0) + self.assertIsNone(f.judge(home, self.acts(home), None)["action"]) # 開いただけ (閉じていない) + f.on_grip(1) + self.assertIsNone(f.judge(home, self.acts(home), None)["action"]) # 閉じたまま + f.on_grip(0) + self.assertEqual(f.judge(home, self.acts(home), None)["still_run"], 1) + self.assertEqual(f.judge(home, self.acts(home), None)["action"], "finish") + + def test_thresholds_and_reset(self): + f = rpc.AutoFinish(True) + f.on_grip(1); f.on_grip(0) + home = np.array(rpc.HOME) + far = home + np.array([0, 8.5, 0, 0, 0, 0]) + self.assertIsNone(f.judge(far, self.acts(far), None)["action"]) # 8° より遠い + self.assertEqual(f.still_run, 0) + self.assertEqual(f.judge(home + 8.0, self.acts(home + 8.0), None)["still_run"], 1) # ちょうど 8° は入る + self.assertEqual(f.judge(home, self.acts(home, 3.5), None)["still_run"], 0) # Δ 3.5° は動いている + self.assertEqual(f.judge(home, self.acts(home, 3.0), None)["still_run"], 1) + f.reset_still() + self.assertEqual(f.judge(home, self.acts(home), None)["still_run"], 1) # 数え直し + self.assertEqual(f.judge(home, self.acts(home), None)["action"], "finish") + + def test_looks_only_first_10_steps(self): + """答えが 10 ステップより長くても, 先頭 10 ステップ (1 秒先まで) だけを見る (codex R1).""" + f = rpc.AutoFinish(True) + f.on_grip(1); f.on_grip(0) + home = np.array(rpc.HOME) + a = np.zeros((50, 7)) + a[:, :6] = home + 0.5 + a[10:, 0] = 20.0 + self.assertEqual([f.judge(home, a, None)["action"] for _ in range(2)], [None, "finish"]) + a[9, 0] = 20.0 # 10 ステップ目は見る + self.assertEqual(f.judge(home, a, None)["still_run"], 0) + + def test_not_while_holding(self): + """開いてから閉じ直した (補正の R) あとは, 持ったまま HOME で止まっても終えない.""" + f = rpc.AutoFinish(True) + home = np.array(rpc.HOME) + f.on_grip(1); f.on_grip(0); f.on_grip(1) + self.assertEqual([f.judge(home, self.acts(home), None)["action"] for _ in range(3)], [None] * 3) + f.on_grip(0) + self.assertEqual([f.judge(home, self.acts(home), None)["action"] for _ in range(2)], [None, "finish"]) + + def test_regrasp_and_rewind(self): + f = rpc.AutoFinish(True) + home = np.array(rpc.HOME) + self.assertIsNone(f.judge(home, self.acts(home), 1)["action"]) # 1 回目のつかみはそのまま + f.on_grip(1); f.on_grip(0) + self.assertEqual(f.judge(home, self.acts(home), 1)["action"], "regrasp") + f.on_rewind_open() # つかんだ区間を巻き戻した: つかんだこと自体を忘れる + self.assertIsNone(f.judge(home, self.acts(home), 1)["action"]) + self.assertIsNone(f.judge(home, self.acts(home), None)["action"]) + + +class PlacePolicy(FakePolicy): + """つかむ → 運ぶ → 放す → HOME へ戻る → HOME で小さく動き続ける (Log35 の形). regrasp=True なら HOME に + 戻ったあとでまた閉じる答えを出す (182327 の空振り). 状態 (state) と自分の段で答えを決める (画像は見ない).""" + regrasp = False + + def __init__(self, *a, **k): + super().__init__(*a, **k) + self.held = self.released = False + self.home_chunks = 0 + + def infer(self, obs): + s = np.asarray(obs["observation/state"], dtype=float) + holding = s[6] > 0.5 + if holding: + self.held = True + elif self.held: + self.released = True + acts = np.zeros((10, 7)) + home = np.array(rpc.HOME) + for k in range(10): + if self.released: + a = s[:6] + (home - s[:6]) * min(1.0, (k + 1) / 5) + if np.max(np.abs(s[:6] - home)) < 3: + a = s[:6] + 0.3 * ((k % 2) * 2 - 1) # HOME 近くで小さく動く (±0.3°) + acts[k, :6] = a + acts[k, 6] = 1.0 if (self.regrasp and np.max(np.abs(s[:6] - home)) < 3 and k >= 3) else 0.0 + elif holding: + acts[k, :6] = s[:6] + np.array([1.0, 0, 0, 0, 0, 0]) * (k + 1) + acts[k, 6] = 0.0 if (s[0] >= 30 and k >= 3) else 1.0 + else: + acts[k, :6] = s[:6] + (np.array([2.0, 0, 0, 0, 0, 0]) * (k + 1) if s[0] < 10 else 0) + acts[k, 6] = 1.0 if (s[0] >= 10 and k >= 3) else 0.0 + return {"actions": acts} + + +class RegraspPolicy(PlacePolicy): + regrasp = True + + +def chunks(lines): + return [x for x in lines if x.get("type") is None and "chunk" in x] + + +class TestClientAutoFinish(unittest.TestCase): + def setUp(self): + self.td = Path(tempfile.mkdtemp()) + time.sleep(1.1) + + def test_finish_goes_home_and_asks(self): + code, world, run, lines, out = run_client( + rpc, EXEC + ["--max-chunks", "20", "--no-step-confirm", "--auto-finish"], ["", "y"], self.td, + policy_cls=PlacePolicy) + self.assertEqual(code, 0, out) + fins = [x for x in lines if x.get("type") == "finish"] + self.assertEqual(len(fins), 1, out) + f = fins[0] + self.assertEqual(f["event"], "auto_finish") + self.assertEqual(f["still_run"], 2) + self.assertTrue(f["released"]) + self.assertEqual((f["home_tol"], f["still_deg"], f["chunks"]), (8.0, 3.0, 2)) + self.assertEqual(len(f["home_err"]), 6) + self.assertEqual(len(f["delta_max"]), 6) + ch = chunks(lines) + last = ch[-1] + self.assertEqual(last["chunk"], f["chunk"]) + self.assertTrue(last["auto_finish"]) + self.assertFalse(last["executed"]) # 終わったチャンクは送らない + self.assertTrue(last["home_requested"] and last["home_arrived"]) + self.assertFalse(any(s[0].startswith(f"pi05_chunk{last['chunk']:03d}") for s in world.sends)) + self.assertEqual(world.sends[-1][0], "pi05_home") + self.assertEqual(world.sends[-1][1], [0.0, 0.0, 0.0, 0.0, 0.0, -30.0]) + self.assertLess(last["chunk"], 19) + # 開いたチャンクのあと, HOME に戻ってから 2 チャンクで終わる + rel = [x["chunk"] for x in ch if x.get("grip_cmd") == 0 and x["executed"]][0] + self.assertGreater(last["chunk"], rel) + self.assertIn("[FINISH] 置き終えたので終えます", out) + self.assertIn("[FINISH] --auto-finish:", out) + trial = json.loads((run / f"{run.name}.json").read_text()) + self.assertEqual(trial["end_reason"], "auto_finish") + self.assertEqual(trial["result"], "completed") + self.assertEqual(trial["outcome"], "success") + self.assertEqual(lines[0]["auto_finish"], {"home_tol": 8.0, "still_deg": 3.0, "chunks": 2}) + self.assertIsNone(rpc.GRIP_OBSERVER) # 終わったら判定器を外す + # chunk_timing の終わり方 + reason, text = ct.end_how(run, ch) + self.assertEqual(reason, "auto_finish") + self.assertIn("自動で終わった", text) + self.assertIn("自動で終えた", ct.chunk_rows(ch)[-1]["note"]) + + def test_finish_with_step_confirm(self): + """チャンクごとに確かめる形でも, 終わる判定のチャンクは入力欄を出さずに HOME へ (近いので小さく動くだけ).""" + code, world, run, lines, out = run_client( + rpc, EXEC + ["--max-chunks", "20", "--auto-finish"], [""] * 7 + ["n"], self.td, policy_cls=PlacePolicy) + self.assertEqual(code, 0, out) + self.assertEqual(world.sends[-1][0], "pi05_home") + self.assertEqual(json.loads((run / f"{run.name}.json").read_text())["end_reason"], "auto_finish") + + def test_custom_chunks(self): + code, world, run, lines, out = run_client( + rpc, EXEC + ["--max-chunks", "20", "--no-step-confirm", "--auto-finish", "--finish-chunks", "3"], + ["", "y"], self.td, policy_cls=PlacePolicy) + self.assertEqual(code, 0, out) + f = [x for x in lines if x.get("type") == "finish"][0] + self.assertEqual(f["still_run"], 3) + self.assertEqual(lines[0]["auto_finish"]["chunks"], 3) + + def test_regrasp_stops_with_prompt(self): + code, world, run, lines, out = run_client( + rpc, EXEC + ["--max-chunks", "20", "--no-step-confirm", "--auto-finish", "--finish-chunks", "5"], + ["", "h", "y"], self.td, policy_cls=RegraspPolicy) + self.assertEqual(code, 0, out) + re_ = [x for x in lines if x.get("type") == "finish"] + self.assertEqual([x["event"] for x in re_], ["regrasp"], out) + ch = chunks(lines) + last = ch[-1] + self.assertEqual(last["chunk"], re_[0]["chunk"]) + self.assertTrue(last["regrasp_stop"]) + self.assertFalse(last["executed"]) + self.assertEqual(last["grip_cmd"], 1) + self.assertIn("[FINISH] 放したあとにまた閉じる答え (2 回目のつかみ)", out) + # 2 回目の閉じる指令は送っていない (始めの開く・1 回目の閉じる・放す だけ) + closes = [g for g in world.grips if g == 1 or (isinstance(g, tuple) and g[0] == "v")] + self.assertEqual(len(closes), 1, world.grips) + self.assertEqual(world.sends[-1][0], "pi05_home") # h で戻した + self.assertIn("2回目のつかみ", ct.chunk_rows(ch)[-1]["note"]) + self.assertIn("2 回目のつかみで止めた 1 回", ct.end_how(run, ch)[1]) + + def test_regrasp_enter_sends(self): + """2 回目のつかみで Enter を押せば今までどおり送る (人の判断).""" + code, world, run, lines, out = run_client( + rpc, EXEC + ["--max-chunks", "20", "--no-step-confirm", "--auto-finish", "--finish-chunks", "5"], + ["", "", "q", ""], self.td, policy_cls=RegraspPolicy) + self.assertEqual(code, 0, out) + ch = chunks(lines) + sent_regrasp = [x for x in ch if x.get("regrasp_stop") and x["executed"]] + self.assertEqual(len(sent_regrasp), 1, out) + closes = [g for g in world.grips if g == 1 or (isinstance(g, tuple) and g[0] == "v")] + self.assertEqual(len(closes), 2, world.grips) + + def test_close_open_in_correction_counts(self): + """補正 (c) の中で g で閉じて g で開いた (つかんで放した) のも数える (codex R2). そのあとの閉じる答えは 2 回目の + つかみとして止め, HOME で止まったら終える.""" + class StayHomePolicy(FakePolicy): + calls = 0 + + def infer(self, obs): + StayHomePolicy.calls += 1 + s = np.asarray(obs["observation/state"], dtype=float) + acts = np.zeros((10, 7)) + acts[:, :6] = s[:6] + 0.3 + acts[:, 6] = 1.0 if StayHomePolicy.calls == 2 else 0.0 # 補正のあとの 1 回目だけ閉じる答え + return {"actions": acts} + + code, world, run, lines, out = run_client( + rpc, EXEC + ["--max-chunks", "10", "--no-step-confirm", "--auto-finish"], + ["c", "s", "", "y"], self.td, keys="gg\n", policy_cls=StayHomePolicy) + self.assertEqual(code, 0, out) + ev = [x["event"] for x in lines if x.get("type") == "finish"] + self.assertEqual(ev, ["regrasp", "auto_finish"], out) + self.assertEqual(world.sends[-1][0], "pi05_home") + closes = [g for g in world.grips if g == 1 or (isinstance(g, tuple) and g[0] == "v")] + self.assertEqual(len(closes), 1, world.grips) # 閉じたのは補正の g だけ + + def test_hold_after_s_with_step_confirm(self): + """チャンクごとに確かめる形で --finish-chunks 1 でも, c・s のあとは自動で終えずに入力欄 (codex 2 回目 R1). + HOME で止まっている腕を, 始めの確かめで c → g (閉) → g (開) にしてから流す.""" + class StillPolicy(FakePolicy): + def infer(self, obs): + s = np.asarray(obs["observation/state"], dtype=float) + acts = np.zeros((10, 7)) + acts[:, :6] = s[:6] + 0.3 + return {"actions": acts} + + code, world, run, lines, out = run_client( + rpc, EXEC + ["--max-chunks", "10", "--auto-finish", "--finish-chunks", "1"], + ["c", "s", "", "y"], self.td, keys="gg\n", policy_cls=StillPolicy) + self.assertEqual(code, 0, out) + ch = chunks(lines) + self.assertEqual([x["event"] for x in lines if x.get("type") == "finish"], ["auto_finish"], out) + # c・s を選んだあとの推論 (終わる条件は満たしている) では終えず, Enter で実行したあとの推論で終える + self.assertEqual(out.count("[FINISH] 終わる条件を満たしたが, 止めているので入力欄を出します"), 2, out) + self.assertEqual([x["chunk"] for x in ch], [0, 1, 2, 3]) + self.assertTrue(ch[2]["executed"]) + self.assertTrue(ch[3]["auto_finish"]) + self.assertEqual(world.sends[-1][0], "pi05_home") + + def test_regrasp_auto_ends(self): + code, world, run, lines, out = run_client( + rpc, EXEC + ["--max-chunks", "20", "--auto", "--auto-finish", "--finish-chunks", "5"], ["y"], self.td, + policy_cls=RegraspPolicy) + self.assertEqual(code, 1, out) + last = chunks(lines)[-1] + self.assertTrue(last["regrasp_stop"]) + self.assertFalse(last["executed"]) + self.assertFalse(any(s[0] == "pi05_home" for s in world.sends)) # 勝手に動かさない + self.assertEqual(json.loads((run / f"{run.name}.json").read_text())["end_reason"], "regrasp") + + def test_pause_wins_over_finish(self): + """止める予約 (スペース) が入っていれば, 終わる条件を満たしても入力欄を出す (勝手に HOME へ動かさない).""" + class HomeCountPolicy(PlacePolicy): + home_infers = 0 + + def infer(self, obs): + s = np.asarray(obs["observation/state"], dtype=float) + if self.released and np.max(np.abs(s[:6] - np.array(rpc.HOME))) < 3: + HomeCountPolicy.home_infers += 1 + return super().infer(obs) + + class SpaceAtSecondHome(tnsc.FakeKeys): + def _read_pending(self): + self.n_poll += 1 + return " " if HomeCountPolicy.home_infers >= 2 else "" + + from unittest import mock + with mock.patch.object(rpc, "PauseKeys", SpaceAtSecondHome): + code, world, run, lines, out = run_client( + rpc, EXEC + ["--max-chunks", "20", "--no-step-confirm", "--auto-finish"], + ["", "h", "y"], self.td, policy_cls=HomeCountPolicy) + self.assertEqual(code, 0, out) + self.assertEqual([x for x in lines if x.get("type") == "finish"], []) + last = chunks(lines)[-1] + self.assertTrue(last.get("paused")) + self.assertEqual(last["finish_check"]["still_run"], 2) # 終わる条件は満たしていた + self.assertIn("[FINISH] 終わる条件を満たしたが, 止めているので入力欄を出します", out) + self.assertEqual(json.loads((run / f"{run.name}.json").read_text())["end_reason"], "h") + + +class TestUnchangedWithoutFlag(unittest.TestCase): + """付けなければ git HEAD の版と同じ送り方・同じ log (項目も増えない. codex R3).""" + def test_same_as_head(self): + src = subprocess.run(["git", "show", "HEAD:pi05/run_policy_client.py"], cwd=_HERE, + capture_output=True, text=True) + if src.returncode != 0: + self.skipTest("git HEAD の版が読めない") + td = Path(tempfile.mkdtemp()) + p = td / "run_policy_client_head.py" + p.write_text(src.stdout) + spec = importlib.util.spec_from_file_location("run_policy_client_head", p) + old = importlib.util.module_from_spec(spec) + spec.loader.exec_module(old) + drop = ("t", "latency_s", "reference", "t_start", "t_end", "t_exec_start", "t_exec_end", + "ended_at", "segment_t", "prompt_t", "requested_t") + for argv, inputs, pol in ( + (EXEC + ["--max-chunks", "14", "--no-step-confirm"], ["", "h", "y"], PlacePolicy), + (EXEC + ["--max-chunks", "10"], [""] * 9 + ["q", ""], RegraspPolicy), + (EXEC + ["--max-chunks", "6", "--no-step-confirm"], ["", "c", "b", "s", "", "h", "y"], None)): + time.sleep(1.1) + c_old, w_old, _, l_old, o_old = run_client(old, argv, inputs, td, policy_cls=pol, keys="1++\n") + time.sleep(1.1) + c_new, w_new, _, l_new, o_new = run_client(rpc, argv, inputs, td, policy_cls=pol, keys="1++\n") + self.assertEqual(c_old, c_new, argv) + self.assertEqual(w_old.sends, w_new.sends, argv) + self.assertEqual(w_old.grips, w_new.grips, argv) + self.assertEqual(strip(l_old, drop=drop), strip(l_new, drop=drop), argv) + self.assertNotIn("[FINISH]", o_new) + self.assertTrue(all("auto_finish" not in x and "finish_check" not in x for x in l_new)) # 頭にも足さない (codex R3) + self.assertIsNone(rpc.GRIP_OBSERVER) + + +if __name__ == "__main__": + if "--table" in sys.argv: + print_table() + sys.exit(0) + unittest.main() diff --git a/test_lab_start.sh b/test_lab_start.sh index df1279f..c7cd4e6 100755 --- a/test_lab_start.sh +++ b/test_lab_start.sh @@ -600,7 +600,7 @@ check "--serve-only でも空打ちまで行う (依頼 176)" 'has out.txt "=== check "Pod は消さない (DELETE を呼ばない) で, かかった時間と片付け方を出す" '[ $(n_call DELETE) = 0 ] && has out.txt "=== かかった時間" && has out.txt "Pod は残しています (id $ID_NEW). 片付けは ./lab_stop.sh --log LogT"' check "記録 lab_start_*.txt に残る・始めの行に --serve-only と出る" 'grep -qF "サーバーとトンネルだけ (--serve-only" "$T/data/lab/LogT"/lab_start_*.txt' rm -rf "$T" -check "--help に --serve-only・--grip-value・--flow / --speed・5b の空打ちの説明が入る (2〜61 行)" 'sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "--serve-only Pod を作って" && sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "--no-tilt-fix 傾きを" && sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "--grip-value N 爪の閉じる値" && sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "--flow / --speed N run_policy_client.py に" && sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "# 5b. 空打ち" && grep -qF "sed -n '"'"'2,61p'"'"'" "$HERE/lab_start.sh"' +check "--help に --serve-only・--grip-value・--flow / --speed・5b の空打ちの説明が入る (2〜64 行)" 'sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--serve-only Pod を作って" && sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--no-tilt-fix 傾きを" && sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--grip-value N 爪の閉じる値" && sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--flow / --speed N run_policy_client.py に" && sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "# 5b. 空打ち" && grep -qF "sed -n '"'"'2,64p'"'"'" "$HERE/lab_start.sh"' echo "== 空打ち (依頼 176): トンネルのあと・アームの前に 1 回. 失敗しても止めずに続ける" setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run @@ -660,7 +660,17 @@ setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run --step-confirm -- check "--step-confirm なら --no-step-confirm を渡さず (ほかの引数は同じ), [CONFIRM] で出す" '[ $RC = 0 ] && has py.log "pi05/run_policy_client.py" && ! has py.log "--no-step-confirm" && grep -q -- "pi05/run_policy_client.py .* --flow$" "$T/py.log" && has out.txt "[CONFIRM] チャンクごとに確かめる (--step-confirm"' rm -rf "$T" check "実機の 8 にも既定で --no-step-confirm を渡す (8 の 2 か所)" '[ "$(grep -c '"'"'${STEP_ARGS\[@\]+"${STEP_ARGS\[@\]}"}'"'"' "$HERE/lab_start.sh")" = 2 ] && grep -qF "STEP_ARGS=(--no-step-confirm)" "$HERE/lab_start.sh" && grep -qF -- "--step-confirm) STEP_ARGS=(); shift ;;" "$HERE/lab_start.sh"' -check "--help に --step-confirm の説明が入る" 'sed -n "2,61p" "$HERE/lab_start.sh" | grep -qF -- "--step-confirm 実機推論で"' +check "--help に --step-confirm の説明が入る" 'sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--step-confirm 実機推論で"' + +echo "== 置き終えたら自動で終わる (依頼 181): 既定は --auto-finish を渡す. --no-auto-finish で今までどおり" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run +check "既定ではクライアントに --auto-finish を渡し, [FINISH] で出す" '[ $RC = 0 ] && [ "$(grep -c -- "pi05/run_policy_client.py .* --auto-finish" "$T/py.log")" = 1 ] && has out.txt "[FINISH] 箱に置き終えたら自動で終わる (--auto-finish"' +rm -rf "$T" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run --no-auto-finish --flow +check "--no-auto-finish なら --auto-finish を渡さず (ほかの引数は同じ), [FINISH] で出す" '[ $RC = 0 ] && has py.log "pi05/run_policy_client.py" && ! has py.log "--auto-finish" && grep -q -- "pi05/run_policy_client.py .* --no-step-confirm --flow$" "$T/py.log" && has out.txt "[FINISH] 置き終えても自動では終わらない (--no-auto-finish"' +rm -rf "$T" +check "実機の 8 にも既定で --auto-finish を渡す (8 の 2 か所)" '[ "$(grep -c '"'"'${FINISH_ARGS\[@\]+"${FINISH_ARGS\[@\]}"}'"'"' "$HERE/lab_start.sh")" = 2 ] && grep -qF "FINISH_ARGS=(--auto-finish)" "$HERE/lab_start.sh" && grep -qF -- "--no-auto-finish) FINISH_ARGS=(); shift ;;" "$HERE/lab_start.sh"' +check "--help に --no-auto-finish の説明が入る" 'sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--no-auto-finish 箱に置き終えたら" && ./lab_start.sh --help | grep -qF -- "--no-auto-finish"' echo echo "OK $OK / NG $NG" ``` ## 依頼182：1チャンクを2つの中継点で送れるようにする 1チャンクの動きを決めていたのが中継点を送る間隔だったので、中継点の数を減らせるようにしました。`lab_start.sh` に `--via-stride` を足し、5 にすると、10個の姿勢のうち5番目と10番目の2点だけを送ります。2点なら、1チャンクは1.2秒ほどになる見込みです。お手本の1チャンク（1秒）にかなり近づきます。 中継点を減らすと、1点あたりの動きが大きくなります。今の決まりでは、1回で20°より大きく動かす指令は20°に切って送ります。この回の7回の記録の答えから計算すると、2点にしたときの1点あたりの動きは最大15.8°で、20°を超える点はありませんでした。`--flow` の遅れ（中央1.4°・最大2.5°）を足しても約18.3°です。2点で動きがカクッとしないかは、実機で見る必要があります。 ### 依頼182 の依頼文 ```markdown --- 作業フォルダ: /Users/shimazueiichi/r2r2r-scripts 上限時間: 60 --- # 依頼182：実機推論の 1 チャンクを少ない中継点で送れるようにする 実機は動かさない（実装・テスト・レビューまで）。Log35。依頼181 のあとに回す（同じファイルを触るため）。 ## なぜ Log35 で --flow の速さ 20 と 30 を比べたら、1 チャンクの動いた時間の中央値はどちらも 2.2〜2.35 秒で変わらなかった（chunk_timing.py。180457・180704・182039・182211・182327）。 今は lab_start.sh が --via-stride 3 で 1 チャンクを 4 点（step 2, 5, 8, 9）に分けて送り、--flow の送る間隔の下限 0.4 秒と各点 0.5 秒前後で、合わせて 2 秒ほどになっている。お手本の 1 チャンクは 1 秒。 エイイチの決め（2026-11-14）：中継点を減らして試す。 ## やること 1. lab_start.sh に --via-stride N を足し、run_policy_client.py にそのまま渡す（既定は今の 3 のまま）。起動時に [VIA ] の行で値を出す 2. --via-stride 5（step 4, 9 の 2 点）で、今の決まり（max_move 20°・安全範囲・--flow の判定）のまま送れることを確かめる。1 点あたりの移動量が大きくなるので、Log35 の 7 本の log.jsonl の答えから、stride 3 と 5 のときの 1 点あたりの最大の移動量を計算して表にし、max_move 20° に引っかかる点があるかを報告に書く（直さない） 3. --speed は 20 に戻して比べる前提で、エイイチが実機で比べるコマンド（stride 3 と 5、どちらも --flow）を報告に書く 4. テスト・codex・変えたファイルだけを指定して commit（git add . と git clean は使わない） ``` ### 依頼182 で Claude Code が返した報告 19:16に始め、19:28に終えました（12分）。 ``` 依頼182：実機推論の 1 チャンクを少ない中継点で送れるようにする（実機は動かしていない） ■ やったこと 1. lab_start.sh に --via-stride N（0〜10。既定は今までの 3）を足し、run_policy_client.py にそのまま渡す（実機の 8 とドライランの 2 か所）。起動時に [VIA ] の行で送る step を出す 既定 3 → [VIA ] --via-stride 3: 1 チャンクを step 2, 5, 8, 9 で送る 5 → step 4, 9 ／ 0 → 中継点なし。グリッパーが変わるチャンクはその手前まで（run_policy_client.py の plan_vias と同じ） run_policy_client.py は変えていない（もとから --via-stride を受ける） 2. stride 5 でも今の決まりのまま送れることを、偽のアームのテストで確かめた（test_flow_send.py に 2 件） - --flow：途中の点 step 4 は待たずに 1 回送り、最後の step 9 だけ 3° の到着を待つ。送る間隔の下限 0.4 秒も守る - max_move：計画するときと、送る直前に実測から計算し直すときの両方で効く - 安全範囲・送る直前の検査は stride 3 と同じ処理を通る 3. Log35 の 7 本の答えから、1 点あたりの最大の移動量を計算した（下の表） 4. テスト：lab_start 237 件（222 から 15 件増）・test_flow_send 18 件（16 から 2 件増）。すべて通った。codex 2 回（1 回目：境界値 1・10・08・09 のテストがない → 足した。2 回目：指摘なし） ■ 1 点あたりの最大の移動量（Log35 の 7 本。実行したチャンクの答えと推論の前の実測角から plan_vias で計算。安全範囲のクランプあり、max_move の制限なし。6 関節の中の最大） 試行 チャンク stride3 の点数 / 中央 / 90% / 最大 stride5 の点数 / 中央 / 90% / 最大 20° 超え 180457 24 94 / 1.7 / 5.5 / 9.8 (j1) 47 / 3.5 / 9.0 / 15.0 (j1) 3:0 / 5:0 180704 15 57 / 3.3 / 6.5 / 9.1 (j1) 29 / 6.1 / 11.2 / 14.4 (j4) 3:0 / 5:0 181057 20 75 / 2.3 / 5.7 / 8.3 (j4) 38 / 4.9 / 9.4 / 14.0 (j4) 3:0 / 5:0 181300 24 92 / 2.0 / 6.6 / 8.1 (j4) 47 / 4.7 / 10.8 / 13.2 (j4) 3:0 / 5:0 182039 15 59 / 3.2 / 7.4 / 9.2 (j1) 30 / 6.8 / 11.3 / 14.1 (j4) 3:0 / 5:0 182211 12 47 / 4.1 / 7.9 / 10.0 (j1) 24 / 7.6 / 13.6 / 15.8 (j1) 3:0 / 5:0 182327 60 232 / 1.1 / 6.3 / 9.3 (j0) 118 / 1.6 / 11.6 / 15.1 (j4) 3:0 / 5:0 合わせて 656 / 1.9 / 6.7 / 10.0 333 / 4.6 / 11.6 / 15.8 3:0 / 5:0（15° 超えは stride 5 で 4 点） ・計画の上では、stride 3・5 とも max_move 20° に引っかかる点はない（stride 5 の最大は 15.8°。182211 のチャンク 11 の step 4、j1） ・実際の stride 3 の記録でも、移動量の制限（[LIMIT] 移動量）は 0 回 ・注意：--flow では送る直前の実測から計算し直す。Log35 の --flow の途中の点は「近づいた」で次へ進むとき残り 中央 1.4°・最大 2.5°（356 回。時間で進んだのは 5 回）。最大 15.8° + 2.5° ≒ 18.3° で 20° 未満。ただし判定の幅 5° いっぱい残っていれば 20.8° になりうる（そのときは今の決まりどおり 20° に切って送る） ・これは記録の答えから計算したもので、stride 5 で動かしたときに AI が出す答えは変わりうる ■ 実機で比べるコマンド（--speed は付けない = 20。Log35 と同じ deep1・爪 25・--flow。Log の番号は仮） stride 3（今まで）： ./lab_start.sh --log Log36 --model deep1 --grip-value 25 --flow --via-stride 3 stride 5： ./lab_start.sh --log Log36 --model deep1 --grip-value 25 --flow --via-stride 5 比べ方： python3 pi05/chunk_timing.py （1 チャンクの動いた時間の中央値。Log35 では 2.2〜2.35 秒） ■ 変えたファイル lab_start.sh / test_lab_start.sh / pi05/test_flow_send.py（commit b3f290a） ■ 決めてほしいこと 1. 実機での比べ（上のコマンド）。実機は動かしていない 2. stride 5 で 1 点の移動は最大 15.8°（計画）。--flow の遅れを足すと 20° に近づく点がまれにありうる。このまま試すか ``` ### 依頼182 のコードの差分（コミット b3f290a） ```diff commit b3f290a88802443e38753323358a75ade1577e03 Author: Eiichi Shimazu Date: Sat Nov 14 19:27:42 2026 +0900 実機推論の 1 チャンクの中継点の間隔を lab_start.sh から変えられるようにする (依頼 182・Log35). lab_start.sh に --via-stride N (0〜10. 既定は今までの 3) を足し, run_policy_client.py の --via-stride にそのまま渡す (実機の 8 とドライランの 2 か所). 起動時に [VIA ] で送る step を出す (3 → step 2, 5, 8, 9 / 5 → step 4, 9 / 0 → 中継点なし. plan_vias と同じ並び). 先頭の 0 は 10 進で読む. --help は 2〜66 行. run_policy_client.py は変えない. テストを足す (lab_start 237 (境界 1・10・08・09. codex R1)・test_flow_send 18 (stride 5 で途中の点 1 つを待たずに送り最後だけ到着を待つ・max_move は計画と送る直前の両方で効く)) (依頼 182. codex 2 回) Co-Authored-By: Claude Opus 5.5 --- lab_start.sh | 20 +++++++++++++++++--- pi05/test_flow_send.py | 44 ++++++++++++++++++++++++++++++++++++++++++++ test_lab_start.sh | 33 ++++++++++++++++++++++++++++++--- 3 files changed, 91 insertions(+), 6 deletions(-) diff --git a/lab_start.sh b/lab_start.sh index 18b1cb0..394710d 100755 --- a/lab_start.sh +++ b/lab_start.sh @@ -38,6 +38,8 @@ # run_policy_client.py の既定 20. 起動時に [GRIP ] で使う値を出す. 依頼 152) # --flow / --speed N run_policy_client.py にそのまま渡す (中継点を止まらずに流す / チャンクを送る速さ 1〜100. # 付けなければ今までどおり. 依頼 176. 起動時に [FLOW ] で出す) +# --via-stride N 1 チャンクの中継点の間隔 (0〜10. run_policy_client.py にそのまま渡す. 既定 3 = step 2, 5, 8, 9 の 4 点. +# 5 なら step 4, 9 の 2 点. 依頼 182. 起動時に [VIA ] で出す) # --step-confirm 実機推論でチャンクごとに確かめ (Enter) を待つ今までの形に戻す. 付けなければ (既定) run_policy_client.py に # --no-step-confirm を渡し, 始めの確かめのあとは止まらずに進み, スペース (Enter も可) を押したときだけ次の推論の # あとで入力欄を出す (依頼 178). 起動時に [CONFIRM] の行でどちらかを出す @@ -93,6 +95,7 @@ MODEL=trim TILT_FIX_ARGS=() # 依頼 144: 既定は傾きをソフトでそろえる. --no-tilt-fix で回さない GRIP_ARGS=() # 依頼 152: --grip-value N のときだけ run_policy_client.py に --grip-value N を渡す GRIP_VALUE_SHOWN="20 (既定. run_policy_client.py の GRIP_VALUE)" +VIA_STRIDE=3 # 依頼 182: --via-stride N で変える (既定は今までの 3) FLOW_ARGS=() # 依頼 176: --flow / --speed N のときだけ run_policy_client.py に渡す STEP_ARGS=(--no-step-confirm) # 依頼 178: 既定はチャンクごとに確かめない. --step-confirm で今までどおり FINISH_ARGS=(--auto-finish) # 依頼 181: 既定は置き終えたら自動で終わる. --no-auto-finish で今までどおり @@ -110,6 +113,10 @@ while [ $# -gt 0 ]; do [ ${#2} -le 3 ] && [ "$((10#$2))" -le 100 ] || { echo "[ERROR] --grip-value は 0〜100 の整数: $2" >&2; exit 2; } GRIP_ARGS=(--grip-value "$((10#$2))"); GRIP_VALUE_SHOWN="$((10#$2)) (--grip-value)"; shift 2 ;; --flow) FLOW_ARGS+=(--flow); shift ;; + --via-stride) [ $# -ge 2 ] || { echo "[ERROR] --via-stride には 0〜10 の整数を付ける" >&2; exit 2; } + case "$2" in ''|*[!0-9]*) echo "[ERROR] --via-stride は 0〜10 の整数: $2" >&2; exit 2 ;; esac + [ ${#2} -le 2 ] && [ "$((10#$2))" -le 10 ] || { echo "[ERROR] --via-stride は 0〜10 の整数: $2" >&2; exit 2; } + VIA_STRIDE="$((10#$2))"; shift 2 ;; --step-confirm) STEP_ARGS=(); shift ;; --no-auto-finish) FINISH_ARGS=(); shift ;; --speed) [ $# -ge 2 ] || { echo "[ERROR] --speed には 1〜100 の整数を付ける" >&2; exit 2; } @@ -118,7 +125,7 @@ while [ $# -gt 0 ]; do FLOW_ARGS+=(--speed "$((10#$2))"); shift 2 ;; --model) [ $# -ge 2 ] || { echo "[ERROR] --model には ${LAB_MODELS// / か } を付ける" >&2; exit 2; } # 値がないと shift 2 が失敗して回り続ける (codex R1) MODEL="$2"; shift 2 ;; - -h|--help) sed -n '2,64p' "$0"; exit 0 ;; + -h|--help) sed -n '2,66p' "$0"; exit 0 ;; *) echo "[ERROR] 知らない引数: $1 (./lab_start.sh --help)" >&2; exit 2 ;; esac done @@ -167,6 +174,13 @@ else echo "[TILT ] 上カメラの傾きのお手本 (各エピソードの 1 枚目の中央値) は $RAW_RANGE から (安全範囲と同じ. --no-tilt-fix なので回さない. 依頼 142)" fi echo "[GRIP ] 爪の閉じる値は $GRIP_VALUE_SHOWN. 締め直し r はこの値−3 とこの値を交互に送る (依頼 152)" +if [ "$VIA_STRIDE" = 0 ]; then + echo "[VIA ] --via-stride 0: 中継点なし (1 チャンクで選んだ 1 点だけ送る. 依頼 182)" +else + VIA_STEPS="" # run_policy_client.py の plan_vias と同じ: N-1, 2N-1, ... (9 より前) と最後の 9 (--steps-per-chunk 10) + for ((k = VIA_STRIDE - 1; k < 9; k += VIA_STRIDE)); do VIA_STEPS+="$k, "; done + echo "[VIA ] --via-stride $VIA_STRIDE: 1 チャンクを step ${VIA_STEPS}9 で送る (グリッパーが変わるチャンクはその手前まで. 依頼 182)" +fi [ ${#FLOW_ARGS[@]} = 0 ] || echo "[FLOW ] 推論の送り方: ${FLOW_ARGS[*]} (依頼 176)" # 付けなければ今までと同じ出力 if [ ${#STEP_ARGS[@]} = 0 ]; then echo "[CONFIRM] チャンクごとに確かめる (--step-confirm. 推論のたびに Enter を待つ)" @@ -549,14 +563,14 @@ while :; do [ $rc = 0 ] || [ $rc = 130 ] || fail "camera_align.py が失敗 (終了コード $rc)" stage_done stage "8. 実機推論 ($round 回目)" - python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride 3 \ + python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride "$VIA_STRIDE" \ --settle-retries 0 --state-from-target --execute --ignore-framing --model "$MODEL_TAG" --framing-raw-dir "$RAW" \ --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FINISH_ARGS[@]+"${FINISH_ARGS[@]}"} ${STEP_ARGS[@]+"${STEP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ ${CONFIRM_ARGS[@]+"${CONFIRM_ARGS[@]}"} rc=$? else stage "8. 推論のクライアント (ドライラン・--dry-keys. アームには触らない)" - python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride 3 \ + python3 pi05/run_policy_client.py --raw-dir "$RAW_RANGE" --steps-per-chunk 10 --via-stride "$VIA_STRIDE" \ --settle-retries 0 --state-from-target --dry-keys --ignore-framing --model "$MODEL_TAG" --framing-raw-dir "$RAW" \ --tilt-raw-dir "$RAW_RANGE" ${TILT_FIX_ARGS[@]+"${TILT_FIX_ARGS[@]}"} ${GRIP_ARGS[@]+"${GRIP_ARGS[@]}"} ${FINISH_ARGS[@]+"${FINISH_ARGS[@]}"} ${STEP_ARGS[@]+"${STEP_ARGS[@]}"} ${FLOW_ARGS[@]+"${FLOW_ARGS[@]}"} \ ${CONFIRM_ARGS[@]+"${CONFIRM_ARGS[@]}"} diff --git a/pi05/test_flow_send.py b/pi05/test_flow_send.py index e66cee3..2ca4382 100644 --- a/pi05/test_flow_send.py +++ b/pi05/test_flow_send.py @@ -338,6 +338,50 @@ class TestFlowClient(unittest.TestCase): run_flow(BASE + argv, self.td, MovingArm()) +class TestFlowStride5(unittest.TestCase): + """--via-stride 5 (step 4, 9 の 2 点) でも今の決まりのまま送る (依頼 182). 送り方は stride 3 と同じ道を通る.""" + def setUp(self): + self.td = Path(tempfile.mkdtemp()) + time.sleep(1.1) + + def tearDown(self): + rpc.CHUNK_SPEED = rpc.SPEED + self.assertEqual(rpc.j0_sweep_scan.SPEED, 20) + + def argv(self, *extra): + a = list(BASE) + a[a.index("--via-stride") + 1] = "5" + return a + list(extra) + + def test_two_points_flow(self): + """途中の点 step 4 は待たずに 1 回送り, 最後の step 9 だけ到着を待つ.""" + arm = MovingArm(rate=5.0) + code, lines, out = run_flow(self.argv("--flow", "--flow-tol", "0.5", "--max-chunks", "1"), self.td, arm) + self.assertEqual(code, 0) + self.assertEqual([s[1] for s in arm.fast_sends], [[5.0, 2.5, 0.0, 0.0, 0.0, -30.0]]) + self.assertEqual([s[1] for s in arm.wait_sends], ["pi05_chunk000_via09"]) + np.testing.assert_allclose(arm.wait_sends[0][2], [10.0, 5.0, 0, 0, 0, -30]) + ch = [x for x in lines if x.get("type") is None and "chunk" in x][0] + self.assertEqual([v["step"] for v in ch["vias"]], [4, 9]) + self.assertEqual(ch["vias"][0]["flow"]["advance"], "time") + self.assertGreaterEqual(ch["vias"][0]["flow"]["send_gap_s"], rpc.FLOW_MIN_INTERVAL_SEC - 1e-3) + self.assertEqual(ch["vias"][1]["flow"]["advance"], "arrived") + self.assertTrue(ch["arrived"] and ch["executed"]) + self.assertIn("中継点 2 点: step 4, 9", out) + + def test_max_move_still_applies(self): + """1 点の移動が大きくなっても max_move で切る (計画のときも, 送る直前に実測からかけ直すときも).""" + arm = MovingArm(rate=200.0) + code, lines, out = run_flow(self.argv("--flow", "--max-move-deg", "3", "--max-chunks", "1"), self.td, arm) + self.assertEqual(code, 0) + self.assertEqual(arm.fast_sends[0][1][0], 3.0) # step 4 の j0 +5° を +3° に + ch = [x for x in lines if x.get("type") is None and "chunk" in x][0] + self.assertTrue(any("±3°" in n for n in ch["vias"][0]["notes"])) + qa_last = np.asarray(ch["vias"][0]["actual_after"]) + self.assertLessEqual(float(np.max(np.abs(np.asarray(arm.wait_sends[0][2]) - qa_last))), 3.0 + 0.5) + self.assertTrue(any("±3°" in n for n in ch["vias"][1]["notes"])) + + class TestSettleSpeed(unittest.TestCase): def tearDown(self): rpc.CHUNK_SPEED = rpc.SPEED diff --git a/test_lab_start.sh b/test_lab_start.sh index c7cd4e6..0f32674 100755 --- a/test_lab_start.sh +++ b/test_lab_start.sh @@ -600,7 +600,7 @@ check "--serve-only でも空打ちまで行う (依頼 176)" 'has out.txt "=== check "Pod は消さない (DELETE を呼ばない) で, かかった時間と片付け方を出す" '[ $(n_call DELETE) = 0 ] && has out.txt "=== かかった時間" && has out.txt "Pod は残しています (id $ID_NEW). 片付けは ./lab_stop.sh --log LogT"' check "記録 lab_start_*.txt に残る・始めの行に --serve-only と出る" 'grep -qF "サーバーとトンネルだけ (--serve-only" "$T/data/lab/LogT"/lab_start_*.txt' rm -rf "$T" -check "--help に --serve-only・--grip-value・--flow / --speed・5b の空打ちの説明が入る (2〜64 行)" 'sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--serve-only Pod を作って" && sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--no-tilt-fix 傾きを" && sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--grip-value N 爪の閉じる値" && sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--flow / --speed N run_policy_client.py に" && sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "# 5b. 空打ち" && grep -qF "sed -n '"'"'2,64p'"'"'" "$HERE/lab_start.sh"' +check "--help に --serve-only・--grip-value・--flow / --speed・5b の空打ちの説明が入る (2〜66 行)" 'sed -n "2,66p" "$HERE/lab_start.sh" | grep -qF -- "--serve-only Pod を作って" && sed -n "2,66p" "$HERE/lab_start.sh" | grep -qF -- "--no-tilt-fix 傾きを" && sed -n "2,66p" "$HERE/lab_start.sh" | grep -qF -- "--grip-value N 爪の閉じる値" && sed -n "2,66p" "$HERE/lab_start.sh" | grep -qF -- "--flow / --speed N run_policy_client.py に" && sed -n "2,66p" "$HERE/lab_start.sh" | grep -qF -- "# 5b. 空打ち" && grep -qF "sed -n '"'"'2,66p'"'"'" "$HERE/lab_start.sh"' echo "== 空打ち (依頼 176): トンネルのあと・アームの前に 1 回. 失敗しても止めずに続ける" setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run @@ -660,7 +660,7 @@ setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run --step-confirm -- check "--step-confirm なら --no-step-confirm を渡さず (ほかの引数は同じ), [CONFIRM] で出す" '[ $RC = 0 ] && has py.log "pi05/run_policy_client.py" && ! has py.log "--no-step-confirm" && grep -q -- "pi05/run_policy_client.py .* --flow$" "$T/py.log" && has out.txt "[CONFIRM] チャンクごとに確かめる (--step-confirm"' rm -rf "$T" check "実機の 8 にも既定で --no-step-confirm を渡す (8 の 2 か所)" '[ "$(grep -c '"'"'${STEP_ARGS\[@\]+"${STEP_ARGS\[@\]}"}'"'"' "$HERE/lab_start.sh")" = 2 ] && grep -qF "STEP_ARGS=(--no-step-confirm)" "$HERE/lab_start.sh" && grep -qF -- "--step-confirm) STEP_ARGS=(); shift ;;" "$HERE/lab_start.sh"' -check "--help に --step-confirm の説明が入る" 'sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--step-confirm 実機推論で"' +check "--help に --step-confirm の説明が入る" 'sed -n "2,66p" "$HERE/lab_start.sh" | grep -qF -- "--step-confirm 実機推論で"' echo "== 置き終えたら自動で終わる (依頼 181): 既定は --auto-finish を渡す. --no-auto-finish で今までどおり" setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run @@ -670,7 +670,34 @@ setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run --no-auto-finish check "--no-auto-finish なら --auto-finish を渡さず (ほかの引数は同じ), [FINISH] で出す" '[ $RC = 0 ] && has py.log "pi05/run_policy_client.py" && ! has py.log "--auto-finish" && grep -q -- "pi05/run_policy_client.py .* --no-step-confirm --flow$" "$T/py.log" && has out.txt "[FINISH] 置き終えても自動では終わらない (--no-auto-finish"' rm -rf "$T" check "実機の 8 にも既定で --auto-finish を渡す (8 の 2 か所)" '[ "$(grep -c '"'"'${FINISH_ARGS\[@\]+"${FINISH_ARGS\[@\]}"}'"'"' "$HERE/lab_start.sh")" = 2 ] && grep -qF "FINISH_ARGS=(--auto-finish)" "$HERE/lab_start.sh" && grep -qF -- "--no-auto-finish) FINISH_ARGS=(); shift ;;" "$HERE/lab_start.sh"' -check "--help に --no-auto-finish の説明が入る" 'sed -n "2,64p" "$HERE/lab_start.sh" | grep -qF -- "--no-auto-finish 箱に置き終えたら" && ./lab_start.sh --help | grep -qF -- "--no-auto-finish"' +check "--help に --no-auto-finish の説明が入る" 'sed -n "2,66p" "$HERE/lab_start.sh" | grep -qF -- "--no-auto-finish 箱に置き終えたら" && ./lab_start.sh --help | grep -qF -- "--no-auto-finish"' + +echo "== 中継点の間隔 (依頼 182): --via-stride N をそのまま渡す. 既定は今までの 3" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run +check "既定ではクライアントに --via-stride 3 を渡し, [VIA ] で step 2, 5, 8, 9 と出す" '[ $RC = 0 ] && [ "$(grep -c -- "pi05/run_policy_client.py .* --steps-per-chunk 10 --via-stride 3 " "$T/py.log")" = 1 ] && has out.txt "[VIA ] --via-stride 3: 1 チャンクを step 2, 5, 8, 9 で送る"' +rm -rf "$T" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run --via-stride 05 --flow +check "--via-stride 5 なら --via-stride 5 を渡し (ほかの引数は同じ), [VIA ] で step 4, 9 と出す" '[ $RC = 0 ] && [ "$(grep -c -- "pi05/run_policy_client.py .* --steps-per-chunk 10 --via-stride 5 " "$T/py.log")" = 1 ] && ! grep -q -- "--via-stride 3" "$T/py.log" && grep -q -- "pi05/run_policy_client.py .* --no-step-confirm --flow$" "$T/py.log" && has out.txt "[VIA ] --via-stride 5: 1 チャンクを step 4, 9 で送る"' +rm -rf "$T" +setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run --via-stride 0 +check "--via-stride 0 は中継点なしと出して 0 を渡す" '[ $RC = 0 ] && grep -q -- "pi05/run_policy_client.py .* --via-stride 0 " "$T/py.log" && has out.txt "[VIA ] --via-stride 0: 中継点なし"' +rm -rf "$T" +for pair in "1|1|0, 1, 2, 3, 4, 5, 6, 7, 8, 9" "10|10|9" "08|8|7, 9" "09|9|8, 9"; do # 境界と先頭の 0 (8 進で読まない. codex R1) + IFS='|' read -r arg want steps <<< "$pair" + setup; state $ID_OLD; pod 200 "$RUNNING"; probe 1 1 1 1 1; run --via-stride "$arg" + check "--via-stride $arg なら $want を渡し, step $steps と出す" '[ $RC = 0 ] && grep -q -- "pi05/run_policy_client.py .* --via-stride $want " "$T/py.log" && has out.txt "[VIA ] --via-stride $want: 1 チャンクを step $steps で送る"' + rm -rf "$T" +done +for bad in 11 -1 abc 100 ""; do + setup; run --via-stride "$bad" + check "--via-stride '$bad' は受けない (終了コード 2・API を呼ばない)" '[ $RC = 2 ] && [ ! -s "$T/calls.log" ] && has out.txt "--via-stride"' + rm -rf "$T" +done +setup; run --via-stride +check "--via-stride に値がなければ受けない (終了コード 2)" '[ $RC = 2 ] && [ ! -s "$T/calls.log" ] && has out.txt "--via-stride には 0〜10"' +rm -rf "$T" +check "実機の 8 にも同じ値を渡す (8 の 2 か所・3 を書き込んだ所は残らない)" '[ "$(grep -cF -- "--steps-per-chunk 10 --via-stride \"\$VIA_STRIDE\"" "$HERE/lab_start.sh")" = 2 ] && ! grep -q -- "--via-stride 3 " "$HERE/lab_start.sh" && grep -qF "VIA_STRIDE=3 " "$HERE/lab_start.sh"' +check "--help に --via-stride の説明が入る" 'sed -n "2,66p" "$HERE/lab_start.sh" | grep -qF -- "--via-stride N 1 チャンクの中継点の間隔" && ./lab_start.sh --help | grep -qF -- "# 5b. 空打ち"' echo echo "OK $OK / NG $NG" ``` ## 次に試すこと：自動で終わる形と、2点の中継点を実機で 次に実機を動かすときは、新しい Pod を立てて、位置5 で次の2つを2〜3回ずつ比べます。どちらも、置き終えたら自動で終わる形が最初から入ります。速さは20に戻します。 ``` cd ~/r2r2r-scripts ./lab_start.sh --log Log36 --model deep1 --grip-value 25 --flow --via-stride 3 ./lab_start.sh --log Log36 --model deep1 --grip-value 25 --flow --via-stride 5 ``` 見るのは、1チャンクの動いた時間が2.2秒から縮むか、置いたあとに自動で終わるか、2点にしてもつかめる割合が落ちないか、の3つです。そのあと、決めた送り方で位置5 のお手本を撮り直し、学習し直します（位置5 の人が直した6本を、教えた動きの再生で撮った6本に入れ替える計画）。 Claude Code の報告には、テストのうち爪の電流を読む部分が、偽のアームを使っていても本物の Pi のデーモンにつながっている、という気づきもありました。アームは動かしませんが、テストを流すたびに実機へつながっています。次の依頼のついでに直します。