inav-toolkit 2.17.0__tar.gz → 2.19.0__tar.gz

{inav_toolkit-2.17.0 → inav_toolkit-2.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inav-toolkit
-Version: 2.17.0
+Version: 2.19.0
 Summary: Blackbox analyzer, parameter checker, and tuning wizard for INAV flight controllers
 License: MIT
 Project-URL: Homepage, https://github.com/agoliveira/INAV-Toolkit

{inav_toolkit-2.17.0 → inav_toolkit-2.19.0}/inav_toolkit/__init__.py

@@ -1,3 +1,3 @@
 """INAV Toolkit - Blackbox analyzer, parameter checker, and tuning wizard for INAV flight controllers."""
 
-__version__ = "2.17.0"
+__version__ = "2.19.0"

{inav_toolkit-2.17.0 → inav_toolkit-2.19.0}/inav_toolkit/blackbox_analyzer.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-INAV Blackbox Analyzer - Multirotor Tuning Tool v2.17.0
+INAV Blackbox Analyzer - Multirotor Tuning Tool v2.19.0
 =====================================================
 Analyzes INAV blackbox logs and tells you EXACTLY what to change.
 
@@ -104,7 +104,7 @@ def _disable_colors():
 AXIS_NAMES = ["Roll", "Pitch", "Yaw"]
 AXIS_COLORS = ["#FF6B6B", "#4ECDC4", "#FFD93D"]
 MOTOR_COLORS = ["#FF6B6B", "#4ECDC4", "#FFD93D", "#A78BFA"]
-REPORT_VERSION = "2.17.0"
+REPORT_VERSION = "2.19.0"
 
 # ─── Frame and Prop Profiles ─────────────────────────────────────────────────
 # Two separate concerns:
@@ -882,7 +882,7 @@ CLI_BOOL_KEYS = {
 }
 
 
-def merge_diff_into_config(config, diff_raw):
+def merge_diff_into_config(config, config_raw):
     """Merge INAV CLI 'diff all' output into the analysis config dict.
 
     Strategy:
@@ -895,19 +895,19 @@ def merge_diff_into_config(config, diff_raw):
 
     Args:
         config: Existing config dict from extract_fc_config()
-        diff_raw: Raw 'diff all' output string
+        config_raw: Raw 'diff all' output string
 
     Returns:
         Number of settings merged
     """
-    if not diff_raw:
+    if not config_raw:
         return 0
 
     try:
         from inav_toolkit.flight_db import parse_diff_output
     except ImportError:
         from inav_flight_db import parse_diff_output
-    diff_settings = parse_diff_output(diff_raw)
+    diff_settings = parse_diff_output(config_raw)
 
     merged = 0
     mismatches = []
@@ -6098,10 +6098,95 @@ def count_blackbox_logs(filepath):
     return max(1, count)
 
 
+# ─── Post-Analysis Cleanup ────────────────────────────────────────────────────
+
+def _post_analysis_cleanup(blackbox_dir, raw_download, split_files, analyzed_file,
+                           archive=False, keep_logs=False):
+    """Clean up blackbox directory after successful analysis.
+
+    Default: delete raw download and all split files.
+    --archive: compress analyzed flight to archive/ first.
+    --keep-logs: skip everything.
+
+    Also cleans stale .bbl files from previous sessions.
+    """
+    if keep_logs:
+        return
+
+    R, B, C, G, Y, RED, DIM = _colors()
+    deleted = 0
+    archived = 0
+
+    # Archive the analyzed flight if requested
+    if archive and analyzed_file and os.path.isfile(analyzed_file):
+        import gzip
+        archive_dir = os.path.join(blackbox_dir, "archive")
+        os.makedirs(archive_dir, exist_ok=True)
+        gz_name = os.path.basename(analyzed_file) + ".gz"
+        gz_path = os.path.join(archive_dir, gz_name)
+        try:
+            with open(analyzed_file, "rb") as f_in:
+                with gzip.open(gz_path, "wb") as f_out:
+                    f_out.write(f_in.read())
+            archived_size = os.path.getsize(gz_path)
+            original_size = os.path.getsize(analyzed_file)
+            ratio = archived_size / original_size * 100 if original_size > 0 else 0
+            print(f"  Archived: {gz_name} ({archived_size // 1024}KB, {ratio:.0f}% of original)")
+            archived = 1
+        except Exception as e:
+            print(f"  Warning: archive failed: {e}")
+
+    # Delete the raw download file
+    if raw_download and os.path.isfile(raw_download):
+        try:
+            sz = os.path.getsize(raw_download) // 1024
+            os.remove(raw_download)
+            deleted += 1
+        except Exception:
+            pass
+
+    # Delete all split files
+    if split_files:
+        for sf in split_files:
+            if sf and os.path.isfile(sf):
+                try:
+                    os.remove(sf)
+                    deleted += 1
+                except Exception:
+                    pass
+
+    # Clean stale .bbl files from previous sessions
+    # (anything not from the current download)
+    current_base = os.path.basename(raw_download) if raw_download else ""
+    if os.path.isdir(blackbox_dir):
+        for fname in os.listdir(blackbox_dir):
+            if not fname.endswith(".bbl"):
+                continue
+            fpath = os.path.join(blackbox_dir, fname)
+            if fpath == raw_download:
+                continue  # already handled
+            if any(fpath == sf for sf in (split_files or [])):
+                continue  # already handled
+            # This is a stale .bbl from a previous session
+            try:
+                os.remove(fpath)
+                deleted += 1
+            except Exception:
+                pass
+
+    if deleted > 0 or archived > 0:
+        parts = []
+        if deleted > 0:
+            parts.append(f"{deleted} log files removed")
+        if archived > 0:
+            parts.append(f"1 archived")
+        print(f"  Cleanup: {', '.join(parts)}")
+
+
 # ─── Main ─────────────────────────────────────────────────────────────────────
 
 def main():
-    parser = argparse.ArgumentParser(description="INAV Blackbox Analyzer v2.17.0 - Prescriptive Tuning",
+    parser = argparse.ArgumentParser(description="INAV Blackbox Analyzer v2.19.0 - Prescriptive Tuning",
                                       formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument("--version", action="version", version=f"inav-analyze {REPORT_VERSION}")
     parser.add_argument("logfile", nargs="?", default=None,
@@ -6115,8 +6200,14 @@ def main():
     parser.add_argument("--device", metavar="PORT",
                         help="Download blackbox from FC via serial. Use 'auto' to scan "
                              "or specify port (e.g., /dev/ttyACM0, COM3).")
-    parser.add_argument("--erase", action="store_true",
-                        help="Erase dataflash after successful download.")
+    parser.add_argument("--no-erase", action="store_true",
+                        help="Don't erase FC flash after successful download and analysis. "
+                             "Default: flash is erased automatically after pipeline completes.")
+    parser.add_argument("--archive", action="store_true",
+                        help="Compress the analyzed flight log to blackbox/archive/ instead of deleting. "
+                             "Builds a compressed history for re-analysis with future versions.")
+    parser.add_argument("--keep-logs", action="store_true",
+                        help="Skip all cleanup - keep raw downloads, splits, and don't erase flash.")
     parser.add_argument("--download-only", action="store_true",
                         help="Download blackbox from device but don't analyze.")
     parser.add_argument("--blackbox-dir", default="./blackbox",
@@ -6141,11 +6232,11 @@ def main():
                         help="Omit the plain-English description of the quad's behavior.")
     parser.add_argument("--no-color", action="store_true",
                         help="Disable colored terminal output.")
-    parser.add_argument("--diff", metavar="FILE", default=None,
-                        help="Path to a CLI 'diff all' file for enriched analysis. "
+    parser.add_argument("--config", metavar="FILE", default=None,
+                        help="Path to a CLI 'dump all' or 'diff all' file for enriched analysis. "
                              "Adds config cross-referencing to nav and tuning results. "
                              "Not needed with --device (config is pulled automatically). "
-                             "Also auto-discovered if a *_diff.txt file sits next to the BBL.")
+                             "Also auto-discovered if a *_dump.txt or *_diff.txt file sits next to the BBL.")
     parser.add_argument("--nav", action="store_true",
                         help="Enable navigation health analysis (compass, GPS, baro, "
                              "estimator). Works on any flight with nav fields in the log.")
@@ -6187,7 +6278,8 @@ def main():
 
     # ── Device mode: download blackbox from FC ──
     logfile = args.logfile
-    diff_raw = None
+    config_raw = None
+    device_port = None
     if args.device:
         try:
             try:
@@ -6257,19 +6349,18 @@ def main():
             pct = summary['used_size'] * 100 // summary['total_size'] if summary['total_size'] > 0 else 0
             print(f"  Dataflash: {used_kb:.0f}KB / {total_kb:.0f}KB ({pct}% used)")
 
-            # Pull CLI diff (always when connected - enriches analysis)
-            diff_raw = None
-            print("  Pulling configuration (diff all)...", end="", flush=True)
-            diff_raw = fc.get_diff_all(timeout=10.0)
-            if diff_raw:
-                n_settings = len([l for l in diff_raw.splitlines() if l.strip().startswith("set ")])
-                print(f" {n_settings} settings")
-                # Save diff to file alongside blackbox
-                diff_path = os.path.join(args.blackbox_dir, f"{info['craft_name'] or 'fc'}_diff.txt")
+            # Pull full config dump (all parameters — used for analysis, fingerprinting, and backup)
+            config_raw = None
+            print("  Pulling configuration (dump all)...", end="", flush=True)
+            config_raw = fc.get_dump_all(timeout=30.0)
+            if config_raw:
+                n_settings = len([l for l in config_raw.splitlines() if l.strip().startswith("set ")])
+                print(f" {n_settings} parameters")
+                config_path = os.path.join(args.blackbox_dir, f"{info['craft_name'] or 'fc'}_dump.txt")
                 os.makedirs(args.blackbox_dir, exist_ok=True)
-                with open(diff_path, "w") as f:
-                    f.write(diff_raw)
-                print(f"  Saved: {diff_path}")
+                with open(config_path, "w") as f:
+                    f.write(config_raw)
+                print(f"  Saved: {config_path}")
             else:
                 print(" no response (FC may not support CLI over MSP)")
 
@@ -6280,13 +6371,16 @@ def main():
             print()
             filepath = fc.download_blackbox(
                 output_dir=args.blackbox_dir,
-                erase_after=args.erase,
+                erase_after=False,  # erase happens after successful analysis
             )
 
             if not filepath:
                 print("  ERROR: Download failed.")
                 sys.exit(1)
 
+            # Store port for post-analysis erase
+            device_port = fc.port_path if hasattr(fc, 'port_path') else args.device
+
             if args.download_only:
                 print(f"\n  To analyze:\n    python3 {sys.argv[0]} {filepath}")
                 sys.exit(0)
@@ -6311,39 +6405,42 @@ def main():
         print(f"ERROR: File not found: {logfile}"); sys.exit(1)
 
     # ── Load diff from file (when not using --device) ──
-    if diff_raw is None:
-        diff_file = None
-        if args.diff:
-            # Explicit file path: --diff my_diff.txt
-            diff_file = args.diff
+    if config_raw is None:
+        config_file = None
+        if args.config:
+            # Explicit file path: --config my_dump.txt
+            config_file = args.config
         else:
-            # Auto-discover diff files in same directory as BBL
+            # Auto-discover config files in same directory as BBL
+            # Prefer dump (complete) over diff (only changed params)
             log_dir = os.path.dirname(os.path.abspath(logfile))
             candidates = []
             for fname in os.listdir(log_dir):
-                if fname.endswith("_diff.txt") or fname == "diff.txt" or fname == "diff_all.txt":
+                if (fname.endswith("_dump.txt") or fname.endswith("_diff.txt")
+                        or fname in ("dump.txt", "dump_all.txt", "diff.txt", "diff_all.txt")):
                     candidates.append(os.path.join(log_dir, fname))
-            if len(candidates) == 1:
-                diff_file = candidates[0]
-            elif len(candidates) > 1:
-                # Pick the most recently modified
-                diff_file = max(candidates, key=os.path.getmtime)
-
-        if diff_file:
-            if os.path.isfile(diff_file):
+            if candidates:
+                # Prefer dump over diff, then most recent
+                def _score(path):
+                    is_dump = "_dump" in path or "dump" in os.path.basename(path)
+                    return (1 if is_dump else 0, os.path.getmtime(path))
+                config_file = max(candidates, key=_score)
+
+        if config_file:
+            if os.path.isfile(config_file):
                 try:
-                    with open(diff_file, "r", errors="ignore") as f:
-                        diff_raw = f.read()
-                    n_settings = len([l for l in diff_raw.splitlines()
+                    with open(config_file, "r", errors="ignore") as f:
+                        config_raw = f.read()
+                    n_settings = len([l for l in config_raw.splitlines()
                                       if l.strip().startswith("set ")])
                     if n_settings > 0:
-                        print(f"  Config: {os.path.basename(diff_file)} ({n_settings} settings)")
+                        print(f"  Config: {os.path.basename(config_file)} ({n_settings} settings)")
                     else:
-                        diff_raw = None  # not a valid diff file
+                        config_raw = None  # not a valid config file
                 except Exception:
-                    diff_raw = None
+                    config_raw = None
             else:
-                print(f"  Warning: Diff file not found: {diff_file}")
+                print(f"  Warning: Config file not found: {config_file}")
 
     # ── History mode: show progression and exit ──
     if args.history or args.trend:
@@ -6374,14 +6471,14 @@ def main():
         if not os.path.isfile(args.compare):
             print(f"ERROR: Comparison file not found: {args.compare}")
             sys.exit(1)
-        _run_comparison(logfile, args.compare, args, diff_raw)
+        _run_comparison(logfile, args.compare, args, config_raw)
         return
 
     # ── Replay mode: interactive HTML time-series ──
     if args.replay:
         if not logfile:
             parser.error("logfile required for --replay")
-        _run_replay(logfile, args, diff_raw)
+        _run_replay(logfile, args, config_raw)
         return
 
     # ── Log quality check mode ──
@@ -6415,20 +6512,48 @@ def main():
     # Flash may contain flights from multiple sessions (config changes between
     # arm cycles). Only the LATEST session's best flight deserves full analysis.
     # Earlier flights are stored in DB for progression but shown as one-liners.
+    analyzed_file = None
     if getattr(args, 'nav', False):
         # Nav mode: skip multi-flight tuning scan, analyze last flight directly
         target = log_files[-1]
         if len(log_files) > 1:
             print(f"\n  Nav mode: analyzing last flight ({len(log_files)} in flash)")
-        _analyze_single_log(target, args, diff_raw)
+        _analyze_single_log(target, args, config_raw)
+        analyzed_file = target
     elif len(log_files) > 1:
-        _process_multi_log(log_files, args, diff_raw)
+        analyzed_file = _process_multi_log(log_files, args, config_raw)
     else:
         # Single flight - full analysis
-        _analyze_single_log(log_files[0], args, diff_raw)
+        _analyze_single_log(log_files[0], args, config_raw)
+        analyzed_file = log_files[0]
+
+    # ── Post-analysis cleanup (only in device mode) ──
+    if device_port and not args.keep_logs:
+        # raw_download is the original downloaded file (pre-split)
+        # For single-flight, it's the same as the analyzed file
+        raw_download = logfile
+        split_files = log_files if n_logs > 1 else []
+
+        _post_analysis_cleanup(
+            args.blackbox_dir, raw_download, split_files, analyzed_file,
+            archive=args.archive, keep_logs=args.keep_logs)
+
+        # Erase FC flash
+        if not args.no_erase:
+            try:
+                try:
+                    from inav_toolkit.msp import INAVDevice
+                except ImportError:
+                    from inav_msp import INAVDevice
+                fc2 = INAVDevice(device_port)
+                fc2.open()
+                fc2.erase_dataflash()
+                fc2.close()
+            except Exception as e:
+                print(f"  Erase failed: {e}")
 
 
-def _process_multi_log(log_files, args, diff_raw):
+def _process_multi_log(log_files, args, config_raw):
     """Handle multiple flights from a single flash download.
 
     Strategy:
@@ -6444,7 +6569,7 @@ def _process_multi_log(log_files, args, diff_raw):
     print(f"  Scanning {len(log_files)} flights...")
     summaries = []
     for lf in log_files:
-        s = _analyze_single_log(lf, args, diff_raw, summary_only=True)
+        s = _analyze_single_log(lf, args, config_raw, summary_only=True)
         if s:
             summaries.append(s)
 
@@ -6457,7 +6582,7 @@ def _process_multi_log(log_files, args, diff_raw):
     # header config matches the diff are "current session" (post-change),
     # flights that don't match are "old session" (pre-change).
     # Without a diff, fall back to comparing consecutive flights.
-    current_fp = _fingerprint_from_diff(diff_raw)
+    current_fp = _fingerprint_from_diff(config_raw)
     is_current = []  # True/False per flight
 
     if current_fp:
@@ -6581,7 +6706,7 @@ def _process_multi_log(log_files, args, diff_raw):
 
     # ── Phase 5: Full analysis on the selected flight ──
     print(f"{'═' * 70}")
-    _analyze_single_log(log_files[best_idx], args, diff_raw)
+    _analyze_single_log(log_files[best_idx], args, config_raw)
 
     # ── Phase 6: Show cross-session progression ──
     if not args.no_db:
@@ -6611,6 +6736,8 @@ def _process_multi_log(log_files, args, diff_raw):
         except Exception:
             pass
 
+    return log_files[best_idx]
+
 
 def _verdict_short(verdict):
     """Short display string for verdict codes."""
@@ -6635,7 +6762,7 @@ def _config_fingerprint(config):
     return "|".join(parts) if parts else ""
 
 
-def _fingerprint_from_diff(diff_raw):
+def _fingerprint_from_diff(config_raw):
     """Build a config fingerprint from CLI 'diff all' output.
 
     This represents the FC's CURRENT config - the ground truth.
@@ -6643,14 +6770,14 @@ def _fingerprint_from_diff(diff_raw):
     session; flights that don't match are from before the user applied
     changes.
     """
-    if not diff_raw:
+    if not config_raw:
         return ""
 
     try:
         from inav_toolkit.flight_db import parse_diff_output
     except ImportError:
         from inav_flight_db import parse_diff_output
-    diff_settings = parse_diff_output(diff_raw)
+    diff_settings = parse_diff_output(config_raw)
 
     # Map CLI names → config keys (same mapping as merge_diff_into_config)
     config = {}
@@ -6666,8 +6793,12 @@ def _fingerprint_from_diff(diff_raw):
     return _config_fingerprint(config)
 
 
-def _print_config_review(diff_raw, config, frame_inches, plan):
-    """Run parameter analyzer on FC diff and show findings not covered by flight analysis.
+def _print_config_review(config_raw, config, frame_inches, plan):
+    """Run parameter analyzer on FC config and show findings not covered by flight analysis.
+
+    Accepts either 'dump all' or 'diff all' output. Dump is preferred since it
+    includes every parameter including unchanged defaults, which matters for
+    nav PID checks on large frames.
 
     Only shows CRITICAL and WARNING findings from categories that the blackbox
     analyzer doesn't cover (safety, nav, motor protocol, GPS, battery, RX).
@@ -6676,6 +6807,9 @@ def _print_config_review(diff_raw, config, frame_inches, plan):
     """
     R, B, C, G, Y, RED, DIM = _colors()
 
+    if not config_raw:
+        return
+
     try:
         try:
             from inav_toolkit.param_analyzer import parse_diff_all, run_all_checks, CRITICAL, WARNING
@@ -6685,7 +6819,7 @@ def _print_config_review(diff_raw, config, frame_inches, plan):
         return  # param analyzer not available
 
     try:
-        parsed = parse_diff_all(diff_raw)
+        parsed = parse_diff_all(config_raw)
     except Exception:
         return
 
@@ -6956,15 +7090,15 @@ footer {{ text-align:center; color:#555; margin-top:30px; padding:10px; border-t
 
 # ─── Comparison Mode ─────────────────────────────────────────────────────────
 
-def _analyze_for_compare(logfile, args, diff_raw=None):
+def _analyze_for_compare(logfile, args, config_raw=None):
     """Run analysis pipeline on a single file and return structured results.
     Returns dict with: config, data, noise_results, pid_results, motor_analysis,
                         dterm_results, plan, noise_fp, hover_osc, profile
     """
     raw_params = parse_headers_from_bbl(logfile)
     config = extract_fc_config(raw_params)
-    if diff_raw:
-        merge_diff_into_config(config, diff_raw)
+    if config_raw:
+        merge_diff_into_config(config, config_raw)
 
     # Auto-detect frame
     craft = config.get("craft_name", "")
@@ -7249,7 +7383,7 @@ footer{{text-align:center;color:var(--dm);font-size:.7rem;padding:24px 0;border-
 </div><footer>INAV Blackbox Analyzer v{REPORT_VERSION} - Comparison Report</footer></body></html>"""
 
 
-def _run_comparison(file_a, file_b, args, diff_raw):
+def _run_comparison(file_a, file_b, args, config_raw):
     """Run comparative analysis on two flight logs."""
     R, B, C, G, Y, RED, DIM = _colors()
 
@@ -7259,12 +7393,12 @@ def _run_comparison(file_a, file_b, args, diff_raw):
     print()
 
     print(f"  Analyzing flight A...", end=" ", flush=True)
-    res_a = _analyze_for_compare(file_a, args, diff_raw)
+    res_a = _analyze_for_compare(file_a, args, config_raw)
     sa = res_a["plan"]["scores"]
     print(f"score {sa['overall']:.0f}/100")
 
     print(f"  Analyzing flight B...", end=" ", flush=True)
-    res_b = _analyze_for_compare(file_b, args, diff_raw)
+    res_b = _analyze_for_compare(file_b, args, config_raw)
     sb = res_b["plan"]["scores"]
     print(f"score {sb['overall']:.0f}/100")
 
@@ -7774,7 +7908,7 @@ allPlotIds.forEach(srcId => {{
 </script></body></html>"""
 
 
-def _run_replay(logfile, args, diff_raw):
+def _run_replay(logfile, args, config_raw):
     """Generate interactive replay HTML for a single flight."""
     R, B, C, G, Y, RED, DIM = _colors()
 
@@ -7783,8 +7917,8 @@ def _run_replay(logfile, args, diff_raw):
 
     raw_params = parse_headers_from_bbl(logfile)
     config = extract_fc_config(raw_params)
-    if diff_raw:
-        merge_diff_into_config(config, diff_raw)
+    if config_raw:
+        merge_diff_into_config(config, config_raw)
 
     ext = os.path.splitext(logfile)[1].lower()
     is_blackbox = ext in (".bbl", ".bfl", ".bbs")
@@ -7833,13 +7967,13 @@ def _run_replay(logfile, args, diff_raw):
     print()
 
 
-def _analyze_single_log(logfile, args, diff_raw=None, summary_only=False):
+def _analyze_single_log(logfile, args, config_raw=None, summary_only=False):
     """Analyze a single blackbox log file.
     
     Args:
         logfile: Path to log file
         args: Command line arguments
-        diff_raw: Optional CLI diff text
+        config_raw: Optional CLI diff text
         summary_only: If True, skip verbose output/reports but still analyze
                       and store in DB. Returns a summary dict.
     
@@ -7878,8 +8012,8 @@ def _analyze_single_log(logfile, args, diff_raw=None, summary_only=False):
     config = extract_fc_config(raw_params)
 
     # ── Merge CLI diff if available ──
-    if diff_raw:
-        n_merged = merge_diff_into_config(config, diff_raw)
+    if config_raw:
+        n_merged = merge_diff_into_config(config, config_raw)
         mismatches = config.get("_diff_mismatches", [])
         if n_merged > 0 or mismatches:
             parts = [f"{n_merged} new settings from CLI diff"]
@@ -8226,7 +8360,7 @@ def _analyze_single_log(logfile, args, diff_raw=None, summary_only=False):
                 db = FlightDB(args.db_path)
                 flight_id, is_new = db.store_flight(
                     plan, config, data, hover_osc, motor_analysis,
-                    pid_results, noise_results, log_file=logfile, diff_raw=diff_raw)
+                    pid_results, noise_results, log_file=logfile, config_raw=config_raw)
                 db.close()
                 summary["flight_id"] = flight_id
                 summary["is_new"] = is_new
@@ -8241,8 +8375,8 @@ def _analyze_single_log(logfile, args, diff_raw=None, summary_only=False):
     # ── Config review from diff (if available) ──
     # Runs parameter analyzer checks on the FC's current config.
     # Catches safety, nav, motor protocol issues that flight data alone can't detect.
-    if diff_raw and not args.no_terminal and plan["verdict"] != "GROUND_ONLY":
-        _print_config_review(diff_raw, config, frame_inches, plan)
+    if config_raw and not args.no_terminal and plan["verdict"] != "GROUND_ONLY":
+        _print_config_review(config_raw, config, frame_inches, plan)
 
     nav_results = None  # nav analysis only runs in --nav mode
     if not args.no_html and plan["verdict"] != "GROUND_ONLY":
@@ -8284,7 +8418,7 @@ def _analyze_single_log(logfile, args, diff_raw=None, summary_only=False):
             db = FlightDB(args.db_path)
             flight_id, is_new = db.store_flight(
                 plan, config, data, hover_osc, motor_analysis,
-                pid_results, noise_results, log_file=logfile, diff_raw=diff_raw)
+                pid_results, noise_results, log_file=logfile, config_raw=config_raw)
             craft = config.get("craft_name", "unknown")
             n_flights = db.get_flight_count(craft)
             if is_new:

{inav_toolkit-2.17.0 → inav_toolkit-2.19.0}/inav_toolkit/flight_db.py

@@ -21,7 +21,7 @@ import json
 import os
 from datetime import datetime
 
-VERSION = "2.17.0"
+VERSION = "2.19.0"
 
 SCHEMA_VERSION = 1
 

{inav_toolkit-2.17.0 → inav_toolkit-2.19.0}/inav_toolkit/msp.py

@@ -33,7 +33,7 @@ try:
 except ImportError:
     serial = None  # Checked in open()
 
-VERSION = "2.17.0"
+VERSION = "2.19.0"
 
 # ─── MSP Command IDs ─────────────────────────────────────────────────────────
 
@@ -1005,6 +1005,17 @@ class INAVDevice:
         """
         return self.cli_command("diff all", timeout=timeout)
 
+    def get_dump_all(self, timeout=30.0):
+        """Pull the full 'dump all' configuration from the FC.
+
+        This is a complete backup of every parameter — much larger output
+        than 'diff all' which only shows non-defaults.
+
+        Returns:
+            Raw dump output string, or None on error
+        """
+        return self.cli_command("dump all", timeout=timeout)
+
     def cli_batch(self, commands, timeout=5.0, save=True):
         """Send multiple CLI commands in a single CLI session.
 

{inav_toolkit-2.17.0 → inav_toolkit-2.19.0}/inav_toolkit/param_analyzer.py

@@ -21,7 +21,7 @@ import sys
 import textwrap
 from datetime import datetime
 
-VERSION = "2.17.0"
+VERSION = "2.19.0"
 
 
 def _enable_ansi_colors():
@@ -811,7 +811,7 @@ def run_all_checks(parsed, frame_inches=None, blackbox_state=None):
     findings.extend(check_motors_protocol(parsed))
     findings.extend(check_filters(parsed, frame_inches))
     findings.extend(check_pid_config(parsed, frame_inches))
-    findings.extend(check_navigation(parsed))
+    findings.extend(check_navigation(parsed, frame_inches))
     findings.extend(check_gps(parsed))
     findings.extend(check_blackbox(parsed))
     findings.extend(check_battery(parsed))
@@ -1280,7 +1280,7 @@ def check_pid_config(parsed, frame_inches=None):
 
 # ─── Navigation Checks ───────────────────────────────────────────────────────
 
-def check_navigation(parsed):
+def check_navigation(parsed, frame_inches=None):
     findings = []
 
     rth_alt = get_setting(parsed, "nav_rth_altitude", 5000)
@@ -1346,26 +1346,123 @@ def check_navigation(parsed):
                 setting="nav_mc_hover_thr",
                 current=str(hover)))
 
-    # Nav PID values from active profile
-    pos_p = profile.get("nav_mc_pos_xy_p", get_setting(parsed, "nav_mc_pos_xy_p", None))
-    heading_p = profile.get("nav_mc_heading_p", get_setting(parsed, "nav_mc_heading_p", None))
+    # ── Frame-aware nav PID checks ──
+    # INAV defaults are tuned for 5" quads. Larger frames have more inertia
+    # and need softer nav PIDs and longer deceleration time. The default
+    # values cause oscillation on deceleration, overshoot on RTH arrival,
+    # and bouncy position hold on 10"+ frames.
+    #
+    # Recommended ranges by frame size:
+    #   5":  pos_p=50-65  vel_p=35-50  vel_d=80-120  decel=100-150
+    #   7":  pos_p=40-55  vel_p=30-40  vel_d=80-120  decel=120-180
+    #   10": pos_p=30-45  vel_p=20-30  vel_d=80-120  decel=180-280
+    #   12": pos_p=25-40  vel_p=15-25  vel_d=80-120  decel=220-350
+    #   15": pos_p=20-35  vel_p=10-20  vel_d=80-120  decel=280-400
+
+    nav_rec = None
+    if frame_inches and frame_inches >= 7:
+        if frame_inches >= 15:
+            nav_rec = {"pos_p_max": 35, "vel_p_max": 20, "decel_min": 280,
+                       "pos_p_rec": 25, "vel_p_rec": 15, "vel_i_rec": 8, "decel_rec": 350}
+        elif frame_inches >= 12:
+            nav_rec = {"pos_p_max": 40, "vel_p_max": 25, "decel_min": 220,
+                       "pos_p_rec": 30, "vel_p_rec": 20, "vel_i_rec": 10, "decel_rec": 280}
+        elif frame_inches >= 10:
+            nav_rec = {"pos_p_max": 45, "vel_p_max": 30, "decel_min": 180,
+                       "pos_p_rec": 40, "vel_p_rec": 25, "vel_i_rec": 10, "decel_rec": 250}
+        elif frame_inches >= 7:
+            nav_rec = {"pos_p_max": 55, "vel_p_max": 40, "decel_min": 120,
+                       "pos_p_rec": 45, "vel_p_rec": 35, "vel_i_rec": 15, "decel_rec": 150}
+
+    # INAV defaults for nav PIDs (these won't appear in diff all if unchanged)
+    INAV_NAV_DEFAULTS = {
+        "nav_mc_pos_xy_p": 65,
+        "nav_mc_vel_xy_p": 40,
+        "nav_mc_vel_xy_i": 15,
+        "nav_mc_pos_deceleration_time": 120,
+        "nav_mc_heading_p": 60,
+    }
 
-    if pos_p is not None and isinstance(pos_p, (int, float)):
-        if pos_p > 50:
-            findings.append(Finding(
-                WARNING, "Navigation", f"Position hold P = {pos_p} - aggressive",
-                "High position P gain can cause oscillation (salad bowling) in position hold and RTH. "
-                "The quad overcorrects, overshoots, and oscillates around the target position.",
-                setting="nav_mc_pos_xy_p",
-                current=str(pos_p),
-                recommended="20-35",
-                cli_fix=f"set nav_mc_pos_xy_p = 30"))
-        elif pos_p < 15:
-            findings.append(Finding(
-                INFO, "Navigation", f"Position hold P = {pos_p} - conservative",
-                "Low position P may result in slow corrections and drifting in wind.",
-                setting="nav_mc_pos_xy_p",
-                current=str(pos_p)))
+    pos_p = profile.get("nav_mc_pos_xy_p",
+                        get_setting(parsed, "nav_mc_pos_xy_p", INAV_NAV_DEFAULTS["nav_mc_pos_xy_p"]))
+    vel_p = profile.get("nav_mc_vel_xy_p",
+                        get_setting(parsed, "nav_mc_vel_xy_p", INAV_NAV_DEFAULTS["nav_mc_vel_xy_p"]))
+    vel_i = profile.get("nav_mc_vel_xy_i",
+                        get_setting(parsed, "nav_mc_vel_xy_i", INAV_NAV_DEFAULTS["nav_mc_vel_xy_i"]))
+    decel = get_setting(parsed, "nav_mc_pos_deceleration_time",
+                        INAV_NAV_DEFAULTS["nav_mc_pos_deceleration_time"])
+    heading_p = profile.get("nav_mc_heading_p",
+                            get_setting(parsed, "nav_mc_heading_p", INAV_NAV_DEFAULTS["nav_mc_heading_p"]))
+
+    if nav_rec:
+        is_default_pos = (pos_p == INAV_NAV_DEFAULTS["nav_mc_pos_xy_p"])
+        is_default_vel = (vel_p == INAV_NAV_DEFAULTS["nav_mc_vel_xy_p"])
+        is_default_decel = (decel == INAV_NAV_DEFAULTS["nav_mc_pos_deceleration_time"])
+        default_note = " (INAV default - tuned for 5-inch)"
+
+        # Frame-aware checks
+        if pos_p is not None and isinstance(pos_p, (int, float)):
+            if pos_p > nav_rec["pos_p_max"]:
+                val_note = default_note if is_default_pos else ""
+                findings.append(Finding(
+                    WARNING, "Navigation",
+                    f"Position P = {pos_p}{val_note} - too aggressive for {frame_inches}-inch",
+                    f"On {frame_inches}-inch with more "
+                    f"inertia, high position P causes overshoot and oscillation on RTH arrival "
+                    f"and position hold. The quad overshoots the target position, corrects back, "
+                    f"overshoots again.",
+                    setting="nav_mc_pos_xy_p",
+                    current=str(pos_p),
+                    recommended=str(nav_rec["pos_p_rec"]),
+                    cli_fix=f"set nav_mc_pos_xy_p = {nav_rec['pos_p_rec']}"))
+
+        if vel_p is not None and isinstance(vel_p, (int, float)):
+            if vel_p > nav_rec["vel_p_max"]:
+                val_note = default_note if is_default_vel else ""
+                findings.append(Finding(
+                    WARNING, "Navigation",
+                    f"Velocity XY P = {vel_p}{val_note} - too aggressive for {frame_inches}-inch",
+                    f"Controls how hard the quad brakes when decelerating. "
+                    f"On {frame_inches}-inch, the quad can't stop as fast due to momentum, "
+                    f"so high velocity P causes oscillation in the direction of travel when "
+                    f"stopping or changing direction.",
+                    setting="nav_mc_vel_xy_p",
+                    current=str(vel_p),
+                    recommended=str(nav_rec["vel_p_rec"]),
+                    cli_fix=f"set nav_mc_vel_xy_p = {nav_rec['vel_p_rec']}"))
+
+        if decel is not None and isinstance(decel, (int, float)):
+            if decel < nav_rec["decel_min"]:
+                val_note = default_note if is_default_decel else ""
+                findings.append(Finding(
+                    WARNING, "Navigation",
+                    f"Deceleration time = {decel} ({decel/100:.1f}s){val_note} - too short for {frame_inches}-inch",
+                    f"This controls how quickly the quad tries to stop from cruise speed. "
+                    f"A {frame_inches}-inch has much more "
+                    f"momentum and needs more distance/time to decelerate smoothly. "
+                    f"Too short causes overshoot and oscillation on RTH and position hold transitions.",
+                    setting="nav_mc_pos_deceleration_time",
+                    current=f"{decel} ({decel/100:.1f}s)",
+                    recommended=f"{nav_rec['decel_rec']} ({nav_rec['decel_rec']/100:.1f}s)",
+                    cli_fix=f"set nav_mc_pos_deceleration_time = {nav_rec['decel_rec']}"))
+    else:
+        # Generic checks (no frame size or small frame)
+        if pos_p is not None and isinstance(pos_p, (int, float)):
+            if pos_p > 50:
+                findings.append(Finding(
+                    WARNING, "Navigation", f"Position hold P = {pos_p} - aggressive",
+                    "High position P gain can cause oscillation in position hold and RTH. "
+                    "The quad overcorrects, overshoots, and oscillates around the target position.",
+                    setting="nav_mc_pos_xy_p",
+                    current=str(pos_p),
+                    recommended="20-35",
+                    cli_fix=f"set nav_mc_pos_xy_p = 30"))
+            elif pos_p < 15:
+                findings.append(Finding(
+                    INFO, "Navigation", f"Position hold P = {pos_p} - conservative",
+                    "Low position P may result in slow corrections and drifting in wind.",
+                    setting="nav_mc_pos_xy_p",
+                    current=str(pos_p)))
 
     if heading_p is not None and isinstance(heading_p, (int, float)):
         if heading_p > 60:

{inav_toolkit-2.17.0 → inav_toolkit-2.19.0}/inav_toolkit/vtol_configurator.py

@@ -25,7 +25,7 @@ import re
 import sys
 import textwrap
 
-VERSION = "2.17.0"
+VERSION = "2.19.0"
 
 
 def _enable_ansi_colors():

{inav_toolkit-2.17.0 → inav_toolkit-2.19.0}/inav_toolkit/wizard.py

@@ -22,7 +22,7 @@ import time
 try:
     from inav_toolkit import __version__ as VERSION
 except ImportError:
-    VERSION = "2.17.0"
+    VERSION = "2.19.0"
 
 # Module paths for subprocess invocation (package-aware)
 ANALYZER_MODULE = "inav_toolkit.blackbox_analyzer"

{inav_toolkit-2.17.0 → inav_toolkit-2.19.0}/inav_toolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inav-toolkit
-Version: 2.17.0
+Version: 2.19.0
 Summary: Blackbox analyzer, parameter checker, and tuning wizard for INAV flight controllers
 License: MIT
 Project-URL: Homepage, https://github.com/agoliveira/INAV-Toolkit

{inav_toolkit-2.17.0 → inav_toolkit-2.19.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inav-toolkit"
-version = "2.17.0"
+version = "2.19.0"
 description = "Blackbox analyzer, parameter checker, and tuning wizard for INAV flight controllers"
 readme = "README.md"
 license = {text = "MIT"}