Add level calibration

2026-08-16 00:38:56 +00:00 · 2026-01-30 07:49:26 +03:00
70 changed files with 416 additions and 1174 deletions
@@ -10,38 +10,28 @@ on:
 jobs:
  build_linux:
    runs-on: ubuntu-latest
    env:
        ARDUINO_SKETCH_ALWAYS_EXPORT_BINARIES: 1
    steps:
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v4
    - name: Install Arduino CLI
      run: curl -fsSL https://raw.githubusercontent.com/arduino/arduino-cli/master/install.sh | BINDIR=/usr/local/bin sh
-    - name: Build firmware for ESP32
+    - name: Build firmware
      env:
        ARDUINO_SKETCH_ALWAYS_EXPORT_BINARIES: 1
      run: make
    - name: Build firmware for ESP32-C3
      run: make BOARD=esp32:esp32:esp32c3
    - name: Build firmware for ESP32-S3
      run: make BOARD=esp32:esp32:esp32s3:CDCOnBoot=cdc
    - name: Build firmware for ESP32-S3 with QSPI PSRAM
      run: make BOARD=esp32:esp32:esp32s3:CDCOnBoot=cdc,PSRAM=enabled EXTRA=--output-dir=flix/build/esp32.esp32.esp32s3.qspi
    - name: Build firmware for ESP32-S3 with OPI PSRAM
      run: make BOARD=esp32:esp32:esp32s3:CDCOnBoot=cdc,PSRAM=opi EXTRA=--output-dir=flix/build/esp32.esp32.esp32s3.opi
    - name: Build firmware for Flix2
      run: make BOARD=esp32:esp32:esp32s3:FlashSize=4M,CDCOnBoot=cdc,PSRAM=opi EXTRA='--build-property "compiler.cpp.extra_flags=-DFLIX2" --output-dir=flix/build/esp32.esp32.flix2'
    - name: Upload binaries
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: firmware-binary
        path: flix/build
-    - name: Build espnow-proxy
+    - name: Build firmware for ESP32-S3
-      run: arduino-cli compile --fqbn esp32:esp32:esp32 tools/espnow-proxy
+      run: make BOARD=esp32:esp32:esp32s3
    - name: Check c_cpp_properties.json
      run: tools/check_c_cpp_properties.py
  build_macos:
    runs-on: macos-latest
    steps:
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v4
    - name: Install Arduino CLI
      run: brew install arduino-cli
    - name: Build firmware
@@ -52,7 +42,7 @@ jobs:
  build_windows:
    runs-on: windows-latest
    steps:
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v4
    - name: Install Arduino CLI
      run: choco install arduino-cli
    - name: Install Make
@@ -72,8 +62,8 @@ jobs:
        apt-get update
        DEBIAN_FRONTEND=noninteractive apt-get install -y curl wget build-essential cmake g++ pkg-config gnupg2 lsb-release sudo
    - name: Install Arduino CLI
-      run: curl -fsSL https://raw.githubusercontent.com/arduino/arduino-cli/master/install.sh | BINDIR=/usr/local/bin sh
+      uses: arduino/setup-arduino-cli@v1.1.1
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v4
    - name: Install Gazebo
      run: |
        sudo sh -c 'echo "deb http://packages.osrfoundation.org/gazebo/ubuntu-stable `lsb_release -cs` main" > /etc/apt/sources.list.d/gazebo-stable.list'
@@ -84,16 +74,7 @@ jobs:
      run: sudo apt-get install -y libsdl2-dev
    - name: Build simulator
      run: make build_simulator
-    - name: Run simulator
+    - uses: actions/upload-artifact@v4
      env:
        GAZEBO_MODEL_PATH: ${{ github.workspace }}/gazebo/models
        GAZEBO_PLUGIN_PATH: ${{ github.workspace }}/gazebo/build
      run: |
        OUT=$(timeout -k 10s 120s gzserver --verbose gazebo/flix.world 2>&1 | tee /dev/stderr)
        if echo "$OUT" | grep -Pq "\[Err\](?! \[RenderEngine)"; then
          exit 1
        fi
    - uses: actions/upload-artifact@v7
      with:
        name: gazebo-plugin-binary
        path: gazebo/build/*.so
@@ -105,7 +86,7 @@ jobs:
    steps:
    - name: Install Arduino CLI
      run: brew install arduino-cli
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v4
    - name: Clean up python binaries # Workaround for https://github.com/actions/setup-python/issues/577
      run: |
        rm -f /usr/local/bin/2to3*
@@ -8,7 +8,6 @@ on:
 permissions:
  contents: read
  actions: read
  pages: write
  id-token: write
@@ -16,7 +15,7 @@ jobs:
  markdownlint:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v4
    - name: Install markdownlint
      run: npm install -g markdownlint-cli2
    - name: Run markdownlint
@@ -25,57 +24,19 @@ jobs:
  build_book:
    runs-on: ubuntu-latest
    needs: markdownlint
    env:
      BINARIES: ${{ github.event_name == 'push' && (github.ref_name == 'master' || github.ref_name == 'dev') && github.repository == 'okalachev/flix' }}
    steps:
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v4
    - name: Install mdBook
      run: cargo install mdbook --vers 0.4.43 --locked
    - name: Build book
      run: cd docs && mdbook build
    - name: Wait for Build to complete
      if: ${{ env.BINARIES }}
      uses: lewagon/wait-on-check-action@v1.9.1
      with:
        ref: ${{ github.sha }}
        check-name: build_linux
        repo-token: ${{ secrets.GITHUB_TOKEN }}
        wait-interval: 30
    - name: Find firmware binaries
      if: ${{ env.BINARIES }}
      id: build_run
      run: |
        RUN_ID=$(gh api "repos/${{ github.repository }}/actions/workflows/build.yml/runs?head_sha=${{ github.sha }}&per_page=1" --jq '.workflow_runs[0].id')
        echo "id=$RUN_ID" >> $GITHUB_OUTPUT
      env:
        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    - name: Download firmware binaries
      if: ${{ env.BINARIES }}
      uses: actions/download-artifact@v7
      with:
        github-token: ${{ secrets.GITHUB_TOKEN }}
        repository: ${{ github.repository }}
        run-id: ${{ steps.build_run.outputs.id }}
        name: firmware-binary
        path: docs/build
    - name: Create shortcuts for firmware binaries
      if: ${{ env.BINARIES }}
      working-directory: docs/build
      run: |
        for FQBN in esp32.esp32.*; do
          zip -r $FQBN.zip $FQBN
          BOARD="${FQBN#esp32.esp32.}"
          ln -s "$FQBN/flix.ino.merged.bin" "flix.$BOARD.merged.bin"
          ln -s "$FQBN/flix.ino.bin" "flix.$BOARD.bin"
          ln -s "$FQBN/flix.ino.bootloader.bin" "flix.$BOARD.bootloader.bin"
        done
    - name: Upload artifact
-      uses: actions/upload-pages-artifact@v5
+      uses: actions/upload-pages-artifact@v3
      with:
        path: docs/build
  deploy:
-    if: ${{ github.event_name == 'push' && github.ref_name == 'master' }}
+    if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
    concurrency:
      group: "pages"
      cancel-in-progress: true
@@ -87,4 +48,4 @@ jobs:
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
-        uses: actions/deploy-pages@v5
+        uses: actions/deploy-pages@v4
@@ -10,7 +10,7 @@ jobs:
  csv_to_ulog:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v4
    - name: Build csv_to_ulog
      run: cd tools/csv_to_ulog && mkdir build && cd build && cmake .. && make
    - name: Test csv_to_ulog
@@ -22,13 +22,13 @@ jobs:
  pyflix:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v4
    - name: Install Python build tools
      run: pip install build
    - name: Build pyflix
      run: python3 -m build tools
    - name: Upload artifacts
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: pyflix
        path: |
@@ -37,7 +37,7 @@ jobs:
  python_tools:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v4
    - name: Install Python dependencies
      run: pip install -r tools/requirements.txt
    - name: Test csv_to_mcap tool
@@ -46,23 +46,3 @@ jobs:
        echo -e "t,x,y,z\n0,1,2,3\n1,4,5,6" > log.csv
        ./csv_to_mcap.py log.csv
        test $(stat -c %s log.mcap) -eq 883
  sloc:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v7
    - run: sudo apt-get install -y cloc jq
    - name: Print source lines of code
      run: cloc --by-file-by-lang flix
    - name: Checkout previous revision
      uses: actions/checkout@v7
      with:
        ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.base.sha || github.event.before }}
        path: prev
    - name: Annotate total source lines
      run: |
        SLOC_CURR=$(cloc flix --json | jq -r '.SUM.code')
        SLOC_PREV=$(cloc prev/flix --json | jq -r '.SUM.code')
        DIFF=$(printf '%+d' "$((SLOC_CURR - SLOC_PREV))")
        echo "* Current SLOC: $SLOC_CURR" >> $GITHUB_STEP_SUMMARY
        echo "* Previous SLOC: $SLOC_PREV" >> $GITHUB_STEP_SUMMARY
        echo "* Diff: $DIFF" >> $GITHUB_STEP_SUMMARY
@@ -4,10 +4,9 @@ build/
 tools/log/
 tools/dist/
 *.egg-info/
-.core
+.dependencies
 .libs
 .vscode/*
-!.vscode/settings.default.json
+!.vscode/settings.json
 !.vscode/c_cpp_properties.json
 !.vscode/tasks.json
 !.vscode/launch.json
@@ -6,18 +6,18 @@
 				"${workspaceFolder}/flix",
 				"${workspaceFolder}/gazebo",
 				"${workspaceFolder}/tools/**",
-				"~/.arduino15/packages/esp32/hardware/esp32/3.3.10/cores/esp32",
+				"~/.arduino15/packages/esp32/hardware/esp32/3.3.6/cores/esp32",
-				"~/.arduino15/packages/esp32/hardware/esp32/3.3.10/libraries/**",
+				"~/.arduino15/packages/esp32/hardware/esp32/3.3.6/libraries/**",
-				"~/.arduino15/packages/esp32/hardware/esp32/3.3.10/variants/d1_mini32",
+				"~/.arduino15/packages/esp32/hardware/esp32/3.3.6/variants/d1_mini32",
-				"~/.arduino15/packages/esp32/tools/esp32-libs/3.3.10/include/**",
+				"~/.arduino15/packages/esp32/tools/esp32-libs/3.3.6/include/**",
 				"~/Arduino/libraries/**",
 				"/usr/include/gazebo-11/",
 				"/usr/include/ignition/math6/"
 			],
 			"forcedInclude": [
 				"${workspaceFolder}/.vscode/intellisense.h",
-				"~/.arduino15/packages/esp32/hardware/esp32/3.3.10/cores/esp32/Arduino.h",
+				"~/.arduino15/packages/esp32/hardware/esp32/3.3.6/cores/esp32/Arduino.h",
-				"~/.arduino15/packages/esp32/hardware/esp32/3.3.10/variants/d1_mini32/pins_arduino.h",
+				"~/.arduino15/packages/esp32/hardware/esp32/3.3.6/variants/d1_mini32/pins_arduino.h",
 				"${workspaceFolder}/flix/cli.ino",
 				"${workspaceFolder}/flix/control.ino",
 				"${workspaceFolder}/flix/estimate.ino",
@@ -33,7 +33,7 @@
 				"${workspaceFolder}/flix/parameters.ino",
 				"${workspaceFolder}/flix/safety.ino"
 			],
-			"compilerPath": "~/.arduino15/packages/esp32/tools/esp-x32/2601/bin/xtensa-esp32-elf-g++",
+			"compilerPath": "~/.arduino15/packages/esp32/tools/esp-x32/2511/bin/xtensa-esp32-elf-g++",
 			"cStandard": "c11",
 			"cppStandard": "c++17",
 			"defines": [
@@ -53,18 +53,18 @@
 			"name": "Mac",
 			"includePath": [
 				"${workspaceFolder}/flix",
-				"~/Library/Arduino15/packages/esp32/hardware/esp32/3.3.10/cores/esp32",
+				"~/Library/Arduino15/packages/esp32/hardware/esp32/3.3.6/cores/esp32",
-				"~/Library/Arduino15/packages/esp32/hardware/esp32/3.3.10/libraries/**",
+				"~/Library/Arduino15/packages/esp32/hardware/esp32/3.3.6/libraries/**",
-				"~/Library/Arduino15/packages/esp32/hardware/esp32/3.3.10/variants/d1_mini32",
+				"~/Library/Arduino15/packages/esp32/hardware/esp32/3.3.6/variants/d1_mini32",
-				"~/Library/Arduino15/packages/esp32/tools/esp32-libs/3.3.10/include/**",
+				"~/Library/Arduino15/packages/esp32/tools/esp32-libs/3.3.6/include/**",
 				"~/Documents/Arduino/libraries/**",
 				"/opt/homebrew/include/gazebo-11/",
 				"/opt/homebrew/include/ignition/math6/"
 			],
 			"forcedInclude": [
 				"${workspaceFolder}/.vscode/intellisense.h",
-				"~/Library/Arduino15/packages/esp32/hardware/esp32/3.3.10/cores/esp32/Arduino.h",
+				"~/Library/Arduino15/packages/esp32/hardware/esp32/3.3.6/cores/esp32/Arduino.h",
-				"~/Library/Arduino15/packages/esp32/hardware/esp32/3.3.10/variants/d1_mini32/pins_arduino.h",
+				"~/Library/Arduino15/packages/esp32/hardware/esp32/3.3.6/variants/d1_mini32/pins_arduino.h",
 				"${workspaceFolder}/flix/flix.ino",
 				"${workspaceFolder}/flix/cli.ino",
 				"${workspaceFolder}/flix/control.ino",
@@ -80,7 +80,7 @@
 				"${workspaceFolder}/flix/parameters.ino",
 				"${workspaceFolder}/flix/safety.ino"
 			],
-			"compilerPath": "~/Library/Arduino15/packages/esp32/tools/esp-x32/2601/bin/xtensa-esp32-elf-g++",
+			"compilerPath": "~/Library/Arduino15/packages/esp32/tools/esp-x32/2511/bin/xtensa-esp32-elf-g++",
 			"cStandard": "c11",
 			"cppStandard": "c++17",
 			"defines": [
@@ -103,16 +103,16 @@
 				"${workspaceFolder}/flix",
 				"${workspaceFolder}/gazebo",
 				"${workspaceFolder}/tools/**",
-				"~/AppData/Local/Arduino15/packages/esp32/hardware/esp32/3.3.10/cores/esp32",
+				"~/AppData/Local/Arduino15/packages/esp32/hardware/esp32/3.3.6/cores/esp32",
-				"~/AppData/Local/Arduino15/packages/esp32/hardware/esp32/3.3.10/libraries/**",
+				"~/AppData/Local/Arduino15/packages/esp32/hardware/esp32/3.3.6/libraries/**",
-				"~/AppData/Local/Arduino15/packages/esp32/hardware/esp32/3.3.10/variants/d1_mini32",
+				"~/AppData/Local/Arduino15/packages/esp32/hardware/esp32/3.3.6/variants/d1_mini32",
-				"~/AppData/Local/Arduino15/packages/esp32/tools/esp32-libs/3.3.10/include/**",
+				"~/AppData/Local/Arduino15/packages/esp32/tools/esp32-libs/3.3.6/include/**",
 				"~/Documents/Arduino/libraries/**"
 			],
 			"forcedInclude": [
 				"${workspaceFolder}/.vscode/intellisense.h",
-				"~/AppData/Local/Arduino15/packages/esp32/hardware/esp32/3.3.10/cores/esp32/Arduino.h",
+				"~/AppData/Local/Arduino15/packages/esp32/hardware/esp32/3.3.6/cores/esp32/Arduino.h",
-				"~/AppData/Local/Arduino15/packages/esp32/hardware/esp32/3.3.10/variants/d1_mini32/pins_arduino.h",
+				"~/AppData/Local/Arduino15/packages/esp32/hardware/esp32/3.3.6/variants/d1_mini32/pins_arduino.h",
 				"${workspaceFolder}/flix/cli.ino",
 				"${workspaceFolder}/flix/control.ino",
 				"${workspaceFolder}/flix/estimate.ino",
@@ -128,7 +128,7 @@
 				"${workspaceFolder}/flix/parameters.ino",
 				"${workspaceFolder}/flix/safety.ino"
 			],
-			"compilerPath": "~/AppData/Local/Arduino15/packages/esp32/tools/esp-x32/2601/bin/xtensa-esp32-elf-g++.exe",
+			"compilerPath": "~/AppData/Local/Arduino15/packages/esp32/tools/esp-x32/2511/bin/xtensa-esp32-elf-g++.exe",
 			"cStandard": "c11",
 			"cppStandard": "c++17",
 			"defines": [
@@ -1,7 +1,6 @@
 {
 	// See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
 	"recommendations": [
 		"dangmai.workspace-default-settings",
 		"ms-vscode.cpptools",
 		"ms-vscode.cmake-tools",
 		"ms-python.python"
@@ -1,40 +1,29 @@
-BOARD = esp32:esp32:esp32
+BOARD = esp32:esp32:d1_mini32
-PORT := $(strip $(wildcard /dev/serial/by-id/usb-Silicon_Labs_CP21* /dev/serial/by-id/usb-1a86_USB_Single_Serial_* /dev/cu.usbserial-* /dev/cu.usbmodem*))
+PORT := $(wildcard /dev/serial/by-id/usb-Silicon_Labs_CP21* /dev/serial/by-id/usb-1a86_USB_Single_Serial_* /dev/cu.usbserial-*)
 PORT := $(strip $(PORT))
-export ARDUINO_NETWORK_CONNECTION_TIMEOUT := 1h
+build: .dependencies
-
+	arduino-cli compile --fqbn $(BOARD) flix
 build: .core .libs
 	arduino-cli compile flix --fqbn $(BOARD) --build-property "build.core_debug_level=1" $(EXTRA)
 upload: build
-	arduino-cli upload flix --fqbn $(BOARD) -p "$(PORT)"
+	arduino-cli upload --fqbn $(BOARD) -p "$(PORT)" flix
 erase:
 	arduino-cli burn-bootloader --fqbn $(BOARD) -p "$(PORT)" -P esptool
 monitor:
 	arduino-cli monitor -p "$(PORT)" -c baudrate=115200
-core .core:
+dependencies .dependencies:
-	arduino-cli core update-index --additional-urls https://espressif.github.io/arduino-esp32/package_esp32_index.json
+	arduino-cli core update-index --config-file arduino-cli.yaml
-	arduino-cli core install esp32:esp32@3.3.10 --additional-urls https://espressif.github.io/arduino-esp32/package_esp32_index.json
+	arduino-cli core install esp32:esp32@3.3.6 --config-file arduino-cli.yaml
 	touch .core
 libs .libs:
 	arduino-cli lib update-index
 	arduino-cli lib install "FlixPeriph"
 	arduino-cli lib install "MAVLink"@2.0.25
-	touch .libs
+	touch .dependencies
 upload_proxy: .core .libs
 	arduino-cli compile tools/espnow-proxy --fqbn $(BOARD)
 	arduino-cli upload tools/espnow-proxy --fqbn $(BOARD) -p "$(PORT)"
 gazebo/build cmake: gazebo/CMakeLists.txt
 	mkdir -p gazebo/build
 	cd gazebo/build && cmake ..
-build_simulator: .libs gazebo/build
+build_simulator: .dependencies gazebo/build
 	make -C gazebo/build
 simulator: build_simulator
@@ -49,6 +38,6 @@ plot:
 	plotjuggler -d $(shell ls -t tools/log/*.csv | head -n1)
 clean:
-	rm -rf gazebo/build flix/build flix/cache .core .libs
+	rm -rf gazebo/build flix/build flix/cache .dependencies
-.PHONY: build upload monitor core libs cmake build_simulator simulator log clean
+.PHONY: build upload monitor dependencies cmake build_simulator simulator log clean
@@ -21,8 +21,8 @@
 * Dedicated for education and research.
 * Made from general-purpose components.
 * Simple and clean source code in Arduino (<2k lines firmware).
-* Communication using MAVLink protocol over Wi-Fi or ESP-NOW.
+* Connectivity using Wi-Fi and MAVLink protocol.
-* Control with USB gamepad, remote control or smartphone.
+* Control using USB gamepad, remote control or smartphone.
 * Wireless command line interface and analyzing.
 * Precise simulation with Gazebo.
 * Python library for scripting and automatic flights.
@@ -47,27 +47,13 @@ See the [user builds gallery](docs/user.md):
 <a href="docs/user.md"><img src="docs/img/user/user.jpg" width=500></a>
 ### PCB
 The official PCB *(Flix2)* is in development now. Follow the [project's channel](https://t.me/opensourcequadcopter) to track the progress.
 Outdoor flights demo video of the current prototype:
 <a href="https://youtu.be/KXlNmvUTi4g"><img width=300 src="https://i3.ytimg.com/vi/KXlNmvUTi4g/maxresdefault.jpg"></a>
 ### Position control
 The position control feature is in development. RoboCamp 2026 demo (using an overhead camera, [sources](https://github.com/xTimop/flix-poscontrol/compare/robolager2026...xTimop:flix-poscontrol:poscontrol)):
 <a href="https://youtu.be/369Xowm4HcU"><img width=300 src="https://i3.ytimg.com/vi/369Xowm4HcU/maxresdefault.jpg"></a>
 ## Simulation
 The simulator is implemented using Gazebo and runs the original Arduino code:
 <img src="docs/img/simulator1.png" width=500 alt="Flix simulator">
-## Documentation articles
+## Documentation
 1. [Assembly instructions](docs/assembly.md).
 2. [Usage: build, setup and flight](docs/usage.md).
@@ -85,14 +71,14 @@ Additional articles:
 |Type|Part|Image|Quantity|
 |-|-|:-:|:-:|
-|Microcontroller board|ESP32 Mini.<br>ESP32-S3/ESP32-C3 boards are also supported.|<img src="docs/img/esp32.jpg" width=100>|1|
+|Microcontroller board|ESP32 Mini|<img src="docs/img/esp32.jpg" width=100>|1|
-|IMU (and barometer¹) board|GY‑91, MPU-9265 (or other MPU‑9250/MPU‑6500 board)<br>ICM20948V2 (ICM‑20948)<br>GY-521 (MPU-6050)|<img src="docs/img/gy-91.jpg" width=90 align=center><br><img src="docs/img/icm-20948.jpg" width=100><br><img src="docs/img/gy-521.jpg" width=100>|1|
+|IMU (and barometer¹) board|GY‑91, MPU-9265 (or other MPU‑9250/MPU‑6500 board)<br>ICM20948V2 (ICM‑20948)³<br>GY-521 (MPU-6050)³⁻¹|<img src="docs/img/gy-91.jpg" width=90 align=center><br><img src="docs/img/icm-20948.jpg" width=100><br><img src="docs/img/gy-521.jpg" width=100>|1|
-|*Boost converter (optional, for more stable power supply)*|*5V output*|<img src="docs/img/buck-boost.jpg" width=100>|1|
+|Boost converter (optional, for more stable power supply)|5V output|<img src="docs/img/buck-boost.jpg" width=100>|1|
 |Motor|8520 3.7V brushed motor.<br>Motor with exact 3.7V voltage is needed, not ranged working voltage (3.7V — 6V).<br>Make sure the motor shaft diameter and propeller hole diameter match!|<img src="docs/img/motor.jpeg" width=100>|4|
-|Propeller|55 mm or 65 mm|<img src="docs/img/prop.jpg" width=100>|4|
+|Propeller|55 mm (alternatively 65 mm)|<img src="docs/img/prop.jpg" width=100>|4|
-|MOSFET (transistor)|UMW 100N03A or [analog](https://t.me/opensourcequadcopter/33).<br>Warning: don't use KIA 100N03A or other manufacturers, they might not work!|<img src="docs/img/100n03a.jpg" width=100>|4|
+|MOSFET (transistor)|100N03A or [analog](https://t.me/opensourcequadcopter/33)|<img src="docs/img/100n03a.jpg" width=100>|4|
-|Pull-down resistor<br>Voltage measurement resistor|10 kΩ|<img src="docs/img/resistor10k.jpg" width=100>|6|
+|Pull-down resistor|10 kΩ|<img src="docs/img/resistor10k.jpg" width=100>|4|
-|3.7V Li-Po battery|LW 952540 (or any compatible by the size).<br>Make sure the battery has enough discharge rate — 25C or more!|<img src="docs/img/battery.jpg" width=100>|1|
+|3.7V Li-Po battery|LW 952540 (or any compatible by the size)|<img src="docs/img/battery.jpg" width=100>|1|
 |Battery connector cable|MX2.0 2P female|<img src="docs/img/mx.png" width=100>|1|
 |Li-Po Battery charger|Any|<img src="docs/img/charger.jpg" width=100>|1|
 |Screws for IMU board mounting|M3x5|<img src="docs/img/screw-m3.jpg" width=100>|2|
@@ -166,16 +152,14 @@ You can see a user-contributed [variant of complete circuit diagram](https://mir
  |-|-|
  |GND|GND|
  |VIN|VCC (or 3.3V depending on the receiver)|
-  |Signal (TX)|GPIO4|
+  |Signal (TX)|GPIO4¹|
-* Optionally connect the battery voltage divider for voltage monitoring to any ADC1 pin (e. g. *GPIO32* on ESP32, *GPIO3* on ESP32-S3).
+*¹ — UART2 RX pin was [changed](https://docs.espressif.com/projects/arduino-esp32/en/latest/migration_guides/2.x_to_3.0.html#id14) to GPIO4 in Arduino ESP32 core 3.0.*
  ESP32 and ESP32-S3 [can measure](https://docs.espressif.com/projects/arduino-esp32/en/latest/api/adc.html#analogsetattenuation) up to 3.1 V and ESP32-S3/ESP32-C3 can measure up to 2.5 V, so choose the voltage divider resistors accordingly.
 ## Resources
 * Telegram channel on developing the drone and the flight controller (in Russian): https://t.me/opensourcequadcopter.
-* Official Telegram chat: https://t.me/opensourcequadcopterchat (English / Russian).
+* Official Telegram chat: https://t.me/opensourcequadcopterchat.
 * Detailed article on Habr.com about the development of the drone (in Russian): https://habr.com/ru/articles/814127/.
 ## Disclaimer
@@ -0,0 +1,5 @@
 board_manager:
  additional_urls:
    - https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
 network:
  connection_timeout: 1h
@@ -28,8 +28,6 @@ Soldered components ([schematics variant](https://miro.com/app/board/uXjVN-dTjoo
 <img src="img/assembly/7.jpg" width=600>
 See an alternative assembly process photos here: https://drive.google.com/drive/folders/1FG5BH9RCzdf1XmJcC70PymiRMXcz6Fx7?usp=sharing.
 ## Motor directions
 > [!WARNING]
@@ -31,7 +31,7 @@
 * [`vector.h`](https://github.com/okalachev/flix/blob/master/flix/vector.h), [`quaternion.h`](https://github.com/okalachev/flix/blob/master/flix/quaternion.h) — библиотеки векторов и кватернионов.
 * [`pid.h`](https://github.com/okalachev/flix/blob/master/flix/pid.h) — ПИД-регулятор.
-* [`filter.h`](https://github.com/okalachev/flix/blob/master/flix/filter.h) — фильтр нижних частот.
+* [`lpf.h`](https://github.com/okalachev/flix/blob/master/flix/lpf.h) — фильтр нижних частот.
 ### Подсистема управления
@@ -34,7 +34,7 @@ Utility files:
 * [`vector.h`](../flix/vector.h), [`quaternion.h`](../flix/quaternion.h) — vector and quaternion libraries.
 * [`pid.h`](../flix/pid.h) — generic PID controller.
-* [`filter.h`](../flix/filter.h) — generic low-pass filter.
+* [`lpf.h`](../flix/lpf.h) — generic low-pass filter.
 ### Control subsystem
@@ -67,38 +67,6 @@ In order to add a console command, modify the `doCommand()` function in `cli.ino
 >
 > For on-the-ground commands, use `pause()` function, instead of `delay()`. This function allows to pause in a way that MAVLink connection will continue working.
 ### Parameter subsystem
 Parameters subsystem (`parameters.ino`) uses standard [Preferences.h](https://docs.espressif.com/projects/arduino-esp32/en/latest/tutorials/preferences.html) ESP32 library to store parameters in non-volatile memory. Each parameter is a regular global variable, which is registered in the `parameters` array.
 To add a new parameter:
 1. Define a global variable for the parameter, two types are supported: `float` and `int`.
 2. Add an entry to the `parameters` array, with the parameter name, a pointer to the variable, and optionally a callback function to call when the parameter is changed.
 3. Everything else will be handled automatically.
 See examples of adding new parameters in commits: [c434107](https://github.com/okalachev/flix/commit/c434107), [a687303](https://github.com/okalachev/flix/commit/a687303).
 > [!NOTE]
 > Since all the parameters are internally stored and passed as floats, the safe range for `int` parameters is -16777216 to 16777215.
 ## Adding a subsystem
 To add a new subsystem:
 1. Create a new `*.ino` file for your subsystem.
 2. Define setup and loop functions for the subsystem, for example `setupMySubsystem()` and `loopMySubsystem()`.
 3. Use `Rate` class if you need to limit the loop frequency, for example:
    ```cpp
    Rate mySubsystemRate(100); // 100 Hz
    void loopMySubsystem() {
    	if (!mySubsystemRate) return;
    	// Do something...
    }
 4. Add setup and loop calls in to `setup()` and `loop()` functions in `flix.ino`.
 ## Building the firmware
 See build instructions in [usage.md](usage.md).
@@ -5,32 +5,27 @@
 Do the following:
 * **Check ESP32 core is installed**. Check if the version matches the one used in the [tutorial](usage.md#building-the-firmware).
-* **Check libraries**. Install all the required libraries from the tutorial. Make sure there are no MPU-9250 or other peripherals libraries that may conflict with the ones used in the tutorial.
+* **Check libraries**. Install all the required libraries from the tutorial. Make sure there are no MPU9250 or other peripherals libraries that may conflict with the ones used in the tutorial.
 * **Check the chosen board**. The correct board to choose in Arduino IDE for ESP32 Mini is *WEMOS D1 MINI ESP32*.
 ## The drone doesn't fly
 Do the following:
-* **Check the battery voltage**. Use a multimeter to measure the battery voltage. The fully charged battery should have about 4.2V.
+* **Check the battery voltage**. Use a multimeter to measure the battery voltage. It should be in range of 3.7-4.2 V.
-* **Check the battery you use has enough discharge current**. The battery should be able to provide 15A of current. So the C-rating for a 1000 mAh battery should be at least 15C (higher is better).
+* **Check if there are some startup errors**. Connect the ESP32 to the computer and check the Serial Monitor output. Use the Reset button to make sure you see the whole ESP32 startup output.
 * **Check if there are some startup errors**. Connect the ESP32 to the computer and check the Serial Monitor output. Use the Reset button or `reboot` command to see the whole startup output.
 * **Check the baudrate is correct**. If you see garbage characters in the Serial Monitor, make sure the baudrate is set to 115200.
 * **Make sure correct IMU model is chosen**. If using ICM-20948/MPU-6050 board, change `MPU9250` to `ICM20948`/`MPU6050` in the `imu.ino` file.
 * **Check if the console is working**. Perform `help` command in Serial Monitor. You should see the list of available commands. You can also access the console using QGroundControl *(Vehicle Setup* ⇒ *Analyze Tools* ⇒ *MAVLink Console)*.
 * **Configure QGroundControl correctly before connecting to the drone** if you use it to control the drone. Go to the settings and enable *Virtual Joystick*. *Auto-Center Throttle* setting **should be disabled**.
 * **If QGroundControl doesn't connect**, you might need to disable the firewall and/or VPN on your computer.
 * **Make sure correct IMU model is chosen**. If using ICM-20948/MPU-6050 board, change `MPU9250` to `ICM20948`/`MPU6050` in the `imu.ino` file.
 * **Check the IMU is working**. Perform `imu` command and check its output:
  * The `status` field should be `OK`.
  * The `rate` field should be about 1000 (Hz).
  * The `accel` and `gyro` fields should change as you move the drone.
 * **Check the IMU orientation is set correctly**. If the attitude estimation is rotated, set the correct IMU orientation as described in the [tutorial](usage.md#define-imu-orientation).
 * **Calibrate the accelerometer.** if is wasn't done before. Type `ca` command in Serial Monitor and follow the instructions.
-* **Check the attitude estimation**. Connect to the drone using QGroundControl. Rotate the drone in different orientations and check if the attitude estimation is shown exactly as on the video below:
+* **Check the attitude estimation**. Connect to the drone using QGroundControl. Rotate the drone in different orientations and check if the attitude estimation shown in QGroundControl is correct.
-
+* **Check the IMU orientation is set correctly**. If the attitude estimation is rotated, set the correct IMU orientation as described in the [tutorial](usage.md#define-imu-orientation).
  <a href="https://youtu.be/yVRN23-GISU"><img width=200 src="https://i3.ytimg.com/vi/yVRN23-GISU/maxresdefault.jpg"></a>
 * **Check the IMU output**. Connect to the drone using QGroundControl on your computer. Go to the *Analyze* tab, *MAVLINK Inspector*. Plot the data from the `SCALED_IMU` message. The gyroscope and accelerometer data should change according to the drone movement.
 * **Check the motors type**. Motors with exact 3.7V voltage are needed, not ranged working voltage (3.7V — 6V).
 * **Check the motors**. Perform the following commands using Serial Monitor:
  * `mfr` — should rotate front right motor (counter-clockwise).
@@ -38,10 +33,7 @@ Do the following:
  * `mrl` — should rotate rear left motor (counter-clockwise).
  * `mrr` — should rotate rear right motor (clockwise).
 * **Check the propeller directions are correct**. Make sure your propeller types (A or B) are installed as on the picture:
  <img src="img/user/peter_ukhov-2/1.jpg" width="200">
-
+* **Check the remote control**. Using `rc` command, check the control values reflect your sticks movement. All the controls should change between -1 and 1, and throttle between 0 and 1.
-* **If using an SBUS receiver**:
+* If using SBUS receiver, **calibrate the RC**. Type `cr` command in Serial Monitor and follow the instructions.
-  * **Define the used GPIO pin** in `RC_RX_PIN` parameter.
+* **Check the IMU output using QGroundControl**. Connect to the drone using QGroundControl on your computer. Go to the *Analyze* tab, *MAVLINK Inspector*. Plot the data from the `SCALED_IMU` message. The gyroscope and accelerometer data should change according to the drone movement.
  * **Calibrate the RC** using `cr` command in the console.
  * **Check the controls** using `rc` command. All the controls should change between -1 and 1, and the throttle between 0 and 1.
@@ -1,63 +1,34 @@
 # Usage: build, setup and flight
-To fly Flix quadcopter, you need to upload the firmware to the ESP32 board, and set up the drone for flight.
+To fly Flix quadcopter, you need to build the firmware, upload it to the ESP32 board, and set up the drone for flight.
-## Uploading the firmware
+To get the firmware sources, clone the repository using git:
 You can either use the **prebuilt binaries** or **build the firmware** from sources — this will let you modify the firmware and add new features.
 ### Prebuilt binaries (the easiest way)
 1. Download the latest firmware file using the following links:
   <!-- markdownlint-disable MD044 -->
   |Type|Boards|Link|
   |-|-|-|
   |ESP32|DevKit, D1 Mini|[`quadcopter.dev/flix.esp32.merged.bin`](https://quadcopter.dev/flix.esp32.merged.bin)|
   |ESP32-S3|Most S3 based|[`quadcopter.dev/flix.esp32s3.merged.bin`](https://quadcopter.dev/flix.esp32s3.merged.bin)|
   |ESP32-S3 (2MB PSRAM)|S3 Super Mini, S3 Zero (2MB PSRAM)|[`quadcopter.dev/flix.esp32s3.qspi.merged.bin`](https://quadcopter.dev/flix.esp32s3.qspi.merged.bin)|
   |ESP32-S3 (8/16MB PSRAM)|S3 Zero (8MB PSRAM)|[`quadcopter.dev/flix.esp32s3.opi.merged.bin`](https://quadcopter.dev/flix.esp32s3.opi.merged.bin)|
   |ESP32-C3|C3 Super Mini|[`quadcopter.dev/flix.esp32c3.merged.bin`](https://quadcopter.dev/flix.esp32c3.merged.bin)|
   |Flix2|Flix2 board|[`quadcopter.dev/flix.flix2.merged.bin`](https://quadcopter.dev/flix.flix2.merged.bin)|
   <!-- markdownlint-enable MD044 -->
 2. Flash your ESP32 board using [ESP32 Web Flasher](https://www.espboards.dev/tools/program/):
   <img src="img/web-flasher.png" width="400">
   * Connect the board to your computer, press *Connect to ESP*, choose the serial port.
   * Go to the *Flash* tab.
   * Choose the downloaded firmware file, set *Flash address* to *0* (important).
   * Click *Program* button and wait until the process is finished.
 ### Building from sources (flexible)
 You can build and upload the firmware using either **Arduino IDE** (easier for beginners) or **command line**.
 Get the sources using git:
 ```bash
 git clone https://github.com/okalachev/flix.git && cd flix
 ```
-Beginners can [download the sources as a ZIP archive](https://github.com/okalachev/flix/archive/refs/heads/master.zip).
+Beginners can [download the source code as a ZIP archive](https://github.com/okalachev/flix/archive/refs/heads/master.zip).
-#### Arduino IDE (Windows, Linux, macOS)
+## Building the firmware
 You can build and upload the firmware using either **Arduino IDE** (easier for beginners) or **command line**.
 ### Arduino IDE (Windows, Linux, macOS)
 <img src="img/arduino-ide.png" width="400" alt="Flix firmware open in Arduino IDE">
 1. Install [Arduino IDE](https://www.arduino.cc/en/software) (version 2 is recommended).
 2. *Windows users might need to install [USB to UART bridge driver from Silicon Labs](https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers).*
-3. Install ESP32 core, version 3.3.10. See the [official Espressif's instructions](https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html#installing-using-arduino-ide) on installing ESP32 Core in Arduino IDE.
+3. Install ESP32 core, version 3.3.6. See the [official Espressif's instructions](https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html#installing-using-arduino-ide) on installing ESP32 Core in Arduino IDE.
 4. Install the following libraries using [Library Manager](https://docs.arduino.cc/software/ide-v2/tutorials/ide-v2-installing-a-library):
   * `FlixPeriph`, the latest version.
   * `MAVLink`, version 2.0.25.
 5. Open the `flix/flix.ino` sketch from downloaded firmware sources in Arduino IDE.
-6. Connect your ESP32 board to the computer and choose correct board type in Arduino IDE (*WEMOS D1 MINI ESP32* for ESP32 Mini, *ESP32S3 Dev Module* for ESP32-S3 Super Mini) and the port.
+6. Connect your ESP32 board to the computer and choose correct board type in Arduino IDE (*WEMOS D1 MINI ESP32* for ESP32 Mini) and the port.
-7. Set *Tools* ⇒ *Core Debug Level* to *Error* to see the errors in the serial console. Set *Tools* ⇒ *USB CDC on Boot* to *Enabled* for ESP32-S3/ESP32-C3 boards.
+7. [Build and upload](https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-uploading-a-sketch) the firmware using Arduino IDE.
 8. [Build and upload](https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-uploading-a-sketch) the firmware using Arduino IDE.
-#### Command line (Windows, Linux, macOS)
+### Command line (Windows, Linux, macOS)
 1. [Install Arduino CLI](https://arduino.github.io/arduino-cli/installation/).
@@ -86,12 +57,6 @@ Beginners can [download the sources as a ZIP archive](https://github.com/okalach
   make upload monitor
   ```
   For ESP32-S3/ESP32-C3 boards, set the appropriate [FQBN](https://docs.arduino.cc/arduino-cli/FAQ/#whats-the-fqbn-string) using `BOARD` parameter:
   ```bash
   make BOARD=esp32:esp32:esp32s3:FlashSize=4M,CDCOnBoot=cdc upload
   ```
 See other available Make commands in [Makefile](../Makefile).
 > [!TIP]
@@ -99,6 +64,15 @@ See other available Make commands in [Makefile](../Makefile).
 ## Before first flight
 ### Choose the IMU model
 In case if using different IMU model than MPU9250, change `imu` variable declaration in the `imu.ino`:
 ```cpp
 ICM20948 imu(SPI);  // For ICM-20948
 MPU6050 imu(Wire);  // For MPU-6050
 ```
 ### Connect using QGroundControl
 QGroundControl is a ground control station software that can be used to monitor and control the drone.
@@ -108,9 +82,6 @@ QGroundControl is a ground control station software that can be used to monitor
 3. Connect your computer or smartphone to the appeared `flix` Wi-Fi network (password: `flixwifi`).
 4. Launch QGroundControl app. It should connect and begin showing the drone's telemetry automatically.
 > [!TIP]
 > If QGroundControl doesn't connect, try to disable the firewall and/or VPN on your computer, as they may block the connection.
 ### Access console
 The console is a command line interface (CLI) that allows to interact with the drone, change parameters, and perform various actions. There are two ways of accessing the console: using **serial port** or using **QGroundControl (wirelessly)**.
@@ -124,7 +95,7 @@ To access the console using serial port:
 To access the console using QGroundControl:
 1. Connect to the drone using QGroundControl app.
-2. Go to the QGroundControl menu ⇒ *Analyze Tools* ⇒ *MAVLink Console*.
+2. Go to the QGroundControl menu ⇒ *Vehicle Setup* ⇒ *Analyze Tools* ⇒ *MAVLink Console*.
 <img src="img/cli.png" width="400">
@@ -139,22 +110,11 @@ The drone is configured using parameters. To access and modify them, go to the Q
 You can also work with parameters using `p` command in the console. Parameter names are case-insensitive.
 ### Configure the IMU
 1. Configure the following parameters for the IMU:
   * `IMU_MODEL` — IMU model (1 for MPU-9250/MPU-6500, 2 for ICM-20948, 3 for MPU-6050, 4 for ICM-40609-D).
   * `IMU_BUS` — communication bus (0 for SPI, 1 for I²C).
   * `IMU_PIN_SCK`, `IMU_PIN_MISO`, `IMU_PIN_MOSI`, `IMU_PIN_CS` — SPI pin numbers.
   * `IMU_PIN_SCL`, `IMU_PIN_SDA` — I²C pin numbers.
   * `IMU_PIN_INT` — IMU data ready pin number (-1 if not used).
 2. Reboot the drone.
 3. Check the IMU is working using `imu` command in the console (should print `status: OK`).
 ### Define IMU orientation
-The IMU orientation (relative to the drone's axes) is defined using the parameters: `IMU_ROT_ROLL`, `IMU_ROT_PITCH`, and `IMU_ROT_YAW`.
+Use parameters, to define the IMU board axes orientation relative to the drone's axes: `IMU_ROT_ROLL`, `IMU_ROT_PITCH`, and `IMU_ROT_YAW`.
-The drone has *X* axis pointing forward, *Y* axis pointing left, and *Z* axis pointing up, and the supported IMU boards have *X* axis pointing to the mounting holes side and *Z* axis pointing up from the component side:
+The drone has *X* axis pointing forward, *Y* axis pointing left, and *Z* axis pointing up, and the supported IMU boards have *X* axis pointing to the pins side and *Z* axis pointing up from the component side:
 <img src="img/imu-axes.png" width="200">
@@ -162,10 +122,10 @@ Use the following table to set the parameters for common IMU orientations:
 |Orientation|Parameters|Orientation|Parameters|
 |:-:|-|-|-|
-|<img src="img/imu-rot-3.png" width="180">|`IMU_ROT_ROLL` = 0<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 0    |<img src="img/imu-rot-7.png" width="180">|`IMU_ROT_ROLL` = 3.142<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 0|
+|<img src="img/imu-rot-1.png" width="180">|`IMU_ROT_ROLL` = 0<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 0    |<img src="img/imu-rot-5.png" width="180">|`IMU_ROT_ROLL` = 3.142<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 0|
-|<img src="img/imu-rot-2.png" width="180">|`IMU_ROT_ROLL` = 0<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = -1.571|<img src="img/imu-rot-6.png" width="180">|`IMU_ROT_ROLL` = 3.142<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = -1.571|
+|<img src="img/imu-rot-2.png" width="180">|`IMU_ROT_ROLL` = 0<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 1.571|<img src="img/imu-rot-6.png" width="180">|`IMU_ROT_ROLL` = 3.142<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = -1.571|
-|<img src="img/imu-rot-1.png" width="180">|`IMU_ROT_ROLL` = 0<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 3.142|<img src="img/imu-rot-5.png" width="180">|`IMU_ROT_ROLL` = 3.142<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 3.142|
+|<img src="img/imu-rot-3.png" width="180">|`IMU_ROT_ROLL` = 0<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 3.142|<img src="img/imu-rot-7.png" width="180">|`IMU_ROT_ROLL` = 3.142<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 3.142|
-|<img src="img/imu-rot-4.png" width="180"><br>☑️ **Default**|<br>`IMU_ROT_ROLL` = 0<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 1.571|<img src="img/imu-rot-8.png" width="180">|`IMU_ROT_ROLL` = 3.142<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 1.571|
+|<img src="img/imu-rot-4.png" width="180"><br>☑️ **Default**|<br>`IMU_ROT_ROLL` = 0<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = -1.571|<img src="img/imu-rot-8.png" width="180">|`IMU_ROT_ROLL` = 3.142<br>`IMU_ROT_PITCH` = 0<br>`IMU_ROT_YAW` = 1.571|
 ### Calibrate accelerometer
@@ -178,48 +138,37 @@ Before flight you need to calibrate the accelerometer:
 If using non-default motor pins, set the pin numbers using the parameters: `MOTOR_PIN_FL`, `MOTOR_PIN_FR`, `MOTOR_PIN_RL`, `MOTOR_PIN_RR` (front-left, front-right, rear-left, rear-right respectively).
-#### Brushless motors
+If using brushless motors and ESCs:
 If using brushless motors with ESCs:
 1. Set the appropriate PWM using the parameters: `MOT_PWM_STOP`, `MOT_PWM_MIN`, and `MOT_PWM_MAX` (1000, 1000, and 2000 is typical).
 2. Decrease the PWM frequency using the `MOT_PWM_FREQ` parameter (400 is typical).
 Reboot the drone to apply the changes.
 > [!CAUTION]
 > **Remove the props when configuring the motors!** If improperly configured, you may not be able to stop them.
-### Battery voltage monitoring (optional)
+### Check everything works
-ESP32 ADC can measure only up to 3.3 V, so you need to use a voltage divider to monitor the battery voltage. To enable voltage measurement, set the following parameters:
+1. Check the IMU is working: perform `imu` command and check its output:
 1. `PWR_VOLT_PIN` — GPIO pin number where the voltage divider is connected (*-1* to disable).
 2. `PWR_VOLT_SCALE` — voltage divider coefficient (*2* for two equal resistors).
 After this setup, you should see the battery voltage in QGroundControl top panel or using `pw` command in the console.
 ### Important: check everything works
 1. Check the IMU is working: perform `imu` command in the console and check the output:
   * The `status` field should be `OK`.
   * The `rate` field should be about 1000 (Hz).
   * The `accel` and `gyro` fields should change as you move the drone.
   * The `accel bias` and `accel scale` fields should contain calibration parameters (not zeros and ones).
   * The `gyro bias` field should contain estimated gyro bias (not zeros).
   * The `landed` field should be `1` when the drone is still on the ground and `0` when you lift it up.
 2. Check the attitude estimation: connect to the drone using QGroundControl, rotate the drone in different orientations and check if the attitude estimation shown in QGroundControl is correct. Compare your attitude indicator (in the *large vertical* mode) to the video:
-   <a href="https://youtu.be/yVRN23-GISU"><img width=300 src="https://i3.ytimg.com/vi/yVRN23-GISU/maxresdefault.jpg"></a>
+    <a href="https://youtu.be/yVRN23-GISU"><img width=300 src="https://i3.ytimg.com/vi/yVRN23-GISU/maxresdefault.jpg"></a>
-3. Perform motor tests. Use the following commands **— remove the propellers before running the tests!**
+3. Perform motor tests in the console. Use the following commands **— remove the propellers before running the tests!**
-   * `mfr` — rotate front right motor (counter-clockwise).
+   * `mfr` — should rotate front right motor (counter-clockwise).
-   * `mfl` — rotate front left motor (clockwise).
+   * `mfl` — should rotate front left motor (clockwise).
-   * `mrl` — rotate rear left motor (counter-clockwise).
+   * `mrl` — should rotate rear left motor (counter-clockwise).
-   * `mrr` — rotate rear right motor (clockwise).
+   * `mrr` — should rotate rear right motor (clockwise).
-   Make sure rotation directions and propeller types match the following diagram:
+   Rotation diagram:
   <img src="img/motors.svg" width=200>
@@ -228,22 +177,10 @@ After this setup, you should see the battery voltage in QGroundControl top panel
 ## Setup remote control
-There are several ways to control the drone's flight: using **smartphone** (Wi-Fi), using **SBUS remote control**, or using **USB remote control** (Wi-Fi/ESP-NOW).
+There are several ways to control the drone's flight: using **smartphone** (Wi-Fi), using **SBUS remote control**, or using **USB remote control** (Wi-Fi).
 ### Control with a smartphone
 #### Using Mavlink Joystick app (Android)
 <img src="https://github.com/goldarte/mavlink-joystick/blob/master/app_screen.png?raw=true" width="400">
 1. Download and install [Mavlink Joystick app](https://github.com/goldarte/mavlink-joystick/releases/latest).
 2. Power the drone using the battery.
 3. Connect your smartphone to the appeared `flix` Wi-Fi network (password: `flixwifi`).
 4. Open Mavlink Joystick app. It should connect and begin showing the drone's telemetry automatically.
 5. Use the virtual joystick to fly the drone!
 #### Using QGroundControl app
 1. Install [QGroundControl mobile app](https://docs.qgroundcontrol.com/master/en/qgc-user-guide/getting_started/download_and_install.html#android) on your smartphone.
 2. Power the drone using the battery.
 3. Connect your smartphone to the appeared `flix` Wi-Fi network (password: `flixwifi`).
@@ -256,13 +193,11 @@ There are several ways to control the drone's flight: using **smartphone** (Wi-F
 ### Control with a remote control
-If using SBUS-connected remote control you need to enable SBUS and calibrate it:
+Before using remote SBUS-connected remote control, you need to calibrate it:
-1. Connect to the drone using QGroundControl.
+1. Access the console using QGroundControl (recommended) or Serial Monitor.
-2. In parameters, set the `RC_RX_PIN` parameter to the GPIO pin number where the SBUS signal is connected, for example: 4. Negative value disables SBUS.
+2. Type `cr` command and follow the instructions.
-3. Check if the receiver is working using `rc` command in the console.
+3. Use the remote control to fly the drone!
 4. Open the console, type `cr` command and follow the instructions to calibrate the remote control.
 5. Use the remote control to fly the drone!
 ### Control with a USB remote control
@@ -273,7 +208,7 @@ If your drone doesn't have RC receiver installed, you can use USB remote control
 3. Power up the drone.
 4. Connect your computer to the appeared `flix` Wi-Fi network (password: `flixwifi`).
 5. Launch QGroundControl app. It should connect and begin showing the drone's telemetry automatically.
-6. Go to the QGroundControl menu ⇒ *Vehicle Setup* ⇒ *Joystick*. Calibrate your USB remote control there.
+6. Go the the QGroundControl menu ⇒ *Vehicle Setup* ⇒ *Joystick*. Calibrate you USB remote control there.
 7. Use the USB remote control to fly the drone!
 ## Flight
@@ -299,11 +234,11 @@ When finished flying, **disarm** the drone, moving the left stick to the bottom
 ### Flight modes
-Flight mode is changed using mode switch on the remote control (if configured) or using the console commands. The main flight mode is *STAB*. In order to change modes using SBUS remote control, set the parameters: `CTL_FLT_MODE_0`, `CTL_FLT_MODE_1`, and `CTL_FLT_MODE_2` to required mode numbers (0 for *RAW*, 1 for *ACRO*, 2 for *STAB*, 3 for *AUTO*).
+Flight mode is changed using mode switch on the remote control or using the command line.
 #### STAB
-In this mode, the drone stabilizes its attitude (orientation). The left stick controls throttle and yaw rate, the right stick controls pitch and roll angles.
+The default mode is *STAB*. In this mode, the drone stabilizes its attitude (orientation). The left stick controls throttle and yaw rate, the right stick controls pitch and roll angles.
 > [!IMPORTANT]
 > The drone doesn't stabilize its position, so slight drift is possible. The pilot should compensate it manually.
@@ -318,9 +253,9 @@ In this mode, the pilot controls the angular rates. This control method is diffi
 #### AUTO
-In this mode, the pilot inputs are ignored (except the mode switch). The drone can be controlled using [pyflix](../tools/pyflix/) Python library, or by modifying the firmware to implement the needed behavior.
+In this mode, the pilot inputs are ignored (except the mode switch, if configured). The drone can be controlled using [pyflix](../tools/pyflix/) Python library, or by modifying the firmware to implement the needed autonomous behavior.
-If the pilot moves the control sticks and mode switch is not configured, the drone will switch back to *STAB* mode.
+If the pilot moves the control sticks, the drone will switch back to *STAB* mode.
 ## Wi-Fi configuration
@@ -330,8 +265,11 @@ The Wi-Fi mode is chosen using `WIFI_MODE` parameter in QGroundControl or in the
 * `0` — Wi-Fi is disabled.
 * `1` — Access Point mode *(AP)* — the drone creates a Wi-Fi network.
-* `2` — Client mode *(STA)* — the drone connects to an existing Wi-Fi network (may cause additional delays, so generally not recommended).
+* `2` — Client mode *(STA)* — the drone connects to an existing Wi-Fi network.
-* `3` — ESP-NOW mode — the drone uses ESP-NOW protocol for communication.
+* `3` — *ESP-NOW (not implemented yet)*.
 > [!WARNING]
 > Tests showed that Client mode may cause **additional delays** in remote control (due to retranslations), so it's generally not recommended.
 The SSID and password are configured using the `ap` and `sta` console commands:
@@ -353,43 +291,9 @@ Disabling Wi-Fi:
 p WIFI_MODE 0
 ```
 ### Using ESP-NOW
 [ESP-NOW](https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/network/esp_now.html) is a low level wireless communication protocol. It can provide lower latency, better reliability, and longer range than Wi-Fi. However, it requires a second ESP32 board to be used as a proxy for the computer.
 <img src="img/espnow-connection.jpg" width="600">
 To setup ESP-NOW communication:
 1. Flash the second ESP32 board with ESP-NOW proxy sketch: [`tools/espnow-proxy/espnow-proxy.ino`](../tools/espnow-proxy/espnow-proxy.ino). Use Arduino IDE or command line: `make upload_proxy`.
 2. Open Serial Monitor in Arduino IDE or use `make monitor` command. The ESP32 will print its MAC address and generated encryption key, for example:
   ```
   espnow 7a:c8:e3:eb:bf:e9 &PiuSysxP9+$L&5E
   ```
   Run this line as a console command on each drone you want to bind to this proxy board. [The maximum number](https://github.com/espressif/esp-idf/blob/e95cab4be8fd293e3f3323181e7a2280874da6f7/components/esp_wifi/include/esp_now.h#L32-L33) of simultaneously connected drones is 20 (unencrypted) or 6 (encrypted).
 3. Set the `WIFI_MODE` parameter to `3` on the drone:
   ```
   p WIFI_MODE 3
   ```
 4. Go to the QGroundControl menu ⇒ *Application Settings* ⇒ *Comm Links*, add new link with the following settings:
   * Name: ESP32.
   * Type: Serial.
   * Serial Port: choose the port of the proxy ESP32 board, e. g. `/dev/cu.usbserial-0001`.
   * Baud Rate: 115200.
 5. Click *Save*, click *Connect*. QGroundControl should connect to the drone using ESP-NOW and begin showing the telemetry.
 > [!TIP]
 > Make sure Arduino IDE is not running when using ESP-NOW proxy board, as it may block the serial port.
 ## Flight log
-After the flight, you can download the flight log wirelessly for analysis. Use the following command on your computer for that:
+After the flight, you can download the flight log for analysis wirelessly. Use the following command on your computer for that:
 ```bash
 make log
@@ -4,87 +4,6 @@ This page contains user-built drones based on the Flix project. Publish your pro
 ---
 Author: [Oleg1405](https://t.me/Oleg1405).<br>
 Description: ESP32 Mini, MPU-6500 IMU, boost converter, BT2.0 power connector, 65 mm props, BetaFPV ELRS Lite Receiver, Radiomaster Pocket + Mavlink Joystick (Android) control.
 <img src="img/user/oleg1405/1.jpg" height=300>
 [Flight video](https://www.youtube.com/shorts/rbXV4sHbpso).
 ---
 Author: Alican Erüst.<br>
 Description: QX95 mm frame, 55 mm propellers, 3.7 V 25C 1050 mAh LiPo battery, MPU6050 IMU, Logitech F310 gamepad controller, with a total quadcopter weight of 66 g.
 <img src="img/user/alicanerus/1.jpg" height=200> <img src="img/user/alicanerus/2.jpg" height=200> <img src="img/user/alicanerus/3.jpg" height=200>
 [Flight video](https://drive.google.com/file/d/1k0WeWTKnCAfaugkX7LcmNxsUuq79RL8Z/view?usp=sharing).
 ---
 Author: [Неруш Михаил](https://t.me/NerushMV).<br>
 Description: custom frame made of 4 mm plywood, 8520 brushed motors, 75 mm propellers, MPU-6500. FlySky FS-i6X with ESP32-based adapter for ESP-NOW communication (using PPM output).<br>
 Sources and materials: [link](https://drive.google.com/drive/folders/1uWiDcuorLrtVs_IIR7Y13omij-7Q1nx8).
 <img src="img/user/nerush/1.jpg" height=200> <img src="img/user/nerush/2.jpg" height=200>
 [Flight video](https://drive.google.com/file/d/1jRXeGx34lJpUfw0GKLQeIzkWZvooQJSE/view?usp=sharing).
 ---
 Author: [Konstantinos Paraskevas](https://github.com/Frapais).<br>
 Description: drone with a custom single-boarded airframe, extending the [Sprig-C3 module](https://github.com/Frapais/Sprig-C3).
 ESP32-C3 microcontroller, ICM-20948 IMU, on-board fuel-gauge, status LED indicator.<br>
 Repository with all the code and PCB sources: https://github.com/Frapais/Sprig-Drone.
 <img src="img/user/kostas/1.jpg" height=150> <img src="img/user/kostas/2.jpg" height=150>
 Detailed video about making the drone:
 <a href="https://youtu.be/82Q-uBq6s48"><img width=400 src="https://i3.ytimg.com/vi/82Q-uBq6s48/maxresdefault.jpg"></a>
 ---
 Author: [Awab Anas](http://t.me/AW_VENOM).<br>
 Description: ESP32 D1 Mini, MPU-6050, 8520 3.7V brushed motors, 55 mm propellers, battery li-po 1200 mAh, controlling via [Mavlink Joystick app](https://github.com/goldarte/mavlink-joystick/releases/latest).<br>
 [Flight validation](https://drive.google.com/file/d/12z0jfctZDBA6b5UKCG0Uje5rAxj6DhF-/view?usp=sharing).
 <img src="img/user/aw_venom/1.jpg" height=200>
 ---
 Author: [Ina Tix](https://t.me/ina_tix).<br>
 Description: XR2981 based DC-DC converter, ELRS MINI 2.4GHz RX SX1280 receiver (SBUS interface), Radiomaster TX12 remote control.<br>
 [Flight validation](https://drive.google.com/file/d/1yqkKNuz4R_yxGqUNQxVpixJbXqEEcUSj/view?usp=share_link).
 <img src="img/user/ina_tix/1.jpg" height=200> <img src="img/user/ina_tix/2.jpg" height=200> <img src="img/user/ina_tix/3.jpg" height=200>
 ---
 Author: Oleg Kalachev.<br>
 Description: the first attempt on making an official PCB based Flix drone (Flix2 board). The IMU is not working on this version, so an external MPU-6050 board was used, therefore considered as **Flix version 1.5**.<br>
 [Flight video](https://drive.google.com/file/d/1R7tuUsFmPY0CGcOCFfMFaCp9kR49K3bl/view?usp=sharing).
 <img src="img/flix1.5.jpg" width=300>
 ---
 Author: [FanBy0ru](https://https://github.com/FanBy0ru).<br>
 Description: custom 3D-printed frame.<br>
 Frame STLs and flight validation: https://cults3d.com/en/3d-model/gadget/armature-pour-flix-drone.
 <img src="img/user/fanby0ru/1.jpg" height=200> <img src="img/user/fanby0ru/2.jpg" height=200>
 ---
 Author: Ivan44 Phalko.<br>
 Description: custom PCB, cusom test bench.<br>
 [Flight validation](https://drive.google.com/file/d/17DNDJ1gPmCmDRAwjedCbJ9RXAyqMqqcX/view?usp=sharing).
 <img src="img/user/phalko/1.jpg" height=200> <img src="img/user/phalko/2.jpg" height=200> <img src="img/user/phalko/3.jpg" height=200>
 ---
 Author: **Arkadiy "Arky" Matsekh**, Foucault Dynamics, Gold Coast, Australia.<br>
 The drone was built for the University of Queensland industry-led Master's capstone project.
@@ -106,17 +25,6 @@ Author: [goldarte](https://t.me/goldarte).<br>
 ---
 Author: [malagis](https://oshwhub.com/malagis).<br>
 A Chinese custom PCB version of Flix with a big community of users, lots of materials and modifications.
 Main project's page: https://oshwhub.com/malagis/esp32-mini-plane.<br>
 Video about the project: https://www.bilibili.com/video/BV14vyqBFEJn/.
 <img src="img/user/malagis/1.jpg" height=200> <img src="img/user/malagis/2.jpg" height=200> <img src="img/user/malagis/3.jpg" height=200>
 ---
 ## School 548 course
 Special course on quadcopter design and engineering took place in october-november 2025 in School 548, Moscow. The course included UAV control theory, electronics, drone assembly and setup practice, using the Flix project.
@@ -6,58 +6,54 @@
 #include "pid.h"
 #include "vector.h"
 #include "util.h"
-#include "filter.h"
+#include "lpf.h"
 extern const int MOTOR_REAR_LEFT, MOTOR_REAR_RIGHT, MOTOR_FRONT_RIGHT, MOTOR_FRONT_LEFT;
 extern const int RAW, ACRO, STAB, AUTO;
 extern const int W_AP, W_STA, W_ESPNOW;
 extern float t, dt, loopRate;
 extern uint16_t channels[16];
 extern float controlTime;
 extern int mode;
 extern bool armed;
 extern LowPassFilter<Vector> gyroBiasFilter;
 extern float voltage;
 const char* motd =
 "\nWelcome to\n"
 " _______  __       __  ___   ___\n"
 "|   ____||  |     |  | \\  \\ /  /\n"
 "|  |__   |  |     |  |  \\  V  /\n"
 "|   __|  |  |     |  |   >   <\n"
 "|  |     |  `----.|  |  /  .  \\\n"
 "|__|     |_______||__| /__/ \\__\\\n\n"
 "(C) Oleg Kalachev\n"
 "https://github.com/okalachev/flix\n\n"
 "Commands:\n\n"
 "help - show help\n"
 "p - show all parameters\n"
-"p <str> - show parameters starting with str\n"
+"p <name> - show parameter\n"
 "p <name> <value> - set parameter\n"
 "preset - reset parameters\n"
 "time - show time info\n"
 "ps - show pitch/roll/yaw\n"
 "psq - show attitude quaternion\n"
 "imu - show IMU data\n"
 "ca - calibrate accel\n"
 "st - show state estimation\n"
 "arm - arm the drone\n"
 "disarm - disarm the drone\n"
 "raw/stab/acro/auto - set mode\n"
 "rc - show RC data\n"
 "cr - calibrate RC\n"
 "pw - show power info\n"
 "wifi - show Wi-Fi info\n"
-"wifi ap/sta/espnow/off - set Wi-Fi mode\n"
+"ap <ssid> <password> - setup Wi-Fi access point\n"
-"ap <ssid> <password> - configure Wi-Fi access point\n"
+"sta <ssid> <password> - setup Wi-Fi client mode\n"
 "sta <ssid> <password> - configure Wi-Fi client mode\n"
 "espnow <mac> [<key>] - configure ESP-NOW peer\n"
 "mot - show motor output\n"
 "log [dump] - print log header [and data]\n"
-"mfr/mfl/mrr/mrl [<thrust>] - test motor (remove props)\n"
+"cr - calibrate RC\n"
 "ca - calibrate accel\n"
 "cl - calibrate level\n"
 "mfr, mfl, mrr, mrl - test motor (remove props)\n"
 "sys - show system info\n"
 "reset - reset drone's state\n"
 "reboot - reboot the drone\n";
 void print(const char* format, ...) {
-	char buf[3000];
+	char buf[1000];
 	va_list args;
 	va_start(args, format);
 	vsnprintf(buf, sizeof(buf), format, args);
@@ -92,8 +88,10 @@ void doCommand(String str, bool echo = false) {
 	// execute command
 	if (command == "help" || command == "motd") {
 		print("%s\n", motd);
-	} else if (command == "p" && arg1 == "") {
+	} else if (command == "p" && arg0 == "") {
-		printParameters(arg0.c_str());
+		printParameters();
 	} else if (command == "p" && arg0 != "" && arg1 == "") {
 		print("%s = %g\n", arg0.c_str(), getParameter(arg0.c_str()));
 	} else if (command == "p") {
 		bool success = setParameter(arg0.c_str(), arg1.toFloat());
 		if (success) {
@@ -107,15 +105,15 @@ void doCommand(String str, bool echo = false) {
 		print("Time: %f\n", t);
 		print("Loop rate: %.0f\n", loopRate);
 		print("dt: %f\n", dt);
 	} else if (command == "ps") {
 		Vector a = attitude.toEuler();
 		print("roll: %f pitch: %f yaw: %f\n", degrees(a.x), degrees(a.y), degrees(a.z));
 	} else if (command == "psq") {
 		print("qw: %f qx: %f qy: %f qz: %f\n", attitude.w, attitude.x, attitude.y, attitude.z);
 	} else if (command == "imu") {
 		printIMUInfo();
 		printIMUCalibration();
 		print("landed: %d\n", landed);
 	} else if (command == "st") {
 		print("rates: %g %g %g\n", rates.x, rates.y, rates.z);
 		print("attitude: %g %g %g %g\n", attitude.w, attitude.x, attitude.y, attitude.z);
 		print("roll: %g° pitch: %g° yaw: %g°\n", degrees(attitude.getRoll()), degrees(attitude.getPitch()), degrees(attitude.getYaw()));
 		print("landed: %d\n", landed);
 	} else if (command == "arm") {
 		armed = true;
 	} else if (command == "disarm") {
@@ -138,18 +136,12 @@ void doCommand(String str, bool echo = false) {
 		print("time: %.1f\n", controlTime);
 		print("mode: %s\n", getModeName());
 		print("armed: %d\n", armed);
 	} else if (command == "pw") {
 		print("Voltage: %.1f V\n", voltage);
 	} else if (command == "wifi" && arg0 == "") {
 		printWiFiInfo();
 	} else if (command == "wifi") {
-		setWiFiMode(arg0);
+		printWiFiInfo();
 	} else if (command == "ap") {
-		configWiFi(W_AP, arg0.c_str(), arg1.c_str());
+		configWiFi(true, arg0.c_str(), arg1.c_str());
 	} else if (command == "sta") {
-		configWiFi(W_STA, arg0.c_str(), arg1.c_str());
+		configWiFi(false, arg0.c_str(), arg1.c_str());
 	} else if (command == "espnow") {
 		configWiFi(W_ESPNOW, arg0.c_str(), arg1.c_str());
 	} else if (command == "mot") {
 		print("front-right %g front-left %g rear-right %g rear-left %g\n",
 			motors[MOTOR_FRONT_RIGHT], motors[MOTOR_FRONT_LEFT], motors[MOTOR_REAR_RIGHT], motors[MOTOR_REAR_LEFT]);
@@ -160,23 +152,23 @@ void doCommand(String str, bool echo = false) {
 		calibrateRC();
 	} else if (command == "ca") {
 		calibrateAccel();
 	} else if (command == "cl") {
 		calibrateLevel();
 	} else if (command == "mfr") {
-		testMotor(MOTOR_FRONT_RIGHT, arg0.isEmpty() ? 0.2 : arg0.toFloat());
+		testMotor(MOTOR_FRONT_RIGHT);
 	} else if (command == "mfl") {
-		testMotor(MOTOR_FRONT_LEFT, arg0.isEmpty() ? 0.2 : arg0.toFloat());
+		testMotor(MOTOR_FRONT_LEFT);
 	} else if (command == "mrr") {
-		testMotor(MOTOR_REAR_RIGHT, arg0.isEmpty() ? 0.2 : arg0.toFloat());
+		testMotor(MOTOR_REAR_RIGHT);
 	} else if (command == "mrl") {
-		testMotor(MOTOR_REAR_LEFT, arg0.isEmpty() ? 0.2 : arg0.toFloat());
+		testMotor(MOTOR_REAR_LEFT);
 	} else if (command == "sys") {
 #ifdef ESP32
 		print("Chip: %s\n", ESP.getChipModel());
 		print("Temperature: %.1f °C\n", temperatureRead());
-		print("Total RAM: %d KB\n", ESP.getHeapSize() / 1024);
+		print("Free heap: %d\n", ESP.getFreeHeap());
 		print("Free heap: %d KB\n", ESP.getFreeHeap() / 1024);
 		print("Firmware: " __DATE__ " " __TIME__ "\n");
 		// Print tasks table
-		print("Num  Task                MinSt  Prio  Core  CPU%%\n");
+		print("Num  Task                Stack  Prio  Core  CPU%%\n");
 		int taskCount = uxTaskGetNumberOfTasks();
 		TaskStatus_t *systemState = new TaskStatus_t[taskCount];
 		uint32_t totalRunTime;
@@ -185,7 +177,7 @@ void doCommand(String str, bool echo = false) {
 			String core = systemState[i].xCoreID == tskNO_AFFINITY ? "*" : String(systemState[i].xCoreID);
 			int cpuPercentage = systemState[i].ulRunTimeCounter / (totalRunTime / 100);
 			print("%-5d%-20s%-7d%-6d%-6s%d\n",systemState[i].xTaskNumber, systemState[i].pcTaskName,
-				systemState[i].usStackHighWaterMark, systemState[i].uxCurrentPriority, core.c_str(), cpuPercentage);
+				systemState[i].usStackHighWaterMark, systemState[i].uxCurrentPriority, core, cpuPercentage);
 		}
 		delete[] systemState;
 #endif
@@ -210,7 +202,7 @@ void handleInput() {
 	while (Serial.available()) {
 		char c = Serial.read();
-		if (c == '\n' || c == '\r') {
+		if (c == '\n') {
 			doCommand(input);
 			input.clear();
 		} else {
@@ -1,27 +0,0 @@
 // Copyright (c) 2026 Oleg Kalachev <okalachev@gmail.com>
 // Repository: https://github.com/okalachev/flix
 // Parameter defaults
 #pragma once
 void setDefaults() {
 	// Set defaults here
 	#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C3)
 		pwmFrequency = 38000;
 	#endif
 	#ifdef FLIX2
 		imuModel = 4; // ICM-40609-D
 		imuIntPin = 10;
 		imuCsPin = 14;
 		motorPins[MOTOR_REAR_LEFT] = 41;
 		motorPins[MOTOR_REAR_RIGHT] = 7;
 		motorPins[MOTOR_FRONT_RIGHT] = 18;
 		motorPins[MOTOR_FRONT_LEFT] = 38;
 		voltagePin = 3;
 	#endif
 }
@@ -6,9 +6,34 @@
 #include "vector.h"
 #include "quaternion.h"
 #include "pid.h"
-#include "filter.h"
+#include "lpf.h"
 #include "util.h"
 #define PITCHRATE_P 0.05
 #define PITCHRATE_I 0.2
 #define PITCHRATE_D 0.001
 #define PITCHRATE_I_LIM 0.3
 #define ROLLRATE_P PITCHRATE_P
 #define ROLLRATE_I PITCHRATE_I
 #define ROLLRATE_D PITCHRATE_D
 #define ROLLRATE_I_LIM PITCHRATE_I_LIM
 #define YAWRATE_P 0.3
 #define YAWRATE_I 0.0
 #define YAWRATE_D 0.0
 #define YAWRATE_I_LIM 0.3
 #define ROLL_P 6
 #define ROLL_I 0
 #define ROLL_D 0
 #define PITCH_P ROLL_P
 #define PITCH_I ROLL_I
 #define PITCH_D ROLL_D
 #define YAW_P 3
 #define PITCHRATE_MAX radians(360)
 #define ROLLRATE_MAX radians(360)
 #define YAWRATE_MAX radians(300)
 #define TILT_MAX radians(30)
 #define RATES_D_LPF_ALPHA 0.2 // cutoff frequency ~ 40 Hz
 const int RAW = 0, ACRO = 1, STAB = 2, AUTO = 3; // flight modes
 int mode = STAB;
 bool armed = false;
@@ -19,14 +44,14 @@ Vector ratesExtra; // feedforward rates
 Vector torqueTarget;
 float thrustTarget;
-PID rollRatePID(0.05, 0.2, 0.001, 0.3, 0.2);
+PID rollRatePID(ROLLRATE_P, ROLLRATE_I, ROLLRATE_D, ROLLRATE_I_LIM, RATES_D_LPF_ALPHA);
-PID pitchRatePID(0.05, 0.2, 0.001, 0.3, 0.2);
+PID pitchRatePID(PITCHRATE_P, PITCHRATE_I, PITCHRATE_D, PITCHRATE_I_LIM, RATES_D_LPF_ALPHA);
-PID yawRatePID(0.3, 0, 0, 0.3);
+PID yawRatePID(YAWRATE_P, YAWRATE_I, YAWRATE_D);
-PID rollPID(6);
+PID rollPID(ROLL_P, ROLL_I, ROLL_D);
-PID pitchPID(6);
+PID pitchPID(PITCH_P, PITCH_I, PITCH_D);
-PID yawPID(3);
+PID yawPID(YAW_P, 0, 0);
-Vector maxRate(radians(360), radians(360), radians(360));
+Vector maxRate(ROLLRATE_MAX, PITCHRATE_MAX, YAWRATE_MAX);
-float tiltMax = radians(30);
+float tiltMax = TILT_MAX;
 int flightModes[] = {STAB, STAB, STAB}; // map for rc mode switch
 extern const int MOTOR_REAR_LEFT, MOTOR_REAR_RIGHT, MOTOR_FRONT_RIGHT, MOTOR_FRONT_LEFT;
@@ -42,7 +67,7 @@ void control() {
 void interpretControls() {
 	if (controlMode < 0.25) mode = flightModes[0];
-	else if (controlMode <= 0.75) mode = flightModes[1];
+	else if (controlMode < 0.75) mode = flightModes[1];
 	else if (controlMode > 0.75) mode = flightModes[2];
 	if (mode == AUTO) return; // pilot is not effective in AUTO mode
@@ -124,26 +149,12 @@ void controlTorque() {
 	motors[MOTOR_REAR_LEFT] = thrustTarget + torqueTarget.x + torqueTarget.y - torqueTarget.z;
 	motors[MOTOR_REAR_RIGHT] = thrustTarget - torqueTarget.x + torqueTarget.y + torqueTarget.z;
 	// Prioritize angle control over thrust control
 	desaturate(motors[MOTOR_FRONT_LEFT], motors[MOTOR_FRONT_RIGHT], motors[MOTOR_REAR_LEFT], motors[MOTOR_REAR_RIGHT]);
 	motors[0] = constrain(motors[0], 0, 1);
 	motors[1] = constrain(motors[1], 0, 1);
 	motors[2] = constrain(motors[2], 0, 1);
 	motors[3] = constrain(motors[3], 0, 1);
 }
 void desaturate(float& a, float& b, float& c, float& d) {
 	float maxThrust = max(max(a, b), max(c, d));
 	if (maxThrust > 1) {
 		float diff = maxThrust - 1;
 		a -= diff;
 		b -= diff;
 		c -= diff;
 		d -= diff;
 	}
 }
 const char* getModeName() {
 	switch (mode) {
 		case RAW: return "RAW";
@@ -1,11 +1,11 @@
 // Copyright (c) 2023 Oleg Kalachev <okalachev@gmail.com>
 // Repository: https://github.com/okalachev/flix
-// Attitude estimation using gyro and accelerometer
+// Attitude estimation from gyro and accelerometer
 #include "quaternion.h"
 #include "vector.h"
-#include "filter.h"
+#include "lpf.h"
 #include "util.h"
 Vector rates; // estimated angular rates, rad/s
@@ -13,13 +13,11 @@ Quaternion attitude; // estimated attitude
 bool landed;
 float accWeight = 0.003;
 float levelWeight = 0.0002;
 LowPassFilter<Vector> ratesFilter(0.2); // cutoff frequency ~ 40 Hz
 void estimate() {
 	applyGyro();
 	applyAcc();
 	applyLevel();
 }
 void applyGyro() {
@@ -32,7 +30,8 @@ void applyGyro() {
 void applyAcc() {
 	// test should we apply accelerometer gravity correction
-	landed = !motorsActive() && abs(acc.norm() - ONE_G) < ONE_G * 0.1f;
+	float accNorm = acc.norm();
 	landed = !motorsActive() && abs(accNorm - ONE_G) < ONE_G * 0.1f;
 	if (!landed) return;
@@ -43,13 +42,3 @@ void applyAcc() {
 	// apply correction
 	attitude = Quaternion::rotate(attitude, Quaternion::fromRotationVector(correction));
 }
 void applyLevel() {
 	if (landed) return;
 	if (thrustTarget < 0.1) return; // skip at idle thrust
 	// assume the pilot keeps the drone more or less level in flight
 	Vector up = Quaternion::rotateVector(Vector(0, 0, 1), attitude);
 	Vector correction = Vector::rotationVectorBetween(Vector(0, 0, 1), up) * levelWeight;
 	attitude = Quaternion::rotate(attitude, Quaternion::fromRotationVector(correction));
 }
@@ -17,12 +17,12 @@ extern float motors[4];
 void setup() {
 	Serial.begin(115200);
-	print("Initializing Flix\n");
+	print("Initializing flix\n");
 	disableBrownOut();
 	setupParameters();
 	setupPower();
 	setupLED();
 	setLED(true);
 	setupMotors();
 	setLED(true);
 	setupWiFi();
 	setupIMU();
 	setupRC();
@@ -39,7 +39,6 @@ void loop() {
 	sendMotors();
 	handleInput();
 	processMavlink();
 	readVoltage();
 	logData();
 	syncParameters();
 }
@@ -4,18 +4,13 @@
 // Work with the IMU sensor
 #include <SPI.h>
 #include <Wire.h>
 #include <FlixPeriph.h>
 #include "vector.h"
-#include "filter.h"
+#include "lpf.h"
 #include "util.h"
-IMU *imu;
+MPU9250 imu(SPI);
-int imuModel = -1; // 1 - MPU9250, 2 - ICM20948, 3 - MPU6050, 4 - ICM40609D
+Vector imuRotation(0, 0, -PI / 2); // imu orientation as Euler angles
 int imuBus = 0; // 0 - SPI, 1 - I2C
 int imuSckPin = SCK, imuMisoPin = MISO, imuMosiPin = MOSI, imuCsPin = SS, imuIntPin = -1;
 int imuSdaPin = SDA, imuSclPin = SCL;
 Vector imuRotation(0, 0, PI / 2); // imu orientation as Euler angles
 Vector gyro; // gyroscope output, rad/s
 Vector gyroBias;
@@ -28,42 +23,27 @@ LowPassFilter<Vector> gyroBiasFilter(0.001);
 void setupIMU() {
 	print("Setup IMU\n");
-	free(imu);
+	imu.begin();
 	if (imuModel == 3) imuBus = 1; // MPU6050 is I2C only
 	if (imuBus == 0) {
 		// SPI connection
 		SPI.begin(imuSckPin, imuMisoPin, imuMosiPin);
 		imu = IMU::create(imuModel, SPI, imuCsPin, imuIntPin);
 	} else {
 		// I2C connection
 		Wire.setPins(imuSdaPin, imuSclPin);
 		imu = IMU::create(imuModel, Wire, imuIntPin);
 	}
 	imu->begin();
 	configureIMU();
 }
 void configureIMU() {
-	imu->setAccelRange(IMU::ACCEL_RANGE_4G);
+	imu.setAccelRange(imu.ACCEL_RANGE_4G);
-	imu->setGyroRange(IMU::GYRO_RANGE_2000DPS);
+	imu.setGyroRange(imu.GYRO_RANGE_2000DPS);
-	imu->setDLPF(IMU::DLPF_MAX);
+	imu.setDLPF(imu.DLPF_MAX);
-	imu->setRate(IMU::RATE_1KHZ_APPROX);
+	imu.setRate(imu.RATE_1KHZ_APPROX);
-	imu->setupInterrupt();
+	imu.setupInterrupt();
 }
 void readIMU() {
-	imu->waitForData();
+	imu.waitForData();
-	imu->getGyro(gyro.x, gyro.y, gyro.z);
+	imu.getGyro(gyro.x, gyro.y, gyro.z);
-	imu->getAccel(acc.x, acc.y, acc.z);
+	imu.getAccel(acc.x, acc.y, acc.z);
 	calibrateGyroOnce();
-
+	// apply scale and bias
 	// Apply scale and bias
 	acc = (acc - accBias) / accScale;
 	gyro = gyro - gyroBias;
-
+	// rotate to body frame
 	// Rotate to body frame
 	Quaternion rotation = Quaternion::fromEuler(imuRotation);
 	acc = Quaternion::rotateVector(acc, rotation.inversed());
 	gyro = Quaternion::rotateVector(gyro, rotation.inversed());
@@ -72,13 +52,12 @@ void readIMU() {
 void calibrateGyroOnce() {
 	static Delay landedDelay(2);
 	if (!landedDelay.update(landed)) return; // calibrate only if definitely stationary
 	gyroBias = gyroBiasFilter.update(gyro);
 }
 void calibrateAccel() {
 	print("Calibrating accelerometer\n");
-	imu->setAccelRange(IMU::ACCEL_RANGE_2G); // the most sensitive mode
+	imu.setAccelRange(imu.ACCEL_RANGE_2G); // the most sensitive mode
 	print("1/6 Place level [8 sec]\n");
 	pause(8);
@@ -112,9 +91,9 @@ void calibrateAccelOnce() {
 	// Compute the average of the accelerometer readings
 	acc = Vector(0, 0, 0);
 	for (int i = 0; i < samples; i++) {
-		imu->waitForData();
+		imu.waitForData();
 		Vector sample;
-		imu->getAccel(sample.x, sample.y, sample.z);
+		imu.getAccel(sample.x, sample.y, sample.z);
 		acc = acc + sample;
 	}
 	acc = acc / samples;
@@ -126,12 +105,19 @@ void calibrateAccelOnce() {
 	if (acc.x < accMin.x) accMin.x = acc.x;
 	if (acc.y < accMin.y) accMin.y = acc.y;
 	if (acc.z < accMin.z) accMin.z = acc.z;
 	// Compute scale and bias
 	accScale = (accMax - accMin) / 2 / ONE_G;
 	accBias = (accMax + accMin) / 2;
 }
 void calibrateLevel() {
 	print("Place perfectly level [1 sec]\n");
 	pause(1);
 	Quaternion correction = Quaternion::fromBetweenVectors(Quaternion::rotateVector(Vector(0, 0, 1), attitude), Vector(0, 0, 1));
 	imuRotation = Quaternion::rotate(correction, Quaternion::fromEuler(imuRotation)).toEuler();
 	print("✓ Done: %.3f %.3f %.3f\n", degrees(imuRotation.x), degrees(imuRotation.y), degrees(imuRotation.z));
 }
 void printIMUCalibration() {
 	print("gyro bias: %f %f %f\n", gyroBias.x, gyroBias.y, gyroBias.z);
 	print("accel bias: %f %f %f\n", accBias.x, accBias.y, accBias.z);
@@ -139,18 +125,16 @@ void printIMUCalibration() {
 }
 void printIMUInfo() {
-	imu->status() ? print("status: ERROR %d\n", imu->status()) : print("status: OK\n");
+	imu.status() ? print("status: ERROR %d\n", imu.status()) : print("status: OK\n");
-	print("model: %s\n", imu->getModel());
+	print("model: %s\n", imu.getModel());
-	print("who am I: 0x%02X\n", imu->whoAmI());
+	print("who am I: 0x%02X\n", imu.whoAmI());
 	print("rate: %.0f\n", loopRate);
-	print("interrupt mode: %s\n", imuIntPin != -1 ? "pin" : "timer");
+	print("gyro: %f %f %f\n", rates.x, rates.y, rates.z);
 	print("temperature: %.1f °C\n", imu->getTemp());
 	print("gyro: %f %f %f\n", gyro.x, gyro.y, gyro.z);
 	print("acc: %f %f %f\n", acc.x, acc.y, acc.z);
-	imu->waitForData();
+	imu.waitForData();
 	Vector rawGyro, rawAcc;
-	imu->getGyro(rawGyro.x, rawGyro.y, rawGyro.z);
+	imu.getGyro(rawGyro.x, rawGyro.y, rawGyro.z);
-	imu->getAccel(rawAcc.x, rawAcc.y, rawAcc.z);
+	imu.getAccel(rawAcc.x, rawAcc.y, rawAcc.z);
 	print("raw gyro: %f %f %f\n", rawGyro.x, rawGyro.y, rawGyro.z);
 	print("raw acc: %f %f %f\n", rawAcc.x, rawAcc.y, rawAcc.z);
 }
@@ -14,10 +14,6 @@ public:
 	LowPassFilter(float alpha): alpha(alpha) {};
 	T update(const T input) {
 		if (!init) {
 			init = true;
 			return output = input;
 		}
 		return output += alpha * (input - output);
 	}
@@ -26,9 +22,6 @@ public:
 	}
 	void reset() {
-		init = false;
+		output = T(); // set to zero
 	}
 private:
 	bool init = false;
 };
@@ -7,18 +7,12 @@
 #include "util.h"
 extern float controlTime;
 extern float voltage;
-int mavlinkSysId = 1;
+bool mavlinkConnected = false;
 Rate telemetrySlow(2);
 Rate telemetryAttitude(20);
 Rate telemetryRC(10);
 Rate telemetryMotors(10);
 Rate telemetryIMU(15);
 float mavlinkTime = NAN; // time of last received message
 String mavlinkPrintBuffer;
 int mavlinkSysId = 1;
 Rate telemetryFast(10);
 Rate telemetrySlow(2);
 void processMavlink() {
 	sendMavlink();
@@ -38,48 +32,31 @@ void sendMavlink() {
 			((mode == AUTO) ? MAV_MODE_FLAG_AUTO_ENABLED : MAV_MODE_FLAG_MANUAL_INPUT_ENABLED),
 			mode, MAV_STATE_STANDBY);
 		sendMessage(&msg);
 	}
-	if (!valid(mavlinkTime)) return; // send only heartbeat until connected
+		if (!mavlinkConnected) return; // send only heartbeat until connected
 	if (telemetrySlow) {
 		mavlink_msg_extended_sys_state_pack(mavlinkSysId, MAV_COMP_ID_AUTOPILOT1, &msg,
 			MAV_VTOL_STATE_UNDEFINED, landed ? MAV_LANDED_STATE_ON_GROUND : MAV_LANDED_STATE_IN_AIR);
 		sendMessage(&msg);
 	}
-	if (telemetrySlow && valid(voltage)) {
+	if (telemetryFast && mavlinkConnected) {
-		uint16_t voltages[] = {(uint16_t)(voltage * 1000), UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX};
+		const float zeroQuat[] = {0, 0, 0, 0};
 		uint16_t voltagesExt[] = {0, 0, 0, 0};
 		float remaining = constrain(mapf(voltage, 3.4, 4.2, 0, 1), 0, 1);
 		mavlink_msg_battery_status_pack(mavlinkSysId, MAV_COMP_ID_AUTOPILOT1, &msg, 0, MAV_BATTERY_FUNCTION_ALL,
 			MAV_BATTERY_TYPE_LIPO, INT16_MAX, voltages, -1, -1, -1, remaining * 100, 0, MAV_BATTERY_CHARGE_STATE_OK, voltagesExt, 0, 0);
 		sendMessage(&msg);
 	}
 	if (telemetryAttitude) {
 		const float offset[] = {0, 0, 0, 0};
 		mavlink_msg_attitude_quaternion_pack(mavlinkSysId, MAV_COMP_ID_AUTOPILOT1, &msg,
-			time, attitude.w, attitude.x, -attitude.y, -attitude.z, rates.x, -rates.y, -rates.z, offset); // convert to frd
+			time, attitude.w, attitude.x, -attitude.y, -attitude.z, rates.x, -rates.y, -rates.z, zeroQuat); // convert to frd
 		sendMessage(&msg);
 	}
 	if (telemetryRC && channels[0]) { // 0 means no RC input
 		mavlink_msg_rc_channels_raw_pack(mavlinkSysId, MAV_COMP_ID_AUTOPILOT1, &msg, controlTime * 1000, 0,
 			channels[0], channels[1], channels[2], channels[3], channels[4], channels[5], channels[6], channels[7], UINT8_MAX);
-		sendMessage(&msg);
+		if (channels[0] != 0) sendMessage(&msg); // 0 means no RC input
 	}
 	if (telemetryMotors) {
 		float controls[8];
 		memcpy(controls, motors, sizeof(motors));
 		mavlink_msg_actuator_control_target_pack(mavlinkSysId, MAV_COMP_ID_AUTOPILOT1, &msg, time, 0, controls);
 		sendMessage(&msg);
 	}
 	if (telemetryIMU) {
 		mavlink_msg_scaled_imu_pack(mavlinkSysId, MAV_COMP_ID_AUTOPILOT1, &msg, time,
-			acc.x / ONE_G * 1000, -acc.y / ONE_G * 1000, -acc.z / ONE_G * 1000, // convert to frd
+			acc.x * 1000, -acc.y * 1000, -acc.z * 1000, // convert to frd
 			gyro.x * 1000, -gyro.y * 1000, -gyro.z * 1000,
 			0, 0, 0, 0);
 		sendMessage(&msg);
@@ -95,13 +72,13 @@ void sendMessage(const void *msg) {
 void receiveMavlink() {
 	uint8_t buf[MAVLINK_MAX_PACKET_LEN];
 	int len = receiveWiFi(buf, MAVLINK_MAX_PACKET_LEN);
 	if (len) mavlinkConnected = true;
 	// New packet, parse it
 	mavlink_message_t msg;
 	mavlink_status_t status;
 	for (int i = 0; i < len; i++) {
 		if (mavlink_parse_char(MAVLINK_COMM_0, buf[i], &msg, &status)) {
 			mavlinkTime = t;
 			handleMavlink(&msg);
 		}
 	}
@@ -255,7 +232,7 @@ void handleMavlink(const void *_msg) {
 		}
 		if (m.command == MAV_CMD_COMPONENT_ARM_DISARM) {
-			if (m.param1 == 1 && controlThrottle > 0.05) return; // don't arm if throttle is not low
+			if (m.param1 && controlThrottle > 0.05) return; // don't arm if throttle is not low
 			accepted = true;
 			armed = m.param1 == 1;
 		}
@@ -14,29 +14,29 @@ int pwmStop = 0;
 int pwmMin = 0;
 int pwmMax = -1; // -1 means duty cycle mode
-const int MOTOR_REAR_LEFT = 0, MOTOR_REAR_RIGHT = 1, MOTOR_FRONT_RIGHT = 2, MOTOR_FRONT_LEFT = 3;
+const int MOTOR_REAR_LEFT = 0;
 const int MOTOR_REAR_RIGHT = 1;
 const int MOTOR_FRONT_RIGHT = 2;
 const int MOTOR_FRONT_LEFT = 3;
 void setupMotors() {
-	print("Setup motors\n");
+	print("Setup Motors\n");
-	// Configure pins
+	// configure pins
 	for (int i = 0; i < 4; i++) {
 		if (motorPins[i] < 0) continue; // skip unassigned motors
 		ledcAttach(motorPins[i], pwmFrequency, pwmResolution);
 		pwmFrequency = ledcChangeFrequency(motorPins[i], pwmFrequency, pwmResolution); // when reconfiguring
 	}
 	sendMotors();
 	print("Motors initialized\n");
 }
 void sendMotors() {
 	for (int i = 0; i < 4; i++) {
 		if (motorPins[i] < 0) continue; // skip unassigned motors
 		ledcWrite(motorPins[i], getDutyCycle(motors[i]));
 	}
 }
 int getDutyCycle(float value) {
 	value = constrain(value, 0, 1);
 	if (pwmMax >= 0) { // pwm mode
 		float pwm = mapf(value, 0, 1, pwmMin, pwmMax);
 		if (value == 0) pwm = pwmStop;
@@ -51,9 +51,9 @@ bool motorsActive() {
 	return motors[0] != 0 || motors[1] != 0 || motors[2] != 0 || motors[3] != 0;
 }
-void testMotor(int n, float thrust) {
+void testMotor(int n) {
 	print("Testing motor %d\n", n);
-	motors[n] = thrust;
+	motors[n] = 1;
 	delay(50); // ESP32 may need to wait until the end of the current cycle to change duty https://github.com/espressif/arduino-esp32/issues/5306
 	sendMotors();
 	pause(3);
@@ -6,27 +6,21 @@
 #include <Preferences.h>
 #include "util.h"
-extern int channelZero[16], channelMax[16];
+extern float channelZero[16];
-extern int rollChannel, pitchChannel, throttleChannel, yawChannel, armedChannel, modeChannel;
+extern float channelMax[16];
-extern int rcRxPin, voltagePin;
+extern float rollChannel, pitchChannel, throttleChannel, yawChannel, armedChannel, modeChannel;
-extern int wifiMode, wifiLongRange, wifiBroadcast, udpLocalPort, udpRemotePort, espnowChannel;
+extern int wifiMode, udpLocalPort, udpRemotePort;
-extern float rcLossTimeout, descendTime, disarmTilt;
+extern float rcLossTimeout, descendTime;
 extern float voltageScale;
 extern LowPassFilter<float> voltageFilter;
 #include "config.h"
 Preferences storage;
 struct Parameter {
-	const char *name; // max length is 15
+	const char *name; // max length is 15 (Preferences key limit)
 	bool integer;
-	union { float *f; int *i; }; // pointer to the variable
+	union { float *f; int *i; }; // pointer to variable
 	float initial; // default value
 	float cache; // what's stored in flash
-	void (*callback)(); // called after parameter change
+	Parameter(const char *name, float *variable) : name(name), integer(false), f(variable) {};
-	Parameter(const char *name, float *variable, void (*callback)() = nullptr) : name(name), integer(false), f(variable), callback(callback) {};
+	Parameter(const char *name, int *variable) : name(name), integer(true), i(variable) {};
 	Parameter(const char *name, int *variable, void (*callback)() = nullptr) : name(name), integer(true), i(variable), callback(callback) {};
 	float getValue() const { return integer ? *i : *f; };
 	void setValue(const float value) { if (integer) *i = value; else *f = value; };
 };
@@ -37,17 +31,13 @@ Parameter parameters[] = {
 	{"CTL_R_RATE_I", &rollRatePID.i},
 	{"CTL_R_RATE_D", &rollRatePID.d},
 	{"CTL_R_RATE_WU", &rollRatePID.windup},
 	{"CTL_R_RATE_D_A", &rollRatePID.lpf.alpha},
 	{"CTL_P_RATE_P", &pitchRatePID.p},
 	{"CTL_P_RATE_I", &pitchRatePID.i},
 	{"CTL_P_RATE_D", &pitchRatePID.d},
 	{"CTL_P_RATE_WU", &pitchRatePID.windup},
 	{"CTL_P_RATE_D_A", &pitchRatePID.lpf.alpha},
 	{"CTL_Y_RATE_P", &yawRatePID.p},
 	{"CTL_Y_RATE_I", &yawRatePID.i},
 	{"CTL_Y_RATE_D", &yawRatePID.d},
 	{"CTL_Y_RATE_WU", &yawRatePID.windup},
 	{"CTL_Y_RATE_D_A", &yawRatePID.lpf.alpha},
 	{"CTL_R_P", &rollPID.p},
 	{"CTL_R_I", &rollPID.i},
 	{"CTL_R_D", &rollPID.d},
@@ -63,15 +53,6 @@ Parameter parameters[] = {
 	{"CTL_FLT_MODE_1", &flightModes[1]},
 	{"CTL_FLT_MODE_2", &flightModes[2]},
 	// imu
 	{"IMU_MODEL", &imuModel},
 	{"IMU_BUS", &imuBus},
 	{"IMU_PIN_SCK", &imuSckPin},
 	{"IMU_PIN_MISO", &imuMisoPin},
 	{"IMU_PIN_MOSI", &imuMosiPin},
 	{"IMU_PIN_CS", &imuCsPin},
 	{"IMU_PIN_SDA", &imuSdaPin},
 	{"IMU_PIN_SCL", &imuSclPin},
 	{"IMU_PIN_INT", &imuIntPin},
 	{"IMU_ROT_ROLL", &imuRotation.x},
 	{"IMU_ROT_PITCH", &imuRotation.y},
 	{"IMU_ROT_YAW", &imuRotation.z},
@@ -84,20 +65,18 @@ Parameter parameters[] = {
 	{"IMU_GYRO_BIAS_A", &gyroBiasFilter.alpha},
 	// estimate
 	{"EST_ACC_WEIGHT", &accWeight},
 	{"EST_LVL_WEIGHT", &levelWeight},
 	{"EST_RATES_LPF_A", &ratesFilter.alpha},
 	// motors
-	{"MOT_PIN_FL", &motorPins[MOTOR_FRONT_LEFT], setupMotors},
+	{"MOT_PIN_FL", &motorPins[MOTOR_FRONT_LEFT]},
-	{"MOT_PIN_FR", &motorPins[MOTOR_FRONT_RIGHT], setupMotors},
+	{"MOT_PIN_FR", &motorPins[MOTOR_FRONT_RIGHT]},
-	{"MOT_PIN_RL", &motorPins[MOTOR_REAR_LEFT], setupMotors},
+	{"MOT_PIN_RL", &motorPins[MOTOR_REAR_LEFT]},
-	{"MOT_PIN_RR", &motorPins[MOTOR_REAR_RIGHT], setupMotors},
+	{"MOT_PIN_RR", &motorPins[MOTOR_REAR_RIGHT]},
-	{"MOT_PWM_FREQ", &pwmFrequency, setupMotors},
+	{"MOT_PWM_FREQ", &pwmFrequency},
-	{"MOT_PWM_RES", &pwmResolution, setupMotors},
+	{"MOT_PWM_RES", &pwmResolution},
 	{"MOT_PWM_STOP", &pwmStop},
 	{"MOT_PWM_MIN", &pwmMin},
 	{"MOT_PWM_MAX", &pwmMax},
 	// rc
 	{"RC_RX_PIN", &rcRxPin, setupRC},
 	{"RC_ZERO_0", &channelZero[0]},
 	{"RC_ZERO_1", &channelZero[1]},
 	{"RC_ZERO_2", &channelZero[2]},
@@ -121,39 +100,25 @@ Parameter parameters[] = {
 	{"RC_MODE", &modeChannel},
 	// wifi
 	{"WIFI_MODE", &wifiMode},
-	{"WIFI_PORT_LOC", &udpLocalPort},
+	{"WIFI_LOC_PORT", &udpLocalPort},
-	{"WIFI_PORT_REM", &udpRemotePort},
+	{"WIFI_REM_PORT", &udpRemotePort},
 	{"WIFI_LONG_RANGE", &wifiLongRange},
 	{"WIFI_BROADCAST", &wifiBroadcast},
 	// espnow
 	{"ESPNOW_CHANNEL", &espnowChannel},
 	// mavlink
 	{"MAV_SYS_ID", &mavlinkSysId},
 	{"MAV_RATE_SLOW", &telemetrySlow.rate},
-	{"MAV_RATE_ATT", &telemetryAttitude.rate},
+	{"MAV_RATE_FAST", &telemetryFast.rate},
 	{"MAV_RATE_RC", &telemetryRC.rate},
 	{"MAV_RATE_MOT", &telemetryMotors.rate},
 	{"MAV_RATE_IMU", &telemetryIMU.rate},
 	// power
 	{"PWR_VOLT_PIN", &voltagePin, setupPower},
 	{"PWR_VOLT_SCALE", &voltageScale},
 	{"PWR_VOLT_LPF_A", &voltageFilter.alpha},
 	// safety
 	{"SF_RC_LOSS_TIME", &rcLossTimeout},
 	{"SF_DESCEND_TIME", &descendTime},
 	{"SF_DISARM_TILT", &disarmTilt},
 };
 void setupParameters() {
-	print("Setup parameters\n");
+	storage.begin("flix", false);
 	setDefaults();
 	storage.begin("flix");
 	// Read parameters from storage
 	for (auto &parameter : parameters) {
-		parameter.initial = parameter.getValue();
+		if (!storage.isKey(parameter.name)) {
-		if (storage.isKey(parameter.name)) {
+			storage.putFloat(parameter.name, parameter.getValue()); // store default value
 			parameter.setValue(storage.getFloat(parameter.name));
 		}
 		parameter.setValue(storage.getFloat(parameter.name, 0));
 		parameter.cache = parameter.getValue();
 	}
 }
@@ -186,7 +151,6 @@ bool setParameter(const char *name, const float value) {
 		if (strcasecmp(parameter.name, name) == 0) {
 			if (parameter.integer && !isfinite(value)) return false; // can't set integer to NaN or Inf
 			parameter.setValue(value);
 			if (parameter.callback) parameter.callback();
 			return true;
 		}
 	}
@@ -199,23 +163,18 @@ void syncParameters() {
 	if (motorsActive()) return; // don't use flash while flying, it may cause a delay
 	for (auto &parameter : parameters) {
-		if (floatEquals(parameter.getValue(), parameter.cache)) continue; // no change
+		if (parameter.getValue() == parameter.cache) continue; // no change
 		if (isnan(parameter.getValue()) && isnan(parameter.cache)) continue; // both are NaN
 		if (isinf(parameter.getValue()) && isinf(parameter.cache)) continue; // both are Inf
 		storage.putFloat(parameter.name, parameter.getValue());
 		parameter.cache = parameter.getValue(); // update cache
 	}
 }
-void printParameters(const char *filter) {
+void printParameters() {
 	print("Name             Value          [Default]\n");
 	for (auto &parameter : parameters) {
-		if (strncasecmp(parameter.name, filter, strlen(filter))) continue;
+		print("%s = %g\n", parameter.name, parameter.getValue());
 		if (floatEquals(parameter.getValue(), parameter.initial)) { // parameter changed
 			print("%-15s  %-13g\n", parameter.name, parameter.getValue());
 		} else {
 			print("%-15s  %-13g  [%g]\n", parameter.name, parameter.getValue(), parameter.initial);
 		}
 	}
 }
@@ -5,7 +5,7 @@
 #pragma once
-#include "filter.h"
+#include "lpf.h"
 class PID {
 public:
@@ -18,7 +18,7 @@ public:
 	LowPassFilter<float> lpf; // low pass filter for derivative term
-	PID(float p, float i = 0, float d = 0, float windup = INFINITY, float dAlpha = 1, float dtMax = 0.1) :
+	PID(float p, float i, float d, float windup = 0, float dAlpha = 1, float dtMax = 0.1) :
 		p(p), i(i), d(d), windup(windup), lpf(dAlpha), dtMax(dtMax) {}
 	float update(float error) {
@@ -1,29 +0,0 @@
 // Copyright (c) 2026 Oleg Kalachev <okalachev@gmail.com>
 // Repository: https://github.com/okalachev/flix
 // Power management
 #include <soc/soc.h>
 #include <soc/rtc_cntl_reg.h>
 #include "filter.h"
 #include "util.h"
 float voltage = NAN;
 LowPassFilter<float> voltageFilter(1);
 int voltagePin = -1;
 float voltageScale = 2;
 void setupPower() {
 	REG_CLR_BIT(RTC_CNTL_BROWN_OUT_REG, RTC_CNTL_BROWN_OUT_ENA); // disable reset on low voltage
 	if (digitalPinToAnalogChannel(voltagePin) == -1) voltagePin = -1; // test ADC pin
 }
 void readVoltage() {
 	if (voltagePin < 0) return;
 	static Rate rate(10);
 	if (!rate) return;
 	float v = analogReadMilliVolts(voltagePin) * voltageScale / 1000.0f;
 	voltage = voltageFilter.update(v);
 }
@@ -6,33 +6,33 @@
 #include <SBUS.h>
 #include "util.h"
-SBUS rc(Serial1);
+SBUS rc(Serial2);
 int rcRxPin = -1; // -1 means disabled
 uint16_t channels[16]; // raw rc channels
-int channelZero[16]; // calibration zero values
+float channelZero[16]; // calibration zero values
-int channelMax[16]; // calibration max values
+float channelMax[16]; // calibration max values
 float controlRoll, controlPitch, controlYaw, controlThrottle; // pilot's inputs, range [-1, 1]
 float controlMode = NAN;
 float controlTime = NAN; // time of the last controls update
-int rollChannel = -1, pitchChannel = -1, throttleChannel = -1, yawChannel = -1, modeChannel = -1; // channel mapping
+// Channels mapping (nan means not assigned):
 float rollChannel = NAN, pitchChannel = NAN, throttleChannel = NAN, yawChannel = NAN, modeChannel = NAN;
 void setupRC() {
 	if (rcRxPin < 0) return;
 	print("Setup RC\n");
-	rc.begin(rcRxPin);
+	rc.begin();
 }
 bool readRC() {
-	if (rcRxPin < 0) return false;
+	if (rc.read()) {
-	if (!rc.read()) return false;
+		SBUSData data = rc.data();
-
+		for (int i = 0; i < 16; i++) channels[i] = data.ch[i]; // copy channels data
-	rc.getChannels(channels);
+		normalizeRC();
-	normalizeRC();
+		controlTime = t;
-	controlTime = t;
+		return true;
-	return true;
+	}
 	return false;
 }
 void normalizeRC() {
@@ -41,35 +41,30 @@ void normalizeRC() {
 		controls[i] = mapf(channels[i], channelZero[i], channelMax[i], 0, 1);
 	}
 	// Update control values
-	controlRoll = rollChannel < 0 ? 0 : controls[rollChannel];
+	controlRoll = rollChannel >= 0 ? controls[(int)rollChannel] : 0;
-	controlPitch = pitchChannel < 0 ? 0 : controls[pitchChannel];
+	controlPitch = pitchChannel >= 0 ? controls[(int)pitchChannel] : 0;
-	controlYaw = yawChannel < 0 ? 0 : controls[yawChannel];
+	controlYaw = yawChannel >= 0 ? controls[(int)yawChannel] : 0;
-	controlThrottle = throttleChannel < 0 ? 0 : controls[throttleChannel];
+	controlThrottle = throttleChannel >= 0 ? controls[(int)throttleChannel] : 0;
-	controlMode = modeChannel < 0 ? NAN : controls[modeChannel]; // mode control is ineffective if not mapped
+	controlMode = modeChannel >= 0 ? controls[(int)modeChannel] : NAN; // mode switch should not have affect if not set
 }
 void calibrateRC() {
-	if (rcRxPin < 0) {
+	uint16_t zero[16];
-		print("RC_RX_PIN = %d, set the RC pin!\n", rcRxPin);
+	uint16_t center[16];
-		return;
+	uint16_t max[16];
 	}
 	uint16_t zero[16]; // for zero positions
 	uint16_t center[16]; // for center positions
 	uint16_t _[16]; // for unused data
 	print("1/8 Calibrating RC: put all switches to default positions [3 sec]\n");
 	pause(3);
-	calibrateRCChannel(NULL, _, zero, "2/8 Move sticks [3 sec]\n...     ...\n...     .o.\n.o.     ...\n");
+	calibrateRCChannel(NULL, zero, zero, "2/8 Move sticks [3 sec]\n...     ...\n...     .o.\n.o.     ...\n");
-	calibrateRCChannel(&throttleChannel, zero, _, "3/8 Move sticks [3 sec]\n.o.     ...\n...     .o.\n...     ...\n");
+	calibrateRCChannel(NULL, center, center, "3/8 Move sticks [3 sec]\n...     ...\n.o.     .o.\n...     ...\n");
-	calibrateRCChannel(NULL, _, center, "4/8 Move sticks [3 sec]\n...     ...\n.o.     .o.\n...     ...\n");
+	calibrateRCChannel(&throttleChannel, zero, max, "4/8 Move sticks [3 sec]\n.o.     ...\n...     .o.\n...     ...\n");
-	calibrateRCChannel(&yawChannel, center, _, "5/8 Move sticks [3 sec]\n...     ...\n..o     .o.\n...     ...\n");
+	calibrateRCChannel(&yawChannel, center, max, "5/8 Move sticks [3 sec]\n...     ...\n..o     .o.\n...     ...\n");
-	calibrateRCChannel(&pitchChannel, zero, _, "6/8 Move sticks [3 sec]\n...     .o.\n...     ...\n.o.     ...\n");
+	calibrateRCChannel(&pitchChannel, zero, max, "6/8 Move sticks [3 sec]\n...     .o.\n...     ...\n.o.     ...\n");
-	calibrateRCChannel(&rollChannel, zero, _, "7/8 Move sticks [3 sec]\n...     ...\n...     ..o\n.o.     ...\n");
+	calibrateRCChannel(&rollChannel, zero, max, "7/8 Move sticks [3 sec]\n...     ...\n...     ..o\n.o.     ...\n");
-	calibrateRCChannel(&modeChannel, zero, _, "8/8 Put mode switch to max [3 sec]\n");
+	calibrateRCChannel(&modeChannel, zero, max, "8/8 Put mode switch to max [3 sec]\n");
 	printRCCalibration();
 }
-void calibrateRCChannel(int *channel, uint16_t in[16], uint16_t out[16], const char *str) {
+void calibrateRCChannel(float *channel, uint16_t in[16], uint16_t out[16], const char *str) {
 	print("%s", str);
 	pause(3);
 	for (int i = 0; i < 30; i++) readRC(); // try update 30 times max
@@ -90,15 +85,15 @@ void calibrateRCChannel(int *channel, uint16_t in[16], uint16_t out[16], const c
 		channelZero[ch] = in[ch];
 		channelMax[ch] = out[ch];
 	} else {
-		*channel = -1;
+		*channel = NAN;
 	}
 }
 void printRCCalibration() {
 	print("Control   Ch     Zero   Max\n");
-	print("Roll      %-7d%-7d%-7d\n", rollChannel, rollChannel < 0 ? 0 : channelZero[rollChannel], rollChannel < 0 ? 0 : channelMax[rollChannel]);
+	print("Roll      %-7g%-7g%-7g\n", rollChannel, rollChannel >= 0 ? channelZero[(int)rollChannel] : NAN, rollChannel >= 0 ? channelMax[(int)rollChannel] : NAN);
-	print("Pitch     %-7d%-7d%-7d\n", pitchChannel, pitchChannel < 0 ? 0 : channelZero[pitchChannel], pitchChannel < 0 ? 0 : channelMax[pitchChannel]);
+	print("Pitch     %-7g%-7g%-7g\n", pitchChannel, pitchChannel >= 0 ? channelZero[(int)pitchChannel] : NAN, pitchChannel >= 0 ? channelMax[(int)pitchChannel] : NAN);
-	print("Yaw       %-7d%-7d%-7d\n", yawChannel, yawChannel < 0 ? 0 : channelZero[yawChannel], yawChannel < 0 ? 0 : channelMax[yawChannel]);
+	print("Yaw       %-7g%-7g%-7g\n", yawChannel, yawChannel >= 0 ? channelZero[(int)yawChannel] : NAN, yawChannel >= 0 ? channelMax[(int)yawChannel] : NAN);
-	print("Throttle  %-7d%-7d%-7d\n", throttleChannel, throttleChannel < 0 ? 0 : channelZero[throttleChannel], throttleChannel < 0 ? 0 : channelMax[throttleChannel]);
+	print("Throttle  %-7g%-7g%-7g\n", throttleChannel, throttleChannel >= 0 ? channelZero[(int)throttleChannel] : NAN, throttleChannel >= 0 ? channelMax[(int)throttleChannel] : NAN);
-	print("Mode      %-7d%-7d%-7d\n", modeChannel, modeChannel < 0 ? 0 : channelZero[modeChannel], modeChannel < 0 ? 0 : channelMax[modeChannel]);
+	print("Mode      %-7g%-7g%-7g\n", modeChannel, modeChannel >= 0 ? channelZero[(int)modeChannel] : NAN, modeChannel >= 0 ? channelMax[(int)modeChannel] : NAN);
 }
@@ -8,12 +8,10 @@ extern float controlRoll, controlPitch, controlThrottle, controlYaw;
 float rcLossTimeout = 1;
 float descendTime = 10;
 float disarmTilt = radians(120);
 void failsafe() {
 	rcLossFailsafe();
 	autoFailsafe();
 	tiltFailsafe();
 }
 // RC loss failsafe
@@ -38,24 +36,12 @@ void descend() {
 // Allow pilot to interrupt automatic flight
 void autoFailsafe() {
 	static float roll, pitch, yaw, throttle;
-	if (abs(roll - controlRoll) > 0.05 || abs(pitch - controlPitch) > 0.05 || abs(yaw - controlYaw) > 0.05 || abs(throttle - controlThrottle) > 0.05) {
+	if (roll != controlRoll || pitch != controlPitch || yaw != controlYaw || abs(throttle - controlThrottle) > 0.05) {
-		// controls changed and mode switch is not configured
+		// controls changed
-		if (mode == AUTO && invalid(controlMode)) mode = STAB; // regain control by the pilot
+		if (mode == AUTO) mode = STAB; // regain control by the pilot
 	}
 	roll = controlRoll;
 	pitch = controlPitch;
 	yaw = controlYaw;
 	throttle = controlThrottle;
 }
 // Disarm if tilted too much
 void tiltFailsafe() {
 	if (!armed) return;
 	if (mode != STAB) return;
 	Vector up = Quaternion::rotateVector(Vector(0, 0, 1), attitude);
 	float tilt = acos(up.z);
 	if (disarmTilt && tilt > disarmTilt) {
 		armed = false;
 	}
 }
@@ -6,7 +6,8 @@
 #pragma once
 #include <math.h>
-#include <ESP32_NOW_Serial.h>
+#include <soc/soc.h>
 #include <soc/rtc_cntl_reg.h>
 const float ONE_G = 9.80665;
 extern float t;
@@ -23,12 +24,6 @@ bool valid(float x) {
 	return isfinite(x);
 }
 bool floatEquals(float a, float b, float epsilon = 0) {
 	if (isnan(a) && isnan(b)) return true;
 	if (a == b) return true;
 	return fabsf(a - b) <= epsilon;
 }
 // Wrap angle to [-PI, PI)
 float wrapAngle(float angle) {
 	angle = fmodf(angle, 2 * PI);
@@ -40,41 +35,29 @@ float wrapAngle(float angle) {
 	return angle;
 }
 // Disable reset on low voltage
 void disableBrownOut() {
 	REG_CLR_BIT(RTC_CNTL_BROWN_OUT_REG, RTC_CNTL_BROWN_OUT_ENA);
 }
 // Trim and split string by spaces
 void splitString(String& str, String& token0, String& token1, String& token2) {
 	str.trim();
 	if (str.isEmpty()) return;
 	char chars[str.length() + 1];
 	str.toCharArray(chars, str.length() + 1);
 	token0 = strtok(chars, " ");
-	token1 = strtok(NULL, " ");
+	token1 = strtok(NULL, " "); // String(NULL) creates empty string
 	token2 = strtok(NULL, "");
 	if (token1.c_str() == NULL) token1 = "";
 	if (token2.c_str() == NULL) token2 = "";
 }
 // Simplified ESP-NOW Serial without resends
 class ESPNOWSerial : public ESP_NOW_Serial_Class {
 public:
 	int lost = 0;
 	using ESP_NOW_Serial_Class::ESP_NOW_Serial_Class;
 	void onSent(bool success) override {
 		if (!success) lost++;
 		ESP_NOW_Serial_Class::onSent(true); // always report success to avoid resends
 	}
 };
 // Rate limiter
 class Rate {
 public:
 	float rate;
-	float last = -INFINITY;
+	float last = 0;
 	Rate(float rate) : rate(rate) {}
 	operator bool() {
 		if (t == last) {
 			return true; // the same step
 		}
 		if (t - last >= 1 / rate) {
 			last = t;
 			return true;
@@ -105,23 +105,10 @@ public:
 	}
 	static Vector rotationVectorBetween(const Vector& a, const Vector& b) {
 		float an = a.norm();
 		float bn = b.norm();
 		if (an < 1e-6 || bn < 1e-6) {
 			return Vector(0, 0, 0);
 		}
 		Vector direction = cross(a, b);
-		if (direction.norm() < 1e-6) { // vectors are parallel
+		if (direction.zero()) {
-			if (dot(a, b) > 0) { // same direction
+			// vectors are opposite, return any perpendicular vector
-				return Vector(0, 0, 0);
+			return cross(a, Vector(1, 0, 0));
 			}
 			// opposite direction
 			Vector perp = cross(a, Vector(1, 0, 0));
 			if (perp.norm() < 1e-6) {
 				perp = cross(a, Vector(0, 1, 0));
 			}
 			perp.normalize();
 			return perp * PI;
 		}
 		direction.normalize();
 		float angle = angleBetween(a, b);
@@ -1,154 +1,76 @@
 // Copyright (c) 2023 Oleg Kalachev <okalachev@gmail.com>
 // Repository: https://github.com/okalachev/flix
-// Wi-Fi and ESP-NOW communication
+// Wi-Fi communication
 #include <WiFi.h>
 #include <WiFiAP.h>
 #include <WiFiUdp.h>
-#include <MacAddress.h>
+#include "Preferences.h"
 #include <ESP32_NOW_Serial.h>
 #include <Preferences.h>
 #include "util.h"
 extern Preferences storage; // use the main preferences storage
-const int W_DISABLED = 0, W_AP = 1, W_STA = 2, W_ESPNOW = 3;
+const int W_DISABLED = 0, W_AP = 1, W_STA = 2;
 int wifiMode = W_AP;
 int wifiLongRange = 0;
 int wifiBroadcast = 0; // 0 - broadcast until connected, 1 - always broadcast
 int udpLocalPort = 14550;
 int udpRemotePort = 14550;
 IPAddress udpRemoteIP = "255.255.255.255";
 WiFiUDP udp;
-ESPNOWSerial espnow(NULL, 0, WIFI_IF_AP);
+WiFiUDP udp;
 ESPNOWSerial espnowBroadcast(ESP_NOW.BROADCAST_ADDR, 0, WIFI_IF_AP);
 int espnowChannel = 6;
 void setupWiFi() {
 	print("Setup Wi-Fi\n");
 	WiFi.enableLongRange(wifiLongRange);
 	if (wifiMode == W_AP) {
 		WiFi.softAP(storage.getString("WIFI_AP_SSID", "flix").c_str(), storage.getString("WIFI_AP_PASS", "flixwifi").c_str());
-		udp.begin(udpLocalPort);
+	} else if (wifiMode == W_STA) {
 	}
 	if (wifiMode == W_STA) {
 		WiFi.begin(storage.getString("WIFI_STA_SSID", "").c_str(), storage.getString("WIFI_STA_PASS", "").c_str());
 		udp.begin(udpLocalPort);
 	}
-
+	udp.begin(udpLocalPort);
 	if (wifiMode == W_ESPNOW) {
 		WiFi.mode(WIFI_AP);
 		WiFi.setChannel(espnowChannel);
 		espnow.addr(MacAddress(storage.getString("ESPNOW_PEER_MAC", "FF:FF:FF:FF:FF:FF").c_str()));
 		String key = storage.getString("ESPNOW_PEER_KEY", "");
 		espnow.setKey(key.isEmpty() ? nullptr : (const uint8_t *)key.c_str());
 		espnow.begin();
 		espnowBroadcast.begin();
 	}
 	WiFi.setSleep(false); // disable power save
 }
 void sendWiFi(const uint8_t *buf, int len) {
 	if (espnow) {
 		espnow.write(buf, len);
 		static Rate discovery(2);
 		if (espnow.isEncrypted() && discovery) espnowBroadcast.write((const uint8_t *)"flix", 4); // broadcast message to help finding this device
 		return;
 	}
 	if (WiFi.softAPgetStationNum() == 0 && !WiFi.isConnected()) return;
-
+	udp.beginPacket(udpRemoteIP, udpRemotePort);
 	bool broadcast = wifiBroadcast || !(t - mavlinkTime < 5); // broadcast if lost connection
 	udp.beginPacket(broadcast ? IPAddress(255, 255, 255, 255) : udpRemoteIP, udpRemotePort);
 	udp.write(buf, len);
 	udp.endPacket();
 }
 int receiveWiFi(uint8_t *buf, int len) {
 	if (espnow) {
 		return espnow.read(buf, len);
 	}
 	if (WiFi.softAPgetStationNum() == 0 && !WiFi.isConnected()) return 0;
 	udp.parsePacket();
 	if (udp.remoteIP()) udpRemoteIP = udp.remoteIP();
 	return udp.read(buf, len);
 }
 void printWiFiInfo() {
-	if (espnow) {
+	if (WiFi.getMode() == WIFI_MODE_AP) {
 		print("Mode: ESP-NOW\n");
 		print("ESP-NOW version: %d\n", ESP_NOW.getVersion());
 		print("Max packet size: %d\n", ESP_NOW.getMaxDataLen());
 		print("MAC: %s\n", WiFi.softAPmacAddress().c_str());
 		print("Peer MAC: %s\n", MacAddress(espnow.addr()).toString().c_str());
 		print("Encrypted: %d\n", espnow.isEncrypted());
 		print("Channel: %d\n", espnow.getChannel());
 		print("Lost packets: %d\n", espnow.lost);
 	} else if (WiFi.getMode() == WIFI_MODE_AP) {
 		print("Mode: Access Point (AP)\n");
 		print("MAC: %s\n", WiFi.softAPmacAddress().c_str());
 		print("SSID: %s\n", WiFi.softAPSSID().c_str());
 		print("Password: ***\n");
 		print("Channel: %d\n", WiFi.channel());
 		print("Clients: %d\n", WiFi.softAPgetStationNum());
 		print("IP: %s\n", WiFi.softAPIP().toString().c_str());
 		print("Remote IP: %s\n", udpRemoteIP.toString().c_str());
 	} else if (WiFi.getMode() == WIFI_MODE_STA) {
 		print("Mode: Client (STA)\n");
 		print("Connected: %d\n", WiFi.isConnected());
 		print("MAC: %s\n", WiFi.macAddress().c_str());
 		print("SSID: %s\n", WiFi.SSID().c_str());
 		print("Password: ***\n");
 		print("Channel: %d\n", WiFi.channel());
 		print("RSSI: %d dBm\n", WiFi.RSSI());
 		print("IP: %s\n", WiFi.localIP().toString().c_str());
 		print("Remote IP: %s\n", udpRemoteIP.toString().c_str());
 	} else {
 		print("Mode: Disabled\n");
 		return;
 	}
-	print("MAVLink connected: %d\n", valid(mavlinkTime));
+	print("Remote IP: %s\n", udpRemoteIP.toString().c_str());
 	print("MAVLink connected: %d\n", mavlinkConnected);
 }
-void configWiFi(int mode, const char *first, const char *second) {
+void configWiFi(bool ap, const char *ssid, const char *password) {
-	MacAddress mac;
+	if (ap) {
-	if (mode == W_AP && strlen(first) > 0 && strlen(second) >= 8) {
+		storage.putString("WIFI_AP_SSID", ssid);
-		storage.putString("WIFI_AP_SSID", first);
+		storage.putString("WIFI_AP_PASS", password);
 		storage.putString("WIFI_AP_PASS", second);
 	} else if (mode == W_STA && strlen(first) > 0 && strlen(second) >= 8) {
 		storage.putString("WIFI_STA_SSID", first);
 		storage.putString("WIFI_STA_PASS", second);
 	} else if (mode == W_ESPNOW && mac.fromString(first)) {
 		storage.putString("ESPNOW_PEER_MAC", first);
 		storage.putString("ESPNOW_PEER_KEY", strlen(second) == ESP_NOW_KEY_LEN ? second : "");
 	} else {
-		print("Invalid configuration\n");
+		storage.putString("WIFI_STA_SSID", ssid);
-		return;
+		storage.putString("WIFI_STA_PASS", password);
 	}
 	print("✓ Reboot to apply new settings\n");
 }
 void setWiFiMode(const String& mode) {
 	if (mode == "ap") {
 		wifiMode = W_AP;
 	} else if (mode == "sta") {
 		wifiMode = W_STA;
 	} else if (mode == "espnow") {
 		wifiMode = W_ESPNOW;
 	} else if (mode == "off") {
 		wifiMode = W_DISABLED;
 	} else {
 		print("Invalid Wi-Fi mode\n");
 		return;
 	}
 	static const char *modes[] = {"Disabled", "Access Point (AP)", "Client (STA)", "ESP-NOW"};
 	print("✓ Wi-Fi mode set to %s, reboot to apply\n", modes[wifiMode]);
 }
@@ -21,8 +21,6 @@
 #define degrees(rad) ((rad)*RAD_TO_DEG)
 #define constrain(amt,low,high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt)))
 template<typename T> T max(T a, T b) { return a > b ? a : b; }
 template<typename T> T min(T a, T b) { return a < b ? a : b; }
 long map(long x, long in_min, long in_max, long out_min, long out_max) {
 	const long run = in_max - in_min;
@@ -151,7 +149,7 @@ public:
 	void setRxInvert(bool invert) {};
 };
-HardwareSerial Serial, Serial1, Serial2;
+HardwareSerial Serial, Serial2;
 class EspClass {
 public:
@@ -167,9 +165,6 @@ void delay(uint32_t ms) {
 bool ledcAttach(uint8_t pin, uint32_t freq, uint8_t resolution) { return true; }
 bool ledcWrite(uint8_t pin, uint32_t duty) { return true; }
 uint32_t ledcChangeFrequency(uint8_t pin, uint32_t freq, uint8_t resolution) { return freq; }
 int8_t digitalPinToAnalogChannel(uint8_t pin) { return -1; }
 uint32_t analogReadMilliVolts(uint8_t pin) { return 0; }
 unsigned long __micros;
 unsigned long __resetTime = 0;
@@ -1,12 +0,0 @@
 // Dummy file for the simulator
 class ESP_NOW_Peer {
 protected:
 	size_t send(const uint8_t *data, int len) { return 0; }
 };
 class ESP_NOW_Serial_Class : public ESP_NOW_Peer {
 public:
 	virtual void onSent(bool success) {};
 	virtual size_t write(const uint8_t *data, size_t len) { return 0; };
 };
@@ -13,13 +13,14 @@ class SBUS {
 public:
 	SBUS(HardwareSerial& bus, const bool inv = true) {};
 	SBUS(HardwareSerial& bus, const int8_t rxpin, const int8_t txpin, const bool inv = true) {};
-	void begin(int rxpin = -1, int txpin = -1, bool inv = true, bool fast = false) {};
+	void begin() {};
 	bool read() { return joystickInit(); };
-	void getChannels(uint16_t (&channels)[16]) const {
+	SBUSData data() {
-		int16_t ch[16];
+		SBUSData data;
-		joystickGet(ch);
+		joystickGet(data.ch);
 		for (int i = 0; i < 16; i++) {
-			channels[i] = map(ch[i], -32768, 32767, 1000, 2000); // convert to pulse width style
+			data.ch[i] = map(data.ch[i], -32768, 32767, 1000, 2000); // convert to pulse width style
 		}
 		return data;
 	};
 };
@@ -9,7 +9,7 @@
 #include "quaternion.h"
 #include "Arduino.h"
 #include "wifi.h"
-#include "filter.h"
+#include "lpf.h"
 extern float t, dt;
 extern float controlRoll, controlPitch, controlYaw, controlThrottle, controlMode;
@@ -21,35 +21,29 @@ extern float motors[4];
 Vector gyro, acc, imuRotation;
 Vector accBias, gyroBias, accScale(1, 1, 1);
 LowPassFilter<Vector> gyroBiasFilter(0);
 int imuModel = 1, imuBus = 0;
 int imuSckPin = 0, imuMisoPin = 0, imuMosiPin = 0, imuCsPin = -1, imuIntPin = -1;
 int imuSdaPin = 0, imuSclPin = 0;
 // declarations
 void step();
 void computeLoopRate();
 void applyGyro();
 void applyAcc();
 void applyLevel();
 void control();
 void interpretControls();
 void controlAttitude();
 void controlRates();
 void controlTorque();
 void desaturate(float& a, float& b, float& c, float& d);
 const char* getModeName();
 void sendMotors();
 int getDutyCycle(float value);
 bool motorsActive();
-void testMotor(int, float);
+void testMotor(int n);
 void print(const char* format, ...);
 void pause(float duration);
 void doCommand(String str, bool echo);
 void handleInput();
 void setupRC();
 void normalizeRC();
 void calibrateRC();
-void calibrateRCChannel(int*, uint16_t[16], uint16_t[16], const char*);
+void calibrateRCChannel(float *channel, uint16_t zero[16], uint16_t max[16], const char *str);
 void printRCCalibration();
 void printLogHeader();
 void printLogData();
@@ -61,25 +55,24 @@ void handleMavlink(const void *_msg);
 void mavlinkPrint(const char* str);
 void sendMavlinkPrint();
 inline Quaternion fluToFrd(const Quaternion &q);
 void setupPower();
 void failsafe();
 void rcLossFailsafe();
 void descend();
 void autoFailsafe();
 void tiltFailsafe();
 int parametersCount();
 const char *getParameterName(int index);
 float getParameter(int index);
 float getParameter(const char *name);
 bool setParameter(const char *name, const float value);
-void printParameters(const char *filter);
+void printParameters();
 void resetParameters();
 // mocks
 void setLED(bool on) {};
 void calibrateGyro() { print("Skip gyro calibrating\n"); };
 void calibrateAccel() { print("Skip accel calibrating\n"); };
 void calibrateLevel() { print("Skip level calibrating\n"); };
 void printIMUCalibration() { print("cal: N/A\n"); };
 void printIMUInfo() {};
 void printWiFiInfo() {};
 void configWiFi(bool, const char*, const char*) { print("Skip WiFi config\n"); };
 void setWiFiMode(const String& mode) { print("Skip WiFi mode set\n"); };
@@ -23,11 +23,10 @@
 #include "estimate.ino"
 #include "safety.ino"
 #include "log.ino"
-#include "filter.h"
+#include "lpf.h"
 #include "mavlink.ino"
 #include "motors.ino"
 #include "parameters.ino"
 #include "power.ino"
 #include "rc.ino"
 #include "time.ino"
@@ -55,7 +54,6 @@ public:
 		initNode();
 		Serial.begin(0);
 		setupParameters();
 		rcRxPin = 1; // set rc pin to enable rc reading
 		gzmsg << "Flix plugin loaded" << endl;
 	}
@@ -74,8 +72,6 @@ public:
 		gyro = Vector(imu->AngularVelocity().X(), imu->AngularVelocity().Y(), imu->AngularVelocity().Z());
 		acc = this->accFilter.update(Vector(imu->LinearAcceleration().X(), imu->LinearAcceleration().Y(), imu->LinearAcceleration().Z()));
 		voltage = 4.2f; // dummy voltage value
 		readRC();
 		estimate();
@@ -1,3 +1,4 @@
 // Dummy file to make it possible to compile simulator with Flix' util.h
 #define WRITE_PERI_REG(addr, val) {}
 #define REG_CLR_BIT(_r, _b) {}
@@ -11,13 +11,7 @@
 #include <sys/poll.h>
 #include <gazebo/gazebo.hh>
-// Mocks
+int wifiMode = 1; // mock
 int wifiMode = 1;
 int wifiLongRange = 0;
 int wifiBroadcast = 0;
 int espnowChannel = 6;
 const int W_DISABLED = 0, W_AP = 1, W_STA = 2, W_ESPNOW = 3;
 int udpLocalPort = 14580;
 int udpRemotePort = 14550;
 const char *udpRemoteIP = "255.255.255.255";
@@ -1,3 +0,0 @@
 # ESPNOW-proxy
 Proxy sketch for using ESP-NOW connection with Flix drone.
@@ -1,88 +0,0 @@
 // Copyright (c) 2026 Oleg Kalachev <okalachev@gmail.com>
 // Repository: https://github.com/okalachev/flix
 // Proxy for ESP-NOW connection
 #include <vector>
 #include <WiFi.h>
 #include <ESP32_NOW_Serial.h>
 #include <MacAddress.h>
 #include <MAVLink.h>
 #include <Preferences.h>
 #include "../../flix/util.h"
 const int CHANNEL = 6;
 char key[ESP_NOW_KEY_LEN + 1] = {0}; // with trailing null
 Preferences storage;
 std::vector<ESPNOWSerial *> peers;
 void onNewPeer(const esp_now_recv_info_t *info, const uint8_t *data, int len, void *arg) {
 	if (len != 4 || memcmp(data, "flix", 4) != 0) return; // check if discovery message
 	Serial.printf("New peer: " MACSTR "\n", MAC2STR(info->src_addr));
 	ESPNOWSerial *link = new ESPNOWSerial(info->src_addr, CHANNEL, WIFI_IF_AP);
 	link->begin();
 	link->setKey((const uint8_t *)key);
 	peers.push_back(link);
 }
 void setup() {
 	Serial.begin(115200);
 	WiFi.mode(WIFI_AP);
 	WiFi.setSleep(false);
 	WiFi.setChannel(CHANNEL);
 	ESP_NOW.onNewPeer(onNewPeer, NULL);
 	ESP_NOW.begin();
 	storage.begin("espnow-proxy");
 	if (!storage.isKey("key")) {
 		generateRandomKey();
 		storage.putString("key", key);
 	}
 	strcpy(key, storage.getString("key").c_str());
 	// Discover the first peer
 	while (peers.empty()) {
 		Serial.printf("espnow %s %s\n", WiFi.softAPmacAddress().c_str(), key);
 		delay(500);
 	}
 }
 void generateRandomKey() {
 	const char chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*-_+=";
 	for (int i = 0; i < ESP_NOW_KEY_LEN; i++) {
 		key[i] = chars[random(0, strlen(chars))];
 	}
 }
 void loop() {
 	uint8_t buf[5000];
 	// Send from Serial to ESP-NOW
 	while (Serial.available() > 0) {
 		int b = Serial.read();
 		if (b < 0) {
 			break;
 		}
 		mavlink_message_t msg;
 		mavlink_status_t status;
 		if (mavlink_parse_char(MAVLINK_COMM_0, (uint8_t)b, &msg, &status)) {
 			int len = mavlink_msg_to_send_buffer(buf, &msg);
 			for (ESPNOWSerial *link : peers) {
 				link->write(buf, len);
 			}
 		}
 	}
 	// Send from ESP-NOW to Serial
 	for (ESPNOWSerial *link : peers) {
 		int len = link->read(buf, sizeof(buf));
 		if (len > 0) {
 			Serial.write(buf, len);
 		}
 	}
 }
@@ -10,7 +10,6 @@ print('Connected:', flix.connected)
 print('Mode:', flix.mode)
 print('Armed:', flix.armed)
 print('Landed:', flix.landed)
 print('Voltage:', flix.voltage, 'V')
 print('Rates:', *[f'{math.degrees(r):.0f}°/s' for r in flix.rates])
 print('Attitude:', *[f'{math.degrees(a):.0f}°' for a in flix.attitude_euler])
 print('Motors:', flix.motors)
@@ -24,11 +23,11 @@ print('> imu')
 print(flix.cli('imu'))
 print('=== Get parameter...')
-pitch_p = flix.get_param('CTL_P_P')
+pitch_p = flix.get_param('PITCH_P')
-print('CTL_P_P = ', pitch_p)
+print('PITCH_P = ', pitch_p)
 print('=== Set parameter...')
-flix.set_param('CTL_P_P', pitch_p)
+flix.set_param('PITCH_P', pitch_p)
 print('=== Wait for gyro update...')
 print('Gyro: ', flix.wait('gyro'))
@@ -24,22 +24,19 @@ pip install pyflix
 The API is accessed through the `Flix` class:
 ```python
-from pyflix import Flix
+from flix import Flix
 flix = Flix()  # create a Flix object and wait for connection
 ```
 If using ESP-NOW connection, specify the proxy device name in `FLIX_DEVICE` environment variable or pass it to the constructor: `Flix(device='/dev/cu.usbserial-0001')`.
 ### Telemetry
-Basic telemetry is available through object properties. The property names generally match the corresponding variables in the firmware code:
+Basic telemetry is available through object properties. The property names generally match the corresponding variables in the firmware itself:
 ```python
 print(flix.connected)       # True if connected to the drone
 print(flix.mode)            # current flight mode (str)
 print(flix.armed)           # True if the drone is armed
 print(flix.landed)          # True if the drone is landed
 print(flix.voltage)         # battery voltage (NaN - unknown, ~0 - USB powered)
 print(flix.attitude)        # attitude quaternion [w, x, y, z]
 print(flix.attitude_euler)  # attitude as Euler angles [roll, pitch, yaw]
 print(flix.rates)           # angular rates [roll_rate, pitch_rate, yaw_rate]
@@ -98,7 +95,6 @@ Full list of events:
 |`armed`|Armed state update|Armed state *(bool)*|
 |`mode`|Flight mode update|Flight mode *(str)*|
 |`landed`|Landed state update|Landed state *(bool)*|
 |`voltage`|Battery voltage update|Voltage *(float)*|
 |`print`|The drone prints text to the console|Text|
 |`attitude`|Attitude update|Attitude quaternion *(list)*|
 |`attitude_euler`|Attitude update|Euler angles *(list)*|
@@ -121,8 +117,8 @@ Full list of events:
 Get and set firmware parameters using `get_param` and `set_param` methods:
 ```python
-pitch_p = flix.get_param('CTL_P_P')  # get parameter value
+pitch_p = flix.get_param('PITCH_P')  # get parameter value
-flix.set_param('CTL_P_P', 5)         # set parameter value
+flix.set_param('PITCH_P', 5)         # set parameter value
 ```
 Execute console commands using `cli` method. This method returns the command response:
@@ -222,13 +218,6 @@ The following scripts demonstrate how to use the library:
 * [`log.py`](../log.py) — download flight logs from the drone.
 * [`example.py`](../example.py) — a simple example, prints telemetry data and waits for events.
 > [!TIP]
 > Set `FLIX_DEVICE` environment variable to use these tools with ESP-NOW connection, for example:
 >
 > ```bash
 > FLIX_DEVICE=/dev/cu.usbserial-0001 tools/cli.py
 > ```
 ## Advanced usage
 ### MAVLink
@@ -5,7 +5,6 @@
 import os
 import time
 import math
 from queue import Queue, Empty
 from typing import Optional, Callable, List, Dict, Any, Union, Sequence
 import logging
@@ -27,7 +26,6 @@ class Flix:
    mode: str = ''
    armed: bool = False
    landed: bool = False
    voltage: float = math.nan
    attitude: List[float]
    attitude_euler: List[float]  # roll, pitch, yaw
    rates: List[float]
@@ -44,27 +42,22 @@ class Flix:
    _print_buffer: str = ''
    _modes = ['RAW', 'ACRO', 'STAB', 'AUTO']
-    def __init__(self, system_id: int=1, wait_connection: bool=True, device=os.getenv('FLIX_DEVICE')):
+    def __init__(self, system_id: int=1, wait_connection: bool=True):
        if not (0 <= system_id < 256):
            raise ValueError('system_id must be in range [0, 255]')
        self._setup_mavlink()
        self.system_id = system_id
        self._init_state()
-        if device is not None:
+        try:
-            # User defined connection
+            # Direct connection
-            logger.debug(f'Connecting to {device}')
+            logger.debug('Listening on port 14550')
-            self.connection: mavutil.mavfile = mavutil.mavlink_connection(device, source_system=255)  # type: ignore
+            self.connection: mavutil.mavfile = mavutil.mavlink_connection('udpin:0.0.0.0:14550', source_system=255)  # type: ignore
-        else:
+        except OSError as e:
-            try:
+            if e.errno != errno.EADDRINUSE:
-                # Direct connection
+                raise
-                logger.debug('Listening on port 14550')
+            # Port busy - using proxy
-                self.connection: mavutil.mavfile = mavutil.mavlink_connection('udpin:0.0.0.0:14550', source_system=255)  # type: ignore
+            logger.debug('Listening on port 14555 (proxy)')
-            except OSError as e:
+            self.connection: mavutil.mavfile = mavutil.mavlink_connection('udpin:0.0.0.0:14555', source_system=254)  # type: ignore
                if e.errno != errno.EADDRINUSE:
                    raise
                # Port busy - using proxy
                logger.debug('Listening on port 14555 (proxy)')
                self.connection: mavutil.mavfile = mavutil.mavlink_connection('udpin:0.0.0.0:14555', source_system=254)  # type: ignore
        self.connection.target_system = system_id
        self.mavlink: mavlink.MAVLink = self.connection.mav
        self._event_listeners: Dict[str, List[Callable[..., Any]]] = {}
@@ -75,7 +68,7 @@ class Flix:
        self._heartbeat_thread.start()
        if wait_connection:
            self.wait('mavlink.HEARTBEAT')
-            time.sleep(0.6) # give some time to receive initial state
+            time.sleep(0.2) # give some time to receive initial state
    def _init_state(self):
        self.attitude = [1, 0, 0, 0]
@@ -145,7 +138,7 @@ class Flix:
        while True:
            try:
                msg: Optional[mavlink.MAVLink_message] = self.connection.recv_match(blocking=True)
-                if msg is None or msg.get_srcSystem() != self.system_id:
+                if msg is None:
                    continue
                self._connected()
                msg_dict = msg.to_dict()
@@ -192,16 +185,11 @@ class Flix:
            self._trigger('motors', self.motors)
        if isinstance(msg, mavlink.MAVLink_scaled_imu_message):
-            ONE_G = 9.80665
+            self.acc = self._mavlink_to_flu([msg.xacc / 1000, msg.yacc / 1000, msg.zacc / 1000])
            self.acc = self._mavlink_to_flu([msg.xacc * ONE_G / 1000, msg.yacc * ONE_G / 1000, msg.zacc * ONE_G / 1000])
            self.gyro = self._mavlink_to_flu([msg.xgyro / 1000, msg.ygyro / 1000, msg.zgyro / 1000])
            self._trigger('acc', self.acc)
            self._trigger('gyro', self.gyro)
        if isinstance(msg, mavlink.MAVLink_battery_status_message):
            self.voltage = msg.voltages[0] / 1000
            self._trigger('voltage', self.voltage)
        if isinstance(msg, mavlink.MAVLink_serial_control_message):
            # new chunk of data
            text = bytes(msg.data)[:msg.count].decode('utf-8', errors='ignore')
@@ -243,7 +231,7 @@ class Flix:
            time.sleep(1)
    @staticmethod
-    def _mavlink_to_flu(v: Sequence[float]) -> List[float]:
+    def _mavlink_to_flu(v: List[float]) -> List[float]:
        if len(v) == 3:  # vector
            return [v[0], -v[1], -v[2]]
        elif len(v) == 4:  # quaternion
@@ -252,8 +240,8 @@ class Flix:
            raise ValueError(f'List must have 3 (vector) or 4 (quaternion) elements')
    @staticmethod
-    def _flu_to_mavlink(v: Sequence[float]) -> List[float]:
+    def _flu_to_mavlink(v: List[float]) -> List[float]:
-        return Flix._mavlink_to_flu(v)  # flu to mavlink is the same as mavlink to flu
+        return Flix._mavlink_to_flu(v)
    def _command_send(self, command: int, params: Sequence[float]):
        if len(params) != 7:
@@ -320,13 +308,13 @@ class Flix:
    def set_armed(self, armed: bool):
        self._command_send(mavlink.MAV_CMD_COMPONENT_ARM_DISARM, (1 if armed else 0, 0, 0, 0, 0, 0, 0))
-    def set_position(self, position: Sequence[float], yaw: Optional[float] = None, wait: bool = False, tolerance: float = 0.1):
+    def set_position(self, position: List[float], yaw: Optional[float] = None, wait: bool = False, tolerance: float = 0.1):
        raise NotImplementedError('Position control is not implemented yet')
-    def set_velocity(self, velocity: Sequence[float], yaw: Optional[float] = None):
+    def set_velocity(self, velocity: List[float], yaw: Optional[float] = None):
        raise NotImplementedError('Velocity control is not implemented yet')
-    def set_attitude(self, attitude: Sequence[float], thrust: float):
+    def set_attitude(self, attitude: List[float], thrust: float):
        if len(attitude) == 3:
            attitude = Quaternion([attitude[0], attitude[1], attitude[2]]).q  # type: ignore
        elif len(attitude) != 4:
@@ -339,7 +327,7 @@ class Flix:
                [attitude[0], attitude[1], attitude[2], attitude[3]],
                0, 0, 0, thrust)
-    def set_rates(self, rates: Sequence[float], thrust: float):
+    def set_rates(self, rates: List[float], thrust: float):
        if len(rates) != 3:
            raise ValueError('Rates must be [roll_rate, pitch_rate, yaw_rate]')
        if not (0 <= thrust <= 1):
@@ -351,7 +339,7 @@ class Flix:
                [1, 0, 0, 0],
                rates[0], rates[1], rates[2], thrust)
-    def set_motors(self, motors: Sequence[float]):
+    def set_motors(self, motors: List[float]):
        if len(motors) != 4:
            raise ValueError('motors must have 4 values')
        if not all(0 <= m <= 1 for m in motors):
@@ -1,6 +1,6 @@
 [project]
 name = "pyflix"
-version = "0.16"
+version = "0.11"
 description = "Python API for Flix drone"
 authors = [{ name="Oleg Kalachev", email="okalachev@gmail.com" }]
 license = "MIT"
		`@@ -1,3 +0,0 @@`
			`# ESPNOW-proxy`

			`Proxy sketch for using ESP-NOW connection with Flix drone.`