[pull] master from iNavFlight:master

.dir-locals.el

@@ -0,0 +1,5 @@
+;;; Directory Local Variables            -*- no-byte-compile: t -*-
+;;; For more information see (info "(emacs) Directory Variables")
+
+((nil . ((c-basic-offset . 4)
+	 (c-default-style . "k&r"))))

.gitattributes

@@ -10,4 +10,4 @@
 Makefile text
 *.bat eol=crlf
 *.txt text
-*.sh text
+*.sh text eol=lf

.github/ISSUE_TEMPLATE/Bug_report.md

@@ -9,11 +9,12 @@ assignees: ''
 
 **PLEASE MAKE SURE YOU READ AND UNDERSTAND THE SOCIAL MEDIA SUPPORT CHANNELS. QUESTIONS ABOUT FLASHING, CONFIGURING, PILOTING MAY BE CLOSED WITHOUT FURTHER INTERACTION.**
 
-* [Telegram channel](https://t.me/INAVFlight)
-* [Facebook group](https://www.facebook.com/groups/INAVOfficial)
-* [RC Groups thread](https://www.rcgroups.com/forums/showthread.php?2495732-Cleanflight-iNav-%28navigation-rewrite%29-project)
+* [INAV Discord Server](https://discord.gg/peg2hhbYwN)
+* [INAV Official on Facebook](https://www.facebook.com/groups/INAVOfficial)
+* [INAV Official on Telegram](https://t.me/INAVFlight)
 
 **Please double-check that nobody reported the issue before by using search in this bug tracker.**
+**For Bug-Reports, please use the following template and provide as much information as possible. Bug-Reports that don't follow the template, might be closed unanswered. If you are not sure if you found a bug, ask for further input in the community channels or open a Github discussion.**
 
 **PLEASE DELETE THE TEXT ABOVE AFTER READING AND UNDERSTANDING IT**
 
@@ -38,7 +39,7 @@ assignees: ''
 
 ## Additional context
 <!-- Add any other context about the problem here.  -->
-<!-- Go to CLI, execute `dump` command copy its output to [PasteBin](https://pastebin.com) and provide a link to a paste here -->
+<!-- Go to CLI, execute `diff` command copy its output to [PasteBin](https://pastebin.com) and provide a link to a paste here -->
 
 ---
 <!-- PLEASE FILL THIS OUT -->

.github/PULL_REQUEST_TEMPLATE/new_target_pull_request.md

@@ -0,0 +1,38 @@
+This pull requests adds support for ``$TARGET_NAME``
+
+ * [ ] Target complies with ``docs/policies/NEW_HARDWARE_POLICY.md``
+
+The following items have been checked and confirmed working by an INAV developer on actual hardware: (feel free to remove non-relevant items)
+
+ * [ ] Samples received
+ * [ ] Flash firmware
+ * [ ] Calibrate
+ * [ ] Orientation matches
+ * [ ] Gyro working
+ * [ ] Accel working
+ * [ ] Voltage correct
+ * [ ] Current correct
+ * [ ] Baro working
+ * [ ] Mag I2C Bus
+ * [ ] Additional I2C2 Buses (Airspeed/other accessories)
+ * [ ] UART1
+ * [ ] UART2
+ * [ ] UART3
+ * [ ] UART4
+ * [ ] UART5
+ * [ ] UART6
+ * [ ] UART7
+ * [ ] UART8
+ * [ ] Analog Camera working
+ * [ ] Video Out working
+ * [ ] OSD working
+ * [ ] LEDs working
+ * [ ] Buzzer working
+ * [ ] Motor outputs
+ * [ ] DShot support on m1-4
+ * [ ] Servo outputs
+ * [ ] Blackbox
+ * [ ] PINIO1
+ * [ ] PINIO2
+ * [ ] PINIO3
+ * [ ] PINIO4

.github/scripts/artifact-workflow-filter.test.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+const { test } = require('node:test');
+
+function conditionFor(file, job) {
+    const source = fs.readFileSync(path.join(__dirname, '../workflows', file), 'utf8').replace(/\r\n/g, '\n');
+    const jobBody = source.split(`\n  ${job}:\n`)[1]?.split(/\n  [\w-]+:\n/)[0];
+    const expression = jobBody?.match(/\n    if: >\n((?:      .*\n)+)/)?.[1].trim();
+    assert.ok(expression, `Missing condition for ${file}:${job}`);
+    // The conditions use only member access, == and &&, so they run as JavaScript.
+    // GitHub's == ignores case and a missing object yields null; JS models neither.
+    return new Function('github', `return Boolean(${expression});`);
+}
+
+function event(overrides = {}) {
+    return {
+        workflow: { path: '.github/workflows/ci.yml' },
+        workflow_run: { name: 'Build firmware', event: 'pull_request', conclusion: 'success' },
+        ...overrides,
+    };
+}
+
+for (const [file, job] of [['pr-test-builds.yml', 'publish'], ['ci-size-report.yml', 'pr-comment']]) {
+    const accepts = conditionFor(file, job);
+    test(`${file}: accepts firmware without workflow_run.path`, () => {
+        assert.equal(accepts({ event: event() }), true);
+    });
+    test(`${file}: rejects same-name non-code workflow`, () => {
+        assert.equal(accepts({ event: event({ workflow: { path: '.github/workflows/non-code-change.yaml' } }) }), false);
+    });
+    test(`${file}: ignores a misleading run path`, () => {
+        const payload = event({ workflow: { path: '.github/workflows/non-code-change.yaml' } });
+        payload.workflow_run.path = '.github/workflows/ci.yml';
+        assert.equal(accepts({ event: payload }), false);
+    });
+    test(`${file}: rejects unsuccessful and non-PR runs`, () => {
+        for (const conclusion of ['failure', 'cancelled', 'skipped', 'action_required', null]) {
+            const payload = event();
+            payload.workflow_run.conclusion = conclusion;
+            assert.equal(accepts({ event: payload }), false);
+        }
+        const payload = event();
+        payload.workflow_run.event = 'push';
+        assert.equal(accepts({ event: payload }), false);
+    });
+    test(`${file}: rejects missing or unknown workflow paths`, () => {
+        for (const workflow of [{}, { path: '.github/workflows/other.yml' }]) {
+            assert.equal(accepts({ event: event({ workflow }) }), false);
+        }
+    });
+}
+
+test('firmware workflow path exists', () => {
+    assert.ok(fs.existsSync(path.join(__dirname, '../..', event().workflow.path)));
+});

.github/scripts/check-pg-versions.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Compare changed PG structs against registrations across the repository.
+
+Preprocessor branches are compared symbolically. Complex #if expressions are
+conservative independent conditions; this is not a C ABI or macro-expansion check.
+"""
+import ast
+import functools
+import itertools
+import os
+import re
+import subprocess
+import sys
+
+
+def git(*args, allow_missing=False):
+    result = subprocess.run(['git', *args], capture_output=True, text=True, encoding='utf-8', errors='replace')
+    if result.returncode and not (allow_missing and result.returncode == 1):
+        raise RuntimeError(result.stderr.strip() or 'git command failed')
+    return result.stdout
+
+
+def clean(source):
+    return re.sub(r'/\*.*?\*/|//[^\n]*', lambda m: '\n' * m[0].count('\n'), source, flags=re.S)
+
+
+def condition(text):
+    text = re.sub(r'\s+', '', text)
+    match = re.fullmatch(r'(!?)defined\(?([A-Za-z_]\w*)\)?', text)
+    return (('defined:' + match[2], not bool(match[1])) if match else (text, True))
+
+
+def annotated(source):
+    """Attach surrounding #if/#elif/#else predicates to each non-directive line."""
+    stack = []
+    result = []
+    for line in source.splitlines(keepends=True):
+        match = re.match(r'\s*#\s*(if|ifdef|ifndef|elif|else|endif)\b(.*)', line)
+        if match:
+            directive, value = match.groups()
+            if directive in ('if', 'ifdef', 'ifndef'):
+                atom = condition(value) if directive == 'if' else ('defined:' + value.strip(), directive == 'ifdef')
+                stack.append(([atom], [atom]))
+            elif directive == 'elif':
+                previous, _ = stack[-1]
+                atom = condition(value)
+                stack[-1] = (previous + [atom], [(a, not b) for a, b in previous] + [atom])
+            elif directive == 'else':
+                previous, _ = stack[-1]
+                stack[-1] = (previous, [(a, not b) for a, b in previous])
+            else:
+                stack.pop()
+            result.append(('', ()))
+        elif re.match(r'\s*#', line):
+            result.append(('', ()))
+        else:
+            result.append((line, tuple(item for _, active in stack for item in active)))
+    return result
+
+
+def structures(source):
+    source = clean(source)
+    lines = annotated(source)
+    result = {}
+    for match in re.finditer(r'\btypedef\s+struct(?:\s+[A-Za-z_]\w*)?\s*\{', source):
+        depth, end = 1, match.end()
+        while end < len(source) and depth:
+            depth += (source[end] == '{') - (source[end] == '}')
+            end += 1
+        alias = re.match(r'\s*([A-Za-z_]\w*)\s*;', source[end:])
+        if not alias:
+            continue
+        first = source.count('\n', 0, match.start())
+        last = source.count('\n', 0, end) + 1
+        result[alias[1]] = lines[first:last]
+    return result
+
+
+def registrations(ref):
+    paths = git('grep', '-l', '-E', 'PG_REGISTER', ref, '--', '*.c', '*.h', allow_missing=True).splitlines()
+    result = {}
+    for entry in paths:
+        path = entry[len(ref) + 1:]
+        lines = annotated(clean(git('show', ref + ':' + path)))
+        text = ''.join(line if line.endswith('\n') else line + '\n' for line, _ in lines)
+        for match in re.finditer(r'\bPG_REGISTER\w*\s*\(([^;]+?)\)\s*;', text):
+            args = [arg.strip() for arg in match[1].split(',')]
+            if len(args) < 4 or not re.fullmatch(r'[A-Za-z_]\w*', args[0]) or not args[-1].isdigit():
+                continue
+            line = text.count('\n', 0, match.start())
+            result.setdefault(args[0], []).append((args[-2], int(args[-1]), lines[line][1], path))
+    return result
+
+
+@functools.lru_cache(maxsize=None)
+def boolean_expression(expression):
+    names = []
+    def replace_defined(match):
+        names.append('defined:' + (match[1] or match[2]))
+        return 'v' + str(len(names) - 1)
+    translated = re.sub(r'defined(?:\(([A-Za-z_]\w*)\)|([A-Za-z_]\w*))', replace_defined, expression)
+    if not names:
+        return None
+    translated = translated.replace('&&', ' and ').replace('||', ' or ').replace('!', ' not ').strip()
+    try:
+        tree = ast.parse(translated, mode='eval')
+    except SyntaxError:
+        return None
+    allowed = (ast.Expression, ast.BoolOp, ast.And, ast.Or, ast.UnaryOp, ast.Not, ast.Name, ast.Load)
+    if any(not isinstance(node, allowed) for node in ast.walk(tree)):
+        return None
+    if any(isinstance(node, ast.Name) and node.id not in {'v' + str(i) for i in range(len(names))} for node in ast.walk(tree)):
+        return None
+    return tree.body, names
+
+
+def variables(expression):
+    parsed = boolean_expression(expression)
+    return parsed[1] if parsed else [expression]
+
+
+def evaluate(expression, values):
+    if expression in ('0', '1'):
+        return bool(int(expression))
+    parsed = boolean_expression(expression)
+    if not parsed:
+        return values[expression]
+    tree, names = parsed
+    def visit(node):
+        if isinstance(node, ast.Name):
+            return values[names[int(node.id[1:])]]
+        if isinstance(node, ast.UnaryOp):
+            return not visit(node.operand)
+        operands = [visit(value) for value in node.values]
+        return all(operands) if isinstance(node.op, ast.And) else any(operands)
+    return visit(tree)
+
+
+def active(predicates, values):
+    return all(evaluate(atom, values) == expected for atom, expected in predicates)
+
+
+def layout(lines, values):
+    return ''.join(re.sub(r'\s+', '', line) for line, predicates in lines if active(predicates, values))
+
+
+def check(base, head):
+    base = git('merge-base', base, head).strip()
+    changed = [path for path in git('diff', '--no-renames', '--name-only', base + '..' + head).splitlines() if path.endswith(('.c', '.h'))]
+    if not changed:
+        print('No C/H files changed')
+        return 0
+    old_paths = set(git('ls-tree', '-r', '--name-only', base).splitlines())
+    new_paths = set(git('ls-tree', '-r', '--name-only', head).splitlines())
+    old_structs, new_structs = {}, {}
+    for path in changed:
+        if path in old_paths:
+            old_structs.update(structures(git('show', base + ':' + path)))
+        if path in new_paths:
+            new_structs.update(structures(git('show', head + ':' + path)))
+    old_regs, new_regs = registrations(base), registrations(head)
+    issues = []
+    for name in old_structs.keys() & new_structs.keys() & new_regs.keys():
+        before, after = old_structs[name], new_structs[name]
+        if before == after:
+            continue
+        previous = old_regs.get(name, [])
+        current = new_regs[name]
+        if not previous:
+            continue  # No persisted instance existed before this change.
+        predicates = [p for _, p in before + after] + [r[2] for r in previous + current]
+        atoms = sorted({variable for predicate in predicates for atom, _ in predicate for variable in variables(atom)} - {'0', '1'})
+        if len(atoms) > 10:
+            issues.append(f'{name}: more than 10 conditional expressions; manually verify the PG versions')
+            continue
+        for flags in itertools.product((False, True), repeat=len(atoms)):
+            values = dict(zip(atoms, flags))
+            old_layout, new_layout = layout(before, values), layout(after, values)
+            if old_layout == new_layout or not old_layout:
+                continue
+            old_versions = {r[0]: r[1] for r in previous if active(r[2], values)}
+            new_versions = {r[0]: r[1] for r in current if active(r[2], values)}
+            if any(pg not in new_versions or new_versions[pg] <= version for pg, version in old_versions.items()):
+                issues.append(f'{name}: changed layout without a version increase in {", ".join(sorted({r[3] for r in current}))}; conditions {values}')
+                break
+    for issue in issues:
+        print('PG version issue: ' + issue)
+    if not issues:
+        print('No PG version issues detected')
+    return int(bool(issues))
+
+
+if __name__ == '__main__':
+    try:
+        base = 'origin/' + os.environ['GITHUB_BASE_REF'] if os.environ.get('GITHUB_BASE_REF') and os.environ.get('GITHUB_HEAD_REF') else 'HEAD~1'
+        sys.exit(check(base, 'HEAD'))
+    except (RuntimeError, ValueError, IndexError, OSError) as error:
+        print('PG checker error: ' + str(error), file=sys.stderr)
+        sys.exit(2)

.github/scripts/check-pg-versions.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+# Exit 0: checked, 1: potential PG version issue, 2: checker error.
+set -euo pipefail
+exec python3 "$(dirname "$0")/check-pg-versions.py"