fix kconfig, add _REG32

If the measured temperature exceeds the fixed threshold of 100 degC, a
fault is declared, causing batteryCheck to show a failsafe warning to
the user.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -3,92 +3,45 @@ description: Create a report to help us improve
 title: "[Bug] "
 labels: ["bug-report"]
 body:
+  - type: markdown
+    attributes:
+      value: |
+        **Tips for a great bug report:**
+        - Describe what went wrong and what you expected
+        - Include a flight log link from [logs.px4.io](http://logs.px4.io/) if possible
+        - Mention your PX4 version, flight controller, and vehicle type if relevant
+
   - type: textarea
     attributes:
       label: Describe the bug
-      description: A clear and concise description of the bug.
+      description: A clear description of the bug and what you expected to happen.
+      placeholder: |
+        What happened and what did you expect instead?
+
+        Steps to reproduce (if applicable):
+        1.
+        2.
+        3.
     validations:
       required: true
 
   - type: textarea
     attributes:
-      label: To Reproduce
+      label: Flight Log / Additional Information
       description: |
-          Steps to reproduce the behavior.
-          1. Drone switched on '...'
-          2. Uploaded mission '....' (attach QGC mission file)
-          3. Took off '....'
-          4. See error
-    validations:
-      required: false
+        **Flight log** (highly recommended for flight-related issues):
+        - Upload to [PX4 Flight Review](http://logs.px4.io/) and paste the link
 
-  - type: textarea
-    attributes:
-      label: Expected behavior
-      description: A clear and concise description of what you expected to happen.
-    validations:
-      required: false
-
-  - type: textarea
-    attributes:
-      label: Screenshot / Media
-      description: Add screenshot / media if you have them
-
-  - type: textarea
-    attributes:
-      label: Flight Log
-      description: |
-          *Always* provide a link to the flight log file:
-          - Download the flight log file from the vehicle ([tutorial](https://docs.px4.io/main/en/getting_started/flight_reporting.html)).
-          - Upload the log to the [PX4 Flight Review](http://logs.px4.io/)
-          - Share the link to the log (Copy and paste the URL of the log)
+        **Additional details** (if relevant):
+        - PX4 version (output of `ver all` in MAVLink Shell)
+        - Flight controller model
+        - Vehicle type (multicopter, fixed-wing, VTOL, etc.)
+        - Screenshots or media
       placeholder: |
-          # PASTE HERE THE LINK TO THE LOG
+        Flight log link:
+
+        Version:
+
+        Hardware:
     validations:
       required: false
-
-  - type: markdown
-    attributes:
-      value: |
-        ## Setup
-
-  - type: textarea
-    attributes:
-      label: Software Version
-      description: |
-          Which version of PX4 are you using?
-      placeholder: |
-          # If you don't know the version, paste the output of `ver all` in the MAVLink Shell of QGC
-    validations:
-      required: false
-
-  - type: input
-    attributes:
-      label: Flight controller
-      description: Specify your flight controller model (what type is it, where was it bought from, ...).
-    validations:
-      required: false
-
-  - type: dropdown
-    attributes:
-      label: Vehicle type
-      options:
-        - Multicopter
-        - Helicopter
-        - Fixed Wing
-        - Hybrid VTOL
-        - Airship/Balloon
-        - Rover
-        - Boat
-        - Submarine
-        - Other
-
-  - type: textarea
-    attributes:
-      label: How are the different components wired up (including port information)
-      description: Details about how all is wired.
-
-  - type: textarea
-    attributes:
-      label: Additional context
-      description: Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +1,4 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 contact_links:
   - name: Support Question
     url: https://docs.px4.io/main/en/contribute/support.html#forums-and-chat

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,22 +1,9 @@
 <!--
 
-Thank you for your contribution!
-
-Get early feedback through
-- Dronecode Discord: https://discord.gg/dronecode
-- PX4 Discuss: http://discuss.px4.io/
-- opening a draft pr and sharing the link
-
--->
-
 ### Solved Problem
-When ... I found that ...
-
 Fixes #{Github issue ID}
 
 ### Solution
-- Add ... for ...
-- Refactor ...
 
 ### Changelog Entry
 For release notes:
@@ -27,11 +14,10 @@ Documentation: Need to clarify page ... / done, read docs.px4.io/...
 ```
 
 ### Alternatives
-We could also ...
 
 ### Test coverage
-- Unit/integration test: ...
-- Simulation/hardware testing logs: https://review.px4.io/
 
 ### Context
 Related links, screenshot before/after, video
+
+-->

.github/instructions/docs.en.instructions.md

@@ -0,0 +1,48 @@
+---
+applyTo: "docs/en/**"
+---
+
+# Review Guidelines docs/en Tree
+
+## File System & Structure
+
+- **Naming:** Use `lowercase_with_underscores` for all filenames. No spaces.
+- **Hierarchy:** Markdown files must reside exactly in a first-level category folder. 
+  - Valid: `docs/en/category/file.md`
+  - Invalid: `docs/en/category/subcategory/file.md`
+- **Text Files:** Any `.txt` or `.text` files must start with an underscore (e.g., `_notes.txt`).
+- **Assets:** All images/non-docs must be in `/docs/assets/`. Deep nesting is permitted here.
+- **Formats:** Prefer **SVG** for diagrams and **PNG** for screenshots. Flag JPG files.
+
+## Markdown & Style
+
+- **Headings:** Use Title Case ("First Letter Capitalisation"). 
+  - The Page Title must be the only H1 (`#`). All others must be `##` or lower.
+  - Do not apply bold or italic styling inside a heading.
+- **Formatting:** 
+  - **Bold:** Only for UI elements (buttons, menu items).
+  - **Italics (Emphasis):** For tool names (e.g., *QGroundControl*).
+  - **Inline Code:** Use backticks for file paths, parameters, and CLI commands (e.g., `prettier`).
+- **Structure:** End every line at the end of a sentence (Semantic Line Breaks).
+
+## Linking & Navigation
+
+- **Standard Links:** Use standard inline syntax: `[link text](../category/filename.md)`.
+  Note relative link. 
+- **Table Links:** To keep tables readable, use reference-style links.
+  - Definition: `[Link Name]: https://example.com` (placed below the table).
+  - Usage: `[Link Name]` within the table cell.
+- **Images:** All image links must include a descriptive, accessible alt-text in the brackets: `![Detailed description of the image content](../../assets/path/to/image.png)`.
+  Note that all images should be relative references to images stored in the assets folder, which should be two folders below the any markdown file (as they are stored in a "category" subfolder) 
+
+- **Standard Links:** Use standard inline syntax: `[link text](../category/filename.md)`. Note the use of relative links.
+- **Table Links:** To keep tables easier to edit, prefer reference-style links.
+  - Definition: `[Link Name]: https://example.com` (placed below the table).
+  - Usage: `[Link Name]` within the table cell.
+- **Images:** All image links must include a descriptive, accessible alt-text: `![Detailed description of the image content](../../assets/path/to/image.png)`.
+  - **Note:** All images must be relative references to the `/docs/assets/` folder. Since documents are nested in a category folder, this is usually two levels up (`../../assets/`).
+
+## Quality Control
+
+- **Prettier Check:** Ensure Prettier rules have been applied. If there is evidence of inconsistent indentation or spacing, request the author run `npx prettier --write .` before merging.
+- **Language:** Enforce **UK English** spelling and grammar.

.github/workflows/flash_analysis.yml

@@ -54,6 +54,7 @@ jobs:
         run: |
           make clean
           make distclean
+          make submodulesclean
 
       - name: If it's a PR checkout the base branch
         if: ${{ github.event.pull_request }}

.github/workflows/ros_integration_tests.yml

@@ -90,6 +90,9 @@ jobs:
         mkdir -p /opt/px4_ws/src
         cd /opt/px4_ws/src
         git clone --recursive https://github.com/Auterion/px4-ros2-interface-lib.git
+        # Ignore python packages due to compilation issue (can be enabled when updating ROS)
+        touch px4-ros2-interface-lib/px4_ros2_py/COLCON_IGNORE || true
+        touch px4-ros2-interface-lib/examples/python/COLCON_IGNORE || true
         cd ..
         # Copy messages to ROS workspace
         "${PX4_DIR}/Tools/copy_to_ros_ws.sh" "$(pwd)"

.github/workflows/stale.yml

@@ -15,7 +15,7 @@ jobs:
           stale-issue-label: 'stale'
           stale-pr-label: 'stale'
           remove-stale-when-updated: true
-          stale-issue-message: 'This issue has been marked as stale due to 90 days of inactivity. If no further activity occurs, it will be automatically closed in 30 days. Please leave a comment, add a reaction, make an update, or remove the stale label if you’d like to keep it open.'
-          close-issue-message: 'This issue has been closed due to prolonged inactivity after being marked as stale. If you believe this was closed in error or the topic is still relevant, please feel free to reopen it or create a new issue.'
-          stale-pr-message: 'This PR was identified as stale and it will be closed in 30 days unless any activity is detected.'
-          close-pr-message: 'This pull request has been closed after being marked as stale with no further activity. Thank you for the time and effort you put into this contribution. If you’d like to continue the discussion or update the work, please feel free to reopen it or submit a new PR.'
+          stale-issue-message: ''
+          close-issue-message: 'This issue has been automatically closed due to 120 days of inactivity. If you believe this is still relevant, please feel free to reopen it or create a new issue.'
+          stale-pr-message: ''
+          close-pr-message: 'This pull request has been automatically closed due to 120 days of inactivity. If you would like to continue, please feel free to reopen it or submit a new PR.'

.github/workflows/sync_to_px4_msgs.yml

@@ -0,0 +1,62 @@
+name: Sync ROS 2 messages to px4_msgs
+on:
+  push:
+    branches:
+      - 'main'
+      - 'stable'
+      - 'beta'
+      - 'release/**'
+    paths:
+      - 'msg/**'
+      - 'srv/**'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  sync_to_px4_msgs:
+    if: github.repository == 'PX4/PX4-Autopilot'
+    runs-on: [runs-on,runner=4cpu-linux-x64,image=ubuntu22-full-x64,"run-id=${{ github.run_id }}",spot=false]
+    steps:
+      - name: Checkout PX4 repo
+        uses: actions/checkout@v4
+
+      - name: Setup git credentials
+        run: |
+          git config --global user.name "${{ secrets.PX4BUILDBOT_USER }}"
+          git config --global user.email "${{ secrets.PX4BUILDBOT_EMAIL }}"
+
+      - name: Clone PX4_msgs repo
+        run: |
+          git clone https://${{ secrets.PX4BUILTBOT_PERSONAL_ACCESS_TOKEN }}@github.com/PX4/px4_msgs.git
+
+      - name: Check out the same branch as the PX4 repo
+        run: |
+          cd px4_msgs
+          if git checkout ${{ github.ref_name }}; then
+            echo "Checked out existing branch"
+          else
+            git checkout -b ${{ github.ref_name }}
+          fi
+
+      - name: Copy ROS 2 messages
+        run: |
+          rm -f px4_msgs/msg/*.msg
+          rm -f px4_msgs/msg/versioned/*.msg
+          rm -f px4_msgs/srv/*.srv
+          rm -f px4_msgs/srv/versioned/*.srv
+          cp msg/*.msg px4_msgs/msg/
+          cp msg/versioned/*.msg px4_msgs/msg/ || true
+          cp srv/*.srv px4_msgs/srv/
+          cp srv/versioned/*.srv px4_msgs/srv/ || true
+
+      - name: Commit and push changes
+        run: |
+          cd px4_msgs
+          git status
+          git add .
+          git commit -a -m "Update to PX4 ${{ github.sha }}" || true
+          git push origin ${{ github.ref_name }} || true
+          cd ..
+          rm -rf px4_msgs

.gitmodules

@@ -103,3 +103,9 @@
 [submodule "src/drivers/ins/sbgecom/sbgECom"]
 	path = src/drivers/ins/sbgecom/sbgECom
 	url = https://github.com/PX4/sbgECom.git
+[submodule "src/modules/mc_raptor/blob"]
+	path = src/modules/mc_raptor/blob
+	url = https://github.com/rl-tools/px4-blob
+[submodule "src/lib/rl_tools/rl_tools"]
+	path = src/lib/rl_tools/rl_tools
+	url = https://github.com/rl-tools/rl-tools.git

.vscode/cmake-variants.yaml

@@ -6,6 +6,16 @@ CONFIG:
       buildType: RelWithDebInfo
       settings:
         CONFIG: px4_sitl_default
+    px4_sitl_raptor:
+      short: px4_sitl_raptor
+      buildType: RelWithDebInfo
+      settings:
+        CONFIG: px4_sitl_raptor
+    px4_sitl_raptor_debug:
+      short: px4_sitl_raptor_debug
+      buildType: Debug
+      settings:
+        CONFIG: px4_sitl_raptor
     px4_sitl_spacecraft:
       short: px4_sitl_spacecraft
       buildType: RelWithDebInfo
@@ -531,3 +541,13 @@ CONFIG:
       buildType: MinSizeRel
       settings:
         CONFIG: svehicle_e2_default
+    x-mav_ap-h743r1_bootloader:
+      short: x-mav_ap-h743r1-boot
+      buildType: MinSizeRel
+      settings:
+        CONFIG: x-mav_ap-h743r1_bootloader
+    x-mav_ap-h743r1_default:
+      short: x-mav_ap-h743r1
+      buildType: MinSizeRel
+      settings:
+        CONFIG: x-mav_ap-h743r1_default

CLAUDE.md

@@ -0,0 +1,467 @@
+# Bitbang DShot Prototype - Design Specification
+
+## Goal
+
+Implement bitbang DShot (including bidirectional) as an alternative to the existing DMA burst/capture approach in the STM32H7 platform layer. The implementation is generic - it works on any STM32H7 board by dynamically discovering port/pin groupings from `timer_io_channels[]` at init time. The **ARK FPV** board is the test target.
+
+Bitbang DShot uses a pacer timer to trigger DMA transfers to/from GPIO registers (BSRR for output, IDR for input), instead of using timer PWM channels with DMA burst to CCR registers. This decouples motor signal generation from timer channel hardware and enables simultaneous capture of all motors on a GPIO port (eliminating round-robin).
+
+## Key Advantage Over Current Approach
+
+The current BDShot implementation captures **one motor per timer per cycle** (round-robin) because each capture channel needs its own DMA stream. At 200Hz update rate, each motor gets RPM updates at only 50Hz (200/4).
+
+Bitbang capture reads the entire GPIO IDR register on every sample, capturing **all motors on a port simultaneously**. Every cycle produces RPM data for every motor - a 4x improvement in per-motor RPM update rate.
+
+## Architecture Overview
+
+### Current (DMA Burst/Capture)
+```
+Timer (PWM mode) ──► CCR1-CCR4 (via DMA burst to DMAR) ──► Pin AF output
+Timer (Capture mode) ──► CCR edge timestamps (via per-channel DMA) ──► one channel at a time
+```
+
+### Bitbang
+```
+Timer (counter mode) ──► Update event triggers DMA ──► writes BSRR words to GPIO port
+Timer (counter mode) ──► Update event triggers DMA ──► reads IDR from GPIO port (all pins)
+```
+
+## Port Group Discovery
+
+At init time, the implementation iterates `timer_io_channels[]` and groups channels by GPIO port. The port and pin are extracted from the existing `gpio_out` field using NuttX bit encoding:
+
+```c
+#include <stm32_gpio.h>  // GPIO_PORT_MASK, GPIO_PORT_SHIFT, GPIO_PIN_MASK, GPIO_PIN_SHIFT
+
+// Extract port index and pin number from timer_io_channels[ch].gpio_out
+uint8_t port_index = (gpio_out & GPIO_PORT_MASK) >> GPIO_PORT_SHIFT;  // 0=A, 1=B, ... 7=H, 8=I
+uint8_t pin_number = (gpio_out & GPIO_PIN_MASK) >> GPIO_PIN_SHIFT;    // 0-15
+
+// Get GPIO peripheral base address from NuttX lookup table
+uint32_t gpio_base = g_gpiobase[port_index];  // e.g., STM32_GPIOH_BASE = 0x58021C00
+```
+
+### Port Group Init Algorithm
+
+```c
+// Pseudocode for up_dshot_init()
+for (uint8_t ch = 0; ch < MAX_TIMER_IO_CHANNELS; ch++) {
+    if (!(channel_mask & (1 << ch))) continue;
+
+    uint32_t gpio_out = timer_io_channels[ch].gpio_out;
+    uint8_t port_index = (gpio_out & GPIO_PORT_MASK) >> GPIO_PORT_SHIFT;
+    uint8_t pin_num = (gpio_out & GPIO_PIN_MASK) >> GPIO_PIN_SHIFT;
+    uint8_t timer_index = timer_io_channels[ch].timer_index;
+
+    // Find or create port group for this GPIO port
+    port_group_t *pg = find_or_create_port_group(port_index);
+    pg->gpio_base = g_gpiobase[port_index];
+    pg->pin_mask |= (1 << pin_num);
+    pg->moder_mask |= (3 << (pin_num * 2));
+    pg->moder_output |= (1 << (pin_num * 2));  // 01 = output mode
+    pg->pin_numbers[pg->pin_count] = pin_num;
+    pg->output_channels[pg->pin_count] = ch;
+    pg->pin_count++;
+
+    // Assign a pacer timer - use the first timer associated with any motor on this port.
+    // On H7 with DMAMUX the timer just needs a TIMx_UP DMA mapping; any timer works.
+    if (pg->timer_index == UINT8_MAX) {
+        pg->timer_index = timer_index;
+    }
+}
+```
+
+This works on any board. Motors on the same GPIO port share a port group regardless of which timer they were originally assigned to.
+
+### ARK FPV Example (test target)
+
+On the ARK FPV, the above algorithm produces two port groups:
+
+| Motor   | GPIO  | Pin | Port Group | Pacer Timer |
+|---------|-------|-----|------------|-------------|
+| FMU_CH1 | PI0   | 0   | Port I     | TIM5 (first timer seen on Port I) |
+| FMU_CH2 | PH12  | 12  | Port H     | TIM5        |
+| FMU_CH3 | PH11  | 11  | Port H     | TIM5        |
+| FMU_CH4 | PH10  | 10  | Port H     | TIM5        |
+| FMU_CH5 | PI5   | 5   | Port I     | (already assigned) |
+| FMU_CH6 | PI6   | 6   | Port I     | (already assigned) |
+| FMU_CH7 | PI7   | 7   | Port I     | (already assigned) |
+| FMU_CH8 | PI2   | 2   | Port I     | (already assigned) |
+
+- **Port H group**: 3 motors, pin_mask=0x1C00, pacer=TIM5
+- **Port I group**: 5 motors, pin_mask=0xE5, pacer=TIM5 (first timer found; could also be TIM8)
+
+Note: The pacer timer just needs a valid `dma_map_up` entry. The first timer encountered for a port group is used. Since DMAMUX on H7 can route any timer update event to any DMA stream, any timer with DMA configured works as a pacer.
+
+## GPIO Registers (STM32H7)
+
+```
+Offset 0x00: MODER   - Mode register (2 bits/pin: 00=input, 01=output, 10=AF, 11=analog)
+Offset 0x10: IDR     - Input data register (read-only, bits [15:0] = pin state)
+Offset 0x14: ODR     - Output data register
+Offset 0x18: BSRR    - Bit set/reset register (write-only, atomic)
+                        Bits [15:0]  = SET (writing 1 sets pin HIGH)
+                        Bits [31:16] = RESET (writing 1 sets pin LOW)
+                        Writing 0 = no change
+```
+
+GPIO base addresses are looked up at runtime via `g_gpiobase[port_index]` (NuttX global array).
+
+### MODER Manipulation
+
+Pin masks and MODER masks are computed dynamically during port group init from the discovered pin numbers:
+
+```c
+// For each pin in the port group:
+pg->pin_mask |= (1 << pin_num);                 // for BSRR set/reset
+pg->moder_mask |= (3 << (pin_num * 2));         // which MODER bits to touch
+pg->moder_output |= (1 << (pin_num * 2));       // 01 = general purpose output
+// moder_input is always 0 (clear the bits = input mode)
+```
+
+To switch to output: `modifyreg32(gpio_base + STM32_GPIO_MODER_OFFSET, pg->moder_mask, pg->moder_output)`
+To switch to input:  `modifyreg32(gpio_base + STM32_GPIO_MODER_OFFSET, pg->moder_mask, 0)`
+
+## DMA Configuration
+
+The DMA request source (DMAMUX) stays the same as current - TIMx_UP triggers each DMA transfer. The only change is the **peripheral address** and **transfer direction**.
+
+### Output DMA (Memory → GPIO BSRR)
+```c
+// Peripheral address is GPIO BSRR instead of TIM DMAR
+px4_stm32_dmasetup(pg->dma_handle,
+    pg->gpio_base + STM32_GPIO_BSRR_OFFSET,       // e.g., 0x58021C18 for Port H
+    (uint32_t)bsrr_output_buffer[pg_index],
+    SUBPERIODS_PER_BIT * DSHOT_FRAME_BITS,          // 20 * 16 = 320 transfers (+ 1 trailing zero)
+    DMA_SCR_PRIHI | DMA_SCR_MSIZE_32BITS | DMA_SCR_PSIZE_32BITS |
+    DMA_SCR_MINC | DMA_SCR_DIR_M2P | DMA_SCR_TCIE);
+```
+
+### Input DMA (GPIO IDR → Memory)
+```c
+px4_stm32_dmasetup(pg->dma_handle,
+    pg->gpio_base + STM32_GPIO_IDR_OFFSET,          // e.g., 0x58021C10 for Port H
+    (uint32_t)idr_capture_buffer[pg_index],
+    CAPTURE_SAMPLE_COUNT,                            // enough samples for GCR frame (~512)
+    DMA_SCR_PRIHI | DMA_SCR_MSIZE_16BITS | DMA_SCR_PSIZE_16BITS |
+    DMA_SCR_MINC | DMA_SCR_DIR_P2M | DMA_SCR_TCIE);
+```
+
+### DMAMUX Routing (unchanged)
+
+Each port group uses its pacer timer's `dma_map_up` for DMAMUX routing:
+```c
+pg->dma_handle = stm32_dmachannel(io_timers[pg->timer_index].dshot.dma_map_up);
+```
+
+The DMAMUX determines **when** the DMA fires (on timer update events). The DMA stream registers determine **what** gets transferred (BSRR/IDR addresses). These are independent - the DMA request source and transfer target don't need to be the same peripheral.
+
+## Timer Configuration
+
+Each port group's pacer timer is configured as a simple upcounter. No PWM output, no capture-compare - just generate periodic update events.
+
+```c
+// Same prescaler as current DShot implementation
+rPSC(timer) = ((timer_clock_freq / dshot_pwm_freq) / DSHOT_MOTOR_PWM_BIT_WIDTH) - 1;
+rARR(timer) = DSHOT_MOTOR_PWM_BIT_WIDTH - 1;  // 19 (20 counts per sub-period)
+// Enable update DMA request
+rDIER(timer) |= ATIM_DIER_UDE;
+// Enable counter
+rCR1(timer) |= GTIM_CR1_CEN;
+```
+
+With `DSHOT_MOTOR_PWM_BIT_WIDTH = 20`, each timer update fires DMA once per sub-period. One DShot bit = 20 sub-periods.
+
+## Output Buffer Layout (BSRR Words)
+
+Each DShot frame is 16 bits. Each bit has 20 sub-periods. The buffer contains one 32-bit BSRR word per sub-period.
+
+**DShot bit waveform (sub-periods 0-19):**
+- Bit '1' (70% duty): SET at sub-period 0, RESET at sub-period 14, zeros elsewhere
+- Bit '0' (35% duty): SET at sub-period 0, RESET at sub-period 7, zeros elsewhere
+
+**Buffer structure per port:**
+```
+[bit0_subperiod0] [bit0_subperiod1] ... [bit0_subperiod19]
+[bit1_subperiod0] [bit1_subperiod1] ... [bit1_subperiod19]
+...
+[bit15_subperiod0] [bit15_subperiod1] ... [bit15_subperiod19]
+[trailing_zero]  ← ensures all pins return LOW at frame end
+```
+
+Total: (16 * 20) + 1 = 321 BSRR words = 1284 bytes per port.
+
+**Encoding example** (3 motors on pins 10, 11, 12 of some port, sending bits 1, 0, 1):
+```
+Sub-period 0:  BSRR = (1<<10) | (1<<11) | (1<<12)  = 0x00001C00  (SET all three)
+Sub-period 7:  BSRR = (1<<(11+16))                  = 0x00080000  (RESET pin11 only - it's '0')
+Sub-period 14: BSRR = (1<<(10+16)) | (1<<(12+16))   = 0x14000000  (RESET pin10, pin12 - they're '1')
+All other sub-periods: BSRR = 0x00000000 (no change)
+```
+
+### Motor Data Set Function
+
+The port group index and pin number for each output channel are determined at init time and stored in a lookup table. No per-frame discovery needed.
+
+```c
+// Populated during up_dshot_init() from timer_io_channels[ch].gpio_out
+static uint8_t _channel_to_port_group[MAX_TIMER_IO_CHANNELS];
+static uint8_t _channel_to_pin[MAX_TIMER_IO_CHANNELS];
+
+void dshot_motor_data_set(uint8_t output_channel, uint16_t packet)
+{
+    uint8_t pg_index = _channel_to_port_group[output_channel];
+    uint8_t pin_num = _channel_to_pin[output_channel];
+    uint32_t set_mask = (1 << pin_num);
+    uint32_t reset_mask = (1 << (pin_num + 16));
+
+    uint32_t *buffer = bsrr_output_buffer[pg_index];
+
+    for (int bit = 0; bit < 16; bit++) {
+        int base = bit * SUBPERIODS_PER_BIT;
+        bool is_one = (packet >> (15 - bit)) & 1;  // MSB first
+        int reset_point = is_one ? MOTOR_PWM_BIT_1 : MOTOR_PWM_BIT_0;
+
+        buffer[base + 0] |= set_mask;               // SET at start of bit
+        buffer[base + reset_point] |= reset_mask;    // RESET at duty cycle end
+    }
+}
+```
+
+Note: Buffer must be zeroed before building each frame, then all motors OR their masks into the shared per-port buffer.
+
+## Capture Buffer Layout (IDR Samples)
+
+After transmitting, GPIO pins switch to input mode. DMA samples the IDR register at the same timer rate (20 sub-periods per DShot bit period).
+
+**GCR response timing:**
+- GCR bit rate = DShot bit rate * 5/4 (750kHz for DShot600)
+- GCR bit period = 1.333us
+- Sample period = 83.3ns (at DShot600 with 20 sub-periods)
+- Samples per GCR bit = ~16 (heavy oversampling, good for edge detection)
+- GCR frame = 21 bits = ~336 samples minimum
+- Use 400-512 samples to be safe
+
+**Buffer:** Array of uint16_t, one per IDR sample.
+```
+[idr_sample_0] [idr_sample_1] ... [idr_sample_N]
+```
+
+Each sample contains all 16 pins of the port. Extract per-motor bitstream by masking:
+```c
+bool pin_state = (idr_sample >> pin_num) & 1;
+```
+
+### Capture Processing
+
+Convert IDR samples to edge intervals, then reuse existing GCR decoder:
+
+```c
+void process_bitbang_capture(uint8_t port_group, uint8_t pin_num, uint8_t output_channel)
+{
+    uint16_t *buffer = idr_capture_buffer[port_group];
+    uint32_t intervals[32];
+    unsigned interval_count = 0;
+
+    // Extract edges from IDR samples
+    bool prev_state = (buffer[0] >> pin_num) & 1;
+    unsigned last_edge = 0;
+
+    for (unsigned i = 1; i < CAPTURE_SAMPLE_COUNT; i++) {
+        bool state = (buffer[i] >> pin_num) & 1;
+        if (state != prev_state) {
+            // Edge detected
+            if (last_edge > 0 && interval_count < 32) {
+                intervals[interval_count++] = i - last_edge;
+            }
+            last_edge = i;
+            prev_state = state;
+        }
+    }
+
+    // Now decode using same GCR logic as existing code
+    // intervals[] contains sample counts between edges
+    // (equivalent to CCR timestamp differences in current impl)
+}
+```
+
+The existing `convert_edge_intervals_to_bitstream()` logic (adaptive base interval, bit counting, RLL/GCR decode, CRC check) can be reused with minor adaptation since the interval units are now sample counts instead of timer ticks. The ratio math is identical.
+
+## Sequence of Operations
+
+### Per-cycle flow (called from `up_dshot_trigger()`):
+
+```
+1. TRANSMIT PHASE
+   a. Zero the BSRR output buffers for all port groups
+   b. Build BSRR buffers (call dshot_motor_data_set for each motor)
+      - Each motor ORs its pin masks into its port group's shared buffer
+   c. Configure GPIO pins as output (MODER = 01) for each port group
+   d. Flush dcache on output buffers
+   e. For each port group:
+      - Allocate DMA via stm32_dmachannel(io_timers[pg->timer_index].dshot.dma_map_up)
+      - Setup DMA: memory→BSRR, 32-bit, 321 transfers
+      - Enable timer UDE (update DMA request)
+      - Start DMA with burst_finished_callback
+      - Enable timer counter
+   f. ~27us later (16 bits × 20 sub-periods × 83.3ns), DMA complete fires
+
+2. TRANSITION PHASE (in burst_finished_callback, per port group)
+   a. Stop DMA, free DMA handle
+   b. Disable timer
+   c. Switch GPIO pins to input mode (MODER = 00)
+   d. Schedule capture start via hrt_call_after(30us)
+
+3. CAPTURE PHASE (in capture_start_callback, per port group)
+   a. Zero capture buffer for this port group
+   b. Flush dcache
+   c. Allocate DMA via stm32_dmachannel(dma_map_up) [reuse same DMAMUX route]
+   d. Setup DMA: IDR→memory, 16-bit, 512 transfers
+   e. Enable timer UDE, start DMA, enable timer
+   f. Schedule capture_complete via hrt_call_after(frame_time + margin)
+
+4. PROCESSING PHASE (in capture_complete_callback, per port group)
+   a. Stop DMA, free DMA handle
+   b. Disable timer
+   c. Invalidate dcache on capture buffer
+   d. For EACH motor on the port (not round-robin!):
+      - Extract per-pin bitstream from IDR samples using pin_numbers[]
+      - Detect edges, compute intervals
+      - Decode GCR → eRPM/EDT
+   e. Switch GPIO back to output mode (MODER = 01)
+   f. Mark port group cycle complete
+
+```
+
+## File Structure
+
+### New file: `platforms/nuttx/src/px4/stm/stm32_common/dshot/dshot_bitbang.c`
+
+Implements the same `up_dshot_*` API as `dshot.c`:
+- `up_dshot_init()` - Initialize port groups, allocate DMA, configure timers
+- `up_dshot_trigger()` - Start the TX→wait→RX→process cycle
+- `dshot_motor_data_set()` - Build BSRR words into port group buffers
+- `up_dshot_arm()` - Enable/disable GPIO output
+- `up_bdshot_get_erpm()` - Return captured eRPM (unchanged)
+- `up_bdshot_channel_online()` - Return online status (unchanged)
+- `up_bdshot_status()` - Print diagnostics
+
+### New/modified: `platforms/nuttx/src/px4/stm/stm32_common/dshot/CMakeLists.txt`
+
+Add build option to select `dshot.c` vs `dshot_bitbang.c`.
+
+### Board-level config
+
+No board-specific changes needed. The bitbang implementation reads the same `io_timers[]` and `timer_io_channels[]` structures that every board already defines. It extracts GPIO port/pin from `timer_io_channels[].gpio_out` (which `initIOTimerChannel()` already populates with `getGPIOPort(pin.port) | getGPIOPin(pin.pin)`) and the DMA mapping from `io_timers[].dshot.dma_map_up`.
+
+A board opts into bitbang mode via a build flag or Kconfig option that selects `dshot_bitbang.c` instead of `dshot.c`.
+
+### What stays the same
+- `drv_dshot.h` API - no changes
+- `DShot.cpp` / `DShot.h` (the driver module) - no changes
+- `DShotTelemetry.cpp` / `DShotTelemetry.h` - no changes
+- GCR decoding logic - copied/adapted from dshot.c but the core algorithm is identical
+- All higher-level consumers of eRPM data
+
+## Data Structures
+
+```c
+#define MAX_PORT_GROUPS 4  // Max distinct GPIO ports with motor pins (typically 1-3)
+#define MAX_PINS_PER_GROUP 8
+
+// Port group: one per GPIO port that has motor pins. Built dynamically at init.
+typedef struct port_group_t {
+    uint32_t gpio_base;                          // GPIO port base address (from g_gpiobase[])
+    uint8_t  port_index;                         // NuttX port index (0=A, 7=H, 8=I, etc.)
+    uint32_t pin_mask;                           // Bitmask of motor pins on this port
+    uint32_t moder_mask;                         // MODER register mask for mode switching
+    uint32_t moder_output;                       // MODER value for output mode (01 per pin)
+    uint8_t  pin_count;                          // Number of motor pins on this port
+    uint8_t  pin_numbers[MAX_PINS_PER_GROUP];    // Pin numbers (0-15)
+    uint8_t  output_channels[MAX_PINS_PER_GROUP]; // Corresponding output channel indices
+    uint8_t  timer_index;                        // Pacer timer index (into io_timers[])
+    DMA_HANDLE dma_handle;                       // DMA stream handle (reused between TX/RX)
+    bool     bidirectional;                      // BDShot enabled for this group
+    bool     cycle_complete;                     // Ready for next trigger
+} port_group_t;
+
+static port_group_t _port_groups[MAX_PORT_GROUPS] = {};
+static uint8_t _num_port_groups = 0;
+
+// Per-channel lookup tables (populated at init from timer_io_channels[].gpio_out)
+static uint8_t _channel_to_port_group[MAX_TIMER_IO_CHANNELS];
+static uint8_t _channel_to_pin[MAX_TIMER_IO_CHANNELS];
+```
+
+## DMA Resource Usage Comparison
+
+### Current (DMA burst + capture)
+- **Output**: 1 DMA stream per timer = N_timers streams
+- **Capture**: 1 DMA stream per captured channel (round-robin, 1 at a time per timer)
+- DMA streams are freed/reallocated between burst and capture phases
+
+### Bitbang
+- **Output**: 1 DMA stream per port group = N_ports streams
+- **Capture**: 1 DMA stream per port group (same streams, reconfigured)
+- DMA streams freed/reallocated between phases (same pattern as current)
+
+DMA resource usage is equivalent (typically N_timers == N_ports or close). The DMAMUX routing uses the same timer update event mappings.
+
+## Memory Usage
+
+### Current
+- Output: ~272 bytes per timer (4 channels * 17 words * 4 bytes, cache-aligned)
+- Capture: ~256 bytes per timer (4 channels * 32 samples * 2 bytes)
+
+### Bitbang
+- Output: ~1284 bytes per port group (321 words * 4 bytes, cache-aligned)
+- Capture: ~1024 bytes per port group (512 samples * 2 bytes, cache-aligned)
+- Scales with number of port groups, not number of motors
+- Higher per-group cost, but acceptable for H7 (1MB+ SRAM)
+
+## Open Questions / Risks
+
+1. **GPIO output speed**: BSRR writes through AHB4 bus on H7. At 83.3ns per DMA transfer (12MHz), is there enough bus bandwidth? Should be fine - AHB4 runs at 240MHz, and BSRR writes are single-cycle.
+
+2. **DMA priority vs other peripherals**: SPI1 (IMU) is on DMA1. Timer DMA is already high priority. No change expected.
+
+3. **GPIO input threshold**: When reading IDR for bidir, the input threshold depends on GPIO input configuration (Schmitt trigger, pull-up/down). The current capture approach uses timer input capture which has different input characteristics. May need to configure GPIO pull-up to match idle-high behavior.
+
+4. **Signal integrity**: Timer PWM output has precise edge timing locked to the timer clock. BSRR writes via DMA may have slight jitter due to bus arbitration. This is likely negligible (< 10ns on H7) but should be verified.
+
+5. **OTYPER configuration**: For bidirectional DShot, the pin needs to be open-drain (or at least not actively driven when in input mode). The MODER switch to input (00) handles this, but verify that switching MODER during/after a frame doesn't cause glitches.
+
+6. **Cache coherency**: BSRR output buffers need dcache clean before DMA. IDR capture buffers need dcache invalidate after DMA. Same pattern as current code.
+
+## Implementation Order
+
+1. **Port group initialization**: Parse `timer_io_channels[]` to build `port_group_t` structures grouped by GPIO port instead of timer
+2. **Output-only DShot**: Implement BSRR buffer building and DMA output. Verify with logic analyzer that DShot frames are correct
+3. **Bidirectional capture**: Implement IDR sampling and per-pin edge extraction. Verify GCR decode produces valid eRPM
+4. **Integration**: Wire up to the existing `up_dshot_*` API so `DShot.cpp` works unchanged
+5. **Testing**: Compare eRPM data quality (CRC error rate, update rate) vs current implementation
+
+## Reference: Betaflight Bitbang Implementation
+
+- [Betaflight dshot_bitbang.c](https://github.com/betaflight/betaflight/blob/master/src/platform/STM32/dshot_bitbang.c)
+- [Betaflight dshot_bitbang_impl.h](https://github.com/betaflight/betaflight/blob/master/src/main/drivers/dshot_bitbang_impl.h)
+- [Original GPIO banging PR #7446](https://github.com/betaflight/betaflight/pull/7446)
+- [Bidirectional bitbang PR #8779](https://github.com/betaflight/betaflight/pull/8779)
+
+## Reference: Current PX4 Implementation Files
+
+- DShot platform layer: `platforms/nuttx/src/px4/stm/stm32_common/dshot/dshot.c`
+- IO timer layer: `platforms/nuttx/src/px4/stm/stm32_common/io_pins/io_timer.c`
+- IO timer struct defs: `platforms/nuttx/src/px4/stm/stm32_common/include/px4_arch/io_timer.h`
+- GPIO/pin helpers: `platforms/nuttx/src/px4/stm/stm32_common/include/px4_arch/hw_description.h`
+- H7 timer/DMA descriptions: `platforms/nuttx/src/px4/stm/stm32h7/include/px4_arch/io_timer_hw_description.h`
+- H7 GPIO register defs: NuttX `arch/arm/src/stm32h7/stm32_gpio.h` (GPIO_PORT_MASK, GPIO_PIN_MASK, g_gpiobase[])
+- H7 GPIO HW registers: NuttX `arch/arm/src/stm32h7/hardware/stm32h7x3xx_gpio.h` (STM32_GPIO_MODER_OFFSET, etc.)
+- DShot API header: `src/drivers/drv_dshot.h`
+- DShot driver module: `src/drivers/dshot/DShot.cpp`
+
+## Reference: Test Target (ARK FPV)
+
+- Timer config: `boards/ark/fpv/src/timer_config.cpp`
+- DMA map: `boards/ark/fpv/nuttx-config/include/board_dma_map.h`
+- Board config: `boards/ark/fpv/src/board_config.h`

CMakeLists.txt

@@ -267,7 +267,7 @@ endif()
 
 set(package-contact "px4users@googlegroups.com")
 
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)

CTestConfig.cmake

@@ -1,15 +0,0 @@
-## This file should be placed in the root directory of your project.
-## Then modify the CMakeLists.txt file in the root directory of your
-## project to incorporate the testing dashboard.
-##
-## # The following are required to submit to the CDash dashboard:
-##   ENABLE_TESTING()
-##   INCLUDE(CTest)
-
-set(CTEST_PROJECT_NAME "PX4 Firmware")
-set(CTEST_NIGHTLY_START_TIME "00:00:00 EST")
-
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "my.cdash.org")
-set(CTEST_DROP_LOCATION "/submit.php?project=PX4+Firmware")
-set(CTEST_DROP_SITE_CDASH TRUE)

Jenkinsfile

@@ -101,6 +101,7 @@ pipeline {
             echo $0;
             git clone https://github.com/emscripten-core/emsdk.git _emscripten_sdk;
             cd _emscripten_sdk;
+            git checkout 4.0.15;
             ./emsdk install latest;
             ./emsdk activate latest;
             cd ..;
@@ -220,36 +221,6 @@ pipeline {
           }
         }
 
-        stage('PX4 ROS msgs') {
-          agent {
-            docker { image 'px4io/px4-dev-base-focal:2021-08-18' }
-          }
-          steps {
-            sh('export')
-            sh('make distclean; git clean -ff -x -d .')
-            withCredentials([usernamePassword(credentialsId: 'px4buildbot_github_personal_token', passwordVariable: 'GIT_PASS', usernameVariable: 'GIT_USER')]) {
-              sh("git clone https://${GIT_USER}:${GIT_PASS}@github.com/PX4/px4_msgs.git")
-              // 'main' branch
-              sh('rm -f px4_msgs/msg/*.msg')
-              sh('rm -f px4_msgs/msg/versioned/*.msg')
-              sh('rm -f px4_msgs/srv/*.srv')
-              sh('rm -f px4_msgs/srv/versioned/*.srv')
-              sh('cp msg/*.msg px4_msgs/msg/')
-              sh('cp msg/versioned/*.msg px4_msgs/msg/ || true')
-              sh('cp srv/*.srv px4_msgs/srv/')
-              sh('cp srv/versioned/*.srv px4_msgs/srv/ || true')
-              sh('cd px4_msgs; git status; git add .; git commit -a -m "Update message definitions `date`" || true')
-              sh('cd px4_msgs; git push origin main || true')
-              sh('rm -rf px4_msgs')
-            }
-          }
-          when {
-            anyOf {
-              branch 'main'
-            }
-          }
-        }
-
         stage('S3') {
           agent {
             docker { image 'px4io/px4-dev-base-focal:2021-08-18' }

ROMFS/px4fmu_common/init.d-posix/airframes/4004_gz_standard_vtol

@@ -101,6 +101,6 @@ param set-default NAV_ACC_RAD 5
 param set-default NAV_DLL_ACT 2
 
 param set-default VT_FWD_THRUST_EN 4
-param set-default VT_F_TRANS_THR 0.3
+param set-default VT_F_TRANS_THR 1
 param set-default VT_TYPE 2
 param set-default FD_ESCS_EN 0

ROMFS/px4fmu_common/init.d-posix/airframes/4008_gz_advanced_plane

@@ -11,8 +11,6 @@ PX4_SIM_MODEL=${PX4_SIM_MODEL:=advanced_plane}
 
 param set-default SIM_GZ_EN 1
 
-param set-default SENS_EN_ARSPDSIM 1
-
 param set-default FW_LND_ANG 8
 
 param set-default FW_PR_FF 0.08

ROMFS/px4fmu_common/init.d-posix/airframes/4019_gz_x500_gimbal

@@ -19,5 +19,6 @@ param set-default MNT_MAN_PITCH 2
 param set-default MNT_MAN_YAW 3
 
 param set-default MNT_RANGE_ROLL 180
-param set-default MNT_RANGE_PITCH 180
+param set-default MNT_MAX_PITCH 45
+param set-default MNT_MIN_PITCH -135
 param set-default MNT_RANGE_YAW 720

ROMFS/px4fmu_common/init.d-posix/airframes/70001_gz_atmos_dual

@@ -0,0 +1,167 @@
+#!/bin/sh
+#
+# @name KTH-ATMOS
+#
+# @type Free-Flyer
+# @class Spacecraft
+#
+# @output Motor1 back left thruster, +x thrust
+# @output Motor2 front left thruster, -x thrust
+# @output Motor3 back right thruster, +x thrust
+# @output Motor4 front right thruster, -x thrust
+# @output Motor5 front left thruster, +y thrust
+# @output Motor6 front right thruster, -y thrust
+# @output Motor7 back left thruster, +y thrust
+# @output Motor8 back right thruster, -y thrust
+#
+# @maintainer discower-io
+# @url https://atmos.discower.io
+#
+
+. ${R}etc/init.d/rc.sc_defaults
+
+PX4_SIMULATOR=${PX4_SIMULATOR:=gz}
+PX4_GZ_WORLD=${PX4_GZ_WORLD:=default}
+PX4_SIM_MODEL=${PX4_SIM_MODEL:=atmos_dual}
+
+param set-default SIM_GZ_EN 1
+
+param set-default SENS_EN_MAGSIM 1
+param set-default COM_ARM_CHK_ESCS 0  # We don't have ESCs
+param set-default FD_ESCS_EN 0
+
+param set-default CA_AIRFRAME 14
+param set-default MAV_TYPE 45
+
+param set-default CA_ROTOR_COUNT 8
+param set-default CA_R_REV 0
+
+# Auto to be provided by Custom Airframe
+param set-default CA_METHOD 0
+
+# Set proper failsafes
+param set-default COM_ACT_FAIL_ACT 0
+param set-default COM_LOW_BAT_ACT 0
+param set-default NAV_DLL_ACT 0
+param set-default GF_ACTION 1
+param set-default NAV_RCL_ACT 1
+
+# disable attitude failure detection
+param set-default FD_FAIL_P 0
+param set-default FD_FAIL_R 0
+
+param set-default CA_ROTOR0_PX -0.12
+param set-default CA_ROTOR0_PY -0.12
+param set-default CA_ROTOR0_PZ 0.0
+param set-default CA_ROTOR0_CT 1.4
+param set-default CA_ROTOR0_AX 1.0
+param set-default CA_ROTOR0_AY 0.0
+param set-default CA_ROTOR0_AZ 0.0
+
+param set-default CA_ROTOR1_PX 0.12
+param set-default CA_ROTOR1_PY -0.12
+param set-default CA_ROTOR1_PZ 0.0
+param set-default CA_ROTOR1_CT 1.4
+param set-default CA_ROTOR1_AX -1.0
+param set-default CA_ROTOR1_AY 0.0
+param set-default CA_ROTOR1_AZ 0.0
+
+param set-default CA_ROTOR2_PX -0.12
+param set-default CA_ROTOR2_PY 0.12
+param set-default CA_ROTOR2_PZ 0.0
+param set-default CA_ROTOR2_CT 1.4
+param set-default CA_ROTOR2_AX 1.0
+param set-default CA_ROTOR2_AY 0.0
+param set-default CA_ROTOR2_AZ 0.0
+
+param set-default CA_ROTOR3_PX 0.12
+param set-default CA_ROTOR3_PY 0.12
+param set-default CA_ROTOR3_PZ 0.0
+param set-default CA_ROTOR3_CT 1.4
+param set-default CA_ROTOR3_AX -1.0
+param set-default CA_ROTOR3_AY 0.0
+param set-default CA_ROTOR3_AZ 0.0
+
+param set-default CA_ROTOR4_PX 0.12
+param set-default CA_ROTOR4_PY -0.12
+param set-default CA_ROTOR4_PZ 0.0
+param set-default CA_ROTOR4_CT 1.4
+param set-default CA_ROTOR4_AX 0.0
+param set-default CA_ROTOR4_AY 1.0
+param set-default CA_ROTOR4_AZ 0.0
+
+param set-default CA_ROTOR5_PX 0.12
+param set-default CA_ROTOR5_PY 0.12
+param set-default CA_ROTOR5_PZ 0.0
+param set-default CA_ROTOR5_CT 1.4
+param set-default CA_ROTOR5_AX 0.0
+param set-default CA_ROTOR5_AY -1.0
+param set-default CA_ROTOR5_AZ 0.0
+
+param set-default CA_ROTOR6_PX -0.12
+param set-default CA_ROTOR6_PY -0.12
+param set-default CA_ROTOR6_PZ 0.0
+param set-default CA_ROTOR6_CT 1.4
+param set-default CA_ROTOR6_AX 0.0
+param set-default CA_ROTOR6_AY 1.0
+param set-default CA_ROTOR6_AZ 0.0
+
+param set-default CA_ROTOR7_PX -0.12
+param set-default CA_ROTOR7_PY 0.12
+param set-default CA_ROTOR7_PZ 0.0
+param set-default CA_ROTOR7_CT 1.4
+param set-default CA_ROTOR7_AX 0.0
+param set-default CA_ROTOR7_AY -1.0
+param set-default CA_ROTOR7_AZ 0.0
+
+param set-default SIM_GZ_EC_FUNC1 101
+param set-default SIM_GZ_EC_FUNC2 102
+param set-default SIM_GZ_EC_FUNC3 103
+param set-default SIM_GZ_EC_FUNC4 104
+param set-default SIM_GZ_EC_FUNC5 105
+param set-default SIM_GZ_EC_FUNC6 106
+param set-default SIM_GZ_EC_FUNC7 107
+param set-default SIM_GZ_EC_FUNC8 108
+param set-default SIM_GZ_EC_FUNC9 301
+param set-default SIM_GZ_EC_FUNC10 302
+param set-default SIM_GZ_EC_FUNC11 303
+param set-default SIM_GZ_EC_FUNC12 304
+
+param set-default SIM_GZ_EC_MIN1 0
+param set-default SIM_GZ_EC_MIN2 0
+param set-default SIM_GZ_EC_MIN3 0
+param set-default SIM_GZ_EC_MIN4 0
+param set-default SIM_GZ_EC_MIN5 0
+param set-default SIM_GZ_EC_MIN6 0
+param set-default SIM_GZ_EC_MIN7 0
+param set-default SIM_GZ_EC_MIN8 0
+param set-default SIM_GZ_EC_MIN9 1100
+param set-default SIM_GZ_EC_MIN10 1100
+param set-default SIM_GZ_EC_MIN11 1100
+param set-default SIM_GZ_EC_MIN12 1100
+
+param set-default SIM_GZ_EC_MAX1 10000
+param set-default SIM_GZ_EC_MAX2 10000
+param set-default SIM_GZ_EC_MAX3 10000
+param set-default SIM_GZ_EC_MAX4 10000
+param set-default SIM_GZ_EC_MAX5 10000
+param set-default SIM_GZ_EC_MAX6 10000
+param set-default SIM_GZ_EC_MAX7 10000
+param set-default SIM_GZ_EC_MAX8 10000
+param set-default SIM_GZ_EC_MAX9 1900
+param set-default SIM_GZ_EC_MAX10 1900
+param set-default SIM_GZ_EC_MAX11 1900
+param set-default SIM_GZ_EC_MAX12 1900
+
+# Controller Tunings
+param set SC_YAWRATE_P 3.335
+param set SC_YAWRATE_I 0.87
+param set SC_YAWRATE_D 0.15
+param set SC_YR_INT_LIM 0.2
+param set SC_YAW_P 3.0
+
+param set SPC_POS_P 0.20
+param set SPC_VEL_P 6.55
+param set SPC_VEL_I 0.0
+param set SPC_VEL_D 0.0
+param set SPC_VEL_MAX 12.0

ROMFS/px4fmu_common/init.d-posix/airframes/CMakeLists.txt

@@ -118,6 +118,7 @@ px4_add_romfs_files(
 	60002_gz_uuv_bluerov2_heavy
 
 	70000_gz_atmos
+	70001_gz_atmos_dual
 
 	# [22000, 22999] Reserve for custom models
 )

ROMFS/px4fmu_common/init.d-posix/px4-rc.gzsim

@@ -159,24 +159,19 @@ if [ -n "${PX4_SIM_MODEL#*gz_}" ] && [ -z "${PX4_GZ_MODEL_NAME}" ]; then
 	fi
 
 	# Set up camera to follow the model if requested
-	if [ -n "${PX4_GZ_FOLLOW}" ]; then
+	if [ -z "${PX4_GZ_NO_FOLLOW}" ]; then
 
 		echo "INFO  [init] Setting camera to follow ${MODEL_NAME_INSTANCE}"
 
-		# Set camera to follow the model
-		${gz_command} service -s "/gui/follow" --reqtype gz.msgs.StringMsg \
-				--reptype gz.msgs.Boolean --timeout 5000 \
-				--req "data: \"${MODEL_NAME_INSTANCE}\"" > /dev/null 2>&1
-
 		# Set default camera offset if not specified
 		follow_x=${PX4_GZ_FOLLOW_OFFSET_X:--2.0}
 		follow_y=${PX4_GZ_FOLLOW_OFFSET_Y:--2.0}
 		follow_z=${PX4_GZ_FOLLOW_OFFSET_Z:-2.0}
 
 		# Set camera offset
-		${gz_command} service -s "/gui/follow/offset" --reqtype gz.msgs.Vector3d \
-				--reptype gz.msgs.Boolean --timeout 5000 \
-				--req "x: ${follow_x}, y: ${follow_y}, z: ${follow_z}" > /dev/null 2>&1
+		${gz_command} topic -t /gui/track -m gz.msgs.CameraTrack \
+				-p "track_mode: FOLLOW, follow_target: {name: '${MODEL_NAME_INSTANCE}'},\
+				 follow_offset: {x: ${follow_x}, y: ${follow_y}, z: ${follow_z}}, follow_pgain: 1.0, track_pgain: 1.0"
 
 		echo "INFO  [init] Camera follow offset set to ${follow_x}, ${follow_y}, ${follow_z}"
 	fi

ROMFS/px4fmu_common/init.d-posix/rcS

@@ -126,15 +126,6 @@ then
 	set AUTOCNF yes
 fi
 
-# Allow overriding parameters via env variables: export PX4_PARAM_{name}={value}
-env | while IFS='=' read -r line; do
-  value=${line#*=}
-  name=${line%%=*}
-  case $name in
-    "PX4_PARAM_"*) param set "${name#PX4_PARAM_}" "$value" ;;
-  esac
-done
-
 # multi-instance setup
 # shellcheck disable=SC2154
 param set MAV_SYS_ID $((px4_instance+1))
@@ -238,6 +229,15 @@ then
 	exit 1
 fi
 
+# Allow overriding parameters via env variables: export PX4_PARAM_{name}={value}
+env | while IFS='=' read -r line; do
+  value=${line#*=}
+  name=${line%%=*}
+  case $name in
+    "PX4_PARAM_"*) param set "${name#PX4_PARAM_}" "$value" ;;
+  esac
+done
+
 dataman start
 
 # only start the simulator if not in replay mode, as both control the lockstep time

ROMFS/px4fmu_common/init.d/CMakeLists.txt

@@ -123,3 +123,9 @@ if(CONFIG_MODULES_TEMPERATURE_COMPENSATION)
 		rc.thermal_cal
 	)
 endif()
+
+if(CONFIG_DRIVERS_VTXTABLE)
+	px4_add_romfs_files(
+		rc.vtxtable
+	)
+endif()

ROMFS/px4fmu_common/init.d/airframes/17002_TF-AutoG2

@@ -18,6 +18,8 @@
 #
 # @board px4_fmu-v2 exclude
 # @board bitcraze_crazyflie exclude
+# @board px4_fmu-v6x exclude
+# @board ark_fmu-v6x exclude
 #
 
 . ${R}etc/init.d/rc.fw_defaults

ROMFS/px4fmu_common/init.d/airframes/17003_TF-G2

@@ -16,6 +16,8 @@
 #
 # @board px4_fmu-v2 exclude
 # @board bitcraze_crazyflie exclude
+# @board px4_fmu-v6x exclude
+# @board ark_fmu-v6x exclude
 #
 
 . ${R}etc/init.d/rc.fw_defaults

ROMFS/px4fmu_common/init.d/airframes/4016_holybro_px4vision

@@ -7,6 +7,8 @@
 #
 # @board px4_fmu-v2 exclude
 # @board bitcraze_crazyflie exclude
+# @board px4_fmu-v6x exclude
+# @board ark_fmu-v6x exclude
 #
 
 . ${R}etc/init.d/rc.mc_defaults
@@ -75,9 +77,6 @@ param set-default NAV_ACC_RAD 2
 param set-default RTL_DESCEND_ALT 5
 param set-default RTL_RETURN_ALT 5
 
-# Logging Parameters
-param set-default SDLOG_PROFILE 131
-
 # Sensors Parameters
 param set-default SENS_CM8JL65_CFG 104
 param set-default SENS_FLOW_MAXHGT 25

ROMFS/px4fmu_common/init.d/airframes/4020_holybro_px4vision_v1_5

@@ -78,9 +78,6 @@ param set-default NAV_ACC_RAD 2
 param set-default RTL_DESCEND_ALT 5
 param set-default RTL_RETURN_ALT 5
 
-# Logging Parameters
-param set-default SDLOG_PROFILE 131
-
 # Sensors Parameters
 param set-default SENS_CM8JL65_CFG 202
 param set-default SENS_FLOW_MAXHGT 25

ROMFS/px4fmu_common/init.d/airframes/4050_generic_250

@@ -29,9 +29,6 @@ param set-default MPC_MAN_TILT_MAX 60
 
 param set-default THR_MDL_FAC 0.3
 
-# enable high-rate logging profile (helps with tuning)
-param set-default SDLOG_PROFILE 19
-
 param set-default IMU_DGYRO_CUTOFF 50
 param set-default IMU_GYRO_CUTOFF 90
 

ROMFS/px4fmu_common/init.d/airframes/4052_holybro_qav250

@@ -11,6 +11,8 @@
 #
 # @board px4_fmu-v2 exclude
 # @board bitcraze_crazyflie exclude
+# @board px4_fmu-v6x exclude
+# @board ark_fmu-v6x exclude
 #
 
 . ${R}etc/init.d/rc.mc_defaults

ROMFS/px4fmu_common/init.d/airframes/4053_holybro_kopis2

@@ -9,6 +9,8 @@
 #
 # @board px4_fmu-v2 exclude
 # @board bitcraze_crazyflie exclude
+# @board px4_fmu-v6x exclude
+# @board ark_fmu-v6x exclude
 #
 
 . ${R}etc/init.d/rc.mc_defaults

ROMFS/px4fmu_common/init.d/airframes/6002_draco_r

@@ -12,7 +12,9 @@
 # @board px4_fmu-v4pro exclude
 # @board px4_fmu-v5 exclude
 # @board px4_fmu-v5x exclude
+# @board px4_fmu-v6x exclude
 # @board bitcraze_crazyflie exclude
+# @board ark_fmu-v6x exclude
 #
 
 . ${R}etc/init.d/rc.mc_defaults

ROMFS/px4fmu_common/init.d/airframes/70000_atmos

@@ -20,6 +20,9 @@
 
 . ${R}etc/init.d/rc.sc_defaults
 
+# Overwrite DDS AG IP to `192.168.0.1`
+param set-default UXRCE_DDS_AG_IP -1062731775
+
 param set-default CA_AIRFRAME 14
 param set-default MAV_TYPE 45
 

ROMFS/px4fmu_common/init.d/rc.mc_apps

@@ -41,3 +41,9 @@ if param compare -s MC_NN_EN 1
 then
 	mc_nn_control start
 fi
+
+
+if param compare -s MC_RAPTOR_ENABLE 1
+then
+	mc_raptor start
+fi

ROMFS/px4fmu_common/init.d/rc.sc_defaults

@@ -8,9 +8,6 @@ set VEHICLE_TYPE spacecraft
 # MAV_TYPE_SPACECRAFT_ORBITTER
 param set-default MAV_TYPE 45
 
-# Set micro-dds-client to use ethernet and IP-address 192.168.0.1
-param set-default UXRCE_DDS_AG_IP -1062731775
-
 # Disable preflight disarm to not interfere with external launching
 param set-default COM_DISARM_PRFLT -1
 param set-default CBRK_SUPPLY_CHK 894281

ROMFS/px4fmu_common/init.d/rc.sensors

@@ -231,6 +231,18 @@ then
 	ads7953 start -S
 fi
 
+# ADC sensor tla2528 external I2C
+if param compare -s ADC_TLA2528_EN 1
+then
+	tla2528 start -X
+fi
+
+# Start TMP102 temperature sensor
+if param compare SENS_EN_TMP102 1
+then
+	tmp102 start -X
+fi
+
 # probe for optional external I2C devices
 if param compare SENS_EXT_I2C_PRB 1
 then

ROMFS/px4fmu_common/init.d/rc.vtxtable

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# VTX table loading script.
+#
+# NOTE: Script variables are declared/initialized/unset in the rcS script.
+#
+
+vtxtable load

ROMFS/px4fmu_common/init.d/rcS

@@ -479,6 +479,19 @@ else
 		pwm_out start
 	fi
 
+	#
+	# Optional UAVCAN/DroneCAN or Cyphal
+	#
+	if param greater -s UAVCAN_ENABLE 0
+	then
+		uavcan start
+	else
+		if param greater -s CYPHAL_ENABLE 0
+		then
+			cyphal start
+		fi
+	fi
+
 	#
 	# Configure vehicle type specific parameters.
 	# Note: rc.vehicle_setup is the entry point for all vehicle type specific setup.
@@ -507,6 +520,11 @@ else
 	#
 	. ${R}etc/init.d/rc.serial
 
+	if param greater -s ZENOH_ENABLE 0
+	then
+		zenoh start
+	fi
+
 	# Must be started after the serial config is read
 	rc_input start $RC_INPUT_ARGS
 
@@ -612,6 +630,16 @@ else
 	fi
 	unset RC_LOGGING
 
+	#
+	# Start the VTX services.
+	#
+	set RC_VTXTABLE ${R}etc/init.d/rc.vtxtable
+	if [ -f ${RC_VTXTABLE} ]
+	then
+		. ${RC_VTXTABLE}
+	fi
+	unset RC_VTXTABLE
+
 	#
 	# Set additional parameters and env variables for selected AUTOSTART.
 	#
@@ -628,27 +656,6 @@ else
 	fi
 	unset BOARD_BOOTLOADER_UPGRADE
 
-	#
-	# Check if UAVCAN is enabled, default to it for ESCs.
-	#
-	if param greater -s UAVCAN_ENABLE 0
-	then
-		# Start core UAVCAN module.
-		if ! uavcan start
-		then
-			tune_control play error
-		fi
-	else
-		if param greater -s CYPHAL_ENABLE 0
-		then
-			cyphal start
-		fi
-	fi
-	if param greater -s ZENOH_ENABLE 0
-	then
-		zenoh start
-	fi
-
 #
 # End of autostart.
 #

Tools/astyle/files_to_check_code_style.sh

@@ -21,11 +21,13 @@ exec find boards msg src platforms test \
     -path src/lib/crypto/monocypher -prune -o \
     -path src/lib/events/libevents -prune -o \
     -path src/lib/parameters/uthash -prune -o \
+    -path src/lib/rl_tools/rl_tools -prune -o \
     -path src/lib/wind_estimator/python/generated -prune -o \
     -path src/modules/ekf2/EKF/python/ekf_derivation/generated -prune -o \
     -path src/modules/ekf2/EKF/yaw_estimator/derivation/generated -prune -o \
     -path src/modules/gyro_fft/CMSIS_5 -prune -o \
     -path src/modules/mavlink/mavlink -prune -o \
+    -path src/modules/mc_raptor/blob -prune -o \
     -path test/fuzztest -prune -o \
     -path test/mavsdk_tests/catch2 -prune -o \
     -path src/lib/crypto/monocypher -prune -o \

Tools/bdshot_analyzer.py

@@ -0,0 +1,433 @@
+#!/usr/bin/env python3
+"""
+BDShot Timing Jitter Analyzer
+
+Analyzes BDShot (Bidirectional DShot) signal timing from Saleae Logic Analyzer
+CSV exports. Measures scheduling consistency and jitter in PX4 flight controller
+DShot output timing.
+
+Usage:
+    python bdshot_analyzer.py capture.csv
+    python bdshot_analyzer.py capture.csv --dshot-rate 300 --loop-rate 800
+    python bdshot_analyzer.py capture.csv --channel-a 0 --channel-b 1
+
+Arguments:
+    input_file          Path to Saleae CSV export
+    --dshot-rate        DShot variant: 150/300/600/1200 (default: 300)
+    --loop-rate         Expected loop rate in Hz (default: 800)
+    --channel-a         CSV column index for first channel (default: 0)
+    --channel-b         CSV column index for second channel (default: 1)
+    --no-plots          Disable histogram display
+    --verbose           Enable verbose debugging output
+
+Capture Setup:
+    1. Connect Saleae to two BDShot signals from different timers
+       (e.g., Motor 1 from Timer1, Motor 5 from Timer2)
+    2. Sample rate: 24+ MS/s for DShot300
+    3. Export as CSV: File -> Export Raw Data -> CSV
+
+Interpreting Results:
+    - Frame Intervals: Should cluster tightly around expected loop period
+    - Inter-Channel Gap: Measures sequential DMA scheduling overhead
+    - Jitter: Small std dev is typical for well-behaved systems
+
+Dependencies: numpy, matplotlib
+"""
+
+import argparse
+import csv
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+# Try to import matplotlib, but allow running without it
+try:
+    import matplotlib.pyplot as plt
+    HAS_MATPLOTLIB = True
+except ImportError:
+    HAS_MATPLOTLIB = False
+
+
+# DShot bit periods in microseconds
+DSHOT_BIT_PERIODS = {
+    150: 6.67,
+    300: 3.33,
+    600: 1.67,
+    1200: 0.83,
+}
+
+
+@dataclass
+class BDShotTransaction:
+    """Represents a single BDShot transaction (command + response)."""
+    start: float   # Timestamp of first falling edge (seconds)
+    end: float     # Timestamp of final rising edge before idle (seconds)
+
+    @property
+    def duration_us(self) -> float:
+        """Transaction duration in microseconds."""
+        return (self.end - self.start) * 1_000_000
+
+
+@dataclass
+class ChannelStats:
+    """Statistics for a single channel's frame intervals."""
+    channel_name: str
+    count: int
+    min_us: float
+    max_us: float
+    mean_us: float
+    std_us: float
+    expected_us: float
+
+    @property
+    def min_jitter_us(self) -> float:
+        return self.min_us - self.expected_us
+
+    @property
+    def max_jitter_us(self) -> float:
+        return self.max_us - self.expected_us
+
+    @property
+    def mean_jitter_us(self) -> float:
+        return self.mean_us - self.expected_us
+
+
+@dataclass
+class GapStats:
+    """Statistics for inter-channel gaps."""
+    count: int
+    min_us: float
+    max_us: float
+    mean_us: float
+    std_us: float
+
+
+def parse_csv(filepath: Path, channel_a_idx: int, channel_b_idx: int, verbose: bool = False):
+    """
+    Parse Saleae CSV export and extract edges for each channel.
+
+    Returns:
+        Tuple of (edges_a, edges_b) where each is a list of (timestamp, new_state) tuples.
+    """
+    edges_a, edges_b = [], []
+    prev_a, prev_b = None, None
+    ch_a_col, ch_b_col = channel_a_idx + 1, channel_b_idx + 1  # +1 for time column
+
+    with open(filepath, 'r', newline='') as f:
+        reader = csv.reader(f)
+        header = next(reader)
+
+        if verbose:
+            print(f"CSV Header: {header}")
+            print(f"Using columns: time=0, ch_a={ch_a_col} ({header[ch_a_col]}), "
+                  f"ch_b={ch_b_col} ({header[ch_b_col]})")
+
+        if ch_a_col >= len(header) or ch_b_col >= len(header):
+            raise ValueError(
+                f"Channel indices out of range. CSV has {len(header)-1} channels. "
+                f"Requested channel_a={channel_a_idx}, channel_b={channel_b_idx}"
+            )
+
+        for row_num, row in enumerate(reader, start=2):
+            try:
+                timestamp = float(row[0])
+                state_a, state_b = int(row[ch_a_col]), int(row[ch_b_col])
+
+                # Record edges (state changes) or initial LOW state
+                if (prev_a is not None and state_a != prev_a) or (prev_a is None and state_a == 0):
+                    edges_a.append((timestamp, state_a))
+                if (prev_b is not None and state_b != prev_b) or (prev_b is None and state_b == 0):
+                    edges_b.append((timestamp, state_b))
+
+                prev_a, prev_b = state_a, state_b
+
+            except (ValueError, IndexError) as e:
+                if verbose:
+                    print(f"Warning: Skipping malformed row {row_num}: {e}")
+
+    if verbose:
+        print(f"Parsed {len(edges_a)} edges for channel A, {len(edges_b)} edges for channel B")
+
+    return edges_a, edges_b
+
+
+def detect_transactions(edges, idle_threshold_us: float, verbose: bool = False):
+    """
+    Detect BDShot transactions from edge list.
+
+    A transaction starts with a falling edge after an idle period and ends
+    when the line returns HIGH and stays HIGH for > idle_threshold_us.
+    """
+    if not edges:
+        return []
+
+    idle_threshold_s = idle_threshold_us / 1_000_000
+    transactions = []
+    tx_start = None
+    last_rising = None
+
+    for i, (timestamp, state) in enumerate(edges):
+        if state == 0:  # Falling edge - start transaction if idle
+            if tx_start is None and (last_rising is None or timestamp - last_rising > idle_threshold_s):
+                tx_start = timestamp
+        elif tx_start is not None:  # Rising edge with active transaction
+            last_rising = timestamp
+            # Complete transaction if next edge is far away or this is the last edge
+            next_gap = edges[i + 1][0] - timestamp if i + 1 < len(edges) else float('inf')
+            if next_gap > idle_threshold_s:
+                transactions.append(BDShotTransaction(start=tx_start, end=timestamp))
+                tx_start = None
+        else:
+            last_rising = timestamp
+
+    if verbose:
+        print(f"Detected {len(transactions)} transactions")
+        if transactions:
+            durations = [tx.duration_us for tx in transactions]
+            print(f"  Duration range: {min(durations):.1f} - {max(durations):.1f} us")
+
+    return transactions
+
+
+def compute_channel_stats(transactions, channel_name: str, expected_interval_us: float):
+    """Compute frame interval statistics for a channel."""
+    if len(transactions) < 2:
+        raise ValueError(f"Need at least 2 transactions to compute intervals, got {len(transactions)}")
+
+    intervals_us = np.diff([tx.start for tx in transactions]) * 1_000_000
+
+    stats = ChannelStats(
+        channel_name=channel_name,
+        count=len(intervals_us),
+        min_us=float(np.min(intervals_us)),
+        max_us=float(np.max(intervals_us)),
+        mean_us=float(np.mean(intervals_us)),
+        std_us=float(np.std(intervals_us)),
+        expected_us=expected_interval_us,
+    )
+
+    return stats, intervals_us
+
+
+def compute_inter_channel_gaps(transactions_a, transactions_b, expected_interval_us: float,
+                               verbose: bool = False):
+    """Compute inter-channel gap statistics (CH_A end -> CH_B start)."""
+    gaps = []
+    max_reasonable_gap_us = expected_interval_us * 0.5
+    b_idx = 0
+
+    for tx_a in transactions_a:
+        # Find first CH_B transaction that starts after this CH_A ends
+        while b_idx < len(transactions_b) and transactions_b[b_idx].start <= tx_a.end:
+            b_idx += 1
+        if b_idx >= len(transactions_b):
+            break
+
+        gap_us = (transactions_b[b_idx].start - tx_a.end) * 1_000_000
+        if 0 < gap_us < max_reasonable_gap_us:
+            gaps.append(gap_us)
+
+    if verbose:
+        print(f"Inter-channel gap matching: {len(gaps)} matched")
+
+    if not gaps:
+        raise ValueError("No valid inter-channel gaps found")
+
+    gaps_arr = np.array(gaps)
+    stats = GapStats(
+        count=len(gaps_arr),
+        min_us=float(np.min(gaps_arr)),
+        max_us=float(np.max(gaps_arr)),
+        mean_us=float(np.mean(gaps_arr)),
+        std_us=float(np.std(gaps_arr)),
+    )
+
+    return stats, gaps_arr
+
+
+def _plot_histogram(ax, data, title: str, xlabel: str, expected_value=None, stats_text=None):
+    """Plot a histogram on the given axes."""
+    bin_count = min(100, max(20, len(data) // 100)) if np.ptp(data) > 0 else 20
+    ax.hist(data, bins=bin_count, edgecolor='black', alpha=0.7)
+    ax.set_title(title, fontsize=12, fontweight='bold')
+    ax.set_xlabel(xlabel, fontsize=10)
+    ax.set_ylabel('Count', fontsize=10)
+
+    if expected_value is not None:
+        ax.axvline(expected_value, color='red', linestyle='--', linewidth=2,
+                   label=f'Expected: {expected_value:.2f} us')
+    ax.axvline(np.mean(data), color='green', linestyle='-', linewidth=2,
+               label=f'Mean: {np.mean(data):.2f} us')
+
+    if stats_text:
+        ax.text(0.98, 0.97, stats_text, transform=ax.transAxes, fontsize=9,
+                verticalalignment='top', horizontalalignment='right',
+                bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8), family='monospace')
+
+    ax.legend(loc='upper left', fontsize=8)
+    ax.grid(True, alpha=0.3)
+
+
+def generate_combined_histogram(intervals_a, intervals_b, gaps, stats_a, stats_b,
+                                gap_stats, expected_interval_us: float, dshot_rate: int):
+    """Generate a combined figure with all histograms."""
+    if not HAS_MATPLOTLIB:
+        return None
+
+    fig = plt.figure(figsize=(14, 10))
+    gs = fig.add_gridspec(2, 2, height_ratios=[1, 1], hspace=0.3, wspace=0.25)
+    ax_a, ax_b, ax_gap = fig.add_subplot(gs[0, 0]), fig.add_subplot(gs[0, 1]), fig.add_subplot(gs[1, :])
+
+    def stats_text(s):
+        return format_stats_text(s.min_us, s.max_us, s.mean_us, s.std_us, s.count)
+
+    _plot_histogram(ax_a, intervals_a, "Channel A Frame Intervals", "Interval (us)",
+                    expected_value=expected_interval_us, stats_text=stats_text(stats_a))
+    _plot_histogram(ax_b, intervals_b, "Channel B Frame Intervals", "Interval (us)",
+                    expected_value=expected_interval_us, stats_text=stats_text(stats_b))
+
+    if len(gaps) > 0:
+        _plot_histogram(ax_gap, gaps, "Inter-Channel Gap (CH_A End -> CH_B Start)",
+                        "Gap (us)", stats_text=stats_text(gap_stats))
+    else:
+        ax_gap.text(0.5, 0.5, "No inter-channel gap data available",
+                    ha='center', va='center', transform=ax_gap.transAxes)
+        ax_gap.set_title("Inter-Channel Gap (CH_A End -> CH_B Start)")
+
+    fig.suptitle(f"BDShot Timing Analysis (DShot{dshot_rate})", fontsize=14, fontweight='bold', y=0.98)
+    return fig
+
+
+def format_stats_text(min_val: float, max_val: float, mean_val: float,
+                      std_val: float, count: int) -> str:
+    """Format statistics as a text block for histogram annotation."""
+    return (f"Count: {count}\n"
+            f"Min:   {min_val:.2f} us\n"
+            f"Max:   {max_val:.2f} us\n"
+            f"Mean:  {mean_val:.2f} us\n"
+            f"Std:   {std_val:.2f} us")
+
+
+def print_report(input_file: Path, dshot_rate: int, loop_rate: float,
+                 capture_duration: float, tx_count_a: int, tx_count_b: int,
+                 stats_a: ChannelStats, stats_b: ChannelStats, gap_stats: GapStats):
+    """Print the analysis report to console."""
+    bit_period = DSHOT_BIT_PERIODS.get(dshot_rate, 3.33)
+    expected_interval = 1_000_000 / loop_rate
+
+    print(f"""
+BDShot Timing Analysis
+{"=" * 60}
+Input: {input_file}
+DShot Rate: {dshot_rate} (bit period: {bit_period:.2f} us)
+Expected Loop Rate: {loop_rate:.0f} Hz ({expected_interval:.2f} us interval)
+Capture Duration: {capture_duration:.2f} s
+Transactions Detected: CH_A={tx_count_a}, CH_B={tx_count_b}
+""")
+
+    def print_channel_stats(name: str, s: ChannelStats):
+        print(f"{name} Frame Intervals")
+        print("-" * 40)
+        print(f"  Count:     {s.count}")
+        print(f"  Min:       {s.min_us:.2f} us  ({s.min_jitter_us:+.2f} us from nominal)")
+        print(f"  Max:       {s.max_us:.2f} us  ({s.max_jitter_us:+.2f} us from nominal)")
+        print(f"  Mean:      {s.mean_us:.2f} us  ({s.mean_jitter_us:+.2f} us from nominal)")
+        print(f"  Std Dev:   {s.std_us:.2f} us\n")
+
+    print_channel_stats("Channel A", stats_a)
+    print_channel_stats("Channel B", stats_b)
+
+    print(f"""Inter-Channel Gap (CH_A End -> CH_B Start)
+{"-" * 40}
+  Count:     {gap_stats.count}
+  Min:       {gap_stats.min_us:.2f} us
+  Max:       {gap_stats.max_us:.2f} us
+  Mean:      {gap_stats.mean_us:.2f} us
+  Std Dev:   {gap_stats.std_us:.2f} us
+""")
+
+
+def fatal(msg: str):
+    """Print error and exit."""
+    print(f"Error: {msg}", file=sys.stderr)
+    sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Analyze BDShot timing from Saleae Logic Analyzer CSV exports",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="Examples:\n  %(prog)s capture.csv\n  %(prog)s capture.csv --dshot-rate 300 --loop-rate 800"
+    )
+    parser.add_argument('input_file', type=Path, help='Path to Saleae CSV export')
+    parser.add_argument('--dshot-rate', type=int, default=300, choices=[150, 300, 600, 1200],
+                        help='DShot variant (default: 300)')
+    parser.add_argument('--loop-rate', type=float, default=800, help='Expected loop rate in Hz (default: 800)')
+    parser.add_argument('--channel-a', type=int, default=0, help='CSV column index for first channel (default: 0)')
+    parser.add_argument('--channel-b', type=int, default=1, help='CSV column index for second channel (default: 1)')
+    parser.add_argument('--no-plots', action='store_true', help='Disable histogram display')
+    parser.add_argument('--verbose', '-v', action='store_true', help='Enable verbose output for debugging')
+    args = parser.parse_args()
+
+    if not args.input_file.exists():
+        fatal(f"Input file not found: {args.input_file}")
+
+    # Calculate timing parameters
+    bit_period_us = DSHOT_BIT_PERIODS.get(args.dshot_rate, 3.33)
+    idle_threshold_us = max(50.0, bit_period_us * 15)  # Must exceed turnaround gap (~25-30us)
+    expected_interval_us = 1_000_000 / args.loop_rate
+
+    if args.verbose:
+        print(f"Bit period: {bit_period_us:.2f} us\nIdle threshold: {idle_threshold_us:.2f} us\n"
+              f"Expected interval: {expected_interval_us:.2f} us\n")
+
+    # Parse CSV
+    print(f"Parsing {args.input_file}...")
+    try:
+        edges_a, edges_b = parse_csv(args.input_file, args.channel_a, args.channel_b, args.verbose)
+    except Exception as e:
+        fatal(f"parsing CSV: {e}")
+
+    if not edges_a or not edges_b:
+        fatal("No edges found in one or both channels")
+
+    # Detect transactions
+    print("Detecting transactions...")
+    transactions_a = detect_transactions(edges_a, idle_threshold_us, args.verbose)
+    transactions_b = detect_transactions(edges_b, idle_threshold_us, args.verbose)
+
+    for name, txns in [("A", transactions_a), ("B", transactions_b)]:
+        if len(txns) < 2:
+            fatal(f"Insufficient transactions in channel {name} ({len(txns)})")
+
+    # Calculate capture duration
+    all_txns = transactions_a + transactions_b
+    capture_duration = max(tx.end for tx in all_txns) - min(tx.start for tx in all_txns)
+
+    # Compute statistics
+    print("Computing statistics...")
+    stats_a, intervals_a = compute_channel_stats(transactions_a, "Channel A", expected_interval_us)
+    stats_b, intervals_b = compute_channel_stats(transactions_b, "Channel B", expected_interval_us)
+
+    try:
+        gap_stats, gaps = compute_inter_channel_gaps(transactions_a, transactions_b,
+                                                     expected_interval_us, args.verbose)
+    except ValueError as e:
+        print(f"Warning: {e}", file=sys.stderr)
+        gap_stats = GapStats(count=0, min_us=0, max_us=0, mean_us=0, std_us=0)
+        gaps = np.array([])
+
+    print_report(args.input_file, args.dshot_rate, args.loop_rate, capture_duration,
+                 len(transactions_a), len(transactions_b), stats_a, stats_b, gap_stats)
+
+    if not args.no_plots and HAS_MATPLOTLIB:
+        generate_combined_histogram(intervals_a, intervals_b, gaps, stats_a, stats_b,
+                                    gap_stats, expected_interval_us, args.dshot_rate)
+        plt.show()
+
+
+if __name__ == '__main__':
+    main()

Tools/check_submodules.sh

@@ -17,37 +17,12 @@ if [[ -f $1"/.git" || -d $1"/.git" ]]; then
 	SUBMODULE_STATUS=$(git submodule summary "$1")
 	STATUSRETVAL=$(echo $SUBMODULE_STATUS | grep -A20 -i "$1")
 	if ! [[ -z "$STATUSRETVAL" ]]; then
-		echo -e "\033[31mChecked $1 submodule, ACTION REQUIRED:\033[0m"
-		echo ""
-		echo -e "Different commits:"
+		echo -e "\033[33mWarning: $1 submodule has uncommitted changes:\033[0m"
 		echo -e "$SUBMODULE_STATUS"
 		echo ""
+		echo -e "To update submodules to the expected version, run:"
+		echo -e "   \033[94mgit submodule sync --recursive && git submodule update --init --recursive\033[0m"
 		echo ""
-		echo -e " *******************************************************************************"
-		echo -e " *   \033[31mIF YOU DID NOT CHANGE THIS FILE (OR YOU DON'T KNOW WHAT A SUBMODULE IS):\033[0m  *"
-		echo -e " *   \033[31mHit 'u' and <ENTER> to update ALL submodules and resolve this.\033[0m            *"
-		echo -e " *   (performs \033[94mgit submodule sync --recursive\033[0m                                  *"
-		echo -e " *    and \033[94mgit submodule update --init --recursive\033[0m )                            *"
-		echo -e " *******************************************************************************"
-		echo ""
-		echo ""
-		echo -e "   Only for EXPERTS:"
-		echo -e "   $1 submodule is not in the recommended version."
-		echo -e "   Hit 'y' and <ENTER> to continue the build with this version. Hit <ENTER> to resolve manually."
-		echo -e "   Use \033[94mgit add $1 && git commit -m 'Updated $1'\033[0m to choose this version (careful!)"
-		echo ""
-		read user_cmd
-		if [ "$user_cmd" == "y" ]; then
-			echo "Continuing build with manually overridden submodule.."
-		elif [ "$user_cmd" == "u" ]; then
-			git submodule sync --recursive -- $1
-			git submodule update --init --recursive -- $1 || true
-			git submodule update --init --recursive --force -- $1
-			echo "Submodule fixed, continuing build.."
-		else
-			echo "Build aborted."
-			exit 1
-		fi
 	fi
 else
 	git submodule --quiet sync --recursive --quiet -- $1

Tools/ci/generate_board_targets_json.py

@@ -25,15 +25,15 @@ parser.add_argument('-p', '--pretty', dest='pretty', action='store_true',
                     help='Pretty output instead of a single line')
 parser.add_argument('-g', '--groups', dest='group', action='store_true',
                     help='Groups targets')
-parser.add_argument('-f', '--filter', dest='filter', help='comma separated list of board names to use instead of all')
+parser.add_argument('-f', '--filter', dest='filter', help='comma separated list of build target name prefixes to include instead of all e.g. "px4_fmu-v5_"')
 
 args = parser.parse_args()
 verbose = args.verbose
 
-board_filter = []
+target_filter = []
 if args.filter:
-    for board in args.filter.split(','):
-        board_filter.append(board)
+    for target in args.filter.split(','):
+        target_filter.append(target)
 
 default_container = 'ghcr.io/px4/px4-dev:v1.16.0-rc1-258-g0369abd556'
 build_configs = []
@@ -144,7 +144,7 @@ for manufacturer in os.scandir(os.path.join(source_dir, '../boards')):
                 label = files.name[:-9]
                 target_name = manufacturer.name + '_' + board.name + '_' + label
 
-                if board_filter and not board_name in board_filter:
+                if target_filter and not any(target_name.startswith(f) for f in target_filter):
                     if verbose: print(f'excluding board {board_name} ({target_name})')
                     continue
 

Tools/module_config/generate_actuators_metadata.py

@@ -238,6 +238,7 @@ def get_actuator_output(yaml_config, output_functions, timer_config_file, verbos
             ( 'disarmed', 'Disarmed', 'DIS', False ),
             ( 'min', 'Minimum', 'MIN', False ),
             ( 'max', 'Maximum', 'MAX', False ),
+            ( 'center', 'Center\n(for Servos)', 'CENT', False ),
             ( 'failsafe', 'Failsafe', 'FAIL', True ),
             ]
         for key, label, param_suffix, advanced in standard_params_array:

Tools/module_config/generate_params.py

@@ -284,6 +284,9 @@ Note that non-motor outputs might already be active in prearm state if COM_PREAR
 '''
         minimum_description = \
 '''Minimum output value (when not disarmed).
+'''
+        center_description = \
+'''Servo Center output value (when not disarmed).
 '''
         maximum_description = \
 '''Maxmimum output value (when not disarmed).
@@ -296,6 +299,7 @@ When set to -1 (default), the value depends on the function (see {:}).
         standard_params_array = [
             ( 'disarmed', 'Disarmed', 'DIS', disarmed_description ),
             ( 'min', 'Minimum', 'MIN', minimum_description ),
+            ( 'center', 'Center', 'CENT', center_description ),
             ( 'max', 'Maximum', 'MAX', maximum_description ),
             ( 'failsafe', 'Failsafe', 'FAIL', failsafe_description ),
             ]
@@ -312,6 +316,10 @@ When set to -1 (default), the value depends on the function (see {:}).
                     standard_params[key]['default'] = -1
                     standard_params[key]['min'] = -1
 
+                if key == 'center':
+                    standard_params[key]['default'] = -1
+                    standard_params[key]['min'] = -1
+
                 param = {
                     'description': {
                         'short': channel_label+' ${i} '+label+' Value',

Tools/msg/generate_msg_docs.py

@@ -8,6 +8,803 @@ Also generates docs/en/middleware/dds_topics.md from dds_topics.yaml
 import os
 import argparse
 import sys
+import re
+
+VALID_FIELDS = { #Note, also have to add the message types as those can be fields
+    'uint64',
+    'uint16',
+    'uint8',
+    'uint32'
+}
+
+ALLOWED_UNITS = set(["m", "m/s", "m/s^2", "(m/s)^2", "deg", "deg/s", "rad", "rad/s", "rad^2", "rpm" ,"V", "A", "mA", "mAh", "W", "dBm", "h", "s", "ms", "us", "Ohm", "MB", "Kb/s", "degC","Pa","%","-"])
+invalid_units = set()
+ALLOWED_FRAMES = set(["NED","Body"])
+ALLOWED_INVALID_VALUES = set(["NaN", "0"])
+ALLOWED_CONSTANTS_NOT_IN_ENUM = set(["ORB_QUEUE_LENGTH","MESSAGE_VERSION"])
+
+class Error:
+    def __init__(self, type, message, linenumber=None, issueString = None, field = None):
+        self.type = type
+        self.message = message
+        self.linenumber = linenumber
+        self.issueString = issueString
+        self.field = field
+
+    def display_error(self):
+        #print(f"Debug: Error: display_error")
+
+
+        if 'trailing_whitespace' == self.type:
+            if self.issueString.strip():    
+                print(f"NOTE: Line has trailing whitespace ({self.message}: {self.linenumber}): {self.issueString}")
+            else:
+                print(f"NOTE: Line has trailing whitespace ({self.message}: {self.linenumber})")
+        elif 'leading_whitespace_field_or_constant' == self.type:
+            print(f"NOTE: Whitespace before field or constant ({self.message}: {self.linenumber}): {self.issueString}")             
+        elif 'field_or_constant_has_multiple_whitepsace' == self.type:
+            print(f"NOTE: Field/constant has more than one sequential whitespace character ({self.message}: {self.linenumber}): {self.issueString}") 
+        elif 'empty_start_line' == self.type:
+            print(f"NOTE: Empty line at start of file ({self.message}: {self.linenumber})")
+        elif 'internal_comment' == self.type:
+            print(f"NOTE: Internal Comment ({self.message}: {self.linenumber})\n {self.issueString}")
+        elif 'internal_comment_empty' == self.type:
+            print(f"NOTE: Empty Internal Comment ({self.message}: {self.linenumber})")
+        elif 'summary_missing' == self.type:
+            print(f"WARNING: No message description ({self.message})")
+        elif 'topic_error' == self.type:
+            print(f"NOTE: TOPIC ISSUE: {self.issueString}")
+        elif 'unknown_unit' == self.type:
+            print(f"WARNING: Unknown Unit: [{self.issueString}] on `{self.field}` ({self.message}: {self.linenumber})")
+        elif 'constant_not_in_assigned_enum' == self.type:
+            print(f"WARNING: `{self.issueString}` constant: Prefix not in `@enum` field metadata ({self.message}: {self.linenumber})")
+        elif 'unknown_invalid_value' == self.type:
+            print(f"WARNING: Unknown @invalid value: [{self.issueString}] on `{self.field}` ({self.message}: {self.linenumber})")
+        elif 'unknown_frame' == self.type:
+            print(f"WARNING: Unknown @frame: [{self.issueString}] on `{self.field}` ({self.message}: {self.linenumber})")
+        elif 'command_no_params_pipes' == self.type:
+            print(f"WARNING: `{self.field}` command has no parameters (pipes): [{self.issueString}] ({self.message}: {self.linenumber})")
+        elif 'command_missing_params' == self.type:
+            print(f"WARNING: `{self.field}` command missing params - should be 7 params surrounded by 8 pipes: [{self.issueString}] ({self.message}: {self.linenumber})")
+        elif 'command_too_many_params' == self.type:
+            print(f"WARNING: `{self.field}` command too many params (should be 7). Extras: [{self.issueString}] ({self.message}: {self.linenumber})")
+
+
+        else:
+            self.display_info()
+
+    def display_info(self):
+        """
+        Display info about an error.
+        Used as a fallback if error does not have specific printout in display_error()
+        """
+        #print(f"Debug: Error: display_info")
+        print(f" type: {self.type}, message: {self.message}, linenumber: {self.linenumber}, issueString: {self.issueString}, field: {self.field}")
+
+class Enum:
+    def __init__(self, name, parentMessage):
+        self.name = name
+        self.parent = parentMessage
+        self.enumValues = dict()
+
+    def display_info(self):
+        """
+        Display info about an enum
+        """
+        print(f"Debug: Enum: display_info")
+        print(f" name: {self.name}")
+        for key, value in self.enumValues.items():
+            value.display_info()
+
+class ConstantValue:
+    def __init__(self, name, type, value, comment, line_number):
+        self.name = name.strip()
+        self.type = type.strip()
+        self.value = value.strip()
+        self.comment = comment
+        self.line_number = line_number
+
+        if not self.value:
+            print(f"Debug WARNING: NO VALUE in ConstantValue: {self.name}")  ## TODO make into ERROR
+            exit()
+
+        # TODO if value or name are empty, error
+
+    def display_info(self):
+        print(f"Debug: ConstantValue: display_info")
+        print(f" name: {self.name}, type: {self.type}, value: {self.value}, comment: {self.comment}, line: {self.line_number}")
+
+
+class CommandParam:
+    """
+    Represents an individual param in a command constant
+    Encapsulates parsing of the param to extract units etc.
+    """
+
+    def __init__(self, num, paramText, line_number, parentCommand):
+        self.paramNum = num
+        self.paramText = paramText.strip()
+        self.enum = None
+        self.range = None
+        #self.type = type
+        self.units = []
+        self.enums = []
+        self.minValue = None
+        self.maxValue = None
+        self.invalidValue = None
+        self.frameValue = None
+        self.lineNumber = line_number
+        self.parent = parentCommand
+        self.parentMessage = self.parent.parent
+
+        match = None
+        if self.paramText:
+            match = re.match(r'^((?:\[[^\]]*\]\s*)+)(.*)$', paramText)
+        self.description = paramText
+        bracketed_part = None
+        if match:
+            bracketed_part = match.group(1).strip() # .strip() removes trailing whitespace from the bracketed part
+            self.description = match.group(2).strip()
+        if bracketed_part:
+          # get units
+            bracket_content_matches = re.findall(r'\[(.*?)\]', bracketed_part)
+            #print(f"DEBUG: bracket_content_matches: {bracket_content_matches}")
+            for item in bracket_content_matches:
+                item = item.strip()
+                if item.startswith('@'): # Not a unit:
+                    if item.startswith('@enum'):
+                        item = item.split(" ")
+                        enum = item[1].strip()
+                        if enum and enum not in self.enums:
+                            self.enums.append(enum)
+
+                        # Create parent enum objects for any enums created in this step
+                        for enumName in self.enums:
+                            if not enumName in self.parentMessage.enums:
+                                self.parentMessage.enums[enumName]=Enum(enumName,self.parentMessage)
+
+                    elif item.startswith('@range'):
+                        item = item[6:].strip().split(",")
+                        self.range = item
+                        self.minValue = item[0].strip()
+                        self.maxValue = item[1].strip()
+                    elif item.startswith('@invalid'):
+                        self.invalidValue = item[8:].strip()
+                        #TODO: Do we require a description? (not currently)
+                        if self.invalidValue.split(" ")[0] not in ALLOWED_INVALID_VALUES:
+                            print(f"TODO: Command param do not support @invalid: {self.invalidValue}")
+                            """
+                            error = Error("unknown_invalid_value", self.parent.filename, self.lineNumber, self.invalidValue, self.name)
+                            #error.display_error()
+                            if not "unknown_invalid_value" in self.parent.errors:
+                                self.parent.errors["unknown_invalid_value"] = []
+                            self.parent.errors["unknown_invalid_value"].append(error)
+                            """
+
+                    elif item.startswith('@frame'):
+                        self.frameValue = item[6:].strip()
+                        print(f"TODO: Command param do not support @frame: {self.frameValue}")
+                        """
+                        if self.frameValue not in ALLOWED_FRAMES:
+                            error = Error("unknown_frame", self.parent.filename, self.lineNumber, self.frameValue, self.name)
+                            #error.display_error()
+                            if not "unknown_frame" in self.parent.errors:
+                                self.parent.errors["unknown_frame"] = []
+                            self.parent.errors["unknown_frame"].append(error)
+                        """    
+                    else:
+                        print(f"WARNING: Unhandled metadata in message comment: {item}")
+                        # TODO - report errors for different kinds of metadata
+                        exit()
+
+                else: # bracket is a unit
+                    unit = item.strip()
+
+                    if item == "-":
+                        unit = ""
+                    
+                    if unit and unit not in self.units:
+                        self.units.append(unit) 
+
+                    if unit not in ALLOWED_UNITS:
+                        invalid_units.add(unit)
+                        error = Error("unknown_unit", self.parentMessage.filename, self.lineNumber, unit, self.parent.name)
+                        #error.display_error()
+                        if not "unknown_unit" in self.parentMessage.errors:
+                            self.parentMessage.errors["unknown_unit"] = []
+                        self.parentMessage.errors["unknown_unit"].append(error)
+
+
+    def display_info(self):
+        print(f"Debug: CommandParam: display_info")
+        print(f" id: {self.paramNum}")
+        print(f"   paramText: {self.paramText}\n  unit:  {self.units}\n  enums: {self.enums}\n  lineNumber: {self.lineNumber}\n  range: {self.range}\n  minValue: {self.minValue}\n  maxValue: {self.maxValue}\n  invalidValue: {self.invalidValue}\n  frameValue: {self.frameValue}\n  parent: {self.parent}\n  ")
+
+
+        
+class CommandConstant:
+    """
+    Represents a constant that is a command definition.
+    Encapsulates parsing of the command format.
+    The individual params are further parsed in CommandParam
+    """
+    def __init__(self, name, type, value, comment, line_number, parentMessage):
+        self.name = name.strip()
+        self.type = type.strip()
+        self.value = value.strip()
+        self.comment = comment
+        self.line_number = line_number
+        self.parent = parentMessage
+
+        self.description = self.comment
+        self.param1 = None
+        self.param2 = None
+        self.param3 = None
+        self.param4 = None
+        self.param5 = None
+        self.param6 = None
+        self.param7 = None
+
+        if not self.value:
+            print(f"Debug WARNING: NO VALUE in CommandConstant: {self.name}")  ## TODO make into ERROR
+            exit()
+
+        if not self.comment: # This is an bug for a command
+            #print(f"Debug WARNING: NO COMMENT in CommandConstant: {self.name}")  ## TODO make into ERROR
+            return
+            
+        # Parse command comment to get the description and parameters.
+        # print(f"Debug CommandConstant: {self.comment}") 
+        if not "|" in self.comment:
+            # This is an error for a command constant
+            error = Error("command_no_params_pipes", self.parent.filename, self.line_number, self.comment, self.name)
+            #error.display_error()
+            if not "command_no_params_pipes" in self.parent.errors:
+                self.parent.errors["command_no_params_pipes"] = []
+            self.parent.errors["command_no_params_pipes"].append(error)
+            return
+        
+        # Split on pipes
+        commandSplit = self.comment.split("|")
+        if len(commandSplit) < 9:
+            # Should 7 pipes, so each command is fully surrounded
+            error = Error("command_missing_params", self.parent.filename, self.line_number, self.comment, self.name)
+            #error.display_error()
+            if not "command_missing_params" in self.parent.errors:
+                self.parent.errors["command_missing_params"] = []
+            self.parent.errors["command_missing_params"].append(error)
+
+        self.description = commandSplit[0].strip()
+        self.description = self.description if self.description else None
+
+        params_to_update = commandSplit[1:8]
+
+        for i, value in enumerate(params_to_update, start=1):
+            if value.strip():
+                # parse the param
+                param = CommandParam(i, value, self.line_number, self)
+                #param.display_info() # DEBUG CODE XXX
+                setattr(self, f"param{i}", param)
+                # parse the param
+
+        if len(commandSplit) > 8:
+            extras = commandSplit[8:]
+            error = Error("command_too_many_params", self.parent.filename, self.line_number, extras, self.name)
+            if not "command_too_many_params" in self.parent.errors:
+                self.parent.errors["command_too_many_params"] = []
+            self.parent.errors["command_too_many_params"].append(error)
+
+
+        # TODO if value or name are empty, error
+
+    def markdown_out(self):
+        #print("DEBUG: CommandConstant.markdown_out")
+        output = f"""### {self.name} ({self.value})
+
+{self.description}
+
+Param | Units | Range/Enum | Description
+--- | --- | --- | ---
+"""
+        for i in range(1, 8):
+            attr_name = f"param{i}"
+            # getattr returns None if the attribute doesn't exist
+            val = getattr(self, attr_name, None)
+
+            if val is not None:
+                rangeVal = ""
+                if val.minValue or val.maxValue:
+                    rangeVal = f"[{val.minValue if val.minValue else '-'} : {val.maxValue if val.maxValue else '-' }]"
+
+                output+=f"{i} | {", ".join(val.units)}|{', '.join(f"[{e}](#{e})" for e in val.enums)}{rangeVal} | {val.description}\n"
+            else:
+                output+=f"{i} | | | ?\n"                
+
+        output+=f"\n"
+        return output
+
+
+    def display_info(self):
+        print(f"Debug: CommandConstant: display_info")
+        print(f" name: {self.name}, type: {self.type}, value: {self.value}, comment: {self.comment}, line: {self.line_number}")
+        print(f"   description: {self.description}\n  param1: {self.param1}\n  param2: {self.param2}\n  param3: {self.param3}\n  param4: {self.param4}\n  param5: {self.param5}\n  param6: {self.param6}\n  param7: {self.param7}")
+
+class MessageField:
+    """
+    Represents a field.
+    Encapsulates parsing of the field information.
+    """
+    def __init__(self, name, type, comment, line_number, parentMessage):
+        self.name = name
+        self.type = type
+        self.comment = comment
+        self.unit = None
+        self.enums = None
+        self.minValue = None
+        self.maxValue = None
+        self.invalidValue = None
+        self.frameValue = None
+        self.lineNumber = line_number
+        self.parent = parentMessage
+
+        #print(f"MessageComment: {comment}")
+        match = None
+        if self.comment:
+            match = re.match(r'^((?:\[[^\]]*\]\s*)+)(.*)$', comment)
+        self.description = comment
+        bracketed_part = None
+        if match:
+            bracketed_part = match.group(1).strip() # .strip() removes trailing whitespace from the bracketed part
+            self.description = match.group(2).strip()
+        if bracketed_part:
+          # get units
+            bracket_content_matches = re.findall(r'\[(.*?)\]', bracketed_part)
+            #print(f"bracket_content_matches: {bracket_content_matches}")
+            for item in bracket_content_matches:
+                item = item.strip()
+                if item.startswith('@'): # Not a unit:
+                    if item.startswith('@enum'):
+                        item = item.split(" ")
+                        self.enums = item[1:]
+                        # Create parent enum objects
+                        for enumName in self.enums:
+                            if not enumName in parentMessage.enums:
+                                parentMessage.enums[enumName]=Enum(enumName,parentMessage)
+                    elif item.startswith('@range'):
+                        item = item[6:].strip().split(",")
+                        self.minValue = item[0].strip()
+                        self.maxValue = item[1].strip()
+                    elif item.startswith('@invalid'):
+                        self.invalidValue = item[8:].strip()
+                        #TODO: Do we require a description? (not currently)
+                        if self.invalidValue.split(" ")[0] not in ALLOWED_INVALID_VALUES:
+                            error = Error("unknown_invalid_value", self.parent.filename, self.lineNumber, self.invalidValue, self.name)
+                            #error.display_error()
+                            if not "unknown_invalid_value" in self.parent.errors:
+                                self.parent.errors["unknown_invalid_value"] = []
+                            self.parent.errors["unknown_invalid_value"].append(error)
+                    elif item.startswith('@frame'):
+                        self.frameValue = item[6:].strip()
+                        if self.frameValue not in ALLOWED_FRAMES:
+                            error = Error("unknown_frame", self.parent.filename, self.lineNumber, self.frameValue, self.name)
+                            #error.display_error()
+                            if not "unknown_frame" in self.parent.errors:
+                                self.parent.errors["unknown_frame"] = []
+                            self.parent.errors["unknown_frame"].append(error)
+                    else:
+                        print(f"WARNING: Unhandled metadata in message comment: {item}")
+                        # TODO - report errors for different kinds of metadata
+                        exit()
+
+                else: # bracket is a unit
+                    self.unit = item
+
+                    if self.unit not in ALLOWED_UNITS:
+                        invalid_units.add(self.unit)
+                        error = Error("unknown_unit", self.parent.filename, self.lineNumber, self.unit, self.name)
+                        #error.display_error()
+                        if not "unknown_unit" in self.parent.errors:
+                            self.parent.errors["unknown_unit"] = []
+                        self.parent.errors["unknown_unit"].append(error)
+
+                    if item == "-":
+                        self.unit = ""
+
+
+    def display_info(self):
+        print(f"Debug: MessageField: display_info")
+        print(f" name: {self.name}, type: {self.type}, description: {self.description}, enums: {self.enums}, minValue: {self.minValue}, maxValue: {self.maxValue}, invalidValue: {self.invalidValue}, frameValue: {self.frameValue}")
+
+
+class UORBMessage:
+    """
+    Represents a whole message, including fields, enums, commands, constants.
+    The parser function delegates the parsing of each part of the message to 
+    more appropriate classes, once the specific type of line has been identified.
+    """
+
+    def __init__(self, filename):
+
+        self.filename = filename
+        msg_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),"../../msg")
+        self.msg_filename = os.path.join(msg_path, self.filename)
+        self.name = os.path.splitext(os.path.basename(msg_file))[0]
+        self.shortDescription = ""
+        self.longDescription = ""
+        self.fields = []
+        self.constantFields = dict()
+        self.commandConstants = dict()
+        self.enums = dict()
+        self.output_file = os.path.join(output_dir, f"{self.name}.md")
+        self.topics = []
+        self.errors = dict()
+
+        self.parseFile()
+
+        if args.errors:
+            #print(f"DEBUG: args.errors: {args.errors}")
+            if args.error_messages:
+                messages = args.error_messages.split(" ")
+                #print(f"DEBUG: args.errors: {messages},self.name: {self.name}")
+                if self.name in messages:
+                    self.reportErrors()
+                    #print(f"Debug: {self.name} in {messages}")
+            else:
+              self.reportErrors()
+
+    def reportErrors(self):
+        #print(f"Debug: UORBMessage: reportErrors()")
+        for errorType, errors in self.errors.items():
+            for error in errors:
+               error.display_error()
+
+    def markdown_out(self):
+        #print(f"Debug: UORBMessage: markdown_out()")
+
+        # Add page header (forces wide pages)
+        markdown = f"""---
+pageClass: is-wide-page
+---
+
+# {self.name} (UORB message)
+
+"""
+        ## Append description info if present
+        markdown += f"{self.shortDescription}\n\n" if self.shortDescription else ""
+        markdown += f"{self.longDescription}\n\n" if self.longDescription else ""
+
+        topicList = " ".join(self.topics)
+        markdown += f"**TOPICS:** {topicList}\n\n"
+
+        # Generate field docs
+        markdown += f"## Fields\n\n"
+        markdown += "Name | Type | Unit [Frame] | Range/Enum | Description\n"
+        markdown += "--- | --- | --- | --- | ---\n"
+        for field in self.fields:
+            unit = f"{field.unit}" if field.unit else ""
+            frame = f"[{field.frameValue}]" if field.frameValue else ""
+            unit = f"{unit} {frame}"
+            unit.strip()
+            unit = f" {unit}"
+
+            value = " "
+            if field.enums:
+                value = ""
+                for enum in field.enums:
+                    value += f"[{enum}](#{enum})"
+                value = value.strip()
+                value = f"{value}"
+            elif field.minValue or field.maxValue:
+                value = f"[{field.minValue if field.minValue else '-'} : {field.maxValue if field.maxValue else '-' }]"
+
+            description = f" {field.description}" if field.description else ""
+            invalid = f" (Invalid: {field.invalidValue}) " if field.invalidValue else ""
+            markdown += f"{field.name} | `{field.type}` |{unit}|{value}|{description}{invalid}\n"
+
+        # Generate table for command docs
+        if len(self.commandConstants) > 0:
+            #print("DEBUGCOMMAND")
+            markdown += f"\n## Commands\n\n"
+
+            """
+            markdown += "Name | Type | Value | Description\n"
+            markdown += "--- | --- | --- |---\n"
+            for name, command in self.commandConstants.items():
+                description = f" {command.comment} " if enum.comment else " "
+                markdown += f'<a href="#{name}"></a> {name} | `{command.type}` | {command.value} |{description}\n'            
+            """
+            for commandConstant in self.commandConstants.values():
+                #print(commandConstant)
+                markdown += commandConstant.markdown_out()     
+
+        # Generate enum docs
+        if len(self.enums) > 0:
+            markdown += f"\n## Enums\n"
+
+            for name, enum in self.enums.items():
+                markdown += f"\n### {name} {{#{name}}}\n\n"
+
+                markdown += "Name | Type | Value | Description\n"
+                markdown += "--- | --- | --- | ---\n"
+
+                for enumValueName, enumValue in enum.enumValues.items():
+                    description = f" {enumValue.comment} " if enumValue.comment else " "
+                    markdown += f'<a href="#{enumValueName}"></a> {enumValueName} | `{enumValue.type}` | {enumValue.value} |{description}\n'
+
+        # Generate table for constants docs
+        if len(self.constantFields) > 0:
+            markdown += f"\n## Constants\n\n"
+            markdown += "Name | Type | Value | Description\n"
+            markdown += "--- | --- | --- |---\n"
+            for name, enum in self.constantFields.items():
+                description = f" {enum.comment} " if enum.comment else " "
+                markdown += f'<a href="#{name}"></a> {name} | `{enum.type}` | {enum.value} |{description}\n'
+
+
+
+        # Append msg contents to the end
+        with open(self.msg_filename, 'r') as source_file:
+            msg_contents = source_file.read()
+            msg_contents = msg_contents.strip()
+
+        #Format markdown using msg name, comment, url, contents.
+        markdown += f"""
+
+## Source Message
+
+[Source file (GitHub)](https://github.com/PX4/PX4-Autopilot/blob/main/msg/{self.filename})
+
+::: details Click here to see original file
+
+```c
+{msg_contents}
+```
+
+:::
+"""
+
+        with open(self.output_file, 'w') as content_file:
+            content_file.write(markdown)
+
+        #exit()
+
+
+    def display_info(self):
+        print(f"UORBMessage: display_info")
+        print(f" name: {self.name}")
+        print(f" filename: {self.filename}, ")
+        print(f" msg_filename: {self.msg_filename}, ")
+        print(f"self.shortDescription: {self.shortDescription}")
+        print(f"self.longDescription: {self.longDescription}")
+        print(f"self.enums: {self.enums}")
+
+        for enum, enumObject in self.enums.items():
+            enumObject.display_info()
+
+        # Output our data so far
+        for field in self.fields:
+            field.display_info()
+
+        for enumvalue in self.constantFields:
+            print(enumvalue)
+            self.constantFields[enumvalue].display_info()
+
+    def handleField(self, line, line_number, parentMessage):
+        #print(f"debug: handleField: (line): \n {line}")
+        # Note, here we know we don't have a comment or a topic.
+        # We expect it to be a field.
+
+        # Check field doesn't have leading whitespace (trailing spaces already checked)
+        if line[:1].isspace(): # Returns True for ' ', '\t', '\n', '\r', etc.
+            #print("First character is whitespace")
+            error = Error("leading_whitespace_field_or_constant", self.filename, line_number, line)
+            if not "leading_whitespace_field_or_constant" in self.errors:
+                self.errors["leading_whitespace_field_or_constant"] = []
+                self.errors["leading_whitespace_field_or_constant"].append(error)
+
+        # Now we can parse the stripped line
+        fieldOrConstant = line.strip()
+
+        # Check that the field or constant has only single whitespace separators
+        stripped_fieldOrConstant = re.sub(r'\s+', ' ', fieldOrConstant) # Collapse all spaces to a single space (LHS already stripped).
+        if stripped_fieldOrConstant != fieldOrConstant:
+            #print("Field/Constant has multiple whitespace characters") # Since the collapsed version shows them.
+            error = Error("field_or_constant_has_multiple_whitepsace", self.filename, line_number, line)
+            if not "field_or_constant_has_multiple_whitepsace" in self.errors:
+                self.errors["field_or_constant_has_multiple_whitepsace"] = []
+                self.errors["field_or_constant_has_multiple_whitepsace"].append(error)
+
+        fieldOrConstant = stripped_fieldOrConstant
+
+
+
+        comment = None
+        if "#" in line:
+            commentExtract = line.split("#", 1) # Split once on left-most '#'
+            fieldOrConstant = commentExtract[0].strip()
+            comment = commentExtract[-1].strip()
+
+        if "=" not in fieldOrConstant:
+            # Is a field:
+            field = fieldOrConstant.split(" ")
+            type = field[0].strip()
+            name = field[1].strip()
+            field = MessageField(name, type, comment, line_number, parentMessage)
+            self.fields.append(field)
+        else:
+            temp = fieldOrConstant.split("=")
+            value = temp[-1]
+            typeAndName = temp[0].split(" ")
+            type = typeAndName[0]
+            name = typeAndName[1]
+            if name.startswith("VEHICLE_CMD_") and parentMessage.name == 'VehicleCommand': #it's a command.
+                #print(f"DEBUG: startswith VEHICLE_CMD_ {name}")
+                commandConstant = CommandConstant(name, type, value, comment, line_number, parentMessage)
+                #commandConstant.display_info()
+                self.commandConstants[name]=commandConstant
+            else: #it's a constant (or part of an enum)
+                constantField = ConstantValue(name, type, value, comment, line_number)
+                self.constantFields[name]=constantField
+
+
+    def parseFile(self):
+        initial_block_lines = []
+        #stopping_token = None
+        found_first_relevant_content = False
+        gettingInitialComments = False
+        gettingFields = False
+
+        with open(self.msg_filename, 'r', encoding='utf-8') as uorbfile:
+            lines = uorbfile.read().splitlines()
+            for line_number, line in enumerate(lines, 1):
+
+                if line != line.rstrip():
+                    #print(f"[{self.filename}] Trailing whitespace on line {line_number}: XX{line}YY")
+                    error = Error("trailing_whitespace", self.filename, line_number, line)
+                    if not "trailing_whitespace" in self.errors:
+                        self.errors["trailing_whitespace"] = []
+                    self.errors["trailing_whitespace"].append(error)
+
+                #print(f"line: {line}")
+                stripped_line = re.sub(r'\s+', ' ', line).strip() # Collapse all spaces to a single space and strip stuff off end.
+                #print(f"stripped_line: {stripped_line}")
+                # TODO? Perhaps report whitespace if the size of those two is different and it is empty
+                # Or perhaps we just fix it on request
+
+                isEmptyLine = False if line.strip() else True
+                if not found_first_relevant_content and isEmptyLine: #Empty line
+                    #print(f"{self.filename}: Empty line at start of file: [{line_number}]\n {line}")
+                    error = Error("empty_start_line", self.filename, line_number, line)
+                    if not "empty_start_line" in self.errors:
+                        self.errors["empty_start_line"] = []
+                    self.errors["empty_start_line"].append(error)
+                    #error.display_error()
+                    continue
+                if not found_first_relevant_content and not isEmptyLine:
+                    found_first_relevant_content = True
+
+                    if stripped_line.startswith("#"):
+                        gettingInitialComments = True
+                    else:
+                        gettingInitialComments = False
+                        gettingFields = True
+
+                if gettingInitialComments and stripped_line.startswith("#"):
+                    stripped_line=stripped_line[1:].strip()
+                    #print(f"DEBUG: gettingInitialComments: comment line: {stripped_line}")
+                    initial_block_lines.append(stripped_line)
+                else:
+                    gettingInitialComments = False
+                    gettingFields = True #Getting fields and constants
+                if gettingFields:
+                    if isEmptyLine:
+                        continue # empty line
+                    if stripped_line.startswith("# TOPICS "):
+                        stripped_line = stripped_line[9:]
+                        stripped_line = stripped_line.split(" ")
+                        self.topics+= stripped_line
+                        # Note, default topic and topic errors handled after all lines parsed
+                        continue
+                    if stripped_line.startswith("#"):
+                        # Its an internal comment
+                        stripped_line=stripped_line[1:].strip()
+                        
+                        if stripped_line:
+                            #print(f"{self.filename}: Internal comment: [{line_number}]\n {line}")
+                            error = Error("internal_comment", self.filename, line_number, line)
+                            if not "internal_comment" in self.errors:
+                                self.errors["internal_comment"] = []
+                            self.errors["internal_comment"].append(error)
+                        else:
+                            #print(f"{self.filename}: Empty internal comment: [{line_number}]\n {line}")
+                            error = Error("internal_comment_empty", self.filename, line_number, line)
+                            if not "internal_comment_empty" in self.errors:
+                                self.errors["internal_comment_empty"] = []
+                            self.errors["internal_comment_empty"].append(error)
+                            #pass # Empty comment
+                        continue
+                    
+                    # Must be a field or a comment.
+                    self.handleField(line, line_number, parentMessage=self)
+
+            # Fix up topics if the topic is empty
+            def camel_to_snake(name):
+                # Match upper case not at start of string
+                s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
+                # Handle cases with multiple capital first letter
+                return re.sub('([A-Z]+)([A-Z][a-z]*)', r'\1_\2', s1).lower()
+
+            defaultTopic = camel_to_snake(self.name)
+            if len(self.topics) == 0:
+                # We have no topic declared, so set the default topic
+                self.topics.append(defaultTopic)
+            elif len(self.topics) == 1:
+                # We have 1 topic declared - either it is default or there is some issue.
+                if defaultTopic in self.topics:
+                    # Declared topic is default topic
+                    error = Error("topic_error", self.filename, "", f"WARNING: TOPIC {defaultTopic} unnecessarily declared for {self.name}")
+                else:
+                    # Declared topic is not default topic
+                    error = Error("topic_error", self.filename, "", f"NOTE: TOPIC {self.topics[1]}: Only Declared topic is not default topic {defaultTopic} for {self.name}")
+                if not "topic_error" in self.errors:
+                    self.errors["topic_error"] = []
+                    self.errors["topic_error"].append(error)
+            elif len(self.topics) > 1:
+                if defaultTopic not in self.topics:
+                    error = Error("topic_error", self.filename, "", f"NOTE: TOPIC - Default topic {defaultTopic} for {self.name} not in {self.topics}")
+
+            # Parse our short and long description
+            #print(f"DEBUG: initial_block_lines: {initial_block_lines}")
+            doingLongDescription = False
+            for summaryline in initial_block_lines:
+                if not self.shortDescription and summaryline.strip() == '':
+                    continue
+                if not doingLongDescription and not summaryline.strip() == '':
+                   self.shortDescription += f" {summaryline}"
+                   self.shortDescription = self.shortDescription.strip()
+                   if not self.shortDescription[-1:] == ".": # Add terminating fullstop if not present.
+                       self.shortDescription += "."
+                if not doingLongDescription and summaryline.strip() == '':
+                   doingLongDescription = True
+                   continue
+                if doingLongDescription:
+                    self.longDescription += f"{summaryline}\n"
+
+            if self.longDescription:
+                self.longDescription.strip()
+
+            if not self.shortDescription:
+                # Summary has not been defined
+                error = Error("summary_missing", self.filename)
+                if not "summary_missing" in self.errors:
+                    self.errors["summary_missing"] = []
+                self.errors["summary_missing"].append(error)
+
+
+            # TODO Parse our constantValues into enums, leaving only constants
+            constantValuesToRemove = []
+            #print(f"DEBUG: Self.enums: {self.enums}")
+            for enumName, enumObject in self.enums.items():
+                for enumValueName, enumValueObject in self.constantFields.items():
+                    if enumValueName.startswith(enumName):
+                        # Copy this value into the object (cant be duplicate because parent is dict)
+                        enumObject.enumValues[enumValueName]=enumValueObject
+                        constantValuesToRemove.append(enumValueName)
+            # Now delete the original enumvalues
+            for enumValName in constantValuesToRemove:
+                del self.constantFields[enumValName]
+            constantsNotAssignedToEnums = len(self.constantFields)
+            if constantsNotAssignedToEnums > 0:
+                #print(f"Debug: WARNING constantsNotAssignedToEnums: {constantsNotAssignedToEnums}")
+                for enumValueName, enumValue in self.constantFields.items():
+                    if enumValueName in ALLOWED_CONSTANTS_NOT_IN_ENUM: # Ignore constants
+                        pass
+                    else:
+                        error = Error("constant_not_in_assigned_enum", self.filename, enumValue.line_number, enumValueName)
+                        if not "constant_not_in_assigned_enum" in self.errors:
+                            self.errors["constant_not_in_assigned_enum"] = []
+                        self.errors["constant_not_in_assigned_enum"].append(error)
+                # TODO Maybe present as list of possible enums.
 
 
 import yaml
@@ -127,83 +924,50 @@ if __name__ == "__main__":
 
     parser = argparse.ArgumentParser(description='Generate docs from .msg files')
     parser.add_argument('-d', dest='dir', help='output directory', required=True)
+    parser.add_argument('-e', dest='errors', action='store_true', help='Report errors')
+    parser.add_argument('-m', dest='error_messages', help='Message to report errors against (by default all)')
     args = parser.parse_args()
 
     output_dir = args.dir
     if not os.path.isdir(output_dir):
+        print(f"making output_dir {output_dir}")
         os.mkdir(output_dir)
 
     msg_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),"../../msg")
     msg_files = get_msgs_list(msg_path)
+
     msg_files.sort()
 
     versioned_msgs_list = ''
     unversioned_msgs_list = ''
+    msgTypes = set()
 
     for msg_file in msg_files:
+        # Add messages to set of allowed types (compound types)
+        #msg_type = msg_file.rsplit('/')[-1]
+        #msg_type = msg_type.rsplit('\\')[-1]
+        #msg_type = msg_type.rsplit('.')[0]
         msg_name = os.path.splitext(os.path.basename(msg_file))[0]
-        output_file = os.path.join(output_dir, msg_name+'.md')
-        msg_filename = os.path.join(msg_path, msg_file)
-        print("{:} -> {:}".format(msg_filename, output_file))
+        msgTypes.add(msg_name)
 
-        #Format msg url
-        msg_url="[source file](https://github.com/PX4/PX4-Autopilot/blob/main/msg/%s)" % msg_file
-
-        msg_description = ""
-        summary_description = ""
-
-        #Get msg description (first non-empty comment line from top of msg)
-        with open(msg_filename, 'r') as lineparser:
-            line = lineparser.readline()
-            while line.startswith('#') or (line.strip() == ''):
-                print('DEBUG: line: %s' % line)
-                line=line[1:].strip()+'\n'
-                stripped_line=line.strip()
-                if msg_description and not summary_description and stripped_line=='':
-                    summary_description = msg_description.strip()
-
-                msg_description+=line
-                line = lineparser.readline()
-            msg_description=msg_description.strip()
-            if not summary_description and msg_description:
-                summary_description = msg_description
-            print('msg_description: Z%sZ' % msg_description)
-            print('summary_description: Z%sZ' % summary_description)
-            summary_description
-        msg_contents = ""
-        #Get msg contents (read the file)
-        with open(msg_filename, 'r') as source_file:
-            msg_contents = source_file.read()
-
-        #Format markdown using msg name, comment, url, contents.
-        markdown_output="""# %s (UORB message)
-
-%s
-
-%s
-
-```c
-%s
-```
-""" % (msg_name, msg_description, msg_url, msg_contents)
-
-        with open(output_file, 'w') as content_file:
-            content_file.write(markdown_output)
+    for msg_file in msg_files:
+        message = UORBMessage(msg_file)
+        # Any additional tests that can't be in UORBMessage parser go here.
+        message.markdown_out()
 
         # Categorize as versioned or unversioned
         if "versioned" in msg_file:
-            versioned_msgs_list += '- [%s](%s.md)' % (msg_name, msg_name)
-            if summary_description:
-                versioned_msgs_list += " — %s" % summary_description
+            versioned_msgs_list += f"- [{message.name}]({message.name}.md)"
+            if message.shortDescription:
+                versioned_msgs_list += f" — {message.shortDescription}"
             versioned_msgs_list += "\n"
         else:
-            unversioned_msgs_list += '- [%s](%s.md)' % (msg_name, msg_name)
-            if summary_description:
-                unversioned_msgs_list += " — %s" % summary_description
+            unversioned_msgs_list += f"- [{message.name}]({message.name}.md)"
+            if message.shortDescription:
+                unversioned_msgs_list += f" — {message.shortDescription}"
             unversioned_msgs_list += "\n"
-
     # Write out the index.md file
-    index_text="""# uORB Message Reference
+    index_text=f"""# uORB Message Reference
 
 ::: info
 This list is [auto-generated](https://github.com/PX4/PX4-Autopilot/blob/main/Tools/msg/generate_msg_docs.py) from the source code.
@@ -218,14 +982,14 @@ Graphs showing how these are used [can be found here](../middleware/uorb_graph.m
 
 ## Versioned Messages
 
-%s
+{versioned_msgs_list}
 
 ## Unversioned Messages
 
-%s
-    """ % (versioned_msgs_list, unversioned_msgs_list)
+{unversioned_msgs_list}
+    """
     index_file = os.path.join(output_dir, 'index.md')
-    with open(index_file, 'w') as content_file:
+    with open(index_file, 'w', encoding='utf-8') as content_file:
             content_file.write(index_text)
 
     generate_dds_yaml_doc(msg_files)

Tools/process_sensor_caldata.py

@@ -1138,6 +1138,8 @@ if num_mags >= 1:
 
     if not math.isnan(sensor_mag_0['temperature'][0]):
 
+        mag_0_params['TC_M0_ID'] = int(np.median(sensor_mag_0['device_id']))
+
         # find the min, max and reference temperature
         mag_0_params['TC_M0_TMIN'] = np.amin(sensor_mag_0['temperature'])
         mag_0_params['TC_M0_TMAX'] = np.amax(sensor_mag_0['temperature'])
@@ -1675,7 +1677,7 @@ baro_0_x_resample = fit_coef_baro_0_x(temp_rel_resample)
 plt.figure(13,figsize=(20,13))
 
 # draw plots
-plt.plot(sensor_baro_0['temperature'],100*sensor_baro_0['pressure']-100*median_pressure,'b')
+plt.plot(sensor_baro_0['temperature'],sensor_baro_0['pressure']-median_pressure,'b')
 plt.plot(temp_resample,baro_0_x_resample,'r')
 plt.title('Baro 0 ({}) Bias vs Temperature'.format(baro_0_params['TC_B0_ID']))
 plt.ylabel('Z bias (Pa)')
@@ -1736,7 +1738,7 @@ if num_baros >= 2:
     plt.figure(14,figsize=(20,13))
 
     # draw plots
-    plt.plot(sensor_baro_1['temperature'],100*sensor_baro_1['pressure']-100*median_pressure,'b')
+    plt.plot(sensor_baro_1['temperature'],sensor_baro_1['pressure']-median_pressure,'b')
     plt.plot(temp_resample,baro_1_x_resample,'r')
     plt.title('Baro 1 ({}) Bias vs Temperature'.format(baro_1_params['TC_B1_ID']))
     plt.ylabel('Z bias (Pa)')
@@ -1797,7 +1799,7 @@ if num_baros >= 3:
     plt.figure(15,figsize=(20,13))
 
     # draw plots
-    plt.plot(sensor_baro_2['temperature'],100*sensor_baro_2['pressure']-100*median_pressure,'b')
+    plt.plot(sensor_baro_2['temperature'],sensor_baro_2['pressure']-median_pressure,'b')
     plt.plot(temp_resample,baro_2_x_resample,'r')
     plt.title('Baro 2 ({}) Bias vs Temperature'.format(baro_2_params['TC_B2_ID']))
     plt.ylabel('Z bias (Pa)')
@@ -1853,7 +1855,7 @@ if num_baros >= 4:
     plt.figure(16,figsize=(20,13))
 
     # draw plots
-    plt.plot(sensor_baro_3['temperature'],100*sensor_baro_3['pressure']-100*median_pressure,'b')
+    plt.plot(sensor_baro_3['temperature'],sensor_baro_3['pressure']-median_pressure,'b')
     plt.plot(temp_resample,baro_3_x_resample,'r')
     plt.title('Baro 3 ({}) Bias vs Temperature'.format(baro_3_params['TC_B3_ID']))
     plt.ylabel('Z bias (Pa)')

Tools/px_uploader.py

@@ -1,983 +0,0 @@
-#!/usr/bin/env python3
-############################################################################
-#
-#   Copyright (c) 2012-2024 PX4 Development Team. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright
-#    notice, this list of conditions and the following disclaimer in
-#    the documentation and/or other materials provided with the
-#    distribution.
-# 3. Neither the name PX4 nor the names of its contributors may be
-#    used to endorse or promote products derived from this software
-#    without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-#
-############################################################################
-
-#
-# Serial firmware uploader for the PX4FMU bootloader
-#
-# The PX4 firmware file is a JSON-encoded Python object, containing
-# metadata fields and a zlib-compressed base64-encoded firmware image.
-#
-# The uploader uses the following fields from the firmware file:
-#
-# image
-#       The firmware that will be uploaded.
-# image_size
-#       The size of the firmware in bytes.
-# board_id
-#       The board for which the firmware is intended.
-# board_revision
-#       Currently only used for informational purposes.
-#
-
-import sys
-import argparse
-import binascii
-import socket
-import struct
-import json
-import zlib
-import base64
-import time
-import array
-import os
-
-from sys import platform as _platform
-
-try:
-    import serial
-except ImportError as e:
-    print(f"Failed to import serial: {e}")
-    print("")
-    print("You may need to install it using:")
-    print("    python -m pip install pyserial")
-    print("")
-    sys.exit(1)
-
-
-# Detect python version
-if sys.version_info[0] < 3:
-    raise RuntimeError("Python 2 is not supported. Please try again using Python 3.")
-    sys.exit(1)
-
-
-# Use monotonic time where available
-def _time():
-    try:
-        return time.monotonic()
-    except Exception:
-        return time.time()
-
-class FirmwareNotSuitableException(Exception):
-    def __init__(self, message):
-        super(FirmwareNotSuitableException, self).__init__(message)
-
-
-class firmware(object):
-    '''Loads a firmware file'''
-
-    desc = {}
-    image = bytes()
-    crctab = array.array('I', [
-        0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
-        0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
-        0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
-        0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
-        0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
-        0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
-        0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
-        0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
-        0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
-        0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
-        0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
-        0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
-        0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
-        0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
-        0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
-        0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
-        0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
-        0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
-        0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
-        0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
-        0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
-        0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
-        0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
-        0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
-        0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
-        0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
-        0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
-        0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
-        0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
-        0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
-        0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
-        0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d])
-    crcpad = bytearray(b'\xff\xff\xff\xff')
-
-    def __init__(self, path):
-
-        # read the file
-        f = open(path, "r")
-        self.desc = json.load(f)
-        f.close()
-
-        self.image = bytearray(zlib.decompress(base64.b64decode(self.desc['image'])))
-
-        # pad image to 4-byte length
-        while ((len(self.image) % 4) != 0):
-            self.image.extend(b'\xff')
-
-    def property(self, propname):
-        return self.desc[propname]
-
-    def __crc32(self, bytes, state):
-        for byte in bytes:
-            index = (state ^ byte) & 0xff
-            state = self.crctab[index] ^ (state >> 8)
-        return state
-
-    def crc(self, padlen):
-        state = self.__crc32(self.image, int(0))
-        for _ in range(len(self.image), (padlen - 1), 4):
-            state = self.__crc32(self.crcpad, state)
-        return state
-
-
-class uploader:
-    '''Uploads a firmware file to the PX4 bootloader'''
-
-    # protocol bytes
-    INSYNC          = b'\x12'
-    EOC             = b'\x20'
-
-    # reply bytes
-    OK              = b'\x10'
-    FAILED          = b'\x11'
-    INVALID         = b'\x13'     # rev3+
-    BAD_SILICON_REV = b'\x14'     # rev5+
-
-    # command bytes
-    NOP             = b'\x00'     # guaranteed to be discarded by the bootloader
-    GET_SYNC        = b'\x21'
-    GET_DEVICE      = b'\x22'
-    CHIP_ERASE      = b'\x23'
-    CHIP_VERIFY     = b'\x24'     # rev2 only
-    PROG_MULTI      = b'\x27'
-    READ_MULTI      = b'\x28'     # rev2 only
-    GET_CRC         = b'\x29'     # rev3+
-    GET_OTP         = b'\x2a'     # rev4+  , get a word from OTP area
-    GET_SN          = b'\x2b'     # rev4+  , get a word from SN area
-    GET_CHIP        = b'\x2c'     # rev5+  , get chip version
-    SET_BOOT_DELAY  = b'\x2d'     # rev5+  , set boot delay
-    GET_CHIP_DES    = b'\x2e'     # rev5+  , get chip description in ASCII
-    GET_VERSION     = b'\x2f'     # rev5+  , get bootloader version in ASCII
-    CHIP_FULL_ERASE = b'\x40'     # full erase of flash, rev6+
-    MAX_DES_LENGTH  = 20
-
-    REBOOT          = b'\x30'
-
-    INFO_BL_REV     = b'\x01'        # bootloader protocol revision
-    BL_REV_MIN      = 2              # minimum supported bootloader protocol
-    BL_REV_MAX      = 5              # maximum supported bootloader protocol
-    INFO_BOARD_ID   = b'\x02'        # board type
-    INFO_BOARD_REV  = b'\x03'        # board revision
-    INFO_FLASH_SIZE = b'\x04'        # max firmware size in bytes
-
-    PROG_MULTI_MAX  = 252            # protocol max is 255, must be multiple of 4
-    READ_MULTI_MAX  = 252            # protocol max is 255
-
-    NSH_INIT        = bytearray(b'\x0d\x0d\x0d')
-    NSH_REBOOT_BL   = b"reboot -b\n"
-    NSH_REBOOT      = b"reboot\n"
-    MAVLINK_REBOOT_ID1 = bytearray(b'\xfe\x21\x72\xff\x00\x4c\x00\x00\x40\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x01\x00\x00\x53\x6b')
-    MAVLINK_REBOOT_ID0 = bytearray(b'\xfe\x21\x45\xff\x00\x4c\x00\x00\x40\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x00\xcc\x37')
-
-    MAX_FLASH_PRGRAM_TIME  = 0.001  # Time on an F7 to send SYNC, RESULT from last data in multi RXed
-
-    def __init__(self, portname, baudrate_bootloader, baudrate_flightstack):
-        # Open the port, keep the default timeout short so we can poll quickly.
-        # On some systems writes can suddenly get stuck without having a
-        # write_timeout > 0 set.
-        # chartime 8n1 * bit rate is us
-        self.chartime = 10 * (1.0 / baudrate_bootloader)
-
-        # we use a window approche to SYNC,<result> gathring
-        self.window = 0
-        self.window_max = 256
-        self.window_per = 2  # Sync,<result>
-        self.ackWindowedMode = False  # Assume Non Widowed mode for all USB CDC
-        self.port = serial.Serial(portname, baudrate_bootloader, timeout=0.5, write_timeout=0)
-        self.otp = b''
-        self.sn = b''
-        self.baudrate_bootloader = baudrate_bootloader
-        self.baudrate_flightstack = baudrate_flightstack
-        self.baudrate_flightstack_idx = -1
-        self.force_erase = False
-
-    def close(self):
-        if self.port is not None:
-            self.port.close()
-
-    def open(self):
-        # upload timeout
-        timeout = _time() + 0.2
-
-        # attempt to open the port while it exists and until timeout occurs
-        while self.port is not None:
-            portopen = True
-            try:
-                portopen = self.port.is_open
-            except AttributeError:
-                portopen = self.port.isOpen()
-
-            if not portopen and _time() < timeout:
-                try:
-                    self.port.open()
-                except OSError:
-                    # wait for the port to be ready
-                    time.sleep(0.04)
-                except serial.SerialException:
-                    # if open fails, try again later
-                    time.sleep(0.04)
-            else:
-                break
-
-    # debugging code
-    def __probe(self, state):
-        # self.port.setRTS(state)
-        return
-
-    def __send(self, c):
-        # print("send " + binascii.hexlify(c))
-        self.port.write(c)
-
-    def __recv(self, count=1):
-        c = self.port.read(count)
-        if len(c) < 1:
-            raise RuntimeError("timeout waiting for data (%u bytes)" % count)
-        # print("recv " + binascii.hexlify(c))
-        return c
-
-    def __recv_int(self):
-        raw = self.__recv(4)
-        val = struct.unpack("<I", raw)
-        return val[0]
-
-    def __getSync(self, doFlush=True):
-        if (doFlush):
-            self.port.flush()
-        c = bytes(self.__recv())
-        if c != self.INSYNC:
-            raise RuntimeError("unexpected %s instead of INSYNC" % c)
-        c = self.__recv()
-        if c == self.INVALID:
-            raise RuntimeError("bootloader reports INVALID OPERATION")
-        if c == self.FAILED:
-            raise RuntimeError("bootloader reports OPERATION FAILED")
-        if c != self.OK:
-            raise RuntimeError("unexpected response 0x%x instead of OK" % ord(c))
-
-    # The control flow for receiving Sync is on the order of 16 Ms per Sync
-    # This will validate all the SYNC,<results> for a window of programing
-    # in about 13.81 Ms for 256 blocks written
-    def __ackSyncWindow(self, count):
-        if (count > 0):
-            data =  bytearray(bytes(self.__recv(count)))
-            if (len(data) != count):
-                raise RuntimeError("Ack Window %i not %i " % (len(data), count))
-            for i in range(0, len(data), 2):
-                if bytes([data[i]]) != self.INSYNC:
-                    raise RuntimeError("unexpected %s instead of INSYNC" % data[i])
-                if bytes([data[i+1]]) == self.INVALID:
-                    raise RuntimeError("bootloader reports INVALID OPERATION")
-                if bytes([data[i+1]]) == self.FAILED:
-                    raise RuntimeError("bootloader reports OPERATION FAILED")
-                if bytes([data[i+1]]) != self.OK:
-                    raise RuntimeError("unexpected response 0x%x instead of OK" % ord(data[i+1]))
-
-    # attempt to get back into sync with the bootloader
-    def __sync(self):
-        # send a stream of ignored bytes longer than the longest possible conversation
-        # that we might still have in progress
-        # self.__send(uploader.NOP * (uploader.PROG_MULTI_MAX + 2))
-        self.port.flushInput()
-        self.__send(uploader.GET_SYNC +
-                    uploader.EOC)
-        self.__getSync()
-
-    def __trySync(self):
-        try:
-            self.port.flush()
-            if (self.__recv() != self.INSYNC):
-                # print("unexpected 0x%x instead of INSYNC" % ord(c))
-                return False
-            c = self.__recv()
-            if (c == self.BAD_SILICON_REV):
-                raise NotImplementedError()
-            if (c != self.OK):
-                # print("unexpected 0x%x instead of OK" % ord(c))
-                return False
-            return True
-
-        except NotImplementedError:
-            raise RuntimeError("Programing not supported for this version of silicon!\n"
-                               "See https://docs.px4.io/main/en/flight_controller/silicon_errata.html")
-        except RuntimeError:
-            # timeout, no response yet
-            return False
-
-    # attempt to determins if the device is CDCACM or A FTDI
-    def __determineInterface(self):
-        self.port.flushInput()
-        # Set a baudrate that can not work on a real serial port
-        # in that it is 233% off.
-        try:
-            self.port.baudrate = self.baudrate_bootloader * 2.33
-        except NotImplementedError as e:
-            # This error can occur because pySerial on Windows does not support odd baudrates
-            print(f"{e} -> could not check for FTDI device, assuming USB connection")
-            return
-
-        self.__send(uploader.GET_SYNC +
-                    uploader.EOC)
-        try:
-            self.__getSync(False)
-        except RuntimeError:
-            # if it fails we are on a real serial port - only leave this enabled on Windows
-            if sys.platform.startswith('win'):
-                self.ackWindowedMode = True
-        finally:
-            try:
-                self.port.baudrate = self.baudrate_bootloader
-            except Exception:
-                pass
-
-    # send the GET_DEVICE command and wait for an info parameter
-    def __getInfo(self, param):
-        self.__send(uploader.GET_DEVICE + param + uploader.EOC)
-        value = self.__recv_int()
-        self.__getSync()
-        return value
-
-    # send the GET_OTP command and wait for an info parameter
-    def __getOTP(self, param):
-        t = struct.pack("I", param)  # int param as 32bit ( 4 byte ) char array.
-        self.__send(uploader.GET_OTP + t + uploader.EOC)
-        value = self.__recv(4)
-        self.__getSync()
-        return value
-
-    # send the GET_SN command and wait for an info parameter
-    def __getSN(self, param):
-        t = struct.pack("I", param)  # int param as 32bit ( 4 byte ) char array.
-        self.__send(uploader.GET_SN + t + uploader.EOC)
-        value = self.__recv(4)
-        self.__getSync()
-        return value
-
-    # send the GET_CHIP command
-    def __getCHIP(self):
-        self.__send(uploader.GET_CHIP + uploader.EOC)
-        value = self.__recv_int()
-        self.__getSync()
-        return value
-
-    # send the GET_CHIP command
-    def __getCHIPDes(self):
-        self.__send(uploader.GET_CHIP_DES + uploader.EOC)
-        length = self.__recv_int()
-        value = self.__recv(length)
-        self.__getSync()
-        pieces = value.split(b",")
-        return pieces
-
-    def __getVersion(self):
-        self.__send(uploader.GET_VERSION + uploader.EOC)
-        try:
-            length = self.__recv_int()
-            value = self.__recv(length)
-            self.__getSync()
-        except RuntimeError:
-            # Bootloader doesn't support version call
-            return "unknown"
-        return value.decode()
-
-    def __drawProgressBar(self, label, progress, maxVal):
-        if maxVal < progress:
-            progress = maxVal
-
-        percent = (float(progress) / float(maxVal)) * 100.0
-
-        redraw = "\r" if sys.stdout.isatty() else "\n"
-        sys.stdout.write("%s%s: [%-20s] %.1f%%" % (redraw, label, '='*int(percent/5.0), percent))
-        sys.stdout.flush()
-
-    # send the CHIP_ERASE command and wait for the bootloader to become ready
-    def __erase(self, label):
-        print(f"Windowed mode: {self.ackWindowedMode}")
-        print("\n", end='')
-
-        if self.force_erase:
-            print("Trying force erase of full chip...\n")
-            self.__send(uploader.CHIP_FULL_ERASE +
-                        uploader.EOC)
-        else:
-            self.__send(uploader.CHIP_ERASE +
-                        uploader.EOC)
-
-        # erase is very slow, give it 30s
-        deadline = _time() + 30.0
-        while _time() < deadline:
-
-            usualEraseDuration = 15.0
-            estimatedTimeRemaining = deadline-_time()
-            if estimatedTimeRemaining >= usualEraseDuration:
-                self.__drawProgressBar(label, 30.0-estimatedTimeRemaining, usualEraseDuration)
-            else:
-                self.__drawProgressBar(label, 10.0, 10.0)
-                sys.stdout.write(" (timeout: %d seconds) " % int(deadline-_time()))
-                sys.stdout.flush()
-
-            if self.__trySync():
-                self.__drawProgressBar(label, 10.0, 10.0)
-                if self.force_erase:
-                    print("\nForce erase done.\n")
-                return
-
-        if self.force_erase:
-            raise RuntimeError("timed out waiting for erase, force erase is likely not supported by bootloader!")
-        else:
-            raise RuntimeError("timed out waiting for erase")
-
-    # send a PROG_MULTI command to write a collection of bytes
-    def __program_multi(self, data, windowMode):
-
-        length = len(data).to_bytes(1, byteorder='big')
-
-        self.__send(uploader.PROG_MULTI)
-        self.__send(length)
-        self.__send(data)
-        self.__send(uploader.EOC)
-        if (not windowMode):
-            self.__getSync(False)
-        else:
-            # The following is done to have minimum delay on the transmission
-            # of the ne fw. The per block cost of __getSync was about 16 mS per.
-            # Passively wait on Sync and Result using board rates and
-            # N.B. attempts to activly wait on InWating still carried 8 mS of overhead
-            self.__probe(False)
-            self.__probe(True)
-            time.sleep((ord(length) * self.chartime) + uploader.MAX_FLASH_PRGRAM_TIME)
-            self.__probe(False)
-
-    # verify multiple bytes in flash
-    def __verify_multi(self, data):
-
-        length = len(data).to_bytes(1, byteorder='big')
-
-        self.__send(uploader.READ_MULTI)
-        self.__send(length)
-        self.__send(uploader.EOC)
-        self.port.flush()
-        programmed = self.__recv(len(data))
-        if programmed != data:
-            print("got    " + binascii.hexlify(programmed))
-            print("expect " + binascii.hexlify(data))
-            return False
-        self.__getSync()
-        return True
-
-    # send the reboot command
-    def __reboot(self):
-        self.__send(uploader.REBOOT +
-                    uploader.EOC)
-        self.port.flush()
-
-        # v3+ can report failure if the first word flash fails
-        if self.bl_rev >= 3:
-            self.__getSync()
-
-    # split a sequence into a list of size-constrained pieces
-    def __split_len(self, seq, length):
-        return [seq[i:i+length] for i in range(0, len(seq), length)]
-
-    # upload code
-    def __program(self, label, fw):
-        self.__probe(False)
-        print("\n", end='')
-        code = fw.image
-        groups = self.__split_len(code, uploader.PROG_MULTI_MAX)
-        # Give imedate feedback
-        self.__drawProgressBar(label, 0, len(groups))
-        uploadProgress = 0
-        for bytes in groups:
-            self.__program_multi(bytes, self.ackWindowedMode)
-            # If in Window mode, extend the window size for the __ackSyncWindow
-            if self.ackWindowedMode:
-                self.window += self.window_per
-
-            # Print upload progress (throttled, so it does not delay upload progress)
-            uploadProgress += 1
-            if uploadProgress % 256 == 0:
-                self.__probe(True)
-                self.__probe(False)
-                self.__probe(True)
-                self.__ackSyncWindow(self.window)
-                self.__probe(False)
-                self.window = 0
-                self.__drawProgressBar(label, uploadProgress, len(groups))
-
-        # Do any remaining fragment
-        self.__ackSyncWindow(self.window)
-        self.window = 0
-        self.__drawProgressBar(label, 100, 100)
-
-    # verify code
-    def __verify_v2(self, label, fw):
-        print("\n", end='')
-        self.__send(uploader.CHIP_VERIFY +
-                    uploader.EOC)
-        self.__getSync()
-        code = fw.image
-        groups = self.__split_len(code, uploader.READ_MULTI_MAX)
-        verifyProgress = 0
-        for bytes in groups:
-            verifyProgress += 1
-            if verifyProgress % 256 == 0:
-                self.__drawProgressBar(label, verifyProgress, len(groups))
-            if (not self.__verify_multi(bytes)):
-                raise RuntimeError("Verification failed")
-        self.__drawProgressBar(label, 100, 100)
-
-    def __verify_v3(self, label, fw):
-        print("\n", end='')
-        self.__drawProgressBar(label, 1, 100)
-        expect_crc = fw.crc(self.fw_maxsize)
-        self.__send(uploader.GET_CRC + uploader.EOC)
-        time.sleep(0.5)
-        report_crc = self.__recv_int()
-        self.__getSync()
-        if report_crc != expect_crc:
-            print("Expected 0x%x" % expect_crc)
-            print("Got      0x%x" % report_crc)
-            raise RuntimeError("Program CRC failed")
-        self.__drawProgressBar(label, 100, 100)
-
-    def __set_boot_delay(self, boot_delay):
-        self.__send(uploader.SET_BOOT_DELAY +
-                    struct.pack("b", boot_delay) +
-                    uploader.EOC)
-        self.__getSync()
-
-    # get basic data about the board
-    def identify(self):
-        self.__determineInterface()
-        # make sure we are in sync before starting
-        self.__sync()
-
-        # get the bootloader protocol ID first
-        self.bl_rev = self.__getInfo(uploader.INFO_BL_REV)
-        if (self.bl_rev < uploader.BL_REV_MIN) or (self.bl_rev > uploader.BL_REV_MAX):
-            print("Unsupported bootloader protocol %d" % uploader.INFO_BL_REV)
-            raise RuntimeError("Bootloader protocol mismatch")
-
-        self.board_type = self.__getInfo(uploader.INFO_BOARD_ID)
-        self.board_rev = self.__getInfo(uploader.INFO_BOARD_REV)
-        self.fw_maxsize = self.__getInfo(uploader.INFO_FLASH_SIZE)
-
-        self.version = self.__getVersion()
-
-    # upload the firmware
-    def upload(self, fw_list, force=False, boot_delay=None, boot_check=False, force_erase=False):
-        self.force_erase = force_erase
-        # select correct binary
-        found_suitable_firmware = False
-        for file in fw_list:
-            fw = firmware(file)
-            if self.board_type == fw.property('board_id'):
-                if len(fw_list) > 1: print("using firmware binary {}".format(file))
-                found_suitable_firmware = True
-                break
-
-        if not found_suitable_firmware:
-            msg = "Firmware not suitable for this board (Firmware board_type=%u board_id=%u)" % (
-                self.board_type, fw.property('board_id'))
-            print("WARNING: %s" % msg)
-            if force:
-                if len(fw_list) > 1:
-                    raise FirmwareNotSuitableException("force flashing failed, more than one file provided, none suitable")
-                print("FORCED WRITE, FLASHING ANYWAY!")
-            else:
-                raise FirmwareNotSuitableException(msg)
-
-        percent = fw.property('image_size') / fw.property('image_maxsize')
-        binary_size = float(fw.property('image_size'))
-        binary_max_size = float(fw.property('image_maxsize'))
-        percent = (binary_size / binary_max_size) * 100
-
-        print("Loaded firmware for board id: %s,%s size: %d bytes (%.2f%%) " % (fw.property('board_id'), fw.property('board_revision'), fw.property('image_size'), percent))
-        print()
-
-        print(f"Bootloader version: {self.version}")
-
-        # Make sure we are doing the right thing
-        start = _time()
-        if self.board_type != fw.property('board_id'):
-            msg = "Firmware not suitable for this board (Firmware board_type=%u board_id=%u)" % (
-                self.board_type, fw.property('board_id'))
-            print("WARNING: %s" % msg)
-            if force:
-                print("FORCED WRITE, FLASHING ANYWAY!")
-            else:
-                raise FirmwareNotSuitableException(msg)
-
-        # Prevent uploads where the image would overflow the flash
-        if self.fw_maxsize < fw.property('image_size'):
-            raise RuntimeError("Firmware image is too large for this board")
-
-        # OTP added in v4:
-        if self.bl_rev >= 4:
-            for byte in range(0, 32*6, 4):
-                x = self.__getOTP(byte)
-                self.otp = self.otp + x
-                # print(binascii.hexlify(x).decode('Latin-1') + ' ', end='')
-            # see src/modules/systemlib/otp.h in px4 code:
-            self.otp_id = self.otp[0:4]
-            self.otp_idtype = self.otp[4:5]
-            self.otp_vid = self.otp[8:4:-1]
-            self.otp_pid = self.otp[12:8:-1]
-            self.otp_coa = self.otp[32:160]
-            # show user:
-            try:
-                print("Sn: ", end='')
-                for byte in range(0, 12, 4):
-                    x = self.__getSN(byte)
-                    x = x[::-1]  # reverse the bytes
-                    self.sn = self.sn + x
-                    print(binascii.hexlify(x).decode('Latin-1'), end='')  # show user
-                print('')
-                print("Chip: %08x" % self.__getCHIP())
-
-                otp_id = self.otp_id.decode('Latin-1')
-                if ("PX4" in otp_id):
-                    print("OTP id: " + otp_id)
-                    print("OTP idtype: " + binascii.b2a_qp(self.otp_idtype).decode('Latin-1'))
-                    print("OTP vid: " + binascii.hexlify(self.otp_vid).decode('Latin-1'))
-                    print("OTP pid: " + binascii.hexlify(self.otp_pid).decode('Latin-1'))
-                    print("OTP coa: " + binascii.b2a_base64(self.otp_coa).decode('Latin-1'))
-
-            except Exception as e:
-                # ignore bad character encodings
-                print(f"Exception ignored: {e}")
-                pass
-
-        # Silicon errata check was added in v5
-        if (self.bl_rev >= 5):
-            des = self.__getCHIPDes()
-            if (len(des) == 2):
-                family, revision = des
-                print(f"Family: {family.decode()}")
-                print(f"Revision: {revision.decode()}")
-                print(f"Flash: {self.fw_maxsize} bytes")
-
-                # Prevent uploads where the maximum image size of the board config is smaller than the flash
-                # of the board. This is a hint the user chose the wrong config and will lack features
-                # for this particular board.
-
-                # This check should also check if the revision is an unaffected revision
-                # and thus can support the full flash, see
-                # https://github.com/PX4/Firmware/blob/master/src/drivers/boards/common/stm32/board_mcu_version.c#L125-L144
-
-                if self.fw_maxsize > fw.property('image_maxsize') and not force:
-                    print(f"WARNING: Board can accept larger flash images ({self.fw_maxsize} bytes) than board config ({fw.property('image_maxsize')} bytes)")
-        else:
-            # If we're still on bootloader v4 on a Pixhawk, we don't know if we
-            # have the silicon errata and therefore need to flash px4_fmu-v2
-            # with 1MB flash or if it supports px4_fmu-v3 with 2MB flash.
-            if fw.property('board_id') == 9 \
-                    and fw.property('image_size') > 1032192 \
-                    and not force:
-                raise RuntimeError("\nThe Board uses bootloader revision 4 and can therefore not determine\n"
-                                   "if flashing more than 1 MB (px4_fmu-v3_default) is safe, chances are\n"
-                                   "high that it is not safe! If unsure, use px4_fmu-v2_default.\n"
-                                   "\n"
-                                   "If you know you that the board does not have the silicon errata, use\n"
-                                   "this script with --force, or update the bootloader. If you are invoking\n"
-                                   "upload using make, you can use force-upload target to force the upload.\n")
-        self.__erase("Erase  ")
-        self.__program("Program", fw)
-
-        if self.bl_rev == 2:
-            self.__verify_v2("Verify ", fw)
-        else:
-            self.__verify_v3("Verify ", fw)
-
-        if boot_delay is not None:
-            self.__set_boot_delay(boot_delay)
-
-        print("\nRebooting.", end='')
-        self.__reboot()
-        self.port.close()
-        print(" Elapsed Time %3.3f\n" % (_time() - start))
-
-    def __next_baud_flightstack(self):
-        if self.baudrate_flightstack_idx + 1 >= len(self.baudrate_flightstack):
-            return False
-        try:
-            self.port.baudrate = self.baudrate_flightstack[self.baudrate_flightstack_idx + 1]
-            self.baudrate_flightstack_idx = self.baudrate_flightstack_idx + 1
-        except serial.SerialException:
-            # Sometimes _configure_port fails
-            time.sleep(0.04)
-
-        return True
-
-    def send_protocol_splitter_format(self, data):
-        # Header Structure:
-        #      bits:   1 2 3 4 5 6 7 8
-        # header[0] - |     Magic     | (='S')
-        # header[1] - |T|   LenH      | (T - 0: mavlink; 1: rtps)
-        # header[2] - |     LenL      |
-        # header[3] - |   Checksum    |
-
-        MAGIC = 83
-
-        len_bytes = len(data).to_bytes(2, "big")
-        LEN_H = len_bytes[0] & 127
-        LEN_L = len_bytes[1] & 255
-        CHECKSUM = MAGIC ^ LEN_H ^ LEN_L
-
-        header_ints = [MAGIC, LEN_H, LEN_L, CHECKSUM]
-        header_bytes = struct.pack("{}B".format(len(header_ints)), *header_ints)
-
-        self.__send(header_bytes)
-        self.__send(data)
-
-    def send_reboot(self, use_protocol_splitter_format=False):
-        if (not self.__next_baud_flightstack()):
-            return False
-
-        print("Attempting reboot on %s with baudrate=%d..." % (self.port.port, self.port.baudrate), file=sys.stderr)
-        if "ttyS" in self.port.port:
-            print("If the board does not respond, check the connection to the Flight Controller")
-        else:
-            print("If the board does not respond, unplug and re-plug the USB connector.", file=sys.stderr)
-
-        try:
-            send_fct = self.__send
-            if use_protocol_splitter_format:
-                send_fct = self.send_protocol_splitter_format
-
-            # try MAVLINK command first
-            self.port.flush()
-            send_fct(uploader.MAVLINK_REBOOT_ID1)
-            send_fct(uploader.MAVLINK_REBOOT_ID0)
-            # then try reboot via NSH
-            send_fct(uploader.NSH_INIT)
-            send_fct(uploader.NSH_REBOOT_BL)
-            send_fct(uploader.NSH_INIT)
-            send_fct(uploader.NSH_REBOOT)
-            self.port.flush()
-            self.port.baudrate = self.baudrate_bootloader
-        except Exception:
-            try:
-                self.port.flush()
-                self.port.baudrate = self.baudrate_bootloader
-            except Exception:
-                pass
-
-        return True
-
-
-def main():
-    # Parse commandline arguments
-    parser = argparse.ArgumentParser(description="Firmware uploader for the PX autopilot system.")
-    parser.add_argument('--port', action="store", required=True, help="Comma-separated list of serial port(s) to which the FMU may be attached")
-    parser.add_argument('--baud-bootloader', action="store", type=int, default=115200, help="Baud rate of the serial port (default is 115200) when communicating with bootloader, only required for true serial ports.")
-    parser.add_argument('--baud-flightstack', action="store", default="57600", help="Comma-separated list of baud rate of the serial port (default is 57600) when communicating with flight stack (Mavlink or NSH), only required for true serial ports.")
-    parser.add_argument('--force', action='store_true', default=False, help='Override board type check, or silicon errata checks and continue loading')
-    parser.add_argument('--force-erase', action="store_true", help="Do not perform the blank check, always erase every sector of the application space")
-    parser.add_argument('--boot-delay', type=int, default=None, help='minimum boot delay to store in flash')
-    parser.add_argument('--use-protocol-splitter-format', action='store_true', help='use protocol splitter format for reboot')
-    parser.add_argument('firmware', action="store", nargs='+', help="Firmware file(s)")
-    args = parser.parse_args()
-
-    if args.use_protocol_splitter_format:
-        print("Using protocol splitter format to reboot pixhawk!")
-
-    # warn people about ModemManager which interferes badly with Pixhawk
-    if os.path.exists("/usr/sbin/ModemManager"):
-        print("==========================================================================================================")
-        print("WARNING: You should uninstall ModemManager as it conflicts with any non-modem serial device (like Pixhawk)")
-        print("==========================================================================================================")
-
-    print("Waiting for bootloader...")
-    # tell any GCS that might be connected to the autopilot to give up
-    # control of the serial port
-
-    # send to localhost and default GCS port
-    ipaddr = '127.0.0.1'
-    portnum = 14550
-
-    # COMMAND_LONG in MAVLink 1
-    heartbeatpacket = bytearray.fromhex('fe097001010000000100020c5103033c8a')
-    commandpacket = bytearray.fromhex('fe210101014c00000000000000000000000000000000000000000000803f00000000f6000000008459')
-
-    # initialize an UDP socket
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-
-    # send heartbeat to initialize connection and command to free the link
-    s.sendto(heartbeatpacket, (ipaddr, portnum))
-    s.sendto(commandpacket, (ipaddr, portnum))
-
-    # close the socket
-    s.close()
-
-    # Spin waiting for a device to show up
-    try:
-        while True:
-            portlist = []
-            patterns = args.port.split(",")
-            # on unix-like platforms use glob to support wildcard ports. This allows
-            # the use of /dev/serial/by-id/usb-3D_Robotics on Linux, which prevents the upload from
-            # causing modem hangups etc
-            if "linux" in _platform or "darwin" in _platform or "cygwin" in _platform:
-                import glob
-                for pattern in patterns:
-                    portlist += glob.glob(pattern)
-            else:
-                portlist = patterns
-
-            baud_flightstack = [int(x) for x in args.baud_flightstack.split(',')]
-
-            successful = False
-            unsuitable_board = False
-            for port in portlist:
-
-                # print("Trying %s" % port)
-
-                # create an uploader attached to the port
-                try:
-                    if "linux" in _platform:
-                        # Linux, don't open Mac OS and Win ports
-                        if "COM" not in port and "tty.usb" not in port:
-                            up = uploader(port, args.baud_bootloader, baud_flightstack)
-                    elif "darwin" in _platform:
-                        # OS X, don't open Windows and Linux ports
-                        if "COM" not in port and "ACM" not in port:
-                            up = uploader(port, args.baud_bootloader, baud_flightstack)
-                    elif "cygwin" in _platform:
-                        # Cygwin, don't open native Windows COM and Linux ports
-                        if "COM" not in port and "ACM" not in port:
-                            up = uploader(port, args.baud_bootloader, baud_flightstack)
-                    elif "win" in _platform:
-                        # Windows, don't open POSIX ports
-                        if "/" not in port:
-                            up = uploader(port, args.baud_bootloader, baud_flightstack)
-                except Exception as e:
-                    # open failed, rate-limit our attempts
-                    time.sleep(0.05)
-                    print(f"Exception ignored: {e}")
-
-                    # and loop to the next port
-                    continue
-
-                found_bootloader = False
-                while True:
-                    up.open()
-
-                    # port is open, try talking to it
-                    try:
-                        # identify the bootloader
-                        up.identify()
-                        found_bootloader = True
-                        print()
-                        print(f"Found board id: {up.board_type},{up.board_rev} bootloader protocol revision {up.bl_rev} on {port}")
-                        break
-
-                    except (RuntimeError, serial.SerialException):
-
-                        if not up.send_reboot(args.use_protocol_splitter_format):
-                            break
-
-                        # wait for the reboot, without we might run into Serial I/O Error 5
-                        time.sleep(0.25)
-
-                        # always close the port
-                        up.close()
-
-                        # wait for the close, without we might run into Serial I/O Error 6
-                        time.sleep(0.3)
-
-                if not found_bootloader:
-                    # Go to the next port
-                    continue
-
-                try:
-                    # ok, we have a bootloader, try flashing it
-                    up.upload(args.firmware, force=args.force, boot_delay=args.boot_delay, force_erase=args.force_erase)
-
-                    # if we made this far without raising exceptions, the upload was successful
-                    successful = True
-
-                except RuntimeError as e:
-                    # print the error
-                    print(f"\n\nError: {e}")
-
-                except FirmwareNotSuitableException:
-                    unsuitable_board = True
-                    up.close()
-                    continue
-
-                except IOError:
-                    up.close()
-                    continue
-
-                finally:
-                    # always close the port
-                    up.close()
-
-                # we could loop here if we wanted to wait for more boards...
-                if successful:
-                    sys.exit(0)
-                else:
-                    sys.exit(1)
-
-            if unsuitable_board:
-                # If we land here, we went through all ports, did not flash any
-                # board and found at least one unsuitable board.
-                # Exit with 2, so a caller can distinguish from other errors
-                sys.exit(2)
-
-            # Delay retries to < 20 Hz to prevent spin-lock from hogging the CPU
-            time.sleep(0.05)
-
-    # CTRL+C aborts the upload/spin-lock by interrupt mechanics
-    except KeyboardInterrupt:
-        print("\n Upload aborted by user.")
-        sys.exit(0)
-
-
-if __name__ == '__main__':
-    main()
-
-# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

Tools/setup/ubuntu.sh

@@ -176,8 +176,10 @@ if [[ $INSTALL_NUTTX == "true" ]]; then
 
 		echo
 		echo "Fetching Xtensa compilers"
-		wget -q -P $DIR https://github.com/espressif/crosstool-NG/releases/download/esp-13.2.0_20240530/xtensa-esp-elf-13.2.0_20240530-x86_64-linux-gnu.tar.xz
-		sudo tar -xf $DIR/xtensa-esp-elf-13.2.0_20240530-x86_64-linux-gnu.tar.xz -C /opt
+		XTENSA_FILE_NAME=xtensa-esp-elf-13.2.0_20240530-x86_64-linux-gnu.tar.xz
+		wget -q -P $DIR https://github.com/espressif/crosstool-NG/releases/download/esp-13.2.0_20240530/$XTENSA_FILE_NAME
+		sudo tar -xf $DIR/$XTENSA_FILE_NAME -C /opt
+		rm $DIR/$XTENSA_FILE_NAME
 		echo 'export PATH=$PATH:/opt/xtensa-esp-elf/bin/' >> /home/$USER/.bashrc
 	fi
 

Tools/simulation/gazebo-classic/sitl_gazebo-classic

@@ -1 +1 @@
-Subproject commit 6697ab169ceab512dc706acea63df4c882662c60
+Subproject commit 5b6966ed572a02e8273f446acb504a45a841ca53

Tools/simulation/gz

@@ -1 +1 @@
-Subproject commit e34154fd1d38fc2a9d50db264870cd2a9a6039a9
+Subproject commit fe3fe236e36a3ed5bce01a7501347d20a466c407

Tools/simulation/jmavsim/jMAVSim

@@ -1 +1 @@
-Subproject commit 66b764ada522893c05224950aa6268c809f8e48a
+Subproject commit 665b26d62d36a33b6bf01c5931c589beb812c6a2

boards/3dr/ctrl-zero-h7-oem-revg/default.px4board

@@ -21,7 +21,6 @@ CONFIG_DRIVERS_IMU_INVENSENSE_ICM20948=y
 CONFIG_DRIVERS_IRLOCK=y
 CONFIG_COMMON_LIGHT=y
 CONFIG_COMMON_MAGNETOMETER=y
-CONFIG_COMMON_OPTICAL_FLOW=y
 CONFIG_DRIVERS_PCA9685_PWM_OUT=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_PWM_OUT=y

boards/3dr/ctrl-zero-h7-oem-revg/nuttx-config/scripts/script.ld

@@ -132,7 +132,6 @@ ENTRY(_stext)
  */
 EXTERN(abort)
 EXTERN(_bootdelay_signature)
-EXTERN(board_get_manifest)
 
 SECTIONS
 {

boards/3dr/ctrl-zero-h7-oem-revg/src/CMakeLists.txt

@@ -48,7 +48,6 @@ else()
 		i2c.cpp
 		init.c
 		led.c
-		mtd.cpp
 		spi.cpp
 		timer_config.cpp
 		usb.c

boards/accton-godwit/ga1/default.px4board

@@ -34,7 +34,6 @@ CONFIG_DRIVERS_OSD_MSP_OSD=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_POWER_MONITOR_INA228=y
 CONFIG_DRIVERS_POWER_MONITOR_INA238=y
-CONFIG_DRIVERS_POWER_MONITOR_PM_SELECTOR_AUTERION=y
 CONFIG_DRIVERS_PWM_OUT=y
 CONFIG_DRIVERS_PX4IO=y
 CONFIG_DRIVERS_RC_INPUT=y
@@ -67,7 +66,6 @@ CONFIG_MODULES_LOGGER=y
 CONFIG_MODULES_MAG_BIAS_ESTIMATOR=y
 CONFIG_MODULES_MANUAL_CONTROL=y
 CONFIG_MODULES_MAVLINK=y
-CONFIG_MAVLINK_DIALECT="development"
 CONFIG_MODULES_MC_ATT_CONTROL=y
 CONFIG_MODULES_MC_AUTOTUNE_ATTITUDE_CONTROL=y
 CONFIG_MODULES_MC_HOVER_THRUST_ESTIMATOR=y

boards/accton-godwit/ga1/init/rc.board_defaults

@@ -3,19 +3,13 @@
 # board specific defaults
 #------------------------------------------------------------------------------
 
-# By disabling all 3 INA modules, we use the
-# i2c_launcher instead.
-param set - default SENS_EN_INA238 0
-param set - default SENS_EN_INA228 0
-param set - default SENS_EN_INA226 0
-
 # Mavlink ethernet (CFG 1000)
-param set - default MAV_2_CONFIG 1000
-param set - default MAV_2_BROADCAST 1
-param set - default MAV_2_MODE 0
-param set - default MAV_2_RADIO_CTL 0
-param set - default MAV_2_RATE 100000
-param set - default MAV_2_REMOTE_PRT 14550
-param set - default MAV_2_UDP_PRT 14550
+param set-default MAV_2_CONFIG 1000
+param set-default MAV_2_BROADCAST 1
+param set-default MAV_2_MODE 0
+param set-default MAV_2_RADIO_CTL 0
+param set-default MAV_2_RATE 100000
+param set-default MAV_2_REMOTE_PRT 14550
+param set-default MAV_2_UDP_PRT 14550
 
 safety_button start

boards/accton-godwit/ga1/src/CMakeLists.txt

@@ -71,6 +71,5 @@ else()
 			nuttx_arch # sdio
 			nuttx_drivers # sdio
 			px4_layer
-			platform_gpio_mcp23009
 	)
 endif()

boards/accton-godwit/ga1/src/init.cpp

@@ -74,7 +74,6 @@
 #include <px4_platform/gpio.h>
 #include <px4_platform/board_determine_hw_info.h>
 #include <px4_platform/board_dma_alloc.h>
-#include <px4_platform/gpio/mcp23009.hpp>
 
 /****************************************************************************
  * Pre-Processor Definitions
@@ -286,13 +285,6 @@ __EXPORT int board_app_initialize(uintptr_t arg)
 
 #  endif /* CONFIG_MMCSD */
 
-	ret = mcp23009_register_gpios(3, 0x25);
-
-	if (ret != OK) {
-		led_on(LED_RED);
-		return ret;
-	}
-
 #endif /* !defined(BOOTLOADER) */
 
 	return OK;

boards/airmind/mindpx-v2/default.px4board

@@ -22,7 +22,6 @@ CONFIG_DRIVERS_IMU_ST_LSM303D=y
 CONFIG_DRIVERS_IRLOCK=y
 CONFIG_COMMON_LIGHT=y
 CONFIG_COMMON_MAGNETOMETER=y
-CONFIG_COMMON_OPTICAL_FLOW=y
 CONFIG_DRIVERS_PCA9685_PWM_OUT=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_PWM_INPUT=y

boards/ark/can-gps/src/board_config.h

@@ -47,7 +47,7 @@
 #define GPIO_BTN_SAFETY       /* PB15 */ (GPIO_INPUT|GPIO_PULLDOWN|GPIO_PORTB|GPIO_PIN15)
 
 /* Safety LED */
-#define GPIO_LED_SAFETY       /* PA1  */ (GPIO_OUTPUT|GPIO_PUSHPULL|GPIO_SPEED_2MHz|GPIO_OUTPUT_SET|GPIO_PORTA|GPIO_PIN1)
+#define GPIO_LED_SAFETY       /* PA1  */ (GPIO_OUTPUT|GPIO_OPENDRAIN|GPIO_SPEED_2MHz|GPIO_OUTPUT_SET|GPIO_PORTA|GPIO_PIN1)
 
 /* Tone alarm output. */
 #define TONE_ALARM_TIMER             2    /* timer 2 */

boards/ark/cannode/default.px4board

@@ -31,6 +31,7 @@ CONFIG_UAVCANNODE_ESC_RAW_COMMAND=y
 CONFIG_UAVCANNODE_ESC_STATUS=y
 CONFIG_UAVCANNODE_FLOW_MEASUREMENT=y
 CONFIG_UAVCANNODE_GNSS_FIX=y
+CONFIG_UAVCANNODE_HARDPOINT_COMMAND=y
 CONFIG_UAVCANNODE_HYGROMETER_MEASUREMENT=y
 CONFIG_UAVCANNODE_LIGHTS_COMMAND=y
 CONFIG_UAVCANNODE_MAGNETIC_FIELD_STRENGTH=y

boards/ark/fmu-v6x/default.px4board

@@ -28,18 +28,12 @@ CONFIG_DRIVERS_IMU_INVENSENSE_IIM42653=y
 CONFIG_DRIVERS_IMU_MURATA_SCH16T=y
 CONFIG_COMMON_LIGHT=y
 CONFIG_DRIVERS_MAGNETOMETER_BOSCH_BMM150=y
-CONFIG_DRIVERS_MAGNETOMETER_HMC5883=y
-CONFIG_DRIVERS_MAGNETOMETER_QMC5883L=y
-CONFIG_DRIVERS_MAGNETOMETER_ISENTEK_IST8308=y
-CONFIG_DRIVERS_MAGNETOMETER_ISENTEK_IST8310=y
 CONFIG_DRIVERS_MAGNETOMETER_LIS3MDL=y
-CONFIG_DRIVERS_MAGNETOMETER_LSM303AGR=y
 CONFIG_DRIVERS_MAGNETOMETER_RM3100=y
-CONFIG_DRIVERS_MAGNETOMETER_MEMSIC_MMC5983MA=y
 CONFIG_DRIVERS_MAGNETOMETER_ST_IIS2MDC=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
-CONFIG_DRIVERS_POWER_MONITOR_INA228=y
 CONFIG_DRIVERS_POWER_MONITOR_INA238=y
+CONFIG_DRIVERS_PCA9685_PWM_OUT=y
 CONFIG_DRIVERS_PWM_OUT=y
 CONFIG_DRIVERS_PX4IO=y
 CONFIG_COMMON_RC=y
@@ -72,7 +66,6 @@ CONFIG_MODULES_LOGGER=y
 CONFIG_MODULES_MAG_BIAS_ESTIMATOR=y
 CONFIG_MODULES_MANUAL_CONTROL=y
 CONFIG_MODULES_MAVLINK=y
-CONFIG_MAVLINK_DIALECT="development"
 CONFIG_MODULES_MC_ATT_CONTROL=y
 CONFIG_MODULES_MC_AUTOTUNE_ATTITUDE_CONTROL=y
 CONFIG_MODULES_MC_HOVER_THRUST_ESTIMATOR=y

boards/ark/fmu-v6x/init/rc.board_defaults

@@ -14,10 +14,7 @@ param set-default MAV_2_RATE 100000
 param set-default MAV_2_REMOTE_PRT 14550
 param set-default MAV_2_UDP_PRT 14550
 
-param set-default SENS_EN_INA238 0
-param set-default SENS_EN_INA228 0
 param set-default SENS_EN_INA226 1
-
 param set-default SENS_EN_THERMAL 1
 param set-default SENS_IMU_MODE 1
 param set-default SENS_IMU_TEMP 10.0

boards/ark/fmu-v6x/init/rc.board_sensors

@@ -97,5 +97,11 @@ bmm150 -I start
 # Internal Baro on I2C
 bmp388 -I start
 
+# Start an external PWM generator
+if param greater PCA9685_EN_BUS 0
+then
+	pca9685_pwm_out start
+fi
+
 unset HAVE_PM2
 unset HAVE_PM3

boards/ark/fmu-v6x/src/board_config.h

@@ -419,9 +419,6 @@
 /* This board provides a DMA pool and APIs */
 #define BOARD_DMA_ALLOC_POOL_SIZE 5120
 
-/* This board has 4 DMA channels available for bidirectional dshot */
-#define BOARD_DMA_NUM_DSHOT_CHANNELS 4
-
 /* This board provides the board_on_reset interface */
 
 #define BOARD_HAS_ON_RESET 1

boards/ark/fpv/default.px4board

@@ -14,13 +14,23 @@ CONFIG_DRIVERS_CDCACM_AUTOSTART=y
 CONFIG_COMMON_DIFFERENTIAL_PRESSURE=y
 CONFIG_COMMON_DISTANCE_SENSOR=y
 CONFIG_DRIVERS_DSHOT=y
+CONFIG_DSHOT_BITBANG=y
 CONFIG_DRIVERS_GPS=y
 CONFIG_DRIVERS_HEATER=y
 CONFIG_DRIVERS_IMU_INVENSENSE_IIM42653=y
 CONFIG_DRIVERS_IMU_MURATA_SCH16T=y
 CONFIG_COMMON_LIGHT=y
-CONFIG_COMMON_MAGNETOMETER=y
+CONFIG_DRIVERS_MAGNETOMETER_BOSCH_BMM150=y
+CONFIG_DRIVERS_MAGNETOMETER_HMC5883=y
+CONFIG_DRIVERS_MAGNETOMETER_QMC5883L=y
+CONFIG_DRIVERS_MAGNETOMETER_ISENTEK_IST8308=y
+CONFIG_DRIVERS_MAGNETOMETER_ISENTEK_IST8310=y
+CONFIG_DRIVERS_MAGNETOMETER_LIS3MDL=y
+CONFIG_DRIVERS_MAGNETOMETER_LSM303AGR=y
+CONFIG_DRIVERS_MAGNETOMETER_RM3100=y
+CONFIG_DRIVERS_MAGNETOMETER_ST_IIS2MDC=y
 CONFIG_DRIVERS_OSD_MSP_OSD=y
+CONFIG_DRIVERS_PCA9685_PWM_OUT=y
 CONFIG_DRIVERS_PWM_OUT=y
 CONFIG_COMMON_RC=y
 CONFIG_DRIVERS_UAVCAN=y

boards/ark/fpv/init/rc.board_airframes

@@ -0,0 +1,18 @@
+4001_quad_x
+4050_generic_250
+6001_hexa_x
+12001_octo_cox
+13100_generic_vtol_tiltrotor
+5001_quad_+
+24001_dodeca_cox
+2100_standard_plane
+13000_generic_vtol_standard
+4601_droneblocks_dexi_5
+11001_hexa_cox
+14001_generic_mc_with_tilt
+16001_helicopter
+9001_octo_+
+7001_hexa_+
+3000_generic_wing
+13200_generic_vtol_tailsitter
+13030_generic_vtol_quad_tiltrotor

boards/ark/fpv/init/rc.board_sensors

@@ -16,3 +16,9 @@ iis2mdc -R 0 -I -b 4 start
 
 # Internal Baro on I2C
 bmp388 -I -b 2 start
+
+# Start an external PWM generator
+if param greater PCA9685_EN_BUS 0
+then
+	pca9685_pwm_out start
+fi

boards/ark/fpv/src/board_config.h

@@ -307,9 +307,6 @@
 /* This board provides a DMA pool and APIs */
 #define BOARD_DMA_ALLOC_POOL_SIZE 5120
 
-/* This board has 3 DMA channels available for bidirectional dshot */
-#define BOARD_DMA_NUM_DSHOT_CHANNELS 3
-
 /* This board provides the board_on_reset interface */
 
 #define BOARD_HAS_ON_RESET 1

boards/ark/pi6x/default.px4board

@@ -19,6 +19,7 @@ CONFIG_COMMON_LIGHT=y
 CONFIG_DRIVERS_MAGNETOMETER_MEMSIC_MMC5983MA=y
 CONFIG_DRIVERS_MAGNETOMETER_ST_IIS2MDC=y
 CONFIG_DRIVERS_OPTICAL_FLOW_PAW3902=y
+CONFIG_DRIVERS_PCA9685_PWM_OUT=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_PWM_OUT=y
 CONFIG_COMMON_RC=y
@@ -41,7 +42,6 @@ CONFIG_MODULES_LOGGER=y
 CONFIG_MODULES_MAG_BIAS_ESTIMATOR=y
 CONFIG_MODULES_MANUAL_CONTROL=y
 CONFIG_MODULES_MAVLINK=y
-CONFIG_MAVLINK_DIALECT="development"
 CONFIG_MODULES_MC_ATT_CONTROL=y
 CONFIG_MODULES_MC_AUTOTUNE_ATTITUDE_CONTROL=y
 CONFIG_MODULES_MC_HOVER_THRUST_ESTIMATOR=y

boards/ark/pi6x/init/rc.board_sensors

@@ -34,3 +34,9 @@ paw3902 -s -b 3 start -Y 90
 
 # Internal distance sensor
 afbrs50 start
+
+# Start an external PWM generator
+if param greater PCA9685_EN_BUS 0
+then
+	pca9685_pwm_out start
+fi

boards/ark/pi6x/rover.px4board

@@ -0,0 +1,17 @@
+CONFIG_MODULES_AIRSPEED_SELECTOR=n
+CONFIG_MODULES_FLIGHT_MODE_MANAGER=n
+CONFIG_MODULES_FW_ATT_CONTROL=n
+CONFIG_MODULES_FW_AUTOTUNE_ATTITUDE_CONTROL=n
+CONFIG_MODULES_FW_MODE_MANAGER=n
+CONFIG_MODULES_FW_LATERAL_LONGITUDINAL_CONTROL=n
+CONFIG_MODULES_FW_RATE_CONTROL=n
+CONFIG_MODULES_MC_ATT_CONTROL=n
+CONFIG_MODULES_MC_AUTOTUNE_ATTITUDE_CONTROL=n
+CONFIG_MODULES_MC_HOVER_THRUST_ESTIMATOR=n
+CONFIG_MODULES_MC_POS_CONTROL=n
+CONFIG_MODULES_MC_RATE_CONTROL=n
+CONFIG_MODULES_VTOL_ATT_CONTROL=n
+CONFIG_DRIVERS_ROBOCLAW=y
+CONFIG_MODULES_ROVER_ACKERMANN=y
+CONFIG_MODULES_ROVER_DIFFERENTIAL=y
+CONFIG_MODULES_ROVER_MECANUM=y

boards/ark/pi6x/src/board_config.h

@@ -309,9 +309,6 @@
 /* This board provides a DMA pool and APIs */
 #define BOARD_DMA_ALLOC_POOL_SIZE 5120
 
-/* This board has 4 DMA channels available for bidirectional dshot */
-#define BOARD_DMA_NUM_DSHOT_CHANNELS 4
-
 /* This board provides the board_on_reset interface */
 
 #define BOARD_HAS_ON_RESET 1

boards/auterion/fmu-v6s/default.px4board

@@ -14,6 +14,9 @@ CONFIG_COMMON_DISTANCE_SENSOR=y
 CONFIG_DRIVERS_DSHOT=y
 CONFIG_DRIVERS_GNSS_SEPTENTRIO=y
 CONFIG_DRIVERS_GPS=y
+CONFIG_DRIVERS_PPS_CAPTURE=y
+CONFIG_DRIVERS_VTX=y
+CONFIG_VTX_CRSF_MSP_SUPPORT=y
 CONFIG_DRIVERS_IMU_BOSCH_BMI088=y
 CONFIG_BMI088_ACCELEROMETER_INT2=y
 CONFIG_COMMON_LIGHT=y
@@ -21,11 +24,11 @@ CONFIG_COMMON_MAGNETOMETER=y
 CONFIG_DATAMAN_PERSISTENT_STORAGE=n
 CONFIG_DRIVERS_PWM_OUT=y
 CONFIG_COMMON_RC=y
+CONFIG_DRIVERS_AUTERION_AUTOSTARTER=y
 CONFIG_DRIVERS_PCA9685_PWM_OUT=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_POWER_MONITOR_INA228=y
 CONFIG_DRIVERS_POWER_MONITOR_INA238=y
-CONFIG_DRIVERS_ROBOCLAW=y
 CONFIG_DRIVERS_UAVCAN=y
 CONFIG_BOARD_UAVCAN_INTERFACES=1
 CONFIG_BOARD_UAVCAN_TIMER_OVERRIDE=2
@@ -57,7 +60,6 @@ CONFIG_LOGGER_STACK_SIZE=4100
 CONFIG_MODULES_MAG_BIAS_ESTIMATOR=y
 CONFIG_MODULES_MANUAL_CONTROL=y
 CONFIG_MODULES_MAVLINK=y
-CONFIG_MAVLINK_DIALECT="development"
 CONFIG_MODULES_MC_ATT_CONTROL=y
 CONFIG_MODULES_MC_AUTOTUNE_ATTITUDE_CONTROL=y
 CONFIG_MODULES_MC_HOVER_THRUST_ESTIMATOR=y
@@ -66,9 +68,6 @@ CONFIG_MODULES_MC_RATE_CONTROL=y
 CONFIG_MODULES_NAVIGATOR=y
 CONFIG_MODE_NAVIGATOR_VTOL_TAKEOFF=y
 CONFIG_MODULES_RC_UPDATE=y
-CONFIG_MODULES_ROVER_ACKERMANN=y
-CONFIG_MODULES_ROVER_DIFFERENTIAL=y
-CONFIG_MODULES_ROVER_MECANUM=y
 CONFIG_MODULES_SENSORS=y
 CONFIG_MODULES_SIMULATION_SIMULATOR_SIH=y
 CONFIG_MODULES_TIME_PERSISTOR=y
@@ -77,9 +76,7 @@ CONFIG_MODULES_VTOL_ATT_CONTROL=y
 CONFIG_SYSTEMCMDS_ACTUATOR_TEST=y
 CONFIG_SYSTEMCMDS_BSONDUMP=y
 CONFIG_SYSTEMCMDS_DMESG=y
-CONFIG_SYSTEMCMDS_GPIO=y
 CONFIG_SYSTEMCMDS_HARDFAULT_LOG=y
-CONFIG_SYSTEMCMDS_I2C_LAUNCHER=y
 CONFIG_SYSTEMCMDS_I2CDETECT=y
 CONFIG_SYSTEMCMDS_LED_CONTROL=y
 CONFIG_SYSTEMCMDS_MFT=y
@@ -91,11 +88,10 @@ CONFIG_SYSTEMCMDS_PARAM=y
 CONFIG_SYSTEMCMDS_PERF=y
 CONFIG_SYSTEMCMDS_REBOOT=y
 CONFIG_SYSTEMCMDS_SD_BENCH=y
-CONFIG_SYSTEMCMDS_SD_STRESS=y
-CONFIG_SYSTEMCMDS_SERIAL_TEST=y
 CONFIG_SYSTEMCMDS_SYSTEM_TIME=y
 CONFIG_SYSTEMCMDS_TOP=y
 CONFIG_SYSTEMCMDS_TOPIC_LISTENER=y
 CONFIG_SYSTEMCMDS_UORB=y
 CONFIG_SYSTEMCMDS_VER=y
 CONFIG_SYSTEMCMDS_WORK_QUEUE=y
+CONFIG_WQ_TTY_STACKSIZE=2500

boards/auterion/fmu-v6s/init/rc.board_defaults

@@ -3,12 +3,6 @@
 # board specific defaults
 #------------------------------------------------------------------------------
 
-# By disabling INA modules, we use the
-# i2c_launcher instead.
-param set-default SENS_EN_INA226 0
-param set-default SENS_EN_INA228 0
-param set-default SENS_EN_INA238 0
-
 # Set the backend of the dataman to SRAM
 param set-default SYS_DM_BACKEND 1
 # Set TELEM1 as default mavlink connection
@@ -19,6 +13,13 @@ param set-default SDLOG_BACKEND 2
 # 200kOhm/10kOhm voltage divider on V_BAT
 param set-default BAT1_V_DIV 21
 
+# Uncomment to use PWM9 as Analog input
+# param set-default PWM_MAIN_TIM2 -2
+
+# Uncomment to use PWM10 as PPS input
+# param set-default PWM_MAIN_TIM3 -2
+# param set-default PWM_MAIN_FUNC10 2064
+
 # Skynode: use the "custom participant", IP=10.41.10.1 config for uxrce_dds_client
 param set-default UXRCE_DDS_PTCFG 2
 param set-default UXRCE_DDS_AG_IP 170461697

boards/auterion/fmu-v6s/init/rc.board_sensors

@@ -60,6 +60,9 @@ then
 	set INA_CONFIGURED yes
 fi
 
+# Auterion auto starter
+auterion_autostarter start
+
 if param compare BAT1_V_CHANNEL -2
 then
 	if [ "$INA_CONFIGURED" != "yes" ]
@@ -74,5 +77,5 @@ ist8310 -X -b 1 -R 10 start
 # Start an external PWM generator
 if param greater PCA9685_EN_BUS 0
 then
-	pca9685_pwm_out start -b 1
+	pca9685_pwm_out start
 fi

boards/auterion/fmu-v6s/nuttx-config/nsh/defconfig

@@ -160,7 +160,7 @@ CONFIG_NSH_BUILTIN_APPS=y
 CONFIG_NSH_CMDPARMS=y
 CONFIG_NSH_CROMFSETC=y
 CONFIG_NSH_LINELEN=128
-CONFIG_NSH_MAXARGUMENTS=15
+CONFIG_NSH_MAXARGUMENTS=24
 CONFIG_NSH_NESTDEPTH=8
 CONFIG_NSH_QUOTE=y
 CONFIG_NSH_ROMFSETC=y
@@ -238,9 +238,12 @@ CONFIG_STM32H7_SPI3_DMA_BUFFER=1024
 CONFIG_STM32H7_SPI4=y
 CONFIG_STM32H7_SPI4_DMA=y
 CONFIG_STM32H7_SPI4_DMA_BUFFER=4096
-CONFIG_STM32H7_TIM12=y
 CONFIG_STM32H7_TIM1=y
+CONFIG_STM32H7_TIM2=y
 CONFIG_STM32H7_TIM3=y
+CONFIG_STM32H7_TIM4=y
+CONFIG_STM32H7_TIM5=y
+CONFIG_STM32H7_TIM8=y
 CONFIG_STM32H7_UART4=y
 CONFIG_STM32H7_UART5=y
 CONFIG_STM32H7_UART7=y

boards/auterion/fmu-v6s/src/board_config.h

@@ -135,15 +135,14 @@
 
 
 /* PWM Timers */
-#define BOARD_NUM_IO_TIMERS 2
-#define DIRECT_PWM_OUTPUT_CHANNELS   8
+/* 3 for PWM outputs, 1 for input capture */
+#define BOARD_NUM_IO_TIMERS 4
+/* 9 for PWM outputs, 1 for input capture */
+#define DIRECT_PWM_OUTPUT_CHANNELS 10
 
 /* High-resolution timer */
-#define HRT_TIMER               8  /* use timer8 for the HRT */
-#define HRT_TIMER_CHANNEL       3  /* use capture/compare channel 3 */
-
-#define HRT_PPM_CHANNEL         /* T8C2 */  2  /* use capture/compare channel 1 */
-#define GPIO_PPM_IN             /* PC7  */ GPIO_TIM8_CH2IN_1
+#define HRT_TIMER               4  /* use timer4 for the HRT */
+#define HRT_TIMER_CHANNEL       1  /* use capture/compare channel 1 */
 
 /* This board provides a DMA pool and APIs */
 #define BOARD_DMA_ALLOC_POOL_SIZE 5120

boards/auterion/fmu-v6s/src/timer_config.cpp

@@ -44,11 +44,17 @@
  * TIM3_CH2  T FMU_CH6
  * TIM3_CH3  T FMU_CH7
  * TIM3_CH4  T FMU_CH8
+ *
+ * TIM5_CH1  T FMU_CH9
+ *
+ * TIM8_CH2  T FMU_CAP1 < Input Capture
  */
 
 constexpr io_timers_t io_timers[MAX_IO_TIMERS] = {
 	initIOTimer(Timer::Timer1, DMA{DMA::Index1}),
 	initIOTimer(Timer::Timer3, DMA{DMA::Index1}),
+	initIOTimer(Timer::Timer5),
+	initIOTimer(Timer::Timer8),
 };
 
 constexpr timer_io_channels_t timer_io_channels[MAX_TIMER_IO_CHANNELS] = {
@@ -60,6 +66,8 @@ constexpr timer_io_channels_t timer_io_channels[MAX_TIMER_IO_CHANNELS] = {
 	initIOTimerChannel(io_timers, {Timer::Timer3, Timer::Channel2}, {GPIO::PortB, GPIO::Pin5}),
 	initIOTimerChannel(io_timers, {Timer::Timer3, Timer::Channel3}, {GPIO::PortB, GPIO::Pin0}),
 	initIOTimerChannel(io_timers, {Timer::Timer3, Timer::Channel4}, {GPIO::PortC, GPIO::Pin9}),
+	initIOTimerChannel(io_timers, {Timer::Timer5, Timer::Channel1}, {GPIO::PortA, GPIO::Pin0}),
+	initIOTimerChannelCapture(io_timers, {Timer::Timer8, Timer::Channel2}, {GPIO::PortC, GPIO::Pin7}),
 };
 
 constexpr io_timers_channel_mapping_t io_timers_channel_mapping =

boards/auterion/fmu-v6x/default.px4board

@@ -20,15 +20,16 @@ CONFIG_DRIVERS_DSHOT=y
 CONFIG_DRIVERS_GNSS_SEPTENTRIO=y
 CONFIG_DRIVERS_GPIO_MCP23009=y
 CONFIG_DRIVERS_GPS=y
+CONFIG_DRIVERS_PPS_CAPTURE=y
 CONFIG_DRIVERS_IMU_BOSCH_BMI088=y
 CONFIG_DRIVERS_IMU_INVENSENSE_ICM20602=y
 CONFIG_DRIVERS_IMU_INVENSENSE_ICM42688P=y
 CONFIG_COMMON_LIGHT=y
 CONFIG_COMMON_MAGNETOMETER=y
+CONFIG_DRIVERS_AUTERION_AUTOSTARTER=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_POWER_MONITOR_INA228=y
 CONFIG_DRIVERS_POWER_MONITOR_INA238=y
-CONFIG_DRIVERS_POWER_MONITOR_PM_SELECTOR_AUTERION=y
 CONFIG_DRIVERS_PWM_INPUT=y
 CONFIG_DRIVERS_PWM_OUT=y
 CONFIG_DRIVERS_PX4IO=y

boards/auterion/fmu-v6x/init/rc.board_defaults

@@ -3,12 +3,6 @@
 # board specific defaults
 #------------------------------------------------------------------------------
 
-# By disabling all 3 INA modules, we use the
-# i2c_launcher instead.
-param set-default SENS_EN_INA238 0
-param set-default SENS_EN_INA228 0
-param set-default SENS_EN_INA226 0
-
 # Skynode: use the "custom participant", IP=10.41.10.1 config for uxrce_dds_client
 param set-default UXRCE_DDS_PTCFG 2
 param set-default UXRCE_DDS_AG_IP 170461697
@@ -26,9 +20,9 @@ safety_button start
 if ver hwbasecmp 009 010 011
 then
 	# No USB
-	mcp23009 start -b 3 -X -D 0xf0 -O 0xf0 -P 0x0f -U 10
+	mcp23009 start -b 3 -X -D 0xf0 -O 0xf0 -P 0x0f -M 0 -U 10
 fi
 if ver hwbasecmp 00a 008
 then
-	mcp23009 start -b 3 -X -D 0xf1 -O 0xf0 -P 0x0f -U 10
+	mcp23009 start -b 3 -X -D 0xf1 -O 0xf0 -P 0x0f -M 0 -U 10
 fi

boards/auterion/fmu-v6x/init/rc.board_sensors

@@ -55,8 +55,8 @@ then
 	set INA_CONFIGURED yes
 fi
 
-#Start Auterion Power Module selector for Skynode boards
-pm_selector_auterion start
+# Auterion auto starter
+auterion_autostarter start
 
 # Auterion's INA238 uses a shunt value of 0.0003 instead of 0.0005.
 param set-default INA238_SHUNT 0.0003
@@ -86,8 +86,5 @@ fi
 #external baro
 bmp388 -X start
 
-# Don't try to start external baro on I2C3 as it can conflict with the MS5525DSO airspeed sensor.
-#ms5611 -X start
-
 unset INA_CONFIGURED
 unset HAVE_PM2

boards/auterion/fmu-v6x/src/CMakeLists.txt

@@ -69,6 +69,6 @@ else()
 			nuttx_arch # sdio
 			nuttx_drivers # sdio
 			px4_layer
-			platform_gpio_mcp23009
+			platform_gpio_mcp
 	)
 endif()

boards/auterion/fmu-v6x/src/board_config.h

@@ -471,7 +471,7 @@
 #define PX4_I2C_BUS_MTD      4,5
 
 
-#define BOARD_NUM_IO_TIMERS 5
+#define BOARD_NUM_IO_TIMERS 4
 
 /* No CDCACM driver for this board, so this is manually defined for version.c
  * so that the px4_board_version reports the correct board id to the companion */

boards/auterion/fmu-v6x/src/init.cpp

@@ -74,7 +74,6 @@
 #include <px4_platform/gpio.h>
 #include <px4_platform/board_determine_hw_info.h>
 #include <px4_platform/board_dma_alloc.h>
-#include <px4_platform/gpio/mcp23009.hpp>
 
 /****************************************************************************
  * Pre-Processor Definitions
@@ -282,13 +281,6 @@ __EXPORT int board_app_initialize(uintptr_t arg)
 
 #  endif /* CONFIG_MMCSD */
 
-	ret = mcp23009_register_gpios(3, 0x25);
-
-	if (ret != OK) {
-		led_on(LED_RED);
-		return ret;
-	}
-
 #endif /* !defined(BOOTLOADER) */
 
 	return OK;

boards/auterion/fmu-v6x/src/timer_config.cpp

@@ -50,8 +50,6 @@
  * TIM1_CH3  T SPI2_DRDY2_ISM330_INT2 < Capture or GPIO INT
  * TIM1_CH1  T SPIX_SYNC              > Pulse or GPIO strobe
  *
- * TIM2_CH3  T HEATER                 > PWM OUT or GPIO
- *
  * TIM14_CH1 T BUZZER_1              - Driven by other driver
  * TIM8_CH1_IN T FMU_PPM_INPUT       - Sampled byt HRT by other driver
  */
@@ -61,7 +59,6 @@ constexpr io_timers_t io_timers[MAX_IO_TIMERS] = {
 	initIOTimer(Timer::Timer4, DMA{DMA::Index1}),
 	initIOTimer(Timer::Timer12),
 	initIOTimer(Timer::Timer1),
-	initIOTimer(Timer::Timer2),
 };
 
 constexpr timer_io_channels_t timer_io_channels[MAX_TIMER_IO_CHANNELS] = {

boards/auterion/fmu-v6x/zenoh.px4board

@@ -1,4 +1,6 @@
 # CONFIG_BOARD_UAVCAN_TIMER_OVERRIDE is not set
 CONFIG_DRIVERS_UAVCAN=n
 CONFIG_MODULES_UXRCE_DDS_CLIENT=n
+CONFIG_SYSTEMCMDS_SD_BENCH=n
+CONFIG_SYSTEMCMDS_I2CDETECT=n
 CONFIG_MODULES_ZENOH=y

boards/av/x-v1/default.px4board

@@ -21,7 +21,6 @@ CONFIG_DRIVERS_IMU_INVENSENSE_ICM20948=y
 CONFIG_DRIVERS_IRLOCK=y
 CONFIG_COMMON_LIGHT=y
 CONFIG_COMMON_MAGNETOMETER=y
-CONFIG_COMMON_OPTICAL_FLOW=y
 CONFIG_DRIVERS_PCA9685_PWM_OUT=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_PWM_OUT=y

boards/beaglebone/blue/default.px4board

@@ -14,6 +14,7 @@ CONFIG_DRIVERS_GPS=y
 CONFIG_DRIVERS_IMU_ANALOG_DEVICES_ADIS16448=y
 CONFIG_DRIVERS_IMU_INVENSENSE_ICM20948=y
 CONFIG_DRIVERS_IMU_INVENSENSE_MPU9250=y
+CONFIG_DRIVERS_LINUX_PWM_OUT=y
 CONFIG_DRIVERS_MAGNETOMETER_HMC5883=y
 CONFIG_DRIVERS_RC_INPUT=y
 CONFIG_DRIVERS_SMART_BATTERY_BATMON=y
@@ -30,8 +31,8 @@ CONFIG_MODULES_EVENTS=y
 CONFIG_MODULES_FLIGHT_MODE_MANAGER=y
 CONFIG_MODULES_FW_ATT_CONTROL=y
 CONFIG_MODULES_FW_AUTOTUNE_ATTITUDE_CONTROL=y
-CONFIG_MODULES_FW_MODE_MANAGER=y
 CONFIG_MODULES_FW_LATERAL_LONGITUDINAL_CONTROL=y
+CONFIG_MODULES_FW_MODE_MANAGER=y
 CONFIG_MODULES_FW_RATE_CONTROL=y
 CONFIG_MODULES_GIMBAL=y
 CONFIG_MODULES_GYRO_CALIBRATION=y

boards/bluerobotics/navigator/init/rc.board_defaults

@@ -11,3 +11,7 @@ param set BAT1_V_DIV 5.7
 
 # Always keep current config
 param set SYS_AUTOCONFIG 0
+
+# PCA9685 PWM Out defaults
+param set-default PCA9685_EN_BUS 4
+param set-default PCA9685_I2C_ADDR 64

boards/bluerobotics/navigator/init/rc.board_sensors

@@ -28,7 +28,7 @@ then
 	echo "ads1115 not found."
 fi
 
-if ! pca9685_pwm_out start -a 0x40 -b 4
+if ! pca9685_pwm_out start
 then
 	echo "pca9685_pwm_out not found."
 fi

boards/cuav/fmu-v6x/default.px4board

@@ -30,7 +30,6 @@ CONFIG_DRIVERS_OSD_MSP_OSD=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_POWER_MONITOR_INA228=y
 CONFIG_DRIVERS_POWER_MONITOR_INA238=y
-CONFIG_DRIVERS_POWER_MONITOR_PM_SELECTOR_AUTERION=y
 CONFIG_DRIVERS_PWM_OUT=y
 CONFIG_DRIVERS_PX4IO=y
 CONFIG_DRIVERS_RC_INPUT=y
@@ -61,7 +60,6 @@ CONFIG_MODULES_LOGGER=y
 CONFIG_MODULES_MAG_BIAS_ESTIMATOR=y
 CONFIG_MODULES_MANUAL_CONTROL=y
 CONFIG_MODULES_MAVLINK=y
-CONFIG_MAVLINK_DIALECT="development"
 CONFIG_MODULES_MC_ATT_CONTROL=y
 CONFIG_MODULES_MC_AUTOTUNE_ATTITUDE_CONTROL=y
 CONFIG_MODULES_MC_HOVER_THRUST_ESTIMATOR=y

boards/cuav/fmu-v6x/init/rc.board_defaults

@@ -3,13 +3,6 @@
 # board specific defaults
 #------------------------------------------------------------------------------
 
-# By disabling all 3 INA modules, we use the
-# i2c_launcher instead.
-param set-default SENS_EN_INA238 0
-param set-default SENS_EN_INA228 0
-param set-default SENS_EN_INA226 0
-
-
 # Mavlink ethernet (CFG 1000)
 param set-default MAV_2_CONFIG 1000
 param set-default MAV_2_BROADCAST 1

boards/cuav/fmu-v6x/init/rc.board_sensors

@@ -68,7 +68,7 @@ fi
 
 bmi088 -A -R 4 -s start
 bmi088 -G -R 4 -s start
-iim42652 -R 6 -s start
+iim42652 -R 6 -s -C 32768 start
 icm45686 -R 2 -s start
 
 rm3100 -I -b 4 start

boards/cuav/fmu-v6x/src/CMakeLists.txt

@@ -71,6 +71,5 @@ else()
 			nuttx_arch # sdio
 			nuttx_drivers # sdio
 			px4_layer
-			platform_gpio_mcp23009
 	)
 endif()

boards/cuav/fmu-v6x/src/init.cpp

@@ -74,7 +74,6 @@
 #include <px4_platform/gpio.h>
 #include <px4_platform/board_determine_hw_info.h>
 #include <px4_platform/board_dma_alloc.h>
-#include <px4_platform/gpio/mcp23009.hpp>
 
 /****************************************************************************
  * Pre-Processor Definitions
@@ -286,13 +285,6 @@ __EXPORT int board_app_initialize(uintptr_t arg)
 
 #  endif /* CONFIG_MMCSD */
 
-	ret = mcp23009_register_gpios(3, 0x25);
-
-	if (ret != OK) {
-		led_on(LED_RED);
-		return ret;
-	}
-
 #endif /* !defined(BOOTLOADER) */
 
 	return OK;

boards/cuav/nora/default.px4board

@@ -27,7 +27,6 @@ CONFIG_DRIVERS_IRLOCK=y
 CONFIG_COMMON_LIGHT=y
 CONFIG_DRIVERS_LIGHTS_RGBLED_PWM=y
 CONFIG_COMMON_MAGNETOMETER=y
-CONFIG_COMMON_OPTICAL_FLOW=y
 CONFIG_DRIVERS_PCA9685_PWM_OUT=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_PWM_OUT=y

boards/cuav/x25-evo/default.px4board

@@ -28,7 +28,6 @@ CONFIG_DRIVERS_OSD_MSP_OSD=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_POWER_MONITOR_INA228=y
 CONFIG_DRIVERS_POWER_MONITOR_INA238=y
-CONFIG_DRIVERS_POWER_MONITOR_PM_SELECTOR_AUTERION=y
 CONFIG_DRIVERS_PWM_OUT=y
 CONFIG_DRIVERS_RC_INPUT=y
 CONFIG_DRIVERS_SAFETY_BUTTON=y

boards/cuav/x25-evo/init/rc.board_defaults

@@ -15,10 +15,6 @@ param set-default MAV_2_UDP_PRT 14550
 param set-default BAT1_V_DIV 18
 param set-default BAT1_A_PER_V 24
 
-param set-default SENS_EN_INA238 0
-param set-default SENS_EN_INA228 0
-param set-default SENS_EN_INA226 0
-
 param set-default USB_MAV_MODE 5
 
 param set-default UAVCAN_SUB_GPS 1

boards/cuav/x7pro/default.px4board

@@ -27,7 +27,6 @@ CONFIG_DRIVERS_IRLOCK=y
 CONFIG_COMMON_LIGHT=y
 CONFIG_DRIVERS_LIGHTS_RGBLED_PWM=y
 CONFIG_COMMON_MAGNETOMETER=y
-CONFIG_COMMON_OPTICAL_FLOW=y
 CONFIG_DRIVERS_PCA9685_PWM_OUT=y
 CONFIG_DRIVERS_POWER_MONITOR_INA226=y
 CONFIG_DRIVERS_PWM_OUT=y