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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inav-toolkit
-Version: 2.16.1
+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.16.1 → 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.16.1"
+__version__ = "2.18.0"

{inav_toolkit-2.16.1 → 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.16.1
+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.16.1"
+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 = []
@@ -2542,17 +2542,34 @@ def measure_tracking_delay_xcorr(sp, gy, sr, max_delay_ms=200):
     return float(np.median(delays))
 
 
-def detect_hover_oscillation(data, sr):
+def detect_hover_oscillation(data, sr, profile=None):
     """Detect oscillation during hover (no/minimal stick input).
 
     Finds segments where setpoint is near zero, then measures gyro
     oscillation amplitude and dominant frequency. This catches the most
     dangerous tuning problem: a quad that can't hold still.
 
+    Frame-size aware: larger frames naturally have more gyro activity,
+    and low-frequency wobble (1-5Hz) outdoors is often wind buffeting,
+    not P oscillation. The cause classification accounts for this.
+
     Returns list of per-axis dicts:
         axis, gyro_rms, gyro_p2p, dominant_freq_hz, severity, cause, hover_seconds
     Or empty list if no hover segments found.
     """
+    if profile is None:
+        profile = get_frame_profile(5)
+
+    # Scale severity thresholds by frame size.
+    # Larger frames have more inertia and naturally higher gyro readings.
+    frame_inches = profile.get("frame_inches", 5)
+    size_factor = max(1.0, frame_inches / 7.0)  # 1.0 for 7", 1.43 for 10", 2.14 for 15"
+
+    # Severity thresholds (RMS deg/s) — scaled by frame size
+    sev_none = 2.0 * size_factor     # 2.0 for 7", 2.9 for 10"
+    sev_mild = 5.0 * size_factor     # 5.0 for 7", 7.1 for 10"
+    sev_moderate = 15.0 * size_factor # 15.0 for 7", 21.4 for 10"
+
     results = []
     min_hover_samples = int(sr * 0.5)  # At least 0.5s of hover
 
@@ -2609,6 +2626,7 @@ def detect_hover_oscillation(data, sr):
 
         # Dominant frequency via FFT
         dominant_freq = None
+        peak_prominence = 0  # How much the peak stands out from noise floor
         if len(hover_gyro) >= int(sr * 0.25):  # Need at least 0.25s for FFT
             freqs = rfftfreq(len(hover_gyro), 1.0 / sr)
             spectrum = np.abs(rfft(hover_gyro))
@@ -2621,29 +2639,35 @@ def detect_hover_oscillation(data, sr):
                 dominant_freq = float(masked_freqs[peak_idx])
                 peak_power = masked_spectrum[peak_idx]
                 mean_power = np.mean(masked_spectrum)
+                peak_prominence = peak_power / mean_power if mean_power > 0 else 0
                 # Only report if peak is significantly above noise floor
-                if peak_power < mean_power * 3:
+                if peak_prominence < 3:
                     dominant_freq = None  # No clear dominant frequency
 
-        # Classify severity
-        # For a well-tuned hover: gyro_rms < 2, p2p < 10
-        # Mild wobble: rms 2-8, p2p 10-30
-        # Serious oscillation: rms 8-20, p2p 30-80
-        # Dangerous: rms > 20, p2p > 80
-        if gyro_rms < 2:
+        # Classify severity (frame-size-scaled thresholds)
+        if gyro_rms < sev_none:
             severity = "none"
-        elif gyro_rms < 5:
+        elif gyro_rms < sev_mild:
             severity = "mild"
-        elif gyro_rms < 15:
+        elif gyro_rms < sev_moderate:
             severity = "moderate"
         else:
             severity = "severe"
 
-        # Classify cause from dominant frequency
+        # Classify cause from dominant frequency — frame-size aware
         cause = None
         if severity != "none" and dominant_freq is not None:
             if dominant_freq < 10:
-                cause = "P_too_high"        # Low-freq: P-term overshoot
+                # Low-frequency wobble. On large frames (10"+), this is often
+                # wind buffeting or GPS position hold corrections, NOT P oscillation.
+                # True P oscillation has a sharp spectral peak (high prominence).
+                # Wind buffeting is broadband (low prominence).
+                if frame_inches >= 10 and peak_prominence < 6:
+                    cause = "wind_buffeting"  # Likely environmental, not tuning
+                elif frame_inches >= 10 and dominant_freq < 3:
+                    cause = "wind_buffeting"  # <3Hz on 10"+ is almost certainly wind
+                else:
+                    cause = "P_too_high"
             elif dominant_freq < 25:
                 cause = "PD_interaction"     # Mid-freq: P/D fighting
             elif dominant_freq < 50:
@@ -2651,7 +2675,11 @@ def detect_hover_oscillation(data, sr):
             else:
                 cause = "filter_gap"         # High-freq noise leaking through
         elif severity != "none":
-            cause = "unknown"
+            # No dominant frequency — broadband noise, likely environmental
+            if frame_inches >= 10:
+                cause = "wind_buffeting"
+            else:
+                cause = "unknown"
 
         results.append({
             "axis": axis,
@@ -2661,6 +2689,7 @@ def detect_hover_oscillation(data, sr):
             "severity": severity,
             "cause": cause,
             "hover_seconds": total_hover_seconds,
+            "peak_prominence": peak_prominence,
         })
 
     return results
@@ -2830,6 +2859,12 @@ def compute_recommended_filter(noise_results, current_hz, filter_type="gyro", pr
        before noise starts.
     3. Avoid placing the cutoff on or near a noise peak (would amplify it).
     4. Clamp to the frame profile's min/max range.
+    5. CHECK PHASE LAG: if the recommended cutoff would add excessive phase lag
+       compared to current, don't recommend lowering. Large quads (10"+) are
+       especially sensitive to phase lag — lowering LPF from 65 to 30Hz can
+       make oscillations worse even though noise numbers improve.
+    6. If noise is well above the current LPF (all peaks >2x current cutoff),
+       the LPF can't meaningfully help — recommend notch/RPM filters instead.
 
     Returns the recommended Hz value (int, rounded to 5), or None.
     """
@@ -2881,7 +2916,7 @@ def compute_recommended_filter(noise_results, current_hz, filter_type="gyro", pr
     # Apply safety margin: place cutoff below the crossover
     ideal = worst_crossover * safety
 
-    # Avoid placing cutoff near a noise peak (within ±15Hz of any strong peak)
+    # Avoid placing cutoff near a noise peak (within +/-15Hz of any strong peak)
     all_peaks = []
     for nr in valid:
         for p in nr["peaks"]:
@@ -2893,12 +2928,83 @@ def compute_recommended_filter(noise_results, current_hz, filter_type="gyro", pr
         if abs(ideal - peak_freq) < 15:
             ideal = min(ideal, peak_freq - 20)
 
+    # ── Phase lag guard ──
+    # If lowering the filter would significantly increase phase lag, don't.
+    # This is critical for large frames where phase lag causes more problems
+    # than the noise the filter would remove.
+    if current_hz is not None and ideal < current_hz:
+        signal_freq = profile.get("phase_lag_freq", 50.0)  # typical control freq
+
+        current_lag = estimate_filter_phase_lag(current_hz, signal_freq)
+        proposed_lag = estimate_filter_phase_lag(ideal, signal_freq)
+
+        if current_lag and proposed_lag:
+            added_lag_ms = proposed_lag["ms"] - current_lag["ms"]
+            added_lag_deg = proposed_lag["degrees"] - current_lag["degrees"]
+
+            # For 10"+ frames, even 5ms extra lag is significant
+            frame_size = profile.get("frame_inches", 5)
+            max_added_lag_ms = 8.0 if frame_size <= 7 else 5.0 if frame_size <= 10 else 3.0
+
+            if added_lag_ms > max_added_lag_ms:
+                # Lowering would add too much phase lag — don't recommend
+                return None
+
+    # ── Relative change guard ──
+    # On large frames, aggressive LPF cuts cause more harm than good.
+    # The added phase lag and signal attenuation destabilize the PID loop.
+    # Don't recommend cutting the LPF by more than 30% on 10"+.
+    if current_hz is not None and ideal < current_hz:
+        frame_size = profile.get("frame_inches", 5)
+        if frame_size >= 10:
+            max_reduction = 0.30  # 30% max cut for 10"+
+        elif frame_size >= 7:
+            max_reduction = 0.40  # 40% for 7"
+        else:
+            max_reduction = 0.50  # 50% for 5"
+
+        min_allowed = current_hz * (1.0 - max_reduction)
+        if ideal < min_allowed:
+            ideal = min_allowed  # Cap the reduction
+
+    # ── Propwash guard ──
+    # If the lowest significant noise is below ~80Hz, it's likely propwash
+    # (aerodynamic turbulence). LPF changes don't effectively address propwash
+    # because it's broadband — you'd have to crush the filter so low that
+    # the phase lag makes everything worse. Propwash is fixed through D-term
+    # tuning and flight technique, not gyro LPF.
+    if current_hz is not None and all_peaks and filter_type == "gyro":
+        lowest_peak = min(all_peaks)
+        frame_size = profile.get("frame_inches", 5)
+        # For large frames, propwash typically sits at 30-80Hz
+        propwash_ceiling = 80 if frame_size >= 10 else 100
+        if lowest_peak <= propwash_ceiling and ideal < current_hz:
+            # The noise driving the recommendation is in the propwash band.
+            # Don't lower the LPF — it won't help and will add lag.
+            # Only recommend if there are also peaks well above propwash.
+            peaks_above_propwash = [p for p in all_peaks if p > propwash_ceiling * 1.5]
+            if not peaks_above_propwash:
+                return None
+            # There are higher peaks too — but don't let propwash drive the cutoff down
+            ideal = max(ideal, current_hz * 0.85)  # at most 15% cut
+
+    # ── High-frequency noise guard ──
+    # If all significant noise is well above the current LPF (>2x cutoff),
+    # lowering the LPF won't meaningfully help — the noise needs notch/RPM
+    # filters, not a lower LPF that would crush phase margin.
+    if current_hz is not None and all_peaks:
+        lowest_significant_peak = min(all_peaks)
+        if lowest_significant_peak > current_hz * 2.0:
+            # All noise is far above current LPF — LPF change won't help
+            return None
+
     # Clamp and round
     result = round(int(np.clip(ideal, min_cutoff, max_cutoff)) / 5) * 5
     return result
 
 
-def compute_recommended_pid(pid_result, current_p, current_i, current_d, profile=None):
+def compute_recommended_pid(pid_result, current_p, current_i, current_d, profile=None,
+                            current_ff=None):
     if pid_result is None:
         return None
     if profile is None:
@@ -2918,6 +3024,26 @@ def compute_recommended_pid(pid_result, current_p, current_i, current_d, profile
     dl_high = delay > ok_dl
     dl_bad = delay > bad_dl
 
+    # ── FF-aware overshoot attribution ──
+    # FF drives initial response proportional to stick speed. High FF + high P
+    # = double overshoot source. When FF is significant (>40), attribute some
+    # overshoot to FF and reduce it before cutting P aggressively.
+    ff_is_high = current_ff is not None and current_ff > 40
+    ff_contributes_overshoot = ff_is_high and os_high
+
+    if ff_contributes_overshoot:
+        # Split the blame: FF handles stick-driven overshoot, P handles error-driven.
+        # With high FF, reduce FF first, smaller P cut.
+        ff_severity = current_ff / 60.0  # 1.0 at FF=60, higher = more blame on FF
+        ff_share = min(0.6, ff_severity * 0.3)  # FF takes up to 60% of the blame
+
+        new_ff = max(15, int(current_ff * (1 - min(0.25, ff_share * 0.4))))
+        if new_ff != current_ff:
+            changes["FF"] = {"current": current_ff, "new": new_ff}
+            reasons.append(
+                f"FeedForward is {current_ff} - contributes to overshoot on stick inputs. "
+                f"Reducing FF from {current_ff} to {new_ff} before cutting P.")
+
     # ── Severity-proportional P adjustment ──
     # How far off from target determines size of correction.
     # Profile's max_change caps the adjustment for safety.
@@ -2925,7 +3051,7 @@ def compute_recommended_pid(pid_result, current_p, current_i, current_d, profile
         new_p = current_p
 
         if os_high:
-            # severity: 1.0 = at ok threshold, 2.0 = 2× the ok threshold, etc.
+            # severity: 1.0 = at ok threshold, 2.0 = 2x the ok threshold, etc.
             severity = os_pct / ok_os
             if severity > 3.0:
                 raw_cut = 0.35
@@ -2936,6 +3062,11 @@ def compute_recommended_pid(pid_result, current_p, current_i, current_d, profile
             else:
                 raw_cut = 0.10
 
+            # If FF is taking some blame, reduce the P cut proportionally
+            if ff_contributes_overshoot:
+                ff_share_actual = min(0.6, (current_ff / 60.0) * 0.3)
+                raw_cut *= (1.0 - ff_share_actual)
+
             has_d = current_d is not None and current_d > 0
             d_hint = " and raise D" if has_d else ""
             if os_high and dl_high:
@@ -4028,6 +4159,8 @@ def generate_action_plan(noise_results, pid_results, motor_analysis, dterm_resul
     ok_noise = profile["ok_noise_db"]
     bad_noise = profile["bad_noise_db"]
 
+    info_items = []
+
     # ── Hover oscillation (highest priority - can't tune if quad won't hold still) ──
     if hover_osc:
         for osc in hover_osc:
@@ -4047,7 +4180,16 @@ def generate_action_plan(noise_results, pid_results, motor_analysis, dterm_resul
             freq_str = f" at ~{freq:.0f}Hz" if freq else ""
             amp_str = f"gyro RMS {rms:.1f}°/s, peak-to-peak {p2p:.0f}°/s{freq_str}"
 
-            if cause == "P_too_high":
+            if cause == "wind_buffeting":
+                # Low-frequency broadband wobble on large frame — likely wind, not P
+                # Don't recommend aggressive P cuts — show as informational
+                info_items.append({
+                    "text": f"{axis}: Low-frequency gyro activity ({rms:.1f}°/s RMS at ~{freq:.0f}Hz)",
+                    "detail": f"On a {profile.get('frame_inches', '?')}-inch frame, {freq:.0f}Hz wobble is "
+                              f"typically wind buffeting or GPS position corrections, not P oscillation. "
+                              f"If this happens indoors or in calm air, then P may be too high."})
+
+            elif cause == "P_too_high":
                 current_p = config.get(f"{axis_l}_p")
                 if current_p:
                     new_p = max(10, int(current_p * 0.70))  # Aggressive 30% cut
@@ -4143,7 +4285,6 @@ def generate_action_plan(noise_results, pid_results, motor_analysis, dterm_resul
                        f"Consider raising lowpass cutoffs or switching BIQUAD filters to PT1."})
 
     # ═══ 0b. MOTOR RESPONSE INFO (not an action - informational only) ═══
-    info_items = []
     if motor_response and motor_response["motor_response_ms"] > profile["ok_delay_ms"]:
         mr_ms = motor_response["motor_response_ms"]
         info_items.append({
@@ -4251,9 +4392,10 @@ def generate_action_plan(noise_results, pid_results, motor_analysis, dterm_resul
         cur_p = config.get(f"{axis.lower()}_p")
         cur_i = config.get(f"{axis.lower()}_i")
         cur_d = config.get(f"{axis.lower()}_d")
+        cur_ff = config.get(f"{axis.lower()}_ff")
 
         if has_config:
-            rec = compute_recommended_pid(pid, cur_p, cur_i, cur_d, profile)
+            rec = compute_recommended_pid(pid, cur_p, cur_i, cur_d, profile, current_ff=cur_ff)
             if rec and rec["changes"]:
                 _os = pid["avg_overshoot_pct"] or 0
                 _dl = pid["tracking_delay_ms"] or 0
@@ -4263,7 +4405,7 @@ def generate_action_plan(noise_results, pid_results, motor_analysis, dterm_resul
                 # Build a single merged description for all PID changes on this axis
                 change_parts = []
                 sub_actions = []  # for CLI generation
-                for term in ["P", "D", "I"]:
+                for term in ["FF", "P", "D", "I"]:
                     if term in rec["changes"]:
                         ch = rec["changes"][term]
                         direction = "Reduce" if ch["new"] < ch["current"] else "Increase"
@@ -4418,6 +4560,14 @@ def generate_action_plan(noise_results, pid_results, motor_analysis, dterm_resul
         for osc in hover_osc:
             rms = osc["gyro_rms"]
             sev = osc["severity"]
+            cause = osc.get("cause")
+
+            # Wind buffeting gets a much softer penalty — it's environmental,
+            # not a tuning problem. Don't tank the score for flying in wind.
+            if cause == "wind_buffeting":
+                osc_scores.append(max(60, 100 - rms * 2))  # Floor at 60
+                continue
+
             if sev == "none":
                 osc_scores.append(100)
             elif sev == "mild":
@@ -4611,9 +4761,9 @@ def create_dterm_chart(dterm_results):
 
 # Map from action plan param names to INAV CLI setting names
 INAV_CLI_MAP = {
-    "roll_p": "mc_p_roll", "roll_i": "mc_i_roll", "roll_d": "mc_d_roll",
-    "pitch_p": "mc_p_pitch", "pitch_i": "mc_i_pitch", "pitch_d": "mc_d_pitch",
-    "yaw_p": "mc_p_yaw", "yaw_i": "mc_i_yaw", "yaw_d": "mc_d_yaw",
+    "roll_p": "mc_p_roll", "roll_i": "mc_i_roll", "roll_d": "mc_d_roll", "roll_ff": "mc_cd_roll",
+    "pitch_p": "mc_p_pitch", "pitch_i": "mc_i_pitch", "pitch_d": "mc_d_pitch", "pitch_ff": "mc_cd_pitch",
+    "yaw_p": "mc_p_yaw", "yaw_i": "mc_i_yaw", "yaw_d": "mc_d_yaw", "yaw_ff": "mc_cd_yaw",
     "gyro_lowpass_hz": "gyro_main_lpf_hz", "gyro_lpf_hz": "gyro_main_lpf_hz",
     "gyro_lowpass2_hz": "gyro_main_lpf2_hz",
     "dterm_lpf_hz": "dterm_lpf_hz", "dterm_lpf2_hz": "dterm_lpf2_hz",
@@ -4626,12 +4776,15 @@ INAV_GUI_MAP = {
     "roll_p": ("PID Tuning", "Roll → P"),
     "roll_i": ("PID Tuning", "Roll → I"),
     "roll_d": ("PID Tuning", "Roll → D"),
+    "roll_ff": ("PID Tuning", "Roll → FF"),
     "pitch_p": ("PID Tuning", "Pitch → P"),
     "pitch_i": ("PID Tuning", "Pitch → I"),
     "pitch_d": ("PID Tuning", "Pitch → D"),
+    "pitch_ff": ("PID Tuning", "Pitch → FF"),
     "yaw_p": ("PID Tuning", "Yaw → P"),
     "yaw_i": ("PID Tuning", "Yaw → I"),
     "yaw_d": ("PID Tuning", "Yaw → D"),
+    "yaw_ff": ("PID Tuning", "Yaw → FF"),
     "gyro_lowpass_hz": ("Filtering", "Gyro LPF Hz"),
     "dterm_lpf_hz": ("Filtering", "D-term LPF Hz"),
 }
@@ -4708,19 +4861,26 @@ def generate_narrative(plan, pid_results, motor_analysis, noise_results, config,
 
     # Hover oscillation (most critical - mention first)
     hover_osc_data = plan["scores"].get("hover_osc", [])
-    osc_axes = [o for o in hover_osc_data if o["severity"] in ("moderate", "severe")] if hover_osc_data else []
+    # Filter out wind_buffeting — it's environmental, not a tuning problem
+    osc_axes = [o for o in hover_osc_data
+                if o["severity"] in ("moderate", "severe") and o.get("cause") != "wind_buffeting"
+                ] if hover_osc_data else []
+    wind_axes = [o for o in hover_osc_data
+                 if o["severity"] in ("moderate", "severe") and o.get("cause") == "wind_buffeting"
+                 ] if hover_osc_data else []
+
     if osc_axes:
         axis_names = [o["axis"] for o in osc_axes]
         worst = max(osc_axes, key=lambda o: o["gyro_rms"])
         if worst["severity"] == "severe":
             parts.append(
                 f"CRITICAL: The quad is oscillating during hover on {'/'.join(axis_names)} "
-                f"(worst: {worst['axis']} at {worst['gyro_rms']:.1f}°/s RMS). "
+                f"(worst: {worst['axis']} at {worst['gyro_rms']:.1f}\u00b0/s RMS). "
                 f"This must be fixed before any other tuning - the quad is fighting itself just to stay in the air.")
         else:
             parts.append(
                 f"The quad shows oscillation during hover on {'/'.join(axis_names)} "
-                f"(worst: {worst['axis']} at {worst['gyro_rms']:.1f}°/s RMS). "
+                f"(worst: {worst['axis']} at {worst['gyro_rms']:.1f}\u00b0/s RMS). "
                 f"This should be addressed first as it affects all other measurements.")
         if worst.get("dominant_freq_hz"):
             freq = worst["dominant_freq_hz"]
@@ -4733,6 +4893,14 @@ def generate_narrative(plan, pid_results, motor_analysis, noise_results, config,
             else:
                 parts.append(f"The oscillation frequency (~{freq:.0f}Hz) suggests noise is leaking through the filters.")
 
+    if wind_axes and not osc_axes:
+        # Only wind buffeting detected — inform but don't alarm
+        worst_w = max(wind_axes, key=lambda o: o["gyro_rms"])
+        parts.append(
+            f"Some low-frequency gyro activity detected on hover ({worst_w['gyro_rms']:.1f}\u00b0/s RMS at "
+            f"~{worst_w['dominant_freq_hz']:.0f}Hz). On this frame size, this is likely wind buffeting "
+            f"or GPS position corrections rather than a PID problem.")
+
     # PID behavior per axis
     ok_os = profile["ok_overshoot"]
     bad_os = profile["bad_overshoot"]
@@ -5933,7 +6101,7 @@ def count_blackbox_logs(filepath):
 # ─── Main ─────────────────────────────────────────────────────────────────────
 
 def main():
-    parser = argparse.ArgumentParser(description="INAV Blackbox Analyzer v2.16.1 - 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,
@@ -5973,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.")
@@ -6019,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:
@@ -6089,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)")
 
@@ -6143,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:
@@ -6206,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 ──
@@ -6252,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:
@@ -6276,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)
 
@@ -6289,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:
@@ -6413,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:
@@ -6467,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.
@@ -6475,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 = {}
@@ -6498,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).
@@ -6508,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
@@ -6517,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
 
@@ -6788,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", "")
@@ -6824,7 +7001,7 @@ def _analyze_for_compare(logfile, args, diff_raw=None):
     sr = data["sample_rate"]
 
     # Run all analyses
-    hover_osc = detect_hover_oscillation(data, sr)
+    hover_osc = detect_hover_oscillation(data, sr, profile)
     noise_results = [analyze_noise(data, ax, f"gyro_{ax.lower()}", sr) for ax in AXIS_NAMES]
     pid_results = [analyze_pid_response(data, i, sr) for i in range(3)]
     motor_analysis = analyze_motors(data, sr, config)
@@ -7081,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()
 
@@ -7091,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")
 
@@ -7606,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()
 
@@ -7615,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")
@@ -7665,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.
     
@@ -7710,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"]
@@ -7979,8 +8156,9 @@ def _analyze_single_log(logfile, args, diff_raw=None, summary_only=False):
     # ── NAV-ONLY MODE: skip tuning, run navigation health analysis ──
     if nav_mode:
         # Quick oscillation check - warn if PID tuning is polluting nav readings
-        hover_osc = detect_hover_oscillation(data, sr)
-        osc_severe = [h for h in hover_osc if h["severity"] in ("moderate", "severe")]
+        hover_osc = detect_hover_oscillation(data, sr, profile)
+        osc_severe = [h for h in hover_osc
+                      if h["severity"] in ("moderate", "severe") and h.get("cause") != "wind_buffeting"]
         tune_warning = False
         if osc_severe:
             tune_warning = True
@@ -8011,7 +8189,7 @@ def _analyze_single_log(logfile, args, diff_raw=None, summary_only=False):
             print("  Enable NAV_POS, NAV_ACC, and Attitude in blackbox settings.")
         return None
 
-    hover_osc = detect_hover_oscillation(data, sr)
+    hover_osc = detect_hover_oscillation(data, sr, profile)
     noise_results = [analyze_noise(data, ax, f"gyro_{ax.lower()}", sr) for ax in AXIS_NAMES]
     noise_fp = fingerprint_noise(noise_results, config, prop_harmonics)
     pid_results = [analyze_pid_response(data, i, sr) for i in range(3)]
@@ -8057,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
@@ -8072,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":
@@ -8115,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.16.1 → inav_toolkit-2.18.0}/inav_toolkit/flight_db.py

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

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

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

@@ -21,7 +21,7 @@ import sys
 import textwrap
 from datetime import datetime
 
-VERSION = "2.16.1"
+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.16.1 → inav_toolkit-2.18.0}/inav_toolkit/vtol_configurator.py

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

{inav_toolkit-2.16.1 → 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.16.1"
+    VERSION = "2.18.0"
 
 # Module paths for subprocess invocation (package-aware)
 ANALYZER_MODULE = "inav_toolkit.blackbox_analyzer"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inav-toolkit
-Version: 2.16.1
+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.16.1 → inav_toolkit-2.18.0}/pyproject.toml

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