mixer_module always use MIN/MAX/DIS/FAIL parameters

2026-06-03 16:40:04 +08:00 · 2021-10-21 21:50:25 -04:00
179 changed files with 6839 additions and 10993 deletions
@@ -10,7 +10,6 @@ on:
 jobs:
  enumerate_targets:
    runs-on: ubuntu-latest
-    container: px4io/px4-dev-base-focal:2021-09-08
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
@@ -128,9 +128,6 @@ config BOARD_KEYSTORE

 menu "Serial ports"

-    config BOARD_SERIAL_URT6
-        string "URT6 tty port"
-
    config BOARD_SERIAL_GPS1
        string "GPS1 tty port"

@@ -161,14 +158,8 @@ menu "Serial ports"
    config BOARD_SERIAL_TEL5
        string "TEL5 tty port"

-    config BOARD_SERIAL_RC
-        string "RC tty port"
-
    config BOARD_SERIAL_WIFI
        string "WIFI tty port"
-
-    config BOARD_SERIAL_PPB
-        string "PPB (Pixhawk Payload Bus) tty port"
 endmenu

 menu "drivers"
@@ -84,8 +84,6 @@ param set-default MPC_Z_VEL_P_ACC 5
 param set-default MPC_Z_VEL_I_ACC 3
 param set-default MPC_LAND_ALT1 3
 param set-default MPC_LAND_ALT2 1
-param set-default MPC_POS_MODE 3
-param set-default CP_GO_NO_DATA 1

 # Navigator Parameters
 param set-default NAV_ACC_RAD 2
@@ -16,12 +16,6 @@ ekf2 start &
 fw_att_control start
 fw_pos_control_l1 start
 airspeed_selector start
-
-#
-# Start attitude control auto-tuner
-#
-fw_autotune_attitude_control start
-
 #
 # Start Land Detector.
 #
@@ -15,7 +15,7 @@ param set-default RTL_RETURN_ALT 30
 param set-default RTL_DESCEND_ALT 10

 param set-default PWM_MAIN_MAX 1950
-param set-default PWM_MAIN_MIN 1075
+param set-default PWM_MAIN_MIN1 1075
 param set-default PWM_MAIN_RATE 400

 param set-default GPS_UBX_DYNMODEL 6
@@ -24,11 +24,9 @@ mc_att_control start vtol
 flight_mode_manager start
 mc_pos_control start vtol
 mc_hover_thrust_estimator start
-mc_autotune_attitude_control start

 fw_att_control start vtol
 fw_pos_control_l1 start vtol
-fw_autotune_attitude_control start vtol

 # Start Land Detector
 # Multicopter for now until we have something for VTOL
@@ -1,12 +1,6 @@
 #!/usr/bin/env bash
 set -eu

-PATTERN="-e ."
-
-if [ $# -gt 0 ]; then
-    PATTERN="$1"
-fi
-
 exec find boards msg src platforms test \
    -path msg/templates/urtps -prune -o \
    -path platforms/nuttx/NuttX -prune -o \
@@ -27,4 +21,4 @@ exec find boards msg src platforms test \
    -path src/lib/crypto/monocypher -prune -o \
    -path src/lib/crypto/libtomcrypt -prune -o \
    -path src/lib/crypto/libtommath -prune -o \
-    -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" -o -name "*.hpp" \) | grep $PATTERN
+    -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" -o -name "*.hpp" \)
@@ -6,14 +6,6 @@ import os
 import sys
 import json
 import re
-from kconfiglib import Kconfig
-
-kconf = Kconfig()
-
-# Supress warning output
-kconf.warn_assign_undef = False
-kconf.warn_assign_override = False
-kconf.warn_assign_redun = False

 source_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')

@@ -36,43 +28,42 @@ excluded_labels = [
    'uavcanv1' # TODO: fix and enable
    ]

-def process_target(px4board_file, target_name):
+def process_target(cmake_file, target_name):
    ret = None
+    is_board_def = False
    platform = None
    toolchain = None
+    for line in open(cmake_file, 'r'):
+        if 'px4_add_board' in line:
+            is_board_def = True
+        if not is_board_def:
+            continue

-    if px4board_file.endswith("default.px4board"):
-        kconf.load_config(px4board_file, replace=True)
-    else: # Merge config with default.px4board
-        default_kconfig = re.sub(r'[a-zA-Z\d_]+\.px4board', 'default.px4board', px4board_file)
-        kconf.load_config(default_kconfig, replace=True)
-        kconf.load_config(px4board_file, replace=False)
+        re_platform = re.search('PLATFORM\s+([^\s]+)', line)
+        if re_platform: platform = re_platform.group(1)

-    if "BOARD_TOOLCHAIN" in kconf.syms:
-        toolchain = kconf.syms["BOARD_TOOLCHAIN"].str_value
+        re_toolchain = re.search('TOOLCHAIN\s+([^\s]+)', line)
+        if re_toolchain: toolchain = re_toolchain.group(1)

-    if "BOARD_PLATFORM" in kconf.syms:
-        platform = kconf.syms["BOARD_PLATFORM"].str_value
+    if is_board_def:
+        assert platform, f"PLATFORM not found in {cmake_file}"

-    assert platform, f"PLATFORM not found in {px4board_file}"
-
-    if platform not in excluded_platforms:
-        # get the container based on the platform and toolchain
-        container = platform
-        if platform == 'posix':
-            container = 'base-focal'
-            if toolchain:
-                if toolchain.startswith('aarch64'):
-                    container = 'aarch64'
-                elif toolchain == 'arm-linux-gnueabihf':
-                    container = 'armhf'
-                else:
-                    if verbose: print(f'possibly unmatched toolchain: {toolchain}')
-        elif platform == 'nuttx':
-            container = 'nuttx-focal'
-
-        ret = {'target': target_name, 'container': container}
+        if platform not in excluded_platforms:
+            # get the container based on the platform and toolchain
+            container = platform
+            if platform == 'posix':
+                container = 'base-focal'
+                if toolchain:
+                    if toolchain.startswith('aarch64'):
+                        container = 'aarch64'
+                    elif toolchain == 'arm-linux-gnueabihf':
+                        container = 'armhf'
+                    else:
+                        if verbose: print(f'possibly unmatched toolchain: {toolchain}')
+            elif platform == 'nuttx':
+                container = 'nuttx-focal'

+            ret = {'target': target_name, 'container': container}
    return ret

 for manufacturer in os.scandir(os.path.join(source_dir, 'boards')):
@@ -86,8 +77,8 @@ for manufacturer in os.scandir(os.path.join(source_dir, 'boards')):
        if not board.is_dir():
            continue
        for files in os.scandir(board.path):
-            if files.is_file() and files.name.endswith('.px4board'):
-                label = files.name[:-9]
+            if files.is_file() and files.name.endswith('.cmake'):
+                label = files.name[:-6]
                target_name = manufacturer.name + '_' + board.name + '_' + label
                if label in excluded_labels:
                    if verbose: print(f'excluding label {label} ({target_name})')
@@ -110,17 +110,10 @@ def main(kconfig_file, config1, config2):

    for line in f:
        match = unset_match(line)
-        #pprint.pprint(line)
+        #pprint.pprint(match)
        if match is not None:
            sym_name = match.group(1)
            kconf.syms[sym_name].unset_value()
-
-            if kconf.syms[sym_name].type is BOOL:
-                for default, cond in kconf.syms[sym_name].orig_defaults:
-                    if(cond.str_value == 'y'):
-                        # Default is y, our diff is unset thus we've set it to no
-                        kconf.syms[sym_name].set_value(0)
-
    f.close()

    # Print warnings for symbols whose actual value doesn't match the assigned
@@ -48,7 +48,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -1,5 +1,6 @@
 CONFIG_BOARD_CONSTRAINED_FLASH=n
 CONFIG_BOARD_NO_HELP=n
-CONFIG_SYSTEMCMDS_REBOOT=y
+CONFIG_BOARD_CONSTRAINED_MEMORY=y
 CONFIG_SYSTEMCMDS_TOP=y
+CONFIG_SYSTEMCMDS_REBOOT=y
 CONFIG_SYSTEMCMDS_UORB=y
@@ -45,7 +45,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -29,7 +29,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -53,7 +53,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -38,7 +38,6 @@ CONFIG_ARMV7M_DTCM=y
 CONFIG_ARMV7M_ICACHE=y
 CONFIG_ARMV7M_MEMCPY=y
 CONFIG_ARMV7M_USEBASEPRI=y
-CONFIG_ARM_MPU_EARLY_RESET=y
 CONFIG_BOARDCTL_RESET=y
 CONFIG_BOARD_CRASHDUMP=y
 CONFIG_BOARD_LOOPSPERMSEC=95150
@@ -72,7 +71,6 @@ CONFIG_FS_FAT=y
 CONFIG_FS_FATTIME=y
 CONFIG_FS_PROCFS=y
 CONFIG_FS_PROCFS_INCLUDE_PROGMEM=y
-CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_FS_PROCFS_REGISTER=y
 CONFIG_FS_ROMFS=y
 CONFIG_GRAN=y
@@ -85,6 +83,7 @@ CONFIG_IDLETHREAD_STACKSIZE=750
 CONFIG_LIBC_FLOATINGPOINT=y
 CONFIG_LIBC_LONG_LONG=y
 CONFIG_LIBC_STRERROR=y
+CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_MEMSET_64BIT=y
 CONFIG_MEMSET_OPTSPEED=y
 CONFIG_MMCSD=y
@@ -129,6 +129,16 @@ __EXPORT void board_on_reset(int status)
 ************************************************************************************/
 __EXPORT void stm32_boardinitialize(void)
 {
+	// clear all existing MPU configuration from bootloader
+	for (int region = 0; region < CONFIG_ARM_MPU_NREGIONS; region++) {
+		putreg32(region, MPU_RNR);
+		putreg32(0, MPU_RBAR);
+		putreg32(0, MPU_RASR);
+
+		// save
+		putreg32(0, MPU_CTRL);
+	}
+
 	/* Reset PWM first thing */
 	board_on_reset(-1);

@@ -54,7 +54,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -38,7 +38,6 @@ CONFIG_ARMV7M_DTCM=y
 CONFIG_ARMV7M_ICACHE=y
 CONFIG_ARMV7M_MEMCPY=y
 CONFIG_ARMV7M_USEBASEPRI=y
-CONFIG_ARM_MPU_EARLY_RESET=y
 CONFIG_BOARDCTL_RESET=y
 CONFIG_BOARD_CRASHDUMP=y
 CONFIG_BOARD_LOOPSPERMSEC=95150
@@ -72,7 +71,6 @@ CONFIG_FS_FAT=y
 CONFIG_FS_FATTIME=y
 CONFIG_FS_PROCFS=y
 CONFIG_FS_PROCFS_INCLUDE_PROGMEM=y
-CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_FS_PROCFS_REGISTER=y
 CONFIG_FS_ROMFS=y
 CONFIG_GRAN=y
@@ -85,6 +83,7 @@ CONFIG_IDLETHREAD_STACKSIZE=750
 CONFIG_LIBC_FLOATINGPOINT=y
 CONFIG_LIBC_LONG_LONG=y
 CONFIG_LIBC_STRERROR=y
+CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_MEMSET_64BIT=y
 CONFIG_MEMSET_OPTSPEED=y
 CONFIG_MMCSD=y
@@ -129,6 +129,16 @@ __EXPORT void board_on_reset(int status)
 ************************************************************************************/
 __EXPORT void stm32_boardinitialize(void)
 {
+	// clear all existing MPU configuration from bootloader
+	for (int region = 0; region < CONFIG_ARM_MPU_NREGIONS; region++) {
+		putreg32(region, MPU_RNR);
+		putreg32(0, MPU_RBAR);
+		putreg32(0, MPU_RASR);
+
+		// save
+		putreg32(0, MPU_CTRL);
+	}
+
 	/* Reset PWM first thing */
 	board_on_reset(-1);

@@ -49,7 +49,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -39,7 +39,6 @@ CONFIG_ARMV7M_DTCM=y
 CONFIG_ARMV7M_ICACHE=y
 CONFIG_ARMV7M_MEMCPY=y
 CONFIG_ARMV7M_USEBASEPRI=y
-CONFIG_ARM_MPU_EARLY_RESET=y
 CONFIG_BOARDCTL_RESET=y
 CONFIG_BOARD_CRASHDUMP=y
 CONFIG_BOARD_LOOPSPERMSEC=95150
@@ -38,7 +38,6 @@ CONFIG_ARMV7M_DTCM=y
 CONFIG_ARMV7M_ICACHE=y
 CONFIG_ARMV7M_MEMCPY=y
 CONFIG_ARMV7M_USEBASEPRI=y
-CONFIG_ARM_MPU_EARLY_RESET=y
 CONFIG_BOARDCTL_RESET=y
 CONFIG_BOARD_CRASHDUMP=y
 CONFIG_BOARD_LOOPSPERMSEC=95150
@@ -120,6 +120,16 @@ __EXPORT void board_on_reset(int status)
 ************************************************************************************/
 __EXPORT void stm32_boardinitialize(void)
 {
+	// clear all existing MPU configuration from bootloader
+	for (int region = 0; region < CONFIG_ARM_MPU_NREGIONS; region++) {
+		putreg32(region, MPU_RNR);
+		putreg32(0, MPU_RBAR);
+		putreg32(0, MPU_RASR);
+
+		// save
+		putreg32(0, MPU_CTRL);
+	}
+
 	/* Reset PWM first thing */
 	board_on_reset(-1);

@@ -48,7 +48,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -30,7 +30,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -38,6 +38,7 @@ CONFIG_COMMON_TELEMETRY=y
 CONFIG_DRIVERS_TONE_ALARM=y
 CONFIG_DRIVERS_UAVCAN=y
 CONFIG_MODULES_AIRSPEED_SELECTOR=y
+CONFIG_MODULES_ATTITUDE_ESTIMATOR_Q=y
 CONFIG_MODULES_BATTERY_STATUS=y
 CONFIG_MODULES_CAMERA_FEEDBACK=y
 CONFIG_MODULES_COMMANDER=y
@@ -47,13 +48,13 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
 CONFIG_MODULES_LAND_DETECTOR=y
 CONFIG_MODULES_LANDING_TARGET_ESTIMATOR=y
 CONFIG_MODULES_LOAD_MON=y
+CONFIG_MODULES_LOCAL_POSITION_ESTIMATOR=y
 CONFIG_MODULES_LOGGER=y
 CONFIG_MODULES_MAG_BIAS_ESTIMATOR=y
 CONFIG_MODULES_MAVLINK=y
@@ -98,3 +99,4 @@ CONFIG_SYSTEMCMDS_UORB=y
 CONFIG_SYSTEMCMDS_USB_CONNECTED=y
 CONFIG_SYSTEMCMDS_VER=y
 CONFIG_SYSTEMCMDS_WORK_QUEUE=y
+CONFIG_EXAMPLES_FAKE_GPS=y
@@ -38,7 +38,6 @@ CONFIG_ARMV7M_DTCM=y
 CONFIG_ARMV7M_ICACHE=y
 CONFIG_ARMV7M_MEMCPY=y
 CONFIG_ARMV7M_USEBASEPRI=y
-CONFIG_ARM_MPU_EARLY_RESET=y
 CONFIG_BOARDCTL_RESET=y
 CONFIG_BOARD_CRASHDUMP=y
 CONFIG_BOARD_LOOPSPERMSEC=95150
@@ -73,7 +72,6 @@ CONFIG_FS_FAT=y
 CONFIG_FS_FATTIME=y
 CONFIG_FS_PROCFS=y
 CONFIG_FS_PROCFS_INCLUDE_PROGMEM=y
-CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_FS_PROCFS_REGISTER=y
 CONFIG_FS_ROMFS=y
 CONFIG_GRAN=y
@@ -86,6 +84,7 @@ CONFIG_IDLETHREAD_STACKSIZE=750
 CONFIG_LIBC_FLOATINGPOINT=y
 CONFIG_LIBC_LONG_LONG=y
 CONFIG_LIBC_STRERROR=y
+CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_MEMSET_64BIT=y
 CONFIG_MEMSET_OPTSPEED=y
 CONFIG_MMCSD=y
@@ -162,6 +162,16 @@ __EXPORT void board_on_reset(int status)
 __EXPORT void
 stm32_boardinitialize(void)
 {
+	// clear all existing MPU configuration from bootloader
+	for (int region = 0; region < CONFIG_ARM_MPU_NREGIONS; region++) {
+		putreg32(region, MPU_RNR);
+		putreg32(0, MPU_RBAR);
+		putreg32(0, MPU_RASR);
+
+		// save
+		putreg32(0, MPU_CTRL);
+	}
+
 	board_on_reset(-1); /* Reset PWM first thing */

 	/* configure LEDs */
@@ -5,7 +5,6 @@ CONFIG_BOARD_EXTERNAL_METADATA=y
 CONFIG_BOARD_SERIAL_GPS1="/dev/ttyS3"
 CONFIG_BOARD_SERIAL_TEL1="/dev/ttyS0"
 CONFIG_BOARD_SERIAL_TEL2="/dev/ttyS1"
-CONFIG_BOARD_SERIAL_RC="/dev/ttyS4"
 CONFIG_DRIVERS_ADC_BOARD_ADC=y
 CONFIG_DRIVERS_BAROMETER_BMP280=y
 CONFIG_DRIVERS_DSHOT=y
@@ -53,7 +53,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -48,7 +48,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -47,7 +47,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -46,7 +46,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -46,7 +46,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -46,7 +46,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -38,7 +38,6 @@ CONFIG_ARMV7M_DTCM=y
 CONFIG_ARMV7M_ICACHE=y
 CONFIG_ARMV7M_MEMCPY=y
 CONFIG_ARMV7M_USEBASEPRI=y
-CONFIG_ARM_MPU_EARLY_RESET=y
 CONFIG_BOARDCTL_RESET=y
 CONFIG_BOARD_CRASHDUMP=y
 CONFIG_BOARD_LOOPSPERMSEC=95150
@@ -74,7 +73,6 @@ CONFIG_FS_FAT=y
 CONFIG_FS_FATTIME=y
 CONFIG_FS_PROCFS=y
 CONFIG_FS_PROCFS_INCLUDE_PROGMEM=y
-CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_FS_PROCFS_REGISTER=y
 CONFIG_FS_ROMFS=y
 CONFIG_GRAN=y
@@ -87,6 +85,7 @@ CONFIG_IDLETHREAD_STACKSIZE=750
 CONFIG_LIBC_FLOATINGPOINT=y
 CONFIG_LIBC_LONG_LONG=y
 CONFIG_LIBC_STRERROR=y
+CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_MEMSET_64BIT=y
 CONFIG_MEMSET_OPTSPEED=y
 CONFIG_MMCSD=y
@@ -123,6 +123,16 @@ __EXPORT void board_on_reset(int status)
 ************************************************************************************/
 __EXPORT void stm32_boardinitialize(void)
 {
+	// clear all existing MPU configuration from bootloader
+	for (int region = 0; region < CONFIG_ARM_MPU_NREGIONS; region++) {
+		putreg32(region, MPU_RNR);
+		putreg32(0, MPU_RBAR);
+		putreg32(0, MPU_RASR);
+
+		// save
+		putreg32(0, MPU_CTRL);
+	}
+
 	/* Reset PWM first thing */
 	board_on_reset(-1);

@@ -47,7 +47,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -38,7 +38,6 @@ CONFIG_ARMV7M_DTCM=y
 CONFIG_ARMV7M_ICACHE=y
 CONFIG_ARMV7M_MEMCPY=y
 CONFIG_ARMV7M_USEBASEPRI=y
-CONFIG_ARM_MPU_EARLY_RESET=y
 CONFIG_BOARDCTL_RESET=y
 CONFIG_BOARD_CRASHDUMP=y
 CONFIG_BOARD_LOOPSPERMSEC=95150
@@ -74,7 +73,6 @@ CONFIG_FS_FAT=y
 CONFIG_FS_FATTIME=y
 CONFIG_FS_PROCFS=y
 CONFIG_FS_PROCFS_INCLUDE_PROGMEM=y
-CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_FS_PROCFS_REGISTER=y
 CONFIG_FS_ROMFS=y
 CONFIG_GRAN=y
@@ -87,6 +85,7 @@ CONFIG_IDLETHREAD_STACKSIZE=750
 CONFIG_LIBC_FLOATINGPOINT=y
 CONFIG_LIBC_LONG_LONG=y
 CONFIG_LIBC_STRERROR=y
+CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_MEMSET_64BIT=y
 CONFIG_MEMSET_OPTSPEED=y
 CONFIG_MMCSD=y
@@ -123,6 +123,16 @@ __EXPORT void board_on_reset(int status)
 ************************************************************************************/
 __EXPORT void stm32_boardinitialize(void)
 {
+	// clear all existing MPU configuration from bootloader
+	for (int region = 0; region < CONFIG_ARM_MPU_NREGIONS; region++) {
+		putreg32(region, MPU_RNR);
+		putreg32(0, MPU_RBAR);
+		putreg32(0, MPU_RASR);
+
+		// save
+		putreg32(0, MPU_CTRL);
+	}
+
 	/* Reset PWM first thing */
 	board_on_reset(-1);

@@ -45,7 +45,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -38,7 +38,6 @@ CONFIG_ARMV7M_DTCM=y
 CONFIG_ARMV7M_ICACHE=y
 CONFIG_ARMV7M_MEMCPY=y
 CONFIG_ARMV7M_USEBASEPRI=y
-CONFIG_ARM_MPU_EARLY_RESET=y
 CONFIG_BOARDCTL_RESET=y
 CONFIG_BOARD_CRASHDUMP=y
 CONFIG_BOARD_LOOPSPERMSEC=95150
@@ -72,7 +71,6 @@ CONFIG_FS_FAT=y
 CONFIG_FS_FATTIME=y
 CONFIG_FS_PROCFS=y
 CONFIG_FS_PROCFS_INCLUDE_PROGMEM=y
-CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_FS_PROCFS_REGISTER=y
 CONFIG_FS_ROMFS=y
 CONFIG_GRAN=y
@@ -85,6 +83,7 @@ CONFIG_IDLETHREAD_STACKSIZE=750
 CONFIG_LIBC_FLOATINGPOINT=y
 CONFIG_LIBC_LONG_LONG=y
 CONFIG_LIBC_STRERROR=y
+CONFIG_FS_PROCFS_MAX_TASKS=64
 CONFIG_MEMSET_64BIT=y
 CONFIG_MEMSET_OPTSPEED=y
 CONFIG_MMCSD=y
@@ -123,6 +123,16 @@ __EXPORT void board_on_reset(int status)
 ************************************************************************************/
 __EXPORT void stm32_boardinitialize(void)
 {
+	// clear all existing MPU configuration from bootloader
+	for (int region = 0; region < CONFIG_ARM_MPU_NREGIONS; region++) {
+		putreg32(region, MPU_RNR);
+		putreg32(0, MPU_RBAR);
+		putreg32(0, MPU_RASR);
+
+		// save
+		putreg32(0, MPU_CTRL);
+	}
+
 	/* Reset PWM first thing */
 	board_on_reset(-1);

@@ -48,7 +48,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -49,7 +49,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -48,7 +48,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -53,7 +53,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -103,7 +103,8 @@ CONFIG_SCHED_WAITPID=y
 CONFIG_SDCLONE_DISABLE=y
 CONFIG_SERIAL_TERMIOS=y
 CONFIG_SIG_DEFAULT=y
-CONFIG_SPITOOL_MAXBUS=2
+CONFIG_SPITOOL_DEFFREQ=400000
+CONFIG_SPITOOL_MAXBUS=0
 CONFIG_STACK_COLORATION=y
 CONFIG_START_DAY=18
 CONFIG_START_MONTH=8
@@ -62,7 +62,7 @@ else()
 		init.c
 		mtd.cpp
 		periphclocks.c
-		spi.cpp
+		spi.c
 		timer_config.cpp
 		userleds.c
 	)
@@ -160,9 +160,8 @@ int s32k1xx_bringup(void);
 *
 ****************************************************************************/

-#ifdef CONFIG_S32K1XX_LPSPI0
+#ifdef CONFIG_S32K1XX_LPSPI
 void s32k1xx_spidev_initialize(void);
-int s32k1xx_spi_bus_initialize(void);
 #endif

 /****************************************************************************************************
@@ -124,13 +124,12 @@ int s32k1xx_bringup(void)
 	s32k1xx_eeeprom_register(0, 4096);
 #endif

-#ifdef CONFIG_S32K1XX_LPSPI0
+#ifdef CONFIG_S32K1XX_LPSPI
 	/* Configure SPI chip selects if 1) SPI is not disabled, and 2) the weak
 	 * function s32k1xx_spidev_initialize() has been brought into the link.
 	 */

 	s32k1xx_spidev_initialize();
-	s32k1xx_spi_bus_initialize();
 #endif

 #if defined(CONFIG_S32K1XX_LPI2C0)
@@ -34,5 +34,6 @@
 #include <px4_arch/i2c_hw_description.h>

 constexpr px4_i2c_bus_t px4_i2c_buses[I2C_BUS_MAX_BUS_ITEMS] = {
+	initI2CBusInternal(PX4_BUS_NUMBER_TO_PX4(1)),
 	initI2CBusExternal(PX4_BUS_NUMBER_TO_PX4(0)),
 };
@@ -1,230 +0,0 @@
-/************************************************************************************
- *
- *   Copyright (C) 2016, 2018, 2021 Gregory Nutt. All rights reserved.
- *   Authors: Gregory Nutt <gnutt@nuttx.org>
- *            David Sidrane <david_s5@nscdg.com>
- *            Landon Haugh <landon.haugh@nxp.com>
- *
- * 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 NuttX 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.
- *
- ************************************************************************************/
-
-#include <nuttx/config.h>
-
-#include <px4_arch/spi_hw_description.h>
-#include <px4_platform_common/px4_config.h>
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <errno.h>
-#include <debug.h>
-
-#include <nuttx/spi/spi.h>
-#include <arch/board/board.h>
-
-#include "arm_arch.h"
-#include "chip.h"
-#include <systemlib/px4_macros.h>
-
-#include "s32k1xx_config.h"
-#include "s32k1xx_lpspi.h"
-#include "s32k1xx_pin.h"
-#include "board_config.h"
-
-#if defined(CONFIG_S32K1XX_LPSPI0)
-// Only LPSPI0 is defined in defconfig. cont. || defined(CONFIG_S32K1XX_LPSPI1) || defined(CONFIG_S32K1XX_LPSPI2)
-
-// UCANS32K146 has only one external SPI @ PTB5
-constexpr px4_spi_bus_t px4_spi_buses[SPI_BUS_MAX_BUS_ITEMS] = {
-	initSPIBusExternal(SPI::Bus::SPI0, {
-		// Going to assume PTB5 means PortB, Pin5
-		initSPIConfigExternal(SPI::CS{GPIO::PortB, GPIO::Pin5})
-	}),
-};
-
-static constexpr bool unused = validateSPIConfig(px4_spi_buses);
-
-#define PX4_MK_GPIO(pin_ftmx, io)    ((((uint32_t)(pin_ftmx)) & ~(_PIN_MODE_MASK | _PIN_OPTIONS_MASK)) |(io))
-
-
-/************************************************************************************
- * Public Functions
- ************************************************************************************/
-
-__EXPORT void board_spi_reset(int ms, int bus_mask)
-{
-	/* Goal not to back feed the chips on the bus via IO lines */
-
-	/* Next Change CS to inputs with pull downs */
-	for (int bus = 0; bus < SPI_BUS_MAX_BUS_ITEMS; ++bus) {
-		if (px4_spi_buses[bus].bus == PX4_BUS_NUMBER_TO_PX4(1)) {
-			for (int i = 0; i < SPI_BUS_MAX_DEVICES; ++i) {
-				if (px4_spi_buses[bus].devices[i].cs_gpio != 0) {
-					// s32k1xx_pinconfig is defined
-					// Only one argument, (uint32_t cfgset)
-					s32k1xx_pinconfig(PX4_MK_GPIO(px4_spi_buses[bus].devices[i].cs_gpio, GPIO_PULLDOWN));
-				}
-			}
-		}
-	}
-
-	/* Restore all the CS to ouputs inactive */
-	for (int bus = 0; bus < SPI_BUS_MAX_BUS_ITEMS; ++bus) {
-		if (px4_spi_buses[bus].bus == PX4_BUS_NUMBER_TO_PX4(1)) {
-			for (int i = 0; i < SPI_BUS_MAX_DEVICES; ++i) {
-				if (px4_spi_buses[bus].devices[i].cs_gpio != 0) {
-					s32k1xx_pinconfig(px4_spi_buses[bus].devices[i].cs_gpio);
-				}
-			}
-		}
-	}
-}
-
-/************************************************************************************
- * Name: s32k1xx_spidev_initialize
- *
- * Description:
- *   Called to configure SPI chip select GPIO pins for the NXP UCANS32K146 board.
- *
- ************************************************************************************/
-
-void s32k1xx_spidev_initialize(void)
-{
-	board_spi_reset(10, 0xffff);
-
-	for (int bus = 0; bus < SPI_BUS_MAX_BUS_ITEMS; ++bus) {
-		for (int i = 0; i < SPI_BUS_MAX_DEVICES; ++i) {
-			if (px4_spi_buses[bus].devices[i].cs_gpio != 0) {
-				s32k1xx_pinconfig(px4_spi_buses[bus].devices[i].cs_gpio);
-			}
-		}
-	}
-}
-
-/************************************************************************************
- * Name: s32k1xx_spi_bus_initialize
- *
- * Description:
- *   Called to configure SPI chip select GPIO pins for the NXP UCANS32K146 board.
- *
- ************************************************************************************/
-
-static const px4_spi_bus_t *_spi_bus0;
-
-__EXPORT int s32k1xx_spi_bus_initialize(void)
-{
-
-	for (int i = 0; i < SPI_BUS_MAX_BUS_ITEMS; ++i) {
-		switch (px4_spi_buses[i].bus) {
-		case 1: _spi_bus0 = &px4_spi_buses[i]; break;
-		}
-	}
-
-	struct spi_dev_s *spi_ext = px4_spibus_initialize(1);
-
-	if (!spi_ext) {
-		syslog(LOG_ERR, "[boot] FAILED to initialize SPI port %d\n", 2);
-		return -ENODEV;
-	}
-
-	/* Default external bus to 1MHz and de-assert the known chip selects.
-	 */
-
-	SPI_SETFREQUENCY(spi_ext, 8 * 1000 * 1000);
-	SPI_SETBITS(spi_ext, 8);
-	SPI_SETMODE(spi_ext, SPIDEV_MODE3);
-
-	/* deselect all */
-	for (int bus = 0; bus < SPI_BUS_MAX_BUS_ITEMS; ++bus) {
-		for (int i = 0; i < SPI_BUS_MAX_DEVICES; ++i) {
-			if (px4_spi_buses[bus].devices[i].cs_gpio != 0) {
-				SPI_SELECT(spi_ext, px4_spi_buses[bus].devices[i].devid, false);
-			}
-		}
-	}
-
-	return OK;
-
-}
-
-/************************************************************************************
- * Name: s32k1xx_spi[n]select, s32k1xx_spi[n]status, and s32k1xx_spi[n]cmddata
- *
- * Description:
- *   These external functions must be provided by board-specific logic.  They are
- *   implementations of the select, status, and cmddata methods of the SPI interface
- *   defined by struct spi_ops_s (see include/nuttx/spi/spi.h). All other methods
- *   including s32k1xx_spibus_initialize()) are provided by common s32k1xx logic.
- *   To use this common SPI logic on your board:
- *
- *   1. Provide logic in s32k1xx_boardinitialize() to configure SPI chip select
- *      pins.
- *   2. Provide s32k1xx_spi[n]select() and s32k1xx_spi[n]status() functions
- *      in your board-specific logic.  These functions will perform chip selection
- *      and status operations using GPIOs in the way your board is configured.
- *   2. If CONFIG_SPI_CMDDATA is defined in the NuttX configuration, provide
- *      s32k1xx_spi[n]cmddata() functions in your board-specific logic.  These
- *      functions will perform cmd/data selection operations using GPIOs in the way
- *      your board is configured.
- *   3. Add a call to s32k1xx_spibus_initialize() in your low level application
- *      initialization logic
- *   4. The handle returned by s32k1xx_spibus_initialize() may then be used to bind the
- *      SPI driver to higher level logic (e.g., calling
- *      mmcsd_spislotinitialize(), for example, will bind the SPI driver to
- *      the SPI MMC/SD driver).
- *
- ************************************************************************************/
-
-static inline void s32k1xx_spixselect(const px4_spi_bus_t *bus, struct spi_dev_s *dev, uint32_t devid, bool selected)
-{
-	for (int i = 0; i < SPI_BUS_MAX_DEVICES; ++i) {
-		if (bus->devices[i].cs_gpio == 0) {
-			break;
-		}
-
-		if (devid == bus->devices[i].devid) {
-			// SPI select is active low, so write !selected to select the device
-			// s32k1xx_gpiowrite is defined (uint32_t pinset, bool value)
-			s32k1xx_gpiowrite(bus->devices[i].cs_gpio, !selected);
-		}
-	}
-}
-
-
-void s32k1xx_lpspi0select(FAR struct spi_dev_s *dev, uint32_t devid, bool selected)
-{
-	spiinfo("devid: %d CS: %s\n", (int)devid, selected ? "assert" : "de-assert");
-	s32k1xx_spixselect(_spi_bus0, dev, devid, selected);
-}
-
-uint8_t s32k1xx_lpspi0status(FAR struct spi_dev_s *dev, uint32_t devid)
-{
-	return SPI_STATUS_PRESENT;
-}
-
-#endif /* CONFIG_S32K1XX_LPSPI0 */
@@ -2,7 +2,6 @@ CONFIG_BOARD_TOOLCHAIN="arm-none-eabi"
 CONFIG_BOARD_ARCHITECTURE="cortex-m4"
 CONFIG_BOARD_CONSTRAINED_FLASH=y
 CONFIG_BOARD_CONSTRAINED_MEMORY=y
-CONFIG_BOARD_SERIAL_URT6="/dev/ttyS2"
 CONFIG_BOARD_SERIAL_TEL2="/dev/ttyS1"
 CONFIG_DRIVERS_ADC_BOARD_ADC=y
 CONFIG_DRIVERS_BAROMETER_BMP280=y
@@ -53,7 +52,6 @@ CONFIG_SYSTEMCMDS_REFLECT=y
 CONFIG_SYSTEMCMDS_SD_BENCH=y
 CONFIG_SYSTEMCMDS_SD_STRESS=y
 CONFIG_SYSTEMCMDS_TOP=y
-CONFIG_SYSTEMCMDS_TOPIC_LISTENER=y
 CONFIG_SYSTEMCMDS_TUNE_CONTROL=y
 CONFIG_SYSTEMCMDS_UORB=y
 CONFIG_SYSTEMCMDS_USB_CONNECTED=y
@@ -34,8 +34,8 @@
 #include <px4_arch/io_timer_hw_description.h>

 constexpr io_timers_t io_timers[MAX_IO_TIMERS] = {
-	initIOTimer(Timer::Timer3, DMA{DMA::Index1, DMA::Stream2, DMA::Channel5}),
 	initIOTimer(Timer::Timer2, DMA{DMA::Index1, DMA::Stream1, DMA::Channel3}),
+	initIOTimer(Timer::Timer3, DMA{DMA::Index1, DMA::Stream2, DMA::Channel5}),
 };

 constexpr timer_io_channels_t timer_io_channels[MAX_TIMER_IO_CHANNELS] = {
@@ -5,11 +5,9 @@ CONFIG_MODULES_MC_HOVER_THRUST_ESTIMATOR=n
 CONFIG_MODULES_MC_POS_CONTROL=n
 CONFIG_MODULES_MC_RATE_CONTROL=n
 CONFIG_SYSTEMCMDS_BL_UPDATE=n
+CONFIG_COMMON_DIFFERENTIAL_PRESSURE=y
 CONFIG_DRIVERS_CAMERA_CAPTURE=y
 CONFIG_DRIVERS_CAMERA_TRIGGER=y
-CONFIG_DRIVERS_DIFFERENTIAL_PRESSURE_ETS=y
-CONFIG_DRIVERS_DIFFERENTIAL_PRESSURE_MS5525=y
-CONFIG_DRIVERS_DIFFERENTIAL_PRESSURE_SDP3X=y
 CONFIG_DRIVERS_DISTANCE_SENSOR_LIGHTWARE_LASER_SERIAL=y
 CONFIG_DRIVERS_DISTANCE_SENSOR_LL40LS=y
 CONFIG_MODULES_CAMERA_FEEDBACK=y
@@ -52,7 +52,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -52,7 +52,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -50,7 +50,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -1,11 +1,14 @@
-CONFIG_DRIVERS_ADC_ADS1115=n
-CONFIG_DRIVERS_IMU_ANALOG_DEVICES_ADIS16448=n
-CONFIG_DRIVERS_IRLOCK=n
-CONFIG_DRIVERS_PCA9685=n
-CONFIG_DRIVERS_PCA9685_PWM_OUT=n
-CONFIG_DRIVERS_RPM=n
 CONFIG_MODULES_ATTITUDE_ESTIMATOR_Q=n
 CONFIG_MODULES_LOCAL_POSITION_ESTIMATOR=n
 CONFIG_BOARD_TESTING=y
+CONFIG_DRIVERS_ADC_ADS1115=n
 CONFIG_DRIVERS_TEST_PPM=y
+CONFIG_DRIVERS_PCA9685=n
+CONFIG_DRIVERS_PCA9685_PWM_OUT=n
 CONFIG_SYSTEMCMDS_MICROBENCH=y
+CONFIG_DRIVERS_RPM=n
+CONFIG_DRIVERS_PCA9685=n
+CONFIG_DRIVERS_PCA9685_PWM_OUT=n
+CONFIG_DRIVERS_IRLOCK=n
+CONFIG_DRIVERS_ADC_ADS1115=n
+CONFIG_DRIVERS_IMU_ANALOG_DEVICES_ADIS16448=n
@@ -55,7 +55,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -6,6 +6,7 @@ CONFIG_DRIVERS_IMU_INVENSENSE_ICM20948=n
 CONFIG_DRIVERS_IRLOCK=n
 CONFIG_DRIVERS_OSD=n
 CONFIG_DRIVERS_PCA9685_PWM_OUT=n
+CONFIG_DRIVERS_PCA9685=y
 CONFIG_DRIVERS_PWM_INPUT=n
 CONFIG_DRIVERS_ROBOCLAW=n
 CONFIG_DRIVERS_RPM=n
@@ -7,7 +7,6 @@ CONFIG_BOARD_SERIAL_GPS2="/dev/ttyS7"
 CONFIG_BOARD_SERIAL_TEL1="/dev/ttyS6"
 CONFIG_BOARD_SERIAL_TEL2="/dev/ttyS4"
 CONFIG_BOARD_SERIAL_TEL3="/dev/ttyS1"
-CONFIG_BOARD_SERIAL_PPB="/dev/ttyS3"
 CONFIG_DRIVERS_ADC_ADS1115=y
 CONFIG_DRIVERS_ADC_BOARD_ADC=y
 CONFIG_COMMON_BAROMETERS=y
@@ -57,7 +56,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -50,7 +50,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -47,7 +47,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -29,7 +29,6 @@ CONFIG_MODULES_ESC_BATTERY=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -17,7 +17,6 @@ CONFIG_MODULES_EKF2=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -1,2 +1,3 @@
 CONFIG_BOARD_NOLOCKSTEP=y
 CONFIG_DRIVERS_DISTANCE_SENSOR_LIGHTWARE_LASER_SERIAL=y
+CONFIG_MODULES_CONTROL_ALLOCATOR=y
@@ -29,7 +29,6 @@ CONFIG_MODULES_EKF2=y
 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_POS_CONTROL_L1=y
 CONFIG_MODULES_GYRO_CALIBRATION=y
 CONFIG_MODULES_GYRO_FFT=y
@@ -210,9 +210,6 @@ if(EXISTS ${BOARD_DEFCONFIG})

 	# Serial ports
 	set(board_serial_ports)
-	if(SERIAL_URT6)
-		list(APPEND board_serial_ports URT6:${SERIAL_URT6})
-	endif()
 	if(SERIAL_GPS1)
        list(APPEND board_serial_ports GPS1:${SERIAL_GPS1})
 	endif()
@@ -243,15 +240,9 @@ if(EXISTS ${BOARD_DEFCONFIG})
 	if(SERIAL_TEL5)
        list(APPEND board_serial_ports TEL5:${SERIAL_TEL5})
 	endif()
-	if(SERIAL_RC)
-		list(APPEND board_serial_ports RC:${SERIAL_RC})
-	endif()
 	if(SERIAL_WIFI)
        list(APPEND board_serial_ports WIFI:${SERIAL_WIFI})
 	endif()
-	if(SERIAL_PPB)
-        list(APPEND board_serial_ports PPB:${SERIAL_PPB})
-	endif()


 	# ROMFS
@@ -156,12 +156,11 @@ function(px4_add_module)
 	if(NOT DYNAMIC)
 		target_link_libraries(${MODULE} PRIVATE prebuild_targets parameters_interface px4_layer px4_platform systemlib)
 		set_property(GLOBAL APPEND PROPERTY PX4_MODULE_LIBRARIES ${MODULE})
+		set_property(GLOBAL APPEND PROPERTY PX4_MODULE_PATHS ${CMAKE_CURRENT_SOURCE_DIR})
+		px4_list_make_absolute(ABS_SRCS ${CMAKE_CURRENT_SOURCE_DIR} ${SRCS})
+		set_property(GLOBAL APPEND PROPERTY PX4_SRC_FILES ${ABS_SRCS})
 	endif()

-	set_property(GLOBAL APPEND PROPERTY PX4_MODULE_PATHS ${CMAKE_CURRENT_SOURCE_DIR})
-	px4_list_make_absolute(ABS_SRCS ${CMAKE_CURRENT_SOURCE_DIR} ${SRCS})
-	set_property(GLOBAL APPEND PROPERTY PX4_SRC_FILES ${ABS_SRCS})
-
 	# set defaults if not set
 	set(MAIN_DEFAULT MAIN-NOTFOUND)
 	set(STACK_MAIN_DEFAULT 2048)
@@ -7,4 +7,3 @@ bool lockdown		# Set to true if actuators are forced to being disabled (due to e
 bool manual_lockdown    # Set to true if manual throttle kill switch is engaged
 bool force_failsafe	# Set to true if the actuators are forced to the failsafe position
 bool in_esc_calibration_mode # IO/FMU should ignore messages from the actuator controls topics
-bool soft_stop # Set to true if we need to ESCs to remove the idle constraint
@@ -9,11 +9,7 @@ float32 variance_east		# Wind estimate error variance in east / Y direction (m/s

 float32 tas_innov 		# True airspeed innovation
 float32 tas_innov_var 		# True airspeed innovation variance
-
-float32 tas_scale_raw 		# Estimated true airspeed scale factor (not validated)
-float32 tas_scale_raw_var 	# True airspeed scale factor variance
-
-float32 tas_scale_validated	# Estimated true airspeed scale factor after validation
+float32 tas_scale 		# Estimated true airspeed scale factor

 float32 beta_innov 		# Sideslip measurement innovation
 float32 beta_innov_var 		# Sideslip measurement innovation variance
@@ -1,71 +0,0 @@
-/****************************************************************************
- *
- *   Copyright (c) 2021 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.
- *
- ****************************************************************************/
-#pragma once
-
-#include "../../../s32k1xx/include/px4_arch/spi_hw_description.h"
-
-constexpr bool validateSPIConfig(const px4_spi_bus_t spi_busses_conf[SPI_BUS_MAX_BUS_ITEMS])
-{
-	const bool nuttx_enabled_spi_buses[] = {
-#ifdef CONFIG_S32K1XX_LPSPI0
-		true,
-#else
-		false,
-#endif
-#ifdef CONFIG_S32K1XX_LPSPI1
-		true,
-#else
-		false,
-#endif
-#ifdef CONFIG_S32K1XX_LPSPI2
-		true,
-#else
-		false,
-#endif
-	};
-
-	for (unsigned i = 0; i < sizeof(nuttx_enabled_spi_buses) / sizeof(nuttx_enabled_spi_buses[0]); ++i) {
-		bool found_bus = false;
-
-		for (int j = 0; j < SPI_BUS_MAX_BUS_ITEMS; ++j) {
-			if (spi_busses_conf[j].bus == (int)i + 1) {
-				found_bus = true;
-			}
-		}
-
-		// Either the bus is enabled in NuttX and configured in spi_busses_conf, or disabled and not configured
-		constexpr_assert(found_bus == nuttx_enabled_spi_buses[i], "SPI bus config mismatch (CONFIG_S32K1XX_LPSPIn)");
-	}
-
-	return false;
-}
@@ -240,22 +240,3 @@ static inline constexpr uint32_t getGPIOPin(GPIO::Pin pin)

 	return 0;
 }
-
-namespace SPI
-{
-
-enum class Bus {
-	SPI0 = 1,
-	SPI1,
-	SPI2,
-};
-
-using CS = GPIO::GPIOPin;
-using DRDY = GPIO::GPIOPin;
-
-struct bus_device_external_cfg_t {
-	CS cs_gpio;
-	DRDY drdy_gpio;
-};
-
-} // namespace SPI
@@ -1,133 +0,0 @@
-/****************************************************************************
- *
- *   Copyright (C) 2020 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.
- *
- ****************************************************************************/
-
-#pragma once
-
-#include <px4_arch/hw_description.h>
-#include <px4_platform_common/spi.h>
-
-#include "s32k1xx_config.h"
-#include "s32k1xx_lpspi.h"
-#include "s32k1xx_pin.h"
-
-static inline constexpr px4_spi_bus_device_t initSPIDevice(uint32_t devid, SPI::CS cs_gpio, SPI::DRDY drdy_gpio = {})
-{
-	px4_spi_bus_device_t ret{};
-	ret.cs_gpio = getGPIOPort(cs_gpio.port) | getGPIOPin(cs_gpio.pin) | (GPIO_LOWDRIVE | GPIO_OUTPUT_ONE);
-
-	if (drdy_gpio.port != GPIO::PortInvalid) {
-		ret.drdy_gpio = getGPIOPort(drdy_gpio.port) | getGPIOPin(drdy_gpio.pin) | (GPIO_PULLUP | PIN_INT_BOTH);
-	}
-
-	if (PX4_SPIDEVID_TYPE(devid) == 0) { // it's a PX4 device (internal or external)
-		ret.devid = PX4_SPIDEV_ID(PX4_SPI_DEVICE_ID, devid);
-
-	} else { // it's a NuttX device (e.g. SPIDEV_FLASH(0))
-		ret.devid = devid;
-	}
-
-	ret.devtype_driver = PX4_SPI_DEV_ID(devid);
-	return ret;
-}
-
-static inline constexpr px4_spi_bus_t initSPIBus(SPI::Bus bus, const px4_spi_bus_devices_t &devices,
-		GPIO::GPIOPin power_enable = {})
-{
-	px4_spi_bus_t ret{};
-	ret.requires_locking = false;
-
-	for (int i = 0; i < SPI_BUS_MAX_DEVICES; ++i) {
-		ret.devices[i] = devices.devices[i];
-
-
-		if (ret.devices[i].cs_gpio != 0) {
-			if (PX4_SPI_DEVICE_ID == PX4_SPIDEVID_TYPE(ret.devices[i].devid)) {
-				int same_devices_count = 0;
-
-				for (int j = 0; j < i; ++j) {
-					if (ret.devices[j].cs_gpio != 0) {
-						same_devices_count += (ret.devices[i].devid & 0xff) == (ret.devices[j].devid & 0xff);
-					}
-				}
-
-				// increment the 2. LSB byte to allow multiple devices of the same type
-				ret.devices[i].devid |= same_devices_count << 8;
-
-			} else {
-				// A bus potentially requires locking if it is accessed by non-PX4 devices (i.e. NuttX drivers)
-				ret.requires_locking = true;
-			}
-		}
-	}
-
-	ret.bus = (int)bus;
-	ret.is_external = false;
-
-	if (power_enable.port != GPIO::PortInvalid) {
-		ret.power_enable_gpio = getGPIOPort(power_enable.port) | getGPIOPin(power_enable.pin) |
-					(GPIO_HIGHDRIVE | GPIO_OUTPUT_ONE);
-	}
-
-	return ret;
-}
-
-// just a wrapper since we cannot pass brace-enclosed initialized arrays directly as arguments
-struct bus_device_external_cfg_array_t {
-	SPI::bus_device_external_cfg_t devices[SPI_BUS_MAX_DEVICES];
-};
-
-static inline constexpr px4_spi_bus_t initSPIBusExternal(SPI::Bus bus, const bus_device_external_cfg_array_t &devices)
-{
-	px4_spi_bus_t ret{};
-
-	for (int i = 0; i < SPI_BUS_MAX_DEVICES; ++i) {
-		if (devices.devices[i].cs_gpio.port == GPIO::PortInvalid) {
-			break;
-		}
-
-		ret.devices[i] = initSPIDevice(i, devices.devices[i].cs_gpio, devices.devices[i].drdy_gpio);
-	}
-
-	ret.bus = (int)bus;
-	ret.is_external = true;
-	ret.requires_locking = false; // external buses are never accessed by NuttX drivers
-	return ret;
-}
-
-static inline constexpr SPI::bus_device_external_cfg_t initSPIConfigExternal(SPI::CS cs_gpio, SPI::DRDY drdy_gpio = {})
-{
-	SPI::bus_device_external_cfg_t ret{};
-	ret.cs_gpio = cs_gpio;
-	ret.drdy_gpio = drdy_gpio;
-	return ret;
-}
@@ -1,6 +1,6 @@
 module_name: uLanding Radar
 serial_config:
-    - command: ulanding_radar start -d ${SERIAL_DEV}
+    - command: ulanding_radar start ${SERIAL_DEV}
      port_config_param:
        name: SENS_ULAND_CFG
        group: Sensors
@@ -118,11 +118,6 @@ struct pwm_output_values {

 #endif // not PX4_PWM_ALTERNATE_RANGES

-/**
- * Do not output a channel with this value
- */
-#define PWM_IGNORE_THIS_CHANNEL UINT16_MAX
-
 /**
 * Servo output signal type, value is actual servo output pulse
 * width in microseconds.
@@ -170,15 +165,9 @@ typedef uint16_t	servo_position_t;
 /** start DSM bind */
 #define DSM_BIND_START	_PX4_IOC(_PWM_SERVO_BASE, 10)

-/** set the PWM value for failsafe */
-#define PWM_SERVO_SET_FAILSAFE_PWM	_PX4_IOC(_PWM_SERVO_BASE, 12)
-
 /** get the PWM value for failsafe */
 #define PWM_SERVO_GET_FAILSAFE_PWM	_PX4_IOC(_PWM_SERVO_BASE, 13)

-/** set the PWM value when disarmed - should be no PWM (zero) by default */
-#define PWM_SERVO_SET_DISARMED_PWM	_PX4_IOC(_PWM_SERVO_BASE, 14)
-
 /** get the PWM value when disarmed */
 #define PWM_SERVO_GET_DISARMED_PWM	_PX4_IOC(_PWM_SERVO_BASE, 15)

@@ -197,21 +186,9 @@ typedef uint16_t	servo_position_t;
 /** get the TRIM value the output will send */
 #define PWM_SERVO_GET_TRIM_PWM	_PX4_IOC(_PWM_SERVO_BASE, 21)

-/** set the lockdown override flag to enable outputs in HIL */
-#define PWM_SERVO_SET_DISABLE_LOCKDOWN		_PX4_IOC(_PWM_SERVO_BASE, 23)
-
-/** get the lockdown override flag to enable outputs in HIL */
-#define PWM_SERVO_GET_DISABLE_LOCKDOWN		_PX4_IOC(_PWM_SERVO_BASE, 24)
-
 /** force safety switch off (to disable use of safety switch) */
 #define PWM_SERVO_SET_FORCE_SAFETY_OFF		_PX4_IOC(_PWM_SERVO_BASE, 25)

-/** force failsafe mode (failsafe values are set immediately even if failsafe condition not met) */
-#define PWM_SERVO_SET_FORCE_FAILSAFE		_PX4_IOC(_PWM_SERVO_BASE, 26)
-
-/** make failsafe non-recoverable (termination) if it occurs */
-#define PWM_SERVO_SET_TERMINATION_FAILSAFE	_PX4_IOC(_PWM_SERVO_BASE, 27)
-
 /** force safety switch on (to enable use of safety switch) */
 #define PWM_SERVO_SET_FORCE_SAFETY_ON		_PX4_IOC(_PWM_SERVO_BASE, 28)

@@ -44,10 +44,6 @@ LinuxPWMOut::LinuxPWMOut() :
 	_cycle_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": cycle")),
 	_interval_perf(perf_alloc(PC_INTERVAL, MODULE_NAME": interval"))
 {
-	if (!_mixing_output.useDynamicMixing()) {
-		_mixing_output.setAllMinValues(PWM_DEFAULT_MIN);
-		_mixing_output.setAllMaxValues(PWM_DEFAULT_MAX);
-	}
 }

 LinuxPWMOut::~LinuxPWMOut()
@@ -161,128 +157,6 @@ void LinuxPWMOut::update_params()
 		return;
 	}

-	int32_t pwm_min_default = PWM_DEFAULT_MIN;
-	int32_t pwm_max_default = PWM_DEFAULT_MAX;
-	int32_t pwm_disarmed_default = 0;
-
-	const char *prefix;
-
-	if (_class_instance == CLASS_DEVICE_PRIMARY) {
-		prefix = "PWM_MAIN";
-
-		param_get(param_find("PWM_MAIN_MIN"), &pwm_min_default);
-		param_get(param_find("PWM_MAIN_MAX"), &pwm_max_default);
-		param_get(param_find("PWM_MAIN_DISARM"), &pwm_disarmed_default);
-
-	} else if (_class_instance == CLASS_DEVICE_SECONDARY) {
-		prefix = "PWM_AUX";
-
-		param_get(param_find("PWM_AUX_MIN"), &pwm_min_default);
-		param_get(param_find("PWM_AUX_MAX"), &pwm_max_default);
-		param_get(param_find("PWM_AUX_DISARM"), &pwm_disarmed_default);
-
-	} else if (_class_instance == CLASS_DEVICE_TERTIARY) {
-		prefix = "PWM_EXTRA";
-
-		param_get(param_find("PWM_EXTRA_MIN"), &pwm_min_default);
-		param_get(param_find("PWM_EXTRA_MAX"), &pwm_max_default);
-		param_get(param_find("PWM_EXTRA_DISARM"), &pwm_disarmed_default);
-
-	} else {
-		PX4_ERR("invalid class instance %d", _class_instance);
-		return;
-	}
-
-	char str[17];
-
-	for (unsigned i = 0; i < MAX_ACTUATORS; i++) {
-		// PWM_MAIN_MINx
-		{
-			sprintf(str, "%s_MIN%u", prefix, i + 1);
-			int32_t pwm_min = -1;
-
-			if (param_get(param_find(str), &pwm_min) == PX4_OK && pwm_min >= 0) {
-				_mixing_output.minValue(i) = math::constrain(pwm_min, PWM_LOWEST_MIN, PWM_HIGHEST_MIN);
-
-				if (pwm_min != _mixing_output.minValue(i)) {
-					int32_t pwm_min_new = _mixing_output.minValue(i);
-					param_set(param_find(str), &pwm_min_new);
-				}
-
-			} else {
-				_mixing_output.minValue(i) = pwm_min_default;
-			}
-		}
-
-		// PWM_MAIN_MAXx
-		{
-			sprintf(str, "%s_MAX%u", prefix, i + 1);
-			int32_t pwm_max = -1;
-
-			if (param_get(param_find(str), &pwm_max) == PX4_OK && pwm_max >= 0) {
-				_mixing_output.maxValue(i) = math::constrain(pwm_max, PWM_LOWEST_MAX, PWM_HIGHEST_MAX);
-
-				if (pwm_max != _mixing_output.maxValue(i)) {
-					int32_t pwm_max_new = _mixing_output.maxValue(i);
-					param_set(param_find(str), &pwm_max_new);
-				}
-
-			} else {
-				_mixing_output.maxValue(i) = pwm_max_default;
-			}
-		}
-
-		// PWM_MAIN_FAILx
-		{
-			sprintf(str, "%s_FAIL%u", prefix, i + 1);
-			int32_t pwm_failsafe = -1;
-
-			if (param_get(param_find(str), &pwm_failsafe) == PX4_OK && pwm_failsafe >= 0) {
-				_mixing_output.failsafeValue(i) = math::constrain(pwm_failsafe, 0, PWM_HIGHEST_MAX);
-
-				if (pwm_failsafe != _mixing_output.failsafeValue(i)) {
-					int32_t pwm_fail_new = _mixing_output.failsafeValue(i);
-					param_set(param_find(str), &pwm_fail_new);
-				}
-			}
-		}
-
-		// PWM_MAIN_DISx
-		{
-			sprintf(str, "%s_DIS%u", prefix, i + 1);
-			int32_t pwm_dis = -1;
-
-			if (param_get(param_find(str), &pwm_dis) == PX4_OK && pwm_dis >= 0) {
-				_mixing_output.disarmedValue(i) = math::constrain(pwm_dis, 0, PWM_HIGHEST_MAX);
-
-				if (pwm_dis != _mixing_output.disarmedValue(i)) {
-					int32_t pwm_dis_new = _mixing_output.disarmedValue(i);
-					param_set(param_find(str), &pwm_dis_new);
-				}
-
-			} else {
-				_mixing_output.disarmedValue(i) = pwm_disarmed_default;
-			}
-		}
-
-		// PWM_MAIN_REVx
-		{
-			sprintf(str, "%s_REV%u", prefix, i + 1);
-			int32_t pwm_rev = 0;
-
-			if (param_get(param_find(str), &pwm_rev) == PX4_OK) {
-				uint16_t &reverse_pwm_mask = _mixing_output.reverseOutputMask();
-
-				if (pwm_rev >= 1) {
-					reverse_pwm_mask = reverse_pwm_mask | (2 << i);
-
-				} else {
-					reverse_pwm_mask = reverse_pwm_mask & ~(2 << i);
-				}
-			}
-		}
-	}
-
 	if (_mixing_output.mixers()) {
 		int16_t values[MAX_ACTUATORS] {};

@@ -124,10 +124,6 @@ PCA9685Wrapper::PCA9685Wrapper(int schd_rate_limit) :
 	_cycle_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": cycle")),
 	_schd_rate_limit(schd_rate_limit)
 {
-	if (!_mixing_output.useDynamicMixing()) {
-		_mixing_output.setAllMinValues(PWM_DEFAULT_MIN);
-		_mixing_output.setAllMaxValues(PWM_DEFAULT_MAX);
-	}
 }

 PCA9685Wrapper::~PCA9685Wrapper()
@@ -179,151 +175,6 @@ void PCA9685Wrapper::updatePWMParams()
 		return;
 	}

-	// update pwm params
-	const char *pname_format_pwm_ch_max[2] = {"PWM_MAIN_MAX%d", "PWM_AUX_MAX%d"};
-	const char *pname_format_pwm_ch_min[2] = {"PWM_MAIN_MIN%d", "PWM_AUX_MIN%d"};
-	const char *pname_format_pwm_ch_fail[2] = {"PWM_MAIN_FAIL%d", "PWM_AUX_FAIL%d"};
-	const char *pname_format_pwm_ch_dis[2] = {"PWM_MAIN_DIS%d", "PWM_AUX_DIS%d"};
-	const char *pname_format_pwm_ch_rev[2] = {"PWM_MAIN_REV%d", "PWM_AUX_REV%d"};
-
-	int32_t default_pwm_max = PWM_DEFAULT_MAX,
-		default_pwm_min = PWM_DEFAULT_MIN,
-		default_pwm_fail = PWM_DEFAULT_MIN,
-		default_pwm_dis = PWM_MOTOR_OFF;
-
-	param_t param_h = param_find("PWM_MAIN_MAX");
-
-	if (param_h != PARAM_INVALID) {
-		param_get(param_h, &default_pwm_max);
-
-	} else {
-		PX4_DEBUG("PARAM_INVALID: %s", "PWM_MAIN_MAX");
-	}
-
-	param_h = param_find("PWM_MAIN_MIN");
-
-	if (param_h != PARAM_INVALID) {
-		param_get(param_h, &default_pwm_min);
-
-	} else {
-		PX4_DEBUG("PARAM_INVALID: %s", "PWM_MAIN_MIN");
-	}
-
-	param_h = param_find("PWM_MAIN_RATE");
-
-	if (param_h != PARAM_INVALID) {
-		int32_t pval = 0;
-		param_get(param_h, &pval);
-
-		if (_last_fetched_Freq != pval) {
-			_last_fetched_Freq = pval;
-			_targetFreq = (float)pval;  // update only if changed
-		}
-
-	} else {
-		PX4_DEBUG("PARAM_INVALID: %s", "PWM_MAIN_RATE");
-	}
-
-	for (int i = 0; i < PCA9685_PWM_CHANNEL_COUNT; i++) {
-		char pname[16];
-		uint8_t param_group, param_index;
-
-		if (i <= 7) {	// Main channel
-			param_group = 0;
-			param_index = i + 1;
-
-		} else {	// AUX
-			param_group = 1;
-			param_index = i - 8 + 1;
-		}
-
-		sprintf(pname, pname_format_pwm_ch_max[param_group], param_index);
-		param_h = param_find(pname);
-
-		if (param_h != PARAM_INVALID) {
-			int32_t pval = 0;
-			param_get(param_h, &pval);
-
-			if (pval != -1) {
-				_mixing_output.maxValue(i) = pval;
-
-			} else {
-				_mixing_output.maxValue(i) = default_pwm_max;
-			}
-
-		} else {
-			PX4_DEBUG("PARAM_INVALID: %s", pname);
-		}
-
-		sprintf(pname, pname_format_pwm_ch_min[param_group], param_index);
-		param_h = param_find(pname);
-
-		if (param_h != PARAM_INVALID) {
-			int32_t pval = 0;
-			param_get(param_h, &pval);
-
-			if (pval != -1) {
-				_mixing_output.minValue(i) = pval;
-
-			} else {
-				_mixing_output.minValue(i) = default_pwm_min;
-			}
-
-		} else {
-			PX4_DEBUG("PARAM_INVALID: %s", pname);
-		}
-
-		sprintf(pname, pname_format_pwm_ch_fail[param_group], param_index);
-		param_h = param_find(pname);
-
-		if (param_h != PARAM_INVALID) {
-			int32_t pval = 0;
-			param_get(param_h, &pval);
-
-			if (pval != -1) {
-				_mixing_output.failsafeValue(i) = pval;
-
-			} else {
-				_mixing_output.failsafeValue(i) = default_pwm_fail;
-			}
-
-		} else {
-			PX4_DEBUG("PARAM_INVALID: %s", pname);
-		}
-
-		sprintf(pname, pname_format_pwm_ch_dis[param_group], param_index);
-		param_h = param_find(pname);
-
-		if (param_h != PARAM_INVALID) {
-			int32_t pval = 0;
-			param_get(param_h, &pval);
-
-			if (pval != -1) {
-				_mixing_output.disarmedValue(i) = pval;
-
-			} else {
-				_mixing_output.disarmedValue(i) = default_pwm_dis;
-			}
-
-		} else {
-			PX4_DEBUG("PARAM_INVALID: %s", pname);
-		}
-
-		sprintf(pname, pname_format_pwm_ch_rev[param_group], param_index);
-		param_h = param_find(pname);
-
-		if (param_h != PARAM_INVALID) {
-			uint16_t &reverse_pwm_mask = _mixing_output.reverseOutputMask();
-			int32_t pval = 0;
-			param_get(param_h, &pval);
-			reverse_pwm_mask &= (0xfffe << i);  // clear this bit
-			reverse_pwm_mask |= (((uint16_t)(pval != 0)) << i); // set to new val
-
-		} else {
-			PX4_DEBUG("PARAM_INVALID: %s", pname);
-		}
-	}
-
 	if (_mixing_output.mixers()) { // only update trims if mixer loaded
 		updatePWMParamTrim();
 	}
@@ -56,10 +56,6 @@ PWMOut::PWMOut(int instance, uint8_t output_base) :
 	_cycle_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": cycle")),
 	_interval_perf(perf_alloc(PC_INTERVAL, MODULE_NAME": interval"))
 {
-	if (!_mixing_output.useDynamicMixing()) {
-		_mixing_output.setAllMinValues(PWM_DEFAULT_MIN);
-		_mixing_output.setAllMaxValues(PWM_DEFAULT_MAX);
-	}
 }

 PWMOut::~PWMOut()
@@ -487,10 +483,6 @@ void PWMOut::Run()
 		}
 	}

-	if (_pwm_initialized && _current_update_rate == 0 && !_mixing_output.useDynamicMixing()) {
-		update_current_rate();
-	}
-
 	// check at end of cycle (updateSubscriptions() can potentially change to a different WorkQueue thread)
 	_mixing_output.updateSubscriptions(true, true);

@@ -505,9 +497,6 @@ void PWMOut::update_params()
 		return;
 	}

-	int32_t pwm_min_default = PWM_DEFAULT_MIN;
-	int32_t pwm_max_default = PWM_DEFAULT_MAX;
-	int32_t pwm_disarmed_default = 0;
 	int32_t pwm_rate_default = 50;
 	int32_t pwm_default_channels = 0;

@@ -516,28 +505,20 @@ void PWMOut::update_params()
 	if (_class_instance == CLASS_DEVICE_PRIMARY) {
 		prefix = "PWM_MAIN";

-		param_get(param_find("PWM_MAIN_MIN"), &pwm_min_default);
-		param_get(param_find("PWM_MAIN_MAX"), &pwm_max_default);
-		param_get(param_find("PWM_MAIN_DISARM"), &pwm_disarmed_default);
 		param_get(param_find("PWM_MAIN_RATE"), &pwm_rate_default);
 		param_get(param_find("PWM_MAIN_OUT"), &pwm_default_channels);

 	} else if (_class_instance == CLASS_DEVICE_SECONDARY) {
 		prefix = "PWM_AUX";

-		param_get(param_find("PWM_AUX_MIN"), &pwm_min_default);
-		param_get(param_find("PWM_AUX_MAX"), &pwm_max_default);
-		param_get(param_find("PWM_AUX_DISARM"), &pwm_disarmed_default);
 		param_get(param_find("PWM_AUX_RATE"), &pwm_rate_default);
 		param_get(param_find("PWM_AUX_OUT"), &pwm_default_channels);

 	} else if (_class_instance == CLASS_DEVICE_TERTIARY) {
 		prefix = "PWM_EXTRA";

-		param_get(param_find("PWM_EXTRA_MIN"), &pwm_min_default);
-		param_get(param_find("PWM_EXTRA_MAX"), &pwm_max_default);
-		param_get(param_find("PWM_EXTRA_DISARM"), &pwm_disarmed_default);
 		param_get(param_find("PWM_EXTRA_RATE"), &pwm_rate_default);
+		param_get(param_find("PWM_EXTRA_OUT"), &pwm_default_channels);

 	} else {
 		PX4_ERR("invalid class instance %d", _class_instance);
@@ -558,106 +539,6 @@ void PWMOut::update_params()

 	char str[17];

-	for (unsigned i = 0; i < _num_outputs; i++) {
-		// PWM_MAIN_MINx
-		{
-			sprintf(str, "%s_MIN%u", prefix, i + 1);
-			int32_t pwm_min = -1;
-
-			if (param_get(param_find(str), &pwm_min) == PX4_OK) {
-				if (pwm_min >= 0 && pwm_min != 1000) {
-					_mixing_output.minValue(i) = math::constrain(pwm_min, (int32_t) PWM_LOWEST_MIN, (int32_t) PWM_HIGHEST_MIN);
-
-					if (pwm_min != _mixing_output.minValue(i)) {
-						int32_t pwm_min_new = _mixing_output.minValue(i);
-						param_set(param_find(str), &pwm_min_new);
-					}
-
-				} else if (pwm_default_channel_mask & 1 << i) {
-					_mixing_output.minValue(i) = pwm_min_default;
-				}
-			}
-		}
-
-		// PWM_MAIN_MAXx
-		{
-			sprintf(str, "%s_MAX%u", prefix, i + 1);
-			int32_t pwm_max = -1;
-
-			if (param_get(param_find(str), &pwm_max) == PX4_OK) {
-				if (pwm_max >= 0 && pwm_max != 2000) {
-					_mixing_output.maxValue(i) = math::constrain(pwm_max, (int32_t) PWM_LOWEST_MAX, (int32_t) PWM_HIGHEST_MAX);
-
-					if (pwm_max != _mixing_output.maxValue(i)) {
-						int32_t pwm_max_new = _mixing_output.maxValue(i);
-						param_set(param_find(str), &pwm_max_new);
-					}
-
-				} else if (pwm_default_channel_mask & 1 << i) {
-					_mixing_output.maxValue(i) = pwm_max_default;
-				}
-			}
-		}
-
-		// PWM_MAIN_FAILx
-		{
-			sprintf(str, "%s_FAIL%u", prefix, i + 1);
-			int32_t pwm_failsafe = -1;
-
-			if (param_get(param_find(str), &pwm_failsafe) == PX4_OK) {
-				if (pwm_failsafe >= 0) {
-					_mixing_output.failsafeValue(i) = math::constrain(pwm_failsafe, (int32_t) 0, (int32_t) PWM_HIGHEST_MAX);
-
-					if (pwm_failsafe != _mixing_output.failsafeValue(i)) {
-						int32_t pwm_fail_new = _mixing_output.failsafeValue(i);
-						param_set(param_find(str), &pwm_fail_new);
-					}
-				}
-			}
-		}
-
-		// PWM_MAIN_DISx
-		{
-			sprintf(str, "%s_DIS%u", prefix, i + 1);
-			int32_t pwm_dis = -1;
-
-			if (param_get(param_find(str), &pwm_dis) == PX4_OK) {
-				if (pwm_dis >= 0 && pwm_dis != 900) {
-					_mixing_output.disarmedValue(i) = math::constrain(pwm_dis, (int32_t) 0, (int32_t) PWM_HIGHEST_MAX);
-
-					if (pwm_dis != _mixing_output.disarmedValue(i)) {
-						int32_t pwm_dis_new = _mixing_output.disarmedValue(i);
-						param_set(param_find(str), &pwm_dis_new);
-					}
-
-				} else if (pwm_default_channel_mask & 1 << i) {
-					_mixing_output.disarmedValue(i) = pwm_disarmed_default;
-				}
-			}
-
-			if (_mixing_output.disarmedValue(i) > 0) {
-				num_disarmed_set++;
-			}
-		}
-
-		// PWM_MAIN_REVx
-		{
-			sprintf(str, "%s_REV%u", prefix, i + 1);
-			int32_t pwm_rev = 0;
-
-			if (param_get(param_find(str), &pwm_rev) == PX4_OK) {
-				uint16_t &reverse_pwm_mask = _mixing_output.reverseOutputMask();
-
-				if (pwm_rev >= 1) {
-					reverse_pwm_mask = reverse_pwm_mask | (1 << i);
-
-				} else {
-					reverse_pwm_mask = reverse_pwm_mask & ~(1 << i);
-				}
-			}
-		}
-	}
-
 	if (_mixing_output.mixers()) {
 		int16_t values[FMU_MAX_ACTUATORS] {};

@@ -736,40 +617,6 @@ int PWMOut::pwm_ioctl(file *filp, int cmd, unsigned long arg)
 		*(uint32_t *)arg = _pwm_alt_rate_channels;
 		break;

-	case PWM_SERVO_SET_FAILSAFE_PWM: {
-			struct pwm_output_values *pwm = (struct pwm_output_values *)arg;
-
-			/* discard if too many values are sent */
-			if (pwm->channel_count > FMU_MAX_ACTUATORS || _mixing_output.useDynamicMixing()) {
-				ret = -EINVAL;
-				break;
-			}
-
-			for (unsigned i = 0; i < pwm->channel_count; i++) {
-				if (pwm->values[i] == 0) {
-					/* ignore 0 */
-				} else if (pwm->values[i] > PWM_HIGHEST_MAX) {
-					_mixing_output.failsafeValue(i) = PWM_HIGHEST_MAX;
-
-				}
-
-#if PWM_LOWEST_MIN > 0
-
-				else if (pwm->values[i] < PWM_LOWEST_MIN) {
-					_mixing_output.failsafeValue(i) = PWM_LOWEST_MIN;
-
-				}
-
-#endif
-
-				else {
-					_mixing_output.failsafeValue(i) = pwm->values[i];
-				}
-			}
-
-			break;
-		}
-
 	case PWM_SERVO_GET_FAILSAFE_PWM: {
 			struct pwm_output_values *pwm = (struct pwm_output_values *)arg;

@@ -781,50 +628,6 @@ int PWMOut::pwm_ioctl(file *filp, int cmd, unsigned long arg)
 			break;
 		}

-	case PWM_SERVO_SET_DISARMED_PWM: {
-			struct pwm_output_values *pwm = (struct pwm_output_values *)arg;
-
-			/* discard if too many values are sent */
-			if (pwm->channel_count > FMU_MAX_ACTUATORS || _mixing_output.useDynamicMixing()) {
-				ret = -EINVAL;
-				break;
-			}
-
-			for (unsigned i = 0; i < pwm->channel_count; i++) {
-				if (pwm->values[i] == 0) {
-					/* ignore 0 */
-				} else if (pwm->values[i] > PWM_HIGHEST_MAX) {
-					_mixing_output.disarmedValue(i) = PWM_HIGHEST_MAX;
-				}
-
-#if PWM_LOWEST_MIN > 0
-
-				else if (pwm->values[i] < PWM_LOWEST_MIN) {
-					_mixing_output.disarmedValue(i) = PWM_LOWEST_MIN;
-				}
-
-#endif
-
-				else {
-					_mixing_output.disarmedValue(i) = pwm->values[i];
-				}
-			}
-
-			/*
-			 * update the counter
-			 * this is needed to decide if disarmed PWM output should be turned on or not
-			 */
-			_num_disarmed_set = 0;
-
-			for (unsigned i = 0; i < FMU_MAX_ACTUATORS; i++) {
-				if (_mixing_output.disarmedValue(i) > 0) {
-					_num_disarmed_set++;
-				}
-			}
-
-			break;
-		}
-
 	case PWM_SERVO_GET_DISARMED_PWM: {
 			struct pwm_output_values *pwm = (struct pwm_output_values *)arg;

@@ -178,7 +178,6 @@ private:

 	static int checkcrc(int argc, char *argv[]);
 	static int bind(int argc, char *argv[]);
-	static int lockdown(int argc, char *argv[]);
 	static int monitor();

 	static constexpr int PX4IO_MAX_ACTUATORS = 8;
@@ -239,12 +238,6 @@ private:

 	MixingOutput _mixing_output{"PWM_MAIN", PX4IO_MAX_ACTUATORS, *this, MixingOutput::SchedulingPolicy::Auto, true};

-	bool _pwm_min_configured{false};
-	bool _pwm_max_configured{false};
-	bool _pwm_fail_configured{false};
-	bool _pwm_dis_configured{false};
-	bool _pwm_rev_configured{false};
-
 	/**
 	 * Update IO's arming-related state
 	 */
@@ -366,11 +359,6 @@ PX4IO::PX4IO(device::Device *interface) :
 	OutputModuleInterface(MODULE_NAME, px4::serial_port_to_wq(PX4IO_SERIAL_DEVICE)),
 	_interface(interface)
 {
-	if (!_mixing_output.useDynamicMixing()) {
-		_mixing_output.setAllMinValues(PWM_DEFAULT_MIN);
-		_mixing_output.setAllMaxValues(PWM_DEFAULT_MAX);
-	}
-
 	_mixing_output.setLowrateSchedulingInterval(20_ms);
 }

@@ -757,11 +745,14 @@ void PX4IO::updateTimerRateGroups()

 void PX4IO::update_params()
 {
+	if (!_mixing_output.armed().armed) {
+		updateFailsafe();
+		updateDisarmed();
+	}
+
 	if (!_mixing_output.armed().armed && _mixing_output.useDynamicMixing()) {
 		// sync params to IO
 		updateTimerRateGroups();
-		updateFailsafe();
-		updateDisarmed();
 		return;
 	}

@@ -770,17 +761,11 @@ void PX4IO::update_params()
 		return;
 	}

-	int32_t pwm_min_default = PWM_DEFAULT_MIN;
-	int32_t pwm_max_default = PWM_DEFAULT_MAX;
-	int32_t pwm_disarmed_default = 0;
 	int32_t pwm_rate_default = 50;
 	int32_t pwm_default_channels = 0;

 	const char *prefix = "PWM_MAIN";

-	param_get(param_find("PWM_MAIN_MIN"), &pwm_min_default);
-	param_get(param_find("PWM_MAIN_MAX"), &pwm_max_default);
-	param_get(param_find("PWM_MAIN_DISARM"), &pwm_disarmed_default);
 	param_get(param_find("PWM_MAIN_RATE"), &pwm_rate_default);
 	param_get(param_find("PWM_MAIN_OUT"), &pwm_default_channels);

@@ -794,125 +779,6 @@ void PX4IO::update_params()

 	char str[17];

-	// PWM_MAIN_MINx
-	if (!_pwm_min_configured) {
-		for (unsigned i = 0; i < _max_actuators; i++) {
-			sprintf(str, "%s_MIN%u", prefix, i + 1);
-			int32_t pwm_min = -1;
-
-			if (param_get(param_find(str), &pwm_min) == PX4_OK) {
-				if (pwm_min >= 0 && pwm_min != 1000) {
-					_mixing_output.minValue(i) = math::constrain(pwm_min, static_cast<int32_t>(PWM_LOWEST_MIN),
-								     static_cast<int32_t>(PWM_HIGHEST_MIN));
-
-					if (pwm_min != _mixing_output.minValue(i)) {
-						int32_t pwm_min_new = _mixing_output.minValue(i);
-						param_set(param_find(str), &pwm_min_new);
-					}
-
-				} else if (pwm_default_channel_mask & 1 << i) {
-					_mixing_output.minValue(i) = pwm_min_default;
-				}
-			}
-		}
-
-		_pwm_min_configured = true;
-	}
-
-	// PWM_MAIN_MAXx
-	if (!_pwm_max_configured) {
-		for (unsigned i = 0; i < _max_actuators; i++) {
-			sprintf(str, "%s_MAX%u", prefix, i + 1);
-			int32_t pwm_max = -1;
-
-			if (param_get(param_find(str), &pwm_max) == PX4_OK) {
-				if (pwm_max >= 0 && pwm_max != 2000) {
-					_mixing_output.maxValue(i) = math::constrain(pwm_max, static_cast<int32_t>(PWM_LOWEST_MAX),
-								     static_cast<int32_t>(PWM_HIGHEST_MAX));
-
-					if (pwm_max != _mixing_output.maxValue(i)) {
-						int32_t pwm_max_new = _mixing_output.maxValue(i);
-						param_set(param_find(str), &pwm_max_new);
-					}
-
-				} else if (pwm_default_channel_mask & 1 << i) {
-					_mixing_output.maxValue(i) = pwm_max_default;
-				}
-			}
-		}
-
-		_pwm_max_configured = true;
-	}
-
-	// PWM_MAIN_FAILx
-	if (!_pwm_fail_configured) {
-		for (unsigned i = 0; i < _max_actuators; i++) {
-			sprintf(str, "%s_FAIL%u", prefix, i + 1);
-			int32_t pwm_fail = -1;
-
-			if (param_get(param_find(str), &pwm_fail) == PX4_OK) {
-				if (pwm_fail >= 0) {
-					_mixing_output.failsafeValue(i) = math::constrain(pwm_fail, static_cast<int32_t>(0),
-									  static_cast<int32_t>(PWM_HIGHEST_MAX));
-
-					if (pwm_fail != _mixing_output.failsafeValue(i)) {
-						int32_t pwm_fail_new = _mixing_output.failsafeValue(i);
-						param_set(param_find(str), &pwm_fail_new);
-					}
-				}
-			}
-		}
-
-		_pwm_fail_configured = true;
-		updateFailsafe();
-	}
-
-	// PWM_MAIN_DISx
-	if (!_pwm_dis_configured) {
-		for (unsigned i = 0; i < _max_actuators; i++) {
-			sprintf(str, "%s_DIS%u", prefix, i + 1);
-			int32_t pwm_dis = -1;
-
-			if (param_get(param_find(str), &pwm_dis) == PX4_OK) {
-				if (pwm_dis >= 0 && pwm_dis != 900) {
-					_mixing_output.disarmedValue(i) = math::constrain(pwm_dis, static_cast<int32_t>(0),
-									  static_cast<int32_t>(PWM_HIGHEST_MAX));
-
-					if (pwm_dis != _mixing_output.disarmedValue(i)) {
-						int32_t pwm_dis_new = _mixing_output.disarmedValue(i);
-						param_set(param_find(str), &pwm_dis_new);
-					}
-
-				} else if (pwm_default_channel_mask & 1 << i) {
-					_mixing_output.disarmedValue(i) = pwm_disarmed_default;
-				}
-			}
-		}
-
-		_pwm_dis_configured = true;
-		updateDisarmed();
-	}
-
-	// PWM_MAIN_REVx
-	if (!_pwm_rev_configured) {
-		uint16_t &reverse_pwm_mask = _mixing_output.reverseOutputMask();
-		reverse_pwm_mask = 0;
-
-		for (unsigned i = 0; i < _max_actuators; i++) {
-			sprintf(str, "%s_REV%u", prefix, i + 1);
-			int32_t pwm_rev = -1;
-
-			if (param_get(param_find(str), &pwm_rev) == PX4_OK) {
-				if (pwm_rev >= 1) {
-					reverse_pwm_mask |= (1 << i);
-				}
-
-			}
-		}
-
-		_pwm_rev_configured = true;
-	}
-
 	// PWM_MAIN_TRIMx
 	if (_mixing_output.mixers()) {
 		int16_t values[8] {};
@@ -1648,27 +1514,6 @@ int PX4IO::ioctl(file *filep, int cmd, unsigned long arg)
 		*(unsigned *)arg = io_reg_get(PX4IO_PAGE_SETUP, PX4IO_P_SETUP_PWM_RATES);
 		break;

-	case PWM_SERVO_SET_FAILSAFE_PWM: {
-			PX4_DEBUG("PWM_SERVO_SET_FAILSAFE_PWM");
-			struct pwm_output_values *pwm = (struct pwm_output_values *)arg;
-
-			if (pwm->channel_count > _max_actuators)
-				/* fail with error */
-			{
-				return -E2BIG;
-			}
-
-			for (unsigned i = 0; i < pwm->channel_count; i++) {
-				if (pwm->values[i] != 0 && !_mixing_output.useDynamicMixing()) {
-					_mixing_output.failsafeValue(i) = math::constrain(pwm->values[i], (uint16_t)PWM_LOWEST_MIN, (uint16_t)PWM_HIGHEST_MAX);
-				}
-			}
-
-			updateFailsafe();
-
-			break;
-		}
-
 	case PWM_SERVO_GET_FAILSAFE_PWM: {
 			PX4_DEBUG("PWM_SERVO_GET_FAILSAFE_PWM");
 			struct pwm_output_values *pwm = (struct pwm_output_values *)arg;
@@ -1683,26 +1528,6 @@ int PX4IO::ioctl(file *filep, int cmd, unsigned long arg)
 			break;
 		}

-	case PWM_SERVO_SET_DISARMED_PWM: {
-			PX4_DEBUG("PWM_SERVO_SET_DISARMED_PWM");
-			struct pwm_output_values *pwm = (struct pwm_output_values *)arg;
-
-			if (pwm->channel_count > _max_actuators) {
-				/* fail with error */
-				return -E2BIG;
-			}
-
-			for (unsigned i = 0; i < pwm->channel_count; i++) {
-				if (pwm->values[i] != 0 && !_mixing_output.useDynamicMixing()) {
-					_mixing_output.disarmedValue(i) = math::constrain(pwm->values[i], (uint16_t)PWM_LOWEST_MIN, (uint16_t)PWM_HIGHEST_MAX);
-				}
-			}
-
-			updateDisarmed();
-
-			break;
-		}
-
 	case PWM_SERVO_GET_DISARMED_PWM: {
 			PX4_DEBUG("PWM_SERVO_GET_DISARMED_PWM");
 			struct pwm_output_values *pwm = (struct pwm_output_values *)arg;
@@ -1794,16 +1619,6 @@ int PX4IO::ioctl(file *filep, int cmd, unsigned long arg)
 		*(unsigned *)arg = _max_actuators;
 		break;

-	case PWM_SERVO_SET_DISABLE_LOCKDOWN:
-		PX4_DEBUG("PWM_SERVO_SET_DISABLE_LOCKDOWN");
-		_lockdown_override = arg;
-		break;
-
-	case PWM_SERVO_GET_DISABLE_LOCKDOWN:
-		PX4_DEBUG("PWM_SERVO_GET_DISABLE_LOCKDOWN");
-		*(unsigned *)arg = _lockdown_override;
-		break;
-
 	case PWM_SERVO_SET_FORCE_SAFETY_OFF:
 		PX4_DEBUG("PWM_SERVO_SET_FORCE_SAFETY_OFF");
 		/* force safety swith off */
@@ -1816,36 +1631,6 @@ int PX4IO::ioctl(file *filep, int cmd, unsigned long arg)
 		ret = io_reg_set(PX4IO_PAGE_SETUP, PX4IO_P_SETUP_FORCE_SAFETY_ON, PX4IO_FORCE_SAFETY_MAGIC);
 		break;

-	case PWM_SERVO_SET_FORCE_FAILSAFE:
-		PX4_DEBUG("PWM_SERVO_SET_FORCE_FAILSAFE");
-
-		/* force failsafe mode instantly */
-		if (arg == 0) {
-			/* clear force failsafe flag */
-			ret = io_reg_modify(PX4IO_PAGE_SETUP, PX4IO_P_SETUP_ARMING, PX4IO_P_SETUP_ARMING_FORCE_FAILSAFE, 0);
-
-		} else {
-			/* set force failsafe flag */
-			ret = io_reg_modify(PX4IO_PAGE_SETUP, PX4IO_P_SETUP_ARMING, 0, PX4IO_P_SETUP_ARMING_FORCE_FAILSAFE);
-		}
-
-		break;
-
-	case PWM_SERVO_SET_TERMINATION_FAILSAFE:
-		PX4_DEBUG("PWM_SERVO_SET_TERMINATION_FAILSAFE");
-
-		/* if failsafe occurs, do not allow the system to recover */
-		if (arg == 0) {
-			/* clear termination failsafe flag */
-			ret = io_reg_modify(PX4IO_PAGE_SETUP, PX4IO_P_SETUP_ARMING, PX4IO_P_SETUP_ARMING_TERMINATION_FAILSAFE, 0);
-
-		} else {
-			/* set termination failsafe flag */
-			ret = io_reg_modify(PX4IO_PAGE_SETUP, PX4IO_P_SETUP_ARMING, 0, PX4IO_P_SETUP_ARMING_TERMINATION_FAILSAFE);
-		}
-
-		break;
-
 	case DSM_BIND_START:
 		/* bind a DSM receiver */
 		ret = dsm_bind_ioctl(arg);
@@ -2211,60 +1996,6 @@ int PX4IO::monitor()
 	return 0;
 }

-int PX4IO::lockdown(int argc, char *argv[])
-{
-	if (argc > 1 && !strcmp(argv[1], "disable")) {
-
-		PX4_WARN("WARNING: ACTUATORS WILL BE LIVE IN HIL! PROCEED?");
-		PX4_WARN("Press 'y' to enable, any other key to abort.");
-
-		/* check if user wants to abort */
-		char c;
-
-		struct pollfd fds;
-		int ret;
-		hrt_abstime start = hrt_absolute_time();
-		const unsigned long timeout = 5000000;
-
-		while (hrt_elapsed_time(&start) < timeout) {
-			fds.fd = 0; /* stdin */
-			fds.events = POLLIN;
-			ret = ::poll(&fds, 1, 0);
-
-			if (ret > 0) {
-
-				if (::read(0, &c, 1) > 0) {
-
-					if (c != 'y') {
-						return 0;
-
-					} else if (c == 'y') {
-						break;
-					}
-				}
-			}
-
-			px4_usleep(10000);
-		}
-
-		if (hrt_elapsed_time(&start) > timeout) {
-			PX4_ERR("TIMEOUT! ABORTED WITHOUT CHANGES.");
-			return 1;
-		}
-
-		get_instance()->ioctl(0, PWM_SERVO_SET_DISABLE_LOCKDOWN, 1);
-
-		PX4_WARN("ACTUATORS ARE NOW LIVE IN HIL!");
-
-	} else {
-		get_instance()->ioctl(0, PWM_SERVO_SET_DISABLE_LOCKDOWN, 0);
-		PX4_WARN("ACTUATORS ARE NOW SAFE IN HIL.");
-	}
-
-	return 0;
-}
-
-
 int PX4IO::task_spawn(int argc, char *argv[])
 {
 	device::Device *interface = get_interface();
@@ -2468,10 +2199,6 @@ int PX4IO::custom_command(int argc, char *argv[])
 		return bind(argc - 1, argv + 1);
 	}

-	if (!strcmp(verb, "lockdown")) {
-		return lockdown(argc, argv);
-	}
-
 	if (!strcmp(verb, "sbus1_out")) {
 		int ret = get_instance()->ioctl(nullptr, SBUS_SET_PROTO_VERSION, 1);

@@ -2534,8 +2261,6 @@ Output driver communicating with the IO co-processor.
 	PRINT_MODULE_USAGE_COMMAND_DESCR("monitor", "continuously monitor status");
 	PRINT_MODULE_USAGE_COMMAND_DESCR("bind", "DSM bind");
 	PRINT_MODULE_USAGE_ARG("dsm2|dsmx|dsmx8", "protocol", false);
-	PRINT_MODULE_USAGE_COMMAND_DESCR("lockdown", "enable (or disable) lockdown");
-	PRINT_MODULE_USAGE_ARG("disable", "disable lockdown", true);
 	PRINT_MODULE_USAGE_COMMAND_DESCR("sbus1_out", "enable sbus1 out");
 	PRINT_MODULE_USAGE_COMMAND_DESCR("sbus2_out", "enable sbus2 out");
 	PRINT_MODULE_USAGE_COMMAND_DESCR("test_fmu_fail", "test: turn off IO updates");
@@ -676,17 +676,6 @@ UavcanNode::init(uavcan::NodeID node_id, UAVCAN_DRIVER::BusEvent &bus_events)
 		return -EINVAL;
 	}

-	_mixing_interface_esc.mixingOutput().setAllDisarmedValues(UavcanEscController::DISARMED_OUTPUT_VALUE);
-
-	if (!_mixing_interface_esc.mixingOutput().useDynamicMixing()) {
-		// these are configurable with dynamic mixing
-		_mixing_interface_esc.mixingOutput().setAllMinValues(0); // Can be changed to 1 later, according to UAVCAN_ESC_IDLT
-		_mixing_interface_esc.mixingOutput().setAllMaxValues(UavcanEscController::max_output_value());
-
-		param_get(param_find("UAVCAN_ESC_IDLT"), &_idle_throttle_when_armed_param);
-		enable_idle_throttle_when_armed(true);
-	}
-
 	/*  Start the Node   */
 	return _node.start();
 }
@@ -791,10 +780,6 @@ UavcanNode::Run()

 	node_spin_once(); // expected to be non-blocking

-	// Check arming state
-	const actuator_armed_s &armed = _mixing_interface_esc.mixingOutput().armed();
-	enable_idle_throttle_when_armed(!armed.soft_stop);
-
 	// check for parameter updates
 	if (_parameter_update_sub.updated()) {
 		// clear update
@@ -838,19 +823,6 @@ UavcanNode::Run()
 	}
 }

-void
-UavcanNode::enable_idle_throttle_when_armed(bool value)
-{
-	value &= _idle_throttle_when_armed_param > 0;
-
-	if (!_mixing_interface_esc.mixingOutput().useDynamicMixing()) {
-		if (value != _idle_throttle_when_armed) {
-			_mixing_interface_esc.mixingOutput().setAllMinValues(value ? 1 : 0);
-			_idle_throttle_when_armed = value;
-		}
-	}
-}
-
 int
 UavcanNode::teardown()
 {
@@ -1205,7 +1177,7 @@ int uavcan_main(int argc, char *argv[])
 	}

 	if (!std::strcmp(argv[1], "hardpoint")) {
-		if (argc > 4 && !std::strcmp(argv[2], "set")) {
+		if (!std::strcmp(argv[2], "set") && argc > 4) {
 			const int hardpoint_id = atoi(argv[3]);
 			const int command = atoi(argv[4]);

@@ -216,8 +216,6 @@ private:
 	void		set_setget_response(uavcan::protocol::param::GetSet::Response *resp) { _setget_response = resp; }
 	void		free_setget_response(void) { _setget_response = nullptr; }

-	void enable_idle_throttle_when_armed(bool value);
-
 	px4::atomic_bool	_task_should_exit{false};	///< flag to indicate to tear down the CAN driver
 	px4::atomic<int>	_fw_server_action{None};
 	int			 _fw_server_status{-1};
@@ -77,15 +77,6 @@ PARAM_DEFINE_INT32(UAVCAN_NODE_ID, 1);
 */
 PARAM_DEFINE_INT32(UAVCAN_BITRATE, 1000000);

-/**
- * UAVCAN ESC will spin at idle throttle when armed, even if the mixer outputs zero setpoints.
- *
- * @boolean
- * @reboot_required true
- * @group UAVCAN
- */
-PARAM_DEFINE_INT32(UAVCAN_ESC_IDLT, 1);
-
 /**
 * UAVCAN rangefinder minimum range
 *
@@ -73,7 +73,7 @@ if DRIVERS_UAVCAN_V1
            default n

        config UAVCAN_V1_GNSS_SUBSCRIBER_0
-            bool "GNSS Subscriber 0"
+            bool "GNSS Subscriber 0 "
            default n

        config UAVCAN_V1_GNSS_SUBSCRIBER_1
@@ -1,92 +0,0 @@
-/****************************************************************************
- *
- *   Copyright (c) 2021 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.
- *
- ****************************************************************************/
-
-/**
- * @file NodeClient.hpp
- *
- * Defines basic implementation of UAVCAN PNP for dynamic Node ID
- *
- * @author Peter van der Perk <peter.vanderperk@nxp.com>
- */
-
-#pragma once
-
-
-#include <px4_platform_common/defines.h>
-#include <drivers/drv_hrt.h>
-
-#include "CanardInterface.hpp"
-
-#include <uavcan/node/ID_1_0.h>
-#include <uavcan/pnp/NodeIDAllocationData_1_0.h>
-#include <uavcan/pnp/NodeIDAllocationData_2_0.h>
-
-#include "Services/AccessRequest.hpp"
-#include "Services/ListRequest.hpp"
-
-#define PNP1_PORT_ID                                 uavcan_pnp_NodeIDAllocationData_1_0_FIXED_PORT_ID_
-#define PNP1_PAYLOAD_SIZE                            uavcan_pnp_NodeIDAllocationData_1_0_SERIALIZATION_BUFFER_SIZE_BYTES_
-#define PNP2_PORT_ID                                 uavcan_pnp_NodeIDAllocationData_2_0_FIXED_PORT_ID_
-#define PNP2_PAYLOAD_SIZE                            uavcan_pnp_NodeIDAllocationData_2_0_SERIALIZATION_BUFFER_SIZE_BYTES_
-
-class NodeClient : public UavcanBaseSubscriber
-{
-public:
-	NodeClient(CanardInstance &ins, UavcanParamManager &pmgr) : UavcanBaseSubscriber(ins, "NodeIDAllocationData", 0),
-		_canard_instance(ins) { };
-
-	void subscribe() override
-	{
-
-		canardRxSubscribe(&_canard_instance,
-				  CanardTransferKindMessage,
-				  (_canard_instance.mtu_bytes == CANARD_MTU_CAN_FD ? PNP2_PORT_ID : PNP1_PORT_ID),  // The fixed Subject-ID
-				  (_canard_instance.mtu_bytes == CANARD_MTU_CAN_FD ? PNP2_PAYLOAD_SIZE : PNP1_PAYLOAD_SIZE),
-				  CANARD_DEFAULT_TRANSFER_ID_TIMEOUT_USEC,
-				  &_subj_sub._canard_sub);
-	}
-
-	bool HandleNodeIDRequest(uavcan_pnp_NodeIDAllocationData_1_0 &msg);
-	bool HandleNodeIDRequest(uavcan_pnp_NodeIDAllocationData_2_0 &msg);
-
-	void callback(const CanardTransfer &receive); // NodeIDAllocation callback
-
-	void update();
-
-private:
-
-	CanardInstance &_canard_instance;
-	CanardTransferID _node_id_alloc_transfer_id{0};
-
-	hrt_abstime _nodealloc_request_last{0};
-};
@@ -36,7 +36,6 @@
 #include "UavcanPublisherBase.hpp"

 #include <com/hex/equipment/flow/Measurement.hpp>
-#include <conversion/rotation.h>

 #include <uORB/SubscriptionCallback.hpp>
 #include <uORB/topics/optical_flow.h>
@@ -54,16 +53,7 @@ public:
 		UavcanPublisherBase(com::hex::equipment::flow::Measurement::DefaultDataTypeID),
 		uORB::SubscriptionCallbackWorkItem(work_item, ORB_ID(optical_flow)),
 		uavcan::Publisher<com::hex::equipment::flow::Measurement>(node)
-	{
-		_rotation = matrix::Dcmf{matrix::Eulerf{0.f, 0.f, 0.f}};
-
-		param_t rot = param_find("CANNODE_FLOW_ROT");
-		int32_t val = 0;
-
-		if (param_get(rot, &val) == PX4_OK) {
-			_rotation = get_rot_matrix((enum Rotation)val);
-		}
-	}
+	{}

 	void PrintInfo() override
 	{
@@ -83,16 +73,10 @@ public:
 		if (uORB::SubscriptionCallbackWorkItem::update(&optical_flow)) {
 			com::hex::equipment::flow::Measurement measurement{};
 			measurement.integration_interval  = optical_flow.integration_timespan * 1e-6f; // us -> s
-
-			// rotate measurements in yaw from sensor frame to body frame
-			const matrix::Vector3f gyro_flow_rotated = _rotation * matrix::Vector3f{optical_flow.gyro_x_rate_integral, optical_flow.gyro_y_rate_integral, 0.f};
-			const matrix::Vector3f pixel_flow_rotated = _rotation * matrix::Vector3f{optical_flow.pixel_flow_x_integral, optical_flow.pixel_flow_y_integral, 0.f};
-
-			measurement.rate_gyro_integral[0] = gyro_flow_rotated(0);
-			measurement.rate_gyro_integral[1] = gyro_flow_rotated(1);
-			measurement.flow_integral[0] = pixel_flow_rotated(0);
-			measurement.flow_integral[1] = pixel_flow_rotated(1);
-
+			measurement.rate_gyro_integral[0] = optical_flow.gyro_x_rate_integral;
+			measurement.rate_gyro_integral[1] = optical_flow.gyro_y_rate_integral;
+			measurement.flow_integral[0] = optical_flow.pixel_flow_x_integral;
+			measurement.flow_integral[1] = optical_flow.pixel_flow_y_integral;
 			measurement.quality = optical_flow.quality;

 			uavcan::Publisher<com::hex::equipment::flow::Measurement>::broadcast(measurement);
@@ -101,7 +85,5 @@ public:
 			uORB::SubscriptionCallbackWorkItem::registerCallback();
 		}
 	}
-private:
-	matrix::Dcmf _rotation;
 };
 } // namespace uavcannode
@@ -59,24 +59,3 @@ PARAM_DEFINE_INT32(CANNODE_BITRATE, 1000000);
 * @group UAVCAN
 */
 PARAM_DEFINE_INT32(CANNODE_TERM, 0);
-
-/**
- * Cannode flow board rotation
- *
- * This parameter defines the yaw rotation of the Cannode flow board relative to the vehicle body frame.
- * Zero rotation is defined as X on flow board pointing towards front of vehicle.
- *
- * @value 0 No rotation
- * @value 1 Yaw 45°
- * @value 2 Yaw 90°
- * @value 3 Yaw 135°
- * @value 4 Yaw 180°
- * @value 5 Yaw 225°
- * @value 6 Yaw 270°
- * @value 7 Yaw 315°
- *
- * @reboot_required true
- *
- * @group UAVCAN
- */
-PARAM_DEFINE_INT32(CANNODE_FLOW_ROT, 0);
@@ -1,6 +1,6 @@
 /****************************************************************************
 *
- *   Copyright (c) 2013-2021 PX4 Development Team. All rights reserved.
+ *   Copyright (c) 2013-2020 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
@@ -276,9 +276,7 @@ ECL_L1_Pos_Controller::navigate_loiter(const Vector2d &vector_A, const Vector2d
 	float tangent_vel = xtrack_vel_center * loiter_direction;

 	/* prevent PD output from turning the wrong way when in circle mode */
-	const float l1_op_tan_vel = 2.f; // hard coded max tangential velocity in the opposite direction
-
-	if (tangent_vel < -l1_op_tan_vel && _circle_mode) {
+	if (tangent_vel < 0.0f && _circle_mode) {
 		lateral_accel_sp_circle_pd = math::max(lateral_accel_sp_circle_pd, 0.0f);
 	}

@@ -104,15 +104,13 @@ _param_prefix(param_prefix)

 	_use_dynamic_mixing = _param_sys_ctrl_alloc.get();

-	if (_use_dynamic_mixing) {
-		initParamHandles();
+	initParamHandles();

-		for (unsigned i = 0; i < MAX_ACTUATORS; i++) {
-			_failsafe_value[i] = UINT16_MAX;
-		}
-
-		updateParams();
+	for (unsigned i = 0; i < MAX_ACTUATORS; i++) {
+		_failsafe_value[i] = UINT16_MAX;
 	}
+
+	updateParams();
 }

 MixingOutput::~MixingOutput()
@@ -129,8 +127,6 @@ void MixingOutput::initParamHandles()
 	char param_name[17];

 	for (unsigned i = 0; i < _max_num_outputs; ++i) {
-		snprintf(param_name, sizeof(param_name), "%s_%s%d", _param_prefix, "FUNC", i + 1);
-		_param_handles[i].function = param_find(param_name);
 		snprintf(param_name, sizeof(param_name), "%s_%s%d", _param_prefix, "DIS", i + 1);
 		_param_handles[i].disarmed = param_find(param_name);
 		snprintf(param_name, sizeof(param_name), "%s_%s%d", _param_prefix, "MIN", i + 1);
@@ -140,6 +136,13 @@ void MixingOutput::initParamHandles()
 		snprintf(param_name, sizeof(param_name), "%s_%s%d", _param_prefix, "FAIL", i + 1);
 		_param_handles[i].failsafe = param_find(param_name);
 	}
+
+	if (_use_dynamic_mixing) {
+		for (unsigned i = 0; i < _max_num_outputs; ++i) {
+			snprintf(param_name, sizeof(param_name), "%s_%s%d", _param_prefix, "FUNC", i + 1);
+			_param_handles[i].function = param_find(param_name);
+		}
+	}
 }

 void MixingOutput::printStatus() const
@@ -190,13 +193,40 @@ void MixingOutput::updateParams()
 		_mixers->set_airmode((Mixer::Airmode)_param_mc_airmode.get());
 	}

+	_reverse_output_mask = 0;
+
+	for (unsigned i = 0; i < _max_num_outputs; i++) {
+		int32_t val;
+
+		if (_param_handles[i].disarmed != PARAM_INVALID && param_get(_param_handles[i].disarmed, &val) == 0) {
+			_disarmed_value[i] = val;
+		}
+
+		if (_param_handles[i].min != PARAM_INVALID && param_get(_param_handles[i].min, &val) == 0) {
+			_min_value[i] = val;
+		}
+
+		if (_param_handles[i].max != PARAM_INVALID && param_get(_param_handles[i].max, &val) == 0) {
+			_max_value[i] = val;
+		}
+
+		if (_min_value[i] > _max_value[i]) {
+			_reverse_output_mask |= 1 << i;
+			uint16_t tmp = _min_value[i];
+			_min_value[i] = _max_value[i];
+			_max_value[i] = tmp;
+		}
+
+		if (_param_handles[i].failsafe != PARAM_INVALID && param_get(_param_handles[i].failsafe, &val) == 0) {
+			_failsafe_value[i] = val;
+		}
+	}
+
 	if (_use_dynamic_mixing) {
 		_param_mot_ordering.set(0); // not used with dynamic mixing

 		bool function_changed = false;

-		_reverse_output_mask = 0;
-
 		for (unsigned i = 0; i < _max_num_outputs; i++) {
 			int32_t val;

@@ -207,29 +237,6 @@ void MixingOutput::updateParams()

 				// we set _function_assignment[i] later to ensure _functions[i] is updated at the same time
 			}
-
-			if (_param_handles[i].disarmed != PARAM_INVALID && param_get(_param_handles[i].disarmed, &val) == 0) {
-				_disarmed_value[i] = val;
-			}
-
-			if (_param_handles[i].min != PARAM_INVALID && param_get(_param_handles[i].min, &val) == 0) {
-				_min_value[i] = val;
-			}
-
-			if (_param_handles[i].max != PARAM_INVALID && param_get(_param_handles[i].max, &val) == 0) {
-				_max_value[i] = val;
-			}
-
-			if (_min_value[i] > _max_value[i]) {
-				_reverse_output_mask |= 1 << i;
-				uint16_t tmp = _min_value[i];
-				_min_value[i] = _max_value[i];
-				_max_value[i] = tmp;
-			}
-
-			if (_param_handles[i].failsafe != PARAM_INVALID && param_get(_param_handles[i].failsafe, &val) == 0) {
-				_failsafe_value[i] = val;
-			}
 		}

 		if (function_changed) {
@@ -120,13 +120,16 @@ float VelocitySmoothing::computeT1(float T123, float a0, float v3, float j_max,
 	float T3_plus = a0 / j_max + T1_plus;
 	float T3_minus = a0 / j_max + T1_minus;

+	float T13_plus = T1_plus + T3_plus;
+	float T13_minus = T1_minus + T3_minus;
+
 	float T1 = 0.f;

-	if ((T1_plus >= 0.f && T3_plus >= 0.f) && ((T1_plus + T3_plus) <= T123)) {
-		T1 = T1_plus;
-
-	} else if ((T1_minus >= 0.f && T3_minus >= 0.f) && ((T1_minus + T3_minus) <= T123)) {
+	if (T13_plus > T123) {
 		T1 = T1_minus;
+
+	} else if (T13_minus > T123) {
+		T1 = T1_plus;
 	}

 	T1 = saturateT1ForAccel(a0, j_max, T1, a_max);
@@ -279,8 +282,7 @@ void VelocitySmoothing::timeSynchronization(VelocitySmoothing *traj, int n_traj)

 	if (desired_time > FLT_EPSILON) {
 		for (int i = 0; i < n_traj; i++) {
-			if ((i != longest_traj_index)
-			    && (traj[i].getTotalTime() < desired_time)) {
+			if (i != longest_traj_index) {
 				traj[i].updateDurationsGivenTotalTime(desired_time);
 			}
 		}
@@ -112,38 +112,6 @@ TEST_F(VelocitySmoothingTest, testTimeSynchronization)
 	EXPECT_LE(fabsf(_trajectories[0].getTotalTime() - _trajectories[1].getTotalTime()), 0.0001);
 }

-TEST_F(VelocitySmoothingTest, testTimeSynchronizationSameDelta)
-{
-	// GIVEN: a set of initial conditions
-	Vector3f a0(0.f, 0.f, 0.f);
-	Vector3f v0(0.5f, -0.2f, 0.f);
-	Vector3f x0(0.f, 0.f, 0.f);
-
-	setInitialConditions(a0, v0, x0);
-
-	// WHEN: the same delta velocity is set to the XY-axes
-	const float delta_v = 0.3f;
-	Vector3f velocity_setpoints{v0(0) + delta_v, v0(1) + delta_v, 0.f};
-
-	for (int i = 0; i < 3; i++) {
-		_trajectories[i].updateDurations(velocity_setpoints(i));
-	}
-
-	VelocitySmoothing::timeSynchronization(_trajectories, 3);
-
-	// THEN: they should have the same T1, T2 and T3 dirations
-	EXPECT_FLOAT_EQ(_trajectories[0].getTotalTime(), _trajectories[1].getTotalTime());
-	EXPECT_FLOAT_EQ(_trajectories[0].getT1(), _trajectories[1].getT1());
-	EXPECT_FLOAT_EQ(_trajectories[0].getT2(), _trajectories[1].getT2());
-	EXPECT_FLOAT_EQ(_trajectories[0].getT3(), _trajectories[1].getT3());
-
-	// AND: the Z axis should have the same duration but spend all its time in T2 (constant phase)
-	EXPECT_FLOAT_EQ(_trajectories[2].getTotalTime(), _trajectories[0].getTotalTime());
-	EXPECT_FLOAT_EQ(_trajectories[2].getT1(), 0.f);
-	EXPECT_FLOAT_EQ(_trajectories[2].getT2(), _trajectories[0].getTotalTime());
-	EXPECT_FLOAT_EQ(_trajectories[2].getT3(), 0.f);
-}
-
 TEST_F(VelocitySmoothingTest, testConstantSetpoint)
 {
 	// GIVEN: A set of constraints
@@ -155,29 +155,6 @@ bool param_modify_on_import(bson_node_t node)
 		}
 	}

-	// 2021-01-31 (v1.12 alpha): translate PWM_MIN/PWM_MAX/PWM_DISARMED to PWM_MAIN
-	{
-		if (strcmp("PWM_MIN", node->name) == 0) {
-			strcpy(node->name, "PWM_MAIN_MIN");
-			PX4_INFO("copying %s -> %s", "PWM_MIN", "PWM_MAIN_MIN");
-		}
-
-		if (strcmp("PWM_MAX", node->name) == 0) {
-			strcpy(node->name, "PWM_MAIN_MAX");
-			PX4_INFO("copying %s -> %s", "PWM_MAX", "PWM_MAIN_MAX");
-		}
-
-		if (strcmp("PWM_RATE", node->name) == 0) {
-			strcpy(node->name, "PWM_MAIN_RATE");
-			PX4_INFO("copying %s -> %s", "PWM_RATE", "PWM_MAIN_RATE");
-		}
-
-		if (strcmp("PWM_DISARMED", node->name) == 0) {
-			strcpy(node->name, "PWM_MAIN_DISARM");
-			PX4_INFO("copying %s -> %s", "PWM_DISARMED", "PWM_MAIN_DISARM");
-		}
-	}
-
 	// 2021-04-30: translate ASPD_STALL to FW_AIRSPD_STALL
 	{
 		if (strcmp("ASPD_STALL", node->name) == 0) {
@@ -29,40 +29,6 @@ parameters:
            max: 2000
            default: 50

-        PWM_AUX_MIN:
-            description:
-                short: PWM aux minimum value
-                long: |
-                    Set to 1000 for industry default or 900 to increase servo travel.
-            type: int32
-            unit: us
-            min: 800
-            max: 1400
-            default: 1000
-
-        PWM_AUX_MAX:
-            description:
-                short: PWM aux maximum value
-                long: |
-                    Set to 2000 for industry default or 2100 to increase servo travel.
-            type: int32
-            unit: us
-            min: 1600
-            max: 2200
-            default: 2000
-
-        PWM_AUX_DISARM:
-            description:
-                short: PWM aux disarmed value
-                long: |
-                    This is the PWM pulse the autopilot is outputting if not armed.
-                    The main use of this parameter is to silence ESCs when they are disarmed.
-            type: int32
-            unit: us
-            min: 0
-            max: 2200
-            default: 1500
-
        PWM_AUX_TRIM${i}:
            description:
                short: PWM aux ${i} trim value
@@ -75,27 +41,3 @@ parameters:
            num_instances: *max_num_config_instances
            instance_start: 1
            default: 0
-
-        PWM_AUX_REV${i}:
-            description:
-                short: PWM aux ${i} reverse value
-                long: |
-                    Enable to invert the channel.
-                    Warning: Use this parameter when connected to a servo only.
-                    For a brushless motor, invert manually two phases to reverse the direction.
-            type: boolean
-            num_instances: *max_num_config_instances
-            instance_start: 1
-            default: 0
-
-        PWM_AUX_RATE${i}:
-            description:
-                short: PWM aux ${i} rate
-                long: |
-                    Set the default PWM output frequency for the aux outputs
-            type: int32
-            unit: Hz
-            min: 0
-            max: 400
-            instance_start: 1
-            default: 50
@@ -121,27 +121,3 @@ parameters:
            num_instances: *max_num_config_instances
            instance_start: 1
            default: 0
-
-        PWM_EXTRA_REV${i}:
-            description:
-                short: PWM extra ${i} reverse value
-                long: |
-                    Enable to invert the channel.
-                    Warning: Use this parameter when connected to a servo only.
-                    For a brushless motor, invert manually two phases to reverse the direction.
-            type: boolean
-            num_instances: *max_num_config_instances
-            instance_start: 1
-            default: 0
-
-        PWM_EXTRA_RATE${i}:
-            description:
-                short: PWM extra ${i} rate
-                long: |
-                    Set the default PWM output frequency for the main outputs
-            type: int32
-            unit: Hz
-            min: 0
-            max: 400
-            instance_start: 1
-            default: 50
@@ -29,40 +29,6 @@ parameters:
            max: 2000
            default: 400

-        PWM_MAIN_MIN:
-            description:
-                short: PWM main minimum value
-                long: |
-                    Set to 1000 for industry default or 900 to increase servo travel.
-            type: int32
-            unit: us
-            min: 800
-            max: 1400
-            default: 1000
-
-        PWM_MAIN_MAX:
-            description:
-                short: PWM main maximum value
-                long: |
-                    Set to 2000 for industry default or 2100 to increase servo travel.
-            type: int32
-            unit: us
-            min: 1600
-            max: 2200
-            default: 2000
-
-        PWM_MAIN_DISARM:
-            description:
-                short: PWM main disarmed value
-                long: |
-                    This is the PWM pulse the autopilot is outputting if not armed.
-                    The main use of this parameter is to silence ESCs when they are disarmed.
-            type: int32
-            unit: us
-            min: 0
-            max: 2200
-            default: 900
-
        PWM_MAIN_TRIM${i}:
            description:
                short: PWM main ${i} trim value
@@ -75,27 +41,3 @@ parameters:
            num_instances: *max_num_config_instances
            instance_start: 1
            default: 0
-
-        PWM_MAIN_REV${i}:
-            description:
-                short: PWM main ${i} reverse value
-                long: |
-                    Enable to invert the channel.
-                    Warning: Use this parameter when connected to a servo only.
-                    For a brushless motor, invert manually two phases to reverse the direction.
-            type: boolean
-            num_instances: *max_num_config_instances
-            instance_start: 1
-            default: 0
-
-        PWM_MAIN_RATE${i}:
-            description:
-                short: PWM main ${i} rate
-                long: |
-                    Set the default PWM output frequency for the main outputs
-            type: int32
-            unit: Hz
-            min: 0
-            max: 400
-            instance_start: 1
-            default: 50
@@ -56,7 +56,7 @@ WindEstimator::initialise(const matrix::Vector3f &velI, const matrix::Vector2f &
 	// initilaise wind states assuming zero side slip and horizontal flight
 	_state(INDEX_W_N) = velI(INDEX_W_N) - tas_meas * cosf(heading_est);
 	_state(INDEX_W_E) = velI(INDEX_W_E) - tas_meas * sinf(heading_est);
-	_state(INDEX_TAS_SCALE) = _scale_init;
+	_state(INDEX_TAS_SCALE) = 1.0f;

 	// compute jacobian of states wrt north/each earth velocity states and true airspeed measurement
 	float L0 = v_e * v_e;
@@ -104,7 +104,7 @@ WindEstimator::update(uint64_t time_now)
 	_wind_estimator_reset = false;

 	// run covariance prediction at 1Hz
-	if (time_now - _time_last_update < 1_s || _time_last_update == 0) {
+	if (time_now - _time_last_update < 1000 * 1000 || _time_last_update == 0) {
 		if (_time_last_update == 0) {
 			_time_last_update = time_now;
 		}
@@ -149,7 +149,7 @@ WindEstimator::fuse_airspeed(uint64_t time_now, const float true_airspeed, const
 	}

 	// don't fuse faster than 10Hz
-	if (time_now - _time_last_airspeed_fuse < 100_ms) {
+	if (time_now - _time_last_airspeed_fuse < 100 * 1000) {
 		return;
 	}

@@ -160,28 +160,28 @@ WindEstimator::fuse_airspeed(uint64_t time_now, const float true_airspeed, const
 	const float v_e = velI(1);
 	const float v_d = velI(2);

-	// calculate airspeed from ground speed and wind states (without scale)
-	const float airspeed_predicted_raw = sqrtf((v_n - _state(INDEX_W_N)) * (v_n - _state(INDEX_W_N)) +
-					     (v_e - _state(INDEX_W_E)) * (v_e - _state(INDEX_W_E)) + v_d * v_d);
+	const float k_tas = _state(INDEX_TAS_SCALE);

-	// compute state observation matrix H
-	const float HH0 = airspeed_predicted_raw;
-	const float HH1 = _state(INDEX_TAS_SCALE) / math::max(HH0, 0.1f);
+	// compute kalman gain K
+	const float HH0 = sqrtf(v_d * v_d + (v_e - _state(INDEX_W_E)) * (v_e - _state(INDEX_W_E)) + (v_n - _state(
+					INDEX_W_N)) * (v_n - _state(INDEX_W_N)));
+	const float HH1 = k_tas / HH0;

 	matrix::Matrix<float, 1, 3> H_tas;
 	H_tas(0, 0) = HH1 * (-v_n + _state(INDEX_W_N));
 	H_tas(0, 1) = HH1 * (-v_e + _state(INDEX_W_E));
 	H_tas(0, 2) = HH0;

-	// compute innovation covariance S
+	matrix::Matrix<float, 3, 1> K = _P * H_tas.transpose();
+
 	const matrix::Matrix<float, 1, 1> S = H_tas * _P * H_tas.transpose() + _tas_var;

-	// compute Kalman gain
-	matrix::Matrix<float, 3, 1> K = _P * H_tas.transpose();
 	K /= S(0, 0);
-
 	// compute innovation
-	const float airspeed_pred = _state(INDEX_TAS_SCALE) * airspeed_predicted_raw;
+	const float airspeed_pred = k_tas * sqrtf((v_n - _state(INDEX_W_N)) * (v_n - _state(INDEX_W_N)) + (v_e - _state(
+					    INDEX_W_E)) *
+				    (v_e - _state(INDEX_W_E)) + v_d * v_d);
+
 	_tas_innov = true_airspeed - airspeed_pred;

 	// innovation variance
@@ -190,13 +190,13 @@ WindEstimator::fuse_airspeed(uint64_t time_now, const float true_airspeed, const
 	bool reinit_filter = false;
 	bool meas_is_rejected = false;

-	// note: _time_rejected_tas and reinit_filter are not used anymore as filter can't get reset due to tas rejection
 	meas_is_rejected = check_if_meas_is_rejected(time_now, _tas_innov, _tas_innov_var, _tas_gate, _time_rejected_tas,
 			   reinit_filter);

-	if (meas_is_rejected || _tas_innov_var < 0.f) {
-		// only reset filter if _tas_innov_var gets unfeasible, but not never if tas measurement is rejected
-		if (_tas_innov_var < 0.0f) {
+	reinit_filter |= _tas_innov_var < 0.0f;
+
+	if (meas_is_rejected || reinit_filter) {
+		if (reinit_filter) {
 			_initialised =	initialise(velI, matrix::Vector2f(0.1f, 0.1f), true_airspeed);
 		}

@@ -224,7 +224,7 @@ WindEstimator::fuse_beta(uint64_t time_now, const matrix::Vector3f &velI, const
 	}

 	// don't fuse faster than 10Hz
-	if (time_now - _time_last_beta_fuse < 100_ms) {
+	if (time_now - _time_last_beta_fuse < 100 * 1000) {
 		return;
 	}

@@ -259,11 +259,11 @@ WindEstimator::fuse_beta(uint64_t time_now, const matrix::Vector3f &velI, const
 	H_beta(0, 1) = HB15 * (HB12 - HB7 + HB8) + HB16 * HB5;
 	H_beta(0, 2) = 0;

-	// compute innovation covariance S
+	// compute kalman gain
+	matrix::Matrix<float, 3, 1> K = _P * H_beta.transpose();
+
 	const matrix::Matrix<float, 1, 1> S = H_beta * _P * H_beta.transpose() + _beta_var;

-	// compute Kalman gain
-	matrix::Matrix<float, 3, 1> K = _P * H_beta.transpose();
 	K /= S(0, 0);

 	// compute predicted side slip angle
@@ -333,6 +333,16 @@ WindEstimator::run_sanity_checks()
 		return;
 	}

+	// check if we should inhibit learning of airspeed scale factor and rather use a pre-set value.
+	// airspeed scale factor errors arise from sensor installation which does not change and only needs
+	// to be computed once for a perticular installation.
+	if (_enforced_airspeed_scale < 0) {
+		_state(INDEX_TAS_SCALE) = math::max(0.0f, _state(INDEX_TAS_SCALE));
+
+	} else {
+		_state(INDEX_TAS_SCALE) = _enforced_airspeed_scale;
+	}
+
 	// attain symmetry
 	for (unsigned row = 0; row < 3; row++) {
 		for (unsigned column = 0; column < row; column++) {
@@ -354,7 +364,7 @@ WindEstimator::check_if_meas_is_rejected(uint64_t time_now, float innov, float i
 		time_meas_rejected = 0;
 	}

-	reinit_filter = time_now - time_meas_rejected > 5_s && time_meas_rejected != 0;
+	reinit_filter = time_now - time_meas_rejected > 5 * 1000 * 1000 && time_meas_rejected != 0;

 	return time_meas_rejected != 0;
 }
--- a/Show More
+++ b/Show More