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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inav-toolkit
-Version: 2.17.0
+Version: 2.18.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.18.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.18.0"

{inav_toolkit-2.17.0 → inav_toolkit-2.18.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.18.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.18.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 = []
@@ -6101,7 +6101,7 @@ def count_blackbox_logs(filepath):
 # ─── Main ─────────────────────────────────────────────────────────────────────
 
 def main():
-    parser = argparse.ArgumentParser(description="INAV Blackbox Analyzer v2.17.0 - Prescriptive Tuning",
+    parser = argparse.ArgumentParser(description="INAV Blackbox Analyzer v2.18.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,
@@ -6141,11 +6141,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 +6187,7 @@ def main():
 
     # ── Device mode: download blackbox from FC ──
     logfile = args.logfile
-    diff_raw = None
+    config_raw = None
     if args.device:
         try:
             try:
@@ -6257,19 +6257,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)")
 
@@ -6311,39 +6310,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 +6376,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 ──
@@ -6420,15 +6422,15 @@ def main():
         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)
     elif len(log_files) > 1:
-        _process_multi_log(log_files, args, diff_raw)
+        _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)
 
 
-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 +6446,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 +6459,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 +6583,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:
@@ -6635,7 +6637,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 +6645,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 +6668,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 +6682,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 +6694,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 +6965,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 +7258,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 +7268,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 +7783,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 +7792,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 +7842,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 +7887,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 +8235,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 +8250,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 +8293,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.18.0}/inav_toolkit/flight_db.py

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

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

@@ -33,7 +33,7 @@ try:
 except ImportError:
     serial = None  # Checked in open()
 
-VERSION = "2.17.0"
+VERSION = "2.18.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.18.0}/inav_toolkit/param_analyzer.py

@@ -21,7 +21,7 @@ import sys
 import textwrap
 from datetime import datetime
 
-VERSION = "2.17.0"
+VERSION = "2.18.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.18.0}/inav_toolkit/vtol_configurator.py

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

{inav_toolkit-2.17.0 → inav_toolkit-2.18.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.18.0"
 
 # Module paths for subprocess invocation (package-aware)
 ANALYZER_MODULE = "inav_toolkit.blackbox_analyzer"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inav-toolkit
-Version: 2.17.0
+Version: 2.18.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.18.0}/pyproject.toml

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