V761/TOPRC: new sub protocol

Top RC Hobby mini planes

.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [pascallanger]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=VF2K9T23DRY56&lc=US&item_name=DIY%20Multiprotocol&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHosted

.github/workflows/main.yml

@@ -0,0 +1,202 @@
+# Workflow for testing MULTI-Module firmware builds
+
+name: CI
+
+on:
+  # Trigger the workflow on pushes, except those that are tagged (avoids double-testing releases)
+  push:
+    branches:
+    - '**'
+    tags-ignore:
+      - '**'
+    paths:
+    - '.github/workflows/**'
+    - 'buildroot/bin/**'
+    - 'Multiprotocol/**'
+
+  # Trigger the workflow on pull requests to the master branch
+  pull_request:
+    branches:
+      - master
+    paths:
+    - '.github/workflows/**'
+    - 'buildroot/bin/**'
+    - 'Multiprotocol/**'
+
+  # Triggers the workflow on release creation
+  release:
+    types:
+      - created
+
+  # Allows the workflow to be triggered manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    # Configure the board matrix
+    strategy:
+      fail-fast: false
+      matrix:
+        board: [
+          "multi4in1-devel:avr:multiatmega328p:bootloader=none", 
+          "multi4in1-devel:avr:multiatmega328p:bootloader=optiboot", 
+          "multi4in1-devel:avr:multixmega32d4", 
+          "multi4in1-devel:STM32F1:multi5in1t18int", 
+          "multi4in1-devel:STM32F1:multistm32f103cb:debug_option=none", 
+          "multi4in1-devel:STM32F1:multistm32f103cb:debug_option=native", 
+          "multi4in1-devel:STM32F1:multistm32f103cb:debug_option=ftdi", 
+          "multi4in1-devel:STM32F1:multistm32f103c8:debug_option=none"
+        ]
+
+    # Set the environment variables
+    env:
+      BOARD: ${{ matrix.board }}
+
+    steps:
+      - uses: actions/checkout@v2
+      
+      - name: Install Arduino CLI
+        uses: arduino/setup-arduino-cli@v1.1.1
+      
+      - name: Prepare build environment
+        run: |
+          echo "Github Ref: $GITHUB_REF"
+          echo "Event name: ${{ github.event_name }}"
+          echo "Event action: ${{ github.event.action }}"
+          echo "Tag name: ${{ github.event.release.tag_name }}"
+
+          arduino-cli config init --additional-urls https://raw.githubusercontent.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/master/package_multi_4in1_board_index.json,https://raw.githubusercontent.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/devel/source/package_multi_4in1_board_devel_index.json
+          arduino-cli core update-index
+          
+          if [[ "$BOARD" =~ ":avr:" ]]; then
+            arduino-cli core install arduino:avr;
+          fi
+
+          if [[ "$BOARD" =~ "multi4in1-devel:avr" ]]; then
+            arduino-cli core install multi4in1-devel:avr
+          elif [[ "$BOARD" =~ "multi4in1:avr" ]]; then
+            arduino-cli core install multi4in1:avr
+          fi
+
+          if [[ "$BOARD" =~ "multi4in1-devel:STM32F1:" ]]; then
+            arduino-cli core install multi4in1-devel:STM32F1
+          elif [[ "$BOARD" =~ "multi4in1:STM32F1:" ]]; then
+            arduino-cli core install multi4in1:STM32F1
+          fi
+
+          chmod +x ${GITHUB_WORKSPACE}/buildroot/bin/*
+          echo "${GITHUB_WORKSPACE}/buildroot/bin" >> $GITHUB_PATH
+
+          mkdir ./build
+          mkdir ./binaries
+
+      - name: Configure MULTI-Module firmware options
+        run: |
+          # Load the build functions
+          source ./buildroot/bin/buildFunctions;  
+          
+          # Get the version
+          getMultiVersion
+          echo "MULTI_VERSION=$(echo $MULTI_VERSION)" >> $GITHUB_ENV
+
+          # Get all the protocols for this board
+          getAllProtocols
+          echo "A7105_PROTOCOLS=$(echo $A7105_PROTOCOLS)" >> $GITHUB_ENV
+          echo "CC2500_PROTOCOLS=$(echo $CC2500_PROTOCOLS)" >> $GITHUB_ENV
+          echo "CYRF6936_PROTOCOLS=$(echo $CYRF6936_PROTOCOLS)" >> $GITHUB_ENV
+          echo "NRF24L01_PROTOCOLS=$(echo $NRF24L01_PROTOCOLS)" >> $GITHUB_ENV
+          echo "SX1276_PROTOCOLS=$(echo $SX1276_PROTOCOLS)" >> $GITHUB_ENV
+          echo "CCNRF_INO_PROTOCOLS=$(echo $CCNRF_INO_PROTOCOLS)" >> $GITHUB_ENV
+          echo "ALL_PROTOCOLS=$(echo $ALL_PROTOCOLS)" >> $GITHUB_ENV
+
+          # Get all the RF modules for this board
+          getAllRFModules
+          echo "ALL_RFMODULES=$(echo $ALL_RFMODULES)" >> $GITHUB_ENV
+
+          # Disable CHECK_FOR_BOOTLOADER when not needed
+          if [[ "$BOARD" =~ ":avr:multiatmega328p:bootloader=none" ]]; then
+            opt_disable CHECK_FOR_BOOTLOADER;
+          fi
+
+          # Trim the build down for the Atmega328p board
+          if [[ "$BOARD" =~ ":avr:multiatmega328p:" ]]; then
+            opt_disable $ALL_PROTOCOLS
+            opt_enable FRSKYX_CC2500_INO AFHDS2A_A7105_INO MJXQ_NRF24L01_INO DSM_CYRF6936_INO;
+          fi
+
+          # Trim the enabled protocols down for the STM32F103CB board with debugging or the STM32F103C8 board in general
+          if [[ "$BOARD" =~ ":STM32F1:multistm32f103cb:debug_option=ftdi" ]] || [[ "$BOARD" =~ ":STM32F1:multistm32f103cb:debug_option=native" ]] || [[ "$BOARD" =~ ":STM32F1:multistm32f103c8" ]]; then
+            opt_disable $ALL_PROTOCOLS;
+            opt_enable FRSKYX_CC2500_INO AFHDS2A_A7105_INO MJXQ_NRF24L01_INO DSM_CYRF6936_INO;
+          fi
+
+      - name: Save default firmware configuration
+        run: |
+          cat Multiprotocol/_Config.h
+          cp Multiprotocol/_Config.h ./_Config.h.bak
+
+      - name: Build default configuration
+        run: |
+          # Skip the default build for boards where it's too large now
+          if [[ "$BOARD" =~ ":STM32F1:multistm32f103cb:debug_option=none" ]] || [[ "$BOARD" =~ ":STM32F1:multi5in1t18int" ]]; then
+            printf "Not testing default build for $BOARD.";
+          else
+            source ./buildroot/bin/buildFunctions;
+            buildMulti
+          fi
+
+      - name: Build serial only
+        run: |
+          source ./buildroot/bin/buildFunctions;
+          cp ./_Config.h.bak Multiprotocol/_Config.h
+          opt_disable ENABLE_PPM;
+          buildMulti;
+      
+      - name: Build PPM only
+        run: |
+          source ./buildroot/bin/buildFunctions;
+          cp ./_Config.h.bak Multiprotocol/_Config.h
+          opt_disable ENABLE_SERIAL;
+          buildMulti;
+
+      - name: Build each RF module individually
+        run: |
+          source ./buildroot/bin/buildFunctions;
+          cp ./_Config.h.bak Multiprotocol/_Config.h;
+          buildEachRFModule;
+
+      - name: Build each protocol individually
+        run: |
+          source ./buildroot/bin/buildFunctions;
+          cp ./_Config.h.bak Multiprotocol/_Config.h;
+          buildEachProtocol;
+
+      - name: Build release files
+        run: |
+          source ./buildroot/bin/buildFunctions;
+          cp ./_Config.h.bak Multiprotocol/_Config.h;
+          buildReleaseFiles;
+          ls -al ./binaries;
+
+          NUM_FILES=$(ls -l ./binaries | grep ^- | wc -l);
+          if [ $NUM_FILES -gt 0 ]; then 
+            echo "HAVE_FILES=true" >> $GITHUB_ENV
+          else
+            echo "HAVE_FILES=false" >> $GITHUB_ENV
+          fi
+
+      - name: Deploy files to release
+        if: github.event_name == 'release' && github.event.action == 'created' && env.HAVE_FILES == 'true'
+        uses: AButler/upload-release-assets@v2.0
+        with:
+          files: './binaries/*'
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: 'Upload Artifacts'
+        if: env.HAVE_FILES == 'true'
+        uses: actions/upload-artifact@v2
+        with:
+          name: multi-test-build
+          path: ./binaries/

BootLoaders/AtmegaEmptyBoot/AtmegaMultiEmpty.hex

@@ -0,0 +1,2 @@
+:02000000FFFF00
+:00000001FF

BootLoaders/AtmegaMultiBoot/AtmegaMultiBoot.hex

@@ -0,0 +1,34 @@
+:107E0000112484B714BE9FEF9BB99CE395B991E010
+:107E100098B98370A9F08AEF80938500109284004E
+:107E200085E08093810096BBB09BFECF10928100CD
+:107E300093B186B181709C73892B8D3109F0B3D0D9
+:107E400082E08093C00088E18093C10086E0809347
+:107E5000C20081E28093C400259AC0E0D0E093E0A4
+:107E6000F92EEE24E39425E0D22E31E1C32EA9D0E1
+:107E7000813481F4A6D08EBBABD08EB3823811F49E
+:107E800085E006C08EB3813811F484E001C083E040
+:107E900091D086C0823411F484E103C0853419F492
+:107EA00085E09DD07DC0853541F48BD0C82F89D029
+:107EB000D0E0D82BCC0FDD1F72C0863521F484E0D2
+:107EC0008ED080E0E5CF843609F03DC07AD079D0FD
+:107ED000B82E77D0C11520E7D20718F000E011E0E6
+:107EE00004C0FE01F7BEE895F9CF6BD0F80181938D
+:107EF0008F01BE12FACFCE01905781159E4018F423
+:107F0000FE01F7BEE89564D0C115FEE7DF0708F073
+:107F100047C007B600FCFDCFFE01A0E0B1E08D91A7
+:107F20009D910C01E7BEE89511243296A03821E01E
+:107F3000B207A9F7FE01D7BEE89507B600FCFDCF52
+:107F4000C7BEE8952DC08437B1F43BD03AD0B82EE7
+:107F500038D03ED0FE01AC2EAB0C8F010F5F1F4F0F
+:107F6000849128D0A01205C02196BA94CB0DD11DC2
+:107F700017C0F801F2CF853739F42AD08EE11AD034
+:107F800085E918D08FE084CF813549F421D080E194
+:107F900011D08091C00086FFFCCF05D001C018D061
+:107FA00080E108D064CFE0E0F0E084918F3F09F0F9
+:107FB000099408959091C00095FFFCCF8093C6006E
+:107FC00008958091C00087FFFCCF8091C60008957E
+:107FD000F8DF803211F085E1EDDF84E1EBCFCF9364
+:107FE000C82FEFDFC150E9F7CF91F2CFA8950895E0
+:0C7FF000E0E6F0E098E1908380830895C3
+:0400000300007E007B
+:00000001FF

BootLoaders/AtmegaMultiBoot/Source/Makefile

@@ -0,0 +1,504 @@
+# Makefile for ATmegaBOOT
+# E.Lins, 18.7.2005
+# $Id$
+#
+# Instructions
+#
+# To make bootloader .hex file:
+# make diecimila
+# make lilypad
+# make ng
+# etc...
+#
+# To burn bootloader .hex file:
+# make diecimila_isp
+# make lilypad_isp
+# make ng_isp
+# etc...
+
+# program name should not be changed...
+PROGRAM    = optiboot
+
+# The default behavior is to build using tools that are in the users
+# current path variables, but we can also build using an installed
+# Arduino user IDE setup, or the Arduino source tree.
+# Uncomment this next lines to build within the arduino environment,
+# using the arduino-included avrgcc toolset (mac and pc)
+# ENV ?= arduino
+# ENV ?= arduinodev
+# OS ?= macosx
+# OS ?= windows
+
+
+# enter the parameters for the avrdude isp tool  -b19200
+#
+# These are the parameters for a usb-based STK500v2 programmer.
+# Exact type unknown.  (historical Makefile values.)
+ISPTOOL	   = stk500v2
+ISPPORT	   =  usb
+ISPSPEED   = -b 57600
+#
+#
+# These are parameters for using an Arduino with the ArduinoISP sketch
+#  as the programmer.  On a mac, for a particular Uno as programmer.
+#ISPTOOL	= stk500v1 -C /Applications/arduino/arduino-0022/hardware/tools/avr/etc/avrdude.conf
+#ISPPORT	= /dev/tty.usbmodemfd3141 
+#ISPSPEED	= -b19200
+
+MCU_TARGET = atmega168
+LDSECTIONS  = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
+
+# Build environments
+# Start of some ugly makefile-isms to allow optiboot to be built
+# in several different environments.  See the README.TXT file for
+# details.
+
+# default
+fixpath = $(1)
+
+ifeq ($(ENV), arduino)
+# For Arduino, we assume that we're connected to the optiboot directory
+# included with the arduino distribution, which means that the full set
+# of avr-tools are "right up there" in standard places.
+TOOLROOT = ../../../tools
+GCCROOT = $(TOOLROOT)/avr/bin/
+AVRDUDE_CONF = -C$(TOOLROOT)/avr/etc/avrdude.conf
+
+ifeq ($(OS), windows)
+# On windows, SOME of the tool paths will need to have backslashes instead
+# of forward slashes (because they use windows cmd.exe for execution instead
+# of a unix/mingw shell?)  We also have to ensure that a consistent shell
+# is used even if a unix shell is installed (ie as part of WINAVR)
+fixpath = $(subst /,\,$1)
+SHELL = cmd.exe
+endif
+
+else ifeq ($(ENV), arduinodev)
+# Arduino IDE source code environment.  Use the unpacked compilers created
+# by the build (you'll need to do "ant build" first.)
+ifeq ($(OS), macosx)
+TOOLROOT = ../../../../build/macosx/work/Arduino.app/Contents/Resources/Java/hardware/tools
+endif
+ifeq ($(OS), windows)
+TOOLROOT = ../../../../build/windows/work/hardware/tools
+endif
+
+GCCROOT = $(TOOLROOT)/avr/bin/
+AVRDUDE_CONF = -C$(TOOLROOT)/avr/etc/avrdude.conf
+
+else
+GCCROOT =
+AVRDUDE_CONF =
+endif
+#
+# End of build environment code.
+
+
+# the efuse should really be 0xf8; since, however, only the lower
+# three bits of that byte are used on the atmega168, avrdude gets
+# confused if you specify 1's for the higher bits, see:
+# http://tinker.it/now/2007/02/24/the-tale-of-avrdude-atmega168-and-extended-bits-fuses/
+#
+# similarly, the lock bits should be 0xff instead of 0x3f (to
+# unlock the bootloader section) and 0xcf instead of 0x2f (to
+# lock it), but since the high two bits of the lock byte are
+# unused, avrdude would get confused.
+
+ISPFUSES    = $(GCCROOT)avrdude $(AVRDUDE_CONF) -c $(ISPTOOL) \
+              -p $(MCU_TARGET) -P $(ISPPORT) $(ISPSPEED) \
+              -e -u -U lock:w:0x3f:m -U efuse:w:0x$(EFUSE):m \
+              -U hfuse:w:0x$(HFUSE):m -U lfuse:w:0x$(LFUSE):m
+ISPFLASH    = $(GCCROOT)avrdude $(AVRDUDE_CONF) -c $(ISPTOOL) \
+              -p $(MCU_TARGET) -P $(ISPPORT) $(ISPSPEED) \
+              -U flash:w:$(PROGRAM)_$(TARGET).hex -U lock:w:0x2f:m
+
+STK500 = "C:\Program Files\Atmel\AVR Tools\STK500\Stk500.exe"
+STK500-1 = $(STK500) -e -d$(MCU_TARGET) -pf -vf -if$(PROGRAM)_$(TARGET).hex \
+-lFF -LFF -f$(HFUSE)$(LFUSE) -EF8 -ms -q -cUSB -I200kHz -s -wt
+STK500-2 = $(STK500) -d$(MCU_TARGET) -ms -q -lCF -LCF -cUSB -I200kHz -s -wt
+
+OBJ        = $(PROGRAM).o
+OPTIMIZE = -Os -fno-inline-small-functions -fno-split-wide-types
+# -mshort-calls
+
+DEFS       = 
+LIBS       =
+
+CC         = $(GCCROOT)avr-gcc
+
+# Override is only needed by avr-lib build system.
+
+override CFLAGS        = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) -DF_CPU=$(AVR_FREQ) $(DEFS)
+override LDFLAGS       = $(LDSECTIONS) -Wl,--relax -Wl,--gc-sections -nostartfiles -nostdlib
+
+OBJCOPY        = $(GCCROOT)avr-objcopy
+OBJDUMP        = $(call fixpath,$(GCCROOT)avr-objdump)
+
+SIZE           = $(GCCROOT)avr-size
+
+
+
+#Voice board test
+# ATmega328
+#
+#atmega328: TARGET = atmega328p
+#atmega328: MCU_TARGET = atmega328p
+#atmega328: CFLAGS += '-DLED_START_FLASHES=0' '-DBAUD_RATE=38400'
+#atmega328: AVR_FREQ = 12000000L 
+#atmega328: LDSECTIONS  = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
+#atmega328: $(PROGRAM)_atmega328.hex
+#atmega328: $(PROGRAM)_atmega328.lst
+
+atmega328: TARGET = atmega328
+atmega328: MCU_TARGET = atmega328p
+atmega328: CFLAGS += '-DLED_START_FLASHES=0' '-DBAUD_RATE=57600'
+atmega328: AVR_FREQ = 16000000L
+atmega328: LDSECTIONS  = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
+atmega328: $(PROGRAM)_atmega328_16.hex
+atmega328: $(PROGRAM)_atmega328_16.lst
+
+
+xmega32D4: TARGET = atxmega32d4
+xmega32D4: MCU_TARGET = atxmega32d4
+xmega32D4: CFLAGS += '-DLED_START_FLASHES=0' '-DBAUD_RATE=57600'
+xmega32D4: AVR_FREQ = 32000000L 
+xmega32D4: LDSECTIONS  = -Wl,--section-start=.text=0x8000
+xmega32D4: $(PROGRAM)_xmega32d4.hex
+xmega32D4: $(PROGRAM)_xmega32d4.lst
+
+
+# Test platforms
+# Virtual boot block test
+virboot328: TARGET = atmega328
+virboot328: MCU_TARGET = atmega328p
+virboot328: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400' '-DVIRTUAL_BOOT'
+virboot328: AVR_FREQ = 16000000L
+virboot328: LDSECTIONS  = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
+virboot328: $(PROGRAM)_atmega328.hex
+virboot328: $(PROGRAM)_atmega328.lst
+
+# 20MHz clocked platforms
+#
+# These are capable of 230400 baud, or 38400 baud on PC (Arduino Avrdude issue)
+#
+
+pro20: TARGET = pro_20mhz
+pro20: MCU_TARGET = atmega168
+pro20: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+pro20: AVR_FREQ = 20000000L
+pro20: $(PROGRAM)_pro_20mhz.hex
+pro20: $(PROGRAM)_pro_20mhz.lst
+
+pro20_isp: pro20
+pro20_isp: TARGET = pro_20mhz
+# 2.7V brownout
+pro20_isp: HFUSE = DD
+# Full swing xtal (20MHz) 258CK/14CK+4.1ms
+pro20_isp: LFUSE = C6
+# 512 byte boot
+pro20_isp: EFUSE = 04
+pro20_isp: isp
+
+# 16MHz clocked platforms
+#
+# These are capable of 230400 baud, or 38400 baud on PC (Arduino Avrdude issue)
+#
+
+pro16: TARGET = pro_16MHz
+pro16: MCU_TARGET = atmega168
+pro16: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+pro16: AVR_FREQ = 16000000L
+pro16: $(PROGRAM)_pro_16MHz.hex
+pro16: $(PROGRAM)_pro_16MHz.lst
+
+pro16_isp: pro16
+pro16_isp: TARGET = pro_16MHz
+# 2.7V brownout
+pro16_isp: HFUSE = DD
+# Full swing xtal (20MHz) 258CK/14CK+4.1ms
+pro16_isp: LFUSE = C6
+# 512 byte boot
+pro16_isp: EFUSE = 04
+pro16_isp: isp
+
+# Diecimila, Duemilanove with m168, and NG use identical bootloaders
+# Call it "atmega168" for generality and clarity, keep "diecimila" for
+# backward compatibility of makefile
+#
+atmega168: TARGET = atmega168
+atmega168: MCU_TARGET = atmega168
+atmega168: CFLAGS += '-DLED_START_FLASHES=0' '-DBAUD_RATE=38400'
+atmega168: AVR_FREQ = 12000000L 
+atmega168: $(PROGRAM)_atmega168.hex
+atmega168: $(PROGRAM)_atmega168.lst
+
+atmega168_isp: atmega168
+atmega168_isp: TARGET = atmega168
+# 2.7V brownout
+atmega168_isp: HFUSE = DD
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+atmega168_isp: LFUSE = FF
+# 512 byte boot
+atmega168_isp: EFUSE = 04
+atmega168_isp: isp
+
+diecimila: TARGET = diecimila
+diecimila: MCU_TARGET = atmega168
+diecimila: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+diecimila: AVR_FREQ = 16000000L 
+diecimila: $(PROGRAM)_diecimila.hex
+diecimila: $(PROGRAM)_diecimila.lst
+
+diecimila_isp: diecimila
+diecimila_isp: TARGET = diecimila
+# 2.7V brownout
+diecimila_isp: HFUSE = DD
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+diecimila_isp: LFUSE = FF
+# 512 byte boot
+diecimila_isp: EFUSE = 04
+diecimila_isp: isp
+
+atmega328_isp: atmega328
+atmega328_isp: TARGET = atmega328
+atmega328_isp: MCU_TARGET = atmega328p
+# 512 byte boot, SPIEN
+atmega328_isp: HFUSE = DE
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+atmega328_isp: LFUSE = FF
+# 2.7V brownout
+atmega328_isp: EFUSE = FD
+atmega328_isp: isp
+
+atmega1284: TARGET = atmega1284p
+atmega1284: MCU_TARGET = atmega1284p
+atmega1284: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400' '-DBIGBOOT'
+atmega1284: AVR_FREQ = 16000000L
+atmega1284: LDSECTIONS  = -Wl,--section-start=.text=0x1fc00 -Wl,--section-start=.version=0x1fffe
+atmega1284: $(PROGRAM)_atmega1284p.hex
+atmega1284: $(PROGRAM)_atmega1284p.lst
+
+atmega1284_isp: atmega1284
+atmega1284_isp: TARGET = atmega1284p
+atmega1284_isp: MCU_TARGET = atmega1284p
+# 1024 byte boot
+atmega1284_isp: HFUSE = DE
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+atmega1284_isp: LFUSE = FF
+# 2.7V brownout
+atmega1284_isp: EFUSE = FD
+atmega1284_isp: isp
+
+# Sanguino has a minimum boot size of 1024 bytes, so enable extra functions
+#
+sanguino: TARGET = atmega644p
+sanguino: MCU_TARGET = atmega644p
+sanguino: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400' '-DBIGBOOT'
+sanguino: AVR_FREQ = 16000000L
+sanguino: LDSECTIONS  = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
+sanguino: $(PROGRAM)_atmega644p.hex
+sanguino: $(PROGRAM)_atmega644p.lst
+
+sanguino_isp: sanguino
+sanguino_isp: TARGET = atmega644p
+sanguino_isp: MCU_TARGET = atmega644p
+# 1024 byte boot
+sanguino_isp: HFUSE = DE
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+sanguino_isp: LFUSE = FF
+# 2.7V brownout
+sanguino_isp: EFUSE = FD
+sanguino_isp: isp
+
+# Mega has a minimum boot size of 1024 bytes, so enable extra functions
+#mega: TARGET = atmega1280
+mega1280: MCU_TARGET = atmega1280
+mega1280: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400' '-DBIGBOOT'
+mega1280: AVR_FREQ = 16000000L
+mega1280: LDSECTIONS  = -Wl,--section-start=.text=0x1fc00  -Wl,--section-start=.version=0x1fffe
+mega1280: $(PROGRAM)_atmega1280.hex
+mega1280: $(PROGRAM)_atmega1280.lst
+
+mega1280_isp: mega
+mega1280_isp: TARGET = atmega1280
+mega1280_isp: MCU_TARGET = atmega1280
+# 1024 byte boot
+mega1280_isp: HFUSE = DE
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+mega1280_isp: LFUSE = FF
+# 2.7V brownout
+mega1280_isp: EFUSE = FD
+mega1280_isp: isp
+
+# ATmega8
+#
+atmega8: TARGET = atmega8
+atmega8: MCU_TARGET = atmega8
+atmega8: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+atmega8: AVR_FREQ = 16000000L 
+atmega8: LDSECTIONS  = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe
+atmega8: $(PROGRAM)_atmega8.hex
+atmega8: $(PROGRAM)_atmega8.lst
+
+atmega8_isp: atmega8
+atmega8_isp: TARGET = atmega8
+atmega8_isp: MCU_TARGET = atmega8
+# SPIEN, CKOPT, Bootsize=512B
+atmega8_isp: HFUSE = CC
+# 2.7V brownout, Low power xtal (16MHz) 16KCK/14CK+65ms
+atmega8_isp: LFUSE = BF
+atmega8_isp: isp
+
+# ATmega88
+#
+atmega88: TARGET = atmega88
+atmega88: MCU_TARGET = atmega88
+atmega88: CFLAGS += '-DLED_START_FLASHES=0' '-DBAUD_RATE=38400'
+atmega88: AVR_FREQ = 12000000L 
+atmega88: LDSECTIONS  = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe
+atmega88: $(PROGRAM)_atmega88.hex
+atmega88: $(PROGRAM)_atmega88.lst
+
+atmega88_isp: atmega88
+atmega88_isp: TARGET = atmega88
+atmega88_isp: MCU_TARGET = atmega88
+# 2.7V brownout
+atmega88_isp: HFUSE = DD
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+atemga88_isp: LFUSE = FF
+# 512 byte boot
+atmega88_isp: EFUSE = 04
+atmega88_isp: isp
+
+
+# 8MHz clocked platforms
+#
+# These are capable of 38400 baud
+#
+
+lilypad: TARGET = lilypad
+lilypad: MCU_TARGET = atmega168
+lilypad: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+lilypad: AVR_FREQ = 8000000L
+lilypad: $(PROGRAM)_lilypad.hex
+lilypad: $(PROGRAM)_lilypad.lst
+
+lilypad_isp: lilypad
+lilypad_isp: TARGET = lilypad
+# 2.7V brownout
+lilypad_isp: HFUSE = DD
+# Internal 8MHz osc (8MHz) Slow rising power
+lilypad_isp: LFUSE = E2
+# 512 byte boot
+lilypad_isp: EFUSE = 04
+lilypad_isp: isp
+
+lilypad_resonator: TARGET = lilypad_resonator
+lilypad_resonator: MCU_TARGET = atmega168
+lilypad_resonator: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+lilypad_resonator: AVR_FREQ = 8000000L
+lilypad_resonator: $(PROGRAM)_lilypad_resonator.hex
+lilypad_resonator: $(PROGRAM)_lilypad_resonator.lst
+
+lilypad_resonator_isp: lilypad_resonator
+lilypad_resonator_isp: TARGET = lilypad_resonator
+# 2.7V brownout
+lilypad_resonator_isp: HFUSE = DD
+# Full swing xtal (20MHz) 258CK/14CK+4.1ms
+lilypad_resonator_isp: LFUSE = C6
+# 512 byte boot
+lilypad_resonator_isp: EFUSE = 04
+lilypad_resonator_isp: isp
+
+pro8: TARGET = pro_8MHz
+pro8: MCU_TARGET = atmega168
+pro8: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+pro8: AVR_FREQ = 8000000L
+pro8: $(PROGRAM)_pro_8MHz.hex
+pro8: $(PROGRAM)_pro_8MHz.lst
+
+pro8_isp: pro8
+pro8_isp: TARGET = pro_8MHz
+# 2.7V brownout
+pro8_isp: HFUSE = DD
+# Full swing xtal (20MHz) 258CK/14CK+4.1ms
+pro8_isp: LFUSE = C6
+# 512 byte boot
+pro8_isp: EFUSE = 04
+pro8_isp: isp
+
+atmega328_pro8: TARGET = atmega328_pro_8MHz
+atmega328_pro8: MCU_TARGET = atmega328p
+atmega328_pro8: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+atmega328_pro8: AVR_FREQ = 8000000L
+atmega328_pro8: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
+atmega328_pro8: $(PROGRAM)_atmega328_pro_8MHz.hex
+atmega328_pro8: $(PROGRAM)_atmega328_pro_8MHz.lst
+
+atmega328_pro8_isp: atmega328_pro8
+atmega328_pro8_isp: TARGET = atmega328_pro_8MHz
+atmega328_pro8_isp: MCU_TARGET = atmega328p
+# 512 byte boot, SPIEN
+atmega328_pro8_isp: HFUSE = DE
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+atmega328_pro8_isp: LFUSE = FF
+# 2.7V brownout
+atmega328_pro8_isp: EFUSE = DE
+atmega328_pro8_isp: isp
+
+# 1MHz clocked platforms
+#
+# These are capable of 9600 baud
+#
+
+luminet: TARGET = luminet
+luminet: MCU_TARGET = attiny84
+luminet: CFLAGS += '-DLED_START_FLASHES=3' '-DSOFT_UART' '-DBAUD_RATE=9600'
+luminet: CFLAGS += '-DVIRTUAL_BOOT_PARTITION'
+luminet: AVR_FREQ = 1000000L
+luminet: LDSECTIONS = -Wl,--section-start=.text=0x1d00 -Wl,--section-start=.version=0x1efe
+luminet: $(PROGRAM)_luminet.hex
+luminet: $(PROGRAM)_luminet.lst
+
+luminet_isp: luminet
+luminet_isp: TARGET = luminet
+luminet_isp: MCU_TARGET = attiny84
+# Brownout disabled
+luminet_isp: HFUSE = DF
+# 1MHz internal oscillator, slowly rising power
+luminet_isp: LFUSE = 62
+# Self-programming enable
+luminet_isp: EFUSE = FE
+luminet_isp: isp
+
+#
+# Generic build instructions
+#
+#
+
+isp: $(TARGET)
+	$(ISPFUSES)
+	$(ISPFLASH)
+
+isp-stk500: $(PROGRAM)_$(TARGET).hex
+	$(STK500-1)
+	$(STK500-2)
+
+%.elf: $(OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)
+	$(SIZE) $@
+
+clean:
+	rm -rf *.o *.elf *.lst *.map *.sym *.lss *.eep *.srec *.bin *.hex
+
+%.lst: %.elf
+	$(OBJDUMP) -h -S $< > $@
+
+%.hex: %.elf
+	$(OBJCOPY) -j .text -j .data -j .version --set-section-flags .version=alloc,load -O ihex $< $@
+
+%.srec: %.elf
+	$(OBJCOPY) -j .text -j .data -j .version --set-section-flags .version=alloc,load -O srec $< $@
+
+%.bin: %.elf
+	$(OBJCOPY) -j .text -j .data -j .version --set-section-flags .version=alloc,load -O binary $< $@

BootLoaders/AtmegaMultiBoot/Source/boot.h

@@ -0,0 +1,848 @@
+/* Modified to use out for SPM access
+** Peter Knight, Optiboot project http://optiboot.googlecode.com
+**
+** Todo: Tidy up
+**
+** "_short" routines execute 1 cycle faster and use 1 less word of flash
+** by using "out" instruction instead of "sts".
+**
+** Additional elpm variants that trust the value of RAMPZ
+*/
+
+/* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007  Eric B. Weddington
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+
+   * Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+   * Neither the name of the copyright holders nor the names of
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE. */
+
+/* $Id: boot.h,v 1.27.2.3 2008/09/30 13:58:48 arcanum Exp $ */
+
+#ifndef _AVR_BOOT_H_
+#define _AVR_BOOT_H_    1
+
+/** \file */
+/** \defgroup avr_boot <avr/boot.h>: Bootloader Support Utilities
+    \code
+    #include <avr/io.h>
+    #include <avr/boot.h>
+    \endcode
+
+    The macros in this module provide a C language interface to the
+    bootloader support functionality of certain AVR processors. These
+    macros are designed to work with all sizes of flash memory.
+
+    Global interrupts are not automatically disabled for these macros. It
+    is left up to the programmer to do this. See the code example below. 
+    Also see the processor datasheet for caveats on having global interrupts 
+    enabled during writing of the Flash.
+
+    \note Not all AVR processors provide bootloader support. See your
+    processor datasheet to see if it provides bootloader support.
+
+    \todo From email with Marek: On smaller devices (all except ATmega64/128),
+    __SPM_REG is in the I/O space, accessible with the shorter "in" and "out"
+    instructions - since the boot loader has a limited size, this could be an
+    important optimization.
+
+    \par API Usage Example
+    The following code shows typical usage of the boot API.
+
+    \code
+    #include <inttypes.h>
+    #include <avr/interrupt.h>
+    #include <avr/pgmspace.h>
+    
+    void boot_program_page (uint32_t page, uint8_t *buf)
+    {
+        uint16_t i;
+        uint8_t sreg;
+
+        // Disable interrupts.
+
+        sreg = SREG;
+        cli();
+    
+        eeprom_busy_wait ();
+
+        boot_page_erase (page);
+        boot_spm_busy_wait ();      // Wait until the memory is erased.
+
+        for (i=0; i<SPM_PAGESIZE; i+=2)
+        {
+            // Set up little-endian word.
+
+            uint16_t w = *buf++;
+            w += (*buf++) << 8;
+        
+            boot_page_fill (page + i, w);
+        }
+
+        boot_page_write (page);     // Store buffer in flash page.
+        boot_spm_busy_wait();       // Wait until the memory is written.
+
+        // Reenable RWW-section again. We need this if we want to jump back
+        // to the application after bootloading.
+
+        boot_rww_enable ();
+
+        // Re-enable interrupts (if they were ever enabled).
+
+        SREG = sreg;
+    }\endcode */
+
+#include <avr/eeprom.h>
+#include <avr/io.h>
+#include <inttypes.h>
+#include <limits.h>
+
+/* Check for SPM Control Register in processor. */
+#if defined (SPMCSR)
+#  define __SPM_REG    SPMCSR
+#elif defined (SPMCR)
+#  define __SPM_REG    SPMCR
+#else
+#  error AVR processor does not provide bootloader support!
+#endif
+
+
+/* Check for SPM Enable bit. */
+#if defined(SPMEN)
+#  define __SPM_ENABLE  SPMEN
+#elif defined(SELFPRGEN)
+#  define __SPM_ENABLE  SELFPRGEN
+#else
+#  error Cannot find SPM Enable bit definition!
+#endif
+
+/** \ingroup avr_boot
+    \def BOOTLOADER_SECTION
+
+    Used to declare a function or variable to be placed into a
+    new section called .bootloader. This section and its contents
+    can then be relocated to any address (such as the bootloader
+    NRWW area) at link-time. */
+
+#define BOOTLOADER_SECTION    __attribute__ ((section (".bootloader")))
+
+/* Create common bit definitions. */
+#ifdef ASB
+#define __COMMON_ASB    ASB
+#else
+#define __COMMON_ASB    RWWSB
+#endif
+
+#ifdef ASRE
+#define __COMMON_ASRE   ASRE
+#else
+#define __COMMON_ASRE   RWWSRE
+#endif
+
+/* Define the bit positions of the Boot Lock Bits. */
+
+#define BLB12           5
+#define BLB11           4
+#define BLB02           3
+#define BLB01           2
+
+/** \ingroup avr_boot
+    \def boot_spm_interrupt_enable()
+    Enable the SPM interrupt. */
+
+#define boot_spm_interrupt_enable()   (__SPM_REG |= (uint8_t)_BV(SPMIE))
+
+/** \ingroup avr_boot
+    \def boot_spm_interrupt_disable()
+    Disable the SPM interrupt. */
+
+#define boot_spm_interrupt_disable()  (__SPM_REG &= (uint8_t)~_BV(SPMIE))
+
+/** \ingroup avr_boot
+    \def boot_is_spm_interrupt()
+    Check if the SPM interrupt is enabled. */
+
+#define boot_is_spm_interrupt()       (__SPM_REG & (uint8_t)_BV(SPMIE))
+
+/** \ingroup avr_boot
+    \def boot_rww_busy()
+    Check if the RWW section is busy. */
+
+#define boot_rww_busy()          (__SPM_REG & (uint8_t)_BV(__COMMON_ASB))
+
+/** \ingroup avr_boot
+    \def boot_spm_busy()
+    Check if the SPM instruction is busy. */
+
+#define boot_spm_busy()               (__SPM_REG & (uint8_t)_BV(__SPM_ENABLE))
+
+/** \ingroup avr_boot
+    \def boot_spm_busy_wait()
+    Wait while the SPM instruction is busy. */
+
+#define boot_spm_busy_wait()          do{}while(boot_spm_busy())
+
+#define __BOOT_PAGE_ERASE         (_BV(__SPM_ENABLE) | _BV(PGERS))
+#define __BOOT_PAGE_WRITE         (_BV(__SPM_ENABLE) | _BV(PGWRT))
+#define __BOOT_PAGE_FILL          _BV(__SPM_ENABLE)
+#define __BOOT_RWW_ENABLE         (_BV(__SPM_ENABLE) | _BV(__COMMON_ASRE))
+#define __BOOT_LOCK_BITS_SET      (_BV(__SPM_ENABLE) | _BV(BLBSET))
+
+#define __boot_page_fill_short(address, data)   \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw  r0, %3\n\t"                       \
+        "out %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        "clr  r1\n\t"                            \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_FILL),       \
+          "z" ((uint16_t)address),               \
+          "r" ((uint16_t)data)                   \
+        : "r0"                                   \
+    );                                           \
+}))
+
+#define __boot_page_fill_normal(address, data)   \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw  r0, %3\n\t"                       \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        "clr  r1\n\t"                            \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_FILL),       \
+          "z" ((uint16_t)address),               \
+          "r" ((uint16_t)data)                   \
+        : "r0"                                   \
+    );                                           \
+}))
+
+#define __boot_page_fill_alternate(address, data)\
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw  r0, %3\n\t"                       \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        ".word 0xffff\n\t"                       \
+        "nop\n\t"                                \
+        "clr  r1\n\t"                            \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_FILL),       \
+          "z" ((uint16_t)address),               \
+          "r" ((uint16_t)data)                   \
+        : "r0"                                   \
+    );                                           \
+}))
+
+#define __boot_page_fill_extended(address, data) \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw  r0, %4\n\t"                       \
+        "movw r30, %A3\n\t"                      \
+        "sts %1, %C3\n\t"                        \
+        "sts %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        "clr  r1\n\t"                            \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "i" (_SFR_MEM_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_FILL),       \
+          "r" ((uint32_t)address),               \
+          "r" ((uint16_t)data)                   \
+        : "r0", "r30", "r31"                     \
+    );                                           \
+}))
+
+#define __boot_page_fill_extended_short(address, data) \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw  r0, %4\n\t"                       \
+        "movw r30, %A3\n\t"                      \
+        "out %1, %C3\n\t"                        \
+        "out %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        "clr  r1\n\t"                            \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "i" (_SFR_IO_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_FILL),       \
+          "r" ((uint32_t)address),               \
+          "r" ((uint16_t)data)                   \
+        : "r0", "r30", "r31"                     \
+    );                                           \
+}))
+
+#define __boot_page_erase_short(address)        \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "out %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_ERASE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+
+#define __boot_page_erase_normal(address)        \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_ERASE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+#define __boot_page_erase_alternate(address)     \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        ".word 0xffff\n\t"                       \
+        "nop\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_ERASE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+#define __boot_page_erase_extended(address)      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw r30, %A3\n\t"                      \
+        "sts  %1, %C3\n\t"                       \
+        "sts %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "i" (_SFR_MEM_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_ERASE),      \
+          "r" ((uint32_t)address)                \
+        : "r30", "r31"                           \
+    );                                           \
+}))
+#define __boot_page_erase_extended_short(address)      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw r30, %A3\n\t"                      \
+        "out  %1, %C3\n\t"                       \
+        "out %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "i" (_SFR_IO_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_ERASE),      \
+          "r" ((uint32_t)address)                \
+        : "r30", "r31"                           \
+    );                                           \
+}))
+
+#define __boot_page_write_short(address)        \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "out %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_WRITE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+#define __boot_page_write_normal(address)        \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_WRITE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+#define __boot_page_write_alternate(address)     \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        ".word 0xffff\n\t"                       \
+        "nop\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_WRITE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+#define __boot_page_write_extended(address)      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw r30, %A3\n\t"                      \
+        "sts %1, %C3\n\t"                        \
+        "sts %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "i" (_SFR_MEM_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_WRITE),      \
+          "r" ((uint32_t)address)                \
+        : "r30", "r31"                           \
+    );                                           \
+}))
+#define __boot_page_write_extended_short(address)      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw r30, %A3\n\t"                      \
+        "out %1, %C3\n\t"                        \
+        "out %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "i" (_SFR_IO_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_WRITE),      \
+          "r" ((uint32_t)address)                \
+        : "r30", "r31"                           \
+    );                                           \
+}))
+
+#define __boot_rww_enable_short()                      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "out %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_RWW_ENABLE)       \
+    );                                           \
+}))
+
+#define __boot_rww_enable()                      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_RWW_ENABLE)       \
+    );                                           \
+}))
+
+#define __boot_rww_enable_alternate()            \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        ".word 0xffff\n\t"                       \
+        "nop\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_RWW_ENABLE)       \
+    );                                           \
+}))
+
+/* From the mega16/mega128 data sheets (maybe others):
+
+     Bits by SPM To set the Boot Loader Lock bits, write the desired data to
+     R0, write "X0001001" to SPMCR and execute SPM within four clock cycles
+     after writing SPMCR. The only accessible Lock bits are the Boot Lock bits
+     that may prevent the Application and Boot Loader section from any
+     software update by the MCU.
+
+     If bits 5..2 in R0 are cleared (zero), the corresponding Boot Lock bit
+     will be programmed if an SPM instruction is executed within four cycles
+     after BLBSET and SPMEN (or SELFPRGEN) are set in SPMCR. The Z-pointer is 
+     don't care during this operation, but for future compatibility it is 
+     recommended to load the Z-pointer with $0001 (same as used for reading the 
+     Lock bits). For future compatibility It is also recommended to set bits 7, 
+     6, 1, and 0 in R0 to 1 when writing the Lock bits. When programming the 
+     Lock bits the entire Flash can be read during the operation. */
+
+#define __boot_lock_bits_set_short(lock_bits)                    \
+(__extension__({                                           \
+    uint8_t value = (uint8_t)(~(lock_bits));               \
+    __asm__ __volatile__                                   \
+    (                                                      \
+        "ldi r30, 1\n\t"                                   \
+        "ldi r31, 0\n\t"                                   \
+        "mov r0, %2\n\t"                                   \
+        "out %0, %1\n\t"                                   \
+        "spm\n\t"                                          \
+        :                                                  \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),                  \
+          "r" ((uint8_t)__BOOT_LOCK_BITS_SET),             \
+          "r" (value)                                      \
+        : "r0", "r30", "r31"                               \
+    );                                                     \
+}))
+
+#define __boot_lock_bits_set(lock_bits)                    \
+(__extension__({                                           \
+    uint8_t value = (uint8_t)(~(lock_bits));               \
+    __asm__ __volatile__                                   \
+    (                                                      \
+        "ldi r30, 1\n\t"                                   \
+        "ldi r31, 0\n\t"                                   \
+        "mov r0, %2\n\t"                                   \
+        "sts %0, %1\n\t"                                   \
+        "spm\n\t"                                          \
+        :                                                  \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),                  \
+          "r" ((uint8_t)__BOOT_LOCK_BITS_SET),             \
+          "r" (value)                                      \
+        : "r0", "r30", "r31"                               \
+    );                                                     \
+}))
+
+#define __boot_lock_bits_set_alternate(lock_bits)          \
+(__extension__({                                           \
+    uint8_t value = (uint8_t)(~(lock_bits));               \
+    __asm__ __volatile__                                   \
+    (                                                      \
+        "ldi r30, 1\n\t"                                   \
+        "ldi r31, 0\n\t"                                   \
+        "mov r0, %2\n\t"                                   \
+        "sts %0, %1\n\t"                                   \
+        "spm\n\t"                                          \
+        ".word 0xffff\n\t"                                 \
+        "nop\n\t"                                          \
+        :                                                  \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),                  \
+          "r" ((uint8_t)__BOOT_LOCK_BITS_SET),             \
+          "r" (value)                                      \
+        : "r0", "r30", "r31"                               \
+    );                                                     \
+}))
+
+/*
+   Reading lock and fuse bits:
+
+     Similarly to writing the lock bits above, set BLBSET and SPMEN (or 
+     SELFPRGEN) bits in __SPMREG, and then (within four clock cycles) issue an 
+     LPM instruction.
+
+     Z address:       contents:
+     0x0000           low fuse bits
+     0x0001           lock bits
+     0x0002           extended fuse bits
+     0x0003           high fuse bits
+
+     Sounds confusing, doesn't it?
+
+     Unlike the macros in pgmspace.h, no need to care for non-enhanced
+     cores here as these old cores do not provide SPM support anyway.
+ */
+
+/** \ingroup avr_boot
+    \def GET_LOW_FUSE_BITS
+    address to read the low fuse bits, using boot_lock_fuse_bits_get
+ */
+#define GET_LOW_FUSE_BITS           (0x0000)
+/** \ingroup avr_boot
+    \def GET_LOCK_BITS
+    address to read the lock bits, using boot_lock_fuse_bits_get
+ */
+#define GET_LOCK_BITS               (0x0001)
+/** \ingroup avr_boot
+    \def GET_EXTENDED_FUSE_BITS
+    address to read the extended fuse bits, using boot_lock_fuse_bits_get
+ */
+#define GET_EXTENDED_FUSE_BITS      (0x0002)
+/** \ingroup avr_boot
+    \def GET_HIGH_FUSE_BITS
+    address to read the high fuse bits, using boot_lock_fuse_bits_get
+ */
+#define GET_HIGH_FUSE_BITS          (0x0003)
+
+/** \ingroup avr_boot
+    \def boot_lock_fuse_bits_get(address)
+
+    Read the lock or fuse bits at \c address.
+
+    Parameter \c address can be any of GET_LOW_FUSE_BITS,
+    GET_LOCK_BITS, GET_EXTENDED_FUSE_BITS, or GET_HIGH_FUSE_BITS.
+
+    \note The lock and fuse bits returned are the physical values,
+    i.e. a bit returned as 0 means the corresponding fuse or lock bit
+    is programmed.
+ */
+#define boot_lock_fuse_bits_get_short(address)                   \
+(__extension__({                                           \
+    uint8_t __result;                                      \
+    __asm__ __volatile__                                   \
+    (                                                      \
+        "ldi r30, %3\n\t"                                  \
+        "ldi r31, 0\n\t"                                   \
+        "out %1, %2\n\t"                                   \
+        "lpm %0, Z\n\t"                                    \
+        : "=r" (__result)                                  \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),                  \
+          "r" ((uint8_t)__BOOT_LOCK_BITS_SET),             \
+          "M" (address)                                    \
+        : "r0", "r30", "r31"                               \
+    );                                                     \
+    __result;                                              \
+}))
+
+#define boot_lock_fuse_bits_get(address)                   \
+(__extension__({                                           \
+    uint8_t __result;                                      \
+    __asm__ __volatile__                                   \
+    (                                                      \
+        "ldi r30, %3\n\t"                                  \
+        "ldi r31, 0\n\t"                                   \
+        "sts %1, %2\n\t"                                   \
+        "lpm %0, Z\n\t"                                    \
+        : "=r" (__result)                                  \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),                  \
+          "r" ((uint8_t)__BOOT_LOCK_BITS_SET),             \
+          "M" (address)                                    \
+        : "r0", "r30", "r31"                               \
+    );                                                     \
+    __result;                                              \
+}))
+
+/** \ingroup avr_boot
+    \def boot_signature_byte_get(address)
+
+    Read the Signature Row byte at \c address.  For some MCU types,
+    this function can also retrieve the factory-stored oscillator
+    calibration bytes.
+
+    Parameter \c address can be 0-0x1f as documented by the datasheet.
+    \note The values are MCU type dependent.
+*/
+
+#define __BOOT_SIGROW_READ (_BV(__SPM_ENABLE) | _BV(SIGRD))
+
+#define boot_signature_byte_get_short(addr) \
+(__extension__({                      \
+      uint16_t __addr16 = (uint16_t)(addr);     \
+      uint8_t __result;                         \
+      __asm__ __volatile__                      \
+      (                                         \
+        "out %1, %2\n\t"                        \
+        "lpm %0, Z" "\n\t"                      \
+        : "=r" (__result)                       \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t) __BOOT_SIGROW_READ),   \
+          "z" (__addr16)                        \
+      );                                        \
+      __result;                                 \
+}))
+
+#define boot_signature_byte_get(addr) \
+(__extension__({                      \
+      uint16_t __addr16 = (uint16_t)(addr);     \
+      uint8_t __result;                         \
+      __asm__ __volatile__                      \
+      (                                         \
+        "sts %1, %2\n\t"                        \
+        "lpm %0, Z" "\n\t"                      \
+        : "=r" (__result)                       \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),       \
+          "r" ((uint8_t) __BOOT_SIGROW_READ),   \
+          "z" (__addr16)                        \
+      );                                        \
+      __result;                                 \
+}))
+
+/** \ingroup avr_boot
+    \def boot_page_fill(address, data)
+
+    Fill the bootloader temporary page buffer for flash 
+    address with data word. 
+
+    \note The address is a byte address. The data is a word. The AVR 
+    writes data to the buffer a word at a time, but addresses the buffer
+    per byte! So, increment your address by 2 between calls, and send 2
+    data bytes in a word format! The LSB of the data is written to the lower 
+    address; the MSB of the data is written to the higher address.*/
+
+/** \ingroup avr_boot
+    \def boot_page_erase(address)
+
+    Erase the flash page that contains address.
+
+    \note address is a byte address in flash, not a word address. */
+
+/** \ingroup avr_boot
+    \def boot_page_write(address)
+
+    Write the bootloader temporary page buffer 
+    to flash page that contains address.
+    
+    \note address is a byte address in flash, not a word address. */
+
+/** \ingroup avr_boot
+    \def boot_rww_enable()
+
+    Enable the Read-While-Write memory section. */
+
+/** \ingroup avr_boot
+    \def boot_lock_bits_set(lock_bits)
+
+    Set the bootloader lock bits.
+
+    \param lock_bits A mask of which Boot Loader Lock Bits to set.
+
+    \note In this context, a 'set bit' will be written to a zero value.
+    Note also that only BLBxx bits can be programmed by this command.
+
+    For example, to disallow the SPM instruction from writing to the Boot
+    Loader memory section of flash, you would use this macro as such:
+
+    \code
+    boot_lock_bits_set (_BV (BLB11));
+    \endcode
+
+    \note Like any lock bits, the Boot Loader Lock Bits, once set,
+    cannot be cleared again except by a chip erase which will in turn
+    also erase the boot loader itself. */
+
+/* Normal versions of the macros use 16-bit addresses.
+   Extended versions of the macros use 32-bit addresses.
+   Alternate versions of the macros use 16-bit addresses and require special
+   instruction sequences after LPM.
+
+   FLASHEND is defined in the ioXXXX.h file.
+   USHRT_MAX is defined in <limits.h>. */ 
+
+#if defined(__AVR_ATmega161__) || defined(__AVR_ATmega163__) \
+    || defined(__AVR_ATmega323__)
+
+/* Alternate: ATmega161/163/323 and 16 bit address */
+#define boot_page_fill(address, data) __boot_page_fill_alternate(address, data)
+#define boot_page_erase(address)      __boot_page_erase_alternate(address)
+#define boot_page_write(address)      __boot_page_write_alternate(address)
+#define boot_rww_enable()             __boot_rww_enable_alternate()
+#define boot_lock_bits_set(lock_bits) __boot_lock_bits_set_alternate(lock_bits)
+
+#elif (FLASHEND > USHRT_MAX)
+
+/* Extended: >16 bit address */
+#define boot_page_fill(address, data) __boot_page_fill_extended_short(address, data)
+#define boot_page_erase(address)      __boot_page_erase_extended_short(address)
+#define boot_page_write(address)      __boot_page_write_extended_short(address)
+#define boot_rww_enable()             __boot_rww_enable_short()
+#define boot_lock_bits_set(lock_bits) __boot_lock_bits_set_short(lock_bits)
+
+#else
+
+/* Normal: 16 bit address */
+#define boot_page_fill(address, data) __boot_page_fill_short(address, data)
+#define boot_page_erase(address)      __boot_page_erase_short(address)
+#define boot_page_write(address)      __boot_page_write_short(address)
+#define boot_rww_enable()             __boot_rww_enable_short()
+#define boot_lock_bits_set(lock_bits) __boot_lock_bits_set_short(lock_bits)
+
+#endif
+
+/** \ingroup avr_boot
+
+    Same as boot_page_fill() except it waits for eeprom and spm operations to
+    complete before filling the page. */
+
+#define boot_page_fill_safe(address, data) \
+do { \
+    boot_spm_busy_wait();                       \
+    eeprom_busy_wait();                         \
+    boot_page_fill(address, data);              \
+} while (0)
+
+/** \ingroup avr_boot
+
+    Same as boot_page_erase() except it waits for eeprom and spm operations to
+    complete before erasing the page. */
+
+#define boot_page_erase_safe(address) \
+do { \
+    boot_spm_busy_wait();                       \
+    eeprom_busy_wait();                         \
+    boot_page_erase (address);                  \
+} while (0)
+
+/** \ingroup avr_boot
+
+    Same as boot_page_write() except it waits for eeprom and spm operations to
+    complete before writing the page. */
+
+#define boot_page_write_safe(address) \
+do { \
+    boot_spm_busy_wait();                       \
+    eeprom_busy_wait();                         \
+    boot_page_write (address);                  \
+} while (0)
+
+/** \ingroup avr_boot
+
+    Same as boot_rww_enable() except waits for eeprom and spm operations to
+    complete before enabling the RWW mameory. */
+
+#define boot_rww_enable_safe() \
+do { \
+    boot_spm_busy_wait();                       \
+    eeprom_busy_wait();                         \
+    boot_rww_enable();                          \
+} while (0)
+
+/** \ingroup avr_boot
+
+    Same as boot_lock_bits_set() except waits for eeprom and spm operations to
+    complete before setting the lock bits. */
+
+#define boot_lock_bits_set_safe(lock_bits) \
+do { \
+    boot_spm_busy_wait();                       \
+    eeprom_busy_wait();                         \
+    boot_lock_bits_set (lock_bits);             \
+} while (0)
+
+#endif /* _AVR_BOOT_H_ */

BootLoaders/AtmegaMultiBoot/Source/optiboot.c

@@ -0,0 +1,891 @@
+/**********************************************************/
+/* Optiboot bootloader for Arduino                        */
+/*                                                        */
+/* http://optiboot.googlecode.com                         */
+/*                                                        */
+/* Arduino-maintained version : See README.TXT            */
+/* http://code.google.com/p/arduino/                      */
+/*  It is the intent that changes not relevant to the     */
+/*  Arduino production envionment get moved from the      */
+/*  optiboot project to the arduino project in "lumps."   */
+/*                                                        */
+/* Heavily optimised bootloader that is faster and        */
+/* smaller than the Arduino standard bootloader           */
+/*                                                        */
+/* Enhancements:                                          */
+/*   Fits in 512 bytes, saving 1.5K of code space         */
+/*   Background page erasing speeds up programming        */
+/*   Higher baud rate speeds up programming               */
+/*   Written almost entirely in C                         */
+/*   Customisable timeout with accurate timeconstant      */
+/*   Optional virtual UART. No hardware UART required.    */
+/*   Optional virtual boot partition for devices without. */
+/*                                                        */
+/* What you lose:                                         */
+/*   Implements a skeleton STK500 protocol which is       */
+/*     missing several features including EEPROM          */
+/*     programming and non-page-aligned writes            */
+/*   High baud rate breaks compatibility with standard    */
+/*     Arduino flash settings                             */
+/*                                                        */
+/* Fully supported:                                       */
+/*   ATmega168 based devices  (Diecimila etc)             */
+/*   ATmega328P based devices (Duemilanove etc)           */
+/*                                                        */
+/* Beta test (believed working.)                          */
+/*   ATmega8 based devices (Arduino legacy)               */
+/*   ATmega328 non-picopower devices                      */
+/*   ATmega644P based devices (Sanguino)                  */
+/*   ATmega1284P based devices                            */
+/*                                                        */
+/* Alpha test                                             */
+/*   ATmega1280 based devices (Arduino Mega)              */
+/*                                                        */
+/* Work in progress:                                      */
+/*   ATtiny84 based devices (Luminet)                     */
+/*                                                        */
+/* Does not support:                                      */
+/*   USB based devices (eg. Teensy)                       */
+/*                                                        */
+/* Assumptions:                                           */
+/*   The code makes several assumptions that reduce the   */
+/*   code size. They are all true after a hardware reset, */
+/*   but may not be true if the bootloader is called by   */
+/*   other means or on other hardware.                    */
+/*     No interrupts can occur                            */
+/*     UART and Timer 1 are set to their reset state      */
+/*     SP points to RAMEND                                */
+/*                                                        */
+/* Code builds on code, libraries and optimisations from: */
+/*   stk500boot.c          by Jason P. Kyle               */
+/*   Arduino bootloader    http://arduino.cc              */
+/*   Spiff's 1K bootloader http://spiffie.org/know/arduino_1k_bootloader/bootloader.shtml */
+/*   avr-libc project      http://nongnu.org/avr-libc     */
+/*   Adaboot               http://www.ladyada.net/library/arduino/bootloader.html */
+/*   AVR305                Atmel Application Note         */
+/*                                                        */
+/* This program is free software; you can redistribute it */
+/* and/or modify it under the terms of the GNU General    */
+/* Public License as published by the Free Software       */
+/* Foundation; either version 2 of the License, or        */
+/* (at your option) any later version.                    */
+/*                                                        */
+/* This program is distributed in the hope that it will   */
+/* be useful, but WITHOUT ANY WARRANTY; without even the  */
+/* implied warranty of MERCHANTABILITY or FITNESS FOR A   */
+/* PARTICULAR PURPOSE.  See the GNU General Public        */
+/* License for more details.                              */
+/*                                                        */
+/* You should have received a copy of the GNU General     */
+/* Public License along with this program; if not, write  */
+/* to the Free Software Foundation, Inc.,                 */
+/* 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA */
+/*                                                        */
+/* Licence can be viewed at                               */
+/* http://www.fsf.org/licenses/gpl.txt                    */
+/*                                                        */
+/**********************************************************/
+
+
+/**********************************************************/
+/*                                                        */
+/* Optional defines:                                      */
+/*                                                        */
+/**********************************************************/
+/*                                                        */
+/* BIG_BOOT:                                              */
+/* Build a 1k bootloader, not 512 bytes. This turns on    */
+/* extra functionality.                                   */
+/*                                                        */
+/* BAUD_RATE:                                             */
+/* Set bootloader baud rate.                              */
+/*                                                        */
+/* LUDICROUS_SPEED:                                       */
+/* 230400 baud :-)                                        */
+/*                                                        */
+/* SOFT_UART:                                             */
+/* Use AVR305 soft-UART instead of hardware UART.         */
+/*                                                        */
+/* LED_START_FLASHES:                                     */
+/* Number of LED flashes on bootup.                       */
+/*                                                        */
+/* LED_DATA_FLASH:                                        */
+/* Flash LED when transferring data. For boards without   */
+/* TX or RX LEDs, or for people who like blinky lights.   */
+/*                                                        */
+/* SUPPORT_EEPROM:                                        */
+/* Support reading and writing from EEPROM. This is not   */
+/* used by Arduino, so off by default.                    */
+/*                                                        */
+/* TIMEOUT_MS:                                            */
+/* Bootloader timeout period, in milliseconds.            */
+/* 500,1000,2000,4000,8000 supported.                     */
+/*                                                        */
+/* UART:                                                  */
+/* UART number (0..n) for devices with more than          */
+/* one hardware uart (644P, 1284P, etc)                   */
+/*                                                        */
+/**********************************************************/
+
+/**********************************************************/
+/* Version Numbers!                                       */
+/*                                                        */
+/* Arduino Optiboot now includes this Version number in   */
+/* the source and object code.                            */
+/*                                                        */
+/* Version 3 was released as zip from the optiboot        */
+/*  repository and was distributed with Arduino 0022.     */
+/* Version 4 starts with the arduino repository commit    */
+/*  that brought the arduino repository up-to-date with   */
+/* the optiboot source tree changes since v3.             */
+/*                                                        */
+/**********************************************************/
+
+/**********************************************************/
+/* Edit History:					  */
+/*							  */
+/* Nov 2012																							  */
+/* Specific version for 9x voice module									  */
+/* by Mike Blandford																		  */
+/* Mar 2012                                               */
+/* 4.5 WestfW: add infrastructure for non-zero UARTS.     */
+/* 4.5 WestfW: fix SIGNATURE_2 for m644 (bad in avr-libc) */
+/* Jan 2012:                                              */
+/* 4.5 WestfW: fix NRWW value for m1284.                  */
+/* 4.4 WestfW: use attribute OS_main instead of naked for */
+/*             main().  This allows optimizations that we */
+/*             count on, which are prohibited in naked    */
+/*             functions due to PR42240.  (keeps us less  */
+/*             than 512 bytes when compiler is gcc4.5     */
+/*             (code from 4.3.2 remains the same.)        */
+/* 4.4 WestfW and Maniacbug:  Add m1284 support.  This    */
+/*             does not change the 328 binary, so the     */
+/*             version number didn't change either. (?)   */
+/* June 2011:                                             */
+/* 4.4 WestfW: remove automatic soft_uart detect (didn't  */
+/*             know what it was doing or why.)  Added a   */
+/*             check of the calculated BRG value instead. */
+/*             Version stays 4.4; existing binaries are   */
+/*             not changed.                               */
+/* 4.4 WestfW: add initialization of address to keep      */
+/*             the compiler happy.  Change SC'ed targets. */
+/*             Return the SW version via READ PARAM       */
+/* 4.3 WestfW: catch framing errors in getch(), so that   */
+/*             AVRISP works without HW kludges.           */
+/*  http://code.google.com/p/arduino/issues/detail?id=368n*/
+/* 4.2 WestfW: reduce code size, fix timeouts, change     */
+/*             verifySpace to use WDT instead of appstart */
+/* 4.1 WestfW: put version number in binary.		  */
+/**********************************************************/
+
+#define OPTIBOOT_MAJVER 4
+#define OPTIBOOT_MINVER 5
+
+#define MULTI_CALLED	1
+
+#define MAKESTR(a) #a
+#define MAKEVER(a, b) MAKESTR(a*256+b)
+
+//asm("  .section .version\n"
+//    "optiboot_version:  .word " MAKEVER(OPTIBOOT_MAJVER, OPTIBOOT_MINVER) "\n"
+//    "  .section .text\n");
+
+#include <inttypes.h>
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+
+// <avr/boot.h> uses sts instructions, but this version uses out instructions
+// This saves cycles and program memory.
+#include "boot.h"
+
+
+// We don't use <avr/wdt.h> as those routines have interrupt overhead we don't need.
+
+#include "pin_defs.h"
+#include "stk500.h"
+
+#ifndef LED_START_FLASHES
+#define LED_START_FLASHES 0
+#endif
+
+#ifdef LUDICROUS_SPEED
+#define BAUD_RATE 230400L
+#endif
+
+/* set the UART baud rate defaults */
+#ifndef BAUD_RATE
+#if F_CPU >= 8000000L
+#define BAUD_RATE   38400L // Highest rate Avrdude win32 will support
+#elsif F_CPU >= 1000000L
+#define BAUD_RATE   9600L   // 19200 also supported, but with significant error
+#elsif F_CPU >= 128000L
+#define BAUD_RATE   4800L   // Good for 128kHz internal RC
+#else
+#define BAUD_RATE 1200L     // Good even at 32768Hz
+#endif
+#endif
+
+#ifndef UART
+#define UART 0
+#endif
+
+#if 0
+/* Switch in soft UART for hard baud rates */
+/*
+ * I don't understand what this was supposed to accomplish, where the
+ * constant "280" came from, or why automatically (and perhaps unexpectedly)
+ * switching to a soft uart is a good thing, so I'm undoing this in favor
+ * of a range check using the same calc used to config the BRG...
+ */
+#if (F_CPU/BAUD_RATE) > 280 // > 57600 for 16MHz
+#ifndef SOFT_UART
+#define SOFT_UART
+#endif
+#endif
+#else // 0
+#if (F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1 > 250
+#error Unachievable baud rate (too slow) BAUD_RATE 
+#endif // baud rate slow check
+#if (F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1 < 3
+#error Unachievable baud rate (too fast) BAUD_RATE 
+#endif // baud rate fastn check
+#endif
+
+/* Watchdog settings */
+#define WATCHDOG_OFF    (0)
+#define WATCHDOG_16MS   (_BV(WDE))
+#define WATCHDOG_32MS   (_BV(WDP0) | _BV(WDE))
+#define WATCHDOG_64MS   (_BV(WDP1) | _BV(WDE))
+#define WATCHDOG_125MS  (_BV(WDP1) | _BV(WDP0) | _BV(WDE))
+#define WATCHDOG_250MS  (_BV(WDP2) | _BV(WDE))
+#define WATCHDOG_500MS  (_BV(WDP2) | _BV(WDP0) | _BV(WDE))
+#define WATCHDOG_1S     (_BV(WDP2) | _BV(WDP1) | _BV(WDE))
+#define WATCHDOG_2S     (_BV(WDP2) | _BV(WDP1) | _BV(WDP0) | _BV(WDE))
+#ifndef __AVR_ATmega8__
+#define WATCHDOG_4S     (_BV(WDP3) | _BV(WDE))
+#define WATCHDOG_8S     (_BV(WDP3) | _BV(WDP0) | _BV(WDE))
+#endif
+
+/* Function Prototypes */
+/* The main function is in init9, which removes the interrupt vector table */
+/* we don't need. It is also 'naked', which means the compiler does not    */
+/* generate any entry or exit code itself. */
+int main(void) __attribute__ ((OS_main)) __attribute__ ((noreturn)) __attribute__ ((section (".init9")));
+void putch(char);
+uint8_t getch(void);
+static inline void getNch(uint8_t); /* "static inline" is a compiler hint to reduce code size */
+void verifySpace();
+#if LED_START_FLASHES > 0
+static inline void flash_led(uint8_t);
+#endif
+uint8_t getLen();
+//static inline void watchdogReset();
+void watchdogConfig(uint8_t x);
+#ifdef SOFT_UART
+void uartDelay() __attribute__ ((naked));
+#endif
+static void appStart() ; // __attribute__ ((naked));
+
+/*
+ * NRWW memory
+ * Addresses below NRWW (Non-Read-While-Write) can be programmed while
+ * continuing to run code from flash, slightly speeding up programming
+ * time.  Beware that Atmel data sheets specify this as a WORD address,
+ * while optiboot will be comparing against a 16-bit byte address.  This
+ * means that on a part with 128kB of memory, the upper part of the lower
+ * 64k will get NRWW processing as well, even though it doesn't need it.
+ * That's OK.  In fact, you can disable the overlapping processing for
+ * a part entirely by setting NRWWSTART to zero.  This reduces code
+ * space a bit, at the expense of being slightly slower, overall.
+ *
+ * RAMSTART should be self-explanatory.  It's bigger on parts with a
+ * lot of peripheral registers.
+ */
+#if defined(__AVR_ATmega168__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0x3800)
+#elif defined(__AVR_ATmega328P__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0x7000)
+#elif defined(__AVR_ATmega328__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0x7000)
+#elif defined (__AVR_ATmega644P__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0xE000)
+// correct for a bug in avr-libc
+#undef SIGNATURE_2
+#define SIGNATURE_2 0x0A
+#elif defined (__AVR_ATmega1284P__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0xE000)
+#elif defined(__AVR_ATtiny84__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0x0000)
+#elif defined(__AVR_ATmega1280__)
+#define RAMSTART (0x200)
+#define NRWWSTART (0xE000)
+#elif defined(__AVR_ATmega8__) || defined(__AVR_ATmega88__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0x1800)
+#endif
+
+/* C zero initialises all global variables. However, that requires */
+/* These definitions are NOT zero initialised, but that doesn't matter */
+/* This allows us to drop the zero init code, saving us memory */
+#define buff    ((uint8_t*)(RAMSTART))
+#ifdef VIRTUAL_BOOT_PARTITION
+#define rstVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+4))
+#define wdtVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+6))
+#endif
+
+/*
+ * Handle devices with up to 4 uarts (eg m1280.)  Rather inelegantly.
+ * Note that mega8 still needs special handling, because ubrr is handled
+ * differently.
+ */
+#if UART == 0
+# define UART_SRA UCSR0A
+# define UART_SRB UCSR0B
+# define UART_SRC UCSR0C
+# define UART_SRL UBRR0L
+# define UART_UDR UDR0
+#elif UART == 1
+# define UART_SRA UCSR1A
+# define UART_SRB UCSR1B
+# define UART_SRC UCSR1C
+# define UART_SRL UBRR1L
+# define UART_UDR UDR1
+#elif UART == 2
+# define UART_SRA UCSR2A
+# define UART_SRB UCSR2B
+# define UART_SRC UCSR2C
+# define UART_SRL UBRR2L
+# define UART_UDR UDR2
+#elif UART == 3
+# define UART_SRA UCSR3A
+# define UART_SRB UCSR3B
+# define UART_SRC UCSR3C
+# define UART_SRL UBRR3L
+# define UART_UDR UDR3
+#endif
+
+/* main program starts here */
+int main(void) {
+  uint8_t ch;
+
+  /*
+   * Making these local and in registers prevents the need for initializing
+   * them, and also saves space because code no longer stores to memory.
+   * (initializing address keeps the compiler happy, but isn't really
+   *  necessary, and uses 4 bytes of flash.)
+   */
+  register uint16_t address = 0;
+
+  // After the zero init loop, this is the first code to run.
+  //
+  // This code makes the following assumptions:
+  //  No interrupts will execute
+  //  SP points to RAMEND
+  //  r1 contains zero
+  //
+  // If not, uncomment the following instructions:
+  // cli();
+  asm volatile ("clr __zero_reg__");
+#ifdef __AVR_ATmega8__
+  SP=RAMEND;  // This is done by hardware reset
+#endif
+
+  // Adaboot no-wait mod
+  ch = MCUSR;
+  MCUSR = 0;
+
+	// Here, if power on, wait 0.5 secs, then check for
+	// serial Rx signal low, if so, stay in bootloader
+	// else go to application
+
+	PORTD = 0xFF ;
+	PORTB = 0x3C ;
+	PORTC = 1 ;
+
+  if (ch & (_BV(PORF) | (_BV(EXTRF)) ) )
+	{
+#ifdef MULTI_CALLED
+#if F_CPU == 12000000L
+		TCNT1H = 256 - 8 ;
+#else
+ #if F_CPU == 16000000L
+		TCNT1H = 256 - 6 ;
+ #else
+		TCNT1H = 256 - 127 ;
+ #endif
+		TCNT1L = 0 ;
+ #endif
+#else
+#if F_CPU == 12000000L
+		TCNT1 = 65535-5859 ;
+#else
+ #if F_CPU == 16000000L
+		TCNT1 = 65535-7813 ;
+ #else
+		TCNT1 = 65535-32767 ;
+ #endif
+#endif
+#endif
+		
+  	TCCR1B = _BV(CS12) | _BV(CS10); // div 1024
+    TIFR1 = _BV(TOV1);
+    while(!(TIFR1 & _BV(TOV1)))
+			;
+  	TCCR1B = 0 ; // Stop timer
+		uint8_t x ;
+		x = PINB & 0x3C ;
+		x |= PINC & 1 ;
+		if ( x != 0x1D )                                                      
+		{
+			appStart() ;	// Power on, go to voice application
+										// if loaded
+		}
+	}
+
+#if LED_START_FLASHES > 0
+  // Set up Timer 1 for timeout counter
+  TCCR1B = _BV(CS12) | _BV(CS10); // div 1024
+#endif
+
+#ifndef SOFT_UART
+  UART_SRA = _BV(U2X0); //Double speed mode USART0
+  UART_SRB = _BV(RXEN0) | _BV(TXEN0);
+  UART_SRC = _BV(UCSZ00) | _BV(UCSZ01);
+//  UART_SRL = (uint8_t)( (F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1 );
+// Baudrate of 57600
+#if F_CPU == 12000000L
+  UART_SRL = 25 ;
+#else
+#if F_CPU == 16000000L
+  UART_SRL = 33 ;
+#else
+#ERROR Baud rate not available
+#endif
+#endif
+
+#endif
+
+  // Set up watchdog to trigger after 500ms
+
+
+//  watchdogConfig(WATCHDOG_1S);
+
+  /* Set LED pin as output */
+  LED_DDR |= _BV(LED);
+
+#ifdef SOFT_UART
+  /* Set TX pin as output */
+  UART_DDR |= _BV(UART_TX_BIT);
+#endif
+
+#if LED_START_FLASHES > 0
+  /* Flash onboard LED to signal entering of bootloader */
+  flash_led(LED_START_FLASHES * 2);
+#endif
+
+  /* Forever loop */
+  for (;;)
+	{
+    /* get character from UART */
+    ch = getch();
+
+    if(ch == STK_GET_PARAMETER)
+		{
+      GPIOR0 = getch();
+      verifySpace();
+      if (GPIOR0 == 0x82)
+			{
+	/*
+	 * Send optiboot version as "minor SW version"
+	 */
+				putch(OPTIBOOT_MINVER);
+      }
+			else if (GPIOR0 == 0x81)
+			{
+	  		putch(OPTIBOOT_MAJVER);
+      }
+			else
+			{
+	/*
+	 * GET PARAMETER returns a generic 0x03 reply for
+         * other parameters - enough to keep Avrdude happy
+	 */
+				putch(0x03);
+      }
+    }
+    else if(ch == STK_SET_DEVICE) {
+      // SET DEVICE is ignored
+      getNch(20);
+    }
+    else if(ch == STK_SET_DEVICE_EXT)
+		{
+     // SET DEVICE EXT is ignored
+      getNch(5);
+    }
+    else if(ch == STK_LOAD_ADDRESS)
+		{
+      // LOAD ADDRESS
+      uint16_t newAddress;
+      newAddress = getch() ;
+      newAddress = (newAddress & 0xff) | (getch() << 8);
+#ifdef RAMPZ
+      // Transfer top bit to RAMPZ
+      RAMPZ = (newAddress & 0x8000) ? 1 : 0;
+#endif
+      newAddress += newAddress; // Convert from word address to byte address
+      address = newAddress;
+      verifySpace();
+    }
+    else if(ch == STK_UNIVERSAL)
+		{
+      // UNIVERSAL command is ignored
+      getNch(4);
+      putch(0x00);
+    }
+    /* Write memory, length is big endian and is in bytes */
+    else if(ch == STK_PROG_PAGE)
+		{
+      // PROGRAM PAGE - we support flash programming only, not EEPROM
+      uint8_t *bufPtr;
+      uint16_t addrPtr;
+  		register uint8_t  length;
+
+      getch();			/* getlen() */
+      length = getch();
+      getch();
+
+			// If we are in RWW section, immediately start page erase
+      if (address < NRWWSTART) __boot_page_erase_short((uint16_t)(void*)address);
+
+      // While that is going on, read in page contents
+      bufPtr = buff;
+      do *bufPtr++ = getch();
+      while (--length);
+
+      // If we are in NRWW section, page erase has to be delayed until now.
+      // Todo: Take RAMPZ into account
+#ifdef MULTI_CALLED
+      if (address < 0x7E00)
+#endif
+      {
+	      if (address >= NRWWSTART) __boot_page_erase_short((uint16_t)(void*)address);
+			}
+      // Read command terminator, start reply
+      verifySpace();
+
+      // If only a partial page is to be programmed, the erase might not be complete.
+      // So check that here
+#ifdef MULTI_CALLED
+      if (address < 0x7E00)
+#endif
+      {
+	      boot_spm_busy_wait();
+
+#ifdef VIRTUAL_BOOT_PARTITION
+      	if ((uint16_t)(void*)address == 0) {
+      	  // This is the reset vector page. We need to live-patch the code so the
+      	  // bootloader runs.
+      	  //
+      	  // Move RESET vector to WDT vector
+      	  uint16_t vect = buff[0] | (buff[1]<<8);
+      	  rstVect = vect;
+      	  wdtVect = buff[8] | (buff[9]<<8);
+      	  vect -= 4; // Instruction is a relative jump (rjmp), so recalculate.
+      	  buff[8] = vect & 0xff;
+      	  buff[9] = vect >> 8;
+
+      	  // Add jump to bootloader at RESET vector
+      	  buff[0] = 0x7f;
+      	  buff[1] = 0xce; // rjmp 0x1d00 instruction
+      	}
+#endif
+
+      // Copy buffer into programming buffer
+      	bufPtr = buff;
+      	addrPtr = (uint16_t)(void*)address;
+      	ch = SPM_PAGESIZE / 2;
+      	do {
+      	  uint16_t a;
+	//        a = *bufPtr++;
+	//        a |= (*bufPtr++) << 8;
+
+					a = *((uint16_t *)bufPtr) ;
+					bufPtr += 2 ;
+
+      	  __boot_page_fill_short((uint16_t)(void*)addrPtr,a);
+      	  addrPtr += 2;
+      	} while (--ch);
+
+      // Write from programming buffer
+      	__boot_page_write_short((uint16_t)(void*)address);
+    	  boot_spm_busy_wait();
+
+#if defined(RWWSRE)
+  	    // Reenable read access to flash
+	      boot_rww_enable();
+#endif
+			}
+    }
+    /* Read memory block mode, length is big endian.  */
+    else if(ch == STK_READ_PAGE)
+		{
+		  register uint8_t  length;
+      // READ PAGE - we only read flash
+      getch();			/* getlen() */
+      length = getch();
+      getch();
+
+      verifySpace();
+#ifdef VIRTUAL_BOOT_PARTITION
+      do {
+        // Undo vector patch in bottom page so verify passes
+        if (address == 0)       ch=rstVect & 0xff;
+        else if (address == 1)  ch=rstVect >> 8;
+        else if (address == 8)  ch=wdtVect & 0xff;
+        else if (address == 9) ch=wdtVect >> 8;
+        else ch = pgm_read_byte_near(address);
+        address++;
+        putch(ch);
+      } while (--length);
+#else
+#ifdef RAMPZ
+// Since RAMPZ should already be set, we need to use EPLM directly.
+//      do putch(pgm_read_byte_near(address++));
+//      while (--length);
+      do {
+        uint8_t result;
+        __asm__ ("elpm %0,Z\n":"=r"(result):"z"(address));
+        putch(result);
+        address++;
+      }
+      while (--length);
+#else
+      do putch(pgm_read_byte_near(address++));
+      while (--length);
+#endif
+#endif
+    }
+
+    /* Get device signature bytes  */
+    else if(ch == STK_READ_SIGN)
+		{
+      // READ SIGN - return what Avrdude wants to hear
+      verifySpace();
+      putch(SIGNATURE_0);
+      putch(SIGNATURE_1);
+      putch(SIGNATURE_2);
+    }
+    else if (ch == STK_LEAVE_PROGMODE) { /* 'Q' */
+      // Adaboot no-wait mod
+
+//      watchdogConfig(WATCHDOG_16MS);
+      
+			verifySpace();
+#ifdef MULTI_CALLED
+	    putch(STK_OK);
+		  while (!(UART_SRA & _BV(TXC0)));
+			appStart() ;
+#endif
+    }
+    else
+		{
+      // This covers the response to commands like STK_ENTER_PROGMODE
+      verifySpace();
+    }
+    putch(STK_OK);
+  }
+}
+
+void putch(char ch) {
+#ifndef SOFT_UART
+  while (!(UART_SRA & _BV(UDRE0)));
+  UART_UDR = ch;
+#else
+  __asm__ __volatile__ (
+    "   com %[ch]\n" // ones complement, carry set
+    "   sec\n"
+    "1: brcc 2f\n"
+    "   cbi %[uartPort],%[uartBit]\n"
+    "   rjmp 3f\n"
+    "2: sbi %[uartPort],%[uartBit]\n"
+    "   nop\n"
+    "3: rcall uartDelay\n"
+    "   rcall uartDelay\n"
+    "   lsr %[ch]\n"
+    "   dec %[bitcnt]\n"
+    "   brne 1b\n"
+    :
+    :
+      [bitcnt] "d" (10),
+      [ch] "r" (ch),
+      [uartPort] "I" (_SFR_IO_ADDR(UART_PORT)),
+      [uartBit] "I" (UART_TX_BIT)
+    :
+      "r25"
+  );
+#endif
+}
+
+uint8_t getch(void) {
+  uint8_t ch;
+
+#ifdef LED_DATA_FLASH
+#ifdef __AVR_ATmega8__
+  LED_PORT ^= _BV(LED);
+#else
+  LED_PIN |= _BV(LED);
+#endif
+#endif
+
+#ifdef SOFT_UART
+  __asm__ __volatile__ (
+    "1: sbic  %[uartPin],%[uartBit]\n"  // Wait for start edge
+    "   rjmp  1b\n"
+    "   rcall uartDelay\n"          // Get to middle of start bit
+    "2: rcall uartDelay\n"              // Wait 1 bit period
+    "   rcall uartDelay\n"              // Wait 1 bit period
+    "   clc\n"
+    "   sbic  %[uartPin],%[uartBit]\n"
+    "   sec\n"
+    "   dec   %[bitCnt]\n"
+    "   breq  3f\n"
+    "   ror   %[ch]\n"
+    "   rjmp  2b\n"
+    "3:\n"
+    :
+      [ch] "=r" (ch)
+    :
+      [bitCnt] "d" (9),
+      [uartPin] "I" (_SFR_IO_ADDR(UART_PIN)),
+      [uartBit] "I" (UART_RX_BIT)
+    :
+      "r25"
+);
+#else
+  while(!(UART_SRA & _BV(RXC0)))
+		
+//		watchdogReset()
+    
+		;
+//  if (!(UART_SRA & _BV(FE0))) {
+      /*
+       * A Framing Error indicates (probably) that something is talking
+       * to us at the wrong bit rate.  Assume that this is because it
+       * expects to be talking to the application, and DON'T reset the
+       * watchdog.  This should cause the bootloader to abort and run
+       * the application "soon", if it keeps happening.  (Note that we
+       * don't care that an invalid char is returned...)
+       */
+//    watchdogReset();
+//  }
+
+  ch = UART_UDR;
+#endif
+
+#ifdef LED_DATA_FLASH
+#ifdef __AVR_ATmega8__
+  LED_PORT ^= _BV(LED);
+#else
+  LED_PIN |= _BV(LED);
+#endif
+#endif
+
+  return ch;
+}
+
+#ifdef SOFT_UART
+// AVR305 equation: #define UART_B_VALUE (((F_CPU/BAUD_RATE)-23)/6)
+// Adding 3 to numerator simulates nearest rounding for more accurate baud rates
+#define UART_B_VALUE (((F_CPU/BAUD_RATE)-20)/6)
+#if UART_B_VALUE > 255
+#error Baud rate too slow for soft UART
+#endif
+
+void uartDelay() {
+  __asm__ __volatile__ (
+    "ldi r25,%[count]\n"
+    "1:dec r25\n"
+    "brne 1b\n"
+    "ret\n"
+    ::[count] "M" (UART_B_VALUE)
+  );
+}
+#endif
+
+void getNch(uint8_t count) {
+  do getch(); while (--count);
+  verifySpace();
+}
+
+void verifySpace()
+{
+  if ( getch() != CRC_EOP) {
+    
+  	putch(STK_NOSYNC);
+//		watchdogConfig(WATCHDOG_16MS);    // shorten WD timeout
+//    
+//		while (1)			      // and busy-loop so that WD causes
+//      ;				      //  a reset and app start.
+  }
+  putch(STK_INSYNC);
+}
+
+#if LED_START_FLASHES > 0
+void flash_led(uint8_t count) {
+  do {
+    TCNT1 = -(F_CPU/(1024*16));
+    TIFR1 = _BV(TOV1);
+    while(!(TIFR1 & _BV(TOV1)));
+//#ifdef __AVR_ATmega8__
+    LED_PORT ^= _BV(LED);
+//#else
+//    LED_PIN |= _BV(LED);
+//#endif
+    watchdogReset();
+  } while (--count);
+}
+#endif
+
+// Watchdog functions. These are only safe with interrupts turned off.
+void watchdogReset() {
+  __asm__ __volatile__ (
+    "wdr\n"
+  );
+}
+
+void watchdogConfig(uint8_t x) {
+  WDTCSR = _BV(WDCE) | _BV(WDE);
+  WDTCSR = x;
+}
+
+void appStart()
+{
+//  watchdogConfig(WATCHDOG_OFF);
+//  __asm__ __volatile__ (
+//#ifdef VIRTUAL_BOOT_PARTITION
+//    // Jump to WDT vector
+//    "ldi r30,4\n"
+//    "clr r31\n"
+//#else
+//    // Jump to RST vector
+//    "clr r30\n"
+//    "clr r31\n"
+//#endif
+//    "ijmp\n"
+//  );
+
+	register void (*p)() ;
+	p = 0 ;
+
+	if ( pgm_read_byte( (uint16_t)p ) != 0xFF )
+	{
+		(*p)() ;
+	}
+}
+

BootLoaders/AtmegaMultiBoot/Source/pin_defs.h

@@ -0,0 +1,80 @@
+#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega88) || defined(__AVR_ATmega8__) || defined(__AVR_ATmega88__)
+/* Onboard LED is connected to pin PB5 in Arduino NG, Diecimila, and Duemilanove */ 
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED         PINB5
+
+/* Ports for soft UART */
+#ifdef SOFT_UART
+#define UART_PORT   PORTD
+#define UART_PIN    PIND
+#define UART_DDR    DDRD
+#define UART_TX_BIT 1
+#define UART_RX_BIT 0
+#endif
+#endif
+
+#if defined(__AVR_ATmega8__)
+  //Name conversion R.Wiersma
+  #define UCSR0A	UCSRA
+  #define UDR0 		UDR
+  #define UDRE0 	UDRE
+  #define RXC0		RXC
+  #define FE0           FE
+  #define TIFR1 	TIFR
+  #define WDTCSR	WDTCR
+#endif
+
+/* Luminet support */
+#if defined(__AVR_ATtiny84__)
+/* Red LED is connected to pin PA4 */ 
+#define LED_DDR     DDRA
+#define LED_PORT    PORTA
+#define LED_PIN     PINA
+#define LED         PINA4
+/* Ports for soft UART - left port only for now. TX/RX on PA2/PA3 */
+#ifdef SOFT_UART
+#define UART_PORT   PORTA
+#define UART_PIN    PINA
+#define UART_DDR    DDRA
+#define UART_TX_BIT 2
+#define UART_RX_BIT 3
+#endif
+#endif
+
+/* Sanguino support */
+#if defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__)
+/* Onboard LED is connected to pin PB0 on Sanguino */ 
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED         PINB0
+
+/* Ports for soft UART */
+#ifdef SOFT_UART
+#define UART_PORT   PORTD
+#define UART_PIN    PIND
+#define UART_DDR    DDRD
+#define UART_TX_BIT 1
+#define UART_RX_BIT 0
+#endif
+#endif
+
+/* Mega support */
+#if defined(__AVR_ATmega1280__)
+/* Onboard LED is connected to pin PB7 on Arduino Mega */ 
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED         PINB7
+
+/* Ports for soft UART */
+#ifdef SOFT_UART
+#define UART_PORT   PORTE
+#define UART_PIN    PINE
+#define UART_DDR    DDRE
+#define UART_TX_BIT 1
+#define UART_RX_BIT 0
+#endif
+#endif

BootLoaders/AtmegaMultiBoot/Source/stk500.h

@@ -0,0 +1,39 @@
+/* STK500 constants list, from AVRDUDE */
+#define STK_OK              0x10
+#define STK_FAILED          0x11  // Not used
+#define STK_UNKNOWN         0x12  // Not used
+#define STK_NODEVICE        0x13  // Not used
+#define STK_INSYNC          0x14  // ' '
+#define STK_NOSYNC          0x15  // Not used
+#define ADC_CHANNEL_ERROR   0x16  // Not used
+#define ADC_MEASURE_OK      0x17  // Not used
+#define PWM_CHANNEL_ERROR   0x18  // Not used
+#define PWM_ADJUST_OK       0x19  // Not used
+#define CRC_EOP             0x20  // 'SPACE'
+#define STK_GET_SYNC        0x30  // '0'
+#define STK_GET_SIGN_ON     0x31  // '1'
+#define STK_SET_PARAMETER   0x40  // '@'
+#define STK_GET_PARAMETER   0x41  // 'A'
+#define STK_SET_DEVICE      0x42  // 'B'
+#define STK_SET_DEVICE_EXT  0x45  // 'E'
+#define STK_ENTER_PROGMODE  0x50  // 'P'
+#define STK_LEAVE_PROGMODE  0x51  // 'Q'
+#define STK_CHIP_ERASE      0x52  // 'R'
+#define STK_CHECK_AUTOINC   0x53  // 'S'
+#define STK_LOAD_ADDRESS    0x55  // 'U'
+#define STK_UNIVERSAL       0x56  // 'V'
+#define STK_PROG_FLASH      0x60  // '`'
+#define STK_PROG_DATA       0x61  // 'a'
+#define STK_PROG_FUSE       0x62  // 'b'
+#define STK_PROG_LOCK       0x63  // 'c'
+#define STK_PROG_PAGE       0x64  // 'd'
+#define STK_PROG_FUSE_EXT   0x65  // 'e'
+#define STK_READ_FLASH      0x70  // 'p'
+#define STK_READ_DATA       0x71  // 'q'
+#define STK_READ_FUSE       0x72  // 'r'
+#define STK_READ_LOCK       0x73  // 's'
+#define STK_READ_PAGE       0x74  // 't'
+#define STK_READ_SIGN       0x75  // 'u'
+#define STK_READ_OSCCAL     0x76  // 'v'
+#define STK_READ_FUSE_EXT   0x77  // 'w'
+#define STK_READ_OSCCAL_EXT 0x78  // 'x'

BootLoaders/Boards/Linux/45-maple.rules

@@ -0,0 +1,5 @@
+ATTRS{idProduct}=="1001", ATTRS{idVendor}=="0110", MODE="664", GROUP="plugdev"
+ATTRS{idProduct}=="1002", ATTRS{idVendor}=="0110", MODE="664", GROUP="plugdev"
+ATTRS{idProduct}=="0003", ATTRS{idVendor}=="1eaf", MODE="664", GROUP="plugdev" SYMLINK+="maple", ENV{ID_MM_DEVICE_IGNORE}="1"
+ATTRS{idProduct}=="0004", ATTRS{idVendor}=="1eaf", MODE="664", GROUP="plugdev" SYMLINK+="maple", ENV{ID_MM_DEVICE_IGNORE}="1"
+

BootLoaders/Boards/Windows/install_drivers.bat

@@ -0,0 +1,11 @@
+@echo off
+
+echo Installing MULTI-Module DFU Bootloader Driver...
+"%~dp0wdi-simple" --vid 0x1EAF --pid 0x0003 --type 2 --name "MULTI-Module DFU Bootloader" --dest "%~dp0MULTI-DFU-Bootloader" -b
+echo.
+
+echo Installing MULTI-Module USB Serial Driver...
+"%~dp0wdi-simple" --vid 0x1EAF --pid 0x0004 --type 3 --name "MULTI-Module USB Serial" --dest "%~dp0MULTI-USB-Serial" -b
+echo.
+
+pause

BootLoaders/OrangeMultiBoot/OrangeMultiBoot.hex

@@ -0,0 +1,47 @@
+:108000001F92CDB7DEB7CFD01124809178009FEFBB
+:1080100090937800837099F088EA91E680936808DD
+:108020009093690880E180934C0880914C0884FF0C
+:10803000FCCF109240088091680682FD8FD082E0CC
+:1080400080936106C12CD12C97D0813479F494D0DF
+:10805000898399D08981823811F485E005C08138FF
+:1080600011F484E001C083E080D075C0823411F443
+:1080700084E103C0853419F485E08CD06CC085356B
+:1080800059F47AD0C82E78D0D12CD82A8D2D881FBB
+:108090008827881F8BBF5EC0863521F484E07AD0A4
+:1080A00080E0E2CF843641F567D066D0F82E64D008
+:1080B000C601DCD000E010E25FD0F80181938F01AF
+:1080C000FE12FACF60D0D7FC46C0CBD0C601DAD0C2
+:1080D000760100E010E2F801619171918F01C70112
+:1080E000DBD0F2E0EF0EF11C011581E2180799F7E1
+:1080F000C601E0D0B6D02FC08437C1F43DD03CD00B
+:10810000F82E3AD040D0F601EC2CEF0C8F010F5F27
+:108110001F4F84912AD0E01207C0EFEFCE1ADE0A7B
+:10812000FA94CF0CD11C17C0F801F0CF853739F481
+:108130002AD08EE11AD085E918D082E495CF813516
+:1081400049F421D080E111D08091A10886FFFCCFB5
+:1081500005D001C018D080E108D076CFE0E0F0E093
+:1081600084918F3F09F0099408959091A10895FF9B
+:10817000FCCF8093A00808958091A10887FFFCCFD1
+:108180008091A0080895F8DF803211F085E1EDDFDD
+:1081900084E1EBCFCF93C82FEFDFC150E9F7CF9148
+:1081A000F2CFA895089583EC8093520080915000FF
+:1081B0008860809350008091510083FFFCCF82EC57
+:1081C0008093550080915000806180935000809191
+:1081D000510084FFFCCF88ED84BF1092400084BF23
+:1081E00024E02093400087E08093A20087E88093FA
+:1081F0008301109241081092420810924308109295
+:10820000440810924608109247088FEF9FEF809322
+:1082100066089093670810926008109261088BE0DE
+:1082200080934008209365062093620688E180933E
+:10823000720698E0909345069093410692E29093DF
+:10824000A6081092A7088093A4088091A3088F7CA9
+:1082500080618093A30883E08093A5088091A008A3
+:1082600008958091CF0187FDFCCF08958F939F9350
+:1082700082E2E0ECF1E08287FF91EF918DE984BF2B
+:10828000E8950895FC0186E28093CA0188ED84BFD9
+:1082900081E08093CB0108950F921F92FC01062E7E
+:1082A000172E83E28093CA018DE984BFE8951F9061
+:1082B0000F900895FC018EE28093CA018DE984BF7E
+:0482C000E8950895A0
+:040000030000800079
+:00000001FF

BootLoaders/OrangeMultiBoot/Source/Makefile

@@ -0,0 +1,503 @@
+# Makefile for ATmegaBOOT
+# E.Lins, 18.7.2005
+# $Id$
+#
+# Instructions
+#
+# To make bootloader .hex file:
+# make diecimila
+# make lilypad
+# make ng
+# etc...
+#
+# To burn bootloader .hex file:
+# make diecimila_isp
+# make lilypad_isp
+# make ng_isp
+# etc...
+
+# program name should not be changed...
+PROGRAM    = optiboot
+
+# The default behavior is to build using tools that are in the users
+# current path variables, but we can also build using an installed
+# Arduino user IDE setup, or the Arduino source tree.
+# Uncomment this next lines to build within the arduino environment,
+# using the arduino-included avrgcc toolset (mac and pc)
+# ENV ?= arduino
+# ENV ?= arduinodev
+# OS ?= macosx
+# OS ?= windows
+
+
+# enter the parameters for the avrdude isp tool  -b19200
+#
+# These are the parameters for a usb-based STK500v2 programmer.
+# Exact type unknown.  (historical Makefile values.)
+ISPTOOL	   = stk500v2
+ISPPORT	   =  usb
+ISPSPEED   = -b 57600
+#
+#
+# These are parameters for using an Arduino with the ArduinoISP sketch
+#  as the programmer.  On a mac, for a particular Uno as programmer.
+#ISPTOOL	= stk500v1 -C /Applications/arduino/arduino-0022/hardware/tools/avr/etc/avrdude.conf
+#ISPPORT	= /dev/tty.usbmodemfd3141 
+#ISPSPEED	= -b19200
+
+MCU_TARGET = atmega168
+LDSECTIONS  = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
+
+# Build environments
+# Start of some ugly makefile-isms to allow optiboot to be built
+# in several different environments.  See the README.TXT file for
+# details.
+
+# default
+fixpath = $(1)
+
+ifeq ($(ENV), arduino)
+# For Arduino, we assume that we're connected to the optiboot directory
+# included with the arduino distribution, which means that the full set
+# of avr-tools are "right up there" in standard places.
+TOOLROOT = ../../../tools
+GCCROOT = $(TOOLROOT)/avr/bin/
+AVRDUDE_CONF = -C$(TOOLROOT)/avr/etc/avrdude.conf
+
+ifeq ($(OS), windows)
+# On windows, SOME of the tool paths will need to have backslashes instead
+# of forward slashes (because they use windows cmd.exe for execution instead
+# of a unix/mingw shell?)  We also have to ensure that a consistent shell
+# is used even if a unix shell is installed (ie as part of WINAVR)
+fixpath = $(subst /,\,$1)
+SHELL = cmd.exe
+endif
+
+else ifeq ($(ENV), arduinodev)
+# Arduino IDE source code environment.  Use the unpacked compilers created
+# by the build (you'll need to do "ant build" first.)
+ifeq ($(OS), macosx)
+TOOLROOT = ../../../../build/macosx/work/Arduino.app/Contents/Resources/Java/hardware/tools
+endif
+ifeq ($(OS), windows)
+TOOLROOT = ../../../../build/windows/work/hardware/tools
+endif
+
+GCCROOT = $(TOOLROOT)/avr/bin/
+AVRDUDE_CONF = -C$(TOOLROOT)/avr/etc/avrdude.conf
+
+else
+GCCROOT =
+AVRDUDE_CONF =
+endif
+#
+# End of build environment code.
+
+
+# the efuse should really be 0xf8; since, however, only the lower
+# three bits of that byte are used on the atmega168, avrdude gets
+# confused if you specify 1's for the higher bits, see:
+# http://tinker.it/now/2007/02/24/the-tale-of-avrdude-atmega168-and-extended-bits-fuses/
+#
+# similarly, the lock bits should be 0xff instead of 0x3f (to
+# unlock the bootloader section) and 0xcf instead of 0x2f (to
+# lock it), but since the high two bits of the lock byte are
+# unused, avrdude would get confused.
+
+ISPFUSES    = $(GCCROOT)avrdude $(AVRDUDE_CONF) -c $(ISPTOOL) \
+              -p $(MCU_TARGET) -P $(ISPPORT) $(ISPSPEED) \
+              -e -u -U lock:w:0x3f:m -U efuse:w:0x$(EFUSE):m \
+              -U hfuse:w:0x$(HFUSE):m -U lfuse:w:0x$(LFUSE):m
+ISPFLASH    = $(GCCROOT)avrdude $(AVRDUDE_CONF) -c $(ISPTOOL) \
+              -p $(MCU_TARGET) -P $(ISPPORT) $(ISPSPEED) \
+              -U flash:w:$(PROGRAM)_$(TARGET).hex -U lock:w:0x2f:m
+
+STK500 = "C:\Program Files\Atmel\AVR Tools\STK500\Stk500.exe"
+STK500-1 = $(STK500) -e -d$(MCU_TARGET) -pf -vf -if$(PROGRAM)_$(TARGET).hex \
+-lFF -LFF -f$(HFUSE)$(LFUSE) -EF8 -ms -q -cUSB -I200kHz -s -wt
+STK500-2 = $(STK500) -d$(MCU_TARGET) -ms -q -lCF -LCF -cUSB -I200kHz -s -wt
+
+OBJ        = $(PROGRAM).o
+OPTIMIZE = -Os -fno-inline-small-functions -fno-split-wide-types
+# -mshort-calls
+
+DEFS       = 
+LIBS       =
+
+CC         = $(GCCROOT)avr-gcc
+
+# Override is only needed by avr-lib build system.
+
+override CFLAGS        = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) -DF_CPU=$(AVR_FREQ) $(DEFS)
+override LDFLAGS       = $(LDSECTIONS) -Wl,--relax -Wl,--gc-sections -nostartfiles -nostdlib
+
+OBJCOPY        = $(GCCROOT)avr-objcopy
+OBJDUMP        = $(call fixpath,$(GCCROOT)avr-objdump)
+
+SIZE           = $(GCCROOT)avr-size
+
+
+
+#Voice board test
+# ATmega328
+#
+#atmega328: TARGET = atmega328p
+#atmega328: MCU_TARGET = atmega328p
+#atmega328: CFLAGS += '-DLED_START_FLASHES=0' '-DBAUD_RATE=38400'
+#atmega328: AVR_FREQ = 12000000L 
+#atmega328: LDSECTIONS  = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
+#atmega328: $(PROGRAM)_atmega328.hex
+#atmega328: $(PROGRAM)_atmega328.lst
+
+xmega32D4: TARGET = atxmega32d4
+xmega32D4: MCU_TARGET = atxmega32d4
+xmega32D4: CFLAGS += '-DLED_START_FLASHES=0' '-DBAUD_RATE=57600'
+xmega32D4: AVR_FREQ = 32000000L 
+xmega32D4: LDSECTIONS  = -Wl,--section-start=.text=0x8000
+xmega32D4: $(PROGRAM)_xmega32d4.hex
+xmega32D4: $(PROGRAM)_xmega32d4.lst
+
+atmega328: TARGET = atmega328
+atmega328: MCU_TARGET = atmega328p
+atmega328: CFLAGS += '-DLED_START_FLASHES=0' '-DBAUD_RATE=57600'
+atmega328: AVR_FREQ = 16000000L
+atmega328: LDSECTIONS  = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
+atmega328: $(PROGRAM)_atmega328_16.hex
+atmega328: $(PROGRAM)_atmega328_16.lst
+
+
+# Test platforms
+# Virtual boot block test
+virboot328: TARGET = atmega328
+virboot328: MCU_TARGET = atmega328p
+virboot328: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400' '-DVIRTUAL_BOOT'
+virboot328: AVR_FREQ = 16000000L
+virboot328: LDSECTIONS  = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
+virboot328: $(PROGRAM)_atmega328.hex
+virboot328: $(PROGRAM)_atmega328.lst
+
+# 20MHz clocked platforms
+#
+# These are capable of 230400 baud, or 38400 baud on PC (Arduino Avrdude issue)
+#
+
+pro20: TARGET = pro_20mhz
+pro20: MCU_TARGET = atmega168
+pro20: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+pro20: AVR_FREQ = 20000000L
+pro20: $(PROGRAM)_pro_20mhz.hex
+pro20: $(PROGRAM)_pro_20mhz.lst
+
+pro20_isp: pro20
+pro20_isp: TARGET = pro_20mhz
+# 2.7V brownout
+pro20_isp: HFUSE = DD
+# Full swing xtal (20MHz) 258CK/14CK+4.1ms
+pro20_isp: LFUSE = C6
+# 512 byte boot
+pro20_isp: EFUSE = 04
+pro20_isp: isp
+
+# 16MHz clocked platforms
+#
+# These are capable of 230400 baud, or 38400 baud on PC (Arduino Avrdude issue)
+#
+
+pro16: TARGET = pro_16MHz
+pro16: MCU_TARGET = atmega168
+pro16: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+pro16: AVR_FREQ = 16000000L
+pro16: $(PROGRAM)_pro_16MHz.hex
+pro16: $(PROGRAM)_pro_16MHz.lst
+
+pro16_isp: pro16
+pro16_isp: TARGET = pro_16MHz
+# 2.7V brownout
+pro16_isp: HFUSE = DD
+# Full swing xtal (20MHz) 258CK/14CK+4.1ms
+pro16_isp: LFUSE = C6
+# 512 byte boot
+pro16_isp: EFUSE = 04
+pro16_isp: isp
+
+# Diecimila, Duemilanove with m168, and NG use identical bootloaders
+# Call it "atmega168" for generality and clarity, keep "diecimila" for
+# backward compatibility of makefile
+#
+atmega168: TARGET = atmega168
+atmega168: MCU_TARGET = atmega168
+atmega168: CFLAGS += '-DLED_START_FLASHES=0' '-DBAUD_RATE=38400'
+atmega168: AVR_FREQ = 12000000L 
+atmega168: $(PROGRAM)_atmega168.hex
+atmega168: $(PROGRAM)_atmega168.lst
+
+atmega168_isp: atmega168
+atmega168_isp: TARGET = atmega168
+# 2.7V brownout
+atmega168_isp: HFUSE = DD
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+atmega168_isp: LFUSE = FF
+# 512 byte boot
+atmega168_isp: EFUSE = 04
+atmega168_isp: isp
+
+diecimila: TARGET = diecimila
+diecimila: MCU_TARGET = atmega168
+diecimila: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+diecimila: AVR_FREQ = 16000000L 
+diecimila: $(PROGRAM)_diecimila.hex
+diecimila: $(PROGRAM)_diecimila.lst
+
+diecimila_isp: diecimila
+diecimila_isp: TARGET = diecimila
+# 2.7V brownout
+diecimila_isp: HFUSE = DD
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+diecimila_isp: LFUSE = FF
+# 512 byte boot
+diecimila_isp: EFUSE = 04
+diecimila_isp: isp
+
+atmega328_isp: atmega328
+atmega328_isp: TARGET = atmega328
+atmega328_isp: MCU_TARGET = atmega328p
+# 512 byte boot, SPIEN
+atmega328_isp: HFUSE = DE
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+atmega328_isp: LFUSE = FF
+# 2.7V brownout
+atmega328_isp: EFUSE = FD
+atmega328_isp: isp
+
+atmega1284: TARGET = atmega1284p
+atmega1284: MCU_TARGET = atmega1284p
+atmega1284: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400' '-DBIGBOOT'
+atmega1284: AVR_FREQ = 16000000L
+atmega1284: LDSECTIONS  = -Wl,--section-start=.text=0x1fc00 -Wl,--section-start=.version=0x1fffe
+atmega1284: $(PROGRAM)_atmega1284p.hex
+atmega1284: $(PROGRAM)_atmega1284p.lst
+
+atmega1284_isp: atmega1284
+atmega1284_isp: TARGET = atmega1284p
+atmega1284_isp: MCU_TARGET = atmega1284p
+# 1024 byte boot
+atmega1284_isp: HFUSE = DE
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+atmega1284_isp: LFUSE = FF
+# 2.7V brownout
+atmega1284_isp: EFUSE = FD
+atmega1284_isp: isp
+
+# Sanguino has a minimum boot size of 1024 bytes, so enable extra functions
+#
+sanguino: TARGET = atmega644p
+sanguino: MCU_TARGET = atmega644p
+sanguino: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400' '-DBIGBOOT'
+sanguino: AVR_FREQ = 16000000L
+sanguino: LDSECTIONS  = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
+sanguino: $(PROGRAM)_atmega644p.hex
+sanguino: $(PROGRAM)_atmega644p.lst
+
+sanguino_isp: sanguino
+sanguino_isp: TARGET = atmega644p
+sanguino_isp: MCU_TARGET = atmega644p
+# 1024 byte boot
+sanguino_isp: HFUSE = DE
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+sanguino_isp: LFUSE = FF
+# 2.7V brownout
+sanguino_isp: EFUSE = FD
+sanguino_isp: isp
+
+# Mega has a minimum boot size of 1024 bytes, so enable extra functions
+#mega: TARGET = atmega1280
+mega1280: MCU_TARGET = atmega1280
+mega1280: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400' '-DBIGBOOT'
+mega1280: AVR_FREQ = 16000000L
+mega1280: LDSECTIONS  = -Wl,--section-start=.text=0x1fc00  -Wl,--section-start=.version=0x1fffe
+mega1280: $(PROGRAM)_atmega1280.hex
+mega1280: $(PROGRAM)_atmega1280.lst
+
+mega1280_isp: mega
+mega1280_isp: TARGET = atmega1280
+mega1280_isp: MCU_TARGET = atmega1280
+# 1024 byte boot
+mega1280_isp: HFUSE = DE
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+mega1280_isp: LFUSE = FF
+# 2.7V brownout
+mega1280_isp: EFUSE = FD
+mega1280_isp: isp
+
+# ATmega8
+#
+atmega8: TARGET = atmega8
+atmega8: MCU_TARGET = atmega8
+atmega8: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+atmega8: AVR_FREQ = 16000000L 
+atmega8: LDSECTIONS  = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe
+atmega8: $(PROGRAM)_atmega8.hex
+atmega8: $(PROGRAM)_atmega8.lst
+
+atmega8_isp: atmega8
+atmega8_isp: TARGET = atmega8
+atmega8_isp: MCU_TARGET = atmega8
+# SPIEN, CKOPT, Bootsize=512B
+atmega8_isp: HFUSE = CC
+# 2.7V brownout, Low power xtal (16MHz) 16KCK/14CK+65ms
+atmega8_isp: LFUSE = BF
+atmega8_isp: isp
+
+# ATmega88
+#
+atmega88: TARGET = atmega88
+atmega88: MCU_TARGET = atmega88
+atmega88: CFLAGS += '-DLED_START_FLASHES=0' '-DBAUD_RATE=38400'
+atmega88: AVR_FREQ = 12000000L 
+atmega88: LDSECTIONS  = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe
+atmega88: $(PROGRAM)_atmega88.hex
+atmega88: $(PROGRAM)_atmega88.lst
+
+atmega88_isp: atmega88
+atmega88_isp: TARGET = atmega88
+atmega88_isp: MCU_TARGET = atmega88
+# 2.7V brownout
+atmega88_isp: HFUSE = DD
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+atemga88_isp: LFUSE = FF
+# 512 byte boot
+atmega88_isp: EFUSE = 04
+atmega88_isp: isp
+
+
+# 8MHz clocked platforms
+#
+# These are capable of 38400 baud
+#
+
+lilypad: TARGET = lilypad
+lilypad: MCU_TARGET = atmega168
+lilypad: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+lilypad: AVR_FREQ = 8000000L
+lilypad: $(PROGRAM)_lilypad.hex
+lilypad: $(PROGRAM)_lilypad.lst
+
+lilypad_isp: lilypad
+lilypad_isp: TARGET = lilypad
+# 2.7V brownout
+lilypad_isp: HFUSE = DD
+# Internal 8MHz osc (8MHz) Slow rising power
+lilypad_isp: LFUSE = E2
+# 512 byte boot
+lilypad_isp: EFUSE = 04
+lilypad_isp: isp
+
+lilypad_resonator: TARGET = lilypad_resonator
+lilypad_resonator: MCU_TARGET = atmega168
+lilypad_resonator: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+lilypad_resonator: AVR_FREQ = 8000000L
+lilypad_resonator: $(PROGRAM)_lilypad_resonator.hex
+lilypad_resonator: $(PROGRAM)_lilypad_resonator.lst
+
+lilypad_resonator_isp: lilypad_resonator
+lilypad_resonator_isp: TARGET = lilypad_resonator
+# 2.7V brownout
+lilypad_resonator_isp: HFUSE = DD
+# Full swing xtal (20MHz) 258CK/14CK+4.1ms
+lilypad_resonator_isp: LFUSE = C6
+# 512 byte boot
+lilypad_resonator_isp: EFUSE = 04
+lilypad_resonator_isp: isp
+
+pro8: TARGET = pro_8MHz
+pro8: MCU_TARGET = atmega168
+pro8: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+pro8: AVR_FREQ = 8000000L
+pro8: $(PROGRAM)_pro_8MHz.hex
+pro8: $(PROGRAM)_pro_8MHz.lst
+
+pro8_isp: pro8
+pro8_isp: TARGET = pro_8MHz
+# 2.7V brownout
+pro8_isp: HFUSE = DD
+# Full swing xtal (20MHz) 258CK/14CK+4.1ms
+pro8_isp: LFUSE = C6
+# 512 byte boot
+pro8_isp: EFUSE = 04
+pro8_isp: isp
+
+atmega328_pro8: TARGET = atmega328_pro_8MHz
+atmega328_pro8: MCU_TARGET = atmega328p
+atmega328_pro8: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=38400'
+atmega328_pro8: AVR_FREQ = 8000000L
+atmega328_pro8: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
+atmega328_pro8: $(PROGRAM)_atmega328_pro_8MHz.hex
+atmega328_pro8: $(PROGRAM)_atmega328_pro_8MHz.lst
+
+atmega328_pro8_isp: atmega328_pro8
+atmega328_pro8_isp: TARGET = atmega328_pro_8MHz
+atmega328_pro8_isp: MCU_TARGET = atmega328p
+# 512 byte boot, SPIEN
+atmega328_pro8_isp: HFUSE = DE
+# Low power xtal (16MHz) 16KCK/14CK+65ms
+atmega328_pro8_isp: LFUSE = FF
+# 2.7V brownout
+atmega328_pro8_isp: EFUSE = DE
+atmega328_pro8_isp: isp
+
+# 1MHz clocked platforms
+#
+# These are capable of 9600 baud
+#
+
+luminet: TARGET = luminet
+luminet: MCU_TARGET = attiny84
+luminet: CFLAGS += '-DLED_START_FLASHES=3' '-DSOFT_UART' '-DBAUD_RATE=9600'
+luminet: CFLAGS += '-DVIRTUAL_BOOT_PARTITION'
+luminet: AVR_FREQ = 1000000L
+luminet: LDSECTIONS = -Wl,--section-start=.text=0x1d00 -Wl,--section-start=.version=0x1efe
+luminet: $(PROGRAM)_luminet.hex
+luminet: $(PROGRAM)_luminet.lst
+
+luminet_isp: luminet
+luminet_isp: TARGET = luminet
+luminet_isp: MCU_TARGET = attiny84
+# Brownout disabled
+luminet_isp: HFUSE = DF
+# 1MHz internal oscillator, slowly rising power
+luminet_isp: LFUSE = 62
+# Self-programming enable
+luminet_isp: EFUSE = FE
+luminet_isp: isp
+
+#
+# Generic build instructions
+#
+#
+
+isp: $(TARGET)
+	$(ISPFUSES)
+	$(ISPFLASH)
+
+isp-stk500: $(PROGRAM)_$(TARGET).hex
+	$(STK500-1)
+	$(STK500-2)
+
+%.elf: $(OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)
+	$(SIZE) $@
+
+clean:
+	rm -rf *.o *.elf *.lst *.map *.sym *.lss *.eep *.srec *.bin *.hex
+
+%.lst: %.elf
+	$(OBJDUMP) -h -S $< > $@
+
+%.hex: %.elf
+	$(OBJCOPY) -j .text -j .data -j .version --set-section-flags .version=alloc,load -O ihex $< $@
+
+%.srec: %.elf
+	$(OBJCOPY) -j .text -j .data -j .version --set-section-flags .version=alloc,load -O srec $< $@
+
+%.bin: %.elf
+	$(OBJCOPY) -j .text -j .data -j .version --set-section-flags .version=alloc,load -O binary $< $@

BootLoaders/OrangeMultiBoot/Source/optiboot.c

@@ -0,0 +1,980 @@
+/**********************************************************/
+/* Optiboot bootloader for Xmega                          */
+/*                                                        */
+/* http://optiboot.googlecode.com                         */
+/*                                                        */
+/* Arduino-maintained version : See README.TXT            */
+/* http://code.google.com/p/arduino/                      */
+/*  It is the intent that changes not relevant to the     */
+/*  Arduino production envionment get moved from the      */
+/*  optiboot project to the arduino project in "lumps."   */
+/*                                                        */
+/* Heavily optimised bootloader that is faster and        */
+/* smaller than the Arduino standard bootloader           */
+/*                                                        */
+/* Enhancements:                                          */
+/*   Fits in 512 bytes, saving 1.5K of code space         */
+/*   Background page erasing speeds up programming        */
+/*   Higher baud rate speeds up programming               */
+/*   Written almost entirely in C                         */
+/*   Customisable timeout with accurate timeconstant      */
+/*   Optional virtual UART. No hardware UART required.    */
+/*   Optional virtual boot partition for devices without. */
+/*                                                        */
+/* What you lose:                                         */
+/*   Implements a skeleton STK500 protocol which is       */
+/*     missing several features including EEPROM          */
+/*     programming and non-page-aligned writes            */
+/*   High baud rate breaks compatibility with standard    */
+/*     Arduino flash settings                             */
+/*                                                        */
+/* Fully supported:                                       */
+/*   ATmega168 based devices  (Diecimila etc)             */
+/*   ATmega328P based devices (Duemilanove etc)           */
+/*                                                        */
+/* Beta test (believed working.)                          */
+/*   ATmega8 based devices (Arduino legacy)               */
+/*   ATmega328 non-picopower devices                      */
+/*   ATmega644P based devices (Sanguino)                  */
+/*   ATmega1284P based devices                            */
+/*                                                        */
+/* Alpha test                                             */
+/*   ATmega1280 based devices (Arduino Mega)              */
+/*                                                        */
+/* Work in progress:                                      */
+/*   ATtiny84 based devices (Luminet)                     */
+/*                                                        */
+/* Does not support:                                      */
+/*   USB based devices (eg. Teensy)                       */
+/*                                                        */
+/* Assumptions:                                           */
+/*   The code makes several assumptions that reduce the   */
+/*   code size. They are all true after a hardware reset, */
+/*   but may not be true if the bootloader is called by   */
+/*   other means or on other hardware.                    */
+/*     No interrupts can occur                            */
+/*     UART and Timer 1 are set to their reset state      */
+/*     SP points to RAMEND                                */
+/*                                                        */
+/* Code builds on code, libraries and optimisations from: */
+/*   stk500boot.c          by Jason P. Kyle               */
+/*   Arduino bootloader    http://arduino.cc              */
+/*   Spiff's 1K bootloader http://spiffie.org/know/arduino_1k_bootloader/bootloader.shtml */
+/*   avr-libc project      http://nongnu.org/avr-libc     */
+/*   Adaboot               http://www.ladyada.net/library/arduino/bootloader.html */
+/*   AVR305                Atmel Application Note         */
+/*                                                        */
+/* This program is free software; you can redistribute it */
+/* and/or modify it under the terms of the GNU General    */
+/* Public License as published by the Free Software       */
+/* Foundation; either version 2 of the License, or        */
+/* (at your option) any later version.                    */
+/*                                                        */
+/* This program is distributed in the hope that it will   */
+/* be useful, but WITHOUT ANY WARRANTY; without even the  */
+/* implied warranty of MERCHANTABILITY or FITNESS FOR A   */
+/* PARTICULAR PURPOSE.  See the GNU General Public        */
+/* License for more details.                              */
+/*                                                        */
+/* You should have received a copy of the GNU General     */
+/* Public License along with this program; if not, write  */
+/* to the Free Software Foundation, Inc.,                 */
+/* 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA */
+/*                                                        */
+/* Licence can be viewed at                               */
+/* http://www.fsf.org/licenses/gpl.txt                    */
+/*                                                        */
+/**********************************************************/
+
+
+/**********************************************************/
+/*                                                        */
+/* Optional defines:                                      */
+/*                                                        */
+/**********************************************************/
+/*                                                        */
+/* BIG_BOOT:                                              */
+/* Build a 1k bootloader, not 512 bytes. This turns on    */
+/* extra functionality.                                   */
+/*                                                        */
+/* BAUD_RATE:                                             */
+/* Set bootloader baud rate.                              */
+/*                                                        */
+/* LUDICROUS_SPEED:                                       */
+/* 230400 baud :-)                                        */
+/*                                                        */
+/* SOFT_UART:                                             */
+/* Use AVR305 soft-UART instead of hardware UART.         */
+/*                                                        */
+/* LED_START_FLASHES:                                     */
+/* Number of LED flashes on bootup.                       */
+/*                                                        */
+/* LED_DATA_FLASH:                                        */
+/* Flash LED when transferring data. For boards without   */
+/* TX or RX LEDs, or for people who like blinky lights.   */
+/*                                                        */
+/* SUPPORT_EEPROM:                                        */
+/* Support reading and writing from EEPROM. This is not   */
+/* used by Arduino, so off by default.                    */
+/*                                                        */
+/* TIMEOUT_MS:                                            */
+/* Bootloader timeout period, in milliseconds.            */
+/* 500,1000,2000,4000,8000 supported.                     */
+/*                                                        */
+/* UART:                                                  */
+/* UART number (0..n) for devices with more than          */
+/* one hardware uart (644P, 1284P, etc)                   */
+/*                                                        */
+/**********************************************************/
+
+/**********************************************************/
+/* Version Numbers!                                       */
+/*                                                        */
+/* Arduino Optiboot now includes this Version number in   */
+/* the source and object code.                            */
+/*                                                        */
+/* Version 3 was released as zip from the optiboot        */
+/*  repository and was distributed with Arduino 0022.     */
+/* Version 4 starts with the arduino repository commit    */
+/*  that brought the arduino repository up-to-date with   */
+/* the optiboot source tree changes since v3.             */
+/*                                                        */
+/**********************************************************/
+
+/**********************************************************/
+/* Edit History:					  */
+/*							  */
+/* Nov 2012																							  */
+/* Specific version for 9x voice module									  */
+/* by Mike Blandford																		  */
+/* Mar 2012                                               */
+/* 4.5 WestfW: add infrastructure for non-zero UARTS.     */
+/* 4.5 WestfW: fix SIGNATURE_2 for m644 (bad in avr-libc) */
+/* Jan 2012:                                              */
+/* 4.5 WestfW: fix NRWW value for m1284.                  */
+/* 4.4 WestfW: use attribute OS_main instead of naked for */
+/*             main().  This allows optimizations that we */
+/*             count on, which are prohibited in naked    */
+/*             functions due to PR42240.  (keeps us less  */
+/*             than 512 bytes when compiler is gcc4.5     */
+/*             (code from 4.3.2 remains the same.)        */
+/* 4.4 WestfW and Maniacbug:  Add m1284 support.  This    */
+/*             does not change the 328 binary, so the     */
+/*             version number didn't change either. (?)   */
+/* June 2011:                                             */
+/* 4.4 WestfW: remove automatic soft_uart detect (didn't  */
+/*             know what it was doing or why.)  Added a   */
+/*             check of the calculated BRG value instead. */
+/*             Version stays 4.4; existing binaries are   */
+/*             not changed.                               */
+/* 4.4 WestfW: add initialization of address to keep      */
+/*             the compiler happy.  Change SC'ed targets. */
+/*             Return the SW version via READ PARAM       */
+/* 4.3 WestfW: catch framing errors in getch(), so that   */
+/*             AVRISP works without HW kludges.           */
+/*  http://code.google.com/p/arduino/issues/detail?id=368n*/
+/* 4.2 WestfW: reduce code size, fix timeouts, change     */
+/*             verifySpace to use WDT instead of appstart */
+/* 4.1 WestfW: put version number in binary.		  */
+/**********************************************************/
+
+#define OPTIBOOT_MAJVER 4
+#define OPTIBOOT_MINVER 5
+
+#define MULTI_CALLED	1
+
+#define MAKESTR(a) #a
+#define MAKEVER(a, b) MAKESTR(a*256+b)
+
+// Page Size is 128 words (256 bytes)
+
+//asm("  .section .version\n"
+//    "optiboot_version:  .word " MAKEVER(OPTIBOOT_MAJVER, OPTIBOOT_MINVER) "\n"
+//    "  .section .text\n");
+
+#include <inttypes.h>
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+
+// <avr/boot.h> uses sts instructions, but this version uses out instructions
+// This saves cycles and program memory.
+//#include "boot.h"
+
+
+// We don't use <avr/wdt.h> as those routines have interrupt overhead we don't need.
+
+#include "pin_defs.h"
+#include "stk500.h"
+
+#define BIND_pin			2						//PD2
+#define BIND_port			PORTD
+#define IS_BIND_BUTTON_on	( (BIND_port.IN & _BV(BIND_pin)) == 0x00 )
+
+#ifndef LED_START_FLASHES
+#define LED_START_FLASHES 0
+#endif
+
+#ifdef LUDICROUS_SPEED
+#define BAUD_RATE 230400L
+#endif
+
+/* set the UART baud rate defaults */
+#ifndef BAUD_RATE
+#if F_CPU >= 8000000L
+#define BAUD_RATE   38400L // Highest rate Avrdude win32 will support
+#elsif F_CPU >= 1000000L
+#define BAUD_RATE   9600L   // 19200 also supported, but with significant error
+#elsif F_CPU >= 128000L
+#define BAUD_RATE   4800L   // Good for 128kHz internal RC
+#else
+#define BAUD_RATE 1200L     // Good even at 32768Hz
+#endif
+#endif
+
+#ifndef UART
+#define UART 0
+#endif
+
+#if 0
+/* Switch in soft UART for hard baud rates */
+/*
+ * I don't understand what this was supposed to accomplish, where the
+ * constant "280" came from, or why automatically (and perhaps unexpectedly)
+ * switching to a soft uart is a good thing, so I'm undoing this in favor
+ * of a range check using the same calc used to config the BRG...
+ */
+#if (F_CPU/BAUD_RATE) > 280 // > 57600 for 16MHz
+#ifndef SOFT_UART
+#define SOFT_UART
+#endif
+#endif
+#else // 0
+#if (F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1 > 250
+#error Unachievable baud rate (too slow) BAUD_RATE 
+#endif // baud rate slow check
+#if (F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1 < 3
+#error Unachievable baud rate (too fast) BAUD_RATE 
+#endif // baud rate fastn check
+#endif
+
+/* Watchdog settings */
+#define WATCHDOG_OFF    (0)
+#define WATCHDOG_16MS   (_BV(WDE))
+#define WATCHDOG_32MS   (_BV(WDP0) | _BV(WDE))
+#define WATCHDOG_64MS   (_BV(WDP1) | _BV(WDE))
+#define WATCHDOG_125MS  (_BV(WDP1) | _BV(WDP0) | _BV(WDE))
+#define WATCHDOG_250MS  (_BV(WDP2) | _BV(WDE))
+#define WATCHDOG_500MS  (_BV(WDP2) | _BV(WDP0) | _BV(WDE))
+#define WATCHDOG_1S     (_BV(WDP2) | _BV(WDP1) | _BV(WDE))
+#define WATCHDOG_2S     (_BV(WDP2) | _BV(WDP1) | _BV(WDP0) | _BV(WDE))
+#ifndef __AVR_ATmega8__
+#define WATCHDOG_4S     (_BV(WDP3) | _BV(WDE))
+#define WATCHDOG_8S     (_BV(WDP3) | _BV(WDP0) | _BV(WDE))
+#endif
+
+/* Function Prototypes */
+/* The main function is in init9, which removes the interrupt vector table */
+/* we don't need. It is also 'naked', which means the compiler does not    */
+/* generate any entry or exit code itself. */
+int main(void) __attribute__ ((OS_main)) __attribute__ ((noreturn)) __attribute__ ((section (".init9")));
+void putch(char);
+uint8_t getch(void);
+static inline void getNch(uint8_t); /* "static inline" is a compiler hint to reduce code size */
+void verifySpace();
+#if LED_START_FLASHES > 0
+static inline void flash_led(uint8_t);
+#endif
+uint8_t getLen();
+//static inline void watchdogReset();
+void watchdogConfig(uint8_t x);
+#ifdef SOFT_UART
+void uartDelay() __attribute__ ((naked));
+#endif
+static void appStart() ; // __attribute__ ((naked));
+void boot_spm_busy_wait() ;
+void __boot_page_erase_short( uint16_t address ) ;
+void __boot_page_fill_short( uint16_t address, uint16_t data) ;
+void __boot_page_write_short( uint16_t address) ;
+void __boot_erase_flash_buffer( uint16_t address ) ;
+void init() ;
+
+/*
+ * NRWW memory
+ * Addresses below NRWW (Non-Read-While-Write) can be programmed while
+ * continuing to run code from flash, slightly speeding up programming
+ * time.  Beware that Atmel data sheets specify this as a WORD address,
+ * while optiboot will be comparing against a 16-bit byte address.  This
+ * means that on a part with 128kB of memory, the upper part of the lower
+ * 64k will get NRWW processing as well, even though it doesn't need it.
+ * That's OK.  In fact, you can disable the overlapping processing for
+ * a part entirely by setting NRWWSTART to zero.  This reduces code
+ * space a bit, at the expense of being slightly slower, overall.
+ *
+ * RAMSTART should be self-explanatory.  It's bigger on parts with a
+ * lot of peripheral registers.
+ */
+#if defined(__AVR_ATmega168__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0x3800)
+#elif defined(__AVR_ATmega328P__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0x7000)
+#elif defined(__AVR_ATmega328__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0x7000)
+#elif defined (__AVR_ATmega644P__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0xE000)
+// correct for a bug in avr-libc
+#undef SIGNATURE_2
+#define SIGNATURE_2 0x0A
+#elif defined (__AVR_ATmega1284P__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0xE000)
+#elif defined(__AVR_ATtiny84__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0x0000)
+#elif defined(__AVR_ATmega1280__)
+#define RAMSTART (0x200)
+#define NRWWSTART (0xE000)
+#elif defined(__AVR_ATmega8__) || defined(__AVR_ATmega88__)
+#define RAMSTART (0x100)
+#define NRWWSTART (0x1800)
+#endif
+
+/* C zero initialises all global variables. However, that requires */
+/* These definitions are NOT zero initialised, but that doesn't matter */
+/* This allows us to drop the zero init code, saving us memory */
+#define buff    ((uint8_t*)(RAMSTART))
+#ifdef VIRTUAL_BOOT_PARTITION
+#define rstVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+4))
+#define wdtVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+6))
+#endif
+
+/*
+ * Handle devices with up to 4 uarts (eg m1280.)  Rather inelegantly.
+ * Note that mega8 still needs special handling, because ubrr is handled
+ * differently.
+ */
+#if UART == 0
+# define UART_SRA UCSR0A
+# define UART_SRB UCSR0B
+# define UART_SRC UCSR0C
+# define UART_SRL UBRR0L
+# define UART_UDR UDR0
+#elif UART == 1
+# define UART_SRA UCSR1A
+# define UART_SRB UCSR1B
+# define UART_SRC UCSR1C
+# define UART_SRL UBRR1L
+# define UART_UDR UDR1
+#elif UART == 2
+# define UART_SRA UCSR2A
+# define UART_SRB UCSR2B
+# define UART_SRC UCSR2C
+# define UART_SRL UBRR2L
+# define UART_UDR UDR2
+#elif UART == 3
+# define UART_SRA UCSR3A
+# define UART_SRB UCSR3B
+# define UART_SRC UCSR3C
+# define UART_SRL UBRR3L
+# define UART_UDR UDR3
+#endif
+
+
+/* main program starts here */
+int main(void)
+{
+  uint8_t ch;
+  uint8_t byte ;
+
+  /*
+   * Making these local and in registers prevents the need for initializing
+   * them, and also saves space because code no longer stores to memory.
+   * (initializing address keeps the compiler happy, but isn't really
+   *  necessary, and uses 4 bytes of flash.)
+   */
+  register uint16_t address = 0;
+	init() ;
+
+  // After the zero init loop, this is the first code to run.
+  //
+  // This code makes the following assumptions:
+  //  No interrupts will execute
+  //  SP points to RAMEND
+  //  r1 contains zero
+  //
+  // If not, uncomment the following instructions:
+  // cli();
+  asm volatile ("clr __zero_reg__");
+
+  ch = RST.STATUS ;
+  RST.STATUS = 0xFF ;	// Clear all flags
+
+	// Here, if power on, wait 0.1 secs, then check for
+	// serial Rx signal low, if so, stay in bootloader
+	// else go to application
+
+  if (ch & (RST_EXTRF_bm | RST_PORF_bm ) )
+	{
+		TCC1.CCA = 25000 ;
+		TCC1.INTFLAGS = TC1_CCAIF_bm ;
+
+    while(!(TCC1.INTFLAGS & TC1_CCAIF_bm))
+			;
+		TCC1.CTRLA = 0 ;	// Stop timer
+		
+		uint8_t x ;
+		x = PORTD.IN & 0x04 ;
+		if ( x != 0 )                                                      
+		{
+			appStart() ;	// Power on, go to app if loaded
+		}
+	}
+
+
+//#ifndef SOFT_UART
+//  UART_SRA = _BV(U2X0); //Double speed mode USART0
+//  UART_SRB = _BV(RXEN0) | _BV(TXEN0);
+//  UART_SRC = _BV(UCSZ00) | _BV(UCSZ01);
+////  UART_SRL = (uint8_t)( (F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1 );
+//// Baudrate of 57600
+//#if F_CPU == 12000000L
+//  UART_SRL = 25 ;
+//#else
+//#if F_CPU == 16000000L
+//  UART_SRL = 33 ;
+//#else
+//#ERROR Baud rate not available
+//#endif
+//#endif
+
+//#endif
+
+  // Set up watchdog to trigger after 500ms
+
+
+//  watchdogConfig(WATCHDOG_1S);
+
+  /* Set LED pin as output */
+#define LED_pin		1								//PD1
+#define LED_port	PORTD
+	LED_port.DIRSET	= _BV(LED_pin) ;
+
+//#ifdef SOFT_UART
+//  /* Set TX pin as output */
+//  UART_DDR |= _BV(UART_TX_BIT);
+//#endif
+
+//#if LED_START_FLASHES > 0
+//  /* Flash onboard LED to signal entering of bootloader */
+//  flash_led(LED_START_FLASHES * 2);
+//#endif
+
+  /* Forever loop */
+  for (;;)
+	{
+    /* get character from UART */
+    ch = getch();
+
+    if(ch == STK_GET_PARAMETER)
+		{
+      byte = getch();
+      verifySpace();
+      if ( byte == 0x82)
+			{
+	/*
+	 * Send optiboot version as "minor SW version"
+	 */
+				putch(OPTIBOOT_MINVER);
+      }
+			else if ( byte == 0x81)
+			{
+	  		putch(OPTIBOOT_MAJVER);
+      }
+			else
+			{
+	/*
+	 * GET PARAMETER returns a generic 0x03 reply for
+         * other parameters - enough to keep Avrdude happy
+	 */
+				putch(0x03);
+      }
+    }
+    else if(ch == STK_SET_DEVICE) {
+      // SET DEVICE is ignored
+      getNch(20);
+    }
+    else if(ch == STK_SET_DEVICE_EXT)
+		{
+     // SET DEVICE EXT is ignored
+      getNch(5);
+    }
+    else if(ch == STK_LOAD_ADDRESS)
+		{
+      // LOAD ADDRESS
+      uint16_t newAddress;
+      newAddress = getch() ;
+      newAddress = (newAddress & 0xff) | (getch() << 8);
+#ifdef RAMPZ
+      // Transfer top bit to RAMPZ
+      RAMPZ = (newAddress & 0x8000) ? 1 : 0;
+#endif
+//      newAddress += newAddress; // Convert from word address to byte address
+      address = newAddress;
+      verifySpace();
+    }
+    else if(ch == STK_UNIVERSAL)
+		{
+      // UNIVERSAL command is ignored
+      getNch(4);
+      putch(0x00);
+    }
+    /* Write memory, length is big endian and is in bytes */
+    else if(ch == STK_PROG_PAGE)
+		{
+      // PROGRAM PAGE - we support flash programming only, not EEPROM
+      uint8_t *bufPtr;
+      uint16_t addrPtr;
+  		register uint8_t  length;
+
+      getch();			/* getlen() */
+      length = getch();
+      getch();
+
+			// If we are in RWW section, immediately start page erase
+//      if (address < NRWWSTART) __boot_page_erase_short((uint16_t)(void*)address);
+      __boot_page_erase_short((uint16_t)(void*)address);
+
+      // While that is going on, read in page contents
+      bufPtr = buff;
+      do *bufPtr++ = getch();
+      while (--length);
+
+      // If we are in NRWW section, page erase has to be delayed until now.
+      // Todo: Take RAMPZ into account
+//#ifdef MULTI_CALLED
+//      if (address < 0x7E00)
+//#endif
+//      {
+//	      if (address >= NRWWSTART) __boot_page_erase_short((uint16_t)(void*)address);
+//			}
+      // Read command terminator, start reply
+      verifySpace();
+
+      // If only a partial page is to be programmed, the erase might not be complete.
+      // So check that here
+#ifdef MULTI_CALLED
+      if (address < 0x8000)
+#endif
+      {
+	      boot_spm_busy_wait();
+
+#ifdef VIRTUAL_BOOT_PARTITION
+      	if ((uint16_t)(void*)address == 0) {
+      	  // This is the reset vector page. We need to live-patch the code so the
+      	  // bootloader runs.
+      	  //
+      	  // Move RESET vector to WDT vector
+      	  uint16_t vect = buff[0] | (buff[1]<<8);
+      	  rstVect = vect;
+      	  wdtVect = buff[8] | (buff[9]<<8);
+      	  vect -= 4; // Instruction is a relative jump (rjmp), so recalculate.
+      	  buff[8] = vect & 0xff;
+      	  buff[9] = vect >> 8;
+
+      	  // Add jump to bootloader at RESET vector
+      	  buff[0] = 0x7f;
+      	  buff[1] = 0xce; // rjmp 0x1d00 instruction
+      	}
+#endif
+
+      // Copy buffer into programming buffer
+      	bufPtr = buff;
+      	addrPtr = (uint16_t)(void*)address;
+      	ch = SPM_PAGESIZE / 2;
+     	  __boot_erase_flash_buffer((uint16_t)(void*)addrPtr ) ;
+      	do {
+      	  uint16_t a;
+	//        a = *bufPtr++;
+	//        a |= (*bufPtr++) << 8;
+
+					a = *((uint16_t *)bufPtr) ;
+					bufPtr += 2 ;
+
+      	  __boot_page_fill_short((uint16_t)(void*)addrPtr,a);
+      	  addrPtr += 2;
+      	} while (--ch);
+
+      // Write from programming buffer
+      	__boot_page_write_short((uint16_t)(void*)address);
+    	  boot_spm_busy_wait();
+
+#if defined(RWWSRE)
+  	    // Reenable read access to flash
+	      boot_rww_enable();
+#endif
+			}
+    }
+    /* Read memory block mode, length is big endian.  */
+    else if(ch == STK_READ_PAGE)
+		{
+		  register uint8_t  length;
+      // READ PAGE - we only read flash
+      getch();			/* getlen() */
+      length = getch();
+      getch();
+
+      verifySpace();
+//#ifdef VIRTUAL_BOOT_PARTITION
+//      do {
+//        // Undo vector patch in bottom page so verify passes
+//        if (address == 0)       ch=rstVect & 0xff;
+//        else if (address == 1)  ch=rstVect >> 8;
+//        else if (address == 8)  ch=wdtVect & 0xff;
+//        else if (address == 9) ch=wdtVect >> 8;
+//        else ch = pgm_read_byte_near(address);
+//        address++;
+//        putch(ch);
+//      } while (--length);
+//#else
+//#ifdef RAMPZ
+//// Since RAMPZ should already be set, we need to use EPLM directly.
+////      do putch(pgm_read_byte_near(address++));
+////      while (--length);
+//      do {
+//        uint8_t result;
+//        __asm__ ("elpm %0,Z\n":"=r"(result):"z"(address));
+//        putch(result);
+//        address++;
+//      }
+//      while (--length);
+//#else
+      do putch(pgm_read_byte_near(address++));
+      while (--length);
+//#endif
+//#endif
+    }
+
+    /* Get device signature bytes  */
+    else if(ch == STK_READ_SIGN)
+		{
+      // READ SIGN - return what Avrdude wants to hear
+      verifySpace();
+      putch(SIGNATURE_0);
+      putch(SIGNATURE_1);
+      putch(SIGNATURE_2);
+    }
+    else if (ch == STK_LEAVE_PROGMODE) { /* 'Q' */
+      // Adaboot no-wait mod
+
+//      watchdogConfig(WATCHDOG_16MS);
+      
+			verifySpace();
+#ifdef MULTI_CALLED
+	    putch(STK_OK);
+  		while(!(USARTC0.STATUS & USART_TXCIF_bm))
+				;
+			appStart() ;
+#endif
+    }
+    else
+		{
+      // This covers the response to commands like STK_ENTER_PROGMODE
+      verifySpace();
+    }
+    putch(STK_OK);
+  }
+}
+
+void putch(char ch)
+{
+//#ifndef SOFT_UART
+  while(!(USARTC0.STATUS & USART_DREIF_bm))
+		;
+  USARTC0.DATA = ch ;
+//#else
+//  __asm__ __volatile__ (
+//    "   com %[ch]\n" // ones complement, carry set
+//    "   sec\n"
+//    "1: brcc 2f\n"
+//    "   cbi %[uartPort],%[uartBit]\n"
+//    "   rjmp 3f\n"
+//    "2: sbi %[uartPort],%[uartBit]\n"
+//    "   nop\n"
+//    "3: rcall uartDelay\n"
+//    "   rcall uartDelay\n"
+//    "   lsr %[ch]\n"
+//    "   dec %[bitcnt]\n"
+//    "   brne 1b\n"
+//    :
+//    :
+//      [bitcnt] "d" (10),
+//      [ch] "r" (ch),
+//      [uartPort] "I" (_SFR_IO_ADDR(UART_PORT)),
+//      [uartBit] "I" (UART_TX_BIT)
+//    :
+//      "r25"
+//  );
+//#endif
+}
+
+uint8_t getch(void)
+{
+  uint8_t ch;
+
+//#ifdef LED_DATA_FLASH
+//#ifdef __AVR_ATmega8__
+//  LED_PORT ^= _BV(LED);
+//#else
+//  LED_PIN |= _BV(LED);
+//#endif
+//#endif
+
+//#ifdef SOFT_UART
+//  __asm__ __volatile__ (
+//    "1: sbic  %[uartPin],%[uartBit]\n"  // Wait for start edge
+//    "   rjmp  1b\n"
+//    "   rcall uartDelay\n"          // Get to middle of start bit
+//    "2: rcall uartDelay\n"              // Wait 1 bit period
+//    "   rcall uartDelay\n"              // Wait 1 bit period
+//    "   clc\n"
+//    "   sbic  %[uartPin],%[uartBit]\n"
+//    "   sec\n"
+//    "   dec   %[bitCnt]\n"
+//    "   breq  3f\n"
+//    "   ror   %[ch]\n"
+//    "   rjmp  2b\n"
+//    "3:\n"
+//    :
+//      [ch] "=r" (ch)
+//    :
+//      [bitCnt] "d" (9),
+//      [uartPin] "I" (_SFR_IO_ADDR(UART_PIN)),
+//      [uartBit] "I" (UART_RX_BIT)
+//    :
+//      "r25"
+//);
+//#else
+  while(!(USARTC0.STATUS & USART_RXCIF_bm))
+		
+//		watchdogReset()
+    
+		;
+//  if (!(UART_SRA & _BV(FE0))) {
+      /*
+       * A Framing Error indicates (probably) that something is talking
+       * to us at the wrong bit rate.  Assume that this is because it
+       * expects to be talking to the application, and DON'T reset the
+       * watchdog.  This should cause the bootloader to abort and run
+       * the application "soon", if it keeps happening.  (Note that we
+       * don't care that an invalid char is returned...)
+       */
+//    watchdogReset();
+//  }
+
+  ch = USARTC0.DATA ;
+//#endif
+
+//#ifdef LED_DATA_FLASH
+//#ifdef __AVR_ATmega8__
+//  LED_PORT ^= _BV(LED);
+//#else
+//  LED_PIN |= _BV(LED);
+//#endif
+//#endif
+
+  return ch;
+}
+
+#ifdef SOFT_UART
+// AVR305 equation: #define UART_B_VALUE (((F_CPU/BAUD_RATE)-23)/6)
+// Adding 3 to numerator simulates nearest rounding for more accurate baud rates
+#define UART_B_VALUE (((F_CPU/BAUD_RATE)-20)/6)
+#if UART_B_VALUE > 255
+#error Baud rate too slow for soft UART
+#endif
+
+void uartDelay() {
+  __asm__ __volatile__ (
+    "ldi r25,%[count]\n"
+    "1:dec r25\n"
+    "brne 1b\n"
+    "ret\n"
+    ::[count] "M" (UART_B_VALUE)
+  );
+}
+#endif
+
+void getNch(uint8_t count) {
+  do getch(); while (--count);
+  verifySpace();
+}
+
+void verifySpace()
+{
+  if ( getch() != CRC_EOP) {
+    
+  	putch(STK_NOSYNC);
+//		watchdogConfig(WATCHDOG_16MS);    // shorten WD timeout
+//    
+//		while (1)			      // and busy-loop so that WD causes
+//      ;				      //  a reset and app start.
+  }
+  putch(STK_INSYNC);
+}
+
+#if LED_START_FLASHES > 0
+void flash_led(uint8_t count) {
+  do {
+    TCNT1 = -(F_CPU/(1024*16));
+    TIFR1 = _BV(TOV1);
+    while(!(TIFR1 & _BV(TOV1)));
+//#ifdef __AVR_ATmega8__
+    LED_PORT ^= _BV(LED);
+//#else
+//    LED_PIN |= _BV(LED);
+//#endif
+    watchdogReset();
+  } while (--count);
+}
+#endif
+
+// Watchdog functions. These are only safe with interrupts turned off.
+void watchdogReset() {
+  __asm__ __volatile__ (
+    "wdr\n"
+  );
+}
+
+//void watchdogConfig(uint8_t x) {
+//  WDTCSR = _BV(WDCE) | _BV(WDE);
+//  WDTCSR = x;
+//}
+
+void init()
+{
+	// Enable external oscillator (16MHz)
+	OSC.XOSCCTRL = OSC_FRQRANGE_12TO16_gc | OSC_XOSCSEL_XTAL_256CLK_gc ;
+	OSC.CTRL |= OSC_XOSCEN_bm ;
+	while( ( OSC.STATUS & OSC_XOSCRDY_bm ) == 0 )
+		/* wait */ ;
+	// Enable PLL (*2 = 32MHz)
+	OSC.PLLCTRL = OSC_PLLSRC_XOSC_gc | 2 ;
+	OSC.CTRL |= OSC_PLLEN_bm ;
+	while( ( OSC.STATUS & OSC_PLLRDY_bm ) == 0 )
+		/* wait */ ;
+	// Switch to PLL clock
+	CPU_CCP = 0xD8 ;
+	CLK.CTRL = CLK_SCLKSEL_RC2M_gc ;
+	CPU_CCP = 0xD8 ;
+	CLK.CTRL = CLK_SCLKSEL_PLL_gc ;
+
+	PMIC.CTRL = 7 ;		// Enable all interrupt levels
+
+
+	// Timer1 config
+	// TCC1 16-bit timer, clocked at 0.5uS
+	EVSYS.CH3MUX = 0x80 + 0x07 ;	// Prescaler of 128
+	TCC1.CTRLB = 0; TCC1.CTRLC = 0; TCC1.CTRLD = 0; TCC1.CTRLE = 0;
+	TCC1.INTCTRLA = 0 ;
+	TCC1.INTCTRLB = 0 ;
+	TCC1.PER = 0xFFFF ;
+	TCC1.CNT = 0 ;
+	TCC1.CTRLA = 0x0B ;	// Event3 (prescale of 16)
+
+	PORTD.OUTSET = 0x04 ;
+	PORTD.DIRCLR = 0x04 ;
+	PORTD.PIN2CTRL = 0x18 ;		// Pullup
+
+	PORTC.OUTSET = 0x08 ;
+	PORTC.DIRSET = 0x08 ;
+	
+	USARTC0.BAUDCTRLA = 34 ;	// 57600
+	USARTC0.BAUDCTRLB = 0 ;
+		
+	USARTC0.CTRLB = 0x18 ;		// Enable Tx and Rx
+	USARTC0.CTRLA = (USARTC0.CTRLA & 0xCF) ;
+	USARTC0.CTRLC = 0x03 ;	// 8 bit, no parity, 1 stop
+	USARTC0.DATA ;
+}
+
+void boot_spm_busy_wait()
+{
+	while(NVM.STATUS & NVM_NVMBUSY_bm)
+		;
+}
+
+#define A_NVM_CMD 0x1CA 
+
+void __boot_page_erase_short( uint16_t address )
+{
+	asm( "push r24" ) ; 
+	asm( "push r25" ) ; 
+	NVM.CMD = NVM_CMD_ERASE_APP_PAGE_gc ;
+	asm( "pop r31" ) ; 
+	asm( "pop r30" ) ; 
+	CCP = CCP_SPM_gc ;
+	asm( "spm" ) ; 
+}
+
+void __boot_erase_flash_buffer( uint16_t address )
+{
+	asm( "movw r30,r24" ) ; 
+	asm( "ldi r24,0x26" ) ; 
+	asm("sts 0x1CA,r24");
+	CCP = CCP_IOREG_gc ;
+	asm( "ldi r24,1" ) ; 
+	asm("sts 0x1CB,r24");
+}
+
+void __boot_page_fill_short( uint16_t address, uint16_t data)
+{
+	asm( "push r0" ) ; 
+	asm( "push r1" ) ; 
+	asm( "movw r30,r24" ) ; 
+	asm( "mov r0,r22" ) ; 
+	asm( "mov r1,r23" ) ; 
+	asm( "ldi r24,0x23" ) ; 
+	asm("sts 0x1CA,r24");
+	CCP = CCP_SPM_gc ;
+	asm( "spm" ) ; 
+	asm( "pop r1" ) ; 
+	asm( "pop r0" ) ; 
+}
+
+void __boot_page_write_short( uint16_t address)
+{
+	asm( "movw r30,r24" ) ; 
+	asm( "ldi r24,0x2E" ) ; 
+	asm("sts 0x1CA,r24");
+	CCP = CCP_SPM_gc ;
+	asm( "spm" ) ; 
+}
+
+void appStart()
+{
+//  watchdogConfig(WATCHDOG_OFF);
+//  __asm__ __volatile__ (
+//#ifdef VIRTUAL_BOOT_PARTITION
+//    // Jump to WDT vector
+//    "ldi r30,4\n"
+//    "clr r31\n"
+//#else
+//    // Jump to RST vector
+//    "clr r30\n"
+//    "clr r31\n"
+//#endif
+//    "ijmp\n"
+//  );
+
+	register void (*p)() ;
+	p = 0 ;
+
+	if ( pgm_read_byte( (uint16_t)p ) != 0xFF )
+	{
+		(*p)() ;
+	}
+}
+

BootLoaders/OrangeMultiBoot/Source/pin_defs.h

@@ -0,0 +1,80 @@
+#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega88) || defined(__AVR_ATmega8__) || defined(__AVR_ATmega88__)
+/* Onboard LED is connected to pin PB5 in Arduino NG, Diecimila, and Duemilanove */ 
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED         PINB5
+
+/* Ports for soft UART */
+#ifdef SOFT_UART
+#define UART_PORT   PORTD
+#define UART_PIN    PIND
+#define UART_DDR    DDRD
+#define UART_TX_BIT 1
+#define UART_RX_BIT 0
+#endif
+#endif
+
+#if defined(__AVR_ATmega8__)
+  //Name conversion R.Wiersma
+  #define UCSR0A	UCSRA
+  #define UDR0 		UDR
+  #define UDRE0 	UDRE
+  #define RXC0		RXC
+  #define FE0           FE
+  #define TIFR1 	TIFR
+  #define WDTCSR	WDTCR
+#endif
+
+/* Luminet support */
+#if defined(__AVR_ATtiny84__)
+/* Red LED is connected to pin PA4 */ 
+#define LED_DDR     DDRA
+#define LED_PORT    PORTA
+#define LED_PIN     PINA
+#define LED         PINA4
+/* Ports for soft UART - left port only for now. TX/RX on PA2/PA3 */
+#ifdef SOFT_UART
+#define UART_PORT   PORTA
+#define UART_PIN    PINA
+#define UART_DDR    DDRA
+#define UART_TX_BIT 2
+#define UART_RX_BIT 3
+#endif
+#endif
+
+/* Sanguino support */
+#if defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__)
+/* Onboard LED is connected to pin PB0 on Sanguino */ 
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED         PINB0
+
+/* Ports for soft UART */
+#ifdef SOFT_UART
+#define UART_PORT   PORTD
+#define UART_PIN    PIND
+#define UART_DDR    DDRD
+#define UART_TX_BIT 1
+#define UART_RX_BIT 0
+#endif
+#endif
+
+/* Mega support */
+#if defined(__AVR_ATmega1280__)
+/* Onboard LED is connected to pin PB7 on Arduino Mega */ 
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED         PINB7
+
+/* Ports for soft UART */
+#ifdef SOFT_UART
+#define UART_PORT   PORTE
+#define UART_PIN    PINE
+#define UART_DDR    DDRE
+#define UART_TX_BIT 1
+#define UART_RX_BIT 0
+#endif
+#endif

BootLoaders/OrangeMultiBoot/Source/stk500.h

@@ -0,0 +1,39 @@
+/* STK500 constants list, from AVRDUDE */
+#define STK_OK              0x10
+#define STK_FAILED          0x11  // Not used
+#define STK_UNKNOWN         0x12  // Not used
+#define STK_NODEVICE        0x13  // Not used
+#define STK_INSYNC          0x14  // ' '
+#define STK_NOSYNC          0x15  // Not used
+#define ADC_CHANNEL_ERROR   0x16  // Not used
+#define ADC_MEASURE_OK      0x17  // Not used
+#define PWM_CHANNEL_ERROR   0x18  // Not used
+#define PWM_ADJUST_OK       0x19  // Not used
+#define CRC_EOP             0x20  // 'SPACE'
+#define STK_GET_SYNC        0x30  // '0'
+#define STK_GET_SIGN_ON     0x31  // '1'
+#define STK_SET_PARAMETER   0x40  // '@'
+#define STK_GET_PARAMETER   0x41  // 'A'
+#define STK_SET_DEVICE      0x42  // 'B'
+#define STK_SET_DEVICE_EXT  0x45  // 'E'
+#define STK_ENTER_PROGMODE  0x50  // 'P'
+#define STK_LEAVE_PROGMODE  0x51  // 'Q'
+#define STK_CHIP_ERASE      0x52  // 'R'
+#define STK_CHECK_AUTOINC   0x53  // 'S'
+#define STK_LOAD_ADDRESS    0x55  // 'U'
+#define STK_UNIVERSAL       0x56  // 'V'
+#define STK_PROG_FLASH      0x60  // '`'
+#define STK_PROG_DATA       0x61  // 'a'
+#define STK_PROG_FUSE       0x62  // 'b'
+#define STK_PROG_LOCK       0x63  // 'c'
+#define STK_PROG_PAGE       0x64  // 'd'
+#define STK_PROG_FUSE_EXT   0x65  // 'e'
+#define STK_READ_FLASH      0x70  // 'p'
+#define STK_READ_DATA       0x71  // 'q'
+#define STK_READ_FUSE       0x72  // 'r'
+#define STK_READ_LOCK       0x73  // 's'
+#define STK_READ_PAGE       0x74  // 't'
+#define STK_READ_SIGN       0x75  // 'u'
+#define STK_READ_OSCCAL     0x76  // 'v'
+#define STK_READ_FUSE_EXT   0x77  // 'w'
+#define STK_READ_OSCCAL_EXT 0x78  // 'x'

BootLoaders/README.md

@@ -0,0 +1,2 @@
+## Page Moved
+Moved to [/docs/Arduino_IDE_Boards.md](/docs/Arduino_IDE_Boards.md).

BootLoaders/StmMultiBoot/README.md

@@ -0,0 +1 @@
+[Source for the StmMultiBooloader](https://github.com/MikeBland/StmMultiBoot)

BootLoaders/StmMultiUSB/README.md

@@ -0,0 +1,2 @@
+[Source for the StmMultiUSB=STM32duino-bootloader](https://github.com/rogerclarkmelbourne/STM32duino-bootloader)
+If you want the latest version, you should look for the file generic_boot20_pa1.bin.

BootLoaders/package_multi_4in1_board_index.json

@@ -0,0 +1,657 @@
+{
+  "packages": [{
+    "name": "multi4in1",
+    "maintainer": "Pascal Langer",
+    "websiteURL": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module",
+    "email": "pascal_langer@yahoo.fr",
+    "help": {
+      "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+    },
+    "platforms": [
+      {
+        "name": "Multi 4-in-1 AVR Boards",
+        "architecture": "avr",
+        "version": "1.0.2",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_avr_board_v1.0.2.tar.gz",
+        "archiveFileName": "package_multi_4in1_avr_board_v1.0.2.tar.gz",
+        "checksum": "SHA-256:b7e2fda37186bf696b7a769b12317737d513181096b33d9ad321ec2fd47f3f80",
+        "size": "164467",
+        "boards": [
+          {"name": "Multi 4-in-1 (Atmega328p, 3.3V, 16MHz)"},
+          {"name": "Multi 4-in-1 (OrangeRX)"}
+        ],
+        "toolsDependencies": []
+      },
+      {
+        "name": "Multi 4-in-1 AVR Boards",
+        "architecture": "avr",
+        "version": "1.0.3",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_avr_board_v1.0.3.tar.gz",
+        "archiveFileName": "package_multi_4in1_avr_board_v1.0.3.tar.gz",
+        "checksum": "SHA-256:7d4561eebe0d7f6422f06d5719a417e15fcc0aa9cdbfc1c48a57066ce768e33c",
+        "size": "164483",
+        "boards": [
+          {"name": "Multi 4-in-1 (Atmega328p, 3.3V, 16MHz)"},
+          {"name": "Multi 4-in-1 (OrangeRX)"}
+        ],
+        "toolsDependencies": []
+      },
+      {
+        "name": "Multi 4-in-1 AVR Boards",
+        "architecture": "avr",
+        "version": "1.0.4",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_avr_board_v1.0.4.tar.gz",
+        "archiveFileName": "package_multi_4in1_avr_board_v1.0.4.tar.gz",
+        "checksum": "SHA-256:6c51a4eb09bcd074cc651dab3f2356ea3afd358f6330aba0d8bdfaa75f718dbb",
+        "size": "167975",
+        "boards": [
+          {"name": "Multi 4-in-1 (Atmega328p, 3.3V, 16MHz)"},
+          {"name": "Multi 4-in-1 (OrangeRX)"}
+        ],
+        "toolsDependencies": []
+      },
+      {
+        "name": "Multi 4-in-1 AVR Boards",
+        "architecture": "avr",
+        "version": "1.0.5",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_avr_board_v1.0.5.tar.gz",
+        "archiveFileName": "package_multi_4in1_avr_board_v1.0.5.tar.gz",
+        "checksum": "SHA-256:0a4754d47cdbb49ca194b15835686331530ed9d36c0db093a29ae5f865e75421",
+        "size": "169830",
+        "boards": [
+          {"name": "Multi 4-in-1 (Atmega328p, 3.3V, 16MHz)"},
+          {"name": "Multi 4-in-1 (OrangeRX)"}
+        ],
+        "toolsDependencies": []
+      },
+      {
+        "name": "Multi 4-in-1 AVR Boards",
+        "architecture": "avr",
+        "version": "1.0.6",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_avr_board_v1.0.6.tar.gz",
+        "archiveFileName": "package_multi_4in1_avr_board_v1.0.6.tar.gz",
+        "checksum": "SHA-256:4f4cf8820e30bf6c88f280514c67ee67b9dc6649f439597cfb8d0be3a5b13bf5",
+        "size": "169819",
+        "boards": [
+          {"name": "Multi 4-in-1 (Atmega328p, 3.3V, 16MHz)"},
+          {"name": "Multi 4-in-1 (OrangeRX)"}
+        ],
+        "toolsDependencies": []
+      },
+      {
+        "name": "Multi 4-in-1 AVR Boards",
+        "architecture": "avr",
+        "version": "1.0.7",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_avr_board_v1.0.7.tar.gz",
+        "archiveFileName": "package_multi_4in1_avr_board_v1.0.7.tar.gz",
+        "checksum": "SHA-256:453c9999e433ed1bdda2ba2b12cb7cbba7b547591db969dc6b7efb941b61cf76",
+        "size": "169825",
+        "boards": [
+          {"name": "Multi 4-in-1 (Atmega328p, 3.3V, 16MHz)"},
+          {"name": "Multi 4-in-1 (OrangeRX)"}
+        ],
+        "toolsDependencies": []
+      },
+      {
+        "name": "Multi 4-in-1 AVR Boards",
+        "architecture": "avr",
+        "version": "1.0.8",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_avr_board_v1.0.8.tar.gz",
+        "archiveFileName": "package_multi_4in1_avr_board_v1.0.8.tar.gz",
+        "checksum": "SHA-256:8e58b8733220d56155e10bf5bec0bfe6bf96f8460b3fd49a4b45c7f9fad776cb",
+        "size": "293388",
+        "boards": [
+          {"name": "Multi 4-in-1 (Atmega328p, 3.3V, 16MHz)"},
+          {"name": "Multi 4-in-1 (OrangeRX)"}
+        ],
+        "toolsDependencies": []
+      },
+      {
+        "name": "Multi 4-in-1 AVR Boards",
+        "architecture": "avr",
+        "version": "1.0.9",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_avr_board_v1.0.9.tar.gz",
+        "archiveFileName": "package_multi_4in1_avr_board_v1.0.9.tar.gz",
+        "checksum": "SHA-256:269c4ddcb8018be2b31f5c9e9f0814d120af492e894b8d5098a814486d56faa5",
+        "size": "318437",
+        "boards": [
+          {"name": "Multi 4-in-1 (Atmega328p, 3.3V, 16MHz)"},
+          {"name": "Multi 4-in-1 (OrangeRX)"}
+        ],
+        "toolsDependencies": []
+      },
+      {
+        "name": "Multi 4-in-1 AVR Boards",
+        "architecture": "avr",
+        "version": "1.1.0",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_avr_board_v1.1.0.tar.gz",
+        "archiveFileName": "package_multi_4in1_avr_board_v1.1.0.tar.gz",
+        "checksum": "SHA-256:7bacf2db754ceb890a203de5ce89d97aa787a9e6462debeb44cf04830859687a",
+        "size": "326431",
+        "boards": [
+          {"name": "Multi 4-in-1 (Atmega328p, 3.3V, 16MHz)"},
+          {"name": "Multi 4-in-1 (OrangeRX)"}
+        ],
+        "toolsDependencies": []
+      },
+      {
+        "name": "MULTI-Module AVR Boards",
+        "architecture": "avr",
+        "version": "1.1.1",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_avr_board_v1.1.1.tar.gz",
+        "archiveFileName": "package_multi_4in1_avr_board_v1.1.1.tar.gz",
+        "checksum": "SHA-256:02158258b4dbaca61bedbb6933336200d13b02ad0db981e2dda253682c482e99",
+        "size": "324512",
+        "boards": [
+          {"name": "Multi 4-in-1 (Atmega328p, 3.3V, 16MHz)"},
+          {"name": "Multi 4-in-1 (OrangeRX)"}
+        ],
+        "toolsDependencies": []
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.0.1",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.0.1.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.0.1.tar.gz",
+        "checksum": "SHA-256:b522b5d3474308768c197a6897cad037fb54d6fac26c75678415a0908793bae3",
+        "size": "10332875",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.0.2",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.0.2.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.0.2.tar.gz",
+        "checksum": "SHA-256:26d21dbd2fe80680ac523b8bca24b3ecf2c2016bac626826d20b651e11278287",
+        "size": "10318646",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.0.3",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.0.3.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.0.3.tar.gz",
+        "checksum": "SHA-256:e48f1f30948b3f7be83e8b1fe2bb5c6b41be7c4d5da02503a0b4827c60926541",
+        "size": "10309833",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.0.4",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.0.4.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.0.4.tar.gz",
+        "checksum": "SHA-256:388a4dbcd567f9d41b82955e12e8a640d9696217081c0ee6ab8c58a25aedf70f",
+        "size": "10307581",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.0.5",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.0.5.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.0.5.tar.gz",
+        "checksum": "SHA-256:46d3b4e62fc46e6b8ca4f429974ffd2ee8cde9e29a6e0cda58f85044991a9c2b",
+        "size": "10313436",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.0.6",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.0.6.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.0.6.tar.gz",
+        "checksum": "SHA-256:ad7a330326069a5ffb2908495b288933f68517b1247cc6636b160eb483a58284",
+        "size": "10319669",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.0.7",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.0.7.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.0.7.tar.gz",
+        "checksum": "SHA-256:f73fded48beaee55e646a3cf36d24beeedc336873c7824683a4912f2aee9e350",
+        "size": "10322111",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.0.8",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.0.8.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.0.8.tar.gz",
+        "checksum": "SHA-256:f8100272ec615074cf7962c2c8331014ebda78f3e4c17172b88b6dd3d83c4331",
+        "size": "10319134",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.0.9",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.0.9.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.0.9.tar.gz",
+        "checksum": "SHA-256:c3621d1cf6580ca5c943a67dc14dc15a60e2797a4b985548abe1919486bf4a8b",
+        "size": "10324251",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.1.0",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.1.0.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.1.0.tar.gz",
+        "checksum": "SHA-256:919ece2021757686e6892679956dcb8a01c9308a152167d61d9204656b4ed7ee",
+        "size": "10333612",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.1.1",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.1.1.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.1.1.tar.gz",
+        "checksum": "SHA-256:549dbfa0f48f3e519a9efa96d03e8933cc72989c618826b2b570980d9c382979",
+        "size": "10331547",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.1.2",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.1.2.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.1.2.tar.gz",
+        "checksum": "SHA-256:debfdc14df3023045a2297bc99daf7104be75f21572fc5a4f57192ffae4028f0",
+        "size": "10322776",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.1.3",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.1.3.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.1.3.tar.gz",
+        "checksum": "SHA-256:6b9dceb033ccc31f37cebc4f025ddb862cd24a733e7c356ca2fa5719d595af89",
+        "size": "10322145",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.1.4",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.1.4.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.1.4.tar.gz",
+        "checksum": "SHA-256:16a83a3b4409cb55aead6593396979483996080634d214ae07c8a956db2480fb",
+        "size": "10322152",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.1.5",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.1.5.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.1.5.tar.gz",
+        "checksum": "SHA-256:2d45c95f59b4fb9fc7f7bf8caca2dd8c13b4258141c20db6169e0c7faf72e5e4",
+        "size": "7930904",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.1.6",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.1.6.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.1.6.tar.gz",
+        "checksum": "SHA-256:d2d1ef721bbcdc3c680c6f98b4b8ab394478ac0f82d67af2f6c389a4a30789f4",
+        "size": "7962942",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 STM32 Board",
+        "architecture": "STM32F1",
+        "version": "1.1.7",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.1.7.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.1.7.tar.gz",
+        "checksum": "SHA-256:37cccde7eafad3d0587d28d13d5f8b2b3244bf7c83e6819b6cb08f4f468815e2",
+        "size": "7966348",
+        "boards": [{
+          "name": "Multi 4-in-1 (STM32F103C)"
+        }],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi X-in-1 STM32 Boards",
+        "architecture": "STM32F1",
+        "version": "1.1.8",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.1.8.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.1.8.tar.gz",
+        "checksum": "SHA-256:e9ed8055ebf72abf37e60e1b8d1c6ee5472132ea7c0a3c4a63fbb8442613e4c2",
+        "size": "7481800",
+        "boards": [
+          {"name": "Multi 4-in-1 (STM32F103C)"},
+          {"name": "Multi 5-in-1 (Jumper T18 Internal)"}
+        ],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi X-in-1 STM32 Boards",
+        "architecture": "STM32F1",
+        "version": "1.2.0",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.2.0.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.2.0.tar.gz",
+        "checksum": "SHA-256:754f08ca2a553701cc9112b645c079b6041107f1bf863648305e560c136a6ac5",
+        "size": "7496214",
+        "boards": [
+          {"name": "Multi 4-in-1 (STM32F103C)"},
+          {"name": "Multi 5-in-1 (Jumper T18 Internal)"}
+        ],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi X-in-1 STM32 Boards",
+        "architecture": "STM32F1",
+        "version": "1.2.1",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.2.1.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.2.1.tar.gz",
+        "checksum": "SHA-256:c66d34afadc5b21e9e28c4d477fa03a6d55db0b74b59ff2dcb07b4d6ef06da1a",
+        "size": "7496448",
+        "boards": [
+          {"name": "Multi 4-in-1 (STM32F103C)"},
+          {"name": "Multi 5-in-1 (Jumper T18 Internal)"}
+        ],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "MULTI-Module STM32 Boards",
+        "architecture": "STM32F1",
+        "version": "1.2.2",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_stm32_board_v1.2.2.tar.gz",
+        "archiveFileName": "package_multi_4in1_stm32_board_v1.2.2.tar.gz",
+        "checksum": "SHA-256:0fe4a8899438bbc31dc37714acca13968e43d75a47e59143343d83b634d2e47d",
+        "size": "7485662",
+        "boards": [
+          {"name": "Multi X-in-1 STM32F103CB (128KB)"},
+          {"name": "Multi X-in-1 STM32F103C8 (64KB)"},
+          {"name": "Multi 5-in-1 (Jumper T18 Internal)"}
+        ],
+        "toolsDependencies": [{
+          "packager": "arduino",
+          "name": "arm-none-eabi-gcc",
+          "version": "4.8.3-2014q1"
+        }]
+      },
+      {
+        "name": "Multi 4-in-1 OrangeRX Board - DEPRECATED, USE MULTI 4-IN-1 AVR BOARDS PACKAGE INSTEAD",
+        "architecture": "orangerx",
+        "version": "1.0.1",
+        "category": "Contributed",
+        "help": {
+          "online": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module"
+        },
+        "url": "https://github.com/pascallanger/DIY-Multiprotocol-TX-Module-Boards/raw/master/archives/package_multi_4in1_orangerx_board_v1.0.1.tar.gz",
+        "archiveFileName": "package_multi_4in1_orangerx_board_v1.0.1.tar.gz",
+        "checksum": "SHA-256:7287ce61028b754bb8ff947317dd15773fc7eeecd752826c707fa356b9b36dc6",
+        "size": "161615",
+        "boards": [{
+          "name": "Multi 4-in-1 (OrangeRX)"
+        }],
+        "toolsDependencies": []
+      }
+    ],
+    "tools": []
+  }]
+}

Lua_scripts/DSM FwdPrg.lua

@@ -0,0 +1,768 @@
+local toolName = "TNS|DSM Forward Programming v0.2|TNE"
+
+---- #########################################################################
+---- #                                                                       #
+---- # Copyright (C) OpenTX                                                  #
+-----#                                                                       #
+---- # License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html               #
+---- #                                                                       #
+---- # This program is free software; you can redistribute it and/or modify  #
+---- # it under the terms of the GNU General Public License version 2 as     #
+---- # published by the Free Software Foundation.                            #
+---- #                                                                       #
+---- # This program is distributed in the hope that it will be useful        #
+---- # but WITHOUT ANY WARRANTY; without even the implied warranty of        #
+---- # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         #
+---- # GNU General Public License for more details.                          #
+---- #                                                                       #
+---- #########################################################################
+
+
+--###############################################################################
+-- Multi buffer for DSM description
+-- Multi_Buffer[0..2]=="DSM" -> Lua script is running
+-- Multi_Buffer[3]==0x70+len -> TX to RX data ready to be sent
+-- Multi_Buffer[4..9]=6 bytes of TX to RX data
+-- Multi_Buffer[10..25]=16 bytes of RX to TX data
+--
+-- To start operation:
+--   Write 0x00 at address 3
+--   Write 0x00 at address 10
+--   Write "DSM" at address 0..2
+--###############################################################################
+
+local RX_VERSION, WAIT_CMD, MENU_TITLE, MENU_LINES, MENU_VALUES, VALUE_CHANGING, VALUE_CHANGING_WAIT, VALUE_CHANGED, EXIT, EXIT_DONE = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+local MENU, LIST_MENU_NOCHANGING, LIST_MENU1, LIST_MENU2, VALUE_NOCHANGING = 0x1C, 0x6C, 0x0C, 0x4C, 0x60
+local Phase = RX_VERSION
+local Waiting_RX = 0
+local Text = {}
+local RxName = {}
+local Retry=100
+local Blink = 0
+local Value_Changed=0
+
+local Menu = { Cur=nil, Id=nil, Title="", Prev=nil, PrevId=nil, Next=nil, NextId=nil, Back=nil, BackId=nil, CurLine=nil, SelLine=nil, EditLine=nil }
+local Line = {}
+local RX = { Name="", Version="" }
+
+-- used for debug
+local rxAnswer = ""
+local debugLine = 0
+
+------------------------------------------------------------------------------------------------------------
+local function GetDebugInfo(lineNr)  -- used for debug
+  local i
+
+      debugLine = lineNr
+	  rxAnswer = "RX:"
+	  for i=10, 25 do
+	    rxAnswer = rxAnswer.." "..string.format("%02X", multiBuffer(i))
+	  end
+  
+end
+
+------------------------------------------------------------------------------------------------------------
+local function conv_int16(number)
+  if number >= 0x8000 then
+    return number - 0x10000
+  end
+  return number
+end
+------------------------------------------------------------------------------------------------------------
+local function Get_Text(index)
+  out = Text[index]
+  if out == nil then -- unknown...
+    out = "Unknown_"..string.format("%X",index)
+  end
+  return out
+end
+------------------------------------------------------------------------------------------------------------
+local function Get_RxName(index)
+  out = RxName[index]
+  if out == nil then -- unknown...
+    out = "Unknown_"..string.format("%X",index)
+  end
+  return out
+end
+------------------------------------------------------------------------------------------------------------
+local function DSM_Release()
+  multiBuffer( 0, 0 )
+  Phase = EXIT_DONE
+end
+------------------------------------------------------------------------------------------------------------
+local function DSM_Send(...)
+  local arg = {...}
+  for i = 1 , #arg do
+    multiBuffer( 3+i, arg[i])
+  end
+  multiBuffer( 3, 0x70+#arg)
+end
+------------------------------------------------------------------------------------------------------------
+local function Value_Add(dir)
+  local line=Line[Menu.SelLine]
+  Speed = getRotEncSpeed()
+  if Speed == ROTENC_MIDSPEED then
+    line.Val = line.Val + (5 * dir)
+  elseif Speed == ROTENC_HIGHSPEED then
+    line.Val = line.Val + (15 * dir)
+  else
+    line.Val = line.Val + dir
+  end
+  if line.Val > line.Max then
+    line.Val = line.Max
+  elseif line.Val < line.Min then
+    line.Val = line.Min
+  end
+  if Line[Menu.SelLine].Type ~= LIST_MENU_NOCHANGING then
+    Phase = VALUE_CHANGING
+    Waiting_RX = 0
+  end
+end
+------------------------------------------------------------------------------------------------------------
+local function DSM_Menu(event)
+  local Speed = 0
+
+  if event == EVT_VIRTUAL_EXIT then
+    if Phase == RX_VERSION then
+      DSM_Release()
+    else
+      Phase = EXIT
+      Waiting_RX = 0
+    end
+  elseif event == EVT_VIRTUAL_NEXT then
+    if Menu.EditLine == nil then
+      -- not changing a value
+      if Menu.SelLine ~= nil then
+        if Menu.SelLine < 7 then
+          local num = Menu.SelLine
+          for i = Menu.SelLine + 1, 6, 1 do
+            if Line[i].Type ~= nil and Line[i].Next ~= nil and Line[i].Type ~= VALUE_NOCHANGING then
+              Menu.SelLine=i
+              break
+            end
+          end
+          if num == Menu.SelLine then
+            if Menu.Next ~= 0 then -- Next
+              Menu.SelLine = 7
+            elseif Menu.Prev ~= 0 then -- Prev
+                Menu.SelLine = 8
+            end
+          end
+        elseif Menu.Prev ~= 0 then -- Prev
+            Menu.SelLine = 8
+        end
+      end
+    else -- need to inc the value
+      Value_Add(1)
+    end
+  elseif event == EVT_VIRTUAL_PREV then
+    if Menu.EditLine == nil then
+      if Menu.SelLine ~= nil then
+        if Menu.SelLine == 8 and Menu.Next ~= 0 then
+          Menu.SelLine = 7
+        elseif Menu.SelLine > 0 then
+          if Menu.SelLine > 6 then
+            Menu.SelLine = 7
+          end
+          local num = Menu.SelLine
+          for i = Menu.SelLine-1, 0, -1 do
+            if Line[i].Type ~= nil and Line[i].Next ~= nil and Line[i].Type ~= VALUE_NOCHANGING then
+              Menu.SelLine=i
+              break
+            end
+          end
+          if num == Menu.SelLine then -- Back
+            Menu.SelLine = -1
+          end
+        else
+          Menu.SelLine = -1 -- Back
+        end
+      end
+    else -- need to dec the value
+      Value_Add(-1)
+    end
+  elseif event == EVT_VIRTUAL_ENTER_LONG then
+    if Menu.EditLine ~= nil then
+    -- reset the value to default
+      if Line[Menu.SelLine].Type ~= LIST_MENU_NOCHANGING then
+        Line[Menu.SelLine].Val = Line[Menu.SelLine].Def
+        Phase = VALUE_CHANGING
+        Waiting_RX = 0
+      end
+    end
+  elseif event == EVT_VIRTUAL_ENTER then
+    if Menu.SelLine == -1 then -- Back
+        Menu.Cur = Menu.Back
+        Menu.Id = Menu.BackId
+        Menu.SelLine = 0
+        Phase = MENU_TITLE
+        Waiting_RX = 0
+    elseif Menu.SelLine == 7 then -- Next
+        Menu.Cur = Menu.Next
+        Menu.Id = Menu.NextId
+        Menu.SelLine = 0
+        Phase = MENU_TITLE
+        Waiting_RX = 0
+    elseif Menu.SelLine == 8 then -- Prev
+        Menu.Cur = Menu.Prev
+        Menu.Id = Menu.PrevId
+        Menu.SelLine = 0
+        Phase = MENU_TITLE
+        Waiting_RX = 0
+    elseif Menu.SelLine ~= nil and Line[Menu.SelLine].Next ~= nil then
+      if Line[Menu.SelLine].Type == MENU then -- Next menu exist
+        Menu.Cur = Line[Menu.SelLine].Next
+        Menu.Id = Line[Menu.SelLine].NextId
+        Phase = MENU_TITLE
+        Waiting_RX = 0
+      else
+        -- value entry
+        if Menu.EditLine == Menu.SelLine then
+          Menu.EditLine = nil
+          Value_Changed = 0
+          Phase = VALUE_CHANGED
+          Waiting_RX = 0
+        else
+          Menu.EditLine = Menu.SelLine
+        end
+      end
+    end
+  end
+end
+------------------------------------------------------------------------------------------------------------
+local function DSM_Send_Receive()
+  if Waiting_RX == 0 then
+    Waiting_RX = 1
+    
+	-- Need to send a request
+    if Phase == RX_VERSION then -- request RX version
+      DSM_Send(0x11,0x06,0x00,0x14,0x00,0x00)
+    
+	elseif Phase == WAIT_CMD then -- keep connection open
+      DSM_Send(0x00,0x04,0x00,0x00)
+    
+	elseif Phase == MENU_TITLE then -- request menu title
+      if Menu.Cur == nil then
+        DSM_Send(0x12,0x06,0x00,0x14,0x00,0x00) -- first menu only
+        Menu.Cur = 0
+      else
+        DSM_Send(0x16,0x06,Menu.Id,Menu.Cur,0x00,Menu.SelLine)
+      end
+    
+	elseif Phase == MENU_LINES then -- request menu lines
+      if Menu.CurLine == nil then
+        DSM_Send(0x13,0x04,Menu.Id,Menu.Cur) -- line 0
+      elseif Menu.CurLine >= 0x80 then
+        local last_byte={0x40,0x01,0x02,0x04,0x00,0x00} -- unknown...
+        DSM_Send(0x20,0x06,Menu.CurLine-0x80,Menu.CurLine-0x80,0x00,last_byte[Menu.CurLine-0x80+1]) -- line X
+      else
+        DSM_Send(0x14,0x06,Menu.Id,Menu.Cur,0x00,Menu.CurLine) -- line X
+      end
+    
+	elseif Phase == MENU_VALUES then -- request menu values
+      DSM_Send(0x15,0x06,Menu.Id,Menu.Cur,Line[Menu.CurLine].ValId,Line[Menu.CurLine].Next) -- line X
+	  
+	elseif Phase == VALUE_CHANGING then -- send value
+	  local value=Line[Menu.SelLine].Val
+      if value < 0 then
+        value = 0x10000 + value
+      end
+      DSM_Send(0x18,0x06,Line[Menu.SelLine].ValId,Line[Menu.SelLine].Next,bit32.rshift(value,8),bit32.band(value,0xFF)) -- send current value
+      Phase = VALUE_CHANGING_WAIT
+	      
+	elseif Phase == VALUE_CHANGED then -- send value
+      if Value_Changed == 0 then
+        local value=Line[Menu.SelLine].Val
+        if value < 0 then
+          value = 0x10000 + value
+        end
+        DSM_Send(0x18,0x06,Line[Menu.SelLine].ValId,Line[Menu.SelLine].Next,bit32.rshift(value,8),bit32.band(value,0xFF)) -- send current value
+        Value_Changed = Value_Changed + 1
+        Waiting_RX = 0
+      elseif Value_Changed == 1 then
+        DSM_Send(0x19,0x06,Line[Menu.SelLine].ValId,Line[Menu.SelLine].Next) -- validate
+      --  Value_Changed = Value_Changed + 1
+      --  Waiting_RX = 0
+      --elseif Value_Changed == 2 then
+      --  DSM_Send(0x1B,0x06,0x10,Menu.SelLine) -- validate again?
+      --  Value_Changed = Value_Changed + 1
+      end
+    
+	elseif Phase == VALUE_CHANGING_WAIT then
+      DSM_Send(0x1A,0x06,Line[Menu.SelLine].ValId,Line[Menu.SelLine].Next)
+    
+	elseif Phase == EXIT then
+      DSM_Send(0x1F,0x02,0xAA)
+
+	end
+    multiBuffer(10,0x00);
+    Retry = 50
+  -- -- -- -- -- -- -- -- -- -- -- -- receive part -- -- -- -- -- -- -- -- -- -- -- -- -- 
+  elseif multiBuffer(10) == 0x09 then
+    -- Answer received
+    -- GetDebugInfo(292) -- used for debug
+	
+	--if multiBuffer(11) == 0x00 then -- waiting for commands?
+    
+	if multiBuffer(11) == 0x01 then -- read version
+	  --ex: 0x09 0x01 0x00 0x15 0x02 0x22 0x01 0x00 0x14 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+      RX.Name = Get_RxName(multiBuffer(13))
+      RX.Version = multiBuffer(14).."."..multiBuffer(15).."."..multiBuffer(16)
+      Phase = MENU_TITLE
+    
+	elseif multiBuffer(11) == 0x02 then -- read menu title
+      --ex: 0x09 0x02 0x4F 0x10 0xA5 0x00 0x00 0x00 0x50 0x10 0x10 0x10 0x00 0x00 0x00 0x00
+      Menu.Cur = multiBuffer(12)
+      Menu.Id  = multiBuffer(13)
+      Menu.Title = Get_Text(multiBuffer(14)+multiBuffer(15)*256)
+      Menu.Prev = multiBuffer(16)
+      Menu.PrevId = multiBuffer(17)
+      Menu.Next = multiBuffer(18)
+      Menu.NextId = multiBuffer(19)
+      Menu.Back = multiBuffer(20)
+      Menu.BackId = multiBuffer(21)
+      for i = 0, 6 do  -- clear menu
+        Line[i] = { Menu = nil, Id = nil, Type = nil, Text="", Next = nil, NextId = nil, ValLine = nil, ValId = nil, Min, Max, Def, Val, Unit, Step }
+      end
+      Menu.CurLine = nil
+      if Menu.Next ~= 0 then
+        Menu.SelLine = 7 -- highlight Next
+      else
+        Menu.SelLine = -1 -- highlight Back
+      end
+      Blink = 0
+      Phase = MENU_LINES
+    
+	elseif multiBuffer(11) == 0x03 then -- read menu lines
+      --ex: 0x09 0x03 0x00 0x10 0x00 0x1C 0xF9 0x00 0x10 0x10 0x00 0x00 0x00 0x00 0x03 0x00
+      --              Menu Id   line Type Text_idx  Next  V_Id Val_Min   Val_Max   Val_Def
+      --ex: 0x09 0x03 0x61 0x10 0x00 0x6C 0x50 0x00 0x00 0x10 0x36 0x00 0x49 0x00 0x36 0x00
+      Menu.CurLine = multiBuffer(14)
+      local line = Line[Menu.CurLine]
+      line.Menu = multiBuffer(12)
+      line.Id = multiBuffer(13) -- not quite sure yet
+      line.Type = multiBuffer(15) -- not quite sure yet: 1C is text menu only, 4C/6C is text followed by text list, C0 is text followed by percentage value, 0C new list type
+      line.Text = Get_Text(multiBuffer(16)+multiBuffer(17)*256)
+      --if multiBuffer(18) == Menu.Cur then
+      --  line.Next = nil
+      --else
+        line.Next = multiBuffer(18) -- not quite sure yet: 1C=text menu=>next menu, others=>identifier of line number of the value
+      --end
+      if Menu.SelLine == -1 and line.Next ~= nil then -- Auto select first line of the menu
+        Menu.SelLine = Menu.CurLine
+      end
+      line.NextId = multiBuffer(19) -- not quite sure yet
+      line.ValLine = multiBuffer(18) -- not quite sure yet
+      line.ValId = multiBuffer(19) -- not quite sure yet
+      line.Min = conv_int16(multiBuffer(20)+multiBuffer(21)*256)
+      line.Max = conv_int16(multiBuffer(22)+multiBuffer(23)*256)
+      line.Def = conv_int16(multiBuffer(24)+multiBuffer(25)*256)
+      if line.Type == MENU then
+        -- nothing to do on menu entries
+      elseif line.Type == LIST_MENU_NOCHANGING or line.Type == LIST_MENU1 or line.Type == LIST_MENU2 then
+        line.Val = nil --line.Def - line.Min -- use default value not sure if needed
+        line.Def = line.Min -- pointer to the start of the list in Text
+        line.Max = line.Max - line.Min -- max index
+        line.Min = 0 -- min index
+      else -- default to numerical value
+        line.Val = nil --line.Def -- use default value not sure if needed
+      end
+      if line.Type ~= MENU and line.Type ~= VALUE_NOCHANGING then -- updatable value to follow
+        line.Text = line.Text..":"
+      end
+      Phase = MENU_LINES
+    
+	elseif multiBuffer(11) == 0x04 then -- read menu values
+      --ex: 0x09 0x04 0x53 0x10 0x00 0x10 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+      --              Menu MeId line VaId Value
+      --ex: 0x09 0x04 0x61 0x10 0x02 0x10 0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+      -- Identify the line and update the value
+      for i = 0, 6 do
+        if Line[i] ~= nil and Line[i].Type ~= nil then
+          if Line[i].Type ~= MENU and Line[i].Next == multiBuffer(14) then -- identifier of line number stored in .Next
+            Line[i].Val = conv_int16(multiBuffer(16)+multiBuffer(17)*256)
+            Menu.CurLine = i
+            break
+          end
+        end
+      end
+      Phase = MENU_VALUES
+  
+	elseif multiBuffer(11) == 0x05 then -- unknown... need to get through the lines...
+      Menu.CurLine = 0x80 + multiBuffer(12)
+      Phase = MENU_LINES
+    
+	elseif multiBuffer(11) == 0xA7 then -- answer to EXIT command
+      DSM_Release()
+	
+	elseif multiBuffer(11) == 0x00 and Phase == VALUE_CHANGING then
+      Phase = VALUE_CHANGING_WAIT
+    
+	end
+    
+	-- Data processed
+    Waiting_RX = 0
+    multiBuffer(10,0x00)
+    Retry = 50
+  
+  else
+    Retry = Retry - 1
+    if Retry <= 0 then
+      -- Retry the RX request
+      Retry = 50
+      Waiting_RX = 0
+      if Phase == EXIT then
+        DSM_Release()
+      end
+      if Phase ~= RX_VERSION and Phase ~= VALUE_CHANGING_WAIT then
+        Phase = WAIT_CMD
+      end
+    end
+  end
+  
+end
+------------------------------------------------------------------------------------------------------------
+local function DSM_Display()
+  lcd.clear()
+ 
+  if LCD_W == 480 then
+    --lcd.drawText(10,55,debugLine.."  "..rxAnswer) -- draw debug info
+    --Draw title
+    lcd.drawFilledRectangle(0, 0, LCD_W, 30, TITLE_BGCOLOR)
+    lcd.drawText(1, 5, "DSM Forward Programming", MENU_TITLE_COLOR)
+    --Draw RX Menu
+    if Phase == RX_VERSION then
+      lcd.drawText(10,50,"No compatible DSM RX...", BLINK)
+    else
+      if Menu.Title ~=  nil then
+        local attrib=0;
+        lcd.drawText(80,32,Menu.Title,MIDSIZE)
+        for i = 0, 6 do
+          if i == Menu.SelLine then
+            attrib = INVERS
+          else
+            attrib = 0
+          end
+          if Line[i] ~= nil and Line[i].Type ~= nil then
+            if Line[i].Type ~= MENU then -- list/value
+              if Line[i].Val ~= nil then
+                local text=""
+                if Line[i].Type == LIST_MENU_NOCHANGING or Line[i].Type == LIST_MENU1 or Line[i].Type == LIST_MENU2 then
+                  text = Get_Text(Line[i].Val+Line[i].Def)
+                elseif ( Line[i].Min == 0 and  Line[i].Max == 100) or ( Line[i].Min == -100 and  Line[i].Max == 100) or ( Line[i].Min == 0 and  Line[i].Max == 150) or ( Line[i].Min == -150 and  Line[i].Max == 150) then
+                  text = Line[i].Val.." %"
+                else
+                  --text = Line[i].Val .." T="..Line[i].Type  -- used for debug
+				  text = Line[i].Val
+                end
+                if Menu.EditLine == Menu.SelLine then -- blink edited entry
+                  Blink = Blink + 1
+                  if Blink > 25 then
+                    attrib = 0
+                    if Blink > 50 then
+                      Blink = 0
+                    end
+                  end
+                end
+                lcd.drawText(240,32+20*(i+2), text, attrib) -- display value
+              end
+              attrib = 0
+            end
+            lcd.drawText(10,32+20*(i+2), Line[i].Text, attrib) -- display text
+          end
+        end
+        if Menu.SelLine == -1 then
+          lcd.drawText(437,32, "Back", INVERS)
+        else
+          lcd.drawText(437,32, "Back", 0)
+        end
+        lcd.drawRectangle(437-5, 32-2, 47, 25)
+        if Menu.Next ~= 0 then
+          if Menu.SelLine == 7 then
+            lcd.drawText(437,220, "Next",INVERS)
+          else
+            lcd.drawText(437,220, "Next")
+          end
+          lcd.drawRectangle(437-5, 220-2, 47, 25)
+        end
+        if Menu.Prev ~= 0 then
+          if Menu.SelLine == 8 then
+            lcd.drawText(5,220, "Prev",INVERS)
+          else
+            lcd.drawText(5,220, "Prev")
+          end
+          lcd.drawRectangle(5-5, 220-2, 47, 25)
+        end
+      end
+      lcd.drawText(170,252, "RX "..RX.Name.." v"..RX.Version) -- display RX info
+    end
+  else
+    -- --Draw RX Menu on LCD_W=128
+    -- if multiBuffer( 4 ) == 0xFF then
+      -- lcd.drawText(2,17,"No compatible DSM RX...",SMLSIZE)
+    -- else
+      -- if Retry_128 ~= 0 then
+        -- --Intro page
+        -- Retry_128 = Retry_128 - 1
+        -- lcd.drawScreenTitle("DSM Forward Programming",0,0)
+        -- lcd.drawText(2,17,"Press Prev Page for previous Menu" ,SMLSIZE)
+      -- else
+        -- --Menu page
+        -- for line = 0, 7, 1 do
+          -- for i = 0, 21-1, 1 do
+            -- value=multiBuffer( line*21+6+i )
+            -- if value > 0x80 then
+              -- value = value - 0x80
+              -- lcd.drawText(2+i*6,1+8*line,string.char(value).." ",SMLSIZE+INVERS)
+            -- else
+              -- lcd.drawText(2+i*6,1+8*line,string.char(value),SMLSIZE)
+            -- end
+          -- end
+        -- end
+      -- end
+    -- end
+  end
+end
+------------------------------------------------------------------------------------------------------------
+-- Init
+local function DSM_Init()
+  --Set protocol to talk to
+  multiBuffer( 0, string.byte('D') )
+  --test if value has been written
+  if multiBuffer( 0 ) ~=  string.byte('D') then
+    error("Not enough memory!")
+    return 2
+  end
+  --Init TX buffer
+  multiBuffer( 3, 0x00 )
+  --Init RX buffer
+  multiBuffer( 10, 0x00 )
+  --Init telemetry
+  multiBuffer( 0, string.byte('D') )
+  multiBuffer( 1, string.byte('S') )
+  multiBuffer( 2, string.byte('M') )
+
+  --RX names--
+  RxName[0x0001]="AR636B"
+  RxName[0x0014]="SPM4651T"
+  RxName[0x0015]="AR637T"
+  RxName[0x0016]="AR637TA"
+  RxName[0x0018]="FC6250HX"
+  RxName[0x001A]="AR8360T"
+  RxName[0x001E]="AR631"
+
+  --Text to be displayed -> need to use a file instead?
+  Text[0x0001]="Off"
+  Text[0x0002]="On"
+  Text[0x0003]="Inh"
+  Text[0x0004]="Act"
+  Text[0x000C]="Inhibit?" --?
+  Text[0x000D]="Gear"
+  
+  --Lists--
+  Text[0x002E]="11ms"
+  Text[0x002F]="22ms"
+  Text[0x0032]="1 X"
+  Text[0x0033]="2 X"
+  Text[0x0034]="4 X"
+  Text[0x0035]="Inhibit?" --?
+  Text[0x0036]="Throttle"
+  Text[0x0037]="Aileron"
+  Text[0x0038]="Elevator"
+  Text[0x0039]="Rudder"
+  Text[0x003A]="Gear"
+
+  --******
+  --This part is strange since the AR637T needs
+  for i=1,7 do -- 3B..41
+    Text[0x003A+i]="Aux"..i
+  end
+  for i=1,8 do -- 41..49
+    Text[0x0041+i]="XPlus-"..i
+  end
+  --But FOTO-PETE reports that it should be:
+  Text[0x0040]="Roll"
+  Text[0x0041]="Pitch"
+  Text[0x0042]="Yaw"
+  Text[0x0043]="Gain"  -- FC6250HX
+  Text[0x0045]="Differential"
+  Text[0x0046]="Priority"
+  Text[0x0049]="Output Setup" -- FC6250HX
+  --******
+ 
+  Text[0x004A]="Failsafe"
+  Text[0x004B]="Main Menu"
+  Text[0x004E]="Position"
+  Text[0x0050]="Outputs"
+  Text[0x0051]="Output Channel 1"
+  Text[0x0052]="Output Channel 2"
+  Text[0x0053]="Output Channel 3"
+  Text[0x0054]="Output Channel 4"
+  Text[0x0055]="Output Channel 5"
+  Text[0x0056]="Output Channel 6"
+  --Text[0x005E]="Inhibit"
+  Text[0x005F]="Hold Last"
+  Text[0x0060]="Preset"
+  --Text[0x0061]="Custom"
+  --Messages--
+  Text[0x0071]="Proportional"
+  Text[0x0072]="Integral"
+  Text[0x0073]="Derivate"
+  Text[0x0078]="FM Channel"
+  Text[0x0080]="Orientation"
+  Text[0x0082]="Heading"
+  Text[0x0085]="Frame Rate"
+  Text[0x0086]="System Setup"
+  Text[0x0087]="F-Mode Setup"
+  Text[0x0088]="Enabled F-Modes"
+  Text[0x0089]="Gain Channel"
+  Text[0x008A]="Gain Sensitivity"
+  Text[0x008B]="Panic"
+  Text[0x0090]="Apply"
+  Text[0x0092]="Start"
+  Text[0x0093]="Complete"
+  Text[0x0094]="Done"
+  Text[0x0097]="Factory Reset"
+  Text[0x0099]="Advanced Setup"
+  Text[0x009A]="Capture Failsafe Positions"
+  Text[0x009C]="Custom Failsafe"
+  Text[0x00A5]="First Time Setup"
+  Text[0x00AA]="Capture Gyro Gains"
+  Text[0x00AD]="Gain Channel Select"
+  Text[0x00B0]="Self-Level/Angle Dem"
+  Text[0x00B1]="Envelope"
+  Text[0x00B5]="Inhibit"
+  Text[0x00B6]="FM1"
+  Text[0x00B7]="FM2"
+  Text[0x00B8]="FM3"
+  Text[0x00B9]="FM4"
+  Text[0x00BA]="FM5"
+  Text[0x00BB]="FM6"
+  Text[0x00BC]="FM7"
+  Text[0x00BD]="FM8"
+  Text[0x00BE]="FM9"
+  Text[0x00BF]="FM10"
+  Text[0x00C7]="Calibrate Sensor"
+  Text[0x00CA]="SAFE/Panic Mode Setup"
+  Text[0x00D3]="Swashplate"
+  Text[0x00D5]="Agility"
+  Text[0x00D8]="Stop"
+  Text[0x00DA]="SAFE"
+  Text[0x00DB]="Stability"
+  Text[0x00DC]="@ per sec"
+  Text[0x00DD]="Tail rotor"
+  Text[0x00DE]="Setup"
+  Text[0x00DF]="AFR"
+  Text[0x00E0]="Collective"
+  Text[0x00E1]="Subtrim"
+  Text[0x00E2]="Phasing"
+  Text[0x00E4]="E-Ring"
+  Text[0x00E7]="Left"
+  Text[0x00E8]="Right"
+  Text[0x00F2]="Fixed"
+  Text[0x00F3]="Adjustable"
+  Text[0x00F9]="Gyro settings"
+  Text[0x00FE]="Stick Priority"
+  Text[0x0100]="Make sure the model has been"
+  Text[0x0101]="configured, including wing type,"
+  Text[0x0102]="reversing, travel, trimmed, etc."
+  Text[0x0103]="before continuing setup."
+  Text[0x0106]="Any wing type, channel assignment,"
+  Text[0x0107]="subtrim, or servo reversing changes"
+  Text[0x0108]="require running through initial"
+  Text[0x0109]="setup again."
+  Text[0x0190]="Relearn Servo Settings"
+  Text[0x019C]="Enter Receiver Bind Mode"
+  Text[0x01D7]="SAFE Select Channel"
+  Text[0x01DC]="AS3X"
+  Text[0x01DD]="AS3X Settings"
+  Text[0x01DE]="AS3X Gains"
+  Text[0x01E0]="Rate Gains"
+  Text[0x01E2]="SAFE Settings"
+  Text[0x01E3]="SAFE Gains"
+  Text[0x01E6]="Attitude Trim"
+  Text[0x01E7]="Envelope"
+  Text[0x01E9]="Roll Right"
+  Text[0x01EA]="Roll Left"
+  Text[0x01EB]="Pitch Down"
+  Text[0x01EC]="Pitch Up"
+  Text[0x01EE]="Throttle to Pitch"
+  Text[0x01EF]="Low Thr to Pitch"
+  Text[0x01F0]="High Thr to Pitch"
+  Text[0x01F3]="Threshold"
+  Text[0x01F4]="Angle"
+  Text[0x01F6]="Failsafe Angles"
+  Text[0x01F8]="Safe Mode"
+  Text[0x01F9]="SAFE Select"
+  Text[0x01FD]="SAFE Failsafe FMode"
+  Text[0x0208]="Decay"
+  Text[0x0209]="Save to Backup"
+  Text[0x020A]="Restore from Backup"
+  Text[0x020D]="First Time SAFE Setup"
+  Text[0x021A]="Set the model level,"
+  Text[0x021B]="and press Continue."
+  Text[0x021C]="" -- empty??
+  Text[0x021D]="" -- empty??
+  Text[0x021F]="Set the model on its nose,"
+  Text[0x0220]="and press Continue. If the"
+  Text[0x0221]="orientation on the next"
+  Text[0x0222]="screen is wrong go back"
+  Text[0x0223]="and try again."
+  Text[0x0224]="Continue"
+  Text[0x0226]="Angle Limits"
+  Text[0x0227]="Other settings"
+  Text[0x0229]="Set Orientation Manually"
+  Text[0x022B]="WARNING!"
+  Text[0x022C]="This will reset the"
+  Text[0x022D]="configuration to factory"
+  Text[0x022E]="defaults. This does not"
+  Text[0x022F]="affect the backup config."
+  Text[0x0230]="" -- empty??
+  Text[0x0231]="This will overwrite the"
+  Text[0x0232]="backup memory with your"
+  Text[0x0233]="current configuartion."
+  Text[0x0234]="" -- blank line
+  Text[0x0235]="" -- blank line
+  Text[0x0236]="This will overwrite the"
+  Text[0x0237]="current config with"
+  Text[0x0238]="that which is in"
+  Text[0x0239]="the backup memory."
+  Text[0x023A]="" -- blank line
+  Text[0x023D]="Copy Flight Mode Settings"
+  Text[0x0240]="Utilities"
+  Text[0x024C]="Gains will be captured on"
+  Text[0x024D]="Captured gains will be"
+  Text[0x024E]="Gains on"
+  Text[0x024F]="were captured and changed"
+  Text[0x0250]="from Adjustable to Fixed"
+  Text[0x0254]="Postive = Up, Negative = Down"
+  Text[0x0263]="Fixed/Adjustable Gains"
+  Text[0x0266]="Heading Gain"
+  Text[0x0267]="Positive = Nose Up/Roll Right"
+  Text[0x0268]="Negative = Nose Down/Roll Left"
+  Text[0x0269]="SAFE - Throttle to Pitch"
+  Text[0x026A]="Use CAUTION for Yaw gain!"
+  Text[0x8000]="FLIGHT MODE"
+  Text[0x8001]="Flight Mode 1"
+  Text[0x8002]="Flight Mode 2"
+  Text[0x8003]="Flight Mode 3"
+end
+------------------------------------------------------------------------------------------------------------
+-- Main
+local function DSM_Run(event)
+  if event == nil then
+    error("Cannot be run as a model script!")
+    return 2
+  else
+    DSM_Menu(event)
+    DSM_Send_Receive()
+    DSM_Display()
+  end
+  if Phase == EXIT_DONE then
+    return 2
+  else
+    return 0
+  end
+end
+
+return { init=DSM_Init, run=DSM_Run }

Lua_scripts/Graupner HoTT Model Locator.lua

@@ -0,0 +1,167 @@
+---- #########################################################################
+---- #                                                                       #
+---- # Telemetry Widget script for FrSky Horus/Radio Master TX16s            #
+---- # Copyright (C) EdgeTX                                                  #
+-----#                                                                       #
+---- # License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html               #
+---- #                                                                       #
+---- # This program is free software; you can redistribute it and/or modify  #
+---- # it under the terms of the GNU General Public License version 2 as     #
+---- # published by the Free Software Foundation.                            #
+---- #                                                                       #
+---- # This program is distributed in the hope that it will be useful        #
+---- # but WITHOUT ANY WARRANTY; without even the implied warranty of        #
+---- # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         #
+---- # GNU General Public License for more details.                          #
+---- #                                                                       #
+---- #########################################################################
+
+-- Model Locator by RSSI
+-- Offer Shmuely (based on code from Scott Bauer 6/21/2015)
+-- Date: 2021
+-- ver: 0.1
+
+-- MHA (based on code from Offer Shmuely)
+-- Date: 2022
+-- ver: 0.11
+-- changes: made version for Graupner HoTT. Uses real Rssi data scaled -15db to -115db to 100..0
+
+-- This widget help to find a lost/crashed model based on the RSSI (if still available)
+-- The widget produce audio representation (variometer style) of the RSSI from the lost model
+-- The widget also  display the RSSI in a visible colorized bar (0-100%)
+
+-- There are two way to use it
+-- 1. The simple way:
+--    walk toward the quad/plane that crashed,
+--    as you get closer to your model the beeps will become more frequent with higher pitch (and a visual bar graph as well)
+--    until you get close enough to find it visually
+
+-- 2. the more accurate way:
+--    turn the antenna straight away (i.e. to point from you, straight away)
+--    try to find the weakest signal! (not the highest), i.e. the lowest RSSI you can find, this is the direction to the model.
+--    now walk to the side (not toward the model), find again the weakest signal, this is also the direction to your model
+--    triangulate the two lines, and it will be :-)
+
+local delayMillis = 100
+local nextPlayTime = getTime()
+local img = Bitmap.open("/SCRIPTS/TOOLS/Model Locator (by RSSI).png")
+
+--------------------------------------------------------------
+local function log(s)
+  --return;
+  print("locator: " .. s)
+end
+--------------------------------------------------------------
+
+
+-- init_func is called once when model is loaded
+local function init()
+  return 0
+end
+
+-- bg_func is called periodically when screen is not visible
+local function bg()
+  return 0
+end
+
+-- This function returns green at gvalue, red at rvalue and graduate in between
+local function getRangeColor(value, red_value, green_value)
+  local range = math.abs(green_value - red_value)
+  if range == 0 then
+    return lcd.RGB(0, 0xdf, 0)
+  end
+  if value == nil then
+    return lcd.RGB(0, 0xdf, 0)
+  end
+
+  if green_value > red_value then
+    if value > green_value then
+      return lcd.RGB(0, 0xdf, 0)
+    end
+    if value < red_value then
+      return lcd.RGB(0xdf, 0, 0)
+    end
+    g = math.floor(0xdf * (value - red_value) / range)
+    r = 0xdf - g
+    return lcd.RGB(r, g, 0)
+  else
+    if value > green_value then
+      return lcd.RGB(0, 0xdf, 0)
+    end
+    if value < red_value then
+      return lcd.RGB(0xdf, 0, 0)
+    end
+    r = math.floor(0xdf * (value - green_value) / range)
+    g = 0xdf - r
+    return lcd.RGB(r, g, 0)
+  end
+end
+
+local function main(event)
+
+  lcd.clear()
+  
+	-- fetch uplink rssi (HoTT sensor Rssi)
+	local rssi = getValue("Rssi")
+
+	-- calculate a percentage for the color bar (range -115db to -15db) 
+	local rssiP = rssi							
+
+	if(rssi ~= 0) then							-- rssi < 0 -> telemtry data received
+		if(rssi >= -15) then					-- -15db to -1db => 100%
+			rssiP = 100
+		else
+			if(rssi >=  -115) then			-- between -115db and -15db => 0% to 100%				
+				rssiP = 100+rssi+15				
+			else
+				rssiP = 0									-- less than -115 => 0%
+			end
+		end
+	end
+	
+  lcd.drawBitmap(img, 250, 50, 40)
+
+  -- Title
+  lcd.drawText(3, 3, "Graupner HoTT Rssi Model Locator", 0)
+  myColor = getRangeColor(rssi, 0, 100)
+  lcd.setColor(CUSTOM_COLOR, myColor)
+
+  -- draw current value
+	local dx = 0
+	if rssi < -99 then
+		dx = -33
+	end
+	
+	if rssi == 0 then	
+		lcd.drawText(115, 73, "no telemetry", DBLSIZE + CUSTOM_COLOR)
+	else
+	  lcd.drawNumber(180+dx, 30, rssi, XXLSIZE + CUSTOM_COLOR)
+		lcd.drawText(275, 73, "db", 0 + CUSTOM_COLOR)
+	end
+
+  -- draw main bar
+  lcd.setColor(CUSTOM_COLOR, YELLOW) -- RED / YELLOW
+  local xMin = 0
+  local yMin = 270
+  local xMax = 480
+  local yMax = 200
+  local h = 0
+  local rssiAsX = (rssiP * xMax) / 100
+
+  for xx = xMin, rssiAsX, 20 do
+    lcd.setColor(CUSTOM_COLOR, getRangeColor(xx, xMin, xMax - 40))
+    h = h + 10
+    lcd.drawFilledRectangle(xx, yMin - h, 15, h, CUSTOM_COLOR)
+  end
+
+  -- beep
+  if getTime() >= nextPlayTime then
+    playFile("/SCRIPTS/TOOLS/Model Locator (by RSSI).wav")
+    nextPlayTime = getTime() + delayMillis - rssiP
+  end
+
+  return 0
+end
+
+return {init = init,run = main,background = bg}
+

Lua_scripts/Graupner HoTT.lua

@@ -0,0 +1,171 @@
+---- #########################################################################
+---- #                                                                       #
+---- # Copyright (C) OpenTX                                                  #
+-----#                                                                       #
+---- # License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html               #
+---- #                                                                       #
+---- # This program is free software; you can redistribute it and/or modify  #
+---- # it under the terms of the GNU General Public License version 2 as     #
+---- # published by the Free Software Foundation.                            #
+---- #                                                                       #
+---- # This program is distributed in the hope that it will be useful        #
+---- # but WITHOUT ANY WARRANTY; without even the implied warranty of        #
+---- # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         #
+---- # GNU General Public License for more details.                          #
+---- #                                                                       #
+---- #########################################################################
+
+
+--###############################################################################
+-- Multi buffer for HoTT description
+-- To start operation:
+--   Write "HoTT" at address 0..3
+--   Write 0xFF at address 4 will request the buffer to be cleared
+--   Write 0x0F at address 5
+-- Read buffer from address 6 access the RX text for 168 bytes, 21 caracters
+--    by 8 lines
+-- Write at address 5 sends an order to the RX: 0xXF=start, 0xX7=prev page,
+--    0xXE=next page, 0xX9=enter, 0xXD=next or 0xXB=prev with X being the sensor
+--    to request data from 8=RX only, 9=Vario, A=GPS, B=Cust, C=ESC, D=GAM, E=EAM
+-- Write at address 4 the value 0xFF will request the buffer to be cleared
+-- !! Before exiting the script must write 0 at address 0 for normal operation !!
+--###############################################################################
+
+HoTT_Sensor = 0
+Timer_128 = 100
+
+local function HoTT_Release()
+  multiBuffer( 0, 0 )
+end
+
+local function HoTT_Send(button)
+  multiBuffer( 5, 0x80+(HoTT_Sensor*16) + button)
+end
+
+local function HoTT_Sensor_Inc()
+  local detected_sensors=multiBuffer( 4 )
+  local a
+  if detected_sensors ~= 0xFF then
+    repeat
+        HoTT_Sensor=(HoTT_Sensor+1)%7	-- Switch to next sensor
+        if HoTT_Sensor ~= 0 then
+          a = math.floor(detected_sensors/ (2^(HoTT_Sensor-1))) -- shift right
+        end
+    until HoTT_Sensor==0 or a % 2 == 1
+    HoTT_Send( 0x0F )
+  end
+end
+
+local function HoTT_Draw_LCD()
+  local i
+  local value
+  local line
+  local result
+  local offset=0
+  
+  local sensor_name = { "", "+Vario", "+GPS", "+Cust", "+ESC", "+GAM", "+EAM" }
+
+  lcd.clear()
+
+  if LCD_W == 480 then
+    --Draw title
+    lcd.drawFilledRectangle(0, 0, LCD_W, 30, TITLE_BGCOLOR)
+    lcd.drawText(1, 5, "Graupner HoTT: config RX" .. sensor_name[HoTT_Sensor+1] .. " - Menu cycle Sensors", MENU_TITLE_COLOR)
+    --Draw RX Menu
+    if multiBuffer( 4 ) == 0xFF then
+      lcd.drawText(10,50,"No HoTT telemetry...", BLINK)
+    else
+      for line = 0, 7, 1 do
+        for i = 0, 21-1, 1 do
+          value=multiBuffer( line*21+6+i )
+          if value > 0x80 then
+            value = value - 0x80
+            lcd.drawText(10+i*16,32+20*line,string.char(value).."   ",INVERS)
+          else
+            lcd.drawText(10+i*16,32+20*line,string.char(value))
+          end
+        end
+      end
+    end
+  else
+    --Draw RX Menu on LCD_W=128
+    if multiBuffer( 4 ) == 0xFF then
+      lcd.drawText(2,17,"No HoTT telemetry...",SMLSIZE)
+    else
+      if Timer_128 ~= 0 then
+        --Intro page
+        Timer_128 = Timer_128 - 1
+        lcd.drawScreenTitle("Graupner Hott",0,0)
+        lcd.drawText(2,17,"Configuration of RX" .. sensor_name[HoTT_Sensor+1] ,SMLSIZE)
+        lcd.drawText(2,37,"Press menu to cycle Sensors" ,SMLSIZE)
+      else
+        --Menu page
+        for line = 0, 7, 1 do
+          for i = 0, 21-1, 1 do
+            value=multiBuffer( line*21+6+i )
+            if value > 0x80 then
+              value = value - 0x80
+              lcd.drawText(2+i*6,1+8*line,string.char(value).." ",SMLSIZE+INVERS)
+            else
+              lcd.drawText(2+i*6,1+8*line,string.char(value),SMLSIZE)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+-- Init
+local function HoTT_Init()
+  --Set protocol to talk to
+  multiBuffer( 0, string.byte('H') )
+  --test if value has been written
+  if multiBuffer( 0 ) ~=  string.byte('H') then
+    error("Not enough memory!")
+    return 2
+  end
+  multiBuffer( 1, string.byte('o') )
+  multiBuffer( 2, string.byte('T') )
+  multiBuffer( 3, string.byte('T') )
+  --Request init of the RX buffer
+  multiBuffer( 4, 0xFF )
+  --Request RX to send the config menu
+  HoTT_Send( 0x0F )
+  HoTT_Sensor = 0;
+  HoTT_Detected_Sensors=0;
+  Timer_128 = 100
+end
+
+-- Main
+local function HoTT_Run(event)
+  if event == nil then
+    error("Cannot be run as a model script!")
+    return 2
+  elseif event == EVT_VIRTUAL_EXIT then
+    HoTT_Release()
+    return 2
+  else
+    if event == EVT_VIRTUAL_PREV_PAGE then
+      killEvents(event)
+      HoTT_Send( 0x07 )
+    elseif event == EVT_VIRTUAL_ENTER then
+      HoTT_Send( 0x09 )
+    elseif event == EVT_VIRTUAL_PREV then
+      HoTT_Send( 0x0B )
+    elseif event == EVT_VIRTUAL_NEXT then
+      HoTT_Send( 0x0D )
+    elseif event == EVT_VIRTUAL_NEXT_PAGE then
+      HoTT_Send( 0x0E )
+    elseif event == EVT_VIRTUAL_MENU then
+      Timer_128 = 100
+      HoTT_Sensor_Inc()
+    else
+      HoTT_Send( 0x0F )
+    end
+    HoTT_Draw_LCD()
+    return 0
+  end
+end
+
+return { init=HoTT_Init, run=HoTT_Run }

Lua_scripts/MultiChan.txt

@@ -0,0 +1,208 @@
+24,0,Assan,Std,0,CH5,CH6,CH7,CH8
+14,0,Bayang,Std,1,Flip,RTH,Pict,Video,HLess,Invert,Rates,n-a,n-a,AnAux1,AnAux2
+14,1,Bayang,H8S3D,1,Flip,RTH,Pict,Video,HLess,Invert,Rates
+14,2,Bayang,X16_AH,1,Flip,RTH,Pict,Video,HLess,Invert,Rates,TakeOf
+14,3,Bayang,IRDRONE,1,Flip,RTH,Pict,Video,HLess,Invert,Rates,TakeOf,EmStop
+14,4,Bayang,DHD_D4,1,Flip,RTH,Pict,Video,HLess,Invert,Rates,TakeOf,EmStop
+14,5,Bayang,QX100,1,Flip,RTH,Pict,Video,HLess,Invert,Rates,TakeOf,EmStop
+59,0,BayangRX,RX,1,AnAux1,AnAux2,Flip,RTH,Pict,Video
+59,1,BayangRX,CPPM,1,AnAux1,AnAux2,Flip,RTH,Pict,Video
+41,0,Bugs,3-6-8,0,Arm,Angle,Flip,Pict,Video,LED
+42,0,BugsMini,Mini,0,Arm,Angle,Flip,Pict,Video,LED
+42,1,BugsMini,3H,0,Arm,Angle,Flip,Pict,Video,LED,AltHol
+34,0,Cabell,V3,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+34,1,Cabell,V3Telem,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+13,0,CG023,Std,1,Flip,Light,Pict,Video,HLess
+13,1,CG023,YD829,1,Flip,n-a,Pict,Video,HLess
+37,0,Corona,COR_V1,0,CH5,CH6,CH7,CH8
+37,1,Corona,COR_V2,0,CH5,CH6,CH7,CH8
+37,2,Corona,FD_V3,0,CH5,CH6,CH7,CH8
+12,0,CX10,Green,1,Flip,Rate
+12,1,CX10,Blue,1,Flip,Rate,Pict,Video
+12,2,CX10,DM007,1,Flip,Mode,Pict,Video,HLess
+12,4,CX10,JC3015_1,1,Flip,Mode,Pict,Video
+12,5,CX10,JC3015_2,1,Flip,Mode,LED,DFlip
+12,6,CX10,MK33041,1,Flip,Mode,Pict,Video,HLess,RTH
+7,0,Devo,8CH,0,CH5,CH6,CH7,CH8
+7,1,Devo,10CH,0,CH5,CH6,CH7,CH8,CH9,CH10
+7,2,Devo,12CH,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12
+7,3,Devo,6CH,0,CH5,CH6
+7,4,Devo,7CH,0,CH5,CH6,CH7
+33,0,DM022,Std,1,Flip,LED,Cam1,Cam2,HLess,RTH,RLow
+6,0,DSM,2_1F,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,n-a,ThKill
+6,1,DSM,2_2F,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,n-a,ThKill
+6,2,DSM,X_1F,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,n-a,ThKill
+6,3,DSM,X_2F,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,n-a,ThKill
+6,4,DSM,AUTO,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,n-a,ThKill
+6,5,DSM,R_1F,0,AUX3,AUX4,AUX5
+70,0,DSM_RX,RX,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12
+70,1,DSM_RX,CPPM,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12
+45,0,E01X,E012,1,n-a,Flip,n-a,HLess,RTH
+45,1,E01X,E015,1,Arm,Flip,LED,HLess,RTH
+16,0,ESKY,Std,0,Gyro,Pitch
+16,1,ESKY,ET4,0,Gyro,Pitch
+35,0,ESKY150,4CH,0
+35,1,ESKY150,7CH,0,FMode,Aux6,Aux7
+69,0,ESKY150V2,Std,0,CH5_RA,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+1,0,Flysky,Flysky,0,CH5,CH6,CH7,CH8
+1,1,Flysky,V9x9,1,Flip,Light,Pict,Video
+1,2,Flysky,V6x6,1,Flip,Light,Pict,Video,HLess,RTH,XCAL,YCAL
+1,3,Flysky,V912,1,BtmBtn,TopBtn
+1,4,Flysky,CX20,0,CH5,CH6,CH7
+28,0,Flysky_AFHDS2A,PWM_IBUS,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14
+28,1,Flysky_AFHDS2A,PPM_IBUS,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14
+28,2,Flysky_AFHDS2A,PWM_SBUS,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14
+28,3,Flysky_AFHDS2A,PPM_SBUS,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14
+28,4,Flysky_AFHDS2A,PWM_IB16,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+28,5,Flysky_AFHDS2A,PPM_IB16,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+28,6,Flysky_AFHDS2A,PWM_SB16,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+28,7,Flysky_AFHDS2A,PPM_SB16,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+56,0,Flysky2A_RX,RX,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14
+56,1,Flysky2A_RX,CPPM,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14
+53,0,Height,5ch,0,Gear
+53,1,Height,8ch,0,Gear,Gyro,Flap,Light
+25,0,FrSkyV,V8,0,CH5,CH6,CH7,CH8
+3,0,FrSkyD,D8,0,CH5,CH6,CH7,CH8
+3,0,FrSkyD,D8Cloned,0,CH5,CH6,CH7,CH8
+67,0,FrSkyL,LR12,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12
+67,1,FrSkyL,LR12_6CH,0,CH5,CH6
+15,0,FrSkyX,D16_FCC,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+15,1,FrSkyX,D16_8CH_FCC,0,CH5,CH6,CH7,CH8
+15,2,FrSkyX,D16_LBT,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+15,3,FrSkyX,D16_8CH_LBT,0,CH5,CH6,CH7,CH8
+15,4,FrSkyX,D16Cloned,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+15,5,FrSkyX,D16Cloned_8CH,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+64,0,FrSkyX2,D16_FCC,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+64,1,FrSkyX2,D16_8CH_FCC,0,CH5,CH6,CH7,CH8
+64,2,FrSkyX2,D16_LBT,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+64,3,FrSkyX2,D16_8CH_LBT,1,CH5,CH6,CH7,CH8
+64,4,FrSkyX2,D16Cloned,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+64,5,FrSkyX2,D16Cloned_8CH,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+65,0,FrSkyR9,R9_915,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+65,1,FrSkyR9,R9_868,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+65,2,FrSkyR9,R9_915_8CH,0,CH5,CH6,CH7,CH8
+65,3,FrSkyR9,R9_968_8CH,0,CH5,CH6,CH7,CH8
+55,0,FrSkyRX,RX,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+55,1,FrSkyRX,CloneTX,0
+55,2,FrSkyRX,EraseTX,0
+55,3,FrSkyRX,CPPM,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+58,0,FX,816,1
+58,1,FX,620,1
+20,0,FY326,FY326,1,Flip,RTH,HLess,Expert,Calib
+20,1,FY326,FY319,1,Flip,RTH,HLess,Expert,Calib
+23,0,FY326,FY326,1,Flip,RTH,HLess,Expert
+47,0,GD00x,V1,1,Trim,LED,Rate
+47,1,GD00x,V2,1,Trim,LED,Rate
+32,0,GW008,FY326,1,Flip
+36,0,H8_3D,Std,1,Flip,Light,Pict,Video,RTH,FlMode,Cal1
+36,1,H8_3D,H20H,1,Flip,Light,Pict,Video,Opt1,Opt2,Cal1,Cal2,Gimbal
+36,2,H8_3D,H20,1,Flip,Light,Pict,Video,Opt1,Opt2,Cal1,Cal2,Gimbal
+36,3,H8_3D,H30,1,Flip,Light,Pict,Video,Opt1,Opt2,Cal1,Cal2,Gimbal
+4,0,Hisky,Std,0,Gear,Pitch,Gyro,CH8
+4,1,Hisky,HK310,0,Aux
+39,0,Hitec,Opt_Fw,0,CH5,CH6,CH7,CH8,CH9
+39,1,Hitec,Opt_Hub,0,CH5,CH6,CH7,CH8,CH9
+39,2,Hitec,Minima,0,CH5,CH6,CH7,CH8,CH9
+26,0,Hontai,Std,1,Flip,LED,Pict,Video,HLess,RTH,Calib
+26,1,Hontai,JJRCX1,1,Flip,Arm,Pict,Video,HLess,RTH,Calib
+26,2,Hontai,X5C1,1,Flip,Arm,Pict,Video,HLess,RTH,Calib
+26,3,Hontai,FQ777_951,1,Flip,Arm,Pict,Video,HLess,RTH,Calib
+57,0,HoTT,Sync,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+57,1,HoTT,No_Sync,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+2,0,Hubsan,H107,1,Flip,Light,Pict,Video,HLess
+2,1,Hubsan,H301,0,RTH,Light,Stab,Video
+2,2,Hubsan,H501,0,RTH,Light,Pict,Video,HLess,GPS_H,ALT_H,Flip,FModes
+22,0,J6Pro,Std,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12
+71,0,JJRC345,JJRC345,1,Flip,HLess,RTH,LED,UNK1,UNK2,UNK3
+71,1,JJRC345,SkyTmblr,1,Flip,HLess,RTH,LED,UNK1,UNK2,UNK3
+49,0,KF606,KF606,1,Trim
+49,1,KF606,MIG320,1,Trim,LED
+9,0,KN,WLToys,0,DRate,THold,IdleUp,Gyro,Ttrim,Atrim,Etrim
+9,1,KN,Feilun,0,DRate,THold,IdleUp,Gyro,Ttrim,Atrim,Etrim
+73,0,Kyosho,Std,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14
+18,0,MJXQ,WHL08,1,Flip,LED,Pict,Video,HLess,RTH,AuFlip,Pan,Tilt,Rate
+18,1,MJXQ,X600,1,Flip,LED,Pict,Video,HLess,RTH,AuFlip,Pan,Tilt,Rate
+18,2,MJXQ,X800,1,Flip,LED,Pict,Video,HLess,RTH,AuFlip,Pan,Tilt,Rate
+18,3,MJXQ,H26D,1,Flip,LED,Pict,Video,HLess,RTH,AuFlip,Pan,Tilt,Rate
+18,4,MJXQ,E010,1,Flip,LED,Pict,Video,HLess,RTH,AuFlip,Pan,Tilt,Rate
+18,5,MJXQ,H26WH,1,Flip,Arm,Pict,Video,HLess,RTH,AuFlip,Pan,Tilt,Rate
+18,6,MJXQ,Phoenix,1,Flip,Arm,Pict,Video,HLess,RTH,AuFlip,Pan,Tilt,Rate
+17,0,MT99XX,Std,1,Flip,LED,Pict,Video,HLess
+17,1,MT99XX,H7,1,Flip,LED,Pict,Video,HLess
+17,2,MT99XX,YZ,1,Flip,LED,Pict,Video,HLess
+17,3,MT99XX,LS,1,Flip,Invert,Pict,Video,HLess
+17,4,MT99XX,FY805,1,Flip,n-a,n-a,n-a,HLess
+17,5,MT99XX,A180,0,3D_6G
+17,6,MT99XX,Dragon,0,Mode,RTH
+17,7,MT99XX,F949G,0,6G_3D,Light
+44,0,NCC1701,Std,1,Warp
+77,0,OMP,M2,0,THold,IdleUp,6G_3D
+60,0,Pelikan,PRO_V4,0,CH5,CH6,CH7,CH8
+60,1,Pelikan,LITE_V4,0,CH5,CH6,CH7,CH8
+60,2,Pelikan,SCX24,0
+51,0,Potensic,A20,1,TakLan,Emerg,Mode,HLess
+66,0,Propel,74-Z,1,LEDs,RollCW,RolCCW,Fire,Weapon,Calib,AltHol,TakeOf,Land,Train
+29,0,Q2x2,Q222,1,Flip,LED,Mod2,Mod1,HLess,RTH,XCal,YCal
+29,1,Q2x2,Q242,1,Flip,LED,Pict,Video,HLess,RTH,XCal,YCal
+29,2,Q2x2,Q282,1,Flip,LED,Pict,Video,HLess,RTH,XCal,YCal
+31,0,Q303,Q303,1,AltHol,Flip,Pict,Video,HLess,RTH,Gimbal
+31,1,Q303,C35,1,Arm,VTX,Pict,Video,n-a,RTH,Gimbal
+31,2,Q303,CX10D,1,Arm,Flip
+31,3,Q303,CX10WD,1,Arm,Flip
+72,0,Q90C,Std,0,FMode,VTX+
+74,0,RadioLink,Surface,0,CH5,CH6,CH7,CH8,FS_CH1,FS_CH2,FS_CH3,FS_CH4,FS_CH5,FS_CH6,FS_CH7,FS_CH8
+74,1,RadioLink,Air,0,CH5,CH6,CH7,CH8,FS_CH1,FS_CH2,FS_CH3,FS_CH4,FS_CH5,FS_CH6,FS_CH7,FS_CH8
+74,2,RadioLink,DumboRC,0,CH5,CH6,CH7,CH8,FS_CH1,FS_CH2,FS_CH3,FS_CH4,FS_CH5,FS_CH6,FS_CH7,FS_CH8
+76,0,Realacc,R11,1,Flip,Light,Calib,HLess,RTH,UNK
+50,0,Redpine,Fast,0,sCH5,sCH6,sCH7,sCH8,sCH9,sCH10,sCH11,sCH12,sCH13,sCH14,sCH15,sCH16
+50,1,Redpine,Slow,0,sCH5,sCH6,sCH7,sCH8,sCH9,sCH10,sCH11,sCH12,sCH13,sCH14,sCH15,sCH16
+21,0,Futaba,SFHSS,0,CH5,CH6,CH7,CH8
+19,0,Shenqi,Cycle,1
+68,0,Skyartec,Std,0,CH5,CH6,CH7
+11,0,SLT,V1,0,Gear,Pitch
+11,1,SLT,V2,0,CH5,CH6,CH7,CH8
+11,2,SLT,Q100,0,Rates,n-a,CH7,CH8,Mode,Flip,n-a,n-a,Calib
+11,3,SLT,Q200,0,Rates,n-a,CH7,CH8,Mode,VidOn,VidOff,Calib
+11,4,SLT,MR100,0,Rates,n-a,CH7,CH8,Mode,Flip,Video,Pict
+10,0,Symax,Std,1,Flip,Rates,Pict,Video,HLess
+10,1,Symax,X5C,1,Flip,Rates,Pict,Video,HLess
+61,0,Tiger,Std,1,Flip,Light
+43,0,Traxxas,6519,0
+5,0,V2x2,Std,1,Flip,Light,Pict,Video,HLess,CalX,CalY
+5,1,V2x2,JXD506,1,Flip,Light,Pict,Video,HLess,StaSto,Emerg,Cam_UD
+48,0,V761,3CH,0,Gyro,Calib,Flip,RtnAct,Rtn
+48,1,V761,4CH,0,Gyro,Calib,Flip,RtnAct,Rtn
+48,2,V761,TOPRC,0,Gyro,Calib,Flip,RtnAct,Rtn
+46,0,V911s,V911s,1,Calib,Rate
+46,1,V911s,E119,1,Calib,Rate,6G_3D
+22,0,WFLY,WFR0xS,0,CH5,CH6,CH7,CH8,CH9
+30,0,WK2x01,WK2801,0,CH5,CH6,CH7,CH8
+30,1,WK2x01,WK2401,0
+30,2,WK2x01,W6_5_1,0,Gear,Dis,Gyro
+30,3,WK2x01,W6_6_1,0,Gear,Col,Gyro
+30,4,WK2x01,W6HEL,0,Gear,Col,Gyro
+30,5,WK2x01,W6HEL_I,0,Gear,Col,Gyro
+62,0,XK,X450,1,FMode,TakeOf,Emerg,3D_6G,Pict,Video
+62,1,XK,X420,1,FMode,TakeOf,Emerg,3D_6G,Pict,Video
+8,0,YD717,Std,1,Flip,Light,Pict,Video,HLess
+8,1,YD717,SkyWlkr,1,Flip,Light,Pict,Video,HLess
+8,2,YD717,Simax4,1,Flip,Light,Pict,Video,HLess
+8,3,YD717,XinXun,1,Flip,Light,Pict,Video,HLess
+8,4,YD717,NiHui,1,Flip,Light,Pict,Video,HLess
+52,0,ZSX,280,1,Light
+78,0,M-Link,Std,0,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16
+79,0,WFLY2,RF20x,0,CH5,CH6,CH7,CH8,CH9,CH10
+80,0,E016Hv2,E016Hv2,1,TakLan,EmStop,Flip,Calib,HLess,RTH
+81,0,E010r5,E010r5,1,Flip,LED,CALIB,HLess,RTH,GLIDE
+82,0,LOLI,Std,0,CH5,CH6,CH7,CH8,1SwSePpPw,2SwSePw,3SwSe,4SwSe,5SwSeSb,6SwSe,7SwSePw,8SwSe
+83,0,E129,E129,1,TakLan,EmStop,TrimA,TrimE,TrimR
+83,1,E129,C186,1,TakLan,EmStop,TrimA,TrimE,TrimR
+84,0,JOYSWAY,Std,0
+85,0,E016H,Std,1,Stop,Flip,n-a,HLess,RTH
+87,0,IKEA
+89,0,LOSI
+90,0,MouldKg,Analog,0
+90,1,MouldKg,Digit,0
+91,0,Xerall,Tank,0,FlTa,TakLan,Rate,HLess,Photo,Video,TrimR,TrimE,TrimA
+92,0,MT99xx2,PA18,0,MODE,FLIP,RTH
+93,0,Kyosho2,KT-17,0

Lua_scripts/MultiChannelsUpdater.lua

@@ -0,0 +1,327 @@
+
+local toolName = "TNS|Multi chan namer|TNE"
+
+---- #########################################################################
+---- #                                                                       #
+---- # Copyright (C) OpenTX                                                  #
+-----#                                                                       #
+---- # License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html               #
+---- #                                                                       #
+---- # This program is free software; you can redistribute it and/or modify  #
+---- # it under the terms of the GNU General Public License version 2 as     #
+---- # published by the Free Software Foundation.                            #
+---- #                                                                       #
+---- # This program is distributed in the hope that it will be useful        #
+---- # but WITHOUT ANY WARRANTY; without even the implied warranty of        #
+---- # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         #
+---- # GNU General Public License for more details.                          #
+---- #                                                                       #
+---- #########################################################################
+
+local protocol_name = ""
+local sub_protocol_name = ""
+local bind_ch = 0
+local module_conf = {}
+local module_pos = "Internal"
+local file_ok = 0
+local done = 0
+local protocol = 0
+local sub_protocol = 0
+local f_seek = 0
+local channel_names={}
+local num_search = "Searching"
+
+local function drawScreenTitle(title)
+    if LCD_W == 480 then
+        lcd.drawFilledRectangle(0, 0, LCD_W, 30, TITLE_BGCOLOR)
+        lcd.drawText(1, 5, title, MENU_TITLE_COLOR)
+    else
+        lcd.drawScreenTitle(title, 0, 0)
+    end
+end
+
+function bitand(a, b)
+    local result = 0
+    local bitval = 1
+    while a > 0 and b > 0 do
+      if a % 2 == 1 and b % 2 == 1 then -- test the rightmost bits
+          result = result + bitval      -- set the current bit
+      end
+      bitval = bitval * 2 -- shift left
+      a = math.floor(a/2) -- shift right
+      b = math.floor(b/2)
+    end
+    return result
+end
+
+local function Multi_Draw_LCD(event)
+  local line = 0
+
+  lcd.clear()
+  drawScreenTitle("Multi channels namer")
+
+  --Display settings
+  local lcd_opt = 0
+  if LCD_W == 480 then
+    x_pos = 10
+    y_pos = 32
+    y_inc = 20
+  else
+    x_pos = 0
+    y_pos = 9
+    y_inc = 8
+    lcd_opt = SMLSIZE
+  end
+
+  --Multi Module detection
+  if module_conf["Type"] ~= 6 then
+    if LCD_W == 480 then
+      lcd.drawText(10,50,"No Multi module configured...", BLINK)
+    else
+      --Draw on LCD_W=128
+      lcd.drawText(2,17,"No Multi module configured...",SMLSIZE)
+    end
+    return
+  else
+    lcd.drawText(x_pos, y_pos+y_inc*line,module_pos .. " Multi detected.", lcd_opt)
+    line = line + 1
+  end
+
+  --Channel order
+  if (ch_order == -1) then
+    lcd.drawText(x_pos, y_pos+y_inc*line,"Channels order can't be read from Multi...", lcd_opt)
+    line = line + 1
+  end
+
+  --Can't open file MultiChan.txt
+  if file_ok == 0 then
+    lcd.drawText(x_pos, y_pos+y_inc*line,"Can't read MultiChan.txt file...", lcd_opt)
+    return
+  end
+
+  if ( protocol_name == "" or sub_protocol_name == "" ) and f_seek ~=-1 then
+    local f = io.open("/SCRIPTS/TOOLS/MultiChan.txt", "r")
+    if f == nil then return end
+    lcd.drawText(x_pos, y_pos+y_inc*line,num_search, lcd_opt)
+    num_search = num_search .. "."
+    if #num_search > 15 then
+      num_search = string.sub(num_search,1,9)
+    end
+    local proto = 0
+    local sub_proto = 0
+    local proto_name = ""
+    local sub_proto_name = ""
+    local channels = ""
+    local nbr_try = 0
+    local nbr_car = 0
+    repeat
+      io.seek(f, f_seek)
+      local data = io.read(f, 100)      -- read 100 characters
+      if #data ==0 then
+          f_seek = -1                   -- end of file
+          break
+      end
+      proto, sub_proto, proto_name, sub_proto_name, bind_ch, channels = string.match(data,'(%d+),(%d),([%w-_ ]+),([%w-_ ]+),(%d)(.+)')
+      if proto ~= nil and sub_proto ~= nil and protocol_name ~= nil and sub_protocol_name ~= nil and bind_ch ~= nil then
+        if tonumber(proto) == protocol and tonumber(sub_proto) == sub_protocol then
+          protocol_name = proto_name
+          sub_protocol_name = sub_proto_name
+          bind_ch = tonumber(bind_ch)
+          if channels ~= nil then
+            --extract channel names
+            nbr_car = string.find(channels, "\r")
+            if nbr_car == nil then nbr_car = string.find(channels, "\n") end
+            if nbr_car ~= nil then
+              channels = string.sub(channels,1,nbr_car-1)
+            end
+            local i = 5
+            for k in string.gmatch(channels, ",([%w-_ ]+)") do
+              channel_names[i] = k
+              i = i + 1
+            end
+          end
+          f_seek = -1                   -- protocol found
+          break
+        end
+      end
+      if f_seek ~= -1 then
+        nbr_car = string.find(data, "\n")
+        if nbr_car == nil then nbr_car = string.find(data, "\r") end
+        if nbr_car == nil then
+          f_seek = -1                   -- end of file
+          break
+        end
+        f_seek = f_seek + nbr_car       -- seek to next line
+        nbr_try = nbr_try + 1
+      end
+    until nbr_try > 20 or f_seek == -1
+    io.close(f)
+  end
+  
+  if f_seek ~= -1 then
+    return -- continue searching...
+  end
+
+  --Protocol & Sub_protocol
+  if protocol_name == "" or sub_protocol_name == "" then
+    lcd.drawText(x_pos, y_pos+y_inc*line,"Unknown protocol "..tostring(protocol).."/"..tostring(sub_protocol).." ...", lcd_opt)
+    return
+  elseif LCD_W > 128 then
+    lcd.drawText(x_pos, y_pos+y_inc*line,"Protocol: " .. protocol_name .. " / SubProtocol: " .. sub_protocol_name, lcd_opt)
+    line = line + 1
+  else
+    lcd.drawText(x_pos, y_pos+y_inc*line,"Protocol: " .. protocol_name, lcd_opt)
+    line = line + 1
+    lcd.drawText(x_pos, y_pos+y_inc*line,"SubProtocol: " .. sub_protocol_name, lcd_opt)
+    line = line + 1
+  end
+
+  text1=""
+  text2=""
+  for i,v in ipairs(channel_names) do
+    if i<=8 then
+      if i==1 then
+        text1 = v
+      else
+        text1=text1 .. "," .. v
+      end
+    else
+      if i==9 then
+        text2 = v
+      else
+        text2=text2 .. "," .. v
+      end
+    end
+  end
+  if LCD_W > 128 then
+    lcd.drawText(x_pos, y_pos+y_inc*line,"Channels: " .. text1, lcd_opt)
+    line = line + 1
+    if text2 ~= "" then
+      lcd.drawText(x_pos*9, y_pos+y_inc*line,text2, lcd_opt)
+      line = line + 1
+    end
+  end
+
+  if event ~= EVT_VIRTUAL_ENTER and done == 0 then
+    lcd.drawText(x_pos, y_pos+y_inc*line,"<ENT> Save", lcd_opt + INVERS + BLINK)
+    return
+  end
+  
+  lcd.drawText(x_pos, y_pos+y_inc*line,"Setting channel names.", lcd_opt)
+  line = line + 1
+  local output, nbr
+  if done == 0 then
+    for i,v in ipairs(channel_names) do
+      output = model.getOutput(i-1)
+      output["name"] = v
+      model.setOutput(i-1,output)
+      nbr = i
+    end
+    for i = nbr, 15 do
+      output = model.getOutput(i)
+      output["name"] = "n-a"
+      model.setOutput(i,output)
+    end
+    if bind_ch == 1 then
+      output = model.getOutput(15)
+      output["name"] = "BindCH"
+      model.setOutput(15,output)
+    end
+    done = 1
+  end
+  lcd.drawText(x_pos, y_pos+y_inc*line,"Done!", lcd_opt)
+  line = line + 1
+end
+
+-- Init
+local function Multi_Init()
+  module_conf = model.getModule(0)
+  if module_conf["Type"] ~= 6 then
+    module_pos = "External"
+    module_conf = model.getModule(1)
+    if module_conf["Type"] ~= 6 then
+      return
+    end
+  end
+
+  protocol = module_conf["protocol"]
+  sub_protocol = module_conf["subProtocol"]
+
+  --Exceptions on first 4 channels...
+  local stick_names = { "Rud", "Ele", "Thr", "Ail" }
+  if ( protocol == 4 and sub_protocol == 1 ) or protocol == 19  or protocol == 52 then -- Hisky/HK310, Shenqi, ZSX
+    stick_names[2] = "n-a"
+    stick_names[4] = "n-a"
+  elseif protocol == 43 then -- Traxxas
+    stick_names[2] = "Aux4"
+    stick_names[4] = "Aux3"
+  elseif ( protocol == 48 and sub_protocol == 0 ) then -- V761 3CH
+    stick_names[4] = "n-a"
+  elseif protocol == 47 or  protocol == 49 or  protocol == 58 then -- GD00x, KF606, FX816
+    stick_names[1] = "n-a"
+    stick_names[2] = "n-a"
+  end
+
+  --Determine fist 4 channels order
+  local ch_order=module_conf["channelsOrder"]
+  if (ch_order == -1) then
+    channel_names[1] = stick_names[defaultChannel(0)+1]
+    channel_names[2] = stick_names[defaultChannel(1)+1]
+    channel_names[3] = stick_names[defaultChannel(2)+1]
+    channel_names[4] = stick_names[defaultChannel(3)+1]
+  else
+    channel_names[bitand(ch_order,3)+1] = stick_names[4]
+    ch_order = math.floor(ch_order/4)
+    channel_names[bitand(ch_order,3)+1] = stick_names[2]
+    ch_order = math.floor(ch_order/4)
+    channel_names[bitand(ch_order,3)+1] = stick_names[3]
+    ch_order = math.floor(ch_order/4)
+    channel_names[bitand(ch_order,3)+1] = stick_names[1]
+  end
+ 
+  --Exceptions on first 4 channels...
+  if ( protocol == 73 or (protocol == 74 and sub_protocol == 0) or (protocol == 60 and sub_protocol == 2) or protocol == 89) then -- Kyosho or RadioLink Surface or Pelikan/SCX24 or Losi
+    channel_names[1] = "ST"
+    channel_names[2] = "THR"
+    channel_names[3] = "CH3"
+    if(protocol == 60 and sub_protocol == 2) then
+      channel_names[4] = "n-a"
+    else
+      channel_names[4] = "CH4"
+    end
+  end
+  if ( protocol == 6 and sub_protocol == 5 ) then -- DSMR
+    channel_names[1] = "ST"
+    channel_names[2] = "THR"
+    channel_names[3] = "AUX1"
+    channel_names[4] = "AUX2"
+  end
+  if ( protocol == 90 ) then -- Mould King
+    channel_names[1] = "A"
+    channel_names[2] = "B"
+    channel_names[3] = "C"
+    channel_names[4] = "D"
+  end
+ 
+  --Check MultiChan.txt
+  local f = io.open("/SCRIPTS/TOOLS/MultiChan.txt", "r")
+  if f == nil then return end
+  file_ok = 1
+  io.close(f)
+end
+
+-- Main
+local function Multi_Run(event)
+  if event == nil then
+    error("Cannot be run as a model script!")
+    return 2
+  else
+    Multi_Draw_LCD(event)
+    if event == EVT_VIRTUAL_EXIT then
+      return 2
+    end
+  end
+  return 0
+end
+
+return { init=Multi_Init, run=Multi_Run }

Lua_scripts/MultiConfig.lua

@@ -0,0 +1,529 @@
+---- #########################################################################
+---- #                                                                       #
+---- # Copyright (C) OpenTX                                                  #
+-----#                                                                       #
+---- # License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html               #
+---- #                                                                       #
+---- # This program is free software; you can redistribute it and/or modify  #
+---- # it under the terms of the GNU General Public License version 2 as     #
+---- # published by the Free Software Foundation.                            #
+---- #                                                                       #
+---- # This program is distributed in the hope that it will be useful        #
+---- # but WITHOUT ANY WARRANTY; without even the implied warranty of        #
+---- # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         #
+---- # GNU General Public License for more details.                          #
+---- #                                                                       #
+---- #########################################################################
+
+
+--###############################################################################
+-- Multi buffer for Config description
+-- To start operation:
+--   Write 0xFF at address 4 will request the buffer to be cleared
+--   Write "Conf" at address 0..3
+-- Read
+--   Read at address 12 gives the current config page
+--   Read at address 13..172 gives the current data of the page = 8 lines * 20 caracters
+-- Write
+--   Write at address 5..11 the command
+--   Write 0x01 at address 4 will send the command to the module
+-- !! Before exiting the script must write 0 at address 0 for normal operation !!
+--###############################################################################
+
+local Version = "v0.2"
+local Focus = -1
+local Page = 0
+local Edit = -1
+local Edit_pos = 1
+local Menu = { {text = "", field_type = 0, field_len = 0, field_value = {}, field_text = ""},
+               {text = "", field_type = 0, field_len = 0, field_value = {}, field_text = ""},
+               {text = "", field_type = 0, field_len = 0, field_value = {}, field_text = ""},
+               {text = "", field_type = 0, field_len = 0, field_value = {}, field_text = ""},
+               {text = "", field_type = 0, field_len = 0, field_value = {}, field_text = ""},
+               {text = "", field_type = 0, field_len = 0, field_value = {}, field_text = ""},
+               {text = "", field_type = 0, field_len = 0, field_value = {}, field_text = ""} }
+local Menu_value = {}
+local Blink = 0
+local ModuleNumber = 0
+local ModuleType = ""
+local Module = {}
+local InitialProtocol = 0
+local InitialSubProtocol = 0
+
+function bitand(a, b)
+    local result = 0
+    local bitval = 1
+    while a > 0 and b > 0 do
+      if a % 2 == 1 and b % 2 == 1 then -- test the rightmost bits
+          result = result + bitval      -- set the current bit
+      end
+      bitval = bitval * 2 -- shift left
+      a = math.floor(a/2) -- shift right
+      b = math.floor(b/2)
+    end
+    return result
+end
+
+local function Config_Send(page, line, value)
+  local i
+  i = (page*16) + line
+  multiBuffer( 5, i )
+  for i = 1 , 6 , 1 do
+    multiBuffer( 5+i, value[i] )
+  end
+  multiBuffer( 4, 1 )
+end
+
+local function Config_Release()
+  --Set the protocol back to what it was
+  Module.protocol = InitialProtocol
+  Module.subProtocol = InitialSubProtocol
+  model.setModule(ModuleNumber, Module)
+
+  --Stop requesting updates
+  local i
+  for i = 3 , 0 , -1 do
+    multiBuffer( i, 0 )
+  end
+end
+
+local function Config_Page( )
+  Config_Send(Page, 0, { 0, 0, 0, 0, 0, 0 })
+end
+
+local function Config_Draw_Edit( event )
+  local i
+  local text
+
+  if Menu[Focus].field_type == 0xD0 then
+  -- Editable Hex value
+    if Edit == -1 then
+    -- Init
+      Edit = 0
+      Edit_pos = 1
+      Blink = 0
+      for i = 1, Menu[Focus].field_len, 1 do
+        Menu_value[i] = Menu[Focus].field_value[i]
+      end
+    end
+    if Edit == 0 then
+    -- Not editing value
+      if event == EVT_VIRTUAL_ENTER then
+        if Edit_pos > Menu[Focus].field_len then
+        -- Save or Cancel
+          Edit = -1
+          if Edit_pos == Menu[Focus].field_len + 1 then
+          -- Save
+            Config_Send(Page, Focus, Menu_value)
+          end
+          return
+        else
+        -- Switch to edit mode
+          Edit = 1
+        end
+      elseif event == EVT_VIRTUAL_PREV and Edit_pos > 1 then
+      -- Move cursor
+        Edit_pos = Edit_pos - 1
+      elseif event == EVT_VIRTUAL_NEXT and Edit_pos < Menu[Focus].field_len + 2 then
+      -- Move cursor
+        Edit_pos = Edit_pos + 1
+      end
+    else
+    -- Editing value
+      if event == EVT_VIRTUAL_ENTER then
+      -- End edit
+        Edit = 0
+      elseif event == EVT_VIRTUAL_PREV then
+      -- Change value
+        Menu_value[Edit_pos] = Menu_value[Edit_pos] - 1
+      elseif event == EVT_VIRTUAL_NEXT then
+      -- Change value
+        Menu_value[Edit_pos] = Menu_value[Edit_pos] + 1
+      end
+      --Blink
+      Blink = Blink + 1
+      if Blink > 30 then
+        Blink = 0
+      end
+    end
+    --Display
+    if LCD_W == 480 then
+      lcd.drawRectangle(160-1, 100-1, 160+2, 55+2, TEXT_COLOR)
+      lcd.drawFilledRectangle(160, 100, 160, 55, TEXT_BGCOLOR)
+    else
+      lcd.clear()
+    end
+    for i = 1, Menu[Focus].field_len, 1 do
+      if i==Edit_pos and (Edit ~= 1 or Blink > 15) then
+        attrib = INVERS
+      else
+        attrib = 0
+      end
+      if LCD_W == 480 then
+        lcd.drawText(170+12*2*(i-1), 110, string.format('%02X', Menu_value[i]), attrib)
+      else
+        lcd.drawText(17+6*2*(i-1), 10, string.format('%02X', Menu_value[i]), attrib + SMLSIZE)
+      end
+    end
+    if Edit_pos == Menu[Focus].field_len + 1 then
+      attrib = INVERS
+    else
+      attrib = 0
+    end
+    if LCD_W == 480 then
+      lcd.drawText(170, 130, "Save", attrib)
+    else
+      lcd.drawText(17, 30, "Save", attrib + SMLSIZE)
+    end
+    if Edit_pos == Menu[Focus].field_len + 2 then
+      attrib = INVERS
+    else
+      attrib = 0
+    end
+    if LCD_W == 480 then
+      lcd.drawText(260, 130, "Cancel", attrib)
+    else
+      lcd.drawText(77, 30, "Cancel", attrib + SMLSIZE)
+    end
+
+  elseif Menu[Focus].field_type == 0x90 then
+  -- Action text
+    if Edit == -1 then
+    -- Init
+      Edit = 0
+      Edit_pos = 2
+    end
+    if event == EVT_VIRTUAL_ENTER then
+      -- Exit
+      Edit = -1
+      if Edit_pos == 1 then
+      -- Yes
+        Config_Send(Page, Focus, { 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA } )
+      end
+      return
+    elseif event == EVT_VIRTUAL_PREV and Edit_pos > 1 then
+    -- Switch to Yes
+      Edit_pos = Edit_pos - 1
+    elseif event == EVT_VIRTUAL_NEXT and Edit_pos < 2 then
+    -- Switch to No
+      Edit_pos = Edit_pos + 1
+    end
+    -- Display
+    if LCD_W == 480 then
+      lcd.drawRectangle(160-1, 100-1, 160+2, 55+2, TEXT_COLOR)
+      lcd.drawFilledRectangle(160, 100, 160, 55, TEXT_BGCOLOR)
+    else
+      lcd.clear()
+    end
+    if LCD_W == 480 then
+      lcd.drawText(170, 110, Menu[Focus].field_text .. "?")
+    else
+      lcd.drawText(17, 10, Menu[Focus].field_text .. "?", SMLSIZE)
+    end
+    if Edit_pos == 1 then
+      attrib = INVERS
+    else
+      attrib = 0
+    end
+    if LCD_W == 480 then
+      lcd.drawText(170, 130, "Yes", attrib)
+    else
+      lcd.drawText(17, 30, "Yes", attrib + SMLSIZE)
+    end
+    if Edit_pos == 2 then
+      attrib = INVERS
+    else
+      attrib = 0
+    end
+    if LCD_W == 480 then
+      lcd.drawText(260, 130, "No", attrib)
+    else
+      lcd.drawText(77, 30, "No", attrib)
+    end
+  end
+end
+
+local function Config_Next_Prev( event )
+-- Next Prev on main menu
+  local line
+  if event == EVT_VIRTUAL_PREV then
+    for line = Focus - 1, 1, -1 do
+      if Menu[line].field_type >= 0x80 and Menu[line].field_type ~= 0xA0 and Menu[line].field_type ~= 0xC0 then
+        Focus = line
+        break
+      end
+    end
+  elseif event == EVT_VIRTUAL_NEXT then
+    for line = Focus + 1, 7, 1 do
+      if Menu[line].field_type >= 0x80 and Menu[line].field_type ~= 0xA0 and Menu[line].field_type ~= 0xC0 then
+        Focus = line
+        break
+      end
+    end
+  end
+end
+
+local function Config_Draw_Menu()
+-- Main menu
+  local i
+  local value
+  local line
+  local length
+  local text
+  
+  lcd.clear()
+
+  if LCD_W == 480 then
+    --Draw title
+    lcd.drawFilledRectangle(0, 0, LCD_W, 30, TITLE_BGCOLOR)
+    lcd.drawText(1, 5, "Multi Config " .. Version, MENU_TITLE_COLOR)
+    if multiBuffer(13) == 0x00 then
+      lcd.drawText(10,50,"No Config telemetry...", BLINK)
+    end
+  else
+    --Draw on LCD_W=128
+    lcd.drawText(1, 0, "Multi Config " .. Version, SMLSIZE)
+    if multiBuffer(13) == 0x00 then
+      lcd.drawText(2,17,"No Config telemetry...",SMLSIZE)
+    end
+  end
+
+  if multiBuffer(13) ~= 0x00 then
+    if LCD_W == 480 then
+      --Draw firmware version and channels order
+      local ch_order = multiBuffer(17)
+      local channel_names = {}
+      channel_names[bitand(ch_order,3)+1] = "A"
+      ch_order = math.floor(ch_order/4)
+      channel_names[bitand(ch_order,3)+1] = "E"
+      ch_order = math.floor(ch_order/4)
+      channel_names[bitand(ch_order,3)+1] = "T"
+      ch_order = math.floor(ch_order/4)
+      channel_names[bitand(ch_order,3)+1] = "R"
+      lcd.drawText(150, 5, ModuleType.." v" .. multiBuffer(13) .. "." .. multiBuffer(14) .. "." .. multiBuffer(15) .. "." .. multiBuffer(16) .. " " .. channel_names[1] .. channel_names[2] .. channel_names[3] .. channel_names[4], MENU_TITLE_COLOR)
+    else
+      lcd.drawText(76, 0, "/Fw" .. multiBuffer(13) .. "." .. multiBuffer(14) .. "." .. multiBuffer(15) .. "." .. multiBuffer(16),SMLSIZE) -- .. " " .. channel_names[1] .. channel_names[2] .. channel_names[3] .. channel_names[4])
+    end
+
+    --Draw Menu
+    for line = 1, 7, 1 do
+      --Clear line info
+      Menu[line].text = ""
+      Menu[line].field_type = 0
+      Menu[line].field_len = 0
+      for i = 1, 7, 1 do
+        Menu[line].field_value[i] = 0
+      end
+      Menu[line].field_text = ""
+      length = 0
+      --Read line from buffer
+      for i = 0, 20-1, 1 do
+        value=multiBuffer( line*20+13+i )
+        if value == 0 then
+          break   -- end of line
+        end
+        if value > 0x80 and Menu[line].field_type == 0 then
+        -- Read field type
+          Menu[line].field_type = bitand(value, 0xF0)
+          Menu[line].field_len = bitand(value, 0x0F)
+          length = Menu[line].field_len
+          if Menu[line].field_type ~= 0xA0 and Menu[line].field_type ~= 0xC0 and Focus == -1 then
+          -- First actionnable field if nothing was selected
+            Focus = line;
+          end
+        else
+          if Menu[line].field_type == 0 then
+          -- Text
+            Menu[line].text = Menu[line].text .. string.char(value)
+          else
+          -- Menu specific fields
+            length = length - 1
+            if Menu[line].field_type == 0x80 or Menu[line].field_type == 0x90 then
+              Menu[line].field_text = Menu[line].field_text .. string.char(value)
+            else
+              Menu[line].field_value[Menu[line].field_len-length] = value
+            end
+            if length == 0 then
+            -- End of fields
+              break
+            end
+          end
+        end
+      end
+      -- Display menu text
+      if Menu[line].text ~= "" then
+        if Menu[line].field_type == 0xA0 or Menu[line].field_type == 0xB0 or Menu[line].field_type == 0xC0 or Menu[line].field_type == 0xD0 then
+          Menu[line].text = Menu[line].text .. ":"
+        end
+        if LCD_W == 480 then
+          lcd.drawText(10,32+20*line,Menu[line].text )
+        else
+          lcd.drawText(2,1+8*line,Menu[line].text,SMLSIZE)
+        end
+      end
+      -- Display specific fields
+      if line == Focus then
+        attrib = INVERS
+      else
+        attrib = 0
+      end
+      if Menu[line].field_type == 0x80 or Menu[line].field_type == 0x90 then
+      -- Text
+        if LCD_W == 480 then
+          lcd.drawText(10+9*#Menu[line].text, 32+20*line, Menu[line].field_text, attrib)
+        else
+          lcd.drawText(2+5*#Menu[line].text, 1+8*line, Menu[line].field_text, SMLSIZE + attrib)
+        end
+      elseif Menu[line].field_type == 0xA0 or Menu[line].field_type == 0xB0 then
+      -- Decimal value
+        value = 0
+        for i = 1, Menu[line].field_len, 1 do
+          value = value*256 + value
+        end
+        if LCD_W == 480 then
+          lcd.drawText(10+9*#Menu[line].text, 32+20*line, value, attrib)
+        else
+          lcd.drawText(2+5*#Menu[line].text, 1+8*line, value, SMLSIZE + attrib)
+        end
+      elseif Menu[line].field_type == 0xC0 or Menu[line].field_type == 0xD0 then
+      -- Hex value
+        text=""
+        for i = 1, Menu[line].field_len, 1 do
+          text = text .. string.format('%02X ', Menu[line].field_value[i])
+        end
+        if LCD_W == 480 then
+          lcd.drawText(10+9*#Menu[line].text, 32+20*line, text, attrib)
+        else
+          lcd.drawText(2+5*#Menu[line].text, 1+8*line, text, SMLSIZE + attrib)
+        end
+      end
+    end
+  end
+end
+
+-- Init
+local function Config_Init()
+  --Find Multi module
+  Module_int = model.getModule(0)
+  Module_ext = model.getModule(1)
+  if Module_int["Type"] ~= 6 and Module_ext["Type"] ~= 6 then
+    error("No Multi module detected...")
+    return 2
+  end
+  if Module_int["Type"] == 6 and Module_ext["Type"] == 6 then
+    error("Two Multi modules detected, turn on only the one to be configured.")
+    return 2
+  end
+  if Module_int["Type"] == 6 then
+    ModuleNumber = 0
+    ModuleType = "Internal"
+  else
+    ModuleNumber = 1
+    ModuleType = "External"
+  end
+  --Get Module settings and set it to config protocol
+  Module = model.getModule(ModuleNumber)
+  InitialProtocol = Module.protocol
+  InitialSubProtocol = Module.subProtocol
+  Module.protocol = 86
+  Module.subProtocol = 0
+  model.setModule(ModuleNumber, Module)
+  --pause while waiting for the module to switch to config
+  for i = 0, 10, 1 do end
+
+  --Set protocol to talk to
+  multiBuffer( 0, string.byte('C') )
+  --test if value has been written
+  if multiBuffer( 0 ) ~=  string.byte('C') then
+    error("Not enough memory!")
+    return 2
+  end
+
+  --Request init of the buffer
+  multiBuffer( 4, 0xFF )
+  multiBuffer(13, 0x00 )
+
+  --Continue buffer init
+  multiBuffer( 1, string.byte('o') )
+  multiBuffer( 2, string.byte('n') )
+  multiBuffer( 3, string.byte('f') )
+
+  -- Test set
+  -- multiBuffer( 12, 0 )
+  -- multiBuffer( 13, 1 )
+  -- multiBuffer( 14, 3 )
+  -- multiBuffer( 15, 2 )
+  -- multiBuffer( 16, 62 )
+  -- multiBuffer( 17, 0 + 1*4 + 2*16 + 3*64)
+
+  -- multiBuffer( 33, string.byte('G') )
+  -- multiBuffer( 34, string.byte('l') )
+  -- multiBuffer( 35, string.byte('o') )
+  -- multiBuffer( 36, string.byte('b') )
+  -- multiBuffer( 37, string.byte('a') )
+  -- multiBuffer( 38, string.byte('l') )
+  -- multiBuffer( 39, string.byte(' ') )
+  -- multiBuffer( 40, string.byte('I') )
+  -- multiBuffer( 41, string.byte('D') )
+  -- multiBuffer( 42, 0xD0 + 4 )
+  -- multiBuffer( 43, 0x12 )
+  -- multiBuffer( 44, 0x34 )
+  -- multiBuffer( 45, 0x56 )
+  -- multiBuffer( 46, 0x78 )
+  -- multiBuffer( 47, 0x9A )
+  -- multiBuffer( 48, 0xBC )
+
+  -- multiBuffer( 53, 0x90 + 9 )
+  -- multiBuffer( 54, string.byte('R') )
+  -- multiBuffer( 55, string.byte('e') )
+  -- multiBuffer( 56, string.byte('s') )
+  -- multiBuffer( 57, string.byte('e') )
+  -- multiBuffer( 58, string.byte('t') )
+  -- multiBuffer( 59, string.byte(' ') )
+  -- multiBuffer( 60, string.byte('G') )
+  -- multiBuffer( 61, string.byte('I') )
+  -- multiBuffer( 62, string.byte('D') )
+  -- multiBuffer( 63, 0x00 )
+end
+
+-- Main
+local function Config_Run(event)
+  if event == nil then
+    error("Cannot be run as a model script!")
+    return 2
+  elseif event == EVT_VIRTUAL_EXIT then
+    Config_Release()
+    return 2
+  else
+    Config_Draw_Menu()
+    if ( event == EVT_VIRTUAL_PREV_PAGE or event == EVT_VIRTUAL_NEXT_PAGE ) and Edit < 1 then
+    -- Not editing, ok to change page
+      if event == EVT_VIRTUAL_PREV_PAGE then
+        killEvents(event)
+        if Page > 0 then
+          --Page = Page - 1
+          --Config_Page()
+        end
+      else
+        --Page = Page + 1
+        --Config_Page()
+      end
+    end
+    if Focus > 0 then
+    -- At least one line has an action
+      if Edit >= 0 then
+      -- Currently editing
+        Config_Draw_Edit( event )
+      elseif event == EVT_VIRTUAL_ENTER then
+      -- Switch to edit
+        Config_Draw_Edit( 0 )
+      elseif event == EVT_VIRTUAL_PREV or event == EVT_VIRTUAL_NEXT then
+      -- Main menu selection
+        Config_Next_Prev( event )
+      end
+    end
+    return 0
+  end
+end
+
+return { init=Config_Init, run=Config_Run }

Lua_scripts/MultiLOLI.lua

@@ -0,0 +1,221 @@
+
+local toolName = "TNS|Multi LOLI RX config|TNE"
+
+---- #########################################################################
+---- #                                                                       #
+---- # Copyright (C) OpenTX                                                  #
+-----#                                                                       #
+---- # License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html               #
+---- #                                                                       #
+---- # This program is free software; you can redistribute it and/or modify  #
+---- # it under the terms of the GNU General Public License version 2 as     #
+---- # published by the Free Software Foundation.                            #
+---- #                                                                       #
+---- # This program is distributed in the hope that it will be useful        #
+---- # but WITHOUT ANY WARRANTY; without even the implied warranty of        #
+---- # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         #
+---- # GNU General Public License for more details.                          #
+---- #                                                                       #
+---- #########################################################################
+
+local loli_nok = false
+local channels={ {  768, "PWM", 100,   102, "PPM",      50,  -768, "Servo",      0, -2048, "Switch", -100 }, -- CH1
+                 {  768, "PWM", 100,  -768, "Servo",      0, -2048, "Switch", -100 }, -- CH2
+                 { -768, "Servo",  0, -2048, "Switch", -100 }, -- CH3
+                 { -768, "Servo",  0, -2048, "Switch", -100 }, -- CH4
+                 {  102, "SBUS", 50,  -768, "Servo",      0, -2048, "Switch", -100 }, -- CH5
+                 { -768, "Servo",  0, -2048, "Switch", -100 }, -- CH6
+                 {  768, "PWM", 100,  -768, "Servo",      0, -2048, "Switch", -100 }, -- CH7
+                 { -768, "Servo",  0, -2048, "Switch", -100 } } -- CH8
+
+local sel = 1
+local edit = false
+
+local blink = 0
+local BLINK_SPEED = 15
+
+local function drawScreenTitle(title)
+    if LCD_W == 480 then
+        lcd.drawFilledRectangle(0, 0, LCD_W, 30, TITLE_BGCOLOR)
+        lcd.drawText(1, 5, title, MENU_TITLE_COLOR)
+    else
+        lcd.drawScreenTitle(title, 0, 0)
+    end
+end
+
+local function LOLI_Draw_LCD(event)
+  local line = 0
+
+  lcd.clear()
+
+  --Display settings
+  local lcd_opt = 0
+  if LCD_W == 480 then
+    drawScreenTitle("Multi - LOLI RX configuration tool")
+    x_pos = 152
+	x_inc = 90
+    y_pos = 40
+    y_inc = 20
+  else
+    x_pos = 5
+	x_inc = 30
+    y_pos = 1
+    y_inc = 8
+    lcd_opt = SMLSIZE
+  end
+
+  --Multi Module detection
+  if loli_nok then
+    if LCD_W == 480 then
+      lcd.drawText(10,50,"The LOLI protocol is not selected...", lcd_opt)
+    else
+      --Draw on LCD_W=128
+      lcd.drawText(2,17,"LOLI protocol not selected...",SMLSIZE)
+    end
+    return
+  end
+  
+  --Display current config
+  if LCD_W == 480 then
+	line = line + 1
+	lcd.drawText(x_pos, y_pos+y_inc*line -2, "Channel", lcd_opt)
+	lcd.drawText(x_pos+x_inc, y_pos+y_inc*line -2, "Function", lcd_opt)
+	lcd.drawRectangle(x_pos-4, y_pos+y_inc*line -4 , 2*x_inc +2, 188)
+	lcd.drawLine(x_pos-4, y_pos+y_inc*line +18, x_pos-4 +2*x_inc +1, y_pos+y_inc*line +18, SOLID, 0)
+	lcd.drawLine(x_pos+x_inc -5, y_pos+y_inc*line -4, x_pos+x_inc -5, y_pos+y_inc*line -5 +188, SOLID, 0)
+    line = line + 1
+  end
+  
+  local out
+  for i = 1, 8 do
+    out = getValue("ch"..(i+8))
+    lcd.drawText(x_pos, y_pos+y_inc*line, "CH"..i, lcd_opt)
+    for j = 1, #channels[i], 3 do
+      if out > channels[i][j] then
+        if sel == i then
+          invert = INVERS
+          if edit == true then
+            blink = blink + 1
+            if blink > BLINK_SPEED then
+              invert = 0
+              if blink > BLINK_SPEED * 2 then
+                blink = 0
+              end
+            end
+          end
+        else
+          invert = 0
+        end
+        lcd.drawText(x_pos+x_inc, y_pos+y_inc*line, channels[i][j+1], lcd_opt + invert)
+        break
+      end
+    end
+    line = line + 1
+  end
+end
+
+local function LOLI_Change_Value(dir)
+  local pos = 0
+  local out
+  --look for the current position
+  out = getValue("ch"..(sel+8))
+  for j = 1, #channels[sel], 3 do
+    if out > channels[sel][j] then
+	  pos = j
+	  break
+	end
+  end
+  
+  --decrement or increment
+  if dir < 0 and pos > 1 then
+    pos = pos - 3
+  elseif dir > 0 and pos + 3 < #channels[sel] then
+    pos = pos + 3
+  else
+    return
+  end
+  
+  --delete all mixers for the selected channel
+  local num_mix = model.getMixesCount(sel-1 +8)
+  for i = 1, num_mix do
+	model.deleteMix(sel-1 +8, 0);
+  end
+
+  --create new mixer
+  local source_max = getFieldInfo("cyc1")
+  
+  local val = { name = channels[sel][pos+1],
+				source = source_max.id - 1, -- MAX=100 on TX16S
+				weight = channels[sel][pos+2],
+				offset = 0,
+				switch = 0,
+				multiplex = 0,
+				curveType = 0,
+				curveValue = 0,
+				flightModes = 0,
+				carryTrim = false,
+				mixWarn = 0,
+				delayUp = 0,
+				delayDown = 0,
+				speedUp = 0,
+				speedDown = 0 }
+  model.insertMix(sel-1 +8, 0, val)
+end
+
+local function LOLI_Menu(event)
+  if event == EVT_VIRTUAL_NEXT then
+    if edit == false then
+      -- not changing a value
+      if sel < 8 then
+        sel = sel + 1
+      end
+    else
+      -- need to inc the value
+      LOLI_Change_Value(1)
+    end
+  elseif event == EVT_VIRTUAL_PREV then
+    if edit == false then
+      -- not changing a value
+      if sel > 1 then
+        sel = sel - 1
+      end
+    else
+      -- need to dec the value
+      LOLI_Change_Value(-1)
+    end
+  elseif event == EVT_VIRTUAL_ENTER then
+    if edit == false then
+      edit = true
+      blink = BLINK_SPEED
+    else
+      edit = false
+    end
+  end
+end
+
+-- Init
+local function LOLI_Init()
+  local module_conf = model.getModule(0)
+  if module_conf["Type"] ~= 6 or module_conf["protocol"] ~= 82 then
+    module_conf = model.getModule(1)
+    if module_conf["Type"] ~= 6 or module_conf["protocol"] ~= 82 then
+      loli_nok = true
+    end
+  end
+end
+
+-- Main
+local function LOLI_Run(event)
+  if event == nil then
+    error("Cannot be run as a model script!")
+    return 2
+  elseif event == EVT_VIRTUAL_EXIT then
+    return 2
+  else
+    LOLI_Menu(event)
+    LOLI_Draw_LCD(event)
+    return 0
+  end
+end
+
+return { init=LOLI_Init, run=LOLI_Run }

Lua_scripts/README.md

@@ -0,0 +1,77 @@
+# Multiprotocol TX Module OpenTX LUA scripts
+<img align="right" width=300 src="../docs/images/multi.png" />
+
+If you like this project and want to support further development please consider making a [donation](../docs/Donations.md).  
+
+<table cellspacing=0>
+  <tr>
+    <td align=center width=200><a href="https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=VF2K9T23DRY56&lc=US&item_name=DIY%20Multiprotocol&currency_code=EUR&amount=5&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHosted"><img src="../docs/images/donate_button.png" border="0" name="submit" title="PayPal - Donate €5" alt="Donate €5"/></a><br><b>€5</b></td>
+    <td align=center width=200><a href="https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=VF2K9T23DRY56&lc=US&item_name=DIY%20Multiprotocol&currency_code=EUR&amount=10&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHosted"><img src="../docs/images/donate_button.png" border="0" name="submit" title="PayPal - Donate €10" alt="Donate €10"/></a><br><b>€10</b></td>
+    <td align=center width=200><a href="https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=VF2K9T23DRY56&lc=US&item_name=DIY%20Multiprotocol&currency_code=EUR&amount=15&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHosted"><img src="../docs/images/donate_button.png" border="0" name="submit" title="PayPal - Donate €15" alt="Donate €10"/></a><br><b>€15</b></td>
+    <td align=center width=200><a href="https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=VF2K9T23DRY56&lc=US&item_name=DIY%20Multiprotocol&currency_code=EUR&amount=25&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHosted"><img src="../docs/images/donate_button.png" border="0" name="submit" title="PayPal - Donate €25" alt="Donate €25"/></a><br><b>€25</b></td>
+    <td align=center width=200><a href="https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=VF2K9T23DRY56&lc=US&item_name=DIY%20Multiprotocol&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHosted"><img src="../docs/images/donate_button.png" border="0" name="submit" title="PayPal - Donate" alt="Donate"/></a><br><b>Other</b></td>
+  </tr>
+</table>
+
+## MultiConfig
+
+Enables to modify on a Multi module the Global ID, Cyrf ID or format the EEPROM.
+
+Matching the ID of 2 Multi modules enable them to control the same receivers without rebinding. Be carefull the 2 modules should not be used at the same time unless you know what you are doing.
+
+Notes:
+- Supported from Multi v1.3.2.85 or above and OpenTX 2.3.12 or above
+- The Multi module to be configured must be active, if there is a second Multi module in the radio it must be off
+- Located on the radio SD card under \SCRIPTS\TOOLS
+
+[![MultiCconfig](https://img.youtube.com/vi/lGyCV2kpqHU/0.jpg)](https://www.youtube.com/watch?v=lGyCV2kpqHU)
+
+## MultiChannelsUpdater
+
+Automatically name the channels based on the loaded Multi protocol and sub protocol including the module channel order convention.
+
+Need OpenTX 2.3.9 or above. Located on the radio SD card under \SCRIPTS\TOOLS. This script needs MultiChan.txt to be present in the same folder.
+
+[![MultiChannelsUpdater](https://img.youtube.com/vi/L58ayXuewyA/0.jpg)](https://www.youtube.com/watch?v=L58ayXuewyA)
+
+## MultiLOLI
+
+Script to set the channels function (switch, servo, pwm, ppm, sbus) on a [LOLI RX](https://github.com/pascallanger/DIY-Multiprotocol-TX-Module/blob/master/Protocols_Details.md#loli---82)
+
+[![MultiLOLIconfig](https://img.youtube.com/vi/e698pQxfv-A/0.jpg)](https://www.youtube.com/watch?v=e698pQxfv-A)
+
+## Graupner HoTT
+
+Enable text configuration of the HoTT RX and sensors: Vario, GPS, ESC, GAM and EAM.
+
+Need OpenTX 2.3.9 or above. Located on the radio SD card under \SCRIPTS\TOOLS.
+
+Notes:
+- Menu/MDL/Model is used to cycle through the detected sensors.
+- It's normal to lose the telemetry feed while using the text mode configuration. Telemetry will resume properly if the script is exited by doing a short press on the exit button.
+
+[![Text mode video](https://img.youtube.com/vi/81wd8NlF3Qw/0.jpg)](https://www.youtube.com/watch?v=81wd8NlF3Qw)
+
+## Graupner HoTT Model Locator
+
+This is the Graupner HoTT adapted version of the Model Locator script using RSSI.
+
+The OpenTX sensor "RSSI" is populated by the individual OpenTX telemetry protocol implementations and returns a value from 0..100 (percent) originating from the early FrSky implementation. It turns out that FrSky did not really provide a genuine signal strength indicator in units of dbm but a link quality indicator in 0..100%. With Graupner HoTT the link quality indicator is not a good basis for the model locator as it is very non-linear and doesn't change much with distance. Using the Graupner HoTT telemetry sensor "Rssi" which is a true signal strength indicator serves the purpose of locating a model much better as it varies much more with distance.
+
+## DSM Forward Programming
+
+Navigation is mainly done using the scroll wheel and ENT. Short press on ENT will edit a value. When editing a value a long ENT press will restore the value to its default. To exit the script and terminate all current operations correctly short press RTN (if you don't do this the RX might not store the changes).
+
+This is a work in progress. It's only available for color screens (Horus, TX16S, T16, T18...).
+
+If some text appears as Unknown_xxx, please report xxx and what the exact text display should be.
+
+Need OpenTX 2.3.10 nightly or above. Located on the radio SD card under \SCRIPTS\TOOLS.
+
+[![DSM Forward Programming](https://img.youtube.com/vi/sjIaDw5j9nE/0.jpg)](https://www.youtube.com/watch?v=sjIaDw5j9nE)
+
+## DSM PID Flight log gain parameters for Blade micros
+
+Lua telemetry script from [feathering on RCGroups](https://www.rcgroups.com/forums/showpost.php?p=46033341&postcount=20728) to facilitate setting the Gain Parameters on the Blade 150S FBL. It doesn't use Forward Programming but instead it just reads telemetry data from the Multi-module and displays it on a telemetry display.
+
+It is very similar to the Telemetry Based Text Generator functionality on Spektrum transmitters where one doesn't need to rely on the angle of the swashplate to determine selection/value.

Lua_scripts/pidDsm.lua

@@ -0,0 +1,127 @@
+--
+-- This telemetry script displays the Flight Log Gain
+-- Parameters streamed from the Blade 150S Spektrum AR6335A
+-- Flybarless Controller.
+
+-- The script facilitates the setting of the FBL's
+-- Gain Parameters including PID  for both
+-- cyclic and tail.  It is similar to the Telemetry Based
+-- Text Generator available on Spektrum transmitters.
+
+-- Supporting similar Blade micros such as the Fusion 180
+-- would possibly require minor modifications to this script. 
+
+-- This script reads telemetry data from the Spektrum
+-- receiver and thus functionality relies on data being
+-- captured by the OpenTX transmitter.  A DSM
+-- telemetry-ready module is required.  Please see the
+-- MULTI-Module project at https://www.multi-module.org/.
+
+-- The only supported display is the Taranis'.  It may work
+-- with higher res screens.
+--
+
+
+-- Sensor names
+local PSensor = "FdeA"
+local ISensor = "FdeB"
+local DSensor = "FdeL"
+local RSensor = "FdeR"
+local ActiveParamSensor = "Hold"
+
+local tags = {"P", "I", "D"}
+
+
+local function getPage(iParam)
+  -- get page from 0-based index
+  -- {0,1,2,3}: cyclic (1), {4,5,6,7}: tail (2)
+  local res = (math.floor(iParam/4)==0) and 1 or 2
+  return res
+end
+
+function round(v)
+  -- round float
+  local factor = 100
+  return math.floor(v * factor + 0.5) / factor
+end
+
+
+local function readValue(sensor)
+  -- read from sensor, round and return
+  local v = getValue(sensor)
+  v = round(v)
+  return v
+end
+ 
+local function readActiveParamValue(sensor)
+  --  read and return a validated active parameter value
+  local v = getValue(sensor)
+  if (v<1 or v>8) then
+    return nil
+  end
+  return v
+end
+   
+local function readParameters()
+  -- read and return parameters
+  local p = readValue(PSensor)
+  local i = readValue(ISensor)
+  local d = readValue(DSensor)
+  local r = readValue(RSensor)
+  local a = readActiveParamValue(ActiveParamSensor)
+  return {p,i,d,r,a}
+end
+
+local function drawParameters()
+  -- draw labels and params on screen
+  local params = readParameters()
+  local activeParam = params[5]
+  
+  -- if active gain does not validate then assume
+  -- Gain Adjustment Mode is disabled
+  if not activeParam then
+    lcd.clear()
+    lcd.drawText(20,30,"Please enter Gain Adjustment Mode")
+    return
+  end
+  
+  local activePage = getPage(activeParam-1)
+  for iParam=0,7 do
+    -- highlight selected parameter
+    local attr = (activeParam==iParam+1) and 2 or 0
+    -- circular index (per page)
+    local perPageIndx = iParam % 4 + 1
+    -- check if displaying cyclic params.
+    local isCyclicPage = (getPage(iParam)==1)
+    -- set y draw coord
+    local y = perPageIndx*10+2
+    
+    -- labels
+    local x = isCyclicPage and 6 or 120
+    -- labels are P,I,D for both pages except for last param
+    local val = iParam==3 and "Response" or
+                  (iParam==7 and "Filtering" or tags[perPageIndx])
+    lcd.drawText (x, y, val, attr)
+    
+    -- gains
+    -- set all params for non-active page to '--' rather than 'last value'
+    val = (getPage(iParam)==activePage) and params[perPageIndx] or '--'
+    x = isCyclicPage and 70 or 180
+    lcd.drawText (x, y, val, attr)
+  end
+end
+
+
+local function run_func(event)
+  -- TODO: calling clear() on every function call redrawing all labels is not ideal
+  lcd.clear()
+  lcd.drawText (8, 2, "Cyclic (0...200)")
+  lcd.drawText (114, 2, "Tail (0...200)")
+  drawParameters()
+end
+
+local function init_func() end
+local function bg_func() end
+
+
+return { run=run_func, background=bg_func, init=init_func  }

Multiprotocol/A7105_SPI.ino

@@ -27,7 +27,9 @@ void A7105_WriteData(uint8_t len, uint8_t channel)
 	for (i = 0; i < len; i++)
 		SPI_Write(packet[i]);
 	A7105_CSN_on;
-	if(protocol!=MODE_FLYSKY)
+	if(protocol!=PROTO_WFLY2)
+	{
+		if(!(protocol==PROTO_FLYSKY || (protocol==PROTO_KYOSHO && sub_protocol==KYOSHO_HYPE)))
 		{
 			A7105_Strobe(A7105_STANDBY);	//Force standby mode, ie cancel any TX or RX...
 			A7105_SetTxRxMode(TX_EN);		//Switch to PA
@@ -35,6 +37,7 @@ void A7105_WriteData(uint8_t len, uint8_t channel)
 		A7105_WriteReg(A7105_0F_PLL_I, channel);
 		A7105_Strobe(A7105_TX);
 	}
+}
 
 void A7105_ReadData(uint8_t len)
 {
@@ -107,7 +110,7 @@ void A7105_WriteID(uint32_t ida)
 {
 	A7105_CSN_off;
 	SPI_Write(A7105_06_ID_DATA);			//ex id=0x5475c52a ;txid3txid2txid1txid0
-	SPI_Write((ida>>24)&0xff);				//53 
+	SPI_Write((ida>>24)&0xff);				//54 
 	SPI_Write((ida>>16)&0xff);				//75
 	SPI_Write((ida>>8)&0xff);				//c5
 	SPI_Write((ida>>0)&0xff);				//2a
@@ -145,8 +148,12 @@ static void A7105_SetPower_Value(int power)
 void A7105_SetPower()
 {
 	uint8_t power=A7105_BIND_POWER;
-	if(IS_BIND_DONE_on)
+	if(IS_BIND_DONE)
+		#ifdef A7105_ENABLE_LOW_POWER
 			power=IS_POWER_FLAG_on?A7105_HIGH_POWER:A7105_LOW_POWER;
+		#else
+			power=A7105_HIGH_POWER;
+		#endif
 	if(IS_RANGE_FLAG_on)
 		power=A7105_RANGE_POWER;
 	if(prev_power != power)
@@ -161,23 +168,115 @@ void A7105_Strobe(uint8_t address) {
 	SPI_Write(address);
 	A7105_CSN_on;
 }
-#ifdef HUBSAN_A7105_INO
-const uint8_t PROGMEM HUBSAN_A7105_regs[] = {
-	0xFF, 0x63, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF ,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x05, 0x04, 0xFF,
-	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x2B, 0xFF, 0xFF, 0x62, 0x80, 0xFF, 0xFF, 0x0A, 0xFF, 0xFF, 0x07,
-	0x17, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x47, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-	0xFF, 0xFF
-};
+
+// Fine tune A7105 LO base frequency
+// this is required for some A7105 modules and/or RXs with inaccurate crystal oscillator
+void A7105_AdjustLOBaseFreq(uint8_t cmd)
+{
+	static int16_t old_offset=2048;
+	int16_t offset=1024;
+	if(cmd==0)
+	{	// Called at init of the A7105
+		old_offset=2048;
+		switch(protocol)
+		{
+			case PROTO_HUBSAN:
+				#ifdef FORCE_HUBSAN_TUNING
+					offset=(int16_t)FORCE_HUBSAN_TUNING;
 				#endif
-#ifdef FLYSKY_A7105_INO
-const uint8_t PROGMEM FLYSKY_A7105_regs[] = {
-	0xff, 0x42, 0x00, 0x14, 0x00, 0xff, 0xff ,0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0x05, 0x00, 0x50,
-	0x9e, 0x4b, 0x00, 0x02, 0x16, 0x2b, 0x12, 0x00, 0x62, 0x80, 0x80, 0x00, 0x0a, 0x32, 0xc3, 0x0f,
-	0x13, 0xc3, 0x00, 0xff, 0x00, 0x00, 0x3b, 0x00, 0x17, 0x47, 0x80, 0x03, 0x01, 0x45, 0x18, 0x00,
-	0x01, 0x0f
-};
+				break;
+			case PROTO_BUGS:
+				#ifdef FORCE_BUGS_TUNING
+					offset=(int16_t)FORCE_BUGS_TUNING;
 				#endif
-#ifdef AFHDS2A_A7105_INO
+				break;
+			case PROTO_FLYSKY:
+				#ifdef FORCE_FLYSKY_TUNING
+					offset=(int16_t)FORCE_FLYSKY_TUNING;
+				#endif
+				break;
+			case PROTO_HEIGHT:
+				#ifdef FORCE_HEIGHT_TUNING
+					offset=(int16_t)FORCE_HEIGHT_TUNING;
+				#endif
+				break;
+			case PROTO_PELIKAN:
+				#ifdef FORCE_PELIKAN_TUNING
+					offset=(int16_t)FORCE_PELIKAN_TUNING;
+				#endif
+				break;
+			case PROTO_KYOSHO:
+				#ifdef FORCE_KYOSHO_TUNING
+					offset=(int16_t)FORCE_KYOSHO_TUNING;
+				#endif
+				break;
+			case PROTO_JOYSWAY:
+				#ifdef FORCE_JOYSWAY_TUNING
+					offset=(int16_t)FORCE_JOYSWAY_TUNING;
+				#endif
+				break;
+			case PROTO_WFLY2:
+				#ifdef FORCE_WFLY2_TUNING
+					offset=(int16_t)FORCE_WFLY2_TUNING;
+				#endif
+				break;
+			case PROTO_AFHDS2A:
+			case PROTO_AFHDS2A_RX:
+				#ifdef FORCE_AFHDS2A_TUNING
+					offset=(int16_t)FORCE_AFHDS2A_TUNING;
+				#endif
+				break;
+		}
+	}
+	if(offset==1024)	// Use channel 15 as an input
+		offset=convert_channel_16b_nolimit(CH15,-300,300,false);
+
+	if(old_offset==offset)	// offset is the same as before...
+			return;
+	old_offset=offset;
+
+	// LO base frequency = 32e6*(bip+(bfp/(2^16)))
+	uint8_t bip;	// LO base frequency integer part
+	uint16_t bfp;	// LO base frequency fractional part
+	offset++;		// as per datasheet, not sure why recommended, but that's a +1kHz drift only ...
+	offset<<=1;
+	if(offset < 0)
+	{
+		bip = 0x4a;	// 2368 MHz
+		bfp = 0xffff + offset;
+	}
+	else
+	{
+		bip = 0x4b;	// 2400 MHz (default)
+		bfp = offset;
+	}
+	A7105_WriteReg( A7105_11_PLL_III, bip);
+	A7105_WriteReg( A7105_12_PLL_IV, (bfp >> 8) & 0xff);
+	A7105_WriteReg( A7105_13_PLL_V, bfp & 0xff);
+	//debugln("Channel: %d, offset: %d, bip: %2x, bfp: %4x", Channel_data[14], offset, bip, bfp);
+}
+
+static void __attribute__((unused)) A7105_SetVCOBand(uint8_t vb1, uint8_t vb2)
+{	// Set calibration band value to best match
+	uint8_t diff1, diff2;
+
+	if (vb1 >= 4)
+		diff1 = vb1 - 4;
+	else
+		diff1 = 4 - vb1;
+
+	if (vb2 >= 4)
+		diff2 = vb2 - 4;
+	else
+		diff2 = 4 - vb2;
+
+	if (diff1 == diff2 || diff1 > diff2)
+		A7105_WriteReg(A7105_25_VCO_SBCAL_I, vb1 | 0x08);
+	else
+		A7105_WriteReg(A7105_25_VCO_SBCAL_I, vb2 | 0x08);
+}
+
+#if defined(AFHDS2A_A7105_INO) || defined(AFHDS2A_RX_A7105_INO)
 const uint8_t PROGMEM AFHDS2A_A7105_regs[] = {
 	0xFF, 0x42 | (1<<5), 0x00, 0x25, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3c, 0x05, 0x00, 0x50,	// 00 - 0f
 	0x9e, 0x4b, 0x00, 0x02, 0x16, 0x2b, 0x12, 0x4f, 0x62, 0x80, 0xFF, 0xFF, 0x2a, 0x32, 0xc3, 0x1f,				// 10 - 1f
@@ -185,15 +284,121 @@ const uint8_t PROGMEM AFHDS2A_A7105_regs[] = {
 	0x01, 0x0f // 30 - 31
 };
 #endif
+#ifdef BUGS_A7105_INO
+const uint8_t PROGMEM BUGS_A7105_regs[] = {
+	0xFF, 0x42, 0x00, 0x15, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x05, 0x01, 0x50,	// 00 - 0f
+	0x9e, 0x4b, 0x00, 0x02, 0x16, 0x2b, 0x12, 0x40, 0x62, 0x80, 0x80, 0x00, 0x0a, 0x32, 0xc3, 0x0f,	// 10 - 1f
+	0x16, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x3b, 0x00, 0x0b, 0x47, 0x80, 0x03, 0x01, 0x45, 0x18, 0x00,	// 20 - 2f
+	0x01, 0x0f // 30 - 31
+};
+#endif
+#ifdef FLYSKY_A7105_INO
+const uint8_t PROGMEM FLYSKY_A7105_regs[] = {
+	0xff, 0x42, 0x00, 0x14, 0x00, 0xff, 0xff ,0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0x05, 0x00, 0x50,	// 00 - 0f
+	0x9e, 0x4b, 0x00, 0x02, 0x16, 0x2b, 0x12, 0x00, 0x62, 0x80, 0x80, 0x00, 0x0a, 0x32, 0xc3, 0x0f,	// 10 - 1f
+	0x13, 0xc3, 0x00, 0xff, 0x00, 0x00, 0x3b, 0x00, 0x17, 0x47, 0x80, 0x03, 0x01, 0x45, 0x18, 0x00,	// 20 - 2f
+	0x01, 0x0f // 30 - 31
+};
+#endif
+#ifdef HEIGHT_A7105_INO
+const uint8_t PROGMEM HEIGHT_A7105_regs[] = {
+	0xff, 0x42, 0x00, 0x07, 0x00, 0xff, 0xff ,0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0x05, 0x01, 0x50,	// 00 - 0f
+	0x9e, 0x4b, 0x00, 0x02, 0x16, 0x2b, 0x12, 0x00, 0x62, 0x80, 0x80, 0x00, 0x0a, 0x32, 0xc3, 0x1f,	// 10 - 1f
+	0x12, 0x00, 0x00, 0xff, 0x00, 0x00, 0x3a, 0x00, 0x3f, 0x47, 0x80, 0x03, 0x01, 0x45, 0x18, 0x00,	// 20 - 2f
+	0x01, 0x0f // 30 - 31
+};
+#endif
+#ifdef HUBSAN_A7105_INO
+const uint8_t PROGMEM HUBSAN_A7105_regs[] = {
+	0xFF, 0x63, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF ,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x05, 0x04, 0xFF,	// 00 - 0f
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x2B, 0xFF, 0xFF, 0x62, 0x80, 0xFF, 0xFF, 0x0A, 0xFF, 0xFF, 0x07,	// 10 - 1f
+	0x17, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x47, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	// 20 - 2f
+	0xFF, 0xFF // 30 - 31
+};
+#endif
+#ifdef PELIKAN_A7105_INO
+const uint8_t PROGMEM PELIKAN_A7105_regs[] = {
+	0xff, 0x42, 0x00, 0x0F, 0x00, 0xff, 0xff ,0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0x05, 0x01, 0x50,	// 00 - 0f
+	0x9e, 0x4b, 0x00, 0x02, 0x16, 0x2b, 0x12, 0x00, 0x62, 0x80, 0x80, 0x00, 0x0a, 0x32, 0xc3, 0x07,	// 10 - 1f
+	0x16, 0x00, 0x00, 0xff, 0x00, 0x00, 0x3b, 0x00, 0x1f, 0x47, 0x80, 0x03, 0x01, 0x45, 0x18, 0x00,	// 20 - 2f
+	0x01, 0x0f // 30 - 31
+};
+#endif
+#ifdef KYOSHO_A7105_INO
+const uint8_t PROGMEM KYOSHO_A7105_regs[] = {
+	0xff, 0x42, 0xff, 0x25, 0x00, 0xff, 0xff ,0x00, 0x00, 0x00, 0x00, 0x01, 0x21, 0x05, 0x00, 0x50,	// 00 - 0f
+	0x9e, 0x4b, 0x00, 0x02, 0x16, 0x2b, 0x12, 0x40, 0x62, 0x80, 0x80, 0x00, 0x0a, 0x32, 0x03, 0x1f,	// 10 - 1f
+	0x1e, 0x00, 0x00, 0xff, 0x00, 0x00, 0x23, 0x70, 0x1F, 0x47, 0x80, 0x57, 0x01, 0x45, 0x19, 0x00,	// 20 - 2f
+	0x01, 0x0f // 30 - 31
+};
+const uint8_t PROGMEM KYOSHO_HYPE_A7105_regs[] = {
+	0xff, 0x42, 0x00, 0x10, 0xC0, 0xff, 0xff ,0x00, 0x00, 0x00, 0x00, 0x01, 0x09, 0x05, 0x01, 0x04,	// 00 - 0f
+	0x9e, 0x4b, 0x00, 0x02, 0x16, 0x2b, 0x12, 0x00, 0x62, 0x80, 0x80, 0x00, 0x0a, 0x96, 0xc2, 0x1f,	// 10 - 1f
+	0x12, 0x00, 0x00, 0xff, 0x00, 0x00, 0x3a, 0x00, 0x17, 0x47, 0x80, 0x03, 0x01, 0x45, 0x18, 0x00,	// 20 - 2f
+	0x01, 0x0f // 30 - 31
+};
+#endif
+#ifdef WFLY2_A7105_INO //A7106 values
+const uint8_t PROGMEM WFLY2_A7105_regs[] = {
+	0xff, 0x62, 0xff, 0x1F, 0x40, 0xff, 0xff ,0x00, 0x00, 0x00, 0x00, 0x33, 0x33, 0x05, 0x00, 0x64,	// 00 - 0f Changes: 0B:19->33, 0C:01,33
+	0x9e, 0x4b, 0x00, 0x02, 0x16, 0x2b, 0x12, 0x40, 0x62, 0x80, 0x80, 0x00, 0x0a, 0x32, 0x03, 0x0f,	// 10 - 1f 1C:4A->0A
+	0x12, 0x00, 0x00, 0xff, 0x00, 0x00, 0x23, 0x70, 0x15, 0x47, 0x80, 0x03, 0x01, 0x45, 0x18, 0x00,	// 20 - 2f 2B:77->03, 2E:19->18
+	0x01, 0x0f // 30 - 31
+};
+#endif
+#ifdef JOYSWAY_A7105_INO
+const uint8_t PROGMEM JOYSWAY_A7105_regs[] = {
+	0xff, 0x62, 0xff, 0x0F, 0x00, 0xff, 0xff ,0x00, 0x00, 0x05, 0x00, 0x01, 0x00, 0xF5, 0x00, 0x15,	// 00 - 0f
+	0x9E, 0x4B, 0x00, 0x03, 0x56, 0x2B, 0x12, 0x4A, 0x02, 0x80, 0x80, 0x00, 0x0E, 0x91, 0x03, 0x0F,	// 10 - 1f
+	0x16, 0x2A, 0x00, 0xff, 0xff, 0xff, 0x3A, 0x06, 0x1F, 0x47, 0x80, 0x01, 0x05, 0x45, 0x18, 0x00,	// 20 - 2f
+	0x01, 0x0f // 30 - 31
+};
+#endif
 
 #define ID_NORMAL 0x55201041
 #define ID_PLUS   0xAA201041
 void A7105_Init(void)
 {
 	uint8_t *A7105_Regs=0;
+    uint8_t vco_calibration0, vco_calibration1;
 	
+	#ifdef JOYSWAY_A7105_INO
+		if(protocol==PROTO_JOYSWAY)
+		{
+			A7105_Regs=(uint8_t*)JOYSWAY_A7105_regs;
+		}
+		else
+	#endif
+	#ifdef WFLY2_A7105_INO
+		if(protocol==PROTO_WFLY2)
+		{
+			A7105_Regs=(uint8_t*)WFLY2_A7105_regs;
+		}
+		else
+	#endif
+	#ifdef HEIGHT_A7105_INO
+		if(protocol==PROTO_HEIGHT)
+		{
+			A7105_Regs=(uint8_t*)HEIGHT_A7105_regs;
+			A7105_WriteID(0x25A53C45);
+		}
+		else
+	#endif
+	#ifdef PELIKAN_A7105_INO
+		if(protocol==PROTO_PELIKAN)
+		{
+			A7105_Regs=(uint8_t*)PELIKAN_A7105_regs;
+			A7105_WriteID(0x06230623);
+		}
+		else
+	#endif
+	#ifdef BUGS_A7105_INO
+		if(protocol==PROTO_BUGS)
+			A7105_Regs=(uint8_t*)BUGS_A7105_regs;
+		else
+	#endif
 	#ifdef HUBSAN_A7105_INO
-		if(protocol==MODE_HUBSAN)
+		if(protocol==PROTO_HUBSAN)
 		{
 			A7105_WriteID(ID_NORMAL);
 			A7105_Regs=(uint8_t*)HUBSAN_A7105_regs;
@@ -203,40 +408,64 @@ void A7105_Init(void)
 		{
 			A7105_WriteID(0x5475c52A);//0x2Ac57554
 			#ifdef FLYSKY_A7105_INO
-				if(protocol==MODE_FLYSKY)
+				if(protocol==PROTO_FLYSKY)
 					A7105_Regs=(uint8_t*)FLYSKY_A7105_regs;
-				else
 			#endif
-				{
-					#ifdef AFHDS2A_A7105_INO
+			#if defined(AFHDS2A_A7105_INO) || defined(AFHDS2A_RX_A7105_INO)
+				if(protocol==PROTO_AFHDS2A || protocol==PROTO_AFHDS2A_RX)
 					A7105_Regs=(uint8_t*)AFHDS2A_A7105_regs;
 			#endif
+			#ifdef KYOSHO_A7105_INO
+				if(protocol==PROTO_KYOSHO)
+				{
+					if(sub_protocol==KYOSHO_FHSS)
+						A7105_Regs=(uint8_t*)KYOSHO_A7105_regs;
+					else
+						A7105_Regs=(uint8_t*)KYOSHO_HYPE_A7105_regs;
 				}
+			#endif
 		}
 
 	for (uint8_t i = 0; i < 0x32; i++)
 	{
 		uint8_t val=pgm_read_byte_near(&A7105_Regs[i]);
 		#ifdef FLYSKY_A7105_INO
-			if(protocol==MODE_FLYSKY && sub_protocol==CX20)
+			if(protocol==PROTO_FLYSKY && sub_protocol==CX20)
 			{
 				if(i==0x0E) val=0x01;
 				if(i==0x1F) val=0x1F;
 				if(i==0x20) val=0x1E;
 			}
 		#endif
-		if( val != 0xFF)
+		#ifdef HEIGHT_A7105_INO
+			if(protocol==PROTO_HEIGHT && sub_protocol==HEIGHT_8CH)
+				if(i==0x03) val=0x0A;
+		#endif
+		if( val != 0xff)
 			A7105_WriteReg(i, val);
 	}
 	A7105_Strobe(A7105_STANDBY);
 
+	if(protocol==PROTO_KYOSHO && sub_protocol==KYOSHO_FHSS)
+	{//strange calibration...
+		//IF Filter Bank Calibration
+		A7105_WriteReg(A7105_02_CALC,0x0F);
+		while(A7105_ReadReg(A7105_02_CALC));			// Wait for calibration to end
+	//	A7105_ReadReg(A7105_22_IF_CALIB_I);
+	//	A7105_ReadReg(A7105_24_VCO_CURCAL);
+	//	A7105_ReadReg(25_VCO_SBCAL_I);
+	//	A7105_ReadReg(1A_RX_GAIN_II);
+	//	A7105_ReadReg(1B_RX_GAIN_III);
+	}
+	else
+	{
 		//IF Filter Bank Calibration
 		A7105_WriteReg(A7105_02_CALC,1);
 		while(A7105_ReadReg(A7105_02_CALC));			// Wait for calibration to end
 	//	A7105_ReadReg(A7105_22_IF_CALIB_I);
 	//	A7105_ReadReg(A7105_24_VCO_CURCAL);
 
-	if(protocol!=MODE_HUBSAN)
+		if(protocol!=PROTO_HUBSAN)
 		{
 			//VCO Current Calibration
 			A7105_WriteReg(A7105_24_VCO_CURCAL,0x13);	//Recommended calibration from A7105 Datasheet
@@ -248,21 +477,53 @@ void A7105_Init(void)
 		A7105_WriteReg(A7105_0F_CHANNEL, 0);
 		A7105_WriteReg(A7105_02_CALC,2);
 		while(A7105_ReadReg(A7105_02_CALC));			// Wait for calibration to end
-//	A7105_ReadReg(A7105_25_VCO_SBCAL_I);
+		vco_calibration0 = A7105_ReadReg(A7105_25_VCO_SBCAL_I);
 		
 		//VCO Bank Calibrate channel A0
 		A7105_WriteReg(A7105_0F_CHANNEL, 0xa0);
 		A7105_WriteReg(A7105_02_CALC, 2);
 		while(A7105_ReadReg(A7105_02_CALC));			// Wait for calibration to end
-//	A7105_ReadReg(A7105_25_VCO_SBCAL_I);
-
-	//Reset VCO Band calibration
-	if(protocol!=MODE_HUBSAN)
-		A7105_WriteReg(A7105_25_VCO_SBCAL_I,protocol==MODE_FLYSKY?0x08:0x0A);
+		vco_calibration1 = A7105_ReadReg(A7105_25_VCO_SBCAL_I);
 
+		if(protocol==PROTO_BUGS || protocol==PROTO_WFLY2)
+			A7105_SetVCOBand(vco_calibration0 & 0x07, vco_calibration1 & 0x07);	// Set calibration band value to best match
+		else
+			if(protocol!=PROTO_HUBSAN)
+			{
+				switch(protocol)
+				{
+					case PROTO_FLYSKY:
+						vco_calibration1=0x08;
+						break;
+					case PROTO_HEIGHT:
+						vco_calibration1=0x02;
+						break;
+					case PROTO_PELIKAN:
+						if(sub_protocol == PELIKAN_SCX24)
+						{
+							vco_calibration1=0x0A;
+							break;
+						}
+					case PROTO_KYOSHO: //sub_protocol Hype
+						vco_calibration1=0x0C;
+						break;
+					case PROTO_JOYSWAY:
+						vco_calibration1=0x09;
+						break;
+					default:
+						vco_calibration1=0x0A;
+						break;
+				}
+				A7105_WriteReg(A7105_25_VCO_SBCAL_I,vco_calibration1);	//Reset VCO Band calibration
+			}
+	}
 	A7105_SetTxRxMode(TX_EN);
 	A7105_SetPower();
 
+	#ifdef USE_A7105_CH15_TUNING
+		A7105_AdjustLOBaseFreq(0);
+	#endif
+	
 	A7105_Strobe(A7105_STANDBY);
 }
 #endif

Multiprotocol/AFHDS2A_Rx_a7105.ino

@@ -0,0 +1,228 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(AFHDS2A_RX_A7105_INO)
+
+#include "iface_a7105.h" 
+
+#define AFHDS2A_RX_TXPACKET_SIZE	38
+#define AFHDS2A_RX_RXPACKET_SIZE	37
+#define AFHDS2A_RX_NUMFREQ			16
+
+enum {
+	AFHDS2A_RX_BIND1,
+	AFHDS2A_RX_BIND2,
+	AFHDS2A_RX_BIND3,
+	AFHDS2A_RX_DATA
+};
+
+static void __attribute__((unused)) AFHDS2A_RX_build_telemetry_packet()
+{
+	uint32_t bits = 0;
+	uint8_t bitsavailable = 0;
+	uint8_t idx = 0;
+
+	packet_in[idx++] = RX_LQI; // 0 - 130
+	packet_in[idx++] = RX_RSSI;
+	packet_in[idx++] = 0; // start channel
+	packet_in[idx++] = 14; // number of channels in packet
+	// pack channels
+	for (uint8_t i = 0; i < 14; i++) {
+		uint32_t val = packet[9+i*2] | (((packet[10+i*2])&0x0F) << 8);
+		if (val < 860)
+			val = 860;
+		// convert ppm (860-2140) to Multi (0-2047)
+		val = min(((val-860)<<3)/5, 2047);
+
+		bits |= val << bitsavailable;
+		bitsavailable += 11;
+		while (bitsavailable >= 8) {
+			packet_in[idx++] = bits & 0xff;
+			bits >>= 8;
+			bitsavailable -= 8;
+		}
+	}
+}
+
+static uint8_t __attribute__((unused)) AFHDS2A_RX_data_ready()
+{
+	// check if FECF+CRCF Ok
+	return !(A7105_ReadReg(A7105_00_MODE) & (1 << 5 | 1 << 6 | 1 << 0));
+}
+
+void AFHDS2A_RX_init()
+{
+	uint8_t i;
+	A7105_Init();
+	hopping_frequency_no = 0;
+	packet_count = 0;
+	rx_data_started = false;
+	rx_disable_lna = IS_POWER_FLAG_on;
+	A7105_SetTxRxMode(rx_disable_lna ? TXRX_OFF : RX_EN);
+	A7105_Strobe(A7105_RX);
+
+	if (IS_BIND_IN_PROGRESS) {
+		phase = AFHDS2A_RX_BIND1;
+	}
+	else {
+		uint16_t temp = AFHDS2A_RX_EEPROM_OFFSET;
+		for (i = 0; i < 4; i++)
+			rx_id[i] = eeprom_read_byte((EE_ADDR)temp++);
+		for (i = 0; i < AFHDS2A_RX_NUMFREQ; i++)
+			hopping_frequency[i] = eeprom_read_byte((EE_ADDR)temp++);
+		phase = AFHDS2A_RX_DATA;
+	}
+}
+
+#define AFHDS2A_RX_WAIT_WRITE 0x80
+
+uint16_t AFHDS2A_RX_callback()
+{
+	static int8_t read_retry;
+	int16_t temp;
+	uint8_t i;
+
+#ifndef FORCE_AFHDS2A_TUNING
+	A7105_AdjustLOBaseFreq(1);
+#endif
+	if (rx_disable_lna != IS_POWER_FLAG_on) {
+		rx_disable_lna = IS_POWER_FLAG_on;
+		A7105_SetTxRxMode(rx_disable_lna ? TXRX_OFF : RX_EN);
+	}
+
+	switch(phase) {
+	case AFHDS2A_RX_BIND1:
+		if(IS_BIND_DONE)
+		{
+			AFHDS2A_RX_init();	// Abort bind
+			break;
+		}
+		debugln("bind p=%d", phase+1);
+		if (AFHDS2A_RX_data_ready()) {
+			A7105_ReadData(AFHDS2A_RX_TXPACKET_SIZE);
+			if ((packet[0] == 0xbb && packet[9] == 0x01) ||	(packet[0] == 0xbc && packet[9] <= 0x02)) {
+				memcpy(rx_id, &packet[1], 4); // TX id actually
+				memcpy(hopping_frequency, &packet[11], AFHDS2A_RX_NUMFREQ);
+				phase = AFHDS2A_RX_BIND2;
+				debugln("phase bind2");
+			}
+		}
+		A7105_WriteReg(A7105_0F_PLL_I, (packet_count++ & 1) ? 0x0D : 0x8C); // bind channels
+		A7105_Strobe(A7105_RX);
+		return 10000;
+
+	case AFHDS2A_RX_BIND2:
+		if(IS_BIND_DONE)
+		{
+			AFHDS2A_RX_init();	// Abort bind
+			break;
+		}
+		// got 2nd bind packet from tx ?
+		if (AFHDS2A_RX_data_ready()) {
+			A7105_ReadData(AFHDS2A_RX_TXPACKET_SIZE);
+			if ((packet[0] == 0xBC && packet[9] == 0x02 && packet[10] == 0x00) &&
+				(memcmp(rx_id, &packet[1], 4) == 0) &&
+				(memcmp(rx_tx_addr, &packet[5], 4) == 0)) {
+				// save tx info to eeprom
+				temp = AFHDS2A_RX_EEPROM_OFFSET;
+				for (i = 0; i < 4; i++)
+					eeprom_write_byte((EE_ADDR)temp++, rx_id[i]);
+				for (i = 0; i < AFHDS2A_RX_NUMFREQ; i++)
+					eeprom_write_byte((EE_ADDR)temp++, hopping_frequency[i]);
+				phase = AFHDS2A_RX_BIND3;
+				debugln("phase bind3");
+				packet_count = 0;
+			}
+		}
+
+	case AFHDS2A_RX_BIND3:
+		debugln("bind p=%d", phase+1);
+		// transmit response packet
+		packet[0] = 0xBC;
+		memcpy(&packet[1], rx_id, 4);
+		memcpy(&packet[5], rx_tx_addr, 4);
+		//packet[9] = 0x01;
+		packet[10] = 0x00;
+		memset(&packet[11], 0xFF, 26);
+		A7105_SetTxRxMode(TX_EN);
+		rx_disable_lna = !IS_POWER_FLAG_on;
+		A7105_WriteData(AFHDS2A_RX_RXPACKET_SIZE, packet_count++ & 1 ? 0x0D : 0x8C);
+		if(phase == AFHDS2A_RX_BIND3 && packet_count > 20)
+		{
+			debugln("done");
+			BIND_DONE;
+			AFHDS2A_RX_init();	// Restart protocol
+			break;
+		}
+		phase |= AFHDS2A_RX_WAIT_WRITE;
+		return 1700;
+	
+	case AFHDS2A_RX_BIND2 | AFHDS2A_RX_WAIT_WRITE:
+		//Wait for TX completion
+		pps_timer = micros();
+		while ((uint32_t)(micros() - pps_timer) < 700) // Wait max 700µs, using serial+telemetry exit in about 120µs
+			if (!(A7105_ReadReg(A7105_00_MODE) & 0x01))
+				break;
+		A7105_Strobe(A7105_RX);
+	case AFHDS2A_RX_BIND3 | AFHDS2A_RX_WAIT_WRITE:
+		phase &= ~AFHDS2A_RX_WAIT_WRITE;
+		return 10000;
+	
+	case AFHDS2A_RX_DATA:
+		if (AFHDS2A_RX_data_ready()) {
+			A7105_ReadData(AFHDS2A_RX_TXPACKET_SIZE);
+			if (memcmp(&packet[1], rx_id, 4) == 0 && memcmp(&packet[5], rx_tx_addr, 4) == 0) {
+				if (packet[0] == 0x58 && packet[37] == 0x00 && (telemetry_link&0x7F) == 0) { // standard packet, send channels to TX
+					int rssi = min(A7105_ReadReg(A7105_1D_RSSI_THOLD),160);
+					RX_RSSI = map16b(rssi, 160, 8, 0, 128);
+					AFHDS2A_RX_build_telemetry_packet();
+					telemetry_link = 1;
+					#ifdef SEND_CPPM
+						if(sub_protocol>0)
+							telemetry_link |= 0x80;	// Disable telemetry output
+					#endif
+				}
+				rx_data_started = true;
+				read_retry = 10; // hop to next channel
+				pps_counter++;
+			}
+		}
+		
+		// packets per second
+		if (millis() - pps_timer >= 1000) {
+			pps_timer = millis();
+			debugln("%d pps", pps_counter);
+			RX_LQI = pps_counter / 2;
+			pps_counter = 0;
+		}
+
+		// frequency hopping
+		if (read_retry++ >= 10) {
+			hopping_frequency_no++;
+			if(hopping_frequency_no >= AFHDS2A_RX_NUMFREQ)
+				hopping_frequency_no = 0;
+			A7105_WriteReg(A7105_0F_PLL_I, hopping_frequency[hopping_frequency_no]);
+			A7105_Strobe(A7105_RX);
+			if (rx_data_started)
+				read_retry = 0;
+			else
+				read_retry = -127; // retry longer until first packet is catched
+		}
+		return 385;
+	}
+	return 3850; // never reached
+}
+
+#endif

Multiprotocol/AFHDS2A_a7105.ino

@@ -20,6 +20,10 @@
 #define AFHDS2A_RXPACKET_SIZE	37
 #define AFHDS2A_NUMFREQ			16
 
+#if not defined TELEMETRY
+	uint8_t RX_LQI=0;
+#endif
+
 enum{
 	AFHDS2A_PACKET_STICKS,
 	AFHDS2A_PACKET_SETTINGS,
@@ -31,6 +35,7 @@ enum{
 	AFHDS2A_BIND2,
 	AFHDS2A_BIND3,
 	AFHDS2A_BIND4,
+	AFHDS2A_DATA_INIT,
 	AFHDS2A_DATA,
 };
 
@@ -41,38 +46,29 @@ static void AFHDS2A_calc_channels()
 	while (idx < AFHDS2A_NUMFREQ)
 	{
 		uint8_t i;
-		uint8_t count_1_42 = 0, count_43_85 = 0, count_86_128 = 0, count_129_168 = 0;
+		uint8_t band_no = ((((idx<<1) | ((idx>>1) & 0b01)) + rx_tx_addr[3]) & 0b11);
 		rnd = rnd * 0x0019660D + 0x3C6EF35F; // Randomization
 
-		uint8_t next_ch = ((rnd >> (idx%32)) % 0xa8) + 1;
-		// Keep the distance 2 between the channels - either odd or even
-		if (((next_ch ^ MProtocol_id) & 0x01 )== 0)
-			continue;
-		// Check that it's not duplicate and spread uniformly
+		uint8_t next_ch = band_no*41 + 1 + ((rnd >> idx) % 41); // Channel range: 1..164
+
 		for (i = 0; i < idx; i++)
 		{
-			if(hopping_frequency[i] == next_ch)
-				break;
-			if(hopping_frequency[i] <= 42)
-				count_1_42++;
-			else if (hopping_frequency[i] <= 85)
-				count_43_85++;
-			else if (hopping_frequency[i] <= 128)
-				count_86_128++;
+			// Keep the distance 5 between the channels 
+			uint8_t distance;
+			if (next_ch > hopping_frequency[i])
+				distance = next_ch - hopping_frequency[i];
 			else
-				count_129_168++;
+				distance = hopping_frequency[i] - next_ch;
+
+			if (distance < 5) break;
 		}
-		if (i != idx)
-			continue;
-		if ((next_ch <= 42 && count_1_42 < 5)
-			||(next_ch >= 43 && next_ch <= 85 && count_43_85 < 5)
-			||(next_ch >= 86 && next_ch <=128 && count_86_128 < 5)
-			||(next_ch >= 129 && count_129_168 < 5))
+
+		if (i != idx) continue;
+
 		hopping_frequency[idx++] = next_ch;
 	}
 }
 
-#if defined(AFHDS2A_FW_TELEMETRY) || defined(AFHDS2A_HUB_TELEMETRY)
 // telemetry sensors ID
 enum{
 	AFHDS2A_SENSOR_RX_VOLTAGE   = 0x00,
@@ -80,25 +76,38 @@ enum{
 	AFHDS2A_SENSOR_RX_RSSI      = 0xfc,
 	AFHDS2A_SENSOR_RX_NOISE     = 0xfb,
 	AFHDS2A_SENSOR_RX_SNR       = 0xfa,
+	AFHDS2A_SENSOR_A3_VOLTAGE   = 0x03,
 };
 
+#if defined(AFHDS2A_FW_TELEMETRY) || defined(AFHDS2A_HUB_TELEMETRY)
 static void AFHDS2A_update_telemetry()
 {
+	// Read TX RSSI
+	int16_t temp=256-(A7105_ReadReg(A7105_1D_RSSI_THOLD)*8)/5;		// value from A7105 is between 8 for maximum signal strength to 160 or less
+	if(temp<0) temp=0;
+	else if(temp>255) temp=255;
+	TX_RSSI=temp;
 	// AA | TXID | rx_id | sensor id | sensor # | value 16 bit big endian | sensor id ......
-	// max 7 sensors per packet
+	// AC | TXID | rx_id | sensor id | sensor # | length | bytes | sensor id ......
 	#ifdef AFHDS2A_FW_TELEMETRY
 		if (option & 0x80)
+		{// forward 0xAA and 0xAC telemetry to TX, skip rx and tx id to save space
+			packet_in[0]= TX_RSSI;
+			debug("T(%02X)=",packet[0]);
+			for(uint8_t i=9;i < AFHDS2A_RXPACKET_SIZE; i++)
 			{
-        // forward telemetry to TX, skip rx and tx id to save space
-        pkt[0]= TX_RSSI;
-        for(int i=9;i < AFHDS2A_RXPACKET_SIZE; i++)
-            pkt[i-8]=packet[i];
-
+				packet_in[i-8]=packet[i];
+				debug(" %02X",packet[i]);
+			}
+			packet_in[29]=packet[0];	// 0xAA Normal telemetry, 0xAC Extended telemetry
 			telemetry_link=2;
+			debugln("");
 			return;
 		}
 	#endif
 	#ifdef AFHDS2A_HUB_TELEMETRY
+		if(packet[0]==0xAA)
+		{ // 0xAA Normal telemetry, 0xAC Extended telemetry not decoded here
 			for(uint8_t sensor=0; sensor<7; sensor++)
 			{
 				// Send FrSkyD telemetry to TX
@@ -110,19 +119,25 @@ static void AFHDS2A_update_telemetry()
 						v_lipo1 = packet[index+2];
 						telemetry_link=1;
 						break;
-			/*case AFHDS2A_SENSOR_RX_ERR_RATE:
-				// packet[index+2];
-				break;*/
-			case AFHDS2A_SENSOR_RX_RSSI:
-				RSSI_dBm = -packet[index+2];
+					case AFHDS2A_SENSOR_A3_VOLTAGE:
+						v_lipo2 = (packet[index+3]<<5) | (packet[index+2]>>3);	// allows to read voltage up to 4S
+						telemetry_link=1;
 						break;
-			case 0xff:
+					case AFHDS2A_SENSOR_RX_ERR_RATE:
+						if(packet[index+2]<=100)
+							RX_LQI=packet[index+2];
+						break;
+					case AFHDS2A_SENSOR_RX_RSSI:
+						RX_RSSI = -packet[index+2];
+						break;
+					case 0xff: // end of data
 						return;
 					/*default:
 						// unknown sensor ID
 						break;*/
 				}
 			}
+		}
 	#endif
 }
 #endif
@@ -163,29 +178,68 @@ static void AFHDS2A_build_bind_packet()
 
 static void AFHDS2A_build_packet(uint8_t type)
 {
+	uint16_t val;
 	memcpy( &packet[1], rx_tx_addr, 4);
 	memcpy( &packet[5], rx_id, 4);
 	switch(type)
 	{
 		case AFHDS2A_PACKET_STICKS:		
 			packet[0] = 0x58;
-			for(uint8_t ch=0; ch<14; ch++)
+			//16 channels + RX_LQI on channel 17
+			for(uint8_t ch=0; ch<num_ch; ch++)
 			{
-				packet[9 +  ch*2] = Servo_data[CH_AETR[ch]]&0xFF;
-				packet[10 + ch*2] = (Servo_data[CH_AETR[ch]]>>8)&0xFF;
+				if(ch == 16 // CH17=RX_LQI
+				#ifdef AFHDS2A_LQI_CH
+					|| ch == (AFHDS2A_LQI_CH-1)	// override channel with LQI
+				#endif
+					)
+					val = 2000 - 10*RX_LQI;
+				else
+					val = convert_channel_ppm(CH_AETR[ch]);
+				if(ch<14)
+				{
+					packet[9 +  ch*2] = val;
+					packet[10 + ch*2] = (val>>8)&0x0F;
+				}
+				else
+				{
+					packet[10 + (ch-14)*6] |= (val)<<4;
+					packet[12 + (ch-14)*6] |= (val)&0xF0;
+					packet[14 + (ch-14)*6] |= (val>>4)&0xF0;
+				}
 			}
 			break;
 		case AFHDS2A_PACKET_FAILSAFE:
 			packet[0] = 0x56;
-			for(uint8_t ch=0; ch<14; ch++)
+			for(uint8_t ch=0; ch<num_ch; ch++)
 			{
-				/*if((Model.limits[ch].flags & CH_FAILSAFE_EN))
+				#ifdef FAILSAFE_ENABLE
+					if(ch<16)
+						val = Failsafe_data[CH_AETR[ch]];
+					else
+						val = FAILSAFE_CHANNEL_NOPULSES;
+					if(val!=FAILSAFE_CHANNEL_HOLD && val!=FAILSAFE_CHANNEL_NOPULSES)
+					{ // Failsafe values
+						val = (((val<<2)+val)>>3)+860;
+						if(ch<14)
 						{
-					packet[9 + ch*2] = Servo_data[CH_AETR[ch]] & 0xff;
-					packet[10+ ch*2] = (Servo_data[CH_AETR[ch]] >> 8) & 0xff;
+							packet[9 +  ch*2] = val;
+							packet[10 + ch*2] = (val>>8)&0x0F;
 						}
-				else*/
+						else
 						{
+							packet[10 + (ch-14)*6] &= 0x0F;
+							packet[10 + (ch-14)*6] |= (val)<<4;
+							packet[12 + (ch-14)*6] &= 0x0F;
+							packet[12 + (ch-14)*6] |= (val)&0xF0;
+							packet[14 + (ch-14)*6] &= 0x0F;
+							packet[14 + (ch-14)*6] |= (val>>4)&0xF0;
+						}
+					}
+					else
+				#endif
+						if(ch<14)
+						{ // no values
 							packet[9 + ch*2] = 0xff;
 							packet[10+ ch*2] = 0xff;
 						}
@@ -195,21 +249,18 @@ static void AFHDS2A_build_packet(uint8_t type)
 			packet[0] = 0xaa;
 			packet[9] = 0xfd;
 			packet[10]= 0xff;
-			uint16_t val_hz=5*(option & 0x7f)+50;			// option value should be between 0 and 70 which gives a value between 50 and 400Hz
-			if(val_hz<50 || val_hz>400) val_hz=50;	// default is 50Hz
-			packet[11]= val_hz;
-			packet[12]= val_hz >> 8;
-			if(sub_protocol == PPM_IBUS || sub_protocol == PPM_SBUS)
-				packet[13] = 0x01;	// PPM output enabled
-			else
-				packet[13] = 0x00;
+			val=5*(option & 0x7f)+50;	// option value should be between 0 and 70 which gives a value between 50 and 400Hz
+			if(val<50 || val>400) val=50;	// default is 50Hz
+			packet[11]= val;
+			packet[12]= val >> 8;
+			packet[13] = sub_protocol & 0x01;	// 1 -> PPM output enabled
 			packet[14]= 0x00;
 			for(uint8_t i=15; i<37; i++)
 				packet[i] = 0xff;
 			packet[18] = 0x05;		// ?
 			packet[19] = 0xdc;		// ?
 			packet[20] = 0x05;		// ?
-			if(sub_protocol == PWM_SBUS || sub_protocol == PPM_SBUS)
+			if(sub_protocol&2)
 				packet[21] = 0xdd;	// SBUS output enabled
 			else
 				packet[21] = 0xde;	// IBUS
@@ -219,12 +270,22 @@ static void AFHDS2A_build_packet(uint8_t type)
 }
 
 #define AFHDS2A_WAIT_WRITE 0x80
-uint16_t ReadAFHDS2A()
+
+#ifdef STM32_BOARD
+	#define AFHDS2A_WRITE_TIME 1550
+#else
+	#define AFHDS2A_WRITE_TIME 1700
+#endif
+
+uint16_t AFHDS2A_callback()
 {
-	static uint8_t packet_type = AFHDS2A_PACKET_STICKS;
-	static uint16_t packet_counter=0;
-	uint8_t data_rx;
+	static uint8_t packet_type;
+	static uint16_t packet_counter;
+	uint8_t data_rx=0;
 	uint16_t start;
+	#ifndef FORCE_AFHDS2A_TUNING
+		A7105_AdjustLOBaseFreq(1);
+	#endif
 	switch(phase)
 	{
 		case AFHDS2A_BIND1:
@@ -232,41 +293,50 @@ uint16_t ReadAFHDS2A()
 		case AFHDS2A_BIND3:
 			AFHDS2A_build_bind_packet();
 			A7105_WriteData(AFHDS2A_TXPACKET_SIZE, packet_count%2 ? 0x0d : 0x8c);
-			if(!(A7105_ReadReg(A7105_00_MODE) & (1<<5 | 1<<6)))
-			{ // FECF+CRCF Ok
+			if(!(A7105_ReadReg(A7105_00_MODE) & (1<<5)))	//  removed FECF check due to issues with fs-x6b -> & (1<<5 | 1<<6)
+			{ // CRCF Ok
 				A7105_ReadData(AFHDS2A_RXPACKET_SIZE);
 				if(packet[0] == 0xbc && packet[9] == 0x01)
 				{
-					uint8_t temp=50+RX_num*4;
-					uint8_t i;
-					for(i=0; i<4; i++)
+					uint16_t addr;
+					if(RX_num<16)
+						addr=AFHDS2A_EEPROM_OFFSET+RX_num*4;
+					else
+						addr=AFHDS2A_EEPROM_OFFSET2+(RX_num-16)*4;
+					for(uint8_t i=0; i<4; i++)
 					{
 						rx_id[i] = packet[5+i];
-						eeprom_write_byte((EE_ADDR)(temp+i),rx_id[i]);
+						eeprom_write_byte((EE_ADDR)(addr+i),rx_id[i]);
 					}
 					phase = AFHDS2A_BIND4;
 					packet_count++;
-					return 3850;
+					break;
 				}
 			}
 			packet_count++;
+			if(IS_BIND_DONE)
+			{ // exit bind if asked to do so from the GUI
+				phase = AFHDS2A_BIND4;
+				break;
+			}
 			phase |= AFHDS2A_WAIT_WRITE;
-			return 1700;
+			return AFHDS2A_WRITE_TIME;
 		case AFHDS2A_BIND1|AFHDS2A_WAIT_WRITE:
 		case AFHDS2A_BIND2|AFHDS2A_WAIT_WRITE:
 		case AFHDS2A_BIND3|AFHDS2A_WAIT_WRITE:
 			//Wait for TX completion
 			start=micros();
-			while ((uint16_t)micros()-start < 700)			// Wait max 700µs, using serial+telemetry exit in about 120µs
+			while ((uint16_t)((uint16_t)micros()-start) < 700)			// Wait max 700µs, using serial+telemetry exit in about 120µs
 				if(!(A7105_ReadReg(A7105_00_MODE) & 0x01))
 					break;
-			A7105_SetTxRxMode(RX_EN);
+			A7105_SetPower();
+			A7105_SetTxRxMode(TXRX_OFF);					// Turn LNA off since we are in near range and we want to prevent swamping
 			A7105_Strobe(A7105_RX);
 			phase &= ~AFHDS2A_WAIT_WRITE;
 			phase++;
 			if(phase > AFHDS2A_BIND3)
 				phase = AFHDS2A_BIND1;
-			return 2150;
+			return 3850-AFHDS2A_WRITE_TIME;
 		case AFHDS2A_BIND4:
 			AFHDS2A_build_bind_packet();
 			A7105_WriteData(AFHDS2A_TXPACKET_SIZE, packet_count%2 ? 0x0d : 0x8c);
@@ -274,86 +344,106 @@ uint16_t ReadAFHDS2A()
 			bind_phase++;
 			if(bind_phase>=4)
 			{ 
-				packet_counter=0;
-				packet_type = AFHDS2A_PACKET_STICKS;
 				hopping_frequency_no=1;
-				phase = AFHDS2A_DATA;
+				phase = AFHDS2A_DATA_INIT;
 				BIND_DONE;
 			}
-			return 3850;
+			break;
+		case AFHDS2A_DATA_INIT:
+			packet_counter=0;
+			packet_type = AFHDS2A_PACKET_STICKS;
+			phase = AFHDS2A_DATA;
 		case AFHDS2A_DATA:
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(3850);
+			#endif
 			AFHDS2A_build_packet(packet_type);
-			if((A7105_ReadReg(A7105_00_MODE) & 0x01))		// Check if something has been received...
-				data_rx=0;
-			else
-				data_rx=1;									// Yes
+			data_rx=A7105_ReadReg(A7105_00_MODE);			// Check if something has been received...
 			A7105_WriteData(AFHDS2A_TXPACKET_SIZE, hopping_frequency[hopping_frequency_no++]);
 			if(hopping_frequency_no >= AFHDS2A_NUMFREQ)
 				hopping_frequency_no = 0;
 			if(!(packet_counter % 1313))
 				packet_type = AFHDS2A_PACKET_SETTINGS;
-			else if(!(packet_counter % 1569))
+			else
+			{
+				#ifdef FAILSAFE_ENABLE
+					if(!(packet_counter % 1569) && IS_FAILSAFE_VALUES_on)
+					{
 						packet_type = AFHDS2A_PACKET_FAILSAFE;
-			else
-				packet_type = AFHDS2A_PACKET_STICKS;		// todo : check for settings changes
-			if(!(A7105_ReadReg(A7105_00_MODE) & (1<<5 | 1<<6)) && data_rx==1)
-			{ // RX+FECF+CRCF Ok
-				A7105_ReadData(AFHDS2A_RXPACKET_SIZE);
-				if(packet[0] == 0xaa)
-				{
-					if(packet[9] == 0xfc)
-						packet_type=AFHDS2A_PACKET_SETTINGS;	// RX is asking for settings
-					#if defined(AFHDS2A_FW_TELEMETRY) || defined(AFHDS2A_HUB_TELEMETRY)
-					else
-					{
-						// Read TX RSSI
-						int16_t temp=256-(A7105_ReadReg(A7105_1D_RSSI_THOLD)*8)/5;		// value from A7105 is between 8 for maximum signal strength to 160 or less
-						if(temp<0) temp=0;
-						else if(temp>255) temp=255;
-						TX_RSSI=temp;
-						AFHDS2A_update_telemetry();
+						FAILSAFE_VALUES_off;
 					}
+					else
 				#endif
+						packet_type = AFHDS2A_PACKET_STICKS;	// todo : check for settings changes
+			}
+			if(!(A7105_ReadReg(A7105_00_MODE) & (1<<5)) && !(data_rx & 1))	// removed FECF check due to issues with fs-x6b ->  & (1<<5 | 1<<6)
+			{ // RX+CRCF Ok
+				A7105_ReadData(AFHDS2A_RXPACKET_SIZE);
+				if(packet[0] == 0xAA && packet[9] == 0xFC)
+					packet_type=AFHDS2A_PACKET_SETTINGS;		// RX is asking for settings
+				else
+					if((packet[0] == 0xAA && packet[9]!=0xFD) || packet[0] == 0xAC)
+					{// Normal telemetry packet, ignore packets which contain the RX configuration: AA FD FF 32 00 01 00 FF FF FF 05 DC 05 DE FA FF FF FF FF FF FF FF FF FF FF FF FF FF FF
+						if(!memcmp(&packet[1], rx_tx_addr, 4))
+						{ // TX address validated
+							for(uint8_t sensor=0; sensor<7; sensor++)
+							{//read LQI value for RX output
+								uint8_t index = 9+(4*sensor);
+								if(packet[index]==AFHDS2A_SENSOR_RX_ERR_RATE && packet[index+2]<=100)
+								{
+									RX_LQI=packet[index+2];
+									break;
+								}
+							}
+							#if defined(AFHDS2A_FW_TELEMETRY) || defined(AFHDS2A_HUB_TELEMETRY)
+								AFHDS2A_update_telemetry();
+							#endif
+						}
 					}
 			}
 			packet_counter++;
 			phase |= AFHDS2A_WAIT_WRITE;
-			return 1700;
+			return AFHDS2A_WRITE_TIME;
 		case AFHDS2A_DATA|AFHDS2A_WAIT_WRITE:
 			//Wait for TX completion
 			start=micros();
-			while ((uint16_t)micros()-start < 700)			// Wait max 700µs, using serial+telemetry exit in about 120µs
+			while ((uint16_t)((uint16_t)micros()-start) < 700)			// Wait max 700µs, using serial+telemetry exit in about 120µs
 				if(!(A7105_ReadReg(A7105_00_MODE) & 0x01))
 					break;
+			A7105_SetPower();
 			A7105_SetTxRxMode(RX_EN);
 			A7105_Strobe(A7105_RX);
 			phase &= ~AFHDS2A_WAIT_WRITE;
-			return 2150;
+			return 3850-AFHDS2A_WRITE_TIME;
 	}
-	return 3850; // never reached, please the compiler
+	return 3850;
 }
 
-uint16_t initAFHDS2A()
+void AFHDS2A_init()
 {
 	A7105_Init();
 
 	AFHDS2A_calc_channels();
 	packet_count = 0;
 	bind_phase = 0;
-	if(IS_AUTOBIND_FLAG_on)
+	if(IS_BIND_IN_PROGRESS)
 		phase = AFHDS2A_BIND1;
 	else
 	{
-		phase = AFHDS2A_DATA;
+		phase = AFHDS2A_DATA_INIT;
 		//Read RX ID from EEPROM based on RX_num, RX_num must be uniq for each RX
-		uint8_t temp=50+RX_num*4;
+		uint16_t addr;
+		if(RX_num<16)
+			addr=AFHDS2A_EEPROM_OFFSET+RX_num*4;
+		else
+			addr=AFHDS2A_EEPROM_OFFSET2+(RX_num-16)*4;
 		for(uint8_t i=0;i<4;i++)
-			rx_id[i]=eeprom_read_byte((EE_ADDR)(temp+i));
+			rx_id[i]=eeprom_read_byte((EE_ADDR)(addr+i));
 	}
 	hopping_frequency_no = 0;
-#if defined(AFHDS2A_FW_TELEMETRY) || defined(AFHDS2A_HUB_TELEMETRY)
-	init_hub_telemetry();
-#endif
-	return 50000;
+	if(sub_protocol&0x04)
+		num_ch=17;
+	else
+		num_ch=14;
 }
 #endif

Multiprotocol/ASSAN_nrf24l01.ino

@@ -33,29 +33,25 @@ enum {
     ASSAN_DATA5
 };
 
-void ASSAN_init()
+void ASSAN_RF_init()
 {
     NRF24L01_Initialize();
+	//Specifics to ASSAN
     NRF24L01_WriteReg(NRF24L01_03_SETUP_AW, 0x02);			// 4 bytes rx/tx address
 	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR,    (uint8_t *)"\x80\x80\x80\xB8", ASSAN_ADDRESS_LENGTH);	// Bind address
 	NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0, (uint8_t *)"\x80\x80\x80\xB8", ASSAN_ADDRESS_LENGTH);	// Bind address
-	NRF24L01_FlushTx();
-	NRF24L01_FlushRx();
-    NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);			// Clear data ready, data sent, and retransmit
-    NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);				// No Auto Acknowldgement on all data pipes
-	NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x01);			// Enable data pipe 0 only
 	NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, ASSAN_PACKET_SIZE);
-    NRF24L01_SetPower();
 }
 
 void ASSAN_send_packet()
 {
-	uint16_t temp;
 	for(uint8_t i=0;i<8;i++)
 	{
-		temp=Servo_data[i]<<3;
-		packet[2*i]=temp>>8;
-		packet[2*i+1]=temp;
+		uint16_t val=Channel_data[i];
+		val=((val<<2)+val)+(860<<3);					// PPM value <<3
+		
+		packet[2*i]=val>>8;
+		packet[2*i+1]=val;
 	}
 	for(uint8_t i=0;i<ASSAN_ADDRESS_LENGTH;i++)
 		packet[16+i]=packet[23-i];
@@ -126,6 +122,9 @@ uint16_t ASSAN_callback()
 			phase=ASSAN_DATA2;
 			return 2000;
 		case ASSAN_DATA2:
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(12000);
+			#endif
 		case ASSAN_DATA3:
 			ASSAN_send_packet();
 			phase++;	// DATA 3 or 4
@@ -143,7 +142,7 @@ static void __attribute__((unused)) ASSAN_initialize_txid()
 	packet[20]=0x53; */
 	// Using packet[20..23] to store the ID1 and packet[24..27] to store the ID2
 	uint8_t freq=0,freq2;
-	for(uint8_t i=0;i<4;i++)
+	for(uint8_t i=0;i<ASSAN_ADDRESS_LENGTH;i++)
 	{
 		uint8_t temp=rx_tx_addr[i];
 		packet[i+20]=temp;
@@ -165,17 +164,16 @@ static void __attribute__((unused)) ASSAN_initialize_txid()
 	hopping_frequency[1]=freq2;
 }
 
-uint16_t initASSAN()
+void ASSAN_init()
 {
 	ASSAN_initialize_txid();
-	ASSAN_init();
+	ASSAN_RF_init();
 	hopping_frequency_no = 0;
 
-	if(IS_AUTOBIND_FLAG_on)
+	if(IS_BIND_IN_PROGRESS)
 		phase=ASSAN_BIND0;
 	else 
 		phase=ASSAN_DATA0;
-	return 1000;
 }
 
 #endif

Multiprotocol/Arduino.ino

@@ -12,12 +12,23 @@
  You should have received a copy of the GNU General Public License
  along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef STM32_BOARD
 /************************************/
 /************************************/
 /**  Arduino replacement routines  **/
 /************************************/
 // replacement map()
+int16_t map16b( int16_t x, int16_t in_min, int16_t in_max, int16_t out_min, int16_t out_max)
+{
+//  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+	long y ;
+	x -= in_min ;
+	y = out_max - out_min ;
+	y *= x ;
+	x = y / (in_max - in_min) ;
+	return x  + out_min ;
+}
+
+#ifndef STM32_BOARD
 int16_t map( int16_t x, int16_t in_min, int16_t in_max, int16_t out_min, int16_t out_max)
 {
 //  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
@@ -104,7 +115,7 @@ void delayMilliseconds(unsigned long ms)
    uint16_t lms = ms ;
 
    while (lms > 0) {
-      if (((uint16_t)micros() - start) >= 1000) {
+      if ((uint16_t)((uint16_t)micros() - start) >= 1000) {
          lms--;
          start += 1000;
       }

Multiprotocol/BUGSMINI_nrf24l01.ino

@@ -0,0 +1,364 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// compatible with MJX Bugs 3 Mini and Bugs 3H
+
+#if defined(BUGSMINI_NRF24L01_INO)
+
+#include "iface_xn297.h"
+
+#define BUGSMINI_INITIAL_WAIT    500
+#define BUGSMINI_PACKET_INTERVAL 6840
+#define BUGSMINI_WRITE_WAIT      2000
+#define BUGSMINI_TX_PAYLOAD_SIZE 24
+#define BUGSMINI_RX_PAYLOAD_SIZE 16
+#define BUGSMINI_NUM_RF_CHANNELS 15
+#define BUGSMINI_ADDRESS_SIZE    5
+
+static uint8_t BUGSMINI_txid[3];
+static uint8_t BUGSMINI_txhash;
+
+enum {
+    BUGSMINI_BIND1,
+    BUGSMINI_BIND2,
+    BUGSMINI_DATA1,
+    BUGSMINI_DATA2
+};
+
+#define BUGSMINI_CH_SW_ARM		CH5_SW
+#define BUGSMINI_CH_SW_ANGLE	CH6_SW
+#define BUGSMINI_CH_SW_FLIP		CH7_SW
+#define BUGSMINI_CH_SW_PICTURE	CH8_SW
+#define BUGSMINI_CH_SW_VIDEO	CH9_SW
+#define BUGSMINI_CH_SW_LED		CH10_SW
+#define BUGSMINI_CH_SW_ALTHOLD	CH11_SW
+
+// flags packet[12]
+#define BUGSMINI_FLAG_FLIP    0x08    // automatic flip
+#define BUGSMINI_FLAG_MODE    0x04    // low/high speed select (set is high speed)
+#define BUGSMINI_FLAG_VIDEO   0x02    // toggle video
+#define BUGSMINI_FLAG_PICTURE 0x01    // toggle picture
+
+// flags packet[13]
+#define BUGSMINI_FLAG_LED     0x80    // enable LEDs
+#define BUGSMINI_FLAG_ARM     0x40    // arm (toggle to turn on motors)
+#define BUGSMINI_FLAG_DISARM  0x20    // disarm (toggle to turn off motors)
+#define BUGSMINI_FLAG_ANGLE   0x02    // angle/acro mode (set is angle mode)
+#define BUGSMINI_FLAG_ALTHOLD 0x04    // angle/altitude hold mode (set is altitude mode)
+
+static void __attribute__((unused)) BUGSMINI_RF_init()
+{
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
+	//XN297_HoppingCalib(BUGSMINI_NUM_RF_CHANNELS*2);
+}
+
+static void __attribute__((unused)) BUGSMINI_check_arming()
+{
+	uint8_t arm_channel = BUGSMINI_CH_SW_ARM;
+
+	if (arm_channel != arm_channel_previous)
+	{
+		arm_channel_previous = arm_channel;
+		if (arm_channel)
+		{
+			armed = 1;
+			arm_flags ^= BUGSMINI_FLAG_ARM;
+		}
+		else
+		{
+			armed = 0;
+			arm_flags ^= BUGSMINI_FLAG_DISARM;
+		}
+	}
+}
+
+static void __attribute__((unused)) BUGSMINI_send_packet()
+{
+	BUGSMINI_check_arming();  // sets globals arm_flags and armed
+
+	uint16_t aileron  = convert_channel_16b_limit(AILERON,500,0);
+	uint16_t elevator = convert_channel_16b_limit(ELEVATOR,0,500);
+	uint16_t throttle = armed ? convert_channel_16b_limit(THROTTLE,0,500) : 0;
+	uint16_t rudder   = convert_channel_16b_limit(RUDDER,500,0);
+
+	packet[1] = BUGSMINI_txid[0];
+	packet[2] = BUGSMINI_txid[1];
+	packet[3] = BUGSMINI_txid[2];
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[4] = 0x00;
+		packet[5] = 0x7d;
+		packet[6] = 0x7d;
+		packet[7] = 0x7d;
+		packet[8] = 0x20;
+		packet[9] = 0x20;
+		packet[10]= 0x20;
+		packet[11]= 0x40;
+		packet[12]^= 0x40;	 // alternating freq hopping flag
+		packet[13]= 0x60;
+		packet[14]= 0x00;
+		packet[15]= 0x00;
+	}
+	else
+	{
+		packet[4] = throttle >> 1;
+		packet[5] = rudder >> 1;
+		packet[6] = elevator >> 1;
+		packet[7] = aileron >> 1;
+		packet[8] = (((aileron / 5) >> 1) + 7)   // dynamic trim 0x07 - 0x39
+					| (aileron << 7);
+		packet[9] = (((elevator / 5) >> 1) + 7)  // dynamic trim 0x07 - 0x39
+					| (elevator << 7);
+		packet[10]= (((rudder / 5) >> 1) + 7)    // dynamic trim 0x07 - 0x39
+					| (rudder << 7);
+		packet[11]= 0x40 | (throttle << 7);
+		packet[12]= 0x80 | ((packet[12] ^ 0x40) & 0x40)
+			| BUGSMINI_FLAG_MODE
+			| GET_FLAG(BUGSMINI_CH_SW_PICTURE, BUGSMINI_FLAG_PICTURE)
+			| GET_FLAG(BUGSMINI_CH_SW_VIDEO, BUGSMINI_FLAG_VIDEO);
+		if(armed)
+			packet[12] |= GET_FLAG(BUGSMINI_CH_SW_FLIP, BUGSMINI_FLAG_FLIP);
+		packet[13] = arm_flags
+			| GET_FLAG(BUGSMINI_CH_SW_LED, BUGSMINI_FLAG_LED)
+			| GET_FLAG(BUGSMINI_CH_SW_ALTHOLD, BUGSMINI_FLAG_ALTHOLD)
+			| GET_FLAG(BUGSMINI_CH_SW_ANGLE, BUGSMINI_FLAG_ANGLE);
+			// BUGS3H althold -> BUGSMINI_FLAG_ALTHOLD|BUGSMINI_FLAG_ANGLE , angle -> 0
+		packet[14] = 0;
+		packet[15] = 0; // a lot of 0x53 and some 0x52 on bugs 3H
+	}
+	uint8_t checksum = 0x6d;
+	for(uint8_t i=1; i < BUGSMINI_TX_PAYLOAD_SIZE; i++)
+	checksum ^= packet[i];
+	packet[0] = checksum;
+
+	if(!(packet[12]&0x40))
+	{
+		hopping_frequency_no++;
+		if(hopping_frequency_no >= BUGSMINI_NUM_RF_CHANNELS)
+			hopping_frequency_no = 0;
+		XN297_Hopping(IS_BIND_IN_PROGRESS ? hopping_frequency_no+BUGSMINI_NUM_RF_CHANNELS : hopping_frequency_no);
+	}
+
+	// Send
+	XN297_SetPower();
+	XN297_SetTxRxMode(TXRX_OFF);
+	XN297_SetTxRxMode(TX_EN);
+	XN297_WritePayload(packet, BUGSMINI_TX_PAYLOAD_SIZE);
+}
+
+// compute final address for the rxid received during bind
+// thanks to Pascal for the function!
+const uint8_t PROGMEM BUGSMINI_end []= {
+	0x2d,0x9e ,0x95,0xa4 ,0x9c,0x5c ,0xb4,0xa6 ,0xa9,0xce ,0x56,0x2b ,0x3e,0x73 ,0xb8,0x95 ,0x6a,0x82,
+	0x94,0x37 ,0x3d,0x5a ,0x4b,0xb2 ,0x69,0x49 ,0xc2,0x24 ,0x6b,0x3d ,0x23,0xc6 ,0x9e,0xa3 ,0xa4,0x98,
+	0x5c,0x9e ,0xa6,0x52 ,0xce,0x76 ,0x2b,0x4b ,0x73,0x3a };
+static void __attribute__((unused)) BUGSMINI_make_address()
+{
+    uint8_t start, length, index;
+
+	//read rxid
+	uint8_t base_adr=BUGSMINI_EEPROM_OFFSET+(RX_num&0x0F)*2;
+    uint8_t rxid_high = eeprom_read_byte((EE_ADDR)(base_adr+0));
+    uint8_t rxid_low  = eeprom_read_byte((EE_ADDR)(base_adr+1));
+    
+    if(rxid_high==0x00 || rxid_high==0xFF)
+        rx_tx_addr[0]=0x52;
+    else
+        rx_tx_addr[0]=rxid_high;
+    
+    rx_tx_addr[1]=BUGSMINI_txhash;
+    
+    if(rxid_low==0x00 || rxid_low==0xFF)
+        rx_tx_addr[2]=0x66;
+    else
+        rx_tx_addr[2]=rxid_low;
+    
+    for(uint8_t end_idx=0;end_idx<23;end_idx++)
+    {
+        //calculate sequence start
+        if(end_idx<=7)
+            start=end_idx;
+        else
+            start=(end_idx-7)*16+7;
+        //calculate sequence length
+        if(end_idx>6)
+        {
+            if(end_idx>15)
+                length=(23-end_idx)<<1;
+            else
+                length=16;
+        }
+        else
+            length=(end_idx+1)<<1;
+        //calculate first index
+        index=start-rxid_high;
+        //scan for a possible match using the current end
+        for(uint8_t i=0;i<length;i++)
+        {
+            if(index==rxid_low)
+            { //match found
+                rx_tx_addr[3]=pgm_read_byte_near( &BUGSMINI_end[end_idx<<1] );
+                rx_tx_addr[4]=pgm_read_byte_near( &BUGSMINI_end[(end_idx<<1)+1] );
+                return;
+            }
+            index+=i&1?7:8;	//increment index
+        }
+    }
+    // Something wrong happened if we arrive here....
+}
+
+#if defined(BUGS_HUB_TELEMETRY)
+static void __attribute__((unused)) BUGSMINI_update_telemetry()
+{
+	uint8_t checksum = 0x6d;
+	for(uint8_t i=1; i<12; i++)
+		checksum += packet_in[i];
+	if(packet_in[0] == checksum)
+	{
+		RX_RSSI = packet_in[3];
+		if(sub_protocol==BUGS3H)
+		{
+			if(packet_in[11] & 0x40)
+				v_lipo1 = 0x40; // Warning
+			else if(packet_in[11] & 0x80)
+				v_lipo1 = 0x20; // Critical
+			else
+				v_lipo1 = 0x80; // Ok
+		}
+		else
+		{
+			if(packet_in[11] & 0x80)
+				v_lipo1 = 0x80; // Ok
+			else if(packet_in[11] & 0x40)
+				v_lipo1 = 0x40; // Warning
+			else
+				v_lipo1 = 0x20; // Critical
+		}
+		telemetry_link=1;
+	}
+}
+#endif
+
+uint16_t BUGSMINI_callback()
+{
+	uint8_t base_adr;
+	switch(phase)
+	{
+		case BUGSMINI_BIND1:
+			if( XN297_IsRX() )
+			{ // RX fifo data ready
+				XN297_ReadPayload(packet, BUGSMINI_RX_PAYLOAD_SIZE);	// Not checking the CRC??
+				base_adr=BUGSMINI_EEPROM_OFFSET+(RX_num&0x0F)*2;
+				eeprom_write_byte((EE_ADDR)(base_adr+0),packet[1]);		// Save rxid in EEPROM
+				eeprom_write_byte((EE_ADDR)(base_adr+1),packet[2]);		// Save rxid in EEPROM
+				BUGSMINI_make_address();
+				XN297_SetTXAddr(rx_tx_addr, 5);
+				XN297_SetRXAddr(rx_tx_addr, BUGSMINI_RX_PAYLOAD_SIZE);
+				phase = BUGSMINI_DATA1;
+				BIND_DONE;
+				break;
+			}
+			BUGSMINI_send_packet();
+			phase = BUGSMINI_BIND2;
+			return BUGSMINI_WRITE_WAIT;
+		case BUGSMINI_BIND2:
+			// switch to RX mode
+			XN297_SetTxRxMode(TXRX_OFF);
+			XN297_SetTxRxMode(RX_EN);
+			phase = BUGSMINI_BIND1;
+			return BUGSMINI_PACKET_INTERVAL - BUGSMINI_WRITE_WAIT;
+		case BUGSMINI_DATA1:
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(BUGSMINI_PACKET_INTERVAL);
+			#endif
+			#if defined(BUGS_HUB_TELEMETRY)
+				if( XN297_IsRX() )
+				{
+					XN297_ReadPayload(packet_in, BUGSMINI_RX_PAYLOAD_SIZE);	// Not checking the CRC??
+					BUGSMINI_update_telemetry();
+				}
+			#endif
+			BUGSMINI_send_packet();
+	#if not defined(BUGS_HUB_TELEMETRY)
+			break;
+	#else
+			phase = BUGSMINI_DATA2;
+			return BUGSMINI_WRITE_WAIT;
+		case BUGSMINI_DATA2:
+			// switch to RX mode
+			XN297_SetTxRxMode(TXRX_OFF);
+			XN297_SetTxRxMode(RX_EN);
+			phase = BUGSMINI_DATA1;
+			return BUGSMINI_PACKET_INTERVAL - BUGSMINI_WRITE_WAIT;
+	#endif
+	}
+	return BUGSMINI_PACKET_INTERVAL;
+}
+
+#define BUGSMINI_NUM_TX_RF_MAPS 4
+// haven't figured out BUGSMINI_txid<-->rf channel mapping yet
+const uint8_t PROGMEM BUGSMINI_RF_chans[BUGSMINI_NUM_TX_RF_MAPS][BUGSMINI_NUM_RF_CHANNELS] = {
+	{0x22,0x2f,0x3a,0x14,0x20,0x2d,0x38,0x18,0x26,0x32,0x11,0x1d,0x29,0x35,0x17},
+	{0x3d,0x34,0x2b,0x22,0x19,0x40,0x37,0x2e,0x25,0x1c,0x3a,0x31,0x28,0x1f,0x16},
+	{0x12,0x20,0x2f,0x1a,0x28,0x38,0x14,0x23,0x32,0x1c,0x2c,0x3b,0x17,0x26,0x34},
+	{0x13,0x25,0x37,0x1F,0x31,0x17,0x28,0x3A,0x1C,0x2E,0x22,0x33,0x19,0x2B,0x3D} };
+const uint8_t PROGMEM BUGSMINI_bind_chans[BUGSMINI_NUM_RF_CHANNELS] = {
+	0x1A,0x23,0x2C,0x35,0x3E,0x17,0x20,0x29,0x32,0x3B,0x14,0x1D,0x26,0x2F,0x38}; // bugs 3 mini bind channels
+const uint8_t PROGMEM BUGSMINI_tx_id[BUGSMINI_NUM_TX_RF_MAPS][3] = {
+	{0xA8,0xE6,0x32},
+	{0xdd,0xab,0xfd},
+	{0x90,0x9e,0x4a},
+	{0x20,0x28,0xBA} };
+const uint8_t PROGMEM BUGSMINI_tx_hash[BUGSMINI_NUM_TX_RF_MAPS] = { // 2nd byte of final address
+	0x6c,0x9e,0x3d,0xb3};
+	
+static void __attribute__((unused)) BUGSMINI_initialize_txid()
+{
+	// load hopping_frequency with tx channels in low part and bind channels in high part
+	for(uint8_t i=0; i<BUGSMINI_NUM_RF_CHANNELS;i++)
+	{
+		hopping_frequency[i]=pgm_read_byte_near( &BUGSMINI_RF_chans[rx_tx_addr[3]%BUGSMINI_NUM_TX_RF_MAPS][i] );
+		hopping_frequency[i+BUGSMINI_NUM_RF_CHANNELS]=pgm_read_byte_near( &BUGSMINI_bind_chans[i] );
+	}
+	// load txid
+	for(uint8_t i=0; i<sizeof(BUGSMINI_txid);i++)
+		BUGSMINI_txid[i]=pgm_read_byte_near( &BUGSMINI_tx_id[rx_tx_addr[3]%BUGSMINI_NUM_TX_RF_MAPS][i] );
+	//load tx_hash
+	BUGSMINI_txhash = pgm_read_byte_near( &BUGSMINI_tx_hash[rx_tx_addr[3]%BUGSMINI_NUM_TX_RF_MAPS] );
+}
+
+void BUGSMINI_init()
+{
+	BUGSMINI_initialize_txid();
+	BUGSMINI_RF_init();
+	memset(packet, (uint8_t)0, BUGSMINI_TX_PAYLOAD_SIZE);
+	if(IS_BIND_IN_PROGRESS)
+	{
+		XN297_SetTXAddr((const uint8_t*)"mjxRC", 5);
+		XN297_SetRXAddr((const uint8_t*)"mjxRC", BUGSMINI_RX_PAYLOAD_SIZE);
+		phase = BUGSMINI_BIND1;
+	}
+	else
+	{
+		BUGSMINI_make_address();
+		XN297_SetTXAddr(rx_tx_addr, 5);
+		XN297_SetRXAddr(rx_tx_addr, BUGSMINI_RX_PAYLOAD_SIZE);
+		phase = BUGSMINI_DATA1;
+	}
+	armed = 0;
+	arm_flags = BUGSMINI_FLAG_DISARM;    // initial value from captures
+	arm_channel_previous = BUGSMINI_CH_SW_ARM;
+}
+
+#endif

Multiprotocol/Bayang_Rx_nrf24l01.ino

@@ -0,0 +1,204 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(BAYANG_RX_NRF24L01_INO)
+
+#include "iface_xn297.h"
+
+#define BAYANG_RX_PACKET_SIZE		15
+#define BAYANG_RX_RF_NUM_CHANNELS	4
+#define BAYANG_RX_RF_BIND_CHANNEL	0
+#define BAYANG_RX_ADDRESS_LENGTH	5
+
+enum {
+	BAYANG_RX_BIND = 0,
+	BAYANG_RX_DATA
+};
+
+static void __attribute__((unused)) Bayang_Rx_RF_init()
+{
+	const uint8_t bind_address[BAYANG_RX_ADDRESS_LENGTH] = { 0,0,0,0,0 };
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
+	XN297_SetTXAddr(bind_address, BAYANG_RX_ADDRESS_LENGTH);
+	XN297_SetRXAddr(bind_address, BAYANG_RX_PACKET_SIZE);
+	XN297_RFChannel(BAYANG_RX_RF_BIND_CHANNEL);
+	XN297_SetTxRxMode(TXRX_OFF);
+	XN297_SetTxRxMode(RX_EN);
+}
+
+static uint8_t __attribute__((unused)) Bayang_Rx_check_validity() {
+	uint8_t sum = packet[0];
+	for (uint8_t i = 1; i < BAYANG_RX_PACKET_SIZE - 1; i++)
+		sum += packet[i];
+	return sum == packet[14];
+}
+
+static void __attribute__((unused)) Bayang_Rx_build_telemetry_packet()
+{
+	uint32_t bits = 0;
+	uint8_t bitsavailable = 0;
+	uint8_t idx = 0;
+
+	packet_in[idx++] = RX_LQI;
+	packet_in[idx++] = RX_LQI>>1;	// no RSSI: 125..0
+	packet_in[idx++] = 0;			// start channel
+	packet_in[idx++] = 10;			// number of channels in packet
+
+	// convert & pack channels
+	for (uint8_t i = 0; i < packet_in[3]; i++) {
+		uint32_t val = CHANNEL_MIN_100;
+		if (i < 4) {
+			// AETR
+			//val = (((packet[4 + i * 2] & ~0x7C) << 8) | packet[5 + i * 2]) << 1;
+			val=packet[4 + i * 2]&0x03;
+			val=(val<<8)+packet[5 + i * 2];
+			val=((val+128)<<3)/5;
+		} else if (i == 4 || i == 5) {
+			val=packet[i==4?1:13];
+			val=((val+32)<<5)/5;						// extra analog channel
+		} else if (((i == 6) && (packet[2] & 0x08)) ||	// flip
+				 ((i == 7) && (packet[2] & 0x01)) ||	// rth
+				 ((i == 8) && (packet[2] & 0x20)) ||	// picture
+				 ((i == 9) && (packet[2] & 0x10))) {	// video
+			// set channel to 100% if feature is enabled
+			val = CHANNEL_MAX_100;
+		}
+		bits |= val << bitsavailable;
+		bitsavailable += 11;
+		while (bitsavailable >= 8) {
+			packet_in[idx++] = bits & 0xff;
+			bits >>= 8;
+			bitsavailable -= 8;
+		}
+	}
+}
+
+void BAYANG_RX_init()
+{
+	uint8_t i;
+	Bayang_Rx_RF_init();
+	hopping_frequency_no = 0;
+	rx_data_started = false;
+	rx_data_received = false;
+	
+	if (IS_BIND_IN_PROGRESS) {
+		phase = BAYANG_RX_BIND;
+	}
+	else {
+		uint16_t temp = BAYANG_RX_EEPROM_OFFSET;
+		for (i = 0; i < 5; i++)
+			rx_tx_addr[i] = eeprom_read_byte((EE_ADDR)temp++);
+		for (i = 0; i < BAYANG_RX_RF_NUM_CHANNELS; i++)
+			hopping_frequency[i] = eeprom_read_byte((EE_ADDR)temp++);
+		//XN297_HoppingCalib(BAYANG_RX_RF_NUM_CHANNELS);
+		XN297_SetTXAddr(rx_tx_addr, BAYANG_RX_ADDRESS_LENGTH);
+		XN297_SetRXAddr(rx_tx_addr, BAYANG_RX_PACKET_SIZE);
+		phase = BAYANG_RX_DATA;
+	}
+}
+
+uint16_t BAYANG_RX_callback()
+{
+	uint8_t i;
+	static int8_t read_retry;
+
+	switch (phase)
+	{
+		case BAYANG_RX_BIND:
+			if(IS_BIND_DONE)
+			{
+				BAYANG_RX_init();	// Abort bind
+				break;
+			}
+			if ( XN297_IsRX() )
+			{
+				debugln("RX");
+				// data received from TX
+				if (XN297_ReadPayload(packet, BAYANG_RX_PACKET_SIZE) && ( packet[0] == 0xA4 || packet[0] == 0xA2 ) && Bayang_Rx_check_validity())
+				{
+					// store tx info into eeprom
+					uint16_t temp = BAYANG_RX_EEPROM_OFFSET;
+					for (i = 0; i < 5; i++) {
+						rx_tx_addr[i] = packet[i + 1];
+						eeprom_write_byte((EE_ADDR)temp++, rx_tx_addr[i]);
+					}
+					for (i = 0; i < 4; i++) {
+						hopping_frequency[i] = packet[i + 6];
+						eeprom_write_byte((EE_ADDR)temp++, hopping_frequency[i]);
+					}
+					//XN297_HoppingCalib(BAYANG_RX_RF_NUM_CHANNELS);
+					XN297_SetTXAddr(rx_tx_addr, BAYANG_RX_ADDRESS_LENGTH);
+					XN297_SetRXAddr(rx_tx_addr, BAYANG_RX_PACKET_SIZE);
+					BIND_DONE;
+					phase = BAYANG_RX_DATA;
+				}
+				XN297_SetTxRxMode(RX_EN);
+			}
+			break;
+		case BAYANG_RX_DATA:
+			if ( XN297_IsRX() ) {
+				if (XN297_ReadPayload(packet, BAYANG_RX_PACKET_SIZE) && packet[0] == 0xA5 && Bayang_Rx_check_validity()) {
+					if ((telemetry_link & 0x7F) == 0) {
+						Bayang_Rx_build_telemetry_packet();
+						telemetry_link = 1;
+						#ifdef SEND_CPPM
+							if(sub_protocol>0)
+								telemetry_link |= 0x80;	// Disable telemetry output
+						#endif
+					}
+					rx_data_started = true;
+					rx_data_received = true;
+					read_retry = 8;
+					pps_counter++;
+				}
+			}
+			// packets per second
+			if (millis() - pps_timer >= 1000) {
+				pps_timer = millis();
+				debugln("%d pps", pps_counter);
+				RX_LQI = pps_counter >> 1;
+				pps_counter = 0;
+			}
+			// frequency hopping
+			if (read_retry++ >= 8) {
+				hopping_frequency_no++;
+				if (hopping_frequency_no >= BAYANG_RX_RF_NUM_CHANNELS)
+					hopping_frequency_no = 0;
+				XN297_Hopping(hopping_frequency_no);
+				XN297_SetTxRxMode(RX_EN);
+				if (rx_data_started)
+				{
+					if(rx_data_received)
+					{ // In sync
+						rx_data_received = false;
+						read_retry = 5;
+						return 1500;
+					}
+					else
+					{ // packet lost
+						read_retry = 0;
+						if(RX_LQI==0)	// communication lost
+							rx_data_started=false;
+					}
+				}
+				else
+					read_retry = -16; // retry longer until first packet is caught
+			}
+			return 250;
+	}
+	return 1000;
+}
+
+#endif

Multiprotocol/Bayang_nrf24l01.ino

@@ -17,14 +17,16 @@ Multiprotocol is distributed in the hope that it will be useful,
 
 #if defined(BAYANG_NRF24L01_INO)
 
-#include "iface_nrf24l01.h"
+#include "iface_xn297.h"
 
 #define BAYANG_BIND_COUNT		1000
-#define BAYANG_PACKET_PERIOD	1000
+#define BAYANG_PACKET_PERIOD	2000
+#define BAYANG_PACKET_TELEM_PERIOD	5000
 #define BAYANG_INITIAL_WAIT		500
 #define BAYANG_PACKET_SIZE		15
 #define BAYANG_RF_NUM_CHANNELS	4
 #define BAYANG_RF_BIND_CHANNEL	0
+#define BAYANG_RF_BIND_CHANNEL_X16_AH 10
 #define BAYANG_ADDRESS_LENGTH	5
 
 enum BAYANG_FLAGS {
@@ -35,201 +37,287 @@ enum BAYANG_FLAGS {
 	BAYANG_FLAG_VIDEO		= 0x10, 
 	BAYANG_FLAG_PICTURE		= 0x20, 
 	// flags going to packet[3]
-    BAYANG_FLAG_INVERTED	= 0x80 // inverted flight on Floureon H101
+	BAYANG_FLAG_INVERTED	= 0x80,			// inverted flight on Floureon H101
+	BAYANG_FLAG_TAKE_OFF	= 0x20,			// take off / landing on X16 AH
+	BAYANG_FLAG_EMG_STOP	= 0x04|0x08,	// 0x08 for VISUO XS809H-W-HD-G
 };
 
-static void __attribute__((unused)) BAYANG_send_packet(uint8_t bind)
+enum BAYANG_OPTION_FLAGS {
+	BAYANG_OPTION_FLAG_TELEMETRY	= 0x01,
+	BAYANG_OPTION_FLAG_ANALOGAUX	= 0x02,
+};
+
+static void __attribute__((unused)) BAYANG_send_packet()
 {
 	uint8_t i;
-	if (bind)
+	if (IS_BIND_IN_PROGRESS)
 	{
 	#ifdef BAYANG_HUB_TELEMETRY
-		if(option)
+		if(option & BAYANG_OPTION_FLAG_TELEMETRY)
+			if(option & BAYANG_OPTION_FLAG_ANALOGAUX)
+				packet[0]= 0xA1;	// telemetry and analog aux are enabled
+			else
 				packet[0]= 0xA3;	// telemetry is enabled
+		else if(option & BAYANG_OPTION_FLAG_ANALOGAUX)
+				packet[0]= 0xA2;	// analog aux is enabled
+			else
+	#else
+		if(option & BAYANG_OPTION_FLAG_ANALOGAUX)
+			packet[0]= 0xA2;		// analog aux is enabled
 		else
 	#endif
 			packet[0]= 0xA4;
+		if(sub_protocol==QX100)
+			packet[0] = 0x53;
+
 		for(i=0;i<5;i++)
 			packet[i+1]=rx_tx_addr[i];
 		for(i=0;i<4;i++)
 			packet[i+6]=hopping_frequency[i];
+		switch (sub_protocol)
+		{
+			case QX100:
+			case X16_AH:
+				packet[10] = 0x00;
+				packet[11] = 0x00;
+				break;
+			case IRDRONE:
+				packet[10] = 0x30;
+				packet[11] = 0x01;
+				break;
+			case DHD_D4:
+				packet[10] = 0xC8;
+				packet[11] = 0x99;
+				break;
+			default:
 				packet[10] = rx_tx_addr[0];	// txid[0]
 				packet[11] = rx_tx_addr[1];	// txid[1]
+				break;
+		}
 	}
 	else
 	{
+		XN297_Hopping(hopping_frequency_no++);
+		hopping_frequency_no%=BAYANG_RF_NUM_CHANNELS;
 		uint16_t val;
+		uint8_t dyntrim = 1;
+		switch (sub_protocol)
+		{
+			case X16_AH:
+			case IRDRONE:
+				packet[0] = 0xA6;
+				break;
+			default:
 				packet[0] = 0xA5;
-		packet[1] = 0xFA;		// normal mode is 0xf7, expert 0xfa
+				break;
+		}
+		if (option & BAYANG_OPTION_FLAG_ANALOGAUX)
+		{
+			// Analog aux channel 1 (channel 14)
+			packet[1] = convert_channel_8b(CH14);
+		}
+		else
+			packet[1] = 0xFA;		// normal mode is 0xF7, expert 0xFa , D4 normal is 0xF4
 
 		//Flags packet[2]
 		packet[2] = 0x00;
-		if(Servo_AUX1)
+		if(CH5_SW)
 			packet[2] = BAYANG_FLAG_FLIP;
-		if(Servo_AUX2)
+		if(CH6_SW)
 			packet[2] |= BAYANG_FLAG_RTH;
-		if(Servo_AUX3)
+		if(CH7_SW)
 			packet[2] |= BAYANG_FLAG_PICTURE;
-		if(Servo_AUX4)
+		if(CH8_SW)
 			packet[2] |= BAYANG_FLAG_VIDEO;
-		if(Servo_AUX5)
+		if(CH9_SW)
+		{
 			packet[2] |= BAYANG_FLAG_HEADLESS;
+			dyntrim = 0;
+		}
 		//Flags packet[3]
 		packet[3] = 0x00;
-		if(Servo_AUX6)
+		if(CH10_SW)
 			packet[3] = BAYANG_FLAG_INVERTED;
-
+		if(CH11_SW)
+			dyntrim = 0;
+		if(CH12_SW)
+		  packet[3] |= BAYANG_FLAG_TAKE_OFF;
+		if(CH13_SW)
+			packet[3] |= BAYANG_FLAG_EMG_STOP;
 		//Aileron
-		val = convert_channel_10b(AILERON);
-		packet[4] = (val>>8) + ((val>>2) & 0xFC);
+		val = convert_channel_10b(AILERON, false);
+		packet[4] = (val>>8) + (dyntrim ? ((val>>2) & 0xFC) : 0x7C);
 		packet[5] = val & 0xFF;
 		//Elevator
-		val = convert_channel_10b(ELEVATOR);
-		packet[6] = (val>>8) + ((val>>2) & 0xFC);
+		val = convert_channel_10b(ELEVATOR, false);
+		packet[6] = (val>>8) + (dyntrim ? ((val>>2) & 0xFC) : 0x7C);
 		packet[7] = val & 0xFF;
 		//Throttle
-		val = convert_channel_10b(THROTTLE);
+		val = convert_channel_10b(THROTTLE, false);
 		packet[8] = (val>>8) + 0x7C;
 		packet[9] = val & 0xFF;
 		//Rudder
-		val = convert_channel_10b(RUDDER);
-		packet[10] = (val>>8) + (val>>2 & 0xFC);
+		val = convert_channel_10b(RUDDER, false);
+		packet[10] = (val>>8) + (dyntrim ? ((val>>2) & 0xFC) : 0x7C);
 		packet[11] = val & 0xFF;
 	}
+	switch (sub_protocol)
+	{
+		case H8S3D:
 			packet[12] = rx_tx_addr[2];	// txid[2]
-	packet[13] = sub_protocol==H8S3D?0x34:0x0A;
+			packet[13] = 0x34;
+			break;
+		case QX100:
+		case X16_AH:
+			packet[12] = 0;
+			packet[13] = 0;
+			break;
+		case IRDRONE:
+			packet[12] = 0xE0;
+			packet[13] = 0x2E;
+			break;
+		case DHD_D4:
+			packet[12] = 0x37;	//0x17 during bind
+			packet[13] = 0xED;
+			break;
+		default:
+			packet[12] = rx_tx_addr[2];	// txid[2]
+			if (option & BAYANG_OPTION_FLAG_ANALOGAUX)
+			{	// Analog aux channel 2 (channel 15)
+				packet[13] = convert_channel_8b(CH15);
+			}
+			else
+				packet[13] = 0x0A;
+			break;
+	}
 	packet[14] = 0;
 	for (uint8_t i=0; i < BAYANG_PACKET_SIZE-1; i++)
 		packet[14] += packet[i];
 
-	NRF24L01_WriteReg(NRF24L01_05_RF_CH, bind ? BAYANG_RF_BIND_CHANNEL:hopping_frequency[hopping_frequency_no++]);
-	hopping_frequency_no%=BAYANG_RF_NUM_CHANNELS;
-
-	// clear packet status bits and TX FIFO
-	NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);
-	NRF24L01_FlushTx();
-
+	// Send
+	XN297_SetPower();
+	XN297_SetTxRxMode(TX_EN);
 	XN297_WritePayload(packet, BAYANG_PACKET_SIZE);
-
-    NRF24L01_SetTxRxMode(TXRX_OFF);
-    NRF24L01_SetTxRxMode(TX_EN);
-
-	// Power on, TX mode, 2byte CRC
-	// Why CRC0? xn297 does not interpret it - either 16-bit CRC or nothing
-	XN297_Configure(_BV(NRF24L01_00_EN_CRC) | _BV(NRF24L01_00_CRCO) | _BV(NRF24L01_00_PWR_UP));
-
-	#ifdef BAYANG_HUB_TELEMETRY
-    if (option)
-	{	// switch radio to rx as soon as packet is sent
-        
-		while (!(NRF24L01_ReadReg(NRF24L01_07_STATUS) & _BV(NRF24L01_07_TX_DS)));
-		NRF24L01_WriteReg(NRF24L01_00_CONFIG, 0x03);
-    }
-	#endif
-
-	NRF24L01_SetPower();	// Set tx_power
 }
 
 #ifdef BAYANG_HUB_TELEMETRY
-static void __attribute__((unused)) check_rx(void)
+static void __attribute__((unused)) BAYANG_check_rx(void)
 {
-	if (NRF24L01_ReadReg(NRF24L01_07_STATUS) & _BV(NRF24L01_07_RX_DR))
+	if( XN297_IsRX() )
 	{ // data received from model
-		XN297_ReadPayload(packet, BAYANG_PACKET_SIZE);
-		NRF24L01_WriteReg(NRF24L01_07_STATUS, 255);
-
-		NRF24L01_FlushRx();
+		XN297_ReadPayload(packet, BAYANG_PACKET_SIZE);	// Strange can't test the CRC since it seems to be disabled on telemetry packets...
 		uint8_t check = packet[0];
 		for (uint8_t i=1; i < BAYANG_PACKET_SIZE-1; i++)
 			check += packet[i];
 		// decode data , check sum is ok as well, since there is no crc
-		if (packet[0] == 0x85 && packet[14] == check)
+		if (packet[0] == 0x85 && packet[14] == check && telemetry_link == 0)
 		{
 			// uncompensated battery volts*100/2
-			v_lipo1 = (packet[3]<<7) + (packet[4]>>2);
+			v_lipo1 = (packet[3]<<7) + (packet[4]>>1);
 			// compensated battery volts*100/2
-			v_lipo2 = (packet[5]<<7) + (packet[6]>>2);
+			v_lipo2 = (packet[5]<<7) + (packet[6]>>1);
 			// reception in packets / sec
-			RSSI_dBm = packet[7];
+			RX_LQI = packet[7];
+			RX_RSSI = RX_LQI;
 			//Flags
 			//uint8_t flags = packet[3] >> 3;
 			// battery low: flags & 1
-			telemetry_counter++;
-			if(telemetry_lost==0)
 			telemetry_link=1;
+			#if defined HUB_TELEMETRY
+				// Multiplexed P, I, D values in packet[8] and packet[9].
+				// The two most significant bits specify which term is sent.
+				// Remaining 14 bits represent the value: 0 .. 16383
+				frsky_send_user_frame(0x24+(packet[8]>>6), packet[9], packet[8] & 0x3F );	//0x24 = ACCEL_X_ID, so ACCEL_X_ID=P, ACCEL_Y_ID=I, ACCEL_Z_ID=D
+			#endif
+			telemetry_counter++;
+			if(telemetry_lost)
+				telemetry_link=0;	// Don't send anything yet
 		}
 	}
+	XN297_SetTxRxMode(TXRX_OFF);
 }
 #endif
 
-static void __attribute__((unused)) BAYANG_init()
+static void __attribute__((unused)) BAYANG_RF_init()
 {
-	NRF24L01_Initialize();
-	NRF24L01_SetTxRxMode(TX_EN);
-
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
 	XN297_SetTXAddr((uint8_t *)"\x00\x00\x00\x00\x00", BAYANG_ADDRESS_LENGTH);
+	//XN297_HoppingCalib(BAYANG_RF_NUM_CHANNELS);
 	
-	NRF24L01_FlushTx();
-	NRF24L01_FlushRx();
-    NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);     // Clear data ready, data sent, and retransmit
-	NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);      // No Auto Acknowldgement on all data pipes
-    NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x01);  // Enable data pipe 0 only
-    NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, BAYANG_PACKET_SIZE);
-    NRF24L01_SetBitrate(NRF24L01_BR_1M);             // 1Mbps
-    NRF24L01_SetPower();
-    NRF24L01_Activate(0x73);    // Activate feature register
-    NRF24L01_WriteReg(NRF24L01_1C_DYNPD, 0x00); // Disable dynamic payload length on all pipes
-    NRF24L01_WriteReg(NRF24L01_1D_FEATURE, 0x01);
-    NRF24L01_Activate(0x73);
+	//Set bind channel
+	uint8_t ch = BAYANG_RF_BIND_CHANNEL;
+	if(sub_protocol == X16_AH || sub_protocol == IRDRONE)
+		ch = BAYANG_RF_BIND_CHANNEL_X16_AH;
+	XN297_RFChannel(ch);
 }
 
+enum {
+	BAYANG_BIND=0,
+	BAYANG_WRITE,
+	BAYANG_CHECK,
+	BAYANG_READ,
+};
+
+#define BAYANG_CHECK_DELAY		1000		// Time after write phase to check write complete
+#define BAYANG_READ_DELAY		600			// Time before read phase
+
 uint16_t BAYANG_callback()
 {
-	if(IS_BIND_DONE_on)
-	{
-		if(packet_count==0)
-			BAYANG_send_packet(0);
-		packet_count++;
 	#ifdef BAYANG_HUB_TELEMETRY
-			if (option)
-			{	// telemetry is enabled 
-				state++;
-				if (state > 1000)
-				{
-					//calculate telemetry reception packet rate - packets per 1000ms
-					TX_RSSI = telemetry_counter;
-					telemetry_counter = 0;
-					state = 0;
-					telemetry_lost=0;
-				}
-
-				if (packet_count > 1)
-					check_rx();
-
-				packet_count %= 5;
-			}
-			else
+		uint16_t start;
 	#endif
-				packet_count%=2;
-	}
-	else
+	switch(phase)
 	{
-		if (bind_counter == 0)
+		case BAYANG_BIND:
+			if (--bind_counter == 0)
 			{
 				XN297_SetTXAddr(rx_tx_addr, BAYANG_ADDRESS_LENGTH);
 				#ifdef BAYANG_HUB_TELEMETRY
-				XN297_SetRXAddr(rx_tx_addr, BAYANG_ADDRESS_LENGTH);
+					XN297_SetRXAddr(rx_tx_addr, BAYANG_PACKET_SIZE);
 				#endif
 				BIND_DONE;
+				phase++;	//WRITE
 			}
 			else
+				BAYANG_send_packet();
+			break;
+		case BAYANG_WRITE:
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync((option & BAYANG_OPTION_FLAG_TELEMETRY)?BAYANG_PACKET_TELEM_PERIOD:BAYANG_PACKET_PERIOD);
+			#endif
+			BAYANG_send_packet();
+			#ifdef BAYANG_HUB_TELEMETRY
+				if (option & BAYANG_OPTION_FLAG_TELEMETRY)
+				{	// telemetry is enabled
+					state++;
+					if (state > 200)
 					{
-			if(packet_count==0)
-				BAYANG_send_packet(1);
-			packet_count++;
-			packet_count%=4;
-			bind_counter--;
+						state = 0;
+						//telemetry reception packet rate - packets per second
+						TX_LQI = telemetry_counter>>1;
+						telemetry_counter = 0;
+						telemetry_lost=0;
 					}
+					phase++;	//CHECK
+					return BAYANG_CHECK_DELAY;
+				}
+			#endif
+			break;
+	#ifdef BAYANG_HUB_TELEMETRY
+		case BAYANG_CHECK:
+			// switch radio to rx as soon as packet is sent
+			start=(uint16_t)micros();
+			while ((uint16_t)((uint16_t)micros()-(uint16_t)start) < 1000)			// Wait max 1ms
+				if(XN297_IsPacketSent())
+					break;
+			XN297_SetTxRxMode(RX_EN);
+			phase++;	// READ
+			return BAYANG_PACKET_TELEM_PERIOD - BAYANG_CHECK_DELAY - BAYANG_READ_DELAY;
+		case BAYANG_READ:
+			BAYANG_check_rx();
+			phase=BAYANG_WRITE;
+			return BAYANG_READ_DELAY;
+	#endif
 	}
 	return BAYANG_PACKET_PERIOD;
 }
@@ -237,25 +325,24 @@ uint16_t BAYANG_callback()
 static void __attribute__((unused)) BAYANG_initialize_txid()
 {
 	//Could be using txid[0..2] but using rx_tx_addr everywhere instead...
+	if(sub_protocol==DHD_D4)
+		hopping_frequency[0]=(rx_tx_addr[2]&0x07)|0x01;
+	else
 		hopping_frequency[0]=0;
-	hopping_frequency[1]=(rx_tx_addr[0]&0x1F)+0x10;
+	hopping_frequency[1]=(rx_tx_addr[3]&0x1F)+0x10;
 	hopping_frequency[2]=hopping_frequency[1]+0x20;
 	hopping_frequency[3]=hopping_frequency[2]+0x20;
 	hopping_frequency_no=0;
 }
 
-uint16_t initBAYANG(void)
+void BAYANG_init(void)
 {
 	BIND_IN_PROGRESS;	// autobind protocol
+	phase=BAYANG_BIND;
     bind_counter = BAYANG_BIND_COUNT;
 	BAYANG_initialize_txid();
-	BAYANG_init();
+	BAYANG_RF_init();
 	packet_count=0;
-#ifdef BAYANG_HUB_TELEMETRY
-	init_hub_telemetry();
-	telemetry_lost=1;	// do not send telemetry to TX right away until we have a TX_RSSI value to prevent warning message...
-#endif
-	return BAYANG_INITIAL_WAIT+BAYANG_PACKET_PERIOD;
 }
 
 #endif

Multiprotocol/Binary_Signature.ino

@@ -0,0 +1,202 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/************************/
+/** Firmware Signature **/
+/************************/
+
+/*
+The firmware signature is appended to the compiled binary image in order to provide information
+about the options used to compile the firmware file.  This information is then used by Multi-module 
+flashing tools to verify that the image is correct / valid.
+
+In order for the build process to determine the options used to build the firmware this file conditionally
+declares 'flag' variables for the options we are interested in.
+
+When the pre-compiler parses the source code these variables are either present or not in the parsed cpp file,
+typically '$build_dir$/preproc/ctags_target_for_gcc_minus_e.cpp'.
+
+Once the .bin file is created an additional command-line build tool scans the parsed cpp file, detects the
+flags, assembles the signature, and finally appends the signature to the end of the binary file.
+
+The signature is 24 bytes long:
+multi-x[8-byte hex code]-[8-byte version number]
+
+For example:
+multi-x1234abcd-01020199
+
+The 8-byte hex code is a 32-bit bitmask value indicating the configuration options, currently:
+
+Bit(s)  Bitmask    Option                  Comment
+1-2     0x3        Module type             Read as a two-bit value indicating a number from 0-3 which maps to a module type (AVR, STM32, OrangeRX)
+3-7     0x7C       Channel order           Read as a five-bit value indicating a number from 0-23 which maps to as channel order (AETR, TAER, RETA, etc) (right-shift two bits to read)
+8       0x80       Bootloader support      Indicates whether or not the firmware was built with support for the bootloader
+9       0x100      CHECK_FOR_BOOTLOADER    Indicates if CHECK_FOR_BOOTLOADER is defined
+10      0x200      INVERT_TELEMETRY        Indicates if INVERT_TELEMETRY is defined
+11      0x400      MULTI_STATUS            Indicates if MULTI_STATUS is defined
+12      0x800      MULTI_TELEMETRY         Indicates if MULTI_TELEMETRY is defined
+13      0x1000     DEBUG_SERIAL            Indicates if DEBUG_SERIAL is defined
+14-16   0xE000     Module sub-type         Reads as a three-bit value indicating a number from 0-7 which maps to a module sub-type (right-shift 13 bits to read)
+
+The 8-byte version number is the version number zero-padded to a fixed width of two-bytes per segment and no separator.  
+E.g. 1.2.3.45 becomes 01020345.
+
+Multi Telemetery Type can be read from bits 11 and 12 using the bitmask 0xC00 and right-shifting ten bits:
+Telemetry Type    Decimal Value   Binary Value
+Undefined         0               00
+erSkyTX           1               01
+OpenTX            2               10
+
+Module types are mapped to the following decimal / binary values:
+Module Type       Decimal Value   Binary Valsue
+AVR (Atmega328p)  0               00
+STM32 (F103)      1               01
+OrangeRX (Xmega)  2               10
+
+Module sub-type is currently used for STM32F103 only and is mapped as follows:
+Module Type       Sub Type        Decimal Value    Binary Value
+STM32 (F103)      STM32F103CB     0                000
+STM32 (F103)      STM32F103C8     1                001
+STM32 (F103)      T18 5in1        2                010
+
+Channel orders are mapped to the following decimal / binary values:
+Channel Order	  Decimal Value	  Binary Value
+AETR	          0	              00000
+AERT	          1	              00001
+ARET	          2	              00010
+ARTE	          3	              00011
+ATRE	          4	              00100
+ATER	          5	              00101
+EATR	          6	              00110
+EART	          7	              00111
+ERAT	          8	              01000
+ERTA	          9	              01001
+ETRA	          10	          01010
+ETAR	          11	          01011
+TEAR	          12	          01100
+TERA	          13	          01101
+TREA	          14	          01110
+TRAE	          15	          01111
+TARE	          16	          10000
+TAER	          17	          10001
+RETA	          18	          10010
+REAT	          19	          10011
+RAET	          20	          10100
+RATE	          21	          10101
+RTAE	          22	          10110
+RTEA	          23	          10111
+*/
+ 
+// Set the flags for detecting and writing the firmware signature
+#if defined (CHECK_FOR_BOOTLOADER)
+    bool firmwareFlag_CHECK_FOR_BOOTLOADER = true;
+#endif
+#if defined (INVERT_TELEMETRY)
+    bool firmwareFlag_INVERT_TELEMETRY = true;
+#endif
+#if defined (MULTI_STATUS)
+    bool firmwareFlag_MULTI_STATUS = true;
+#endif
+#if defined (MULTI_TELEMETRY)
+    bool firmwareFlag_MULTI_TELEMETRY = true;
+#endif
+#if defined (DEBUG_SERIAL)
+    bool firmwareFlag_DEBUG_SERIAL = true;
+#endif
+
+// STM32 Module sub-type flags
+#if defined (MCU_STM32F103CB)
+    bool firmwareFlag_MCU_STM32F103CB = true;
+#endif
+#if defined (MCU_STM32F103C8)
+    bool firmwareFlag_MCU_STM32F103C8 = true;
+#endif
+#if defined (MULTI_5IN1_INTERNAL)
+    bool firmwareFlag_MULTI_5IN1_INTERNAL = true;
+#endif
+
+// Channel order flags
+#if defined (AETR)
+    bool firmwareFlag_ChannelOrder_AETR = true;
+#endif
+#if defined (AERT)
+    bool firmwareFlag_ChannelOrder_AERT = true;
+#endif
+#if defined (ARET)
+    bool firmwareFlag_ChannelOrder_ARET = true;
+#endif
+#if defined (ARTE)
+    bool firmwareFlag_ChannelOrder_ARTE = true;
+#endif
+#if defined (ATRE)
+    bool firmwareFlag_ChannelOrder_ATRE = true;
+#endif
+#if defined (ATER)
+    bool firmwareFlag_ChannelOrder_ATER = true;
+#endif
+#if defined (EATR)
+    bool firmwareFlag_ChannelOrder_EATR = true;
+#endif
+#if defined (EART)
+    bool firmwareFlag_ChannelOrder_EART = true;
+#endif
+#if defined (ERAT)
+    bool firmwareFlag_ChannelOrder_ERAT = true;
+#endif
+#if defined (ERTA)
+    bool firmwareFlag_ChannelOrder_ERTA = true;
+#endif
+#if defined (ETRA)
+    bool firmwareFlag_ChannelOrder_ETRA = true;
+#endif
+#if defined (ETAR)
+    bool firmwareFlag_ChannelOrder_ETAR = true;
+#endif
+#if defined (TEAR)
+    bool firmwareFlag_ChannelOrder_TEAR = true;
+#endif
+#if defined (TERA)
+    bool firmwareFlag_ChannelOrder_TERA = true;
+#endif
+#if defined (TREA)
+    bool firmwareFlag_ChannelOrder_TREA = true;
+#endif
+#if defined (TRAE)
+    bool firmwareFlag_ChannelOrder_TRAE = true;
+#endif
+#if defined (TARE)
+    bool firmwareFlag_ChannelOrder_TARE = true;
+#endif
+#if defined (TAER)
+    bool firmwareFlag_ChannelOrder_TAER = true;
+#endif
+#if defined (RETA)
+    bool firmwareFlag_ChannelOrder_RETA = true;
+#endif
+#if defined (REAT)
+    bool firmwareFlag_ChannelOrder_REAT = true;
+#endif
+#if defined (RAET)
+    bool firmwareFlag_ChannelOrder_RAET = true;
+#endif
+#if defined (RATE)
+    bool firmwareFlag_ChannelOrder_RATE = true;
+#endif
+#if defined (RTAE)
+    bool firmwareFlag_ChannelOrder_RTAE = true;
+#endif
+#if defined (RTEA)
+    bool firmwareFlag_ChannelOrder_RTEA = true;
+#endif

Multiprotocol/Bugs_a7105.ino

@@ -0,0 +1,464 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+ 
+#ifdef BUGS_A7105_INO
+
+//////////// rxid -> radioid algorithm //////////////////////////////
+// Hex digit 1 is periodic with length 2, and hex digit 2 is periodic
+// with length 16. However, storing the byte of those 2 digits
+// instead of manipulating bits results simpler code and smaller binary.
+const uint8_t PROGMEM BUGS_most_popular_67_cycle[]= {
+	0x34, 0xc5, 0x6a, 0xb4, 0x29, 0xd5, 0x2c, 0xd3, 0x91, 0xb3, 0x6c, 0x49,
+	0x52, 0x9c, 0x4d, 0x65, 0xc3, 0x4a, 0x5b, 0xd6, 0x92, 0x6d, 0x94, 0xa6,
+	0x55, 0xcd, 0x2b, 0x9a, 0x36, 0x95, 0x4b, 0xd4, 0x35, 0x8d, 0x96, 0xb2,
+	0xa3 };
+
+static uint8_t __attribute__((unused)) BUGS_most_popular_67(uint8_t i)
+{
+	uint8_t ii;
+	if (i == 0)
+		return 0xd2;
+	else if (i == 1)
+		return 0xda;
+	else if (i % 16 < 2)
+	{
+		ii = 2 * (i / 16) + i % 16 - 2;
+		if (ii % 2 == 0)
+			ii += 7;
+	}
+	else
+		ii=2 * (i / 16) + (i % 16 - 2) % 7;
+	return pgm_read_byte_near( &BUGS_most_popular_67_cycle[ii]);
+}
+
+static uint8_t __attribute__((unused)) BUGS_most_popular_45(uint8_t i)
+{
+	if (i == 0)
+		return 0xa3;
+	else if (i == 1)
+		return 0x86;
+	else
+	{
+		if (i % 8 == 1)
+			i -= 8;
+		else
+			i--;
+		return BUGS_most_popular_67(i);
+	}
+}
+
+static uint8_t __attribute__((unused)) BUGS_most_popular_23(uint8_t i)
+{
+	if (i == 0)
+		return 0xb2;
+	else if (i == 1)
+		return 0xcb;
+	else
+	{
+		if (i % 8 == 1)
+			i -= 8;
+		else
+			i--;
+		return BUGS_most_popular_45(i);
+	}
+}
+
+const uint8_t PROGMEM BUGS_most_popular_01[] = {
+	0x52, 0xac, 0x59, 0xa4, 0x53, 0xab, 0x57, 0xa9,
+    0x56, 0xa5, 0x5b, 0xa7, 0x5d, 0xa6, 0x58, 0xad};
+
+static uint32_t __attribute__((unused)) BUGS_most_popular(uint8_t i)
+{
+	i += !(i <= 127);
+	uint8_t mp01=pgm_read_byte_near( &BUGS_most_popular_01[i % 16] );
+	return (uint32_t) mp01 << 24 |
+		(uint32_t) BUGS_most_popular_23(i) << 16 |
+		(uint32_t) BUGS_most_popular_45(i) << 8 |
+		BUGS_most_popular_67(i);
+}
+
+static uint32_t __attribute__((unused)) BUGS_second_most_popular(uint8_t i)
+{
+	if (i < 127)
+		return BUGS_most_popular(i + 1);
+	else if (i > 128)
+		return BUGS_most_popular(i - 1);
+	else
+		return 0x52d6926d;
+}
+
+// The 22 irregular values do not match the above periodicities. They might be
+// errors from the readout, but let us try them here as long as it is not
+// proven.
+#define BUGS_NBR_IRREGULAR 22
+const uint16_t PROGMEM BUGS_irregular_keys[BUGS_NBR_IRREGULAR] = {
+	1131, 1287, 2842, 4668, 5311, 11594, 13122, 13813,
+	20655, 22975, 25007, 25068, 28252, 33309, 35364, 35765,
+	37731, 40296, 43668, 46540, 49868, 65535 };
+
+const uint32_t PROGMEM BUGS_irregular_values[BUGS_NBR_IRREGULAR] = {
+	0x52d6926d, 0xa586da34, 0x5329d52c, 0xa66c4952,
+	0x536c4952, 0x524a5bd6, 0x534d65c3, 0xa9d391b3,
+	0x5249529c, 0xa555cd2b, 0xac9a3695, 0x58d391b3,
+	0xa791b36c, 0x53926d94, 0xa7926d94, 0xa72cd391,
+	0xa9b429d5, 0x5629d52c, 0xad2b9a36, 0xa74d65c3,
+	0x526d94a6, 0xad96b2a3 };
+
+static uint32_t __attribute__((unused)) BUGS_is_irregular(uint16_t i)
+{
+	for (uint8_t j = 0; j < BUGS_NBR_IRREGULAR; ++j)
+		if (pgm_read_word_near( &BUGS_irregular_keys[j]) == i)
+			return pgm_read_dword_near( &BUGS_irregular_values[j]);
+	return 0;
+}
+
+static uint32_t __attribute__((unused)) BUGS_rxid_to_radioid(uint16_t rxid)
+{
+	uint8_t block = rxid / 256;
+	uint8_t second_seq_size;
+	bool use_most_popular;
+
+	if (rxid < 32768)
+	{
+		second_seq_size = 128 - block;
+		use_most_popular = rxid % 256 >= second_seq_size;
+	}
+	else
+	{
+		second_seq_size = block - 127;
+		use_most_popular = 255 - rxid % 256 >= second_seq_size;
+	}
+	uint32_t v = BUGS_is_irregular(rxid);
+	if (!v)
+	{
+		if (use_most_popular)
+			v = BUGS_most_popular(rxid % 255);
+		else
+			v = BUGS_second_most_popular(rxid % 255);
+	}
+	return v;
+}
+//////////// rxid -> radioid algorithm //////////////////////////////
+
+// For code readability
+#define BUGS_CH_SW_ARM		CH5_SW
+#define BUGS_CH_SW_ANGLE	CH6_SW
+#define BUGS_CH_SW_FLIP		CH7_SW
+#define BUGS_CH_SW_PICTURE	CH8_SW
+#define BUGS_CH_SW_VIDEO	CH9_SW
+#define BUGS_CH_SW_LED		CH10_SW
+
+// flags packet byte 4
+#define BUGS_FLAG_FLIP		0x08    // automatic flip
+#define BUGS_FLAG_MODE		0x04    // low/high speed select (set is high speed)
+#define BUGS_FLAG_VIDEO		0x02    // toggle video
+#define BUGS_FLAG_PICTURE	0x01    // toggle picture
+
+// flags packet byte 5
+#define BUGS_FLAG_LED		0x80    // enable LEDs
+#define BUGS_FLAG_ARM		0x40    // arm (toggle to turn on motors)
+#define BUGS_FLAG_DISARM	0x20    // disarm (toggle to turn off motors)
+#define BUGS_FLAG_ANGLE		0x04    // angle/acro mode (set is angle mode)
+
+#define BUGS_PACKET_SIZE	22
+#define BUGS_NUM_RFCHAN		16
+
+enum {
+	BUGS_BIND_1,
+	BUGS_BIND_2,
+	BUGS_BIND_3,
+	BUGS_DATA_1,
+	BUGS_DATA_2,
+	BUGS_DATA_3,
+};
+
+static void __attribute__((unused)) BUGS_check_arming()
+{
+	uint8_t arm_channel = BUGS_CH_SW_ARM;
+
+	if (arm_channel != arm_channel_previous)
+	{
+		arm_channel_previous = arm_channel;
+		if (arm_channel)
+		{
+			armed = 1;
+			arm_flags ^= BUGS_FLAG_ARM;
+		}
+		else
+		{
+			armed = 0;
+			arm_flags ^= BUGS_FLAG_DISARM;
+		}
+	}
+}
+
+static void __attribute__((unused)) BUGS_build_packet(uint8_t bind)
+{
+	uint8_t force_values = bind | !armed;
+	uint8_t change_channel = ((packet_count & 0x1) << 6);
+	uint16_t aileron  = convert_channel_16b_limit(AILERON,800,0);
+	uint16_t elevator = convert_channel_16b_limit(ELEVATOR,800,0);
+	uint16_t throttle = convert_channel_16b_limit(THROTTLE,0,800);
+	uint16_t rudder   = convert_channel_16b_limit(RUDDER,800,0);
+
+	memset(packet, 0, BUGS_PACKET_SIZE);
+	packet[1] = 0x76;		// txid (rx uses to know hopping frequencies)
+	packet[2] = 0x71;
+	packet[3] = 0x94;
+
+	BUGS_check_arming();	// sets globals arm_flags and armed
+	if(bind)
+	{
+		packet[4] = change_channel | 0x80;
+		packet[5] = 0x02 | arm_flags
+		| GET_FLAG(BUGS_CH_SW_ANGLE, BUGS_FLAG_ANGLE);
+	}
+	else
+	{
+		packet[4] = change_channel | BUGS_FLAG_MODE
+		| GET_FLAG(BUGS_CH_SW_FLIP, BUGS_FLAG_FLIP)
+		| GET_FLAG(BUGS_CH_SW_PICTURE, BUGS_FLAG_PICTURE)
+		| GET_FLAG(BUGS_CH_SW_VIDEO, BUGS_FLAG_VIDEO);
+		packet[5] = 0x02 | arm_flags
+		| GET_FLAG(BUGS_CH_SW_ANGLE, BUGS_FLAG_ANGLE)
+		| GET_FLAG(BUGS_CH_SW_LED, BUGS_FLAG_LED);
+	}
+
+	packet[6] = force_values ? 100 : (aileron  >> 2);
+	packet[7] = force_values ? 100 : (elevator >> 2);
+	packet[8] = force_values ?   0 : (throttle >> 2);
+	packet[9] = force_values ? 100 : (rudder   >> 2);
+	packet[10] = 100;
+	packet[11] = 100;
+	packet[12] = 100;
+	packet[13] = 100;
+
+	packet[14] = ((aileron  << 6) & 0xc0)
+	| ((elevator << 4) & 0x30)
+	| ((throttle << 2) & 0x0c)
+	| ((rudder       ) & 0x03);
+
+	//    packet[15] = 0;
+
+	// driven trims
+	packet[16] = aileron / 8 + 14;
+	packet[17] = elevator / 8 + 14;
+	packet[18] = 64;
+	packet[19] = rudder / 8 + 14;
+
+	//    packet[20] = 0;
+	//    packet[21] = 0;
+
+    uint8_t check = 0x6d;
+    for (uint8_t i=1; i < BUGS_PACKET_SIZE; i++)
+        check ^= packet[i];
+	packet[0] = check;
+}
+
+const uint8_t PROGMEM BUGS_hop []= {
+		0x1d, 0x3b, 0x4d, 0x29, 0x11, 0x2d, 0x0b, 0x3d, 0x59, 0x48, 0x17, 0x41, 0x23, 0x4e, 0x2a, 0x63,	// bind phase ID=0xac59a453
+		0x4b, 0x19, 0x35, 0x1e, 0x63, 0x0f, 0x45, 0x21, 0x51, 0x3a, 0x5d, 0x25, 0x0a, 0x44, 0x61, 0x27,	// data phase ID=0xA4C56AB4 for txid 767194 if rx responds C6 BB 57 7F 00 00 00 00 00 00 FF 87 40 00 00 00
+	};
+
+static void  __attribute__((unused))BUGS_set_radio_data()
+{	// captured radio data for bugs rx/tx version A2
+	// it appears that the hopping frequencies are determined by the txid
+	// and the data phase radio id is determined by the first 2 bytes of the
+	// rx bind packet
+	uint8_t offset=0;
+	uint32_t radio_id=0xac59a453;	// bind phase ID=0xac59a453
+
+	if(IS_BIND_DONE)
+	{
+		offset=BUGS_NUM_RFCHAN;
+		// Read radio_id from EEPROM
+		uint8_t base_adr=BUGS_EEPROM_OFFSET+(RX_num&0x0F)*2;
+		uint16_t rxid=0;
+		for(uint8_t i=0; i<2; i++)
+			rxid|=eeprom_read_byte((EE_ADDR)(base_adr+i))<<(i*8);
+		radio_id = BUGS_rxid_to_radioid(rxid);
+	}
+	A7105_WriteID(radio_id);
+
+	for(uint8_t i=0; i<BUGS_NUM_RFCHAN;i++)
+		hopping_frequency[i]=pgm_read_byte_near( &BUGS_hop[i+offset] );
+}
+
+static void __attribute__((unused)) BUGS_increment_counts()
+{	// this logic works with the use of packet_count in BUGS_build_packet
+	// to properly indicate channel changes to rx
+	packet_count += 1;
+	if ((packet_count & 1) == 0)
+	{
+		hopping_frequency_no += 1;
+		hopping_frequency_no %= BUGS_NUM_RFCHAN;
+	}
+}
+
+#define BUGS_PACKET_PERIOD   6100
+#define BUGS_DELAY_TX        2000
+#define BUGS_DELAY_POST_RX   1500
+#define BUGS_DELAY_BIND_RST   200
+
+// FIFO config is one less than desired value
+#define BUGS_FIFO_SIZE_RX      15
+#define BUGS_FIFO_SIZE_TX      21
+uint16_t BUGS_callback(void)
+{
+	uint8_t mode, base_adr;
+	uint16_t rxid;
+	uint16_t start;
+
+	// keep frequency tuning updated
+	#ifndef FORCE_FLYSKY_TUNING
+		A7105_AdjustLOBaseFreq(1);
+	#endif
+
+	switch(phase)
+	{
+		case BUGS_BIND_1:
+			BUGS_build_packet(1);
+			A7105_Strobe(A7105_STANDBY);
+			A7105_WriteReg(A7105_03_FIFOI, BUGS_FIFO_SIZE_TX);
+			A7105_WriteData(BUGS_PACKET_SIZE, hopping_frequency[hopping_frequency_no]);
+			phase = BUGS_BIND_2;
+			packet_period = BUGS_DELAY_TX;
+			break;
+
+		case BUGS_BIND_2:
+			//Wait for TX completion
+			start=micros();
+			while ((uint16_t)((uint16_t)micros()-start) < 500)			// Wait max 500µs, using serial+telemetry exit in about 60µs
+				if(!(A7105_ReadReg(A7105_00_MODE) & 0x01))
+					break;
+			A7105_SetTxRxMode(RX_EN);
+			A7105_WriteReg(A7105_0F_PLL_I, hopping_frequency[hopping_frequency_no] - 2);
+			A7105_WriteReg(A7105_03_FIFOI, BUGS_FIFO_SIZE_RX);
+			A7105_Strobe(A7105_RX);
+
+			BUGS_increment_counts();
+			phase = BUGS_BIND_3;
+			packet_period = BUGS_PACKET_PERIOD-BUGS_DELAY_TX-BUGS_DELAY_POST_RX;
+			break;
+
+		case BUGS_BIND_3:
+			mode = A7105_ReadReg(A7105_00_MODE);
+			A7105_Strobe(A7105_STANDBY);
+			A7105_SetTxRxMode(TX_EN);
+			if (mode & 0x01)
+			{
+				phase = BUGS_BIND_1;
+				packet_period = BUGS_DELAY_BIND_RST;         // No received data so restart binding procedure.
+				break;
+			}
+			A7105_ReadData(16);
+			if ((packet[0] + packet[1] + packet[2] + packet[3]) == 0)
+			{
+				phase = BUGS_BIND_1;
+				packet_period = BUGS_DELAY_BIND_RST;         // No received data so restart binding procedure.
+				break;
+			}
+			A7105_Strobe(A7105_STANDBY);
+			BIND_DONE;
+			// set radio_id
+			rxid = (packet[1] << 8) + packet[2];
+			base_adr=BUGS_EEPROM_OFFSET+(RX_num&0x0F)*2;
+			for(uint8_t i=0; i<2; i++)
+				eeprom_write_byte((EE_ADDR)(base_adr+i),rxid>>(i*8));	// Save rxid in EEPROM
+			BUGS_set_radio_data();
+			phase = BUGS_DATA_1;
+			packet_count = 0;
+			hopping_frequency_no = 0;
+			packet_period = BUGS_DELAY_POST_RX;
+			break;
+
+		case BUGS_DATA_1:
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(BUGS_PACKET_PERIOD);
+			#endif
+			A7105_SetPower();
+			BUGS_build_packet(0);
+			A7105_WriteReg(A7105_03_FIFOI, BUGS_FIFO_SIZE_TX);
+			A7105_WriteData(BUGS_PACKET_SIZE, hopping_frequency[hopping_frequency_no]);
+			phase = BUGS_DATA_2;
+			packet_period = BUGS_DELAY_TX;
+			break;
+
+		case BUGS_DATA_2:
+			//Wait for TX completion
+			start=micros();
+			while ((uint16_t)((uint16_t)micros()-start) < 500)			// Wait max 500µs, using serial+telemetry exit in about 60µs
+				if(!(A7105_ReadReg(A7105_00_MODE) & 0x01))
+					break;
+			A7105_SetTxRxMode(RX_EN);
+			A7105_WriteReg(A7105_0F_PLL_I, hopping_frequency[hopping_frequency_no] - 2);
+			A7105_WriteReg(A7105_03_FIFOI, BUGS_FIFO_SIZE_RX);
+			A7105_Strobe(A7105_RX);
+
+			BUGS_increment_counts();
+			phase = BUGS_DATA_3;
+			packet_period = BUGS_PACKET_PERIOD-BUGS_DELAY_TX-BUGS_DELAY_POST_RX;
+			break;
+
+		case BUGS_DATA_3:
+			mode = A7105_ReadReg(A7105_00_MODE);
+			A7105_Strobe(A7105_STANDBY);
+			A7105_SetTxRxMode(TX_EN);
+			if (!(mode & 0x01))
+			{
+				A7105_ReadData(16);
+				#if defined(BUGS_HUB_TELEMETRY)
+					v_lipo1=packet[10] == 0xff ? 0xff : 0x00;					// Voltage in this case is only an alert on level good or bad.
+					RX_RSSI=packet[3];
+					// Read TX RSSI
+					int16_t temp=256-(A7105_ReadReg(A7105_1D_RSSI_THOLD)*8)/5;	// Value from A7105 is between 8 for maximum signal strength to 160 or less
+					if(temp<0) temp=0;
+					else if(temp>255) temp=255;
+					TX_RSSI=temp;
+					telemetry_link=1;
+				#endif
+			}
+			phase = BUGS_DATA_1;
+			packet_period = BUGS_DELAY_POST_RX;
+			break;
+	}
+	return packet_period;
+}
+
+void BUGS_init(void)
+{
+	uint16_t rxid=0;
+	uint8_t base_adr=BUGS_EEPROM_OFFSET+(RX_num&0x0F)*2;
+	for(uint8_t i=0; i<2; i++)
+		rxid|=eeprom_read_byte((EE_ADDR)(base_adr+i))<<(i*8);
+	if(rxid==0xffff)
+		BIND_IN_PROGRESS;
+
+	BUGS_set_radio_data();
+	if (IS_BIND_IN_PROGRESS)
+		phase = BUGS_BIND_1;
+	else
+		phase = BUGS_DATA_1;
+
+	A7105_Init();
+
+	hopping_frequency_no = 0;
+	packet_count = 0;
+	armed = 0;
+	arm_flags = BUGS_FLAG_DISARM;		// initial value from captures
+	arm_channel_previous = BUGS_CH_SW_ARM;
+}
+
+#endif

Multiprotocol/Build_orangetx.cmd

@@ -1,20 +0,0 @@
-@echo off
-if "%AVR32_HOME%"=="" (
-echo.
-echo You must install winavr to compile Multi for OrangeTX: https://sourceforge.net/projects/winavr/
-echo.
-pause
-exit /b
-)
-if exist MultiOrange.cpp.orangetx ren *.orangetx *.
-if exist .dep (make clean)
-md .dep
-make
-if exist MultiOrange.hex (
-objcopy -I ihex MultiOrange.hex -O binary MultiOrange.bin
-echo.
-echo Compilation OK.
-echo Use MultiOrange.hex to program your OrangeTX module.
-echo.
-)
-pause

Multiprotocol/CABELL_nrf224l01.ino

@@ -0,0 +1,415 @@
+/*
+ Protocol by Dennis Cabell, 2017
+ KE8FZX
+  
+ To use this software, you must adhere to the license terms described below, and assume all responsibility for the use
+ of the software.  The user is responsible for all consequences or damage that may result from using this software.
+ The user is responsible for ensuring that the hardware used to run this software complies with local regulations and that 
+ any radio signal generated or received from use of this software is legal for that user to generate.  The author(s) of this software 
+ assume no liability whatsoever.  The author(s) of this software is not responsible for legal or civil consequences of 
+ using this software, including, but not limited to, any damages cause by lost control of a vehicle using this software.  
+ If this software is copied or modified, this disclaimer must accompany all copies.
+ 
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+ 
+// The Receiver for this protocol is available at: https://github.com/soligen2010/RC_RX_CABELL_V3_FHSS
+
+#if defined(CABELL_NRF24L01_INO)
+
+#include "iface_nrf24l01.h"
+
+#define CABELL_BIND_COUNT		2000		// At least 2000 so that if TX toggles the serial bind flag then bind mode is never exited
+#define CABELL_PACKET_PERIOD	3000		// Do not set too low or else next packet may not be finished transmitting before the channel is changed next time around
+
+#define CABELL_NUM_CHANNELS		16			// The maximum number of RC channels that can be sent in one packet
+#define CABELL_MIN_CHANNELS		4			// The minimum number of channels that must be included in a packet, the number of channels cannot be reduced any further than this
+#define CABELL_PAYLOAD_BYTES	24			// 12 bits per value * 16 channels
+
+#define CABELL_RADIO_CHANNELS			9	// This is 1/5 of the total number of radio channels used for FHSS
+#define CABELL_RADIO_MIN_CHANNEL_NUM	3	// Channel 0 is right on the boarder of allowed frequency range, so move up to avoid bleeding over
+#define CABELL_TELEMETRY_PACKET_LENGTH	4
+
+#define CABELL_BIND_RADIO_ADDR	0xA4B7C123F7LL
+
+#define CABELL_OPTION_MASK_CHANNEL_REDUCTION		0x0F
+#define CABELL_OPTION_MASK_RECIEVER_OUTPUT_MODE		0x30
+#define CABELL_OPTION_SHIFT_RECIEVER_OUTPUT_MODE	4
+#define CABELL_OPTION_MASK_MAX_POWER_OVERRIDE		0x40
+
+typedef struct
+{
+   enum RxMode_t : uint8_t
+   {   // Note bit 8 is used to indicate if the packet is the first of 2 on the channel.  Mask out this bit before using the enum
+         normal                 = 0,
+         bind                   = 1,
+         setFailSafe            = 2,
+         normalWithTelemetry    = 3,
+         telemetryResponse      = 4,
+         unBind                 = 127
+   } RxMode;
+   uint8_t reserved = 0;
+   uint8_t option;
+                          /*   mask 0x0F    : Channel reduction.  The number of channels to not send (subtracted from the 16 max channels) at least 4 are always sent
+                           *   mask 0x30>>4 : Receiver output mode
+                           *                  0 (00) = Single PPM on individual pins for each channel 
+                           *                  1 (01) = SUM PPM on channel 1 pin
+                           *                  2 (10) = Future use.  Reserved for SBUS output
+                           *                  3 (11) = Unused
+                           *   mask 0x40>>6   Contains max power override flag for Multi-protocol TX module. Also sent to RX
+                           *   mask 0x80>>7   Unused 
+                           */  
+   uint8_t modelNum;
+   uint8_t checkSum_LSB; 
+   uint8_t checkSum_MSB; 
+   uint8_t payloadValue [CABELL_PAYLOAD_BYTES] = {0}; //12 bits per channel value, unsigned
+} CABELL_RxTxPacket_t;   
+
+//-----------------------------------------------------------------------------------------
+static uint8_t __attribute__((unused)) CABELL_getNextChannel (uint8_t seqArray[], uint8_t seqArraySize, uint8_t prevChannel)
+{
+	/* Possible channels are in 5 bands, each band comprised of seqArraySize channels
+	* seqArray contains seqArraySize elements in the relative order in which we should progress through the band 
+	* 
+	* Each time the channel is changes, bands change in a way so that the next channel will be in a
+	* different non-adjacent band. Both the band changes and the index in seqArray is incremented.
+	*/
+	prevChannel -= CABELL_RADIO_MIN_CHANNEL_NUM;				// Subtract CABELL_RADIO_MIN_CHANNEL_NUM because it was added to the return value
+	if(prevChannel>(seqArraySize * 5))
+		prevChannel=seqArraySize * 5;							// Constrain the values just in case something bogus was sent in.
+
+	uint8_t currBand = prevChannel / seqArraySize;             
+	uint8_t nextBand = (currBand + 3) % 5;
+
+	uint8_t prevChannalSeqArrayValue = prevChannel % seqArraySize;
+	uint8_t prevChannalSeqArrayPosition = 0;
+	for (int x = 0; x < seqArraySize; x++)
+	{	// Find the position of the previous channel in the array
+		if (seqArray[x] == prevChannalSeqArrayValue)
+			prevChannalSeqArrayPosition = x;
+	}
+	uint8_t nextChannalSeqArrayPosition = prevChannalSeqArrayPosition + 1;
+	if (nextChannalSeqArrayPosition >= seqArraySize)
+		nextChannalSeqArrayPosition = 0;
+
+	return (seqArraySize * nextBand) + seqArray[nextChannalSeqArrayPosition] + CABELL_RADIO_MIN_CHANNEL_NUM;	// Add CABELL_RADIO_MIN_CHANNEL_NUM so we dont use channel 0 as it may bleed below 2.400 GHz
+}
+
+//-----------------------------------------------------------------------------------------
+#if defined CABELL_HUB_TELEMETRY 
+static void __attribute__((unused)) CABELL_get_telemetry()
+{
+	// calculate TX rssi based on past 250 expected telemetry packets.  Cannot use full second count because telemetry_counter is not large enough
+	state++;
+	if (state > 250)
+	{
+		TX_RSSI = telemetry_counter;
+		telemetry_counter = 0;
+		state = 0;
+		telemetry_lost=0;
+	}
+
+	// Process incoming telemetry packet of it was received
+	if (NRF24L01_ReadReg(NRF24L01_07_STATUS) & _BV(NRF24L01_07_RX_DR)) 
+	{ // data received from model
+		NRF24L01_ReadPayload(packet, CABELL_TELEMETRY_PACKET_LENGTH);
+		if ((packet[0] & 0x7F) == CABELL_RxTxPacket_t::telemetryResponse)	// ignore high order bit in compare because it toggles with each packet
+		{
+			RX_RSSI = packet[1];	// Packet rate 0 to 255 where 255 is 100% packet rate
+			v_lipo1 = packet[2];	// Directly from analog input of receiver, but reduced to 8-bit depth (0 to 255).  Scaling depends on the input to the analog pin of the receiver.
+			v_lipo2 = packet[3];	// Directly from analog input of receiver, but reduced to 8-bit depth (0 to 255).  Scaling depends on the input to the analog pin of the receiver.
+			telemetry_counter++;      
+			if(telemetry_lost==0)
+				telemetry_link=1;
+		}
+	}
+	else
+	{
+		// If no telemetry packet was received then delay by the typical telemetry packet processing time
+		// This is done to try to keep the sendPacket process timing more consistent. Since the SPI payload read takes some time
+		delayMicroseconds(50);
+	}
+	NRF24L01_SetTxRxMode(TX_EN);  
+	NRF24L01_FlushRx(); 
+}
+#endif
+
+//-----------------------------------------------------------------------------------------
+static void __attribute__((unused)) CABELL_send_packet(uint8_t bindMode)
+{  
+	#if defined CABELL_HUB_TELEMETRY  
+		if (!bindMode && (sub_protocol == CABELL_V3_TELEMETRY))		// check for incoming packet and switch radio back to TX mode if we were listening for telemetry      
+			CABELL_get_telemetry();
+	#endif
+
+	CABELL_RxTxPacket_t TxPacket;
+
+	uint8_t channelReduction = constrain((option & CABELL_OPTION_MASK_CHANNEL_REDUCTION),0,CABELL_NUM_CHANNELS-CABELL_MIN_CHANNELS);	// Max 12 - cannot reduce below 4 channels
+	if (bindMode)
+		channelReduction = 0;	// Send full packet to bind as higher channels will contain bind info
+
+	uint8_t packetSize = sizeof(TxPacket) - ((((channelReduction - (channelReduction%2))/ 2)) * 3);		// reduce 3 bytes per 2 channels, but not last channel if it is odd
+	uint8_t maxPayloadValueIndex = sizeof(TxPacket.payloadValue) - (sizeof(TxPacket) - packetSize);
+
+	if ((sub_protocol == CABELL_UNBIND) && !bindMode)
+	{
+		TxPacket.RxMode = CABELL_RxTxPacket_t::unBind;
+		TxPacket.option = option;
+	}
+	else
+	{
+		if (sub_protocol == CABELL_SET_FAIL_SAFE && !bindMode)
+			TxPacket.RxMode = CABELL_RxTxPacket_t::setFailSafe;
+		else
+		{
+			if (bindMode)
+				TxPacket.RxMode = CABELL_RxTxPacket_t::bind;        
+			else
+			{
+				switch (sub_protocol)
+				{
+					case CABELL_V3_TELEMETRY:
+						TxPacket.RxMode = CABELL_RxTxPacket_t::normalWithTelemetry;
+						break;
+					default:
+						TxPacket.RxMode = CABELL_RxTxPacket_t::normal;  
+						break;
+				}      
+			}
+		}
+		TxPacket.option = (bindMode) ? (option & (~CABELL_OPTION_MASK_CHANNEL_REDUCTION)) : option;		//remove channel reduction if in bind mode
+	}
+ 
+	rf_ch_num = CABELL_getNextChannel (hopping_frequency,CABELL_RADIO_CHANNELS, rf_ch_num);
+	TxPacket.reserved = rf_ch_num & 0x3F;
+	TxPacket.modelNum = RX_num;
+	uint16_t checkSum = TxPacket.modelNum + TxPacket.option + TxPacket.RxMode  + TxPacket.reserved;		// Start Calculate checksum
+
+	int adjusted_x;
+	int payloadIndex = 0;
+	uint16_t holdValue;
+
+	for (int x = 0;(x < CABELL_NUM_CHANNELS - channelReduction); x++)
+	{
+		switch (x)
+		{
+			case 0	: adjusted_x = ELEVATOR;	break;
+			case 1	: adjusted_x = AILERON;		break;
+			case 2	: adjusted_x = RUDDER;		break;
+			case 3	: adjusted_x = THROTTLE;	break;
+			default	: adjusted_x = x;			break;
+		}
+		holdValue = convert_channel_16b_limit(adjusted_x,1000,2000);				// valid channel values are 1000 to 2000
+		if (bindMode)
+		{
+			switch (adjusted_x)
+			{
+				case THROTTLE	: holdValue = 1000;					break;      // always set throttle to off when binding for safety
+				//tx address sent for bind
+				case 11			: holdValue = 1000 + rx_tx_addr[0];	break;
+				case 12			: holdValue = 1000 + rx_tx_addr[1];	break;
+				case 13			: holdValue = 1000 + rx_tx_addr[2];	break;
+				case 14			: holdValue = 1000 + rx_tx_addr[3];	break;
+				case 15			: holdValue = 1000 + rx_tx_addr[4];	break;
+			}
+		}
+
+		// use 12 bits per value
+		if (x % 2)
+		{ //output channel number is ODD
+			holdValue = holdValue<<4;
+			payloadIndex--;     
+		}
+		else
+			holdValue &= 0x0FFF;
+		TxPacket.payloadValue[payloadIndex] |=  (uint8_t)(holdValue & 0x00FF);
+		payloadIndex++;
+		TxPacket.payloadValue[payloadIndex] |=  (uint8_t)((holdValue>>8) & 0x00FF);   
+		payloadIndex++;
+	}
+
+	for(int x = 0; x < maxPayloadValueIndex ; x++)
+		checkSum += TxPacket.payloadValue[x];  // Finish Calculate checksum 
+
+	TxPacket.checkSum_MSB = checkSum >> 8;
+	TxPacket.checkSum_LSB = checkSum & 0x00FF;
+
+	// Set channel for next transmission
+	NRF24L01_WriteReg(NRF24L01_05_RF_CH,rf_ch_num); 
+
+	//NRF24L01_FlushTx();   //just in case things got hung up
+	//NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);
+
+	uint8_t* p = reinterpret_cast<uint8_t*>(&TxPacket.RxMode);
+	*p &= 0x7F;                  // Make sure 8th bit is clear
+	*p |= (packet_count++)<<7;   // This causes the 8th bit of the first byte to toggle with each xmit so consecutive payloads are not identical.
+	// This is a work around for a reported bug in clone NRF24L01 chips that mis-took this case for a re-transmit of the same packet.
+
+	NRF24L01_SetPower();
+	NRF24L01_WritePayload((uint8_t*)&TxPacket, packetSize);
+
+	#if defined CABELL_HUB_TELEMETRY 
+		if (!bindMode && (sub_protocol == CABELL_V3_TELEMETRY))
+		{ // switch radio to rx as soon as packet is sent  
+			// calculate transmit time based on packet size and data rate of 1MB per sec
+			// This is done because polling the status register during xmit caused issues.
+			// bits = packst_size * 8  +  73 bits overhead
+			// at 250 Kbs per sec, one bit is 4 uS
+			// then add 140 uS which is 130 uS to begin the xmit and 10 uS fudge factor
+			delayMicroseconds(((((unsigned long)packetSize * 8ul)  +  73ul) * 4ul) + 140ul)   ;
+			packet_period = CABELL_PACKET_PERIOD + (constrain(((int16_t)(CABELL_NUM_CHANNELS - channelReduction) - (int16_t)6 ),(int16_t)0 ,(int16_t)10 ) * (int16_t)100);  // increase packet period by 100 us for each channel over 6
+			NRF24L01_WriteReg(NRF24L01_00_CONFIG, 0x0F);  // RX mode with 16 bit CRC
+		}
+		else 
+	#endif
+			packet_period = CABELL_PACKET_PERIOD;   // Standard packet period when not in telemetry mode.
+}
+
+//-----------------------------------------------------------------------------------------
+static void __attribute__((unused)) CABELL_getChannelSequence (uint8_t outArray[], uint8_t numChannels, uint64_t permutation)
+{
+	/* This procedure initializes an array with the sequence progression of channels.
+	* This is not the actual channels itself, but the sequence base to be used within bands of
+	* channels.
+	*
+	* There are numChannels! permutations for arranging the channels
+	* one of these permutations will be calculated based on the permutation input
+	* permutation should be between 1 and numChannels! but the routine will constrain it
+	* if these bounds are exceeded.  Typically the radio's unique TX ID should be used.
+	*
+	* The maximum numChannels is 20.  Anything larger than this will cause the uint64_t
+	* variables to overflow, yielding unknown results (possibly infinite loop?).  Therefor
+	* this routine constrains the value.
+	*/
+	uint8_t i;   //iterator counts numChannels
+	uint32_t indexOfNextSequenceValue;
+	uint32_t numChannelsFactorial=1;
+	uint32_t perm32 ;
+	uint8_t  sequenceValue;
+
+	numChannels = constrain(numChannels,1,9);
+
+	for (i = 1; i <= numChannels;i++)
+	{
+		numChannelsFactorial *= i;					//  Calculate n!
+		outArray[i-1] = i-1;						//  Initialize array with the sequence
+	}
+
+	perm32 = permutation >> 8 ;						// Shift 40 bit input to 32 bit
+	perm32 = (perm32 % numChannelsFactorial);		// permutation must be between 1 and n! or this algorithm will infinite loop
+	perm32 <<= 8 ;									// Shift back 8 bits
+	perm32 += permutation & 0x00FF ;				// Tack on least 8 bits
+	perm32 = (perm32 % numChannelsFactorial) + 1;	// permutation must be between 1 and n! or this algorithm will infinite loop
+
+	//Rearrange the array elements based on the permutation selected
+	for (i=0, perm32--; i<numChannels; i++ )
+	{
+		numChannelsFactorial /= numChannels-i;
+		indexOfNextSequenceValue = i+(perm32/numChannelsFactorial);
+		perm32 %= numChannelsFactorial;
+
+		//Copy the value in the selected array position
+		sequenceValue = outArray[indexOfNextSequenceValue];
+
+		//Shift the unused elements in the array to make room to move in the one just selected
+		for( ; indexOfNextSequenceValue > i; indexOfNextSequenceValue--)
+			outArray[indexOfNextSequenceValue] = outArray[indexOfNextSequenceValue-1];
+
+		// Copy the selected value into it's new array slot
+		outArray[i] = sequenceValue;
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+static void __attribute__((unused)) CABELL_setAddress()
+{
+	uint64_t CABELL_addr;
+
+	//  Serial.print("NORM ID: ");Serial.print((uint32_t)(CABELL_normal_addr>>32)); Serial.print("    ");Serial.println((uint32_t)((CABELL_normal_addr<<32)>>32));
+
+	if (IS_BIND_DONE)
+	{
+		CABELL_addr = (((uint64_t)rx_tx_addr[0]) << 32) + 
+			(((uint64_t)rx_tx_addr[1]) << 24) + 
+			(((uint64_t)rx_tx_addr[2]) << 16) + 
+			(((uint64_t)rx_tx_addr[3]) << 8) + 
+			(((uint64_t)rx_tx_addr[4]));					// Address to use after binding
+	}
+	else
+		CABELL_addr = CABELL_BIND_RADIO_ADDR;				// Static addr for binding
+
+	CABELL_getChannelSequence(hopping_frequency,CABELL_RADIO_CHANNELS,CABELL_addr);		// Get the sequence for hopping through channels
+	rf_ch_num = CABELL_RADIO_MIN_CHANNEL_NUM;				// Initialize the channel sequence
+
+	packet_count=0;  
+
+	uint64_t CABELL_Telemetry_addr = ~CABELL_addr;			// Invert bits for reading so that telemetry packets have a different address.
+
+	NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0, reinterpret_cast<uint8_t*>(&CABELL_Telemetry_addr), 5);
+	NRF24L01_WriteRegisterMulti(NRF24L01_0B_RX_ADDR_P1, reinterpret_cast<uint8_t*>(&CABELL_Telemetry_addr), 5);
+	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR,    reinterpret_cast<uint8_t*>(&CABELL_addr), 5);
+}
+
+//-----------------------------------------------------------------------------------------
+static void __attribute__((unused)) CABELL_RF_init()
+{
+	NRF24L01_Initialize();
+
+	NRF24L01_SetBitrate(NRF24L01_BR_250K);				// slower data rate gives better range/reliability
+	CABELL_setAddress();
+	NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, 0x20);		// 32 byte packet length
+	NRF24L01_WriteReg(NRF24L01_12_RX_PW_P1, 0x20);		// 32 byte packet length
+	NRF24L01_WriteReg(NRF24L01_1C_DYNPD, 0x3F);			// Enable dynamic payload length on all pipes
+	NRF24L01_WriteReg(NRF24L01_1D_FEATURE, 0x04);		// Enable dynamic Payload Length
+
+	NRF24L01_SetTxRxMode(TX_EN);						// Clear data ready, data sent, retransmit and enable CRC 16bits, ready for TX
+}
+
+//-----------------------------------------------------------------------------------------
+uint16_t CABELL_callback()
+{
+	if (IS_BIND_DONE)
+	{
+		CABELL_send_packet(0);  // packet_period is set/adjusted in CABELL_send_packet
+		#ifdef MULTI_SYNC
+			telemetry_set_input_sync(packet_period);
+		#endif
+		return packet_period;
+	}
+	else if (bind_counter == 0)
+	{
+		BIND_DONE;
+		CABELL_RF_init();   // non-bind address 
+	}
+	else
+	{
+		CABELL_send_packet(1);
+		bind_counter--;
+	}
+	return CABELL_PACKET_PERIOD;
+}
+
+//-----------------------------------------------------------------------------------------
+void CABELL_init(void)
+{
+	if (IS_BIND_DONE)
+		bind_counter = 0;
+	else  
+		bind_counter = CABELL_BIND_COUNT;
+	CABELL_RF_init();
+
+	packet_period = CABELL_PACKET_PERIOD;
+}
+
+#endif

Multiprotocol/CC2500_SPI.ino

@@ -144,8 +144,17 @@ static void CC2500_SetPower_Value(uint8_t power)
 void CC2500_SetPower()
 {
 	uint8_t power=CC2500_BIND_POWER;
-	if(IS_BIND_DONE_on)
+	if(IS_BIND_DONE)
+		#ifdef CC2500_ENABLE_LOW_POWER
 			power=IS_POWER_FLAG_on?CC2500_HIGH_POWER:CC2500_LOW_POWER;
+		#else
+			power=CC2500_HIGH_POWER;
+		#endif
+	if(IS_LBT_POWER_on)
+	{
+		power=CC2500_LBT_POWER;
+		LBT_POWER_off;			// Only accept once
+	}
 	if(IS_RANGE_FLAG_on)
 		power=CC2500_RANGE_POWER;
 	if(prev_power != power)
@@ -154,4 +163,128 @@ void CC2500_SetPower()
 		prev_power=power;
 	}
 }
+
+void __attribute__((unused)) CC2500_SetFreqOffset()
+{
+	if(prev_option != option)
+	{
+		prev_option = option;
+		CC2500_WriteReg(CC2500_0C_FSCTRL0, option);
+	}
+}
+
+void __attribute__((unused)) CC2500_250K_Init()
+{
+	CC2500_Strobe(CC2500_SIDLE);
+
+	// Address Config = No address check
+	// Base Frequency = 2400
+	// CRC Autoflush = false
+	// CRC Enable = false
+	// Channel Spacing = 333.251953
+	// Data Format = Normal mode
+	// Data Rate = 249.939
+	// Deviation = 126.953125
+	// Device Address = 0
+	// Manchester Enable = false
+	// Modulated = true
+	// Modulation Format = GFSK
+	// Packet Length Mode = Variable packet length mode. Packet length configured by the first byte after sync word
+	// RX Filter BW = 203.125000
+	// Sync Word Qualifier Mode = No preamble/sync
+	// TX Power = 0
+	// Whitening = false
+	// Fast Frequency Hopping - no PLL auto calibration
+/*	//Previous config
+	CC2500_WriteReg(CC2500_08_PKTCTRL0,	0x01);   // Packet Automation Control
+	CC2500_WriteReg(CC2500_0B_FSCTRL1,	0x0A);   // Frequency Synthesizer Control
+	CC2500_WriteReg(CC2500_0C_FSCTRL0, option);  // Frequency offset hack 
+	CC2500_WriteReg(CC2500_0D_FREQ2,	0x5C);   // Frequency Control Word, High Byte
+	CC2500_WriteReg(CC2500_0E_FREQ1,	0x4E);   // Frequency Control Word, Middle Byte
+	CC2500_WriteReg(CC2500_0F_FREQ0,	0xC3);   // Frequency Control Word, Low Byte
+	CC2500_WriteReg(CC2500_10_MDMCFG4,	0x8D);   // Modem Configuration
+	CC2500_WriteReg(CC2500_11_MDMCFG3,	0x3B);   // Modem Configuration
+	CC2500_WriteReg(CC2500_12_MDMCFG2,	0x10);   // Modem Configuration
+	CC2500_WriteReg(CC2500_13_MDMCFG1,	0x23);   // Modem Configuration
+	CC2500_WriteReg(CC2500_14_MDMCFG0,	0xA4);   // Modem Configuration
+	CC2500_WriteReg(CC2500_15_DEVIATN,	0x62);   // Modem Deviation Setting
+	CC2500_WriteReg(CC2500_18_MCSM0,	0x08);   // Main Radio Control State Machine Configuration
+	CC2500_WriteReg(CC2500_19_FOCCFG,	0x1D);   // Frequency Offset Compensation Configuration
+	CC2500_WriteReg(CC2500_1A_BSCFG,	0x1C);   // Bit Synchronization Configuration
+	CC2500_WriteReg(CC2500_1B_AGCCTRL2, 0xC7);   // AGC Control
+	CC2500_WriteReg(CC2500_1C_AGCCTRL1, 0x00);   // AGC Control
+	CC2500_WriteReg(CC2500_1D_AGCCTRL0, 0xB0);   // AGC Control
+	CC2500_WriteReg(CC2500_21_FREND1,	0xB6);   // Front End RX Configuration
+	CC2500_WriteReg(CC2500_23_FSCAL3,	0xEA);   // Frequency Synthesizer Calibration
+	CC2500_WriteReg(CC2500_25_FSCAL1,	0x00);   // Frequency Synthesizer Calibration
+	CC2500_WriteReg(CC2500_26_FSCAL0,	0x11);   // Frequency Synthesizer Calibration
+*/
+	CC2500_WriteReg(CC2500_07_PKTCTRL1, 0x05);   // Packet Automation Control, address check true auto append RSSI & LQI
+	CC2500_WriteReg(CC2500_08_PKTCTRL0, 0x00);   // Packet Automation Control, fixed packet len
+	CC2500_WriteReg(CC2500_0B_FSCTRL1,  0x0A);   // Frequency Synthesizer Control (IF Frequency)
+	CC2500_WriteReg(CC2500_0C_FSCTRL0,  0x00);   // Frequency Synthesizer Control
+	CC2500_WriteReg(CC2500_0D_FREQ2,    0x5C);   // Frequency Control Word, High Byte
+	CC2500_WriteReg(CC2500_0E_FREQ1,    0x4E);   // Frequency Control Word, Middle Byte
+	CC2500_WriteReg(CC2500_0F_FREQ0,    0xC5);   // Frequency Control Word, Low Byte
+	CC2500_WriteReg(CC2500_10_MDMCFG4,  0x3D);   // Modem Configuration  Set to 406kHz BW filter
+	CC2500_WriteReg(CC2500_11_MDMCFG3,  0x3B);   // Modem Configuration
+	CC2500_WriteReg(CC2500_12_MDMCFG2,	0x10);   // Modem Configuration, GFSK, no preambule and no sync word -> TX by default
+	CC2500_WriteReg(CC2500_13_MDMCFG1,  0x03);   // Modem Configuration, 2 bytes of preamble
+	CC2500_WriteReg(CC2500_14_MDMCFG0,  0xA4);   // Modem Configuration
+	CC2500_WriteReg(CC2500_15_DEVIATN,  0x62);   // Modem Deviation Setting
+	CC2500_WriteReg(CC2500_18_MCSM0,    0x08);   // Main Radio Control State Machine Configuration
+	CC2500_WriteReg(CC2500_19_FOCCFG,   0x1D);   // Frequency Offset Compensation Configuration
+	CC2500_WriteReg(CC2500_1A_BSCFG,    0x1C);   // Bit Synchronization Configuration
+	CC2500_WriteReg(CC2500_1B_AGCCTRL2, 0xC7);   // AGC Control
+	CC2500_WriteReg(CC2500_1C_AGCCTRL1, 0x00);   // AGC Control
+	CC2500_WriteReg(CC2500_1D_AGCCTRL0, 0xB0);   // AGC Control
+	CC2500_WriteReg(CC2500_21_FREND1,   0xB6);   // Front End RX Configuration
+	CC2500_WriteReg(CC2500_23_FSCAL3,   0xEA);   // Frequency Synthesizer Calibration
+	CC2500_WriteReg(CC2500_25_FSCAL1,   0x00);   // Frequency Synthesizer Calibration
+	CC2500_WriteReg(CC2500_26_FSCAL0,   0x11);   // Frequency Synthesizer Calibration
+	
+	//Prep RX
+	// Set first 3 bytes of rx addr in [0]->SYNC1, [1]->SYNC0 and [2]->ADDR
+	// CC2500_WriteReg(CC2500_04_SYNC1,    [0]);   // Sync word, high byte
+	// CC2500_WriteReg(CC2500_05_SYNC0,    [1]);   // Sync word, low byte
+	// CC2500_WriteReg(CC2500_09_ADDR,     [2]);   // Set addr
+	//RX
+	// CC2500_WriteReg(CC2500_12_MDMCFG2,  0x12);  // Modem Configuration, GFSK, 16/16 Sync Word TX&RX
+	//TX
+	// CC2500_WriteReg(CC2500_12_MDMCFG2,	0x10); // Modem Configuration, GFSK, no preambule and no sync word
+	// need to set packet length before sending/receiving
+	// CC2500_WriteReg(CC2500_06_PKTLEN,   cc2500_packet_len);  // Packet len, fix packet len
+
+	CC2500_SetTxRxMode(TX_EN);
+	CC2500_SetPower();
+}
+void __attribute__((unused)) CC2500_250K_HoppingCalib(uint8_t num_freq)
+{
+	for (uint8_t i = 0; i < num_freq; i++)
+	{
+		CC2500_Strobe(CC2500_SIDLE);
+		// spacing is 333.25 kHz, must multiply channel by 3
+		CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency[i]*3);
+		// calibrate
+		CC2500_Strobe(CC2500_SCAL);
+		delayMicroseconds(900);
+		calData[i]=CC2500_ReadReg(CC2500_25_FSCAL1);
+	}
+}
+void __attribute__((unused)) CC2500_250K_Hopping(uint8_t index)
+{
+	// spacing is 333.25 kHz, must multiply channel by 3
+	CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency[index] * 3);
+	// set PLL calibration
+	CC2500_WriteReg(CC2500_25_FSCAL1, calData[index]);
+}
+void __attribute__((unused)) CC2500_250K_RFChannel(uint8_t number)
+{
+	CC2500_Strobe(CC2500_SIDLE);
+	// spacing is 333.25 kHz, must multiply channel by 3
+	CC2500_WriteReg(CC2500_0A_CHANNR, number*3);
+	// calibrate
+	CC2500_Strobe(CC2500_SCAL);
+	delayMicroseconds(900);
+}
 #endif

Multiprotocol/CFlie_nrf24l01.ino

@@ -0,0 +1,845 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Most of this code was ported from theseankelly's related DeviationTX work.
+
+#if defined(CFLIE_NRF24L01_INO)
+
+#include "iface_nrf24l01.h"
+
+#define CFLIE_BIND_COUNT 60
+
+//=============================================================================
+// CRTP (Crazy RealTime Protocol) Implementation
+//=============================================================================
+
+// Port IDs
+enum {
+    CRTP_PORT_CONSOLE = 0x00,
+    CRTP_PORT_PARAM = 0x02,
+    CRTP_PORT_SETPOINT = 0x03,
+    CRTP_PORT_MEM = 0x04,
+    CRTP_PORT_LOG = 0x05,
+    CRTP_PORT_POSITION = 0x06,
+    CRTP_PORT_SETPOINT_GENERIC = 0x07,
+    CRTP_PORT_PLATFORM = 0x0D,
+    CRTP_PORT_LINK = 0x0F,
+};
+
+// Channel definitions for the LOG port
+enum {
+    CRTP_LOG_CHAN_TOC = 0x00,
+    CRTP_LOG_CHAN_SETTINGS = 0x01,
+    CRTP_LOG_CHAN_LOGDATA = 0x02,
+};
+
+// Command definitions for the LOG port's TOC channel
+enum {
+    CRTP_LOG_TOC_CMD_ELEMENT = 0x00,
+    CRTP_LOG_TOC_CMD_INFO = 0x01,
+};
+
+// Command definitions for the LOG port's CMD channel
+enum {
+    CRTP_LOG_SETTINGS_CMD_CREATE_BLOCK = 0x00,
+    CRTP_LOG_SETTINGS_CMD_APPEND_BLOCK = 0x01,
+    CRTP_LOG_SETTINGS_CMD_DELETE_BLOCK = 0x02,
+    CRTP_LOG_SETTINGS_CMD_START_LOGGING = 0x03,
+    CRTP_LOG_SETTINGS_CMD_STOP_LOGGING = 0x04,
+    CRTP_LOG_SETTINGS_CMD_RESET_LOGGING = 0x05,
+};
+
+// Log variables types
+enum {
+    LOG_UINT8 = 0x01,
+    LOG_UINT16 = 0x02,
+    LOG_UINT32 = 0x03,
+    LOG_INT8 = 0x04,
+    LOG_INT16 = 0x05,
+    LOG_INT32 = 0x06,
+    LOG_FLOAT = 0x07,
+    LOG_FP16 = 0x08,
+};
+
+#define CFLIE_TELEM_LOG_BLOCK_ID            0x01
+#define CFLIE_TELEM_LOG_BLOCK_PERIOD_10MS   50 // 50*10 = 500ms
+
+// Setpoint type definitions for the generic setpoint channel
+enum {
+    CRTP_SETPOINT_GENERIC_STOP_TYPE = 0x00,
+    CRTP_SETPOINT_GENERIC_VELOCITY_WORLD_TYPE = 0x01,
+    CRTP_SETPOINT_GENERIC_Z_DISTANCE_TYPE = 0x02,
+    CRTP_SETPOINT_GENERIC_CPPM_EMU_TYPE = 0x03,
+};
+
+static inline uint8_t crtp_create_header(uint8_t port, uint8_t channel)
+{
+    return ((port)&0x0F)<<4 | (channel & 0x03);
+}
+
+//=============================================================================
+// End CRTP implementation
+//=============================================================================
+
+// Address size
+#define TX_ADDR_SIZE 5
+
+// Timeout for callback in uSec, 10ms=10000us for Crazyflie
+#define CFLIE_PACKET_PERIOD 10000
+
+#define MAX_PACKET_SIZE 32  // CRTP is 32 bytes
+
+// CPPM CRTP supports up to 10 aux channels but deviation only
+// supports a total of 12 channels. R,P,Y,T leaves 8 aux channels left
+#define MAX_CPPM_AUX_CHANNELS 8
+
+static uint8_t tx_payload_len = 0; // Length of the packet stored in packet
+static uint8_t rx_payload_len = 0; // Length of the packet stored in rx_packet
+static uint8_t rx_packet[MAX_PACKET_SIZE]; // For reading in ACK payloads
+
+static uint8_t data_rate;
+
+enum {
+    CFLIE_INIT_SEARCH = 0,
+    CFLIE_INIT_CRTP_LOG,
+    CFLIE_INIT_DATA,
+    CFLIE_SEARCH,
+    CFLIE_DATA
+};
+
+static uint8_t crtp_log_setup_state;
+enum {
+    CFLIE_CRTP_LOG_SETUP_STATE_INIT = 0,
+    CFLIE_CRTP_LOG_SETUP_STATE_SEND_CMD_GET_INFO,
+    CFLIE_CRTP_LOG_SETUP_STATE_ACK_CMD_GET_INFO,
+    CFLIE_CRTP_LOG_SETUP_STATE_SEND_CMD_GET_ITEM,
+    CFLIE_CRTP_LOG_SETUP_STATE_ACK_CMD_GET_ITEM,
+    // It might be a good idea to add a state here
+    // to send the command to reset the logging engine
+    // to avoid log block ID conflicts. However, there
+    // is not a conflict with the current defaults in
+    // cfclient and I'd rather be able to log from the Tx
+    // and cfclient simultaneously
+    CFLIE_CRTP_LOG_SETUP_STATE_SEND_CONTROL_CREATE_BLOCK,
+    CFLIE_CRTP_LOG_SETUP_STATE_ACK_CONTROL_CREATE_BLOCK,
+    CFLIE_CRTP_LOG_SETUP_STATE_SEND_CONTROL_START_BLOCK,
+    CFLIE_CRTP_LOG_SETUP_STATE_ACK_CONTROL_START_BLOCK,
+    CFLIE_CRTP_LOG_SETUP_STATE_COMPLETE,
+};
+
+// State variables for the crtp_log_setup_state_machine
+static uint8_t toc_size;             // Size of the TOC read from the crazyflie
+static uint8_t next_toc_variable;    // State variable keeping track of the next var to read
+static uint8_t vbat_var_id;          // ID of the vbatMV variable
+static uint8_t extvbat_var_id;       // ID of the extVbatMV variable
+static uint8_t rssi_var_id;          // ID of the RSSI variable
+
+// Constants used for finding var IDs from the toc
+static const char* pm_group_name = "pm";
+static const char* vbat_var_name = "vbatMV";
+static const uint8_t vbat_var_type = LOG_UINT16;
+static const char* extvbat_var_name = "extVbatMV";
+static const uint8_t extvbat_var_type = LOG_UINT16;
+static const char* radio_group_name = "radio";
+static const char* rssi_var_name = "rssi";
+static const uint8_t rssi_var_type = LOG_UINT8;
+
+// Repurposing DSM Telemetry fields
+#define TELEM_CFLIE_INTERNAL_VBAT   TELEM_DSM_FLOG_VOLT2    // Onboard voltage
+#define TELEM_CFLIE_EXTERNAL_VBAT   TELEM_DSM_FLOG_VOLT1    // Voltage from external pin (BigQuad)
+#define TELEM_CFLIE_RSSI            TELEM_DSM_FLOG_FADESA   // Repurpose FADESA for RSSI
+
+enum {
+    PROTOOPTS_TELEMETRY = 0,
+    PROTOOPTS_CRTP_MODE = 1,
+    LAST_PROTO_OPT,
+};
+
+#define TELEM_OFF 0
+#define TELEM_ON_ACKPKT 1
+#define TELEM_ON_CRTPLOG 2
+
+#define CRTP_MODE_RPYT 0
+#define CRTP_MODE_CPPM 1
+
+// Bit vector from bit position
+#define BV(bit) (1 << bit)
+
+#define PACKET_CHKTIME 500      // time to wait if packet not yet acknowledged or timed out    
+
+// Helper for sending a packet
+// Assumes packet data has been put in packet
+// and tx_payload_len has been set correctly
+static void send_packet()
+{
+    // clear packet status bits and Tx/Rx FIFOs
+    NRF24L01_WriteReg(NRF24L01_07_STATUS, (_BV(NRF24L01_07_TX_DS) | _BV(NRF24L01_07_MAX_RT)));
+    NRF24L01_FlushTx();
+    NRF24L01_FlushRx();
+
+    // Transmit the payload
+    NRF24L01_WritePayload(packet, tx_payload_len);
+
+    // // Check and adjust transmission power.
+    NRF24L01_SetPower();
+}
+
+static uint16_t dbg_cnt = 0;
+static uint8_t packet_ack()
+{
+	if (++dbg_cnt > 50)
+	{
+		// debugln("S: %02x\n", NRF24L01_ReadReg(NRF24L01_07_STATUS));
+		dbg_cnt = 0;
+	}
+	switch (NRF24L01_ReadReg(NRF24L01_07_STATUS) & (BV(NRF24L01_07_TX_DS) | BV(NRF24L01_07_MAX_RT)))
+	{
+		case BV(NRF24L01_07_TX_DS):
+			rx_payload_len = NRF24L01_GetDynamicPayloadSize();
+			if (rx_payload_len > MAX_PACKET_SIZE)
+				rx_payload_len = MAX_PACKET_SIZE;
+			NRF24L01_ReadPayload(rx_packet, rx_payload_len);
+			return PKT_ACKED;
+		case BV(NRF24L01_07_MAX_RT):
+			return PKT_TIMEOUT;
+	}
+	return PKT_PENDING;
+}
+
+static void set_rate_channel(uint8_t rate, uint8_t channel)
+{
+	NRF24L01_WriteReg(NRF24L01_05_RF_CH, channel);		// Defined by model id
+	NRF24L01_SetBitrate(rate);							// Defined by model id
+}
+
+static void send_search_packet()
+{
+	uint8_t buf[1];
+	buf[0] = 0xff;
+	// clear packet status bits and TX FIFO
+	NRF24L01_WriteReg(NRF24L01_07_STATUS, (BV(NRF24L01_07_TX_DS) | BV(NRF24L01_07_MAX_RT)));
+	NRF24L01_FlushTx();
+
+	if (rf_ch_num++ > 125)
+	{
+		rf_ch_num = 0;
+		switch(data_rate)
+		{
+			case NRF24L01_BR_250K:
+				data_rate = NRF24L01_BR_1M;
+				break;
+			case NRF24L01_BR_1M:
+				data_rate = NRF24L01_BR_2M;
+				break;
+			case NRF24L01_BR_2M:
+				data_rate = NRF24L01_BR_250K;
+				break;
+		}
+	}
+	set_rate_channel(data_rate, rf_ch_num);
+
+	NRF24L01_WritePayload(buf, sizeof(buf));
+
+}
+
+// Frac 16.16
+#define FRAC_MANTISSA 16 // This means, not IEEE 754...
+#define FRAC_SCALE (1 << FRAC_MANTISSA)
+
+// Convert fractional 16.16 to float32
+static void frac2float(int32_t n, float* res)
+{
+	if (n == 0)
+	{
+		*res = 0.0;
+		return;
+	}
+	uint32_t m = n < 0 ? -n : n; // Figure out mantissa?
+	int i;
+	for (i = (31-FRAC_MANTISSA); (m & 0x80000000) == 0; i--, m <<= 1);
+	m <<= 1; // Clear implicit leftmost 1
+	m >>= 9;
+	uint32_t e = 127 + i;
+	if (n < 0) m |= 0x80000000;
+	m |= e << 23;
+	*((uint32_t *) res) = m;
+}
+
+static void send_crtp_rpyt_packet()
+{
+	int32_t f_roll;
+	int32_t f_pitch;
+	int32_t f_yaw;
+	uint16_t thrust;
+
+	uint16_t val;
+
+	struct CommanderPacketRPYT
+	{
+		float roll;
+		float pitch;
+		float yaw;
+		uint16_t thrust;
+	}__attribute__((packed)) cpkt;
+
+	// Channels in AETR order
+	// Roll, aka aileron, float +- 50.0 in degrees
+	// float roll  = -(float) Channels[0]*50.0/10000;
+	val = convert_channel_16b_limit(AILERON, -10000, 10000);
+	// f_roll = -Channels[0] * FRAC_SCALE / (10000 / 50);
+	f_roll = val * FRAC_SCALE / (10000 / 50);
+
+	frac2float(f_roll, &cpkt.roll); // TODO: Remove this and use the correct Mode switch below...
+	// debugln("Roll: raw, converted:  %d, %d, %d, %0.2f", Channel_data[AILERON], val, f_roll, cpkt.roll);
+
+	// Pitch, aka elevator, float +- 50.0 degrees
+	//float pitch = -(float) Channels[1]*50.0/10000;
+	val = convert_channel_16b_limit(ELEVATOR, -10000, 10000);
+	// f_pitch = -Channels[1] * FRAC_SCALE / (10000 / 50);
+	f_pitch = -val * FRAC_SCALE / (10000 / 50);
+
+	frac2float(f_pitch, &cpkt.pitch); // TODO: Remove this and use the correct Mode switch below...
+	// debugln("Pitch: raw, converted:  %d, %d, %d, %0.2f", Channel_data[ELEVATOR], val, f_pitch, cpkt.pitch);
+
+	// Thrust, aka throttle 0..65535, working range 5535..65535
+	// Android Crazyflie app puts out a throttle range of 0-80%: 0..52000
+	thrust = convert_channel_16b_limit(THROTTLE, 0, 32767) * 2;
+
+	// Crazyflie needs zero thrust to unlock
+	if (thrust < 900)
+		cpkt.thrust = 0;
+	else
+		cpkt.thrust = thrust;
+
+	// debugln("Thrust: raw, converted:  %d, %u, %u", Channel_data[THROTTLE], thrust, cpkt.thrust);
+
+	// Yaw, aka rudder, float +- 400.0 deg/s
+	// float yaw   = -(float) Channels[3]*400.0/10000;
+	val = convert_channel_16b_limit(RUDDER, -10000, 10000);
+	// f_yaw = - Channels[3] * FRAC_SCALE / (10000 / 400);
+	f_yaw = val * FRAC_SCALE / (10000 / 400);
+	frac2float(f_yaw, &cpkt.yaw);
+
+	// debugln("Yaw: raw, converted:  %d, %d, %d, %0.2f", Channel_data[RUDDER], val, f_yaw, cpkt.yaw);
+
+	// Switch on/off?
+	// TODO: Get X or + mode working again:
+	// if (Channels[4] >= 0) {
+	//     frac2float(f_roll, &cpkt.roll);
+	//     frac2float(f_pitch, &cpkt.pitch);
+	// } else {
+	//     // Rotate 45 degrees going from X to + mode or opposite.
+	//     // 181 / 256 = 0.70703125 ~= sqrt(2) / 2
+	//     int32_t f_x_roll = (f_roll + f_pitch) * 181 / 256;
+	//     frac2float(f_x_roll, &cpkt.roll);
+	//     int32_t f_x_pitch = (f_pitch - f_roll) * 181 / 256;
+	//     frac2float(f_x_pitch, &cpkt.pitch);
+	// }
+
+	// Construct and send packet
+	packet[0] = crtp_create_header(CRTP_PORT_SETPOINT, 0); // Commander packet to channel 0
+	memcpy(&packet[1], (char*) &cpkt, sizeof(cpkt));
+	tx_payload_len = 1 + sizeof(cpkt);
+	send_packet();
+}
+
+/*static void send_crtp_cppm_emu_packet()
+{
+    struct CommanderPacketCppmEmu {
+        struct {
+            uint8_t numAuxChannels : 4; // Set to 0 through MAX_AUX_RC_CHANNELS
+            uint8_t reserved : 4;
+        } hdr;
+        uint16_t channelRoll;
+        uint16_t channelPitch;
+        uint16_t channelYaw;
+        uint16_t channelThrust;
+        uint16_t channelAux[10];
+    } __attribute__((packed)) cpkt;
+
+    // To emulate PWM RC signals, rescale channels from (-10000,10000) to (1000,2000)
+    // This is done by dividing by 20 to get a total range of 1000 (-500,500)
+    // and then adding 1500 to to rebase the offset
+#define RESCALE_RC_CHANNEL_TO_PWM(chan) ((chan / 20) + 1500)
+
+    // Make sure the number of aux channels in use is capped to MAX_CPPM_AUX_CHANNELS
+    // uint8_t numAuxChannels = Model.num_channels - 4;
+    uint8_t numAuxChannels = 2; // TODO: Figure this out correctly
+    if(numAuxChannels > MAX_CPPM_AUX_CHANNELS)
+    {
+        numAuxChannels = MAX_CPPM_AUX_CHANNELS;
+    }
+
+    cpkt.hdr.numAuxChannels = numAuxChannels;
+
+    // Remap AETR to AERT (RPYT)
+    cpkt.channelRoll = convert_channel_16b_limit(AILERON,1000,2000);
+    cpkt.channelPitch = convert_channel_16b_limit(ELEVATOR,1000,2000);
+    // Note: T & R Swapped:
+    cpkt.channelYaw = convert_channel_16b_limit(RUDDER, 1000, 2000);
+    cpkt.channelThrust = convert_channel_16b_limit(THROTTLE, 1000, 2000);
+
+    // Rescale the rest of the aux channels - RC channel 4 and up
+    for (uint8_t i = 4; i < 14; i++)
+    {
+        cpkt.channelAux[i] = convert_channel_16b_limit(i, 1000, 2000);
+    }
+
+    // Total size of the commander packet is a 1-byte header, 4 2-byte channels and
+    // a variable number of 2-byte auxiliary channels
+    uint8_t commanderPacketSize = 1 + 8 + (2*numAuxChannels);
+
+    // Construct and send packet
+    packet[0] = crtp_create_header(CRTP_PORT_SETPOINT_GENERIC, 0); // Generic setpoint packet to channel 0
+    packet[1] = CRTP_SETPOINT_GENERIC_CPPM_EMU_TYPE;
+
+    // Copy the header (1) plus 4 2-byte channels (8) plus whatever number of 2-byte aux channels are in use
+    memcpy(&packet[2], (char*)&cpkt, commanderPacketSize); // Why not use sizeof(cpkt) here??
+    tx_payload_len = 2 + commanderPacketSize; // CRTP header, commander type, and packet
+    send_packet();
+}*/
+
+static void send_cmd_packet()
+{
+    // TODO: Fix this so we can actually configure the packet type
+    // switch(Model.proto_opts[PROTOOPTS_CRTP_MODE])
+    // {
+    // case CRTP_MODE_CPPM:
+    //     send_crtp_cppm_emu_packet();
+    //     break;
+    // case CRTP_MODE_RPYT:
+    //     send_crtp_rpyt_packet();
+    //     break;
+    // default:
+    //     send_crtp_rpyt_packet();
+    // }
+
+    // send_crtp_cppm_emu_packet(); // oh maAAAn
+    send_crtp_rpyt_packet();
+}
+
+// State machine for setting up CRTP logging
+// returns 1 when the state machine has completed, 0 otherwise
+static uint8_t crtp_log_setup_state_machine()
+{
+    uint8_t state_machine_completed = 0;
+    // A note on the design of this state machine:
+    //
+    // Responses from the crazyflie come in the form of ACK payloads.
+    // There is no retry logic associated with ACK payloads, so it is possible
+    // to miss a response from the crazyflie. To avoid this, the request
+    // packet must be re-sent until the expected response is received. However,
+    // re-sending the same request generates another response in the crazyflie
+    // Rx queue, which can produce large backlogs of duplicate responses.
+    //
+    // To avoid this backlog but still guard against dropped ACK payloads,
+    // transmit cmd packets (which don't generate responses themselves)
+    // until an empty ACK payload is received (the crazyflie alternates between
+    // 0xF3 and 0xF7 for empty ACK payloads) which indicates the Rx queue on the
+    // crazyflie has been drained. If the queue has been drained and the
+    // desired ACK has still not been received, it was likely dropped and the
+    // request should be re-transmit.
+
+    switch (crtp_log_setup_state) {
+    case CFLIE_CRTP_LOG_SETUP_STATE_INIT:
+        toc_size = 0;
+        next_toc_variable = 0;
+        vbat_var_id = 0;
+        extvbat_var_id = 0;
+        crtp_log_setup_state = CFLIE_CRTP_LOG_SETUP_STATE_SEND_CMD_GET_INFO;
+        // fallthrough
+    case CFLIE_CRTP_LOG_SETUP_STATE_SEND_CMD_GET_INFO:
+        crtp_log_setup_state = CFLIE_CRTP_LOG_SETUP_STATE_ACK_CMD_GET_INFO;
+        packet[0] = crtp_create_header(CRTP_PORT_LOG, CRTP_LOG_CHAN_TOC);
+        packet[1] = CRTP_LOG_TOC_CMD_INFO;
+        tx_payload_len = 2;
+        send_packet();
+        break;
+
+    case CFLIE_CRTP_LOG_SETUP_STATE_ACK_CMD_GET_INFO:
+        if (packet_ack() == PKT_ACKED) {
+            if (rx_payload_len >= 3
+                    && rx_packet[0] == crtp_create_header(CRTP_PORT_LOG, CRTP_LOG_CHAN_TOC)
+                    && rx_packet[1] == CRTP_LOG_TOC_CMD_INFO) {
+                // Received the ACK payload. Save the toc_size
+                // and advance to the next state
+                toc_size = rx_packet[2];
+                crtp_log_setup_state =
+                        CFLIE_CRTP_LOG_SETUP_STATE_SEND_CMD_GET_ITEM;
+                return state_machine_completed;
+            } else if (rx_packet[0] == 0xF3 || rx_packet[0] == 0xF7) {
+                // "empty" ACK packet received - likely missed the ACK
+                // payload we are waiting for.
+                // return to the send state and retransmit the request
+                crtp_log_setup_state =
+                        CFLIE_CRTP_LOG_SETUP_STATE_SEND_CMD_GET_INFO;
+                return state_machine_completed;
+            }
+        }
+
+        // Otherwise, send a cmd packet to get the next ACK in the Rx queue
+        send_cmd_packet();
+        break;
+
+    case CFLIE_CRTP_LOG_SETUP_STATE_SEND_CMD_GET_ITEM:
+        crtp_log_setup_state = CFLIE_CRTP_LOG_SETUP_STATE_ACK_CMD_GET_ITEM;
+        packet[0] = crtp_create_header(CRTP_PORT_LOG, CRTP_LOG_CHAN_TOC);
+        packet[1] = CRTP_LOG_TOC_CMD_ELEMENT;
+        packet[2] = next_toc_variable;
+        tx_payload_len = 3;
+        send_packet();
+        break;
+
+    case CFLIE_CRTP_LOG_SETUP_STATE_ACK_CMD_GET_ITEM:
+        if (packet_ack() == PKT_ACKED) {
+            if (rx_payload_len >= 3
+                    && rx_packet[0] == crtp_create_header(CRTP_PORT_LOG, CRTP_LOG_CHAN_TOC)
+                    && rx_packet[1] == CRTP_LOG_TOC_CMD_ELEMENT
+                    && rx_packet[2] == next_toc_variable) {
+                // For every element in the TOC we must compare its
+                // type (rx_packet[3]), group and name (back to back
+                // null terminated strings starting with the fifth byte)
+                // and see if it matches any of the variables we need
+                // for logging
+                //
+                // Currently enabled for logging:
+                //  - vbatMV (LOG_UINT16)
+                //  - extVbatMV (LOG_UINT16)
+                //  - rssi (LOG_UINT8)
+                if(rx_packet[3] == vbat_var_type
+                        && (0 == strcmp((char*)&rx_packet[4], pm_group_name))
+                        && (0 == strcmp((char*)&rx_packet[4 + strlen(pm_group_name) + 1], vbat_var_name))) {
+                    // Found the vbat element - save it for later
+                    vbat_var_id = next_toc_variable;
+                }
+
+                if(rx_packet[3] == extvbat_var_type
+                        && (0 == strcmp((char*)&rx_packet[4], pm_group_name))
+                        && (0 == strcmp((char*)&rx_packet[4 + strlen(pm_group_name) + 1], extvbat_var_name))) {
+                    // Found the extvbat element - save it for later
+                    extvbat_var_id = next_toc_variable;
+                }
+
+                if(rx_packet[3] == rssi_var_type
+                        && (0 == strcmp((char*)&rx_packet[4], radio_group_name))
+                        && (0 == strcmp((char*)&rx_packet[4 + strlen(radio_group_name) + 1], rssi_var_name))) {
+                    // Found the rssi element - save it for later
+                    rssi_var_id = next_toc_variable;
+                }
+
+                // Advance the toc variable counter
+                // If there are more variables, read them
+                // If not, move on to the next state
+                next_toc_variable += 1;
+                if(next_toc_variable >= toc_size) {
+                    crtp_log_setup_state = CFLIE_CRTP_LOG_SETUP_STATE_SEND_CONTROL_CREATE_BLOCK;
+                } else {
+                    // There are more TOC elements to get
+                    crtp_log_setup_state = CFLIE_CRTP_LOG_SETUP_STATE_SEND_CMD_GET_ITEM;
+                }
+                return state_machine_completed;
+            } else if (rx_packet[0] == 0xF3 || rx_packet[0] == 0xF7) {
+                // "empty" ACK packet received - likely missed the ACK
+                // payload we are waiting for.
+                // return to the send state and retransmit the request
+                crtp_log_setup_state =
+                        CFLIE_CRTP_LOG_SETUP_STATE_SEND_CMD_GET_INFO;
+                return state_machine_completed;
+            }
+        }
+
+        // Otherwise, send a cmd packet to get the next ACK in the Rx queue
+        send_cmd_packet();
+        break;
+
+    case CFLIE_CRTP_LOG_SETUP_STATE_SEND_CONTROL_CREATE_BLOCK:
+        crtp_log_setup_state = CFLIE_CRTP_LOG_SETUP_STATE_ACK_CONTROL_CREATE_BLOCK;
+        packet[0] = crtp_create_header(CRTP_PORT_LOG, CRTP_LOG_CHAN_SETTINGS);
+        packet[1] = CRTP_LOG_SETTINGS_CMD_CREATE_BLOCK;
+        packet[2] = CFLIE_TELEM_LOG_BLOCK_ID; // Log block ID
+        packet[3] = vbat_var_type; // Variable type
+        packet[4] = vbat_var_id; // ID of the VBAT variable
+        packet[5] = extvbat_var_type; // Variable type
+        packet[6] = extvbat_var_id; // ID of the ExtVBat variable
+        packet[7] = rssi_var_type; // Variable type
+        packet[8] = rssi_var_id; // ID of the RSSI variable
+        tx_payload_len = 9;
+        send_packet();
+        break;
+
+    case CFLIE_CRTP_LOG_SETUP_STATE_ACK_CONTROL_CREATE_BLOCK:
+        if (packet_ack() == PKT_ACKED) {
+            if (rx_payload_len >= 2
+                    && rx_packet[0] == crtp_create_header(CRTP_PORT_LOG, CRTP_LOG_CHAN_SETTINGS)
+                    && rx_packet[1] == CRTP_LOG_SETTINGS_CMD_CREATE_BLOCK) {
+                // Received the ACK payload. Advance to the next state
+                crtp_log_setup_state =
+                        CFLIE_CRTP_LOG_SETUP_STATE_SEND_CONTROL_START_BLOCK;
+                return state_machine_completed;
+            } else if (rx_packet[0] == 0xF3 || rx_packet[0] == 0xF7) {
+                // "empty" ACK packet received - likely missed the ACK
+                // payload we are waiting for.
+                // return to the send state and retransmit the request
+                crtp_log_setup_state =
+                        CFLIE_CRTP_LOG_SETUP_STATE_SEND_CONTROL_CREATE_BLOCK;
+                return state_machine_completed;
+            }
+        }
+
+        // Otherwise, send a cmd packet to get the next ACK in the Rx queue
+        send_cmd_packet();
+        break;
+
+    case CFLIE_CRTP_LOG_SETUP_STATE_SEND_CONTROL_START_BLOCK:
+        crtp_log_setup_state = CFLIE_CRTP_LOG_SETUP_STATE_ACK_CONTROL_START_BLOCK;
+        packet[0] = crtp_create_header(CRTP_PORT_LOG, CRTP_LOG_CHAN_SETTINGS);
+        packet[1] = CRTP_LOG_SETTINGS_CMD_START_LOGGING;
+        packet[2] = CFLIE_TELEM_LOG_BLOCK_ID; // Log block ID 1
+        packet[3] = CFLIE_TELEM_LOG_BLOCK_PERIOD_10MS; // Log frequency in 10ms units
+        tx_payload_len = 4;
+        send_packet();
+        break;
+
+    case CFLIE_CRTP_LOG_SETUP_STATE_ACK_CONTROL_START_BLOCK:
+        if (packet_ack() == PKT_ACKED) {
+            if (rx_payload_len >= 2
+                    && rx_packet[0] == crtp_create_header(CRTP_PORT_LOG, CRTP_LOG_CHAN_SETTINGS)
+                    && rx_packet[1] == CRTP_LOG_SETTINGS_CMD_START_LOGGING) {
+                // Received the ACK payload. Advance to the next state
+                crtp_log_setup_state =
+                        CFLIE_CRTP_LOG_SETUP_STATE_COMPLETE;
+                return state_machine_completed;
+            } else if (rx_packet[0] == 0xF3 || rx_packet[0] == 0xF7) {
+                // "empty" ACK packet received - likely missed the ACK
+                // payload we are waiting for.
+                // return to the send state and retransmit the request
+                crtp_log_setup_state =
+                        CFLIE_CRTP_LOG_SETUP_STATE_SEND_CONTROL_START_BLOCK;
+                return state_machine_completed;
+            }
+        }
+
+        // Otherwise, send a cmd packet to get the next ACK in the Rx queue
+        send_cmd_packet();
+        break;
+
+    case CFLIE_CRTP_LOG_SETUP_STATE_COMPLETE:
+        state_machine_completed = 1;
+        return state_machine_completed;
+        break;
+    }
+
+    return state_machine_completed;
+}
+
+static void CFLIE_RF_init()
+{
+    NRF24L01_Initialize();
+
+    // CRC, radio on
+    NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x01);              // Auto Acknowledgement for data pipe 0
+    NRF24L01_WriteReg(NRF24L01_04_SETUP_RETR, 0x13);         // 3 retransmits, 500us delay
+
+    NRF24L01_WriteReg(NRF24L01_05_RF_CH, rf_ch_num);        // Defined in initialize_rx_tx_addr
+    NRF24L01_SetBitrate(data_rate);                          // Defined in initialize_rx_tx_addr
+
+    NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0, rx_tx_addr, TX_ADDR_SIZE);
+    NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, rx_tx_addr, TX_ADDR_SIZE);
+
+    NRF24L01_WriteReg(NRF24L01_1C_DYNPD, 0x01);       // Enable Dynamic Payload Length on pipe 0
+    NRF24L01_WriteReg(NRF24L01_1D_FEATURE, 0x06);     // Enable Dynamic Payload Length, enable Payload with ACK
+
+	NRF24L01_SetTxRxMode(TX_EN);						// Clear data ready, data sent, retransmit and enable CRC 16bits, ready for TX
+}
+
+// TODO: Fix telemetry
+
+// Update telemetry using the CRTP logging framework
+// static void update_telemetry_crtplog()
+// {
+//     static uint8_t frameloss = 0;
+
+//     // Read and reset count of dropped packets
+//     frameloss += NRF24L01_ReadReg(NRF24L01_08_OBSERVE_TX) >> 4;
+//     NRF24L01_WriteReg(NRF24L01_05_RF_CH, rf_ch_num); // reset packet loss counter
+//     Telemetry.value[TELEM_DSM_FLOG_FRAMELOSS] = frameloss;
+//     TELEMETRY_SetUpdated(TELEM_DSM_FLOG_FRAMELOSS);
+
+//     if (packet_ack() == PKT_ACKED) {
+//         // See if the ACK packet is a cflie log packet
+//         // A log data packet is a minimum of 5 bytes. Ignore anything less.
+//         if (rx_payload_len >= 5) {
+//             // Port 5 = log, Channel 2 = data
+//             if (rx_packet[0] == crtp_create_header(CRTP_PORT_LOG, CRTP_LOG_CHAN_LOGDATA)) {
+//                 // The log block ID
+//                 if (rx_packet[1] == CFLIE_TELEM_LOG_BLOCK_ID) {
+//                     // Bytes 5 and 6 are the Vbat in mV units
+//                     uint16_t vBat;
+//                     memcpy(&vBat, &rx_packet[5], sizeof(uint16_t));
+//                     Telemetry.value[TELEM_CFLIE_INTERNAL_VBAT] = (int32_t) (vBat / 10); // The log value expects centivolts
+//                     TELEMETRY_SetUpdated(TELEM_CFLIE_INTERNAL_VBAT);
+
+//                     // Bytes 7 and 8 are the ExtVbat in mV units
+//                     uint16_t extVBat;
+//                     memcpy(&extVBat, &rx_packet[7], sizeof(uint16_t));
+//                     Telemetry.value[TELEM_CFLIE_EXTERNAL_VBAT] = (int32_t) (extVBat / 10); // The log value expects centivolts
+//                     TELEMETRY_SetUpdated(TELEM_CFLIE_EXTERNAL_VBAT);
+
+//                     // Byte 9 is the RSSI
+//                     Telemetry.value[TELEM_CFLIE_RSSI] = rx_packet[9];
+//                     TELEMETRY_SetUpdated(TELEM_CFLIE_RSSI);
+//                 }
+//             }
+//         }
+//     }
+// }
+
+// // Update telemetry using the ACK packet payload
+// static void update_telemetry_ackpkt()
+// {
+//     static uint8_t frameloss = 0;
+
+//     // Read and reset count of dropped packets
+//     frameloss += NRF24L01_ReadReg(NRF24L01_08_OBSERVE_TX) >> 4;
+//     NRF24L01_WriteReg(NRF24L01_05_RF_CH, rf_ch_num); // reset packet loss counter
+//     Telemetry.value[TELEM_DSM_FLOG_FRAMELOSS] = frameloss;
+//     TELEMETRY_SetUpdated(TELEM_DSM_FLOG_FRAMELOSS);
+
+//     if (packet_ack() == PKT_ACKED) {
+//         // Make sure this is an ACK packet (first byte will alternate between 0xF3 and 0xF7
+//         if (rx_packet[0] == 0xF3 || rx_packet[0] == 0xF7) {
+//             // If ACK packet contains RSSI (proper length and byte 1 is 0x01)
+//             if(rx_payload_len >= 3 && rx_packet[1] == 0x01) {
+//                 Telemetry.value[TELEM_CFLIE_RSSI] = rx_packet[2];
+//                 TELEMETRY_SetUpdated(TELEM_CFLIE_RSSI);
+//             }
+//             // If ACK packet contains VBAT (proper length and byte 3 is 0x02)
+//             if(rx_payload_len >= 8 && rx_packet[3] == 0x02) {
+//                 uint32_t vBat = 0;
+//                 memcpy(&vBat, &rx_packet[4], sizeof(uint32_t));
+//                 Telemetry.value[TELEM_CFLIE_INTERNAL_VBAT] = (int32_t)(vBat / 10); // The log value expects centivolts
+//                 TELEMETRY_SetUpdated(TELEM_CFLIE_INTERNAL_VBAT);
+//             }
+//         }
+//     }
+// }
+
+static uint16_t CFLIE_callback()
+{
+    switch (phase) {
+    case CFLIE_INIT_SEARCH:
+        send_search_packet();
+        phase = CFLIE_SEARCH;
+        break;
+    case CFLIE_INIT_CRTP_LOG:
+        if (crtp_log_setup_state_machine()) {
+            phase = CFLIE_INIT_DATA;
+        }
+        break;
+    case CFLIE_INIT_DATA:
+        send_cmd_packet();
+        phase = CFLIE_DATA;
+        break;
+    case CFLIE_SEARCH:
+        switch (packet_ack()) {
+        case PKT_PENDING:
+            return PACKET_CHKTIME;                 // packet send not yet complete
+        case PKT_ACKED:
+            phase = CFLIE_DATA;
+            // PROTOCOL_SetBindState(0);
+            // MUSIC_Play(MUSIC_DONE_BINDING);
+            BIND_DONE;
+            break;
+        case PKT_TIMEOUT:
+            send_search_packet();
+        }
+        break;
+
+    case CFLIE_DATA:
+		#ifdef MULTI_SYNC
+			telemetry_set_input_sync(CFLIE_PACKET_PERIOD);
+		#endif
+		// if (Model.proto_opts[PROTOOPTS_TELEMETRY] == TELEM_ON_CRTPLOG) {
+        //     update_telemetry_crtplog();
+        // } else if (Model.proto_opts[PROTOOPTS_TELEMETRY] == TELEM_ON_ACKPKT) {
+        //     update_telemetry_ackpkt();
+        // }
+
+        if (packet_ack() == PKT_PENDING)
+            return PACKET_CHKTIME;         // packet send not yet complete
+        send_cmd_packet();
+        break;
+    }
+    return CFLIE_PACKET_PERIOD;                  // Packet at standard protocol interval
+}
+
+// Generate address to use from TX id and manufacturer id (STM32 unique id)
+static uint8_t CFLIE_initialize_rx_tx_addr()
+{
+    rx_tx_addr[0] = 
+    rx_tx_addr[1] = 
+    rx_tx_addr[2] = 
+    rx_tx_addr[3] = 
+    rx_tx_addr[4] = 0xE7; // CFlie uses fixed address
+
+    // if (Model.fixed_id) {
+    //     rf_ch_num = Model.fixed_id % 100;
+    //     switch (Model.fixed_id / 100) {
+    //     case 0:
+    //         data_rate = NRF24L01_BR_250K;
+    //         break;
+    //     case 1:
+    //         data_rate = NRF24L01_BR_1M;
+    //         break;
+    //     case 2:
+    //         data_rate = NRF24L01_BR_2M;
+    //         break;
+    //     default:
+    //         break;
+    //     }
+
+    //     if (Model.proto_opts[PROTOOPTS_TELEMETRY] == TELEM_ON_CRTPLOG) {
+    //         return CFLIE_INIT_CRTP_LOG;
+    //     } else {
+    //         return CFLIE_INIT_DATA;
+    //     }
+    // } else {
+    //     data_rate = NRF24L01_BR_250K;
+    //     rf_ch_num = 10;
+    //     return CFLIE_INIT_SEARCH;
+    // }
+
+    // Default 1
+    data_rate = NRF24L01_BR_1M;
+    rf_ch_num = 10;
+
+    // Default 2
+    // data_rate = NRF24L01_BR_2M;
+    // rf_ch_num = 110;
+    return CFLIE_INIT_SEARCH;
+}
+
+void CFLIE_init(void)
+{
+	BIND_IN_PROGRESS;	// autobind protocol
+
+    phase = CFLIE_initialize_rx_tx_addr();
+    crtp_log_setup_state = CFLIE_CRTP_LOG_SETUP_STATE_INIT;
+    packet_count=0;
+
+    CFLIE_RF_init();
+}
+
+#endif

Multiprotocol/CG023_nrf24l01.ino

@@ -13,13 +13,10 @@
  along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
  */
 // compatible with EAchine 3D X4, CG023/CG031, Attop YD-822/YD-829/YD-829C and H8_3D/JJRC H20/H22
-// Merged CG023 and H8_3D protocols
-// Last sync with hexfet new_protocols/cg023_nrf24l01.c dated 2015-10-03
-// Last sync with hexfet new_protocols/h8_3d_nrf24l01.c dated 2015-11-18
 
 #if defined(CG023_NRF24L01_INO)
 
-#include "iface_nrf24l01.h"
+#include "iface_xn297.h"
 
 #define CG023_PACKET_PERIOD		8200 // Timeout for callback in uSec
 #define CG023_INITIAL_WAIT		500
@@ -27,9 +24,6 @@
 #define CG023_RF_BIND_CHANNEL	0x2D
 #define CG023_BIND_COUNT		500  // 4 seconds
 #define YD829_PACKET_PERIOD		4100 // Timeout for callback in uSec
-#define H8_3D_PACKET_PERIOD		1800 // Timeout for callback in uSec
-#define H8_3D_PACKET_SIZE		20
-#define H8_3D_RF_NUM_CHANNELS	4
 
 
 enum CG023_FLAGS {
@@ -55,96 +49,32 @@ enum YD829_FLAGS {
     YD829_FLAG_STILL    = 0x80,
 };
 
-enum H8_3D_FLAGS {
-    // flags going to packet[17]
-    H8_3D_FLAG_FLIP      = 0x01,
-    H8_3D_FLAG_RATE_MID  = 0x02,
-    H8_3D_FLAG_RATE_HIGH = 0x04,
-    H8_3D_FLAG_LIGTH	 = 0x08, // Light on H22
-    H8_3D_FLAG_HEADLESS  = 0x10, // RTH + headless on H8, headless on JJRC H20, RTH on H22
-    H8_3D_FLAG_RTH		 = 0x20, // 360 flip mode on H8 3D and H22, RTH on JJRC H20
-};
-
-enum H8_3D_FLAGS_2 {
-    // flags going to packet[18]
-    H8_3D_FLAG_VIDEO      = 0x80,
-    H8_3D_FLAG_PICTURE    = 0x40,
-    H8_3D_FLAG_CALIBRATE1 = 0x20,  // H8 3D acc calibration, H20 headless calib
-    H8_3D_FLAG_CALIBRATE2 = 0x10,  // H11D and H20 acc calibration
-    H8_3D_FLAG_CAM_DN     = 0x08,
-    H8_3D_FLAG_CAM_UP     = 0x04,
-};
-
-static void __attribute__((unused)) CG023_send_packet(uint8_t bind)
+static void __attribute__((unused)) CG023_send_packet()
 {
 	// throttle : 0x00 - 0xFF
 	throttle=convert_channel_8b(THROTTLE);
 	// rudder
-	rudder = convert_channel_8b_scale(RUDDER,0x44,0xBC);	// yaw right : 0x80 (neutral) - 0xBC (right)
+	rudder = convert_channel_16b_limit(RUDDER,0x44,0xBC);	// yaw right : 0x80 (neutral) - 0xBC (right)
 	if (rudder<=0x80)
 		rudder=0x80-rudder;							// yaw left : 0x00 (neutral) - 0x3C (left)
 	// elevator : 0xBB - 0x7F - 0x43
-	elevator = convert_channel_8b_scale(ELEVATOR, 0x43, 0xBB); 
+	elevator = convert_channel_16b_limit(ELEVATOR, 0x43, 0xBB); 
 	// aileron : 0x43 - 0x7F - 0xBB
-	aileron = convert_channel_8b_scale(AILERON, 0x43, 0xBB); 
+	aileron = convert_channel_16b_limit(AILERON, 0x43, 0xBB); 
 	
+	if (IS_BIND_IN_PROGRESS)
+	{
+		packet[0]= 0xaa;
+		XN297_RFChannel(CG023_RF_BIND_CHANNEL);
+	}
+	else
+	{
+		packet[0]= 0x55;
+		XN297_RFChannel(hopping_frequency_no);
+	}
+	// transmitter id
 	packet[1] = rx_tx_addr[0]; 
 	packet[2] = rx_tx_addr[1];
-	if(sub_protocol==H8_3D)
-	{
-		packet[0] = 0x13;
-		packet[3] = rx_tx_addr[2];
-		packet[4] = rx_tx_addr[3];
-		packet[8] = rx_tx_addr[0]+rx_tx_addr[1]+rx_tx_addr[2]+rx_tx_addr[3]; // txid checksum
-		memset(&packet[9], 0, 10);
-		if (bind)
-		{    
-			packet[5] = 0x00;
-			packet[6] = 0x00;
-			packet[7] = 0x01;
-		}
-		else
-		{
-			packet[5] = hopping_frequency_no;
-			packet[6] = 0x08;
-			packet[7] = 0x03;
-			packet[9] = throttle;
-			if(rudder==0x01) rudder=0;	// Small deadband
-			if(rudder==0x81) rudder=0;	// Small deadband
-			packet[10] = rudder;
-			packet[11] = elevator;
-			packet[12] = aileron;
-			// neutral trims
-			packet[13] = 0x20;
-			packet[14] = 0x20;
-			packet[15] = 0x20;
-			packet[16] = 0x20;
-			packet[17] = 					  H8_3D_FLAG_RATE_HIGH
-						| GET_FLAG(Servo_AUX1,H8_3D_FLAG_FLIP)
-						| GET_FLAG(Servo_AUX2,H8_3D_FLAG_LIGTH) //H22 light
-						| GET_FLAG(Servo_AUX5,H8_3D_FLAG_HEADLESS)
-						| GET_FLAG(Servo_AUX6,H8_3D_FLAG_RTH); // 180/360 flip mode on H8 3D
-			packet[18] =  GET_FLAG(Servo_AUX3,H8_3D_FLAG_PICTURE)
-						| GET_FLAG(Servo_AUX4,H8_3D_FLAG_VIDEO)
-						| GET_FLAG(Servo_AUX7,H8_3D_FLAG_CALIBRATE1)
-						| GET_FLAG(Servo_AUX8,H8_3D_FLAG_CALIBRATE2);
-			if(Servo_data[AUX9]<PPM_MIN_COMMAND)
-				packet[18] |= H8_3D_FLAG_CAM_DN;
-			if(Servo_data[AUX9]>PPM_MAX_COMMAND)
-				packet[18] |= H8_3D_FLAG_CAM_UP;
-		}
-	    uint8_t  sum = packet[9];
-		for (uint8_t i=10; i < H8_3D_PACKET_SIZE-1; i++)
-			sum += packet[i];
-		packet[19] = sum; // data checksum
-	}
-	else
-	{ // CG023 and YD829
-		if (bind)
-			packet[0]= 0xaa;
-		else
-			packet[0]= 0x55;
-		// transmitter id
 	// unknown
 	packet[3] = 0x00;
 	packet[4] = 0x00;
@@ -162,119 +92,69 @@ static void __attribute__((unused)) CG023_send_packet(uint8_t bind)
 	{
 		// rate
 		packet[13] =				  CG023_FLAG_RATE_HIGH
-						| GET_FLAG(Servo_AUX1,CG023_FLAG_FLIP)
-						| GET_FLAG(Servo_AUX2,CG023_FLAG_LED_OFF)
-						| GET_FLAG(Servo_AUX3,CG023_FLAG_STILL)
-						| GET_FLAG(Servo_AUX4,CG023_FLAG_VIDEO)
-						| GET_FLAG(Servo_AUX5,CG023_FLAG_EASY);
+					| GET_FLAG(CH5_SW,CG023_FLAG_FLIP)
+					| GET_FLAG(CH6_SW,CG023_FLAG_LED_OFF)
+					| GET_FLAG(CH7_SW,CG023_FLAG_STILL)
+					| GET_FLAG(CH8_SW,CG023_FLAG_VIDEO)
+					| GET_FLAG(CH9_SW,CG023_FLAG_EASY);
 	}
 	else
 	{// YD829
 		// rate
 		packet[13] =				  YD829_FLAG_RATE_HIGH
-						| GET_FLAG(Servo_AUX1,YD829_FLAG_FLIP)
-						| GET_FLAG(Servo_AUX3,YD829_FLAG_STILL)
-						| GET_FLAG(Servo_AUX4,YD829_FLAG_VIDEO)
-						| GET_FLAG(Servo_AUX5,YD829_FLAG_HEADLESS);
+					| GET_FLAG(CH5_SW,YD829_FLAG_FLIP)
+					| GET_FLAG(CH7_SW,YD829_FLAG_STILL)
+					| GET_FLAG(CH8_SW,YD829_FLAG_VIDEO)
+					| GET_FLAG(CH9_SW,YD829_FLAG_HEADLESS);
 	}
 	packet[14] = 0;
+	
+	// Send
+	XN297_SetTxRxMode(TX_EN);
+	XN297_SetPower();
+	XN297_WritePayload(packet, CG023_PACKET_SIZE);
 }
 
-	// Power on, TX mode, 2byte CRC
-	// Why CRC0? xn297 does not interpret it - either 16-bit CRC or nothing
-	XN297_Configure(_BV(NRF24L01_00_EN_CRC) | _BV(NRF24L01_00_CRCO) | _BV(NRF24L01_00_PWR_UP));
-	if (bind)
-		NRF24L01_WriteReg(NRF24L01_05_RF_CH, sub_protocol==H8_3D?hopping_frequency[0]:CG023_RF_BIND_CHANNEL);
-	else
+static void __attribute__((unused)) CG023_RF_init()
 {
-		if(sub_protocol==H8_3D)
-		{
-			NRF24L01_WriteReg(NRF24L01_05_RF_CH, hopping_frequency[hopping_frequency_no++]);
-			hopping_frequency_no %= H8_3D_RF_NUM_CHANNELS;
-		}
-		else // CG023 and YD829
-			NRF24L01_WriteReg(NRF24L01_05_RF_CH, hopping_frequency_no);
-	}
-	// clear packet status bits and TX FIFO
-	NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);
-	NRF24L01_FlushTx();
-	XN297_WritePayload(packet, sub_protocol==H8_3D ? H8_3D_PACKET_SIZE:CG023_PACKET_SIZE);
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
 
-	NRF24L01_SetPower();	// Set tx_power
-}
-
-static void __attribute__((unused)) CG023_init()
-{
-    NRF24L01_Initialize();
-    NRF24L01_SetTxRxMode(TX_EN);
-	if(sub_protocol==H8_3D)
-		XN297_SetTXAddr((uint8_t *)"\xC4\x57\x09\x65\x21", 5);
-	else // CG023 and YD829
 	XN297_SetTXAddr((uint8_t *)"\x26\xA8\x67\x35\xCC", 5);
-
-    NRF24L01_FlushTx();
-    NRF24L01_FlushRx();
-    NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);     // Clear data ready, data sent, and retransmit
-    NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);      // No Auto Acknowldgement on all data pipes
-    NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x01);  // Enable data pipe 0 only
-    NRF24L01_SetBitrate(NRF24L01_BR_1M);             // 1Mbps
-    NRF24L01_SetPower();
 }
 
 uint16_t CG023_callback()
 {
-	if(IS_BIND_DONE_on)
-		CG023_send_packet(0);
-	else
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(packet_period);
+	#endif
+	if(bind_counter)
 	{
+		bind_counter--;
 		if (bind_counter == 0)
 			BIND_DONE;
-		else
-		{
-			CG023_send_packet(1);
-			bind_counter--;
-		}
 	}
+	CG023_send_packet();
 	return	packet_period;
 }
 
 static void __attribute__((unused)) CG023_initialize_txid()
 {
-	if(sub_protocol==H8_3D)
-	{
-		rx_tx_addr[0] = 0xa0 + (rx_tx_addr[0] % 0x10);
-		rx_tx_addr[1] = 0xb0 + (rx_tx_addr[1] % 0x20);
-		rx_tx_addr[2] = rx_tx_addr[2] % 0x20;
-		rx_tx_addr[3] = rx_tx_addr[3] % 0x11;
-
-		hopping_frequency[0] = 0x06 + ((rx_tx_addr[0]&0x0f) % 0x0f);
-		hopping_frequency[1] = 0x15 + ((rx_tx_addr[1]&0x0f) % 0x0f);
-		hopping_frequency[2] = 0x24 + ((rx_tx_addr[2]&0x0f) % 0x0f);
-		hopping_frequency[3] = 0x33 + ((rx_tx_addr[3]&0x0f) % 0x0f);
-	}
-	else
-	{ // CG023 and YD829
 	rx_tx_addr[0]= 0x80 | (rx_tx_addr[0] % 0x40);
 	if( rx_tx_addr[0] == 0xAA)						// avoid using same freq for bind and data channel
 		rx_tx_addr[0] ++;
 	hopping_frequency_no = rx_tx_addr[0] - 0x7D;	// rf channel for data packets
 }
-}
 
-uint16_t initCG023(void)
+void CG023_init(void)
 {
 	BIND_IN_PROGRESS;	// autobind protocol
     bind_counter = CG023_BIND_COUNT;
 	CG023_initialize_txid();
-	CG023_init();
+	CG023_RF_init();
 	if(sub_protocol==CG023)
 		packet_period=CG023_PACKET_PERIOD;
-	else
-		if(sub_protocol==YD829)
+	else // YD829
 		packet_period=YD829_PACKET_PERIOD;
-		else
-			packet_period=H8_3D_PACKET_PERIOD;
-	return	CG023_INITIAL_WAIT+YD829_PACKET_PERIOD;
 }
 
 #endif

Multiprotocol/CX10_nrf24l01.ino

@@ -12,12 +12,12 @@
  You should have received a copy of the GNU General Public License
  along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
  */
-// compatible with Cheerson CX-10 blue & newer red pcb, CX-10A, CX11, CX-10 green pcb, DM007, Floureon FX-10, JXD 509 (Q282)
+// compatible with Cheerson CX-10 blue & newer red pcb, CX-10A, CX11, CX-10 green pcb, DM007, Floureon FX-10, JXD 509 (Q282), Q222, Q242 and Q282
 // Last sync with hexfet new_protocols/cx10_nrf24l01.c dated 2015-11-26
 
 #if defined(CX10_NRF24L01_INO)
 
-#include "iface_nrf24l01.h"
+#include "iface_xn297.h"
 
 #define CX10_BIND_COUNT		4360	// 6 seconds
 #define CX10_PACKET_SIZE	15
@@ -46,29 +46,29 @@ enum {
     CX10_DATA
 };
 
-static void __attribute__((unused)) CX10_Write_Packet(uint8_t bind)
+static void __attribute__((unused)) CX10_Write_Packet()
 {
 	uint8_t offset = 0;
 	if(sub_protocol == CX10_BLUE)
 		offset = 4;
-	packet[0] = bind ? 0xAA : 0x55;
+	packet[0] = IS_BIND_IN_PROGRESS ? 0xAA : 0x55;
 	packet[1] = rx_tx_addr[0];
 	packet[2] = rx_tx_addr[1];
 	packet[3] = rx_tx_addr[2];
 	packet[4] = rx_tx_addr[3];
 	// packet[5] to [8] (aircraft id) is filled during bind for blue board
-	uint16_t aileron=map(limit_channel_100(AILERON),servo_min_100,servo_max_100,1000,2000);
-	uint16_t elevator=map(limit_channel_100(ELEVATOR),servo_min_100,servo_max_100,2000,1000);
-	uint16_t throttle=map(limit_channel_100(THROTTLE),servo_min_100,servo_max_100,1000,2000);
-	uint16_t rudder=map(limit_channel_100(RUDDER),servo_min_100,servo_max_100,2000,1000);
+	uint16_t aileron= convert_channel_16b_limit(AILERON ,1000,2000);
+	uint16_t elevator=convert_channel_16b_limit(ELEVATOR,2000,1000);
+	uint16_t throttle=convert_channel_16b_limit(THROTTLE,1000,2000);
+	uint16_t rudder=  convert_channel_16b_limit(RUDDER  ,2000,1000);
     // Channel 5 - flip flag
-	packet[12+offset] = GET_FLAG(Servo_AUX1,CX10_FLAG_FLIP); // flip flag applied on rudder
+	packet[12+offset] = GET_FLAG(CH5_SW,CX10_FLAG_FLIP); 	// flip flag applied on rudder
 
 	// Channel 6 - rate mode is 2 lsb of packet 13
-	if(Servo_data[AUX2] > PPM_MAX_COMMAND)		// rate 3 / headless on CX-10A
+	if(CH6_SW)												// rate 3 / headless on CX-10A
 		flags = 0x02;
 	else
-		if(Servo_data[AUX2] < PPM_MIN_COMMAND)
+		if(Channel_data[CH6] < CHANNEL_MIN_COMMAND)
 			flags = 0x00;									// rate 1
 		else
 			flags = 0x01;									// rate 2
@@ -78,66 +78,66 @@ static void __attribute__((unused)) CX10_Write_Packet(uint8_t bind)
 	switch(sub_protocol)
 	{
 		case CX10_BLUE:
-			flags |= GET_FLAG(!Servo_AUX3, 0x10)	// Channel 7 - picture
-					|GET_FLAG( Servo_AUX4, 0x08);	// Channel 8 - video
+			flags |= GET_FLAG(!CH7_SW, 0x10)				// Channel 7 - picture
+					|GET_FLAG( CH8_SW, 0x08);				// Channel 8 - video
 			break;
-		case Q282:
-		case Q242:
-		case Q222:
+		case F_Q282:
+		case F_Q242:
+		case F_Q222:
 			memcpy(&packet[15], "\x10\x10\xaa\xaa\x00\x00", 6);
 			//FLIP|LED|PICTURE|VIDEO|HEADLESS|RTH|XCAL|YCAL
-			flags2 = GET_FLAG(Servo_AUX1, 0x80)		// Channel 5 - FLIP
-					|GET_FLAG(!Servo_AUX2, 0x40)	// Channel 6 - LED
-					|GET_FLAG(Servo_AUX5, 0x08)		// Channel 9 - HEADLESS
-					|GET_FLAG(Servo_AUX7, 0x04)		// Channel 11 - XCAL
-					|GET_FLAG(Servo_AUX8, 0x02);	// Channel 12 - YCAL or Start/Stop motors on JXD 509
+			flags2 = GET_FLAG(CH5_SW, 0x80)					// Channel 5 - FLIP
+					|GET_FLAG(!CH6_SW, 0x40)				// Channel 6 - LED
+					|GET_FLAG(CH9_SW, 0x08)					// Channel 9 - HEADLESS
+					|GET_FLAG(CH11_SW, 0x04)				// Channel 11 - XCAL
+					|GET_FLAG(CH12_SW, 0x02);				// Channel 12 - YCAL or Start/Stop motors on JXD 509
 	
-			if(sub_protocol==Q242)
+			if(sub_protocol==F_Q242)
 			{
 				flags=2;
-				flags2|= GET_FLAG(Servo_AUX3,0x01)	// Channel 7 - picture
-						|GET_FLAG(Servo_AUX4,0x10);	// Channel 8 - video
+				flags2|= GET_FLAG(CH7_SW,0x01)				// Channel 7 - picture
+						|GET_FLAG(CH8_SW,0x10);				// Channel 8 - video
 				packet[17]=0x00;
 				packet[18]=0x00;
 			}
 			else
-			{ // Q282 & Q222
+			{ // F_Q282 & F_Q222
 				flags=3;									// expert
-				if(Servo_AUX4)						// Channel 8 - Q282 video / Q222 Module 1
+				if(CH8_SW)									// Channel 8 - F_Q282 video / F_Q222 Module 1
 				{
 					if (!(video_state & 0x20)) video_state ^= 0x21;
 				}
 				else
 					if (video_state & 0x20) video_state &= 0x01;
 				flags2 |= video_state
-						|GET_FLAG(Servo_AUX3,0x10);	// Channel 7 - Q282 picture / Q222 Module 2
+						|GET_FLAG(CH7_SW,0x10);				// Channel 7 - F_Q282 picture / F_Q222 Module 2
 			}
-			if(Servo_AUX6)	flags |=0x80;			// Channel 10 - RTH
+			if(CH10_SW)	flags |=0x80;						// Channel 10 - RTH
 			break;
 		case DM007:
 			aileron = 3000 - aileron;
 			//FLIP|MODE|PICTURE|VIDEO|HEADLESS
-			flags2=  GET_FLAG(Servo_AUX3,CX10_FLAG_SNAPSHOT)	// Channel 7 - picture
-					|GET_FLAG(Servo_AUX4,CX10_FLAG_VIDEO);		// Channel 8 - video
-			if(Servo_AUX5)	flags |= CX10_FLAG_HEADLESS;		// Channel 9 - headless
+			flags2=  GET_FLAG(CH7_SW,CX10_FLAG_SNAPSHOT)	// Channel 7 - picture
+					|GET_FLAG(CH8_SW,CX10_FLAG_VIDEO);		// Channel 8 - video
+			if(CH9_SW)	flags |= CX10_FLAG_HEADLESS;		// Channel 9 - headless
 			break;
 		case JC3015_2:
 			aileron = 3000 - aileron;
 			elevator = 3000 - elevator;
 			//FLIP|MODE|LED|DFLIP
-			if(Servo_AUX4)	packet[12] &= ~CX10_FLAG_FLIP;
+			if(CH8_SW)	packet[12] &= ~CX10_FLAG_FLIP;
 		case JC3015_1:
 			//FLIP|MODE|PICTURE|VIDEO
-			flags2=	 GET_FLAG(Servo_AUX3,_BV(3))	// Channel 7
-					|GET_FLAG(Servo_AUX4,_BV(4));	// Channel 8
+			flags2=	 GET_FLAG(CH7_SW,_BV(3))				// Channel 7
+					|GET_FLAG(CH8_SW,_BV(4));				// Channel 8
 			break;
 		case MK33041:
 			elevator = 3000 - elevator;
 			//FLIP|MODE|PICTURE|VIDEO|HEADLESS|RTH
-			flags|=GET_FLAG(Servo_AUX3,_BV(7))	// Channel 7 - picture
-				  |GET_FLAG(Servo_AUX6,_BV(2));	// Channel 10 - rth
-			flags2=GET_FLAG(Servo_AUX4,_BV(0))	// Channel 8 - video
-				  |GET_FLAG(Servo_AUX5,_BV(5));	// Channel 9 - headless
+			flags|=GET_FLAG(CH7_SW,_BV(7))					// Channel 7 - picture
+				  |GET_FLAG(CH10_SW,_BV(2));				// Channel 10 - rth
+			flags2=GET_FLAG(CH8_SW,_BV(0))					// Channel 8 - video
+				  |GET_FLAG(CH9_SW,_BV(5));					// Channel 9 - headless
 			break;
 	}
 	packet[5+offset] = lowByte(aileron);
@@ -151,39 +151,23 @@ static void __attribute__((unused)) CX10_Write_Packet(uint8_t bind)
 	packet[13+offset]=flags;
 	packet[14+offset]=flags2;
 	
-	// Power on, TX mode, 2byte CRC
-	// Why CRC0? xn297 does not interpret it - either 16-bit CRC or nothing
-	XN297_Configure(_BV(NRF24L01_00_EN_CRC) | _BV(NRF24L01_00_CRCO) | _BV(NRF24L01_00_PWR_UP));
-	if (bind)
-		NRF24L01_WriteReg(NRF24L01_05_RF_CH, CX10_RF_BIND_CHANNEL);
-	else
+	// Send
+	if(IS_BIND_DONE)
 	{
-		NRF24L01_WriteReg(NRF24L01_05_RF_CH, hopping_frequency[hopping_frequency_no++]);
+		XN297_Hopping(hopping_frequency_no++);
 		hopping_frequency_no %= CX10_NUM_RF_CHANNELS;
 	}
-	// clear packet status bits and TX FIFO
-	NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);
-	NRF24L01_FlushTx();
-
+	XN297_SetPower();
+	XN297_SetTxRxMode(TX_EN);
 	XN297_WritePayload(packet, packet_length);
-	NRF24L01_SetPower();
 }
 
-static void __attribute__((unused)) CX10_init()
+static void __attribute__((unused)) CX10_RF_init()
 {
-	NRF24L01_Initialize();
-	NRF24L01_SetTxRxMode(TX_EN);
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
 	XN297_SetTXAddr((uint8_t *)"\xcc\xcc\xcc\xcc\xcc", 5);
-	XN297_SetRXAddr((uint8_t *)"\xcc\xcc\xcc\xcc\xcc",5);
-	NRF24L01_FlushTx();
-	NRF24L01_FlushRx();
-	NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);			// Clear data ready, data sent, and retransmit
-	NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);				// No Auto Acknowledgment on all data pipes
-	NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x01);			// Enable data pipe 0 only
-	NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, packet_length);	// rx pipe 0 (used only for blue board)
-    NRF24L01_WriteReg(NRF24L01_05_RF_CH, CX10_RF_BIND_CHANNEL);
-	NRF24L01_SetBitrate(NRF24L01_BR_1M);					// 1Mbps
-	NRF24L01_SetPower();
+	XN297_SetRXAddr((uint8_t *)"\xcc\xcc\xcc\xcc\xcc", packet_length);
+	XN297_RFChannel(CX10_RF_BIND_CHANNEL);
 }
 
 uint16_t CX10_callback()
@@ -197,39 +181,39 @@ uint16_t CX10_callback()
 			}
 			else
 			{
-				CX10_Write_Packet(1);
+				CX10_Write_Packet();
 				bind_counter--;
 			}
 			break;
 		case CX10_BIND2:
-			if( NRF24L01_ReadReg(NRF24L01_07_STATUS) & _BV(NRF24L01_07_RX_DR))
+			// switch to TX mode
+			if( XN297_IsRX() )
 			{ // RX fifo data ready
-				XN297_ReadPayload(packet, packet_length);
-				NRF24L01_SetTxRxMode(TXRX_OFF);
-				NRF24L01_SetTxRxMode(TX_EN);
-				if(packet[9] == 1)
+				debugln("RX");
+				if(XN297_ReadPayload(packet, packet_length) && packet[9] == 1)
 				{
 					BIND_DONE;
+					XN297_SetTxRxMode(TXRX_OFF);
 					phase = CX10_DATA;
+					break;
 				}
 			}
 			else
 			{
-				// switch to TX mode
-				NRF24L01_SetTxRxMode(TXRX_OFF);
-				NRF24L01_FlushTx();
-				NRF24L01_SetTxRxMode(TX_EN);
-				CX10_Write_Packet(1);
-				delayMicroseconds(400);
-				// switch to RX mode
-				NRF24L01_SetTxRxMode(TXRX_OFF);
-				NRF24L01_FlushRx();
-				NRF24L01_SetTxRxMode(RX_EN);
-				XN297_Configure(_BV(NRF24L01_00_EN_CRC) | _BV(NRF24L01_00_CRCO) | _BV(NRF24L01_00_PWR_UP) | _BV(NRF24L01_00_PRIM_RX));
+				XN297_SetTxRxMode(TXRX_OFF);
+				CX10_Write_Packet();
+				// wait for packet to be sent
+				while( !XN297_IsPacketSent());					//delayMicroseconds(400);
 			}
+			// switch to RX mode
+			XN297_SetTxRxMode(TXRX_OFF);
+			XN297_SetTxRxMode(RX_EN);
 			break;
 		case CX10_DATA:
-			CX10_Write_Packet(0);
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(packet_period);
+			#endif
+			CX10_Write_Packet();
 			break;
 	}
 	return packet_period;
@@ -238,12 +222,12 @@ uint16_t CX10_callback()
 static void __attribute__((unused)) CX10_initialize_txid()
 {
 	rx_tx_addr[1]%= 0x30;
-	if(sub_protocol&0x08)	//Q2X2 protocols
+	if(sub_protocol&0x08)	//F_Q2X2 protocols
 	{
-		uint8_t offset=0;	//Q282
-		if(sub_protocol==Q242)
+		uint8_t offset=0;	//F_Q282
+		if(sub_protocol==F_Q242)
 			offset=2;
-		if(sub_protocol==Q222)
+		if(sub_protocol==F_Q222)
 			offset=3;
 		for(uint8_t i=0;i<4;i++)
 			hopping_frequency[i]=0x46+2*i+offset;
@@ -257,8 +241,13 @@ static void __attribute__((unused)) CX10_initialize_txid()
 	}
 }
 
-uint16_t initCX10(void)
+void CX10_init(void)
 {
+	BIND_IN_PROGRESS;	// autobind protocol
+	
+	if(protocol == PROTO_Q2X2)
+		sub_protocol|=0x08;		// Increase the number of sub_protocols for CX-10
+	
 	if(sub_protocol==CX10_BLUE)
 	{
 		packet_length = CX10A_PACKET_SIZE;
@@ -272,7 +261,7 @@ uint16_t initCX10(void)
 	}
 	else
 	{
-		if(sub_protocol&0x08)	//Q2X2 protocols
+		if(sub_protocol&0x08)	//F_Q2X2 protocols
 			packet_length = Q2X2_PACKET_SIZE;
 		else
 		    packet_length = CX10_PACKET_SIZE;
@@ -281,9 +270,7 @@ uint16_t initCX10(void)
 		bind_counter = CX10_BIND_COUNT;
 	}
 	CX10_initialize_txid();
-	CX10_init();
-	BIND_IN_PROGRESS;	// autobind protocol
-	return CX10_INITIAL_WAIT+packet_period;
+	CX10_RF_init();
 }
 
 #endif

Multiprotocol/CYRF6936_SPI.ino

@@ -78,14 +78,29 @@ uint8_t CYRF_Reset()
 */
 void CYRF_GetMfgData(uint8_t data[])
 {
+#ifndef FORCE_CYRF_ID
+	if(eeprom_read_byte((EE_ADDR)EEPROM_CID_INIT_OFFSET)==0xf0)
+	{//read Cyrf ID from EEPROM
+		for(uint8_t i=0;i<6;i++)
+			data[i] = eeprom_read_byte((EE_ADDR)EEPROM_CID_OFFSET+i);
+	}
+	else
+	{//read Cyrf ID and store it EEPROM
 		/* Fuses power on */
 		CYRF_WriteRegister(CYRF_25_MFG_ID, 0xFF);
 
 		CYRF_ReadRegisterMulti(CYRF_25_MFG_ID, data, 6);
+		for(uint8_t i=0;i<6;i++)
+			eeprom_write_byte((EE_ADDR)EEPROM_CID_OFFSET+i, data[i]);
+		eeprom_write_byte((EE_ADDR)EEPROM_CID_INIT_OFFSET, 0xf0);
 
 		/* Fuses power off */
 		CYRF_WriteRegister(CYRF_25_MFG_ID, 0x00);
 	}
+#else
+	memcpy(data,FORCE_CYRF_ID,6);
+#endif
+}
 
 /*
 * 1 - Tx else Rx
@@ -94,15 +109,17 @@ void CYRF_SetTxRxMode(uint8_t mode)
 {
 	if(mode==TXRX_OFF)
 	{
+		if( protocol!=PROTO_WFLY && protocol!=PROTO_MLINK )
 			CYRF_WriteRegister(CYRF_0F_XACT_CFG, 0x24); // 4=IDLE, 8=TX, C=RX
 		CYRF_WriteRegister(CYRF_0E_GPIO_CTRL,0x00); // XOUT=0 PACTL=0
 	}
 	else
 	{
 		//Set the post tx/rx state
+		if( protocol!=PROTO_WFLY && protocol!=PROTO_MLINK )
 			CYRF_WriteRegister(CYRF_0F_XACT_CFG, mode == TX_EN ? 0x28 : 0x2C); // 4=IDLE, 8=TX, C=RX
 		if(mode == TX_EN)
-#ifdef DSM_BLUE
+#ifdef ORANGE_TX_BLUE
 			CYRF_WriteRegister(CYRF_0E_GPIO_CTRL,0x20); // XOUT=1, PACTL=0
 		else
 			CYRF_WriteRegister(CYRF_0E_GPIO_CTRL,0x80);	// XOUT=0, PACTL=1
@@ -132,8 +149,12 @@ static void CYRF_SetPower_Value(uint8_t power)
 void CYRF_SetPower(uint8_t val)
 {
 	uint8_t power=CYRF_BIND_POWER;
-	if(IS_BIND_DONE_on)
+	if(IS_BIND_DONE)
+		#ifdef CYRF6936_ENABLE_LOW_POWER
 			power=IS_POWER_FLAG_on?CYRF_HIGH_POWER:CYRF_LOW_POWER;
+		#else
+			power=CYRF_HIGH_POWER;
+		#endif
 	if(IS_RANGE_FLAG_on)
 		power=CYRF_RANGE_POWER;
 	power|=val;
@@ -142,15 +163,26 @@ void CYRF_SetPower(uint8_t val)
 		CYRF_WriteRegister(CYRF_03_TX_CFG,power);
 		prev_power=power;
 	}
+
+	#ifdef USE_CYRF6936_CH15_TUNING
+		static uint16_t Channel15=1024;
+		if(Channel15!=Channel_data[CH15])
+		{ // adjust frequency
+			Channel15=Channel_data[CH15]+0x155;	// default value is 0x555 = 0x400 + 0x155
+			CYRF_WriteRegister(CYRF_1B_TX_OFFSET_LSB, Channel15&0xFF);
+			CYRF_WriteRegister(CYRF_1C_TX_OFFSET_MSB, Channel15>>8);
+			Channel15-=0x155;
+		}
+	#endif
 }
 
 /*
 *
 */
-void CYRF_ConfigCRCSeed(uint16_t crc)
+void CYRF_ConfigCRCSeed(uint16_t crc_seed)
 {
-	CYRF_WriteRegister(CYRF_15_CRC_SEED_LSB,crc & 0xff);
-	CYRF_WriteRegister(CYRF_16_CRC_SEED_MSB,crc >> 8);
+	CYRF_WriteRegister(CYRF_15_CRC_SEED_LSB,crc_seed & 0xff);
+	CYRF_WriteRegister(CYRF_16_CRC_SEED_MSB,crc_seed >> 8);
 }
 /*
 * these are the recommended sop codes from Cyrpress
@@ -195,9 +227,9 @@ void CYRF_ReadDataPacketLen(uint8_t dpbuffer[], uint8_t length)
 static void CYRF_WriteDataPacketLen(const uint8_t dpbuffer[], uint8_t len)
 {
 	CYRF_WriteRegister(CYRF_01_TX_LENGTH, len);
-	CYRF_WriteRegister(CYRF_02_TX_CTRL, 0x40);
+	CYRF_WriteRegister(CYRF_02_TX_CTRL, 0x43);	// 0x40
 	CYRF_WriteRegisterMulti(CYRF_20_TX_BUFFER, dpbuffer, len);
-	CYRF_WriteRegister(CYRF_02_TX_CTRL, 0xBF);
+	CYRF_WriteRegister(CYRF_02_TX_CTRL, 0x83);	// 0xBF
 }
 
 void CYRF_WriteDataPacket(const uint8_t dpbuffer[])
@@ -237,7 +269,7 @@ void CYRF_FindBestChannels(uint8_t *channels, uint8_t len, uint8_t minspace, uin
 	delayMilliseconds(1);
 	for(i = 0; i < NUM_FREQ; i++)
 	{
-		CYRF_ConfigRFChannel(i);
+		CYRF_ConfigRFChannel(protocol==PROTO_LOSI?i|1:i);
 		delayMicroseconds(270);					//slow channel require 270usec for synthesizer to settle
         if( !(CYRF_ReadRegister(CYRF_05_RX_CTRL) & 0x80)) {
             CYRF_WriteRegister(CYRF_05_RX_CTRL, 0x80); //Prepare to receive
@@ -263,7 +295,7 @@ void CYRF_FindBestChannels(uint8_t *channels, uint8_t len, uint8_t minspace, uin
 	}
 	CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x20);		// Abort RX operation
 	CYRF_SetTxRxMode(TX_EN);
-	CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x20);		// Clear abort RX
+	CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x00);		// Clear abort RX
 }
 
 #if defined(DEVO_CYRF6936_INO) || defined(J6PRO_CYRF6936_INO)
@@ -292,6 +324,7 @@ const uint8_t PROGMEM DEVO_j6pro_sopcodes[][8] = {
 #endif
 };
 #endif
+
 static void __attribute__((unused)) CYRF_PROGMEM_ConfigSOPCode(const uint8_t *data)
 {
 	uint8_t code[8];
@@ -299,4 +332,69 @@ static void __attribute__((unused)) CYRF_PROGMEM_ConfigSOPCode(const uint8_t *da
 		code[i]=pgm_read_byte_near(&data[i]);
 	CYRF_ConfigSOPCode(code);
 }
+
+//CYRF GFSK 1Mb functions
+const uint8_t PROGMEM CYRF_GFSK1M_init_vals[][2] = {
+	{CYRF_02_TX_CTRL, 0x00},		// transmit err & complete interrupts disabled
+	{CYRF_05_RX_CTRL, 0x00},		// receive err & complete interrupts disabled
+	{CYRF_28_CLK_EN, 0x02},			// Force Receive Clock Enable, MUST be set
+	{CYRF_32_AUTO_CAL_TIME, 0x3c},	// must be set to 3C
+	{CYRF_35_AUTOCAL_OFFSET, 0x14},	// must be  set to 14
+	{CYRF_06_RX_CFG, 0x48},			// LNA manual control, Rx Fast Turn Mode Enable
+	{CYRF_1B_TX_OFFSET_LSB, 0x00},	// Tx frequency offset LSB
+	{CYRF_1C_TX_OFFSET_MSB, 0x00},	// Tx frequency offset MSB
+	{CYRF_0F_XACT_CFG, 0x24},		// Force End State, transaction end state = idle
+	{CYRF_03_TX_CFG, 0x00},			// GFSK mode
+	{CYRF_12_DATA64_THOLD, 0x0a},	// 64 Chip Data PN Code Correlator Threshold = 10
+	{CYRF_0F_XACT_CFG, 0x04},		// Transaction End State = idle
+	{CYRF_39_ANALOG_CTRL, 0x01},	// synth setting time for all channels is the same as for slow channels
+	{CYRF_0F_XACT_CFG, 0x24},		//Force IDLE
+	{CYRF_29_RX_ABORT, 0x00},		//Clear RX abort
+	{CYRF_12_DATA64_THOLD, 0x0a},	//set pn correlation threshold
+	{CYRF_10_FRAMING_CFG, 0x4a},	//set sop len and threshold
+	{CYRF_29_RX_ABORT, 0x0f},		//Clear RX abort?
+	{CYRF_03_TX_CFG, 0x00},			// GFSK mode
+	{CYRF_10_FRAMING_CFG, 0x4a},	// 0b11000000 //set sop len and threshold
+	{CYRF_1F_TX_OVERRIDE, 0x04},	//disable tx CRC
+	{CYRF_1E_RX_OVERRIDE, 0x14},	//disable rx crc
+	{CYRF_14_EOP_CTRL, 0x00},		//set EOP sync == 0
+};
+static void __attribute__((unused)) CYRF_GFSK1M_Init(uint8_t payload_length, uint8_t preamble_len)
+{
+	for(uint8_t i = 0; i < sizeof(CYRF_GFSK1M_init_vals) / 2; i++)	
+		CYRF_WriteRegister(pgm_read_byte_near(&CYRF_GFSK1M_init_vals[i][0]), pgm_read_byte_near(&CYRF_GFSK1M_init_vals[i][1]));
+
+
+	CYRF_WriteRegister(CYRF_01_TX_LENGTH, payload_length);
+	
+	CYRF_WritePreamble(0xAAAA00 | preamble_len);
+
+	CYRF_SetPower(0x00);
+	
+	CYRF_SetTxRxMode(TX_EN);
+}
+static void __attribute__((unused)) CYRF_GFSK1M_SendPayload(uint8_t *buffer, uint8_t len)
+{
+	uint8_t send=len>16 ? 16 : len;
+	CYRF_WriteRegister(CYRF_02_TX_CTRL, 0x40);
+	CYRF_WriteRegisterMulti(CYRF_20_TX_BUFFER, buffer, send);			// Fill the buffer with 16 bytes max
+	CYRF_WriteRegister(CYRF_02_TX_CTRL, 0x80);							// Start send
+	buffer += send;
+	len -= send;
+
+	while(len>8)
+	{
+		while((CYRF_ReadRegister(CYRF_04_TX_IRQ_STATUS)&0x10) == 0);	// Wait that half of the buffer is empty
+		CYRF_WriteRegisterMulti(CYRF_20_TX_BUFFER, buffer, 8);			// Add 8 bytes to the buffer
+		buffer+=8;
+		len-=8;
+	}
+
+	if(len)
+	{
+		while((CYRF_ReadRegister(CYRF_04_TX_IRQ_STATUS)&0x10) == 0);	// Wait that half of the buffer is empty
+		CYRF_WriteRegisterMulti(CYRF_20_TX_BUFFER, buffer, len);		// Add the remaining bytes to the buffer
+	}
+}
+#define CYRF_GFSK1M_SetPower() CYRF_SetPower(0x00)
 #endif

Multiprotocol/Convert.ino

@@ -12,19 +12,102 @@
  You should have received a copy of the GNU General Public License
  along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 /************************/
 /**  Convert routines  **/
 /************************/
-// Channel value is converted to 8bit values full scale
-uint8_t convert_channel_8b(uint8_t num)
+// Reverse a channel and store it
+void reverse_channel(uint8_t num)
 {
-	return (uint8_t) (map(limit_channel_100(num),servo_min_100,servo_max_100,0,255));	
+	uint16_t val=2048-Channel_data[num];
+	if(val>=2048) val=2047;
+	Channel_data[num]=val;
 }
 
-// Channel value is converted to 8bit values to provided values scale
-uint8_t convert_channel_8b_scale(uint8_t num,uint8_t min,uint8_t max)
+// Channel value is converted to ppm 860<->2140 -125%<->+125% and 988<->2012 -100%<->+100%
+uint16_t convert_channel_ppm(uint8_t num)
 {
-	return (uint8_t) (map(limit_channel_100(num),servo_min_100,servo_max_100,min,max));	
+	uint16_t val=Channel_data[num];
+	return (((val<<2)+val)>>3)+860;				//value range 860<->2140 -125%<->+125%
+}
+
+// Channel value 100% is converted to 10bit values 0<->1023
+uint16_t convert_channel_10b(uint8_t num, bool failsafe)
+{
+	uint16_t val;
+	#ifdef FAILSAFE_ENABLE
+	if(failsafe)
+		val=Failsafe_data[num];				// 0<->2047
+	else
+	#endif
+		val=Channel_data[num];
+	val=((val<<2)+val)>>3;
+	if(val<=128) return 0;
+	if(val>=1152) return 1023;
+	return val-128;
+}
+
+// Channel value 100% is converted to 8bit values 0<->255
+uint8_t convert_channel_8b(uint8_t num)
+{
+	uint16_t val=Channel_data[num];
+	val=((val<<2)+val)>>5;
+	if(val<=32) return 0;
+	if(val>=288) return 255;
+	return val-32;
+}
+
+// Channel value 100% is converted to 8b with deadband
+uint8_t convert_channel_8b_limit_deadband(uint8_t num,uint8_t min,uint8_t mid, uint8_t max, uint8_t deadband)
+{
+	uint16_t val=limit_channel_100(num);		// 204<->1844
+	uint16_t db_low=CHANNEL_MID-deadband, db_high=CHANNEL_MID+deadband; // 1024+-deadband
+	int32_t calc;
+	uint8_t out;
+	if(val>=db_low && val<=db_high)
+		return mid;
+	else if(val<db_low)
+	{
+		val-=CHANNEL_MIN_100;
+		calc=mid-min;
+		calc*=val;
+		calc/=(db_low-CHANNEL_MIN_100);
+		out=calc;
+		out+=min;
+	}
+	else
+	{
+		val-=db_high;
+		calc=max-mid;
+		calc*=val;
+		calc/=(CHANNEL_MAX_100-db_high+1);
+		out=calc;
+		out+=mid;
+		if(max>min) out++; else out--;
+	}
+	return out;
+}
+
+// Channel value 100% is converted to value scaled
+int16_t convert_channel_16b_limit(uint8_t num,int16_t min,int16_t max)
+{
+	int32_t val=limit_channel_100(num);			// 204<->1844
+	val=(val-CHANNEL_MIN_100)*(max-min)/(CHANNEL_MAX_100-CHANNEL_MIN_100)+min;
+	return (uint16_t)val;
+}
+
+// Channel value -125%<->125% is scaled to 16bit value with no limit
+int16_t convert_channel_16b_nolimit(uint8_t num, int16_t min, int16_t max, bool failsafe)
+{
+	int32_t val;
+	#ifdef FAILSAFE_ENABLE
+	if(failsafe)
+		val=Failsafe_data[num];				// 0<->2047
+	else
+	#endif
+		val=Channel_data[num];				// 0<->2047
+	val=(val-CHANNEL_MIN_100)*(max-min)/(CHANNEL_MAX_100-CHANNEL_MIN_100)+min;
+	return (uint16_t)val;
 }
 
 // Channel value is converted sign + magnitude 8bit values
@@ -35,34 +118,59 @@ uint8_t convert_channel_s8b(uint8_t num)
 	return (ch < 128 ? 127-ch : ch);	
 }
 
-// Channel value is converted to 10bit values
-uint16_t convert_channel_10b(uint8_t num)
+// Channel value is limited to 100%
+uint16_t limit_channel_100(uint8_t num)
 {
-	return (uint16_t) (map(limit_channel_100(num),servo_min_100,servo_max_100,1,1023));
-}
-
-// Channel value is multiplied by 1.5
-uint16_t convert_channel_frsky(uint8_t num)
-{
-	return Servo_data[num] + Servo_data[num]/2;
+	if(Channel_data[num]>=CHANNEL_MAX_100)
+		return CHANNEL_MAX_100;
+	if (Channel_data[num]<=CHANNEL_MIN_100)
+		return CHANNEL_MIN_100;
+	return Channel_data[num];
 }
 
 // Channel value is converted for HK310
 void convert_channel_HK310(uint8_t num, uint8_t *low, uint8_t *high)
 {
-	uint16_t temp=0xFFFF-(4*Servo_data[num])/3;
+	uint16_t temp=0xFFFF-(3440+((Channel_data[num]*5)>>1))/3;
 	*low=(uint8_t)(temp&0xFF);
 	*high=(uint8_t)(temp>>8);
 }
 
-// Channel value is limited to PPM_100
-uint16_t limit_channel_100(uint8_t ch)
+#ifdef FAILSAFE_ENABLE
+// Failsafe value is converted for HK310
+void convert_failsafe_HK310(uint8_t num, uint8_t *low, uint8_t *high)
 {
-	if(Servo_data[ch]>servo_max_100)
-		return servo_max_100;
-	else
-		if (Servo_data[ch]<servo_min_100)
-			return servo_min_100;
-	return Servo_data[ch];
+	uint16_t temp=0xFFFF-(3440+((Failsafe_data[num]*5)>>1))/3;
+	*low=(uint8_t)(temp&0xFF);
+	*high=(uint8_t)(temp>>8);
+}
+#endif
+
+// Channel value for FrSky (PPM is multiplied by 1.5)
+uint16_t convert_channel_frsky(uint8_t num)
+{
+	uint16_t val=Channel_data[num];
+	return ((val*15)>>4)+1290;
 }
 
+// 0-2047, 0 = 817, 1024 = 1500, 2047 = 2182
+//64=860,1024=1500,1984=2140//Taranis 125%
+static uint16_t  __attribute__((unused)) FrSkyX_scaleForPXX( uint8_t i, uint8_t num_chan=8)
+{	//mapped 860,2140(125%) range to 64,1984(PXX values);
+	uint16_t chan_val=convert_channel_frsky(i)-1226;
+	if(i>=num_chan) chan_val|=2048;   // upper channels offset
+	return chan_val;
+}
+
+#ifdef FAILSAFE_ENABLE
+static uint16_t  __attribute__((unused)) FrSkyX_scaleForPXX_FS( uint8_t i, uint8_t num_chan=8)
+{	//mapped 1,2046(125%) range to 64,1984(PXX values);
+	uint16_t chan_val=((Failsafe_data[i]*15)>>4)+64;
+	if(Failsafe_data[i]==FAILSAFE_CHANNEL_NOPULSES)
+		chan_val=FAILSAFE_CHANNEL_NOPULSES;
+	else if(Failsafe_data[i]==FAILSAFE_CHANNEL_HOLD)
+		chan_val=FAILSAFE_CHANNEL_HOLD;
+	if(i>=num_chan) chan_val|=2048;   // upper channels offset
+	return chan_val;
+}
+#endif

Multiprotocol/Corona_cc2500.ino

@@ -0,0 +1,300 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(CORONA_CC2500_INO)
+
+#include "iface_cc2500.h"
+
+//#define CORONA_FORCE_ID
+
+#define CORONA_RF_NUM_CHANNELS	3
+#define CORONA_ADDRESS_LENGTH	4
+#define CORONA_BIND_CHANNEL_V1	0xD1	// also Flydream V3
+#define CORONA_BIND_CHANNEL_V2	0xB8
+#define CORONA_COARSE			0x00
+#define FDV3_BIND_PERIOD		5000
+#define FDV3_CHANNEL_PERIOD		4000
+
+const PROGMEM uint8_t CORONA_init_values[] = {
+  /* 00 */ 0x29, 0x2E, 0x06, 0x07, 0xD3, 0x91, 0xFF, 0x04,
+  /* 08 */ 0x05, 0x00, CORONA_BIND_CHANNEL_V1, 0x06, 0x00, 0x5C, 0x4E, 0xC4 + CORONA_COARSE,
+  /* 10 */ 0x5B, 0xF8, 0x03, 0x23, 0xF8, 0x47, 0x07, 0x30,
+  /* 18 */ 0x18, 0x16, 0x6C, 0x43, 0x40, 0x91, 0x87, 0x6B,
+  /* 20 */ 0xF8, 0x56, 0x10, 0xA9, 0x0A, 0x00, 0x11, 0x41,
+  /* 28 */ 0x00, 0x59, 0x7F, 0x3F, 0x81, 0x35, 0x0B
+};
+
+uint8_t fdv3_id_send;
+
+static void __attribute__((unused)) CORONA_rf_init()
+{
+	CC2500_Strobe(CC2500_SIDLE);
+
+	for (uint8_t i = 0; i <= 0x2E; ++i)
+		CC2500_WriteReg(i, pgm_read_byte_near(&CORONA_init_values[i]));
+	if(sub_protocol==COR_V2)
+	{
+		CC2500_WriteReg(CC2500_0A_CHANNR, CORONA_BIND_CHANNEL_V2);
+		CC2500_WriteReg(CC2500_0E_FREQ1, 0x80);
+		CC2500_WriteReg(CC2500_0F_FREQ0, 0x00 + CORONA_COARSE);
+		CC2500_WriteReg(CC2500_15_DEVIATN, 0x50);
+		CC2500_WriteReg(CC2500_17_MCSM1, 0x00);
+	    CC2500_WriteReg(CC2500_1B_AGCCTRL2, 0x67);
+		CC2500_WriteReg(CC2500_1C_AGCCTRL1, 0xFB);
+		CC2500_WriteReg(CC2500_1D_AGCCTRL0, 0xDC);
+	}
+	else if(sub_protocol==FD_V3)
+	{
+		// Flydream receiver captures have deviation 50, tx captures show 47
+		CC2500_WriteReg(CC2500_15_DEVIATN, 0x50);
+	}
+	
+	CC2500_WriteReg(CC2500_0C_FSCTRL0, option);
+
+	//not sure what they are doing to the PATABLE since basically only the first byte is used and it's only 8 bytes long. So I think they end up filling the PATABLE fully with 0xFF
+	CC2500_WriteRegisterMulti(CC2500_3E_PATABLE,(const uint8_t *)"\x08\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 13);
+
+	CC2500_SetTxRxMode(TX_EN);
+	CC2500_SetPower();
+}
+
+// Generate id and hopping freq
+static void __attribute__((unused)) CORONA_TXID_init()
+{
+	#ifdef CORONA_FORCE_ID
+		// Example of ID and channels taken from dumps
+		switch(sub_protocol)
+		{
+			case COR_V1:
+				memcpy((void *)rx_tx_addr,(void *)"\x1F\xFE\x6C\x35",CORONA_ADDRESS_LENGTH);
+				memcpy((void *)hopping_frequency,(void *)"\x17\x0D\x03\x49",CORONA_RF_NUM_CHANNELS+1);
+				break;
+			case COR_V2:
+				memcpy((void *)rx_tx_addr,(void *)"\xFE\xFE\x02\xFB",CORONA_ADDRESS_LENGTH);
+				memcpy((void *)hopping_frequency,(void *)"\x14\x3D\x35",CORONA_RF_NUM_CHANNELS);
+			case FD_V3:
+				memcpy((void *)rx_tx_addr,(void *)"\x02\xFA\x38\x38",CORONA_ADDRESS_LENGTH);
+				memcpy((void *)hopping_frequency,(void *)"\x71\xB9\x30",CORONA_RF_NUM_CHANNELS);
+				break;
+	}
+	#else
+		// From dumps channels are anything between 0x00 and 0xC5 on V1.
+		// But 0x00 and 0xB8 should be avoided on V2 since they are used for bind.
+		// Below code make sure channels are between 0x02 and 0xA0, spaced with
+		// a minimum of 2 and not ordered (RX only use the 1st channel unless there is an issue).
+		// Extra hopping frequency used for Flydream V3 id packets.
+		uint8_t order=rx_tx_addr[3]&0x03;
+		for(uint8_t i=0; i<CORONA_RF_NUM_CHANNELS+1; i++)
+			hopping_frequency[i^order]=2+rx_tx_addr[3-i]%39+(i<<5)+(i<<3);
+
+		if(sub_protocol!=FD_V3)
+		{
+			// ID looks random but on the 15 V1 dumps they all show the same odd/even rule
+			if(rx_tx_addr[3]&0x01)
+			{	// If [3] is odd then [0] is odd and [2] is even 
+				rx_tx_addr[0]|=0x01;
+				rx_tx_addr[2]&=0xFE;
+			}
+			else
+			{	// If [3] is even then [0] is even and [2] is odd 
+				rx_tx_addr[0]&=0xFE;
+				rx_tx_addr[2]|=0x01;
+			}
+			rx_tx_addr[1]=0xFE;			// Always FE in the dumps of V1 and V2
+		}
+		else
+		{
+			rx_tx_addr[1]=0xFA;			// Always FA for Flydream V3
+			rx_tx_addr[3]=hopping_frequency[CORONA_RF_NUM_CHANNELS];	// channel used for id/freq packets
+		}
+	#endif
+}
+
+static uint16_t __attribute__((unused)) CORONA_build_bind_pkt()
+{
+	if(sub_protocol==COR_V1)
+	{	// V1
+		if(bind_counter&1)
+		{ // Send TX ID
+			packet[0]=0x04;		// 5 bytes to follow
+			for(uint8_t i=0; i<CORONA_ADDRESS_LENGTH; i++)
+				packet[i+1]=rx_tx_addr[i];
+			packet[5]=0xCD;		// Unknown but seems to be always the same value for V1
+			return 3689;
+		}
+		else
+		{ // Send hopping freq
+			packet[0]=0x03;		// 4 bytes to follow
+			for(uint8_t i=0; i<CORONA_RF_NUM_CHANNELS+1; i++)
+				packet[i+1]=hopping_frequency[i];
+			// Only the first 3 channels of hopping_frequency used for data
+			return 3438;
+		}
+	}
+	else
+	{	// V2 and FDV3
+		packet[0]=0x04;		// 5 bytes to follow
+		for(uint8_t i=0; i<CORONA_ADDRESS_LENGTH; i++)
+			packet[i+1]=rx_tx_addr[i];
+		packet[5]=0x00;		// Unknown but seems to be always the same value for V2 and FDV3
+		if(sub_protocol==FD_V3)
+			return FDV3_BIND_PERIOD;
+		else
+			return 26791;
+	}
+}
+
+// 8 Channels with direct values from PPM
+static uint16_t __attribute__((unused)) CORONA_build_packet()
+{
+	CC2500_SetPower();
+	if(state && sub_protocol==COR_V2)
+	{	// Send identifier packet for 2.65sec. This is how the RX learns the hopping table after a bind. Why it's not part of the bind like V1 is a mistery...
+		// Set channel
+		CC2500_WriteReg(CC2500_0A_CHANNR, 0x00);
+		state--;
+		packet[0]=0x07;		// 8 bytes to follow
+		// Send hopping freq
+		for(uint8_t i=0; i<CORONA_RF_NUM_CHANNELS; i++)
+			packet[i+1]=hopping_frequency[i];
+		// Send TX ID
+		for(uint8_t i=0; i<CORONA_ADDRESS_LENGTH; i++)
+			packet[i+4]=rx_tx_addr[i];
+		packet[8]=0;
+		return 6647;
+	}
+
+	// Flydream every fourth packet is identifier packet and is on channel number
+	// that is last byte of rx_tx_addr
+	if (fdv3_id_send)
+	{
+		fdv3_id_send = 0;
+		CC2500_WriteReg(CC2500_0A_CHANNR, rx_tx_addr[CORONA_ADDRESS_LENGTH-1]);
+		packet[0] = 0x07;   // 8 bytes to follow
+		// Send TX ID
+		for(uint8_t i = 0; i < CORONA_ADDRESS_LENGTH; i++)
+			packet[i+1] = rx_tx_addr[i];
+		// Send hopping freq
+		for(uint8_t i = 0; i < CORONA_RF_NUM_CHANNELS; i++)
+			packet[i+1+CORONA_ADDRESS_LENGTH] = hopping_frequency[i];
+		packet[8] = 0;
+		return 2*FDV3_CHANNEL_PERIOD;  // extra delay after id packet according to captures
+	}
+
+	// Set RF channel
+	CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency[hopping_frequency_no]);
+
+	// Build packet
+	packet[0] = 0x10;   // 17 bytes to follow
+
+	// Channels
+	memset(packet+9, 0x00, 4);
+	for (uint8_t i=0; i<8; i++)
+	{ // Channel values are packed
+		uint16_t val=convert_channel_ppm(i);
+		packet[i+1] = val;
+		packet[9 + (i>>1)] |= (i&0x01)?(val>>4)&0xF0:(val>>8)&0x0F;
+	}
+
+	// TX ID
+	for (uint8_t i=0; i < CORONA_ADDRESS_LENGTH; i++)
+		packet[i+13] = rx_tx_addr[i];
+
+	packet[17] = 0x00;
+
+	if (sub_protocol!=FD_V3)
+	{
+		// Packet period is based on hopping
+		switch (hopping_frequency_no)
+		{
+			case 0:
+				packet_period = sub_protocol == COR_V1
+				? 4991
+				: 4248;
+				break;
+			case 1: 
+				packet_period = sub_protocol == COR_V1
+				? 4991
+				: 4345;
+				break;
+			case 2: 
+				packet_period = sub_protocol == COR_V1
+				? 12520
+				: 13468;
+				if (sub_protocol == COR_V2)
+					packet[17] = 0x03;
+				break;
+		}
+	}
+	hopping_frequency_no++;
+
+	if (sub_protocol == FD_V3)
+	{
+		if (hopping_frequency_no == CORONA_RF_NUM_CHANNELS)
+		{
+			fdv3_id_send = 1;
+			packet_period = 6000; // extra delay before id packet according to captures
+		}
+		else
+			packet_period = FDV3_CHANNEL_PERIOD;
+	}
+
+	hopping_frequency_no %= CORONA_RF_NUM_CHANNELS;
+	return packet_period;
+}
+
+uint16_t CORONA_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(22000);
+	#endif
+	// Tune frequency if it has been changed
+	CC2500_SetFreqOffset();
+
+	if(IS_BIND_IN_PROGRESS)
+	{
+		if (bind_counter-- == 0) BIND_DONE;
+		packet_period=CORONA_build_bind_pkt();
+	}
+	else
+		packet_period=CORONA_build_packet();
+
+	// Send packet
+	CC2500_WriteData(packet, packet[0]+2);
+	return packet_period;
+}
+
+void CORONA_init()
+{
+	switch(sub_protocol)
+	{
+		case COR_V1:
+			bind_counter=1400;		// Stay in bind mode for 5s
+			break;
+		case COR_V2:
+			bind_counter=187;		// Stay in bind mode for 5s
+			break;
+		case FD_V3:
+			bind_counter = 2000;	// Stay in bind mode for 10s
+			break;
+	}
+	state=400;					// Used by V2 to send RF channels + ID for 2.65s at startup
+	hopping_frequency_no=0;
+	fdv3_id_send = 0;
+	CORONA_TXID_init();
+	CORONA_rf_init();
+}
+
+#endif

Multiprotocol/DM002_nrf24l01.ino

@@ -0,0 +1,142 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// compatible with DM002
+
+#if defined(DM002_NRF24L01_INO)
+
+#include "iface_xn297.h"
+
+#define DM002_PACKET_PERIOD		6100 // Timeout for callback in uSec
+#define DM002_INITIAL_WAIT		500
+#define DM002_PACKET_SIZE		12   // packets have 12-byte payload
+#define DM002_RF_BIND_CHANNEL	0x27
+#define DM002_BIND_COUNT		655  // 4 seconds
+
+enum DM002_FLAGS {
+    // flags going to packet[9]
+    DM002_FLAG_FLIP		= 0x01, 
+    DM002_FLAG_LED		= 0x02, 
+    DM002_FLAG_MEDIUM	= 0x04, 
+    DM002_FLAG_HIGH		= 0x08, 
+    DM002_FLAG_RTH		= 0x10,
+    DM002_FLAG_HEADLESS	= 0x20,
+    DM002_FLAG_CAMERA1	= 0x40,
+    DM002_FLAG_CAMERA2	= 0x80,
+};
+
+static void __attribute__((unused)) DM002_send_packet()
+{
+	memcpy(packet+5,(uint8_t *)"\x00\x7F\x7F\x7F\x00\x00\x00",7);
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[0] = 0xAA;
+		packet[1] = rx_tx_addr[0]; 
+		packet[2] = rx_tx_addr[1];
+		packet[3] = rx_tx_addr[2];
+		packet[4] = rx_tx_addr[3];
+	}
+	else
+	{
+		packet[0]=0x55;
+		// Throttle : 0 .. 200
+		packet[1]=convert_channel_16b_limit(THROTTLE,0,200);
+		// Other channels min 0x57, mid 0x7F, max 0xA7
+		packet[2] = convert_channel_16b_limit(RUDDER,0x57,0xA7);
+		packet[3] = convert_channel_16b_limit(AILERON, 0x57,0xA7);
+		packet[4] = convert_channel_16b_limit(ELEVATOR, 0xA7, 0x57);
+		// Features
+		packet[9] =   GET_FLAG(CH5_SW,DM002_FLAG_FLIP)
+					| GET_FLAG(!CH6_SW,DM002_FLAG_LED)
+					| GET_FLAG(CH7_SW,DM002_FLAG_CAMERA1)
+					| GET_FLAG(CH8_SW,DM002_FLAG_CAMERA2)
+					| GET_FLAG(CH9_SW,DM002_FLAG_HEADLESS)
+					| GET_FLAG(CH10_SW,DM002_FLAG_RTH)
+					| GET_FLAG(!CH11_SW,DM002_FLAG_HIGH);
+		// Packet counter
+		if(packet_count&0x03)
+		{
+			packet_count++;
+			hopping_frequency_no++;
+			hopping_frequency_no&=4;
+		}
+		packet_count&=0x0F;
+		packet[10] = packet_count;
+		packet_count++;
+		XN297_Hopping(hopping_frequency_no);
+	}
+	//CRC
+	for(uint8_t i=0;i<DM002_PACKET_SIZE-1;i++)
+		packet[11]+=packet[i];
+	
+	//Send
+	XN297_SetPower();
+	XN297_SetTxRxMode(TX_EN);
+	XN297_WritePayload(packet, DM002_PACKET_SIZE);
+}
+
+static void __attribute__((unused)) DM002_RF_init()
+{
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
+	XN297_SetTXAddr((uint8_t *)"\x26\xA8\x67\x35\xCC", 5);
+	XN297_RFChannel(DM002_RF_BIND_CHANNEL);
+}
+
+uint16_t DM002_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(DM002_PACKET_PERIOD);
+	#endif
+	if (bind_counter)
+	{
+		bind_counter--;
+		if (bind_counter == 0)
+		{
+			BIND_DONE;
+			XN297_SetTXAddr(rx_tx_addr, 5);
+		}
+	}
+	DM002_send_packet();
+	return	DM002_PACKET_PERIOD;
+}
+
+static void __attribute__((unused)) DM002_initialize_txid()
+{
+	// Only 3 IDs/RFs are available, RX_NUM is used to switch between them
+	switch(rx_tx_addr[3]%3)
+	{
+		case 0:
+			memcpy(hopping_frequency,(uint8_t *)"\x34\x39\x43\x48",4);
+			memcpy(rx_tx_addr,(uint8_t *)"\x47\x93\x00\x00\xD5",5);
+			break;
+		case 1:
+			memcpy(hopping_frequency,(uint8_t *)"\x35\x39\x3B\x3D",4);
+			memcpy(rx_tx_addr,(uint8_t *)"\xAC\xA1\x00\x00\xD5",5);
+			break;
+		case 2:
+			memcpy(hopping_frequency,(uint8_t *)"\x32\x37\x41\x46",4);
+			memcpy(rx_tx_addr,(uint8_t *)"\x92\x45\x01\x00\xD5",5);
+			break;
+	}
+}
+
+void DM002_init(void)
+{
+	BIND_IN_PROGRESS;	// autobind protocol
+    bind_counter = DM002_BIND_COUNT;
+	DM002_initialize_txid();
+	DM002_RF_init();
+}
+
+#endif

Multiprotocol/DSM.ino

@@ -0,0 +1,188 @@
+#if defined(DSM_CYRF6936_INO) || defined(DSM_RX_CYRF6936_INO)
+
+#include "iface_cyrf6936.h"
+
+uint8_t sop_col;
+
+const uint8_t PROGMEM DSM_pncodes[5][9][8] = {
+	/* Note these are in order transmitted (LSB 1st) */
+	{ /* Row 0 */
+		/* Col 0 */ {0x03, 0xBC, 0x6E, 0x8A, 0xEF, 0xBD, 0xFE, 0xF8},
+		/* Col 1 */ {0x88, 0x17, 0x13, 0x3B, 0x2D, 0xBF, 0x06, 0xD6},
+		/* Col 2 */ {0xF1, 0x94, 0x30, 0x21, 0xA1, 0x1C, 0x88, 0xA9},
+		/* Col 3 */ {0xD0, 0xD2, 0x8E, 0xBC, 0x82, 0x2F, 0xE3, 0xB4},
+		/* Col 4 */ {0x8C, 0xFA, 0x47, 0x9B, 0x83, 0xA5, 0x66, 0xD0},
+		/* Col 5 */ {0x07, 0xBD, 0x9F, 0x26, 0xC8, 0x31, 0x0F, 0xB8},
+		/* Col 6 */ {0xEF, 0x03, 0x95, 0x89, 0xB4, 0x71, 0x61, 0x9D},
+		/* Col 7 */ {0x40, 0xBA, 0x97, 0xD5, 0x86, 0x4F, 0xCC, 0xD1},
+		/* Col 8 */ {0xD7, 0xA1, 0x54, 0xB1, 0x5E, 0x89, 0xAE, 0x86}
+	},
+	{ /* Row 1 */
+		/* Col 0 */ {0x83, 0xF7, 0xA8, 0x2D, 0x7A, 0x44, 0x64, 0xD3},
+		/* Col 1 */ {0x3F, 0x2C, 0x4E, 0xAA, 0x71, 0x48, 0x7A, 0xC9},
+		/* Col 2 */ {0x17, 0xFF, 0x9E, 0x21, 0x36, 0x90, 0xC7, 0x82},
+		/* Col 3 */ {0xBC, 0x5D, 0x9A, 0x5B, 0xEE, 0x7F, 0x42, 0xEB},
+		/* Col 4 */ {0x24, 0xF5, 0xDD, 0xF8, 0x7A, 0x77, 0x74, 0xE7},
+		/* Col 5 */ {0x3D, 0x70, 0x7C, 0x94, 0xDC, 0x84, 0xAD, 0x95},
+		/* Col 6 */ {0x1E, 0x6A, 0xF0, 0x37, 0x52, 0x7B, 0x11, 0xD4},
+		/* Col 7 */ {0x62, 0xF5, 0x2B, 0xAA, 0xFC, 0x33, 0xBF, 0xAF},
+		/* Col 8 */ {0x40, 0x56, 0x32, 0xD9, 0x0F, 0xD9, 0x5D, 0x97}
+	},
+	{ /* Row 2 */
+		/* Col 0 */ {0x40, 0x56, 0x32, 0xD9, 0x0F, 0xD9, 0x5D, 0x97},
+		/* Col 1 */ {0x8E, 0x4A, 0xD0, 0xA9, 0xA7, 0xFF, 0x20, 0xCA},
+		/* Col 2 */ {0x4C, 0x97, 0x9D, 0xBF, 0xB8, 0x3D, 0xB5, 0xBE},
+		/* Col 3 */ {0x0C, 0x5D, 0x24, 0x30, 0x9F, 0xCA, 0x6D, 0xBD},
+		/* Col 4 */ {0x50, 0x14, 0x33, 0xDE, 0xF1, 0x78, 0x95, 0xAD},
+		/* Col 5 */ {0x0C, 0x3C, 0xFA, 0xF9, 0xF0, 0xF2, 0x10, 0xC9},
+		/* Col 6 */ {0xF4, 0xDA, 0x06, 0xDB, 0xBF, 0x4E, 0x6F, 0xB3},
+		/* Col 7 */ {0x9E, 0x08, 0xD1, 0xAE, 0x59, 0x5E, 0xE8, 0xF0},
+		/* Col 8 */ {0xC0, 0x90, 0x8F, 0xBB, 0x7C, 0x8E, 0x2B, 0x8E}
+	},
+	{ /* Row 3 */
+		/* Col 0 */ {0xC0, 0x90, 0x8F, 0xBB, 0x7C, 0x8E, 0x2B, 0x8E},
+		/* Col 1 */ {0x80, 0x69, 0x26, 0x80, 0x08, 0xF8, 0x49, 0xE7},
+		/* Col 2 */ {0x7D, 0x2D, 0x49, 0x54, 0xD0, 0x80, 0x40, 0xC1},
+		/* Col 3 */ {0xB6, 0xF2, 0xE6, 0x1B, 0x80, 0x5A, 0x36, 0xB4},
+		/* Col 4 */ {0x42, 0xAE, 0x9C, 0x1C, 0xDA, 0x67, 0x05, 0xF6},
+		/* Col 5 */ {0x9B, 0x75, 0xF7, 0xE0, 0x14, 0x8D, 0xB5, 0x80},
+		/* Col 6 */ {0xBF, 0x54, 0x98, 0xB9, 0xB7, 0x30, 0x5A, 0x88},
+		/* Col 7 */ {0x35, 0xD1, 0xFC, 0x97, 0x23, 0xD4, 0xC9, 0x88},
+		/* Col 8 */ {0xE1, 0xD6, 0x31, 0x26, 0x5F, 0xBD, 0x40, 0x93}
+// Wrong values used by Orange TX/RX
+//		/* Col 8 */ {0x88, 0xE1, 0xD6, 0x31, 0x26, 0x5F, 0xBD, 0x40}
+	},
+	{ /* Row 4 */
+		/* Col 0 */ {0xE1, 0xD6, 0x31, 0x26, 0x5F, 0xBD, 0x40, 0x93},
+		/* Col 1 */ {0xDC, 0x68, 0x08, 0x99, 0x97, 0xAE, 0xAF, 0x8C},
+		/* Col 2 */ {0xC3, 0x0E, 0x01, 0x16, 0x0E, 0x32, 0x06, 0xBA},
+		/* Col 3 */ {0xE0, 0x83, 0x01, 0xFA, 0xAB, 0x3E, 0x8F, 0xAC},
+		/* Col 4 */ {0x5C, 0xD5, 0x9C, 0xB8, 0x46, 0x9C, 0x7D, 0x84},
+		/* Col 5 */ {0xF1, 0xC6, 0xFE, 0x5C, 0x9D, 0xA5, 0x4F, 0xB7},
+		/* Col 6 */ {0x58, 0xB5, 0xB3, 0xDD, 0x0E, 0x28, 0xF1, 0xB0},
+		/* Col 7 */ {0x5F, 0x30, 0x3B, 0x56, 0x96, 0x45, 0xF4, 0xA1},
+		/* Col 8 */ {0x03, 0xBC, 0x6E, 0x8A, 0xEF, 0xBD, 0xFE, 0xF8}
+	},
+};
+
+static void __attribute__((unused)) DSM_read_code(uint8_t *buf, uint8_t row, uint8_t col, uint8_t len)
+{
+	for(uint8_t i=0;i<len;i++)
+		buf[i]=pgm_read_byte_near( &DSM_pncodes[row][col][i] );
+}
+
+const uint8_t PROGMEM DSM_init_vals[][2] = {
+	{CYRF_02_TX_CTRL, 0x00},				// All TX interrupt disabled
+	{CYRF_05_RX_CTRL, 0x00},				// All RX interrupt disabled
+	{CYRF_28_CLK_EN, 0x02},					// Force receive clock enable
+	{CYRF_32_AUTO_CAL_TIME, 0x3c},			// Default init value
+	{CYRF_35_AUTOCAL_OFFSET, 0x14},			// Default init value
+	{CYRF_26_XTAL_CFG, 0x08},				// Start delay
+	{CYRF_06_RX_CFG, 0x4A},					// LNA enabled, RX override enabled, Fast turn mode enabled, RX is 1MHz below TX
+	{CYRF_1B_TX_OFFSET_LSB, 0x55},			// Default init value
+	{CYRF_1C_TX_OFFSET_MSB, 0x05},			// Default init value
+	{CYRF_39_ANALOG_CTRL, 0x01},			// All slow for synth setting time
+	{CYRF_01_TX_LENGTH, 0x10},				// 16 bytes packet
+	{CYRF_14_EOP_CTRL, 0x02},				// Set EOP Symbol Count to 2
+	{CYRF_12_DATA64_THOLD, 0x0a},			// 64 Chip Data PN corelator threshold, default datasheet value is 0x0E
+	//Below is for bind only
+	{CYRF_03_TX_CFG, 0x38 | CYRF_BIND_POWER}, //64 chip codes, SDR mode
+	{CYRF_10_FRAMING_CFG, 0x4a},			// SOP disabled, no LEN field and SOP correlator of 0x0a but since SOP is disabled...
+	{CYRF_1F_TX_OVERRIDE, 0x04},			// Disable TX CRC, no ACK, use TX synthesizer
+	{CYRF_1E_RX_OVERRIDE, 0x14},			// Disable RX CRC, Force receive data rate, use RX synthesizer
+};
+
+const uint8_t PROGMEM DSM_data_vals[][2] = {
+	{CYRF_29_RX_ABORT, 0x20},				// Abort RX operation in case we are coming from bind
+	{CYRF_0F_XACT_CFG, 0x24},				// Force Idle
+	{CYRF_29_RX_ABORT, 0x00},				// Clear abort RX
+	{CYRF_03_TX_CFG, 0x28 | CYRF_HIGH_POWER}, // 64 chip codes, 8DR mode
+	{CYRF_10_FRAMING_CFG, 0xea},			// SOP enabled, SOP_CODE_ADR 64 chips, Packet len enabled, SOP correlator 0x0A
+	{CYRF_1F_TX_OVERRIDE, 0x00},			// CRC16 enabled, no ACK
+	{CYRF_1E_RX_OVERRIDE, 0x00},			// CRC16 enabled, no ACK
+};
+
+static void __attribute__((unused)) DSM_cyrf_config()
+{
+	for(uint8_t i = 0; i < sizeof(DSM_init_vals) / 2; i++)	
+		CYRF_WriteRegister(pgm_read_byte_near(&DSM_init_vals[i][0]), pgm_read_byte_near(&DSM_init_vals[i][1]));
+	CYRF_WritePreamble(0x333304);
+}
+
+static void __attribute__((unused)) DSM_cyrf_configdata()
+{
+	for(uint8_t i = 0; i < sizeof(DSM_data_vals) / 2; i++)
+		CYRF_WriteRegister(pgm_read_byte_near(&DSM_data_vals[i][0]), pgm_read_byte_near(&DSM_data_vals[i][1]));
+}
+
+static uint8_t __attribute__((unused)) DSM_get_pn_row(uint8_t channel, bool dsmx)
+{
+	if(protocol == PROTO_DSM && sub_protocol == DSMR)
+		return (channel + 2) % 5;
+	return (dsmx ? (channel - 2) % 5 : channel % 5);
+}
+
+static void __attribute__((unused)) DSM_set_sop_data_crc(bool ch2, bool dsmx)
+{
+	//The crc for channel '1' is NOT(mfgid[0] << 8 + mfgid[1])
+	//The crc for channel '2' is (mfgid[0] << 8 + mfgid[1])
+	if(ch2)
+		CYRF_ConfigCRCSeed(seed);	//CH2
+	else
+		CYRF_ConfigCRCSeed(~seed);	//CH1, DSMR only use CH1
+
+	uint8_t pn_row = DSM_get_pn_row(hopping_frequency[hopping_frequency_no], dsmx);
+	uint8_t code[16];
+	#if 0
+		debug_time();
+		debug(" crc:%04X,row:%d,col:%d,rf:%02X",(~seed)&0xffff,pn_row,sop_col,hopping_frequency[hopping_frequency_no]);
+	#endif
+	DSM_read_code(code,pn_row,sop_col,8);					// pn_row between 0 and 4, sop_col between 1 and 7
+	CYRF_ConfigSOPCode(code);
+	DSM_read_code(code,pn_row,7 - sop_col,8);				// 7-sop_col between 0 and 6
+	DSM_read_code(code+8,pn_row,7 - sop_col + 1,8);			// 7-sop_col+1 between 1 and 7
+	CYRF_ConfigDataCode(code, 16);
+
+	CYRF_ConfigRFChannel(hopping_frequency[hopping_frequency_no]);
+	hopping_frequency_no++;
+	if(dsmx)
+		hopping_frequency_no %=23;
+	else
+		hopping_frequency_no %=2;
+}
+
+static void __attribute__((unused)) DSM_calc_dsmx_channel()
+{
+	uint8_t idx = 0;
+	uint32_t id = ~(((uint32_t)cyrfmfg_id[0] << 24) | ((uint32_t)cyrfmfg_id[1] << 16) | ((uint32_t)cyrfmfg_id[2] << 8) | (cyrfmfg_id[3] << 0));
+	uint32_t id_tmp = id;
+	while(idx < 23)
+	{
+		uint8_t i;
+		uint8_t count_3_27 = 0, count_28_51 = 0, count_52_76 = 0;
+		id_tmp = id_tmp * 0x0019660D + 0x3C6EF35F;		// Randomization
+		uint8_t next_ch = ((id_tmp >> 8) % 0x49) + 3;	// Use least-significant byte and must be larger than 3
+		if ( (next_ch ^ cyrfmfg_id[3]) & 0x01 )
+			continue;
+		for (i = 0; i < idx; i++)
+		{
+			if(hopping_frequency[i] == next_ch)
+				break;
+			if(hopping_frequency[i] <= 27)
+				count_3_27++;
+			else
+				if (hopping_frequency[i] <= 51)
+					count_28_51++;
+				else
+					count_52_76++;
+		}
+		if (i != idx)
+			continue;
+		if ((next_ch < 28 && count_3_27 < 8)
+			||(next_ch >= 28 && next_ch < 52 && count_28_51 < 7)
+			||(next_ch >= 52 && count_52_76 < 8))
+			hopping_frequency[idx++] = next_ch;
+	}
+}
+
+#endif

Multiprotocol/DSM_Rx_cyrf6936.ino

@@ -0,0 +1,491 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(DSM_RX_CYRF6936_INO)
+
+#include "iface_cyrf6936.h"
+
+//#define DSM_DEBUG_RF
+//#define DSM_DEBUG_CH
+
+uint8_t DSM_rx_type;
+
+enum {
+	DSM_RX_BIND1 = 0,
+	DSM_RX_BIND2,
+	DSM_RX_DATA_PREP,
+	DSM2_RX_SCAN,
+	DSM_RX_DATA_CH1,
+	DSM_RX_DATA_CH2,
+};
+
+static void __attribute__((unused)) DSM_RX_RF_init()
+{
+	DSM_cyrf_config();
+	rx_disable_lna = IS_POWER_FLAG_on;
+	if(IS_BIND_IN_PROGRESS)
+	{
+		//64 SDR Mode is configured so only the 8 first values are needed but need to write 16 values...
+		uint8_t code[16];
+		DSM_read_code(code,0,8,8);
+		CYRF_ConfigDataCode(code, 16);
+		CYRF_ConfigRFChannel(1);
+		CYRF_SetTxRxMode(RX_EN);									// Force end state read
+		CYRF_WriteRegister(CYRF_05_RX_CTRL, 0x83);					// Prepare to receive
+	}
+	else
+	{
+		DSM_cyrf_configdata();
+		CYRF_WriteRegister(CYRF_06_RX_CFG, rx_disable_lna ? 0x0A:0x4A);	// AGC disabled, LNA disabled/enabled, Attenuator disabled, RX override enabled, Fast turn mode enabled, RX is 1MHz below TX
+	}
+}
+
+uint16_t convert_channel_DSM_nolimit(int32_t val)
+{
+	val=(val-0x150)*(CHANNEL_MAX_100-CHANNEL_MIN_100)/(0x6B0-0x150)+CHANNEL_MIN_100;
+	if(val<0)
+		val=0;
+	else
+		if(val>2047)
+			val=2047;
+	return (uint16_t)val;
+}
+
+static uint8_t __attribute__((unused)) DSM_RX_check_packet()
+{
+ 	uint8_t rx_status=CYRF_ReadRegister(CYRF_07_RX_IRQ_STATUS);
+	if((rx_status & 0x03) == 0x02)  									// RXC=1, RXE=0 then 2nd check is required (debouncing)
+		rx_status |= CYRF_ReadRegister(CYRF_07_RX_IRQ_STATUS);
+	if((rx_status & 0x07) == 0x02)
+	{ // data received with no errors
+		len=CYRF_ReadRegister(CYRF_09_RX_COUNT);
+		#ifdef DSM_DEBUG_RF
+			debugln("l=%d",len);
+		#endif
+		if(len>=2 && len<=16)
+		{
+			// Read packet
+			CYRF_WriteRegister(CYRF_07_RX_IRQ_STATUS, 0x80);		// Need to set RXOW before data read
+			CYRF_ReadDataPacketLen(packet, len);
+
+			// Check packet ID
+			if ((DSM_rx_type&0x80) == 0)
+			{//DSM2
+				packet[0] ^= 0xff;
+				packet[1] ^= 0xff;
+			}
+			#ifdef DSM_DEBUG_CH
+				for(uint8_t i=0;i<len;i++)
+					debug("%02X ",packet[i]);
+				debugln("");
+			#endif
+			if(packet[0] == cyrfmfg_id[2] && packet[1] == cyrfmfg_id[3])
+				return 0x02;										// Packet ok
+		}
+		return 0x00;												// Wrong size or ID -> nothing received
+	}
+	return rx_status;												// Return error code
+}
+
+static void __attribute__((unused)) DSM_RX_build_telemetry_packet()
+{
+	uint8_t nbr_bits = 11;
+	if((DSM_rx_type&0xF0) == 0x00)
+		nbr_bits=10;												// Only DSM_22 is using a resolution of 1024
+
+	// Use packet length to calculate the number of channels
+	len -= 2;														// Remove header length
+	len >>= 1;														// Channels are on 2 bytes
+	if(len==0) return;												// No channels...
+
+	// Extract channels
+	uint8_t idx;
+	for (uint8_t i = 0; i < len; i++)
+	{
+		uint16_t value=(packet[i*2+2]<<8) | packet[i*2+3];
+		if(value!=0xFFFF)
+		{
+			idx=(value&0x7FFF)>>nbr_bits;							// retrieve channel index
+			#ifdef DSM_DEBUG_CH
+				debugln("i=%d,v=%d,u=%X",idx,value&0x7FF,value&0x8000);
+			#endif
+			if(idx<13)
+			{
+				if(nbr_bits==10) value <<= 1;						// switch to 11 bits
+				value &= 0x7FF;
+				rx_rc_chan[CH_TAER[idx]]=convert_channel_DSM_nolimit(value);
+			}
+		}
+	}
+
+	// Buid telemetry packet
+	idx=0;
+	packet_in[idx++] = RX_LQI;
+	packet_in[idx++] = RX_LQI;
+	packet_in[idx++] = 0;  											// start channel
+	packet_in[idx++] = 12; 											// number of channels in packet
+
+	// Pack channels
+	uint32_t bits = 0;
+	uint8_t bitsavailable = 0;
+	for (uint8_t i = 0; i < 12; i++)
+	{
+		bits |= ((uint32_t)rx_rc_chan[i]) << bitsavailable;
+		bitsavailable += 11;
+		while (bitsavailable >= 8)
+		{
+			packet_in[idx++] = bits & 0xff;
+			bits >>= 8;
+			bitsavailable -= 8;
+		}
+	}
+	if(bitsavailable)
+		packet_in[idx++] = bits & 0xff;
+	// Send telemetry
+	telemetry_link = 1;
+	#ifdef SEND_CPPM
+		if(sub_protocol>0)
+			telemetry_link |= 0x80;	// Disable telemetry output
+	#endif
+}
+
+static bool __attribute__((unused)) DSM_RX_bind_check_validity()
+{
+	uint16_t sum = 384 - 0x10;//
+	for(uint8_t i = 0; i < 8; i++)
+		sum += packet_in[i];
+	if( packet_in[8] != (sum>>8) || packet_in[9] != (sum&0xFF))		//Checksum
+		return false;
+	for(uint8_t i = 8; i < 14; i++)
+		sum += packet_in[i];
+	if( packet_in[14] != (sum>>8) || packet_in[15] != (sum&0xFF))	//Checksum
+		return false;
+	if(memcmp(packet_in,packet_in+4,4))								//Check ID
+		return false;
+	return true;
+}
+
+static void __attribute__((unused)) DSM_RX_build_bind_packet()
+{
+	uint16_t sum = 384 - 0x10;//
+	packet[0] = 0xff ^ cyrfmfg_id[0];								// ID
+	packet[1] = 0xff ^ cyrfmfg_id[1];
+	packet[2] = 0xff ^ cyrfmfg_id[2];
+	packet[3] = 0xff ^ cyrfmfg_id[3];
+	packet[4] = 0x01;												// RX version
+	packet[5] = num_ch;												// Number of channels
+	packet[6] = DSM_rx_type;										// DSM type, let's just send back whatever the TX gave us...
+	packet[7] = 0x00;												// Unknown
+	for(uint8_t i = 0; i < 8; i++)
+		sum += packet[i];
+	packet[8] = sum >> 8;
+	packet[9] = sum & 0xff;
+}
+
+static void __attribute__((unused)) DSM_abort_channel_rx(uint8_t ch)
+{
+	CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x20);						// Abort RX operation
+	CYRF_SetTxRxMode(IS_POWER_FLAG_on ? TXRX_OFF:RX_EN);			// Force end state read
+	if (rx_disable_lna != IS_POWER_FLAG_on && IS_BIND_DONE)
+	{
+		rx_disable_lna = IS_POWER_FLAG_on;
+		CYRF_WriteRegister(CYRF_06_RX_CFG, rx_disable_lna ? 0x0A:0x4A);	// AGC disabled, LNA disabled/enabled, Attenuator disabled, RX override enabled, Fast turn mode enabled, RX is 1MHz below TX
+	}
+	if(ch&0x02) DSM_set_sop_data_crc(true ,DSM_rx_type&0x80);		// Set sop data,crc seed and rf channel using CH1, DSM2/X
+	if(ch&0x01) DSM_set_sop_data_crc(false,DSM_rx_type&0x80);		// Set sop data,crc seed and rf channel using CH1, DSM2/X
+	CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x00);						// Clear abort RX operation
+	CYRF_WriteRegister(CYRF_05_RX_CTRL, 0x83);						// Prepare to receive
+}
+
+uint16_t DSM_RX_callback()
+{
+	uint8_t rx_status;
+	static uint8_t read_retry=0;
+
+	switch (phase)
+	{
+		case DSM_RX_BIND1:
+			if(IS_BIND_DONE)										// Abort bind
+			{
+				phase = DSM_RX_DATA_PREP;
+				break;
+			}
+			if(packet_count==0)
+				read_retry=0;
+			//Check received data
+			rx_status = CYRF_ReadRegister(CYRF_07_RX_IRQ_STATUS);
+			if((rx_status & 0x03) == 0x02)  						// RXC=1, RXE=0 then 2nd check is required (debouncing)
+				rx_status |= CYRF_ReadRegister(CYRF_07_RX_IRQ_STATUS);
+			if((rx_status & 0x07) == 0x02)
+			{ // data received with no errors
+				CYRF_WriteRegister(CYRF_07_RX_IRQ_STATUS, 0x80);	// Need to set RXOW before data read
+				len=CYRF_ReadRegister(CYRF_09_RX_COUNT);
+				debugln("RX:%d, CH:%d",len,hopping_frequency_no);
+				if(len==16)
+				{
+					CYRF_ReadDataPacketLen(packet_in, 16);
+					if(DSM_RX_bind_check_validity())
+					{
+						// store tx info into eeprom
+						uint16_t temp = DSM_RX_EEPROM_OFFSET;
+						debug("ID=");
+						for(uint8_t i=0;i<4;i++)
+						{
+							cyrfmfg_id[i]=packet_in[i]^0xFF;
+							eeprom_write_byte((EE_ADDR)temp++, cyrfmfg_id[i]);
+							debug(" %02X", cyrfmfg_id[i]);
+						}
+						// save num_ch
+						num_ch=packet_in[11];
+						// store DSM_rx_type
+						/*packet[12]     1 byte -> max DSM type allowed:
+							0x01 => 22ms 1024 DSM2 1 packet => number of channels is <8
+							0x02 => 22ms 1024 DSM2 2 packets => either a number of channel >7
+							0x12 => 11ms 2048 DSM2 2 packets => can be any number of channels
+							0xA2 => 22ms 2048 DSMX 1 packet => number of channels is <8
+							0xB2 => 11ms 2048 DSMX => can be any number of channels
+							(0x01 or 0xA2) and num_ch < 7 => 22ms else 11ms
+							&0x80 => false=DSM2, true=DSMX
+							&0xF0 => false=1024, true=2048 */
+						DSM_rx_type=packet_in[12];
+						debugln(", num_ch=%d, type=%02X",num_ch, DSM_rx_type);
+						eeprom_write_byte((EE_ADDR)temp, DSM_rx_type);
+						CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x20);	// Abort RX operation
+						CYRF_SetTxRxMode(TX_EN);					// Force end state TX
+						CYRF_ConfigDataCode((const uint8_t *)"\x98\x88\x1B\xE4\x30\x79\x03\x84", 16);
+						CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x00);	// Clear abort RX
+						DSM_RX_build_bind_packet();
+						bind_counter=500;
+						phase++;									// DSM_RX_BIND2;
+						return 1000;
+					}
+				}
+				DSM_abort_channel_rx(0);							// Abort RX operation and receive
+				if(read_retry==0)
+					read_retry=8;
+			}
+			else
+				if(rx_status & 0x02)								// RX error
+					DSM_abort_channel_rx(0);						// Abort RX operation and receive
+			packet_count++;
+			if(packet_count>12)
+			{
+				packet_count=1;
+				if(read_retry)
+					read_retry--;
+				if(read_retry==0)
+				{
+					packet_count=0;
+					hopping_frequency_no++;							// Change channel
+					hopping_frequency_no %= 0x50;
+					hopping_frequency_no |= 0x01;					// Odd channels only
+					CYRF_ConfigRFChannel(hopping_frequency_no);
+					DSM_abort_channel_rx(0);						// Abort RX operation and receive
+				}
+			}
+			return 1000;
+		case DSM_RX_BIND2:
+			//Transmit settings back
+			CYRF_WriteDataPacketLen(packet,10);						// Send packet
+			if(bind_counter--==0)
+			{
+				BIND_DONE;
+				phase++;											// DSM_RX_DATA_PREP
+			}
+			break;
+		case DSM_RX_DATA_PREP:
+			hopping_frequency_no = 0;
+			read_retry=0;
+			rx_data_started = false;
+			pps_counter = 0;
+			RX_LQI = 100;
+			DSM_cyrf_configdata();
+			pps_timer=millis();
+			sop_col = (cyrfmfg_id[0] + cyrfmfg_id[1] + cyrfmfg_id[2] + 2) & 0x07;
+			seed = (cyrfmfg_id[0] << 8) + cyrfmfg_id[1];
+			if(DSM_rx_type&0x80)
+			{ // DSMX
+				DSM_calc_dsmx_channel();							// Build hop table
+				DSM_abort_channel_rx(1);							// Abort RX operation, set sop&data&seed&rf using CH1, DSM2/X and receive
+				phase=DSM_RX_DATA_CH1;
+			}
+			else
+			{ // DSM2
+				rf_ch_num=0;
+				hopping_frequency_no = 0;
+				hopping_frequency[0] = 3;
+				hopping_frequency[1] = 0;
+				DSM_abort_channel_rx(1);							// Abort RX operation, set sop&data&seed&rf using CH1, DSM2/X and receive
+				phase=DSM2_RX_SCAN;
+			}
+			break;
+		case DSM2_RX_SCAN:											// Scan for DSM2 frequencies
+			//Received something ?
+			rx_status = DSM_RX_check_packet();
+			if(rx_status == 0x02)
+			{ // data received with no errors
+				debugln("CH%d:Found %d",rf_ch_num+1,hopping_frequency[rf_ch_num]);
+				read_retry=0;
+				if(rf_ch_num)
+				{													// Both CH1 and CH2 found
+					read_retry=0;
+					hopping_frequency_no=0;
+					DSM_abort_channel_rx(1);						// Abort RX operation, set sop&data&seed&rf using CH1, DSM2/X and receive
+					pps_timer=millis();
+					phase++;										// DSM_RX_DATA_CH1
+				}
+				else
+				{
+					rf_ch_num++;									// CH1 found, scan for CH2
+					hopping_frequency_no = 1;
+					if(hopping_frequency[1] < 3)					// If no CH2 keep then restart from current
+						hopping_frequency[1]=hopping_frequency[0]+1;
+					DSM_abort_channel_rx(2);						// Abort RX operation, set sop&data&seed&rf using CH2, DSM2/X and receive
+				}
+			}
+			else
+			{
+				read_retry++;
+				if(read_retry>50)									// After 50ms
+				{ // Try next channel
+					debugln("CH%d:Next channel",rf_ch_num+1);
+					read_retry=0;
+					hopping_frequency_no = rf_ch_num;
+					hopping_frequency[rf_ch_num]++;
+					if(hopping_frequency[rf_ch_num] > 73) hopping_frequency[rf_ch_num] = 3;
+					DSM_abort_channel_rx(rf_ch_num+1);				// Abort RX operation, set sop&data&seed&rf using CH1/2, DSM2/X and receive
+				}
+				else if(rx_status & 0x02)
+				{ // data received with errors
+					if((rx_status & 0x01) && rf_ch_num==0)
+						hopping_frequency[1] = hopping_frequency[0];// Might be CH2 since it's a CRC error so keep it
+					debugln("CH%d:RX error",rf_ch_num+1);
+					DSM_abort_channel_rx(0);						// Abort RX operation and receive
+				}
+			}
+			return 1000;
+		case DSM_RX_DATA_CH1:
+			//Packets per second
+			if (millis() - pps_timer >= 1000)
+			{//182pps @11ms, 91pps @22ms
+				pps_timer = millis();
+				if(DSM_rx_type!=0xA2 && DSM_rx_type!=0x01)			// if 11ms
+					pps_counter >>=1;								// then /2
+				debugln("%d pps", pps_counter);
+				RX_LQI = pps_counter;								// max=91pps
+				pps_counter = 0;
+			}
+			//Received something ?
+			rx_status = DSM_RX_check_packet();
+			if(rx_status == 0x02)
+			{ // data received with no errors
+				#ifdef DSM_DEBUG_RF
+					debugln("CH1:RX");
+				#endif
+				DSM_RX_build_telemetry_packet();
+				rx_data_started = true;
+				pps_counter++;
+				DSM_abort_channel_rx(2);							// Abort RX operation, set sop&data&seed&rf using CH2, DSM2/X and receive
+				phase++;
+				return 5000;
+			}
+			else
+			{
+				read_retry++;
+				if(rx_data_started && read_retry>6)					// After 6*500=3ms
+				{ // skip to CH2
+					#ifdef DSM_DEBUG_RF
+						debugln("CH1:Skip to CH2");
+					#endif
+					DSM_abort_channel_rx(2);						// Abort RX operation, set sop&data&seed&rf using CH2, DSM2/X and receive
+					phase++;
+					return 4000;
+				}
+				if(rx_data_started && RX_LQI==0)
+				{  // communication lost
+					#ifdef DSM_DEBUG_RF
+						debugln("CH1:Restart...");
+					#endif
+					phase=DSM_RX_DATA_PREP;
+					return 1000;
+				}
+				if(read_retry>250)
+				{ // move to next RF channel
+					#ifdef DSM_DEBUG_RF
+						debugln("CH1:Scan");
+					#endif
+					DSM_abort_channel_rx(3);						// Abort RX operation, set sop&data&seed&rf using CH2 then CH1, DSM2/X and receive
+					read_retry=0;
+				}
+				else if(rx_status & 0x02)
+				{ // data received with errors
+					#ifdef DSM_DEBUG_RF
+						debugln("CH1:RX error %02X",rx_status);
+					#endif
+					DSM_abort_channel_rx(0);						// Abort RX operation and receive
+				}
+			}
+			return 500;
+		case DSM_RX_DATA_CH2:
+			rx_status = DSM_RX_check_packet();
+			if(rx_status == 0x02)
+			{ // data received with no errors
+				#ifdef DSM_DEBUG_RF
+					debugln("CH2:RX");
+				#endif
+				DSM_RX_build_telemetry_packet();
+				pps_counter++;
+			}
+			#ifdef DSM_DEBUG_RF
+				else
+					debugln("CH2:No RX");
+			#endif
+			DSM_abort_channel_rx(1);								// Abort RX operation, set sop&data&seed&rf using CH1, DSM2/X and receive
+			read_retry=0;
+			phase=DSM_RX_DATA_CH1;
+			if(DSM_rx_type==0xA2) //|| DSM_rx_type==0x01 -> not needed for DSM2 since we are ok to listen even if there will be nothing
+				return 15000;										//22ms
+			else
+				return 4000;										//11ms
+	}
+	return 10000;
+}
+
+void DSM_RX_init()
+{
+	DSM_RX_RF_init();
+	hopping_frequency_no = 0;
+	
+	if (IS_BIND_IN_PROGRESS)
+	{
+		packet_count=0;
+		phase = DSM_RX_BIND1;
+	}
+	else
+	{
+		uint16_t temp = DSM_RX_EEPROM_OFFSET;
+		debug("ID=");
+		for(uint8_t i=0;i<4;i++)
+		{
+			cyrfmfg_id[i]=eeprom_read_byte((EE_ADDR)temp++);
+			debug(" %02X", cyrfmfg_id[i]);
+		}
+		DSM_rx_type=eeprom_read_byte((EE_ADDR)temp);
+		debugln(", type=%02X", DSM_rx_type);
+		phase = DSM_RX_DATA_PREP;
+	}
+}
+
+#endif

Multiprotocol/DSM_cyrf6936.ino

@@ -17,6 +17,10 @@
 
 #include "iface_cyrf6936.h"
 
+//#define DSM_DEBUG_FWD_PGM
+
+//#define DSM_GR300
+
 #define DSM_BIND_CHANNEL 0x0d //13 This can be any odd channel
 
 //During binding we will send BIND_COUNT/2 packets
@@ -41,11 +45,10 @@ enum {
 };
 
 //
-uint8_t sop_col;
-uint8_t DSM_num_ch=0;
 uint8_t ch_map[14];
-const uint8_t PROGMEM ch_map_progmem[][14] = {
-//22+11ms for 4..7 channels
+const uint8_t PROGMEM DSM_ch_map_progmem[][14] = {
+//22+11ms for 3..7 channels
+	{1, 0, 2, 0xff, 0xff, 0xff, 0xff, 1,  0,   2, 0xff, 0xff, 0xff,    0xff}, //3ch  - Guess
 	{1, 0, 2, 3, 0xff, 0xff, 0xff, 1,    0,    2,    3, 0xff, 0xff,    0xff}, //4ch  - Guess
 	{1, 0, 2, 3, 4,    0xff, 0xff, 1,    0,    2,    3,    4, 0xff,    0xff}, //5ch  - Guess
 	{1, 5, 2, 3, 0,    4,    0xff, 1,    5,    2,    3,    0,    4,    0xff}, //6ch  - HP6DSM
@@ -55,124 +58,15 @@ const uint8_t PROGMEM ch_map_progmem[][14] = {
 	{1, 5, 2, 3, 6,    0xff, 0xff, 4,    0,    7,    8,    0xff, 0xff, 0xff}, //9ch  - Guess
 	{1, 5, 2, 3, 6,    0xff, 0xff, 4,    0,    7,    8,    9,    0xff, 0xff}, //10ch - Guess
 	{1, 5, 2, 3, 6,    10,   0xff, 4,    0,    7,    8,    9,    0xff, 0xff}, //11ch - Guess
-	{1, 5, 2, 4, 6,    10,   0xff, 0,    7,    3,    8,    9   , 11  , 0xff}, //12ch - DX18
-//11ms for 8..12 channels
+	{1, 5, 2, 4, 6,    10,   0xff, 0,    7,    3,    8,    9   , 11  , 0xff}, //12ch - DX18/DX8G2
+//11ms for 8..11 channels
 	{1, 5, 2, 3, 6,    7,    0xff, 1,    5,    2,    4,    0,    0xff, 0xff}, //8ch  - DX7
 	{1, 5, 2, 3, 6,    7,    0xff, 1,    5,    2,    4,    0,    8,    0xff}, //9ch  - Guess
 	{1, 5, 2, 3, 4,    8,    9,    1,    5,    2,    3,    0,    7,    6   }, //10ch - DX18
+	{1, 5, 2, 3, 4,    8,    9,    1,   10,    2,    3,    0,    7,    6   }, //11ch - Guess
 };
 
-const uint8_t PROGMEM pncodes[5][8][8] = {
-	/* Note these are in order transmitted (LSB 1st) */
-	{ /* Row 0 */
-		/* Col 0 */ {0x03, 0xBC, 0x6E, 0x8A, 0xEF, 0xBD, 0xFE, 0xF8},
-		/* Col 1 */ {0x88, 0x17, 0x13, 0x3B, 0x2D, 0xBF, 0x06, 0xD6},
-		/* Col 2 */ {0xF1, 0x94, 0x30, 0x21, 0xA1, 0x1C, 0x88, 0xA9},
-		/* Col 3 */ {0xD0, 0xD2, 0x8E, 0xBC, 0x82, 0x2F, 0xE3, 0xB4},
-		/* Col 4 */ {0x8C, 0xFA, 0x47, 0x9B, 0x83, 0xA5, 0x66, 0xD0},
-		/* Col 5 */ {0x07, 0xBD, 0x9F, 0x26, 0xC8, 0x31, 0x0F, 0xB8},
-		/* Col 6 */ {0xEF, 0x03, 0x95, 0x89, 0xB4, 0x71, 0x61, 0x9D},
-		/* Col 7 */ {0x40, 0xBA, 0x97, 0xD5, 0x86, 0x4F, 0xCC, 0xD1},
-		/* Col 8    {0xD7, 0xA1, 0x54, 0xB1, 0x5E, 0x89, 0xAE, 0x86}*/
-	},
-	{ /* Row 1 */
-		/* Col 0 */ {0x83, 0xF7, 0xA8, 0x2D, 0x7A, 0x44, 0x64, 0xD3},
-		/* Col 1 */ {0x3F, 0x2C, 0x4E, 0xAA, 0x71, 0x48, 0x7A, 0xC9},
-		/* Col 2 */ {0x17, 0xFF, 0x9E, 0x21, 0x36, 0x90, 0xC7, 0x82},
-		/* Col 3 */ {0xBC, 0x5D, 0x9A, 0x5B, 0xEE, 0x7F, 0x42, 0xEB},
-		/* Col 4 */ {0x24, 0xF5, 0xDD, 0xF8, 0x7A, 0x77, 0x74, 0xE7},
-		/* Col 5 */ {0x3D, 0x70, 0x7C, 0x94, 0xDC, 0x84, 0xAD, 0x95},
-		/* Col 6 */ {0x1E, 0x6A, 0xF0, 0x37, 0x52, 0x7B, 0x11, 0xD4},
-		/* Col 7 */ {0x62, 0xF5, 0x2B, 0xAA, 0xFC, 0x33, 0xBF, 0xAF},
-		/* Col 8    {0x40, 0x56, 0x32, 0xD9, 0x0F, 0xD9, 0x5D, 0x97} */
-	},
-	{ /* Row 2 */
-		/* Col 0 */ {0x40, 0x56, 0x32, 0xD9, 0x0F, 0xD9, 0x5D, 0x97},
-		/* Col 1 */ {0x8E, 0x4A, 0xD0, 0xA9, 0xA7, 0xFF, 0x20, 0xCA},
-		/* Col 2 */ {0x4C, 0x97, 0x9D, 0xBF, 0xB8, 0x3D, 0xB5, 0xBE},
-		/* Col 3 */ {0x0C, 0x5D, 0x24, 0x30, 0x9F, 0xCA, 0x6D, 0xBD},
-		/* Col 4 */ {0x50, 0x14, 0x33, 0xDE, 0xF1, 0x78, 0x95, 0xAD},
-		/* Col 5 */ {0x0C, 0x3C, 0xFA, 0xF9, 0xF0, 0xF2, 0x10, 0xC9},
-		/* Col 6 */ {0xF4, 0xDA, 0x06, 0xDB, 0xBF, 0x4E, 0x6F, 0xB3},
-		/* Col 7 */ {0x9E, 0x08, 0xD1, 0xAE, 0x59, 0x5E, 0xE8, 0xF0},
-		/* Col 8    {0xC0, 0x90, 0x8F, 0xBB, 0x7C, 0x8E, 0x2B, 0x8E} */
-	},
-	{ /* Row 3 */
-		/* Col 0 */ {0xC0, 0x90, 0x8F, 0xBB, 0x7C, 0x8E, 0x2B, 0x8E},
-		/* Col 1 */ {0x80, 0x69, 0x26, 0x80, 0x08, 0xF8, 0x49, 0xE7},
-		/* Col 2 */ {0x7D, 0x2D, 0x49, 0x54, 0xD0, 0x80, 0x40, 0xC1},
-		/* Col 3 */ {0xB6, 0xF2, 0xE6, 0x1B, 0x80, 0x5A, 0x36, 0xB4},
-		/* Col 4 */ {0x42, 0xAE, 0x9C, 0x1C, 0xDA, 0x67, 0x05, 0xF6},
-		/* Col 5 */ {0x9B, 0x75, 0xF7, 0xE0, 0x14, 0x8D, 0xB5, 0x80},
-		/* Col 6 */ {0xBF, 0x54, 0x98, 0xB9, 0xB7, 0x30, 0x5A, 0x88},
-		/* Col 7 */ {0x35, 0xD1, 0xFC, 0x97, 0x23, 0xD4, 0xC9, 0x88},
-		/* Col 8    {0xE1, 0xD6, 0x31, 0x26, 0x5F, 0xBD, 0x40, 0x93} */
-// Wrong values used by Orange TX/RX
-//		/* Col 8 */ {0x88, 0xE1, 0xD6, 0x31, 0x26, 0x5F, 0xBD, 0x40}
-	},
-	{ /* Row 4 */
-		/* Col 0 */ {0xE1, 0xD6, 0x31, 0x26, 0x5F, 0xBD, 0x40, 0x93},
-		/* Col 1 */ {0xDC, 0x68, 0x08, 0x99, 0x97, 0xAE, 0xAF, 0x8C},
-		/* Col 2 */ {0xC3, 0x0E, 0x01, 0x16, 0x0E, 0x32, 0x06, 0xBA},
-		/* Col 3 */ {0xE0, 0x83, 0x01, 0xFA, 0xAB, 0x3E, 0x8F, 0xAC},
-		/* Col 4 */ {0x5C, 0xD5, 0x9C, 0xB8, 0x46, 0x9C, 0x7D, 0x84},
-		/* Col 5 */ {0xF1, 0xC6, 0xFE, 0x5C, 0x9D, 0xA5, 0x4F, 0xB7},
-		/* Col 6 */ {0x58, 0xB5, 0xB3, 0xDD, 0x0E, 0x28, 0xF1, 0xB0},
-		/* Col 7 */ {0x5F, 0x30, 0x3B, 0x56, 0x96, 0x45, 0xF4, 0xA1},
-		/* Col 8    {0x03, 0xBC, 0x6E, 0x8A, 0xEF, 0xBD, 0xFE, 0xF8} */
-	},
-};
-
-static void __attribute__((unused)) read_code(uint8_t *buf, uint8_t row, uint8_t col, uint8_t len)
-{
-	for(uint8_t i=0;i<len;i++)
-		buf[i]=pgm_read_byte_near( &pncodes[row][col][i] );
-}
-
-static uint8_t __attribute__((unused)) get_pn_row(uint8_t channel)
-{
-	return ((sub_protocol == DSMX_11 || sub_protocol == DSMX_22 )? (channel - 2) % 5 : channel % 5);	
-}
-
-const uint8_t PROGMEM init_vals[][2] = {
-	{CYRF_02_TX_CTRL, 0x00},				// All TX interrupt disabled
-	{CYRF_05_RX_CTRL, 0x00},				// All RX interrupt disabled
-	{CYRF_28_CLK_EN, 0x02},					// Force receive clock enable
-	{CYRF_32_AUTO_CAL_TIME, 0x3c},			// Default init value
-	{CYRF_35_AUTOCAL_OFFSET, 0x14},			// Default init value
-	{CYRF_06_RX_CFG, 0x4A},					// LNA enabled, RX override enabled, Fast turn mode enabled, RX is 1MHz below TX
-	{CYRF_1B_TX_OFFSET_LSB, 0x55},			// Default init value
-	{CYRF_1C_TX_OFFSET_MSB, 0x05},			// Default init value
-	{CYRF_39_ANALOG_CTRL, 0x01},			// All slow for synth setting time
-	{CYRF_01_TX_LENGTH, 0x10},				// 16 bytes packet
-	{CYRF_14_EOP_CTRL, 0x02},				// Set EOP Symbol Count to 2
-	{CYRF_12_DATA64_THOLD, 0x0a},			// 64 Chip Data PN corelator threshold, default datasheet value is 0x0E
-	//Below is for bind only
-	{CYRF_03_TX_CFG, 0x38 | CYRF_BIND_POWER}, //64 chip codes, SDR mode
-	{CYRF_10_FRAMING_CFG, 0x4a},			// SOP disabled, no LEN field and SOP correlator of 0x0a but since SOP is disabled...
-	{CYRF_1F_TX_OVERRIDE, 0x04},			// Disable TX CRC, no ACK, use TX synthesizer
-	{CYRF_1E_RX_OVERRIDE, 0x14},			// Disable RX CRC, Force receive data rate, use RX synthesizer
-};
-
-const uint8_t PROGMEM data_vals[][2] = {
-	{CYRF_29_RX_ABORT, 0x20},				// Abort RX operation in case we are coming from bind
-	{CYRF_0F_XACT_CFG, 0x24},				// Force Idle
-	{CYRF_29_RX_ABORT, 0x00},				// Clear abort RX
-	{CYRF_03_TX_CFG, 0x28 | CYRF_HIGH_POWER}, // 64 chip codes, 8DR mode
-	{CYRF_10_FRAMING_CFG, 0xea},			// SOP enabled, SOP_CODE_ADR 64 chips, Packet len enabled, SOP correlator 0x0A
-	{CYRF_1F_TX_OVERRIDE, 0x00},			// CRC16 enabled, no ACK
-	{CYRF_1E_RX_OVERRIDE, 0x00},			// CRC16 enabled, no ACK
-};
-
-static void __attribute__((unused)) cyrf_config()
-{
-	for(uint8_t i = 0; i < sizeof(init_vals) / 2; i++)	
-		CYRF_WriteRegister(pgm_read_byte_near(&init_vals[i][0]), pgm_read_byte_near(&init_vals[i][1]));
-	CYRF_WritePreamble(0x333304);
-	CYRF_ConfigRFChannel(0x61);
-}
-
-static void __attribute__((unused)) build_bind_packet()
+static void __attribute__((unused)) DSM_build_bind_packet()
 {
 	uint8_t i;
 	uint16_t sum = 384 - 0x10;//
@@ -189,20 +83,26 @@ static void __attribute__((unused)) build_bind_packet()
 	packet[8] = sum >> 8;
 	packet[9] = sum & 0xff;
 	packet[10] = 0x01;						// ???
-	packet[11] = DSM_num_ch;
+	if(sub_protocol==DSM_AUTO)
+		packet[11] = 12;
+	else
+		packet[11] = num_ch;				// DX5 DSMR sends 0x48...
 
-	if (sub_protocol==DSM2_22)
-		packet[12]=DSM_num_ch<8?0x01:0x02;	// DSM2/1024 1 or 2 packets depending on the number of channels
-	if(sub_protocol==DSM2_11)
+	if (sub_protocol==DSMR)
+		packet[12] = 0xa2;
+	else if (sub_protocol==DSM2_1F)
+		packet[12] = num_ch<8?0x01:0x02;	// DSM2/1024 1 or 2 packets depending on the number of channels
+	else if(sub_protocol==DSM2_2F)
 		packet[12] = 0x12;					// DSM2/2048 2 packets
-	if(sub_protocol==DSMX_22)
+	else if(sub_protocol==DSMX_1F)
 		#if defined DSM_TELEMETRY
 			packet[12] = 0xb2;				// DSMX/2048 2 packets
 		#else
-			packet[12] = DSM_num_ch<8? 0xa2 : 0xb2;	// DSMX/2048 1 or 2 packets depending on the number of channels
+			packet[12] = num_ch<8? 0xa2 : 0xb2;	// DSMX/2048 1 or 2 packets depending on the number of channels
 		#endif
-	if(sub_protocol==DSMX_11 || sub_protocol==DSM_AUTO) // Force DSMX/1024 in mode Auto
-		packet[12]=0xb2;					// DSMX/1024 2 packets
+	else									// DSMX_2F && DSM_AUTO
+		packet[12] = 0xb2;					// DSMX/2048 2 packets
+	
 
 	packet[13] = 0x00;						//???
 	for(i = 8; i < 14; i++)
@@ -211,141 +111,123 @@ static void __attribute__((unused)) build_bind_packet()
 	packet[15] = sum & 0xff;
 }
 
-static void __attribute__((unused)) initialize_bind_phase()
+static void __attribute__((unused)) DSM_initialize_bind_phase()
 {
 	CYRF_ConfigRFChannel(DSM_BIND_CHANNEL); //This seems to be random?
 	//64 SDR Mode is configured so only the 8 first values are needed but need to write 16 values...
-	CYRF_ConfigDataCode((const uint8_t*)"\xD7\xA1\x54\xB1\x5E\x89\xAE\x86\xc6\x94\x22\xfe\x48\xe6\x57\x4e", 16);
-	build_bind_packet();
+	uint8_t code[16];
+	DSM_read_code(code,0,8,8);
+	CYRF_ConfigDataCode(code, 16);
+	DSM_build_bind_packet();
 }
 
-static void __attribute__((unused)) cyrf_configdata()
-{
-	for(uint8_t i = 0; i < sizeof(data_vals) / 2; i++)
-		CYRF_WriteRegister(pgm_read_byte_near(&data_vals[i][0]), pgm_read_byte_near(&data_vals[i][1]));
-}
-
-static void __attribute__((unused)) update_channels()
+static void __attribute__((unused)) DSM_update_channels()
 {
 	prev_option=option;
-	if(sub_protocol==DSM_AUTO)
-		DSM_num_ch=12;						// Force 12 channels in mode Auto
-	else
-		DSM_num_ch=option;
-	if(DSM_num_ch<4 || DSM_num_ch>12)
-		DSM_num_ch=6;						// Default to 6 channels if invalid choice...
+	num_ch=option & 0x0F;				// Remove flags 0x80=max_throw, 0x40=11ms
+
+	if(num_ch<3 || num_ch>12)
+		num_ch=6;						// Default to 6 channels if invalid choice...
+
+	if(sub_protocol==DSMR && num_ch>7)
+		num_ch=7;						// Max 7 channels in DSMR
 
 	// Create channel map based on number of channels and refresh rate
-	uint8_t idx=DSM_num_ch-4;
-	if(DSM_num_ch>7 && DSM_num_ch<11 && (sub_protocol==DSM2_11 || sub_protocol==DSMX_11))
-		idx+=5;								// In 11ms mode change index only for channels 8..10
+	uint8_t idx=num_ch-3;
+	if((option & 0x40) && num_ch>7 && num_ch<12)
+		idx+=5;							// In 11ms mode change index only for channels 8..11
 	for(uint8_t i=0;i<14;i++)
-		ch_map[i]=pgm_read_byte_near(&ch_map_progmem[idx][i]);
+		ch_map[i]=pgm_read_byte_near(&DSM_ch_map_progmem[idx][i]);
 }
 
-static void __attribute__((unused)) build_data_packet(uint8_t upper)
+static void __attribute__((unused)) DSM_build_data_packet(uint8_t upper)
 {
-	uint16_t max = 2047;
 	uint8_t bits = 11;
 
 	if(prev_option!=option)
-		update_channels();
+		DSM_update_channels();
 
-	if (sub_protocol==DSMX_11 || sub_protocol==DSMX_22 )
-	{
+	if (sub_protocol==DSMX_2F || sub_protocol==DSMX_1F)
+	{//DSMX
 		packet[0] = cyrfmfg_id[2];
 		packet[1] = cyrfmfg_id[3];
 	}
 	else
-	{
+	{//DSM2 && DSMR
 		packet[0] = (0xff ^ cyrfmfg_id[2]);
 		packet[1] = (0xff ^ cyrfmfg_id[3]);
-		if(sub_protocol==DSM2_22)
-		{
-			max=1023;						// Only DSM_22 is using a resolution of 1024
-			bits=10;
-		}
+		if(sub_protocol==DSM2_1F)
+			bits=10;								// Only DSM2_1F is using a resolution of 1024
 	}
 
+	if(sub_protocol == DSMR)
+	{
 		for (uint8_t i = 0; i < 7; i++)
 		{
-		uint8_t idx = ch_map[(upper?7:0) + i];//1,5,2,3,0,4	   
-		uint16_t value = 0xffff;;	
-		if (idx != 0xff)
-		{
-			if (!IS_BIND_DONE_on)
-			{ // Failsafe position during binding
-				value=max/2;				//all channels to middle
-				if(idx==0)
-					value=1;				//except throttle
-			}
-			else
-				value=map(Servo_data[CH_TAER[idx]],servo_min_125,servo_max_125,0,max);
-			value |= (upper && i==0 ? 0x8000 : 0) | (idx << bits);
-		}	  
+			uint16_t value = 0x0000;
+			if(i < num_ch)
+				value=Channel_data[i]<<1;
 			packet[i*2+2] = (value >> 8) & 0xff;
 			packet[i*2+3] = (value >> 0) & 0xff;
 		}
+		return;
 	}
 
-static void __attribute__((unused)) set_sop_data_crc()
+	#ifdef DSM_THROTTLE_KILL_CH
+		uint16_t kill_ch=Channel_data[DSM_THROTTLE_KILL_CH-1];
+	#endif
+	for (uint8_t i = 0; i < 7; i++)
 	{	
-	//The crc for channel '1' is NOT(mfgid[0] << 8 + mfgid[1])
-	//The crc for channel '2' is (mfgid[0] << 8 + mfgid[1])
-	uint16_t crc = (cyrfmfg_id[0] << 8) + cyrfmfg_id[1];
-	if(phase==DSM_CH1_CHECK_A||phase==DSM_CH1_CHECK_B)
-		CYRF_ConfigCRCSeed(crc);	//CH2
+		uint8_t idx = ch_map[(upper?7:0) + i];		// 1,5,2,3,0,4	   
+		uint16_t value = 0xffff;
+		if((option&0x40) == 0 && num_ch < 8 && upper)
+			idx=0xff;								// in 22ms do not transmit upper channels if <8, is it the right method???
+		if (idx != 0xff)
+		{
+			/* Spektrum own remotes transmit normal values during bind and actually use this (e.g. Nano CP X) to
+			   select the transmitter mode (e.g. computer vs non-computer radio), so always send normal output */
+			#ifdef DSM_THROTTLE_KILL_CH
+				if(idx==CH1 && kill_ch<=604)
+				{//Activate throttle kill only if channel is throttle and DSM_THROTTLE_KILL_CH below -50%
+					if(kill_ch<CHANNEL_MIN_100)		// restrict val to 0...400
+						kill_ch=0;
 					else
-		CYRF_ConfigCRCSeed(~crc);	//CH1
-
-	uint8_t pn_row = get_pn_row(hopping_frequency[hopping_frequency_no]);
-	uint8_t code[16];
-	read_code(code,pn_row,sop_col,8);					// pn_row between 0 and 4, sop_col between 1 and 7
-	CYRF_ConfigSOPCode(code);
-	read_code(code,pn_row,7 - sop_col,8);				// 7-sop_col between 0 and 6
-	read_code(code+8,pn_row,7 - sop_col + 1,8);			// 7-sop_col+1 between 1 and 7
-	CYRF_ConfigDataCode(code, 16);
-
-	CYRF_ConfigRFChannel(hopping_frequency[hopping_frequency_no]);
-	hopping_frequency_no++;
-	if(sub_protocol == DSMX_11 || sub_protocol == DSMX_22)
-		hopping_frequency_no %=23;
-	else
-		hopping_frequency_no %=2;
+						kill_ch-=CHANNEL_MIN_100;
+					value=(kill_ch*21)/25;			// kill channel -100%->904us ... -50%->1100us *0x150/400
 				}
-
-static void __attribute__((unused)) calc_dsmx_channel()
-{
-	uint8_t idx = 0;
-	uint32_t id = ~(((uint32_t)cyrfmfg_id[0] << 24) | ((uint32_t)cyrfmfg_id[1] << 16) | ((uint32_t)cyrfmfg_id[2] << 8) | (cyrfmfg_id[3] << 0));
-	uint32_t id_tmp = id;
-	while(idx < 23)
-	{
-		uint8_t i;
-		uint8_t count_3_27 = 0, count_28_51 = 0, count_52_76 = 0;
-		id_tmp = id_tmp * 0x0019660D + 0x3C6EF35F;		// Randomization
-		uint8_t next_ch = ((id_tmp >> 8) % 0x49) + 3;	// Use least-significant byte and must be larger than 3
-		if ( (next_ch ^ cyrfmfg_id[3]) & 0x01 )
-			continue;
-		for (i = 0; i < idx; i++)
-		{
-			if(hopping_frequency[i] == next_ch)
-				break;
-			if(hopping_frequency[i] <= 27)
-				count_3_27++;
 				else
-				if (hopping_frequency[i] <= 51)
-					count_28_51++;
+			#endif
+				#ifdef DSM_MAX_THROW
+					value=Channel_data[CH_TAER[idx]];										// -100%..+100% => 1024..1976us and -125%..+125% => 904..2096us based on Redcon 6 channel DSM2 RX
+				#else
+					if(option & 0x80)
+						value=Channel_data[CH_TAER[idx]];									// -100%..+100% => 1024..1976us and -125%..+125% => 904..2096us based on Redcon 6 channel DSM2 RX
 					else
-					count_52_76++;
+						value=convert_channel_16b_nolimit(CH_TAER[idx],0x156,0x6AA,false);	// -100%..+100% => 1100..1900us and -125%..+125% => 1000..2000us based on a DX8 G2 dump
+				#endif
+			if(bits==10) value>>=1;
+			value |= (upper && i==0 ? 0x8000 : 0) | (idx << bits);
 		}	  
-		if (i != idx)
-			continue;
-		if ((next_ch < 28 && count_3_27 < 8)
-			||(next_ch >= 28 && next_ch < 52 && count_28_51 < 7)
-			||(next_ch >= 52 && count_52_76 < 8))
-			hopping_frequency[idx++] = next_ch;
+		packet[i*2+2] = value >> 8;
+		packet[i*2+3] = value;
 	}
+	#ifdef DSM_FWD_PGM
+		if(upper==0 && DSM_SerialRX && (DSM_SerialRX_val[0]&0xF8)==0x70 )
+		{ // Send forward programming data if available
+			for(uint8_t i=0; i<(DSM_SerialRX_val[0]&0x07);i++)
+			{
+				packet[i*2+4]=0x70+i;
+				packet[i*2+5]=DSM_SerialRX_val[i+1];
+			}
+			DSM_SerialRX=false;
+			#ifdef DSM_DEBUG_FWD_PGM
+				debug("FWD=");
+				for(uint8_t i=4; i<16;i++)
+					debug(" %02X",packet[i]);
+				debugln("");
+			#endif
+		}
+	#endif
 }
 
 static uint8_t __attribute__((unused)) DSM_Check_RX_packet()
@@ -355,20 +237,24 @@ static uint8_t __attribute__((unused)) DSM_Check_RX_packet()
 	uint16_t sum = 384 - 0x10;
 	for(uint8_t i = 1; i < 9; i++)
 	{
-		sum += pkt[i];
+		sum += packet_in[i];
 		if(i<5)
-			if(pkt[i] != (0xff ^ cyrfmfg_id[i-1]))
+			if(packet_in[i] != (0xff ^ cyrfmfg_id[i-1]))
 				result=0; 						// bad packet
 	}
-	if( pkt[9] != (sum>>8)  && pkt[10] != (uint8_t)sum )
+	if( packet_in[9] != (sum>>8)  && packet_in[10] != (uint8_t)sum )
 		result=0;
 	return result;
 }
 
-uint16_t ReadDsm()
+uint16_t DSM_callback()
 {
 	#define DSM_CH1_CH2_DELAY	4010			// Time between write of channel 1 and channel 2
+	#ifdef STM32_BOARD
+		#define DSM_WRITE_DELAY		1600		// Time after write to verify write complete
+	#else
 		#define DSM_WRITE_DELAY		1950		// Time after write to verify write complete
+	#endif
 	#define DSM_READ_DELAY		600				// Time before write to check read phase, and switch channels. Was 400 but 600 seems what the 328p needs to read a packet
 	#if defined DSM_TELEMETRY
 		uint8_t rx_phase;
@@ -376,6 +262,11 @@ uint16_t ReadDsm()
 	#endif
 	uint8_t start;
 
+	#ifdef DSM_GR300
+		uint16_t timing=5000+(convert_channel_8b(CH13)*100);
+		debugln("T=%u",timing);
+	#endif
+	
 	switch(phase)
 	{
 		case DSM_BIND_WRITE:
@@ -390,7 +281,7 @@ uint16_t ReadDsm()
 	#if defined DSM_TELEMETRY
 		case DSM_BIND_CHECK:
 			//64 SDR Mode is configured so only the 8 first values are needed but we need to write 16 values...
-			CYRF_ConfigDataCode((const uint8_t *)"\x98\x88\x1B\xE4\x30\x79\x03\x84\xC9\x2C\x06\x93\x86\xB9\x9E\xD7", 16);
+			CYRF_ConfigDataCode((const uint8_t *)"\x98\x88\x1B\xE4\x30\x79\x03\x84", 16);
 			CYRF_SetTxRxMode(RX_EN);							//Receive mode
 			CYRF_WriteRegister(CYRF_05_RX_CTRL, 0x87);			//Prepare to receive
 			bind_counter=2*DSM_BIND_COUNT;						//Timeout of 4.2s if no packet received
@@ -403,19 +294,30 @@ uint16_t ReadDsm()
 				rx_phase |= CYRF_ReadRegister(CYRF_07_RX_IRQ_STATUS);
 			if((rx_phase & 0x07) == 0x02)
 			{ // data received with no errors
-				CYRF_WriteRegister(CYRF_07_RX_IRQ_STATUS, 0x80);	// need to set RXOW before data read
-				len=CYRF_ReadRegister(CYRF_09_RX_COUNT);
-				if(len>MAX_PKT-2)
-					len=MAX_PKT-2;
-				CYRF_ReadDataPacketLen(pkt+1, len);
-				if(len==10 && DSM_Check_RX_packet())
+				CYRF_WriteRegister(CYRF_07_RX_IRQ_STATUS, 0x80);// Need to set RXOW before data read
+				if(CYRF_ReadRegister(CYRF_09_RX_COUNT)==10)		// Len
 				{
-					pkt[0]=0x80;
-					telemetry_link=1;						// send received data on serial
+					CYRF_ReadDataPacketLen(packet_in+1, 10);
+					if(DSM_Check_RX_packet())
+					{
+						debug("Bind");
+						for(uint8_t i=0;i<10;i++)
+							debug(" %02X",packet_in[i+1]);
+						debugln("");
+						packet_in[0]=0x80;
+						packet_in[6]&=0x0F;						// It looks like there is a flag 0x40 being added by some receivers
+						if(packet_in[6]>12) packet_in[6]=12;
+						else if(packet_in[6]<3) packet_in[6]=6;
+						telemetry_link=1;						// Send received data on serial
 						phase++;
 						return 2000;
 					}
 				}
+				CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x20);		// Abort RX operation
+				CYRF_SetTxRxMode(RX_EN);						// Force end state read
+				CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x00);		// Clear abort RX operation
+				CYRF_WriteRegister(CYRF_05_RX_CTRL, 0x83);		// Prepare to receive
+			}
 			else
 				if((rx_phase & 0x02) != 0x02)
 				{ // data received with errors
@@ -433,51 +335,74 @@ uint16_t ReadDsm()
 	#endif
 		case DSM_CHANSEL:
 			BIND_DONE;
-			cyrf_configdata();
+			DSM_cyrf_configdata();
 			CYRF_SetTxRxMode(TX_EN);
 			hopping_frequency_no = 0;
 			phase = DSM_CH1_WRITE_A;							// in fact phase++
-			set_sop_data_crc();
+			if(sub_protocol == DSMR)
+				DSM_set_sop_data_crc(false, true);
+			else
+				DSM_set_sop_data_crc(true, sub_protocol==DSMX_2F||sub_protocol==DSMX_1F);	//prep CH1
 			return 10000;
 		case DSM_CH1_WRITE_A:
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(11000);				// Always request 11ms spacing even if we don't use half of it in 22ms mode
+			#endif
+			if(sub_protocol == DSMR)
+				CYRF_SetPower(0x08);							//Keep transmit power in sync
+			else
+				CYRF_SetPower(0x28);							//Keep transmit power in sync
 		case DSM_CH1_WRITE_B:
+			DSM_build_data_packet(phase == DSM_CH1_WRITE_B);	// build lower or upper channels
 		case DSM_CH2_WRITE_A:
 		case DSM_CH2_WRITE_B:
-			build_data_packet(phase == DSM_CH1_WRITE_B||phase == DSM_CH2_WRITE_B);	// build lower or upper channels
 			CYRF_ReadRegister(CYRF_04_TX_IRQ_STATUS);			// clear IRQ flags
 			CYRF_WriteDataPacket(packet);
+			#if 0
+				for(uint8_t i=0;i<16;i++)
+					debug(" %02X", packet[i]);
+				debugln("");
+			#endif
 			phase++;											// change from WRITE to CHECK mode
 			return DSM_WRITE_DELAY;
 		case DSM_CH1_CHECK_A:
 		case DSM_CH1_CHECK_B:
 		case DSM_CH2_CHECK_A:
 		case DSM_CH2_CHECK_B:
-			start=micros();
-			while ((uint8_t)micros()-start < 100)			// Wait max 100µs, max I've seen is 50µs
-				if(CYRF_ReadRegister(CYRF_04_TX_IRQ_STATUS) & 0x02)
+			start=(uint8_t)micros();
+			while ((uint8_t)((uint8_t)micros()-(uint8_t)start) < 100)			// Wait max 100µs, max I've seen is 50µs
+				if((CYRF_ReadRegister(CYRF_02_TX_CTRL) & 0x80) == 0x00)
 					break;
-			if(phase==DSM_CH1_CHECK_A || phase==DSM_CH1_CHECK_B)
+			
+			if((phase==DSM_CH1_CHECK_A || phase==DSM_CH1_CHECK_B) && sub_protocol!=DSMR)
 			{
 				#if defined DSM_TELEMETRY
 					// reset cyrf6936 if freezed after switching from TX to RX
 					if (((CYRF_ReadRegister(CYRF_04_TX_IRQ_STATUS) & 0x22) == 0x20) || (CYRF_ReadRegister(CYRF_02_TX_CTRL) & 0x80))
 					{
 						CYRF_Reset();
-						cyrf_config();
-						cyrf_configdata();
+						DSM_cyrf_config();
+						DSM_cyrf_configdata();
 						CYRF_SetTxRxMode(TX_EN);
 					}
 				#endif
-				set_sop_data_crc();
+				DSM_set_sop_data_crc(true, sub_protocol==DSMX_2F||sub_protocol==DSMX_1F);	// prep CH2
 				phase++;									// change from CH1_CHECK to CH2_WRITE
 				return DSM_CH1_CH2_DELAY - DSM_WRITE_DELAY;
 			}
-			if (phase == DSM_CH2_CHECK_A)
-				CYRF_SetPower(0x28);						//Keep transmit power in sync
 #if defined DSM_TELEMETRY
 			phase++;										// change from CH2_CHECK to CH2_READ
 			CYRF_SetTxRxMode(RX_EN);						//Receive mode
 			CYRF_WriteRegister(CYRF_05_RX_CTRL, 0x87);		//0x80??? //Prepare to receive
+			if(sub_protocol==DSMR)
+			{
+				phase = DSM_CH2_READ_B;
+				return 11000 - DSM_WRITE_DELAY - DSM_READ_DELAY;
+			}
+			#ifdef DSM_GR300
+				if(num_ch==3)
+					return timing - DSM_CH1_CH2_DELAY - DSM_WRITE_DELAY - DSM_READ_DELAY;
+			#endif
 			return 11000 - DSM_CH1_CH2_DELAY - DSM_WRITE_DELAY - DSM_READ_DELAY;
 		case DSM_CH2_READ_A:
 		case DSM_CH2_READ_B:
@@ -489,19 +414,32 @@ uint16_t ReadDsm()
 			{ // good data (complete with no errors)
 				CYRF_WriteRegister(CYRF_07_RX_IRQ_STATUS, 0x80);	// need to set RXOW before data read
 				len=CYRF_ReadRegister(CYRF_09_RX_COUNT);
-				if(len>MAX_PKT-2)
-					len=MAX_PKT-2;
-				CYRF_ReadDataPacketLen(pkt+1, len);
-				pkt[0]=CYRF_ReadRegister(CYRF_13_RSSI)&0x1F;// store RSSI of the received telemetry signal
+				if(len>TELEMETRY_BUFFER_SIZE-2)
+					len=TELEMETRY_BUFFER_SIZE-2;
+				CYRF_ReadDataPacketLen(packet_in+1, len);
+				#ifdef DSM_DEBUG_FWD_PGM
+					//debug(" %02X", packet_in[1]);
+					if(packet_in[1]==9)
+					{
+						for(uint8_t i=0;i<len;i++)
+							debug(" %02X", packet_in[i+1]);
+						debugln("");
+					}
+				#endif
+				packet_in[0]=CYRF_ReadRegister(CYRF_13_RSSI)&0x1F;// store RSSI of the received telemetry signal
 				telemetry_link=1;
 			}
 			CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x20);		// Abort RX operation
-			if (phase == DSM_CH2_READ_A && (sub_protocol==DSM2_22 || sub_protocol==DSMX_22) && DSM_num_ch < 8)	// 22ms mode
+			if (phase == DSM_CH2_READ_A && (sub_protocol==DSM2_1F || sub_protocol==DSMX_1F) && num_ch < 8)	// 22ms mode
 			{
 				CYRF_SetTxRxMode(RX_EN);					// Force end state read
 				CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x00);	// Clear abort RX operation
 				CYRF_WriteRegister(CYRF_05_RX_CTRL, 0x87);	//0x80???	//Prepare to receive
 				phase = DSM_CH2_READ_B;
+				#ifdef DSM_GR300
+					if(num_ch==3)
+						return timing;
+				#endif
 				return 11000;
 			}
 			if (phase == DSM_CH2_READ_A)
@@ -510,46 +448,96 @@ uint16_t ReadDsm()
 				phase = DSM_CH1_WRITE_A;					//Transmit lower
 			CYRF_SetTxRxMode(TX_EN);						//TX mode
 			CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x00);		//Clear abort RX operation
-			set_sop_data_crc();
+			DSM_set_sop_data_crc(false, sub_protocol==DSMX_2F||sub_protocol==DSMX_1F||sub_protocol==DSMR);
 			return DSM_READ_DELAY;
 #else
 			// No telemetry
-			set_sop_data_crc();
+			DSM_set_sop_data_crc(phase==DSM_CH1_CHECK_A||phase==DSM_CH1_CHECK_B, sub_protocol==DSMX_2F||sub_protocol==DSMX_1F);
 			if (phase == DSM_CH2_CHECK_A)
 			{
-				if(DSM_num_ch > 7 || sub_protocol==DSM2_11 || sub_protocol==DSMX_11)
+				if(num_ch > 7 || sub_protocol==DSM2_2F || sub_protocol==DSMX_2F)
 					phase = DSM_CH1_WRITE_B;				//11ms mode or upper to transmit change from CH2_CHECK_A to CH1_WRITE_A
 				else										
 				{											//Normal mode 22ms
 					phase = DSM_CH1_WRITE_A;				// change from CH2_CHECK_A to CH1_WRITE_A (ie no upper)
+					#ifdef DSM_GR300
+						if(num_ch==3)
+							return timing - DSM_CH1_CH2_DELAY - DSM_WRITE_DELAY ;
+					#endif
 					return 22000 - DSM_CH1_CH2_DELAY - DSM_WRITE_DELAY ;
 				}
 			}
 			else
 				phase = DSM_CH1_WRITE_A;					// change from CH2_CHECK_B to CH1_WRITE_A (upper already transmitted so transmit lower)
+			#ifdef DSM_GR300
+				if(num_ch==3)
+					return timing - DSM_CH1_CH2_DELAY - DSM_WRITE_DELAY ;
+			#endif
 			return 11000 - DSM_CH1_CH2_DELAY - DSM_WRITE_DELAY;
 #endif
 	}
 	return 0;		
 }
 
-uint16_t initDsm()
+
+const uint8_t PROGMEM DSMR_ID_FREQ[][4 + 23] = {
+	{ 0x71, 0x74, 0x1c, 0xe4, 0x11, 0x2f, 0x17, 0x3d, 0x23, 0x3b, 0x0f, 0x21, 0x25, 0x49, 0x1d, 0x13, 0x4d, 0x1f, 0x41, 0x4b, 0x47, 0x05, 0x27, 0x15, 0x19, 0x3f, 0x07 },
+	{ 0xfe, 0xfe, 0xfe, 0xfe, 0x45, 0x31, 0x33, 0x4b, 0x11, 0x29, 0x49, 0x3f, 0x09, 0x13, 0x47, 0x21, 0x1d, 0x43, 0x1f, 0x05, 0x41, 0x19, 0x1b, 0x2d, 0x15, 0x4d, 0x0f },
+	{ 0xfe, 0xff, 0xff, 0xff, 0x2a, 0x06, 0x22, 0x28, 0x16, 0x24, 0x38, 0x0e, 0x32, 0x2e, 0x14, 0x3a, 0x04, 0x44, 0x0c, 0x42, 0x1c, 0x4a, 0x10, 0x36, 0x3c, 0x48, 0x26 },
+	{ 0xff, 0xfe, 0xff, 0xff, 0x28, 0x34, 0x48, 0x46, 0x3a, 0x12, 0x18, 0x32, 0x14, 0x42, 0x16, 0x40, 0x22, 0x44, 0x1c, 0x0a, 0x36, 0x20, 0x10, 0x0c, 0x3c, 0x26, 0x2e },
+	{ 0xff, 0xff, 0xfe, 0xff, 0x3c, 0x16, 0x04, 0x48, 0x1e, 0x4a, 0x10, 0x18, 0x22, 0x28, 0x38, 0x40, 0x20, 0x06, 0x3e, 0x42, 0x30, 0x1a, 0x2c, 0x1c, 0x46, 0x14, 0x34 },
+	{ 0xff, 0xff, 0xff, 0xfe, 0x4d, 0x39, 0x1b, 0x13, 0x45, 0x2f, 0x0d, 0x3d, 0x0b, 0x11, 0x47, 0x2d, 0x19, 0x1d, 0x23, 0x35, 0x33, 0x3b, 0x21, 0x31, 0x17, 0x0f, 0x43 },
+	{ 0xff, 0xff, 0xff, 0xff, 0x14, 0x28, 0x2e, 0x32, 0x3e, 0x10, 0x38, 0x0e, 0x12, 0x06, 0x2c, 0x26, 0x30, 0x4c, 0x34, 0x16, 0x04, 0x3a, 0x42, 0x48, 0x36, 0x46, 0x1a },
+	{ 0x00, 0xff, 0xff, 0xff, 0x3e, 0x30, 0x42, 0x24, 0x06, 0x0e, 0x14, 0x1c, 0x08, 0x10, 0x20, 0x22, 0x04, 0x32, 0x0c, 0x44, 0x3c, 0x46, 0x4a, 0x26, 0x4c, 0x48, 0x1e },
+	{ 0xff, 0x00, 0xff, 0xff, 0x38, 0x0e, 0x22, 0x2a, 0x44, 0x3a, 0x4a, 0x3e, 0x16, 0x20, 0x36, 0x24, 0x46, 0x18, 0x1e, 0x12, 0x1c, 0x30, 0x2c, 0x14, 0x06, 0x0c, 0x40 },
+	{ 0x00, 0x00, 0xff, 0xff, 0x06, 0x4c, 0x26, 0x08, 0x46, 0x3e, 0x30, 0x12, 0x38, 0x1c, 0x04, 0x4a, 0x2c, 0x1a, 0x20, 0x3a, 0x18, 0x36, 0x28, 0x2e, 0x22, 0x40, 0x10 },
+	{ 0xff, 0xff, 0x00, 0xff, 0x12, 0x06, 0x3c, 0x2a, 0x22, 0x38, 0x48, 0x4c, 0x32, 0x44, 0x26, 0x16, 0x0c, 0x28, 0x2c, 0x36, 0x1c, 0x1a, 0x42, 0x10, 0x08, 0x4a, 0x34 },
+	{ 0x00, 0xff, 0x00, 0xff, 0x04, 0x4c, 0x4a, 0x28, 0x2a, 0x24, 0x14, 0x1e, 0x40, 0x48, 0x44, 0x2c, 0x2e, 0x1a, 0x12, 0x46, 0x3a, 0x0e, 0x18, 0x1c, 0x20, 0x10, 0x42 },
+	{ 0xff, 0x00, 0x00, 0xff, 0x06, 0x10, 0x14, 0x16, 0x48, 0x18, 0x44, 0x2c, 0x0a, 0x26, 0x24, 0x42, 0x36, 0x30, 0x38, 0x3e, 0x0c, 0x3c, 0x34, 0x46, 0x2a, 0x32, 0x0e },
+	{ 0x00, 0x00, 0x00, 0xff, 0x2c, 0x0a, 0x46, 0x28, 0x38, 0x24, 0x14, 0x06, 0x04, 0x10, 0x18, 0x30, 0x12, 0x20, 0x3a, 0x1a, 0x32, 0x3c, 0x3e, 0x4a, 0x1e, 0x44, 0x36 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x45, 0x23, 0x07, 0x37, 0x4b, 0x13, 0x3d, 0x31, 0x19, 0x2b, 0x2f, 0x2d, 0x1f, 0x4d, 0x3f, 0x1b, 0x43, 0x27, 0x3b, 0x11, 0x05, 0x0d, 0x17 },
+	{ 0xff, 0xff, 0xff, 0x00, 0x0b, 0x4b, 0x1d, 0x39, 0x09, 0x0f, 0x49, 0x25, 0x07, 0x35, 0x3b, 0x05, 0x33, 0x17, 0x2d, 0x11, 0x2b, 0x29, 0x1f, 0x45, 0x1b, 0x41, 0x47 },
+	{ 0x00, 0xff, 0xff, 0x00, 0x41, 0x35, 0x11, 0x25, 0x29, 0x27, 0x33, 0x47, 0x4d, 0x31, 0x05, 0x37, 0x15, 0x1f, 0x23, 0x07, 0x1b, 0x0f, 0x3b, 0x49, 0x19, 0x3f, 0x0b },
+	{ 0xff, 0x00, 0xff, 0x00, 0x25, 0x47, 0x05, 0x0b, 0x45, 0x1f, 0x2b, 0x27, 0x2d, 0x09, 0x07, 0x43, 0x49, 0x29, 0x4d, 0x39, 0x33, 0x41, 0x17, 0x0f, 0x15, 0x19, 0x3b },
+	{ 0x00, 0x00, 0xff, 0x00, 0x3b, 0x05, 0x21, 0x0d, 0x1b, 0x43, 0x17, 0x2d, 0x1d, 0x25, 0x4b, 0x35, 0x4d, 0x3f, 0x07, 0x09, 0x37, 0x41, 0x15, 0x1f, 0x0f, 0x27, 0x29 },
+	{ 0xff, 0xff, 0x00, 0x00, 0x2b, 0x35, 0x1b, 0x1d, 0x0f, 0x47, 0x09, 0x0d, 0x45, 0x41, 0x21, 0x11, 0x2f, 0x43, 0x27, 0x33, 0x4b, 0x37, 0x13, 0x19, 0x4d, 0x23, 0x17 },
+	{ 0x00, 0xff, 0x00, 0x00, 0x1b, 0x1d, 0x33, 0x13, 0x2b, 0x27, 0x09, 0x41, 0x25, 0x17, 0x19, 0x2d, 0x4b, 0x37, 0x45, 0x11, 0x21, 0x0d, 0x3d, 0x4d, 0x07, 0x39, 0x43 },
+	{ 0xff, 0x00, 0x00, 0x00, 0x37, 0x27, 0x43, 0x4b, 0x39, 0x13, 0x07, 0x0d, 0x25, 0x17, 0x29, 0x1b, 0x1d, 0x45, 0x19, 0x2d, 0x0b, 0x3d, 0x15, 0x47, 0x1f, 0x21, 0x4d } };
+
+void DSM_init()
+{ 
+	if(sub_protocol == DSMR)
+	{
+		uint8_t row = rx_tx_addr[3]%22;
+		for(uint8_t i=0; i< 4; i++)
+			cyrfmfg_id[i] = pgm_read_byte_near(&DSMR_ID_FREQ[row][i]);
+		for(uint8_t i=0; i< 23; i++)
+			hopping_frequency[i] = pgm_read_byte_near(&DSMR_ID_FREQ[row][i+4]);
+	}
+	else
 	{
 		CYRF_GetMfgData(cyrfmfg_id);
 		//Model match
 		cyrfmfg_id[3]^=RX_num;
+	}
+
 	//Calc sop_col
 	sop_col = (cyrfmfg_id[0] + cyrfmfg_id[1] + cyrfmfg_id[2] + 2) & 0x07;
-	//Fix for OrangeRX using wrong pncodes by preventing access to "Col 8"
-	if(sop_col==0)
+
+	//Fix for OrangeRX using wrong DSM_pncodes by preventing access to "Col 8"
+	if(sop_col==0 && sub_protocol != DSMR)
 	{
 	   cyrfmfg_id[rx_tx_addr[0]%3]^=0x01;					//Change a bit so sop_col will be different from 0
 	   sop_col = (cyrfmfg_id[0] + cyrfmfg_id[1] + cyrfmfg_id[2] + 2) & 0x07;
 	}
+
+	//Calc CRC seed
+	seed = (cyrfmfg_id[0] << 8) + cyrfmfg_id[1];
+
 	//Hopping frequencies
-	if (sub_protocol == DSMX_11 || sub_protocol == DSMX_22)
-		calc_dsmx_channel();
-	else
+	if (sub_protocol == DSMX_2F || sub_protocol == DSMX_1F)
+		DSM_calc_dsmx_channel();
+	else if(sub_protocol != DSMR)
 	{ 
 		uint8_t tmpch[10];
 		CYRF_FindBestChannels(tmpch, 10, 5, 3, 75);
@@ -564,22 +552,21 @@ uint16_t initDsm()
 		}
 		hopping_frequency[1] = tmpch[idx];
 	}
+
 	//
-	cyrf_config();
+	DSM_cyrf_config();
 	CYRF_SetTxRxMode(TX_EN);
 	//
-	update_channels();
+	DSM_update_channels();
 	//
-	if(IS_AUTOBIND_FLAG_on )
+	if(IS_BIND_IN_PROGRESS)
 	{
-		BIND_IN_PROGRESS;
-		initialize_bind_phase();		
+		DSM_initialize_bind_phase();		
 		phase = DSM_BIND_WRITE;
 		bind_counter=DSM_BIND_COUNT;
 	}
 	else
 		phase = DSM_CHANSEL;//
-	return 10000;
 }
 
 #endif

Multiprotocol/Devo_cyrf6936.ino

@@ -17,8 +17,6 @@
  
 #include "iface_cyrf6936.h"
 
-#define DEVO_NUM_CHANNELS 8
-
 //For Debug
 //#define NO_SCRAMBLE
 
@@ -57,24 +55,24 @@ static void __attribute__((unused)) DEVO_add_pkt_suffix()
 {
     uint8_t bind_state;
 	#ifdef ENABLE_PPM
-	if(mode_select && option==0 && IS_BIND_DONE_on) 			//PPM mode and option not already set and bind is finished
+	if(mode_select && (option&0x01)==0 && IS_BIND_DONE) 			//PPM mode and option not already set and bind is finished
 	{
 		BIND_SET_INPUT;
 		BIND_SET_PULLUP;										// set pullup
 		if(IS_BIND_BUTTON_on)
 		{
-			eeprom_write_byte((EE_ADDR)(30+mode_select),0x01);	// Set fixed id mode for the current model
-			option=1;
+			eeprom_write_byte((EE_ADDR)(MODELMODE_EEPROM_OFFSET+RX_num),0x01);	// Set fixed id mode for the current model
+			option |= 0x01;
 		}
 		BIND_SET_OUTPUT;
 	}
 	#endif //ENABLE_PPM
-    if(prev_option!=option && IS_BIND_DONE_on)
+    if(prev_option!=option && IS_BIND_DONE)
 	{
 		MProtocol_id = RX_num + MProtocol_id_master;
 		bind_counter=DEVO_BIND_COUNT;
 	}
-	if (option)
+	if (option&0x01)
 	{
         if (bind_counter > 0)
             bind_state = 0xc0;
@@ -93,22 +91,36 @@ static void __attribute__((unused)) DEVO_add_pkt_suffix()
 
 static void __attribute__((unused)) DEVO_build_beacon_pkt(uint8_t upper)
 {
-	packet[0] = (DEVO_NUM_CHANNELS << 4) | 0x07;
-	uint8_t max = 8;
+	packet[0] = (num_ch << 4) | 0x07;
+	uint8_t max = 8, offset = 0, enable = 0;
 	if (upper)
 	{
 		packet[0] += 1;
 		max = 4;
+		offset = 8;
 	}
 	for(uint8_t i = 0; i < max; i++)
+	{
+		#ifdef FAILSAFE_ENABLE
+			uint16_t failsafe=Failsafe_data[CH_EATR[i+offset]];
+			if(i + offset < num_ch && failsafe!=FAILSAFE_CHANNEL_HOLD && IS_FAILSAFE_VALUES_on)
+			{
+				enable |= 0x80 >> i;
+				packet[i+1] = ((failsafe*25)>>8)-100;
+			}
+			else
+		#else
+			(void)offset;
+		#endif
 				packet[i+1] = 0;
-	packet[9] = 0;
+	}
+	packet[9] = enable;
 	DEVO_add_pkt_suffix();
 }
 
 static void __attribute__((unused)) DEVO_build_bind_pkt()
 {
-	packet[0] = (DEVO_NUM_CHANNELS << 4) | 0x0a;
+	packet[0] = (num_ch << 4) | 0x0a;
 	packet[1] = bind_counter & 0xff;
 	packet[2] = (bind_counter >> 8);
 	packet[3] = *hopping_frequency_ptr;
@@ -130,11 +142,11 @@ static void __attribute__((unused)) DEVO_build_data_pkt()
 {
 	static uint8_t ch_idx=0;
 
-	packet[0] = (DEVO_NUM_CHANNELS << 4) | (0x0b + ch_idx);
+	packet[0] = (num_ch << 4) | (0x0b + ch_idx);
 	uint8_t sign = 0x0b;
 	for (uint8_t i = 0; i < 4; i++)
 	{
-		int16_t value=map(Servo_data[CH_EATR[ch_idx * 4 + i]],servo_min_125,servo_max_125,-1600,1600);//range -1600..+1600
+		int16_t value=convert_channel_16b_nolimit(CH_EATR[ch_idx * 4 + i],-1600,1600,false);//range -1600..+1600
 		if(value < 0)
 		{
 			value = -value;
@@ -145,11 +157,170 @@ static void __attribute__((unused)) DEVO_build_data_pkt()
 	}
 	packet[9] = sign;
 	ch_idx++;
-	if (ch_idx * 4 >= DEVO_NUM_CHANNELS)
+	if (ch_idx * 4 >= num_ch)
 		ch_idx = 0;
 	DEVO_add_pkt_suffix();
 }
 
+#if defined DEVO_HUB_TELEMETRY
+static uint32_t __attribute__((unused)) DEVO_text_to_int(uint8_t *ptr, uint8_t len)
+{
+	uint32_t value = 0;
+	for(uint8_t i = 0; i < len; i++)
+		value = value * 10 + (ptr[i] - '0');
+	return value;
+}
+
+static void __attribute__((unused)) DEVO_float_to_ints(uint8_t *ptr, uint16_t *value, uint16_t *decimal)
+{
+	bool seen_decimal = false;
+	*value = 0;
+	*decimal = 0;
+	for(uint8_t i = 0; i < 7; i++)
+	{
+		if(ptr[i] == '.')
+		{
+			seen_decimal = true;
+			continue;
+		}
+		if(ptr[i] < '0' || ptr[i] > '9')
+		{
+			if(*value != 0 || seen_decimal)
+				return;
+		}
+		else
+		{
+			if(seen_decimal)
+				*decimal = *decimal * 10 + (ptr[i] - '0');
+			else
+				*value = *value * 10 + (ptr[i] - '0');
+		}
+	}
+}
+
+static void __attribute__((unused)) DEVO_parse_telemetry_packet()
+{ // Telemetry packets every 2.4ms
+	DEVO_scramble_pkt(); //This will unscramble the packet
+	
+	debugln("RX");
+	if ((((uint32_t)packet[15] << 16) | ((uint32_t)packet[14] << 8) | packet[13]) != (MProtocol_id & 0x00ffffff))
+		return;	// ID does not match
+		
+	if((telemetry_link & 3) != 0)
+	{
+		debugln("S%d",telemetry_link);
+		return;	// Previous telemetry not sent yet...
+	}
+
+	//Debug telem RX
+	//for(uint8_t i=0;i<12;i++)
+	//	debug("%02X ",packet[i]);
+	//debugln("");
+	
+	#if defined HUB_TELEMETRY
+	//Telemetry https://github.com/DeviationTX/deviation/blob/5efb6a28bea697af9a61b5a0ed2528cc8d203f90/src/protocol/devo_cyrf6936.c#L232
+		uint16_t val, dec;
+		uint32_t val32;
+		switch(packet[0])
+		{
+			case 0x30:	// Volt and RPM packet
+				//RSSI and voltage
+				TX_RSSI = CYRF_ReadRegister(CYRF_13_RSSI) & 0x1F;
+				TX_RSSI = (TX_RSSI << 1) + TX_RSSI;
+				RX_RSSI = TX_RSSI;
+				telemetry_link |= 1;
+				v_lipo1 = packet[1] << 1;
+				v_lipo2 = packet[3] << 1;
+				//packet[5] = 127;																					// 12.7V
+				if(packet[5] != 0)
+				{
+					val  = (packet[5]*11)/21;																		// OpenTX strange transformation??
+					dec  = val;
+					val /= 10;
+					dec -= val*10;
+					frsky_send_user_frame(0x3A, val, 0x00);															// volt3
+					frsky_send_user_frame(0x3B, dec, 0x00);															// volt3
+				}
+				val = packet[7] * 120;																				// change to RPM
+				frsky_send_user_frame(0x03, val, val>>8);															// RPM
+				break;
+			case 0x31:	// Temperature packet
+				//memcpy(&packet[1],"\x29\x2A\x2B\x00\x00\x00\x00\x00\x00\x00\x00\x00",12);							// 21°, 22°, 23°
+				for(uint8_t i=0; i<2;i++)
+					if(packet[i+1]!=0xff)
+					{
+						val = packet[i+1];
+						val -= 20;
+						frsky_send_user_frame(0x02 + i*3, val, val>>8);												// temp 1 & 2
+					}
+				break;
+			// GPS Data
+			case 0x32: // Longitude
+				//memcpy(&packet[1],"\x30\x33\x30\x32\x30\x2e\x38\x32\x37\x30\x45\xfb",12);							// 030°20.8270E in ddmm.mmmm
+				//memcpy(&packet[1],"\x31\x31\x37\x31\x31\x2e\x35\x39\x34\x37\x57\xfb",12);							// RX705 sends 117°11.5947W which should be 11706.95685W in ddmm.mmmm
+				val = DEVO_text_to_int(&packet[1], 3)*100;															// dd00
+				val32 = DEVO_text_to_int(&packet[4], 2) * 10000 + DEVO_text_to_int(&packet[7], 4);					// mmmmmm
+				if(option&0x02)																						// if RX705 GPS format
+					val32 = (val32*3)/5;																			// then * 6/10 correction
+				dec = val32/10000;
+				val = val + dec;																					// dddmm
+				frsky_send_user_frame(0x12  , val, val>>8);
+				val = val32 - dec*10000;																			// .mmmm
+				frsky_send_user_frame(0x12+8, val, val>>8);
+				frsky_send_user_frame(0x1A+8, packet[11], 0x00);													// 'E'/'W'
+				break;
+			case 0x33: // Latitude
+				//memcpy(&packet[1],"\x35\x39\x35\x34\x2e\x37\x37\x37\x36\x4e\x07\x00",12);							// 59°54.776N in ddmm.mmmm
+				//memcpy(&packet[1],"\x31\x37\x31\x31\x2e\x35\x39\x34\x37\x4e\xfb\x00",12);							// RX705 sends 17°11.5947N which should be 1706.95685N in ddmm.mmmm
+				val = DEVO_text_to_int(&packet[1], 2)*100;															// dd00
+				val32 = DEVO_text_to_int(&packet[3], 2) * 10000 + DEVO_text_to_int(&packet[6], 4);					// mmmmmm
+				if(option&0x02)																						// if RX705 GPS format
+					val32 = (val32*3)/5;																			// then * 6/10 correction
+				dec = val32/10000;
+				val = val + dec;																					// dddmm
+				frsky_send_user_frame(0x13  , val, val>>8);
+				val = val32 - dec*10000;																			// .mmmm
+				frsky_send_user_frame(0x13+8, val, val>>8);
+				frsky_send_user_frame(0x1B+8, packet[10], 0x00);													// 'N'/'S'
+				break;
+			case 0x34: // Altitude
+				//memcpy(&packet[1],"\x31\x32\x2e\x38\x00\x00\x00\x4d\x4d\x4e\x45\xfb",12);							// 12.8 MMNE
+				DEVO_float_to_ints(&packet[1], &val, &dec);
+				frsky_send_user_frame(0x10, val, val>>8);
+				frsky_send_user_frame(0x21, dec, dec>>8);
+				break;
+			case 0x35: // Speed
+				//memcpy(&packet[1],"\x00\x00\x00\x00\x00\x00\x30\x2e\x30\x30\x00\x00",12);							// 0.0
+				DEVO_float_to_ints(&packet[1], &val, &dec);
+				frsky_send_user_frame(0x11  , val, val>>8);
+				frsky_send_user_frame(0x11+8, dec, dec>>8);
+				break;
+			case 0x36: // Time
+				//memcpy(&packet[1],"\x31\x38\x32\x35\x35\x32\x31\x35\x31\x30\x31\x32",12);							// "182552151012" = 2012-10-15 18:25:52 (UTC)
+				if(packet[1]!=0)
+				{
+					frsky_send_user_frame(0x15, DEVO_text_to_int(&packet[9], 2), DEVO_text_to_int(&packet[7], 2));	// month, day
+					val = 2000 + DEVO_text_to_int(&packet[11], 2);													// year
+					frsky_send_user_frame(0x16, val, val>>8);
+					frsky_send_user_frame(0x17, DEVO_text_to_int(&packet[1], 2), DEVO_text_to_int(&packet[3], 2));	// hour, min
+					frsky_send_user_frame(0x18, DEVO_text_to_int(&packet[5], 2), 0x00);								// second
+				}
+				break;
+		}
+	#else
+		if(packet[0] == 0x30)
+		{
+			TX_RSSI = CYRF_ReadRegister(CYRF_13_RSSI) & 0x1F;
+			TX_RSSI = (TX_RSSI << 1) + TX_RSSI;
+			RX_RSSI = TX_RSSI;
+			telemetry_link |= 1;
+			v_lipo1 = packet[1] << 1;
+			v_lipo2 = packet[3] << 1;
+		}
+	#endif
+}
+#endif
+
 static void __attribute__((unused)) DEVO_cyrf_set_bound_sop_code()
 {
 	/* crc == 0 isn't allowed, so use 1 if the math results in 0 */
@@ -244,7 +415,7 @@ static void __attribute__((unused)) DEVO_BuildPacket()
 			}
 			break;
 		case DEVO_BOUND_10:
-			DEVO_build_beacon_pkt(DEVO_NUM_CHANNELS > 8 ? failsafe_pkt : 0);
+			DEVO_build_beacon_pkt(num_ch > 8 ? failsafe_pkt : 0);
 			failsafe_pkt = failsafe_pkt ? 0 : 1;
 			DEVO_scramble_pkt();
 			phase = DEVO_BOUND_1;
@@ -255,11 +426,90 @@ static void __attribute__((unused)) DEVO_BuildPacket()
 		packet_count = 0;
 }
 
-uint16_t devo_callback()
+uint16_t DEVO_callback()
 {
 	static uint8_t txState=0;
+	
+#if defined DEVO_HUB_TELEMETRY
+	int delay;
+	
 	if (txState == 0)
 	{
+		#ifdef MULTI_SYNC
+			telemetry_set_input_sync(2400);
+		#endif
+		DEVO_BuildPacket();
+		CYRF_WriteDataPacket(packet);
+		txState = 1;
+		return 900;
+	}
+	if (txState == 1)
+	{
+		int i = 0;
+		uint8_t reg;
+		while (! ((reg = CYRF_ReadRegister(CYRF_04_TX_IRQ_STATUS)) & 0x02))
+		{
+			if (++i >= DEVO_NUM_WAIT_LOOPS)
+				break;
+		}
+		if (((reg & 0x22) == 0x20) || (CYRF_ReadRegister(CYRF_02_TX_CTRL) & 0x80))
+		{
+			CYRF_Reset();
+			DEVO_cyrf_init();
+			DEVO_cyrf_set_bound_sop_code();
+			CYRF_ConfigRFChannel(*hopping_frequency_ptr);
+			//printf("Rst CYRF\n");
+			delay = 1500;
+			txState = 15;
+		}
+		else
+		{
+			if (phase == DEVO_BOUND)
+			{
+				/* exit binding state */
+				phase = DEVO_BOUND_3;
+				DEVO_cyrf_set_bound_sop_code();
+			}
+			if((packet_count != 0) && (bind_counter == 0))
+			{
+				CYRF_SetTxRxMode(RX_EN); //Receive mode
+				CYRF_WriteRegister(CYRF_05_RX_CTRL, 0x87); //0x80??? //Prepare to receive
+				txState = 2;
+				return 1300;
+			}
+		}
+		if(packet_count == 0)
+		{
+			CYRF_SetPower(0x08);		//Keep tx power updated
+			hopping_frequency_ptr = hopping_frequency_ptr == &hopping_frequency[2] ? hopping_frequency : hopping_frequency_ptr + 1;
+			CYRF_ConfigRFChannel(*hopping_frequency_ptr);
+		}
+		delay = 1500;
+	}
+	if(txState == 2)
+	{
+		uint8_t rx_state = CYRF_ReadRegister(CYRF_07_RX_IRQ_STATUS);
+		if((rx_state & 0x03) == 0x02)
+		{  // RXC=1, RXE=0 then 2nd check is required (debouncing)
+			rx_state |= CYRF_ReadRegister(CYRF_07_RX_IRQ_STATUS);   
+		}
+		if((rx_state & 0x07) == 0x02)
+		{ // good data (complete with no errors)
+			CYRF_WriteRegister(CYRF_07_RX_IRQ_STATUS, 0x80);	// need to set RXOW before data read
+			CYRF_ReadDataPacketLen(packet, CYRF_ReadRegister(CYRF_09_RX_COUNT));
+			DEVO_parse_telemetry_packet();
+		}
+		CYRF_SetTxRxMode(TX_EN); //Write mode
+		delay = 200;
+	}
+	txState = 0;   
+	return delay;
+#else
+	if (txState == 0)
+	{
+		#ifdef MULTI_SYNC
+			telemetry_set_input_sync(2400);
+		#endif
 		txState = 1;
 		DEVO_BuildPacket();
 		CYRF_WriteDataPacket(packet);
@@ -283,10 +533,44 @@ uint16_t devo_callback()
 		CYRF_ConfigRFChannel(*hopping_frequency_ptr);
 	}
 	return 1200;
+#endif
 }
 
-uint16_t DevoInit()
+void DEVO_init()
 {	
+	#ifdef ENABLE_PPM
+		if(mode_select) //PPM mode
+		{
+			if(IS_BIND_BUTTON_FLAG_on)
+			{
+				option &= 0xFE;
+				eeprom_write_byte((EE_ADDR)(MODELMODE_EEPROM_OFFSET+RX_num),option);	// reset to autobind mode for the current model
+			}
+			else
+			{	
+				option=eeprom_read_byte((EE_ADDR)(MODELMODE_EEPROM_OFFSET+RX_num));		// load previous mode: autobind or fixed id
+				if(option > 3) option = 0;												// if invalid then it should be autobind
+			}
+		}
+	#endif //ENABLE_PPM
+	switch(sub_protocol)
+	{
+		case 1:
+			num_ch=10;
+			break;
+		case 2:
+			num_ch=12;
+			break;
+		case 3:
+			num_ch=6;
+			break;
+		case 4:
+			num_ch=7;
+			break;
+		default:
+			num_ch=8;
+			break;
+	}
 	DEVO_cyrf_init();
 	CYRF_GetMfgData(cyrfmfg_id);
 	CYRF_SetTxRxMode(TX_EN);
@@ -299,8 +583,13 @@ uint16_t DevoInit()
 
 	packet_count = 0;
 
-	prev_option=option;
-	if(option==0)
+	if(option&0x01)
+	{
+		phase = DEVO_BOUND_1;
+		bind_counter = 0;
+		DEVO_cyrf_set_bound_sop_code();
+	}
+	else
 	{
 		MProtocol_id = ((uint32_t)(hopping_frequency[0] ^ cyrfmfg_id[0] ^ cyrfmfg_id[3]) << 16)
 					 | ((uint32_t)(hopping_frequency[1] ^ cyrfmfg_id[1] ^ cyrfmfg_id[4]) << 8)
@@ -310,13 +599,6 @@ uint16_t DevoInit()
 		phase = DEVO_BIND;
 		BIND_IN_PROGRESS;
 	}
-	else
-	{
-		phase = DEVO_BOUND_1;
-		bind_counter = 0;
-		DEVO_cyrf_set_bound_sop_code();
-	}  
-	return 2400;
 }
 
 #endif

Multiprotocol/E010R5_cyrf6936.ino

@@ -0,0 +1,151 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(E010R5_CYRF6936_INO)
+
+#include "iface_rf2500.h"
+
+#define E010R5_FORCE_ID
+
+#define E010R5_PAYLOAD_SIZE	14
+
+
+static void __attribute__((unused)) E010R5_build_data_packet()
+{
+	packet[ 0] = 0x0D;								// Packet length
+	packet[ 1] = convert_channel_8b(THROTTLE);
+	packet[ 2] = convert_channel_s8b(RUDDER);
+	packet[ 3] = convert_channel_s8b(ELEVATOR);
+	packet[ 4] = convert_channel_s8b(AILERON);
+	packet[ 5] = 0x20;								// Trim Rudder
+	packet[ 6] = 0x20;								// Trim Elevator
+	packet[ 7] = 0x20;								// Trim Aileron
+	packet[ 8] = 0x01								// Flags: high=0x01, low=0x00
+			| GET_FLAG(CH5_SW, 0x04)				//        flip=0x04
+			| GET_FLAG(CH6_SW, 0x08)				//        led=0x08
+			| GET_FLAG(CH8_SW, 0x10)				//		  headless=0x10
+			| GET_FLAG(CH9_SW, 0x20);				//		  one key return=0x20
+	packet[ 9] = IS_BIND_IN_PROGRESS ? 0x80 : 0x00	// Flags: bind=0x80
+			| GET_FLAG(CH7_SW, 0x20)				//        calib=0x20
+			| GET_FLAG(CH10_SW, 0x01);				//		  strange effect=0x01=long press on right button
+	packet[10] = rx_tx_addr[0];
+	packet[11] = rx_tx_addr[1];
+	packet[12] = rx_tx_addr[2];
+	packet[13] = 0x9D;								// Check
+	for(uint8_t i=0;i<13;i++)
+		packet[13] += packet[i];
+
+	RF2500_BuildPayload(packet);
+}
+
+uint16_t E010R5_callback()
+{
+	//Bind
+	if(bind_counter)
+		if(--bind_counter==0)
+			BIND_DONE;
+
+	//Send packet
+	RF2500_SendPayload();
+	
+	//Timing and hopping
+	packet_count++;
+	switch(packet_count)
+	{
+		case 1:
+		case 2:
+		case 4:
+		case 5:
+			return 1183;
+		default:
+			hopping_frequency_no++;
+			hopping_frequency_no &= 3;
+			if(IS_BIND_IN_PROGRESS)
+				rf_ch_num = 0x30 + (hopping_frequency_no<<3);
+			else
+				rf_ch_num = hopping_frequency[hopping_frequency_no];
+			RF2500_RFChannel(rf_ch_num);
+			RF2500_SetPower();
+			packet_count = 0;
+		case 3:
+			E010R5_build_data_packet();
+			return 3400;
+	}
+	return 0;
+}
+
+void E010R5_init()
+{
+	BIND_IN_PROGRESS;									// Autobind protocol
+	bind_counter = 2600;
+
+	//RF2500 emu init
+	RF2500_Init(E010R5_PAYLOAD_SIZE, false);			// 14 bytes, not scrambled
+	RF2500_SetTXAddr((uint8_t*)"\x0E\x54\x96\xEE");		// Same address for bind and normal packets
+	
+	rx_tx_addr[0]=0x00;
+	hopping_frequency[0]=0x35;	//53
+	#ifdef E010R5_FORCE_ID
+		switch(rx_tx_addr[3]%5)
+		{
+			case 0:
+				//TX1
+				//hopping_frequency[0]=0x35;	//53
+				hopping_frequency[1]=0x30;		//48
+				rx_tx_addr[1]=0x45;
+				rx_tx_addr[2]=0x46;
+				break;
+			case 1:
+				//TX2
+				//hopping_frequency[0]=0x35;	//53
+				hopping_frequency[1]=0x3C;		//60
+				rx_tx_addr[1]=0x1B;
+				rx_tx_addr[2]=0x9E;
+				break;
+			case 2:
+				//TX4
+				hopping_frequency[0]=0x30;		//48
+				hopping_frequency[1]=0x38;		//56
+				rx_tx_addr[1]=0x2E;
+				rx_tx_addr[2]=0xAE;
+				break;
+			case 3:
+				//TX5
+				//hopping_frequency[0]=0x35;	//53
+				hopping_frequency[1]=0x41;		//65
+				rx_tx_addr[0]=0x0D;
+				rx_tx_addr[1]=0xB9;
+				rx_tx_addr[2]=0xFC;
+				break;
+			default:
+				//TX3
+				hopping_frequency[0]=0x30;		//48
+				hopping_frequency[1]=0x38;		//56
+				rx_tx_addr[1]=0x17;
+				rx_tx_addr[2]=0x0D;
+				break;
+		}
+    #endif
+	// This is the same as the E010 v1...
+	hopping_frequency[2]=hopping_frequency[0]+0x10;
+	hopping_frequency[3]=hopping_frequency[1]+0x10;
+
+	E010R5_build_data_packet();
+	RF2500_RFChannel(hopping_frequency[0]);
+	hopping_frequency_no=0;
+	packet_count=0;
+}
+
+#endif

Multiprotocol/E016HV2_cc2500.ino

@@ -0,0 +1,157 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(E016HV2_CC2500_INO)
+
+#include "iface_cc2500.h"
+
+//#define FORCE_E016HV2_ORIGINAL_ID
+
+#define E016HV2_INITIAL_WAIT		500
+#define E016HV2_PACKET_PERIOD		10000
+#define E016HV2_RF_BIND_CHANNEL	5
+#define E016HV2_PAYLOAD_SIZE		11
+#define E016HV2_BIND_COUNT		300	//3sec
+
+static void __attribute__((unused)) E016HV2_send_packet()
+{
+	//payload length (after this byte)
+	packet[0 ] = 0x0A;
+	
+	//bind indicator
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[1 ] = 0x02;
+		if(bind_counter)
+			bind_counter--;
+		else
+		{
+			BIND_DONE;
+			CC2500_250K_RFChannel(rf_ch_num);			// Set main channel
+		}
+	}
+	else
+		packet[1 ] = 0x20;
+	
+	//ID
+	packet[2 ] = rx_tx_addr[2];
+	packet[3 ] = rx_tx_addr[3];
+
+	//channels TREA
+	uint8_t channel;
+	if(IS_BIND_IN_PROGRESS)
+		channel=0x64;								// Throttle must be centered during bind
+	else
+		channel=convert_channel_8b_limit_deadband(THROTTLE,0x00,0x64,0xC8, 20);
+	packet[4 ]  = channel;
+	channel=convert_channel_16b_limit(RUDDER,0x00,0xC8);
+	packet[5 ]  = channel;
+	channel=convert_channel_16b_limit(ELEVATOR,0x00,0xC8);
+	packet[6 ]  = channel;
+	channel=convert_channel_16b_limit(AILERON,0x00,0xC8);
+	packet[7 ]  = channel;
+
+	//flags
+	if(CH8_SW && !phase) //toggle calib flag
+		flags ^= 0x40;
+	phase=CH8_SW;
+
+	packet[8 ] = GET_FLAG(CH7_SW,  0x01)			// 0x01=Flip
+			   | GET_FLAG(CH9_SW,  0x02)			// 0x02=Headless
+			   | GET_FLAG(CH10_SW, 0x04)			// 0x04=One Key Return
+			   | flags;								// 0x40=Calib
+
+	packet[9 ] = 0x02;								// Speed control 0x00:low, 0x01:medium, 0x02:high
+	
+	packet[10] = GET_FLAG(CH5_SW, 0x01)				// 0x01=TakeOff/Land  (momentary switch)
+			   | GET_FLAG(CH6_SW, 0x04);			// 0x04=Emergeny Stop (momentary switch)
+
+	CC2500_SetPower();								// Set tx_power
+	CC2500_SetFreqOffset();							// Set frequency offset
+
+	//Build real packet and send it
+	static uint8_t pid=0;
+	crc=0;
+	
+	// stop TX/RX
+	CC2500_Strobe(CC2500_SIDLE);
+	// flush tx FIFO
+	CC2500_Strobe(CC2500_SFTX);
+	// packet length
+	CC2500_WriteReg(CC2500_3F_TXFIFO, 6 + 4 + 1 + 11 + 2);	// preamble + address + packet_control + payload + crc
+
+	// preamble+address
+	CC2500_WriteRegisterMulti(CC2500_3F_TXFIFO, (uint8_t*)"\xAA\xAA\xAA\xAA\xAA\xAA\xE7\xE7\xE7\xE7", 10);
+
+	// packet control
+	CC2500_WriteReg(CC2500_3F_TXFIFO, 0x50+(pid<<2));
+	pid++;
+
+	// payload
+	//debug("P:")
+	for (uint8_t i = 0; i < E016HV2_PAYLOAD_SIZE; ++i)
+	{
+		uint8_t byte = (bit_reverse(packet[i])<<1) | (packet[i+1]&0x01);
+		//debug(" %02X",byte)
+		CC2500_WriteReg(CC2500_3F_TXFIFO,byte);
+		crc16_update(byte, 8);
+	}
+
+	// crc
+	CC2500_WriteReg(CC2500_3F_TXFIFO,crc >> 8);
+	CC2500_WriteReg(CC2500_3F_TXFIFO,crc);
+	//debugln(" %04X",crc)
+
+	// transmit
+	CC2500_Strobe(CC2500_STX);
+}
+
+uint16_t E016HV2_callback()
+{
+	E016HV2_send_packet();
+	return E016HV2_PACKET_PERIOD;
+}
+
+void E016HV2_init()
+{
+	//Config CC2500
+	CC2500_250K_Init();
+	CC2500_250K_RFChannel(E016HV2_RF_BIND_CHANNEL);		// Set bind channel
+
+	#ifdef FORCE_E016HV2_ORIGINAL_ID
+		rx_tx_addr[2]=0x27;
+		rx_tx_addr[3]=0x1B;
+		//rf_ch_num = 44;
+	#endif
+	//General ID
+	//3F1B -> 68,2C1B -> 49,2B1B -> 48,2A1B -> 47,291B -> 46,281B -> 45,271B -> 44,261B -> 43,251B -> 42
+	//241B -> no bind,231B -> no bind,221B -> 71,211B -> 70,201B -> 69,1F1B -> 68,1E1B -> 67,1D1B -> 66,1C1B -> 65,1B1B -> 64,1A1B -> 63,191B -> 62,181B -> 61,171B -> 60,161B -> 59
+	//0C1B -> 49,051B -> 42,041B -> no bind,031B -> no bind,021B -> 71,011B -> 70,001B -> no bind
+	if(rx_tx_addr[2]<3) rx_tx_addr[2]+=3;			// rx_tx_addr[2]=0 is invalid
+	if(rx_tx_addr[3]==0) rx_tx_addr[3]+=64;			// rx_tx_addr[3]=0 is invalid
+	rf_ch_num = (rx_tx_addr[2] + rx_tx_addr[3]) % 32 + 42;
+	if(rf_ch_num>71)								// channels 72 and 73 are invalid
+	{
+		rx_tx_addr[2]-=2;
+		rf_ch_num-=2;
+	}
+	
+	phase=CH8_SW;
+	flags=0;
+	bind_counter = E016HV2_BIND_COUNT;
+	BIND_IN_PROGRESS;								// Autobind protocol
+}
+
+#endif

Multiprotocol/E016H_nrf24l01.ino

@@ -0,0 +1,154 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// compatible with E016H
+
+#if defined(E016H_NRF24L01_INO)
+
+#include "iface_xn297.h"
+
+//Protocols constants
+#define E016H_BIND_COUNT		500
+#define E016H_ADDRESS_LENGTH	5
+
+#define E016H_PACKET_PERIOD		4080
+#define E016H_PACKET_SIZE		10
+#define E016H_BIND_CHANNEL		80
+#define E016H_NUM_CHANNELS		4
+
+//Channels
+#define E016H_STOP_SW			CH5_SW
+#define E016H_FLIP_SW			CH6_SW
+#define E016H_HEADLESS_SW		CH8_SW
+#define E016H_RTH_SW			CH9_SW
+
+// E016H flags packet[1]
+#define E016H_FLAG_CALIBRATE	0x80
+#define E016H_FLAG_STOP			0x20
+#define E016H_FLAG_FLIP			0x04
+// E016H flags packet[3]
+#define E016H_FLAG_HEADLESS		0x10
+#define E016H_FLAG_RTH			0x04
+// E016H flags packet[7]
+#define E016H_FLAG_TAKEOFF		0x80
+#define E016H_FLAG_HIGHRATE		0x08
+
+static void __attribute__((unused)) E016H_send_packet()
+{
+    uint8_t can_flip = 0, calibrate = 1;
+
+	if(IS_BIND_IN_PROGRESS)
+	{
+		memcpy(packet, &rx_tx_addr[1], 4);
+		memcpy(&packet[4], hopping_frequency, 4);
+		packet[8] = 0x23;
+	}
+	else
+	{
+		// trim commands
+		packet[0] = 0;
+		// aileron
+		uint16_t val = convert_channel_16b_limit(AILERON, 0, 0x3ff);
+		can_flip |= (val < 0x100) || (val > 0x300);
+		packet[1] = val >> 8;
+		packet[2] = val & 0xff;
+		if(val < 0x300) calibrate = 0;
+		// elevator
+		val = convert_channel_16b_limit(ELEVATOR, 0x3ff, 0);
+		can_flip |= (val < 0x100) || (val > 0x300);
+		packet[3] = val >> 8;
+		packet[4] = val & 0xff;
+		if(val < 0x300) calibrate = 0;
+		// throttle
+		val = convert_channel_16b_limit(THROTTLE, 0, 0x3ff);
+		packet[5] = val >> 8;
+		packet[6] = val & 0xff;
+		if(val > 0x100) calibrate = 0;
+		// rudder
+		val = convert_channel_16b_limit(RUDDER, 0, 0x3ff);
+		packet[7] = val >> 8;
+		packet[8] = val & 0xff;
+		if(val > 0x100) calibrate = 0;
+		// flags
+		packet[1] |= GET_FLAG(E016H_STOP_SW, E016H_FLAG_STOP)
+				  |  (can_flip ? GET_FLAG(E016H_FLIP_SW, E016H_FLAG_FLIP) : 0)
+				  |  (calibrate ? E016H_FLAG_CALIBRATE : 0);
+		packet[3] |= GET_FLAG(E016H_HEADLESS_SW, E016H_FLAG_HEADLESS)
+				  |  GET_FLAG(E016H_RTH_SW, E016H_FLAG_RTH);
+		packet[7] |= E016H_FLAG_HIGHRATE;
+		// frequency hopping
+		XN297_Hopping(hopping_frequency_no++ & 0x03);
+	}
+	// checksum
+	packet[9] = packet[0];
+	for (uint8_t i=1; i < E016H_PACKET_SIZE-1; i++)
+		packet[9] += packet[i];
+
+	// Send
+	XN297_SetPower();
+	XN297_SetTxRxMode(TX_EN);
+	XN297_WritePayload(packet, E016H_PACKET_SIZE);
+}
+
+static void __attribute__((unused)) E016H_RF_init()
+{
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
+	XN297_SetTXAddr((uint8_t *)"\x5a\x53\x46\x30\x31", 5);  // bind address
+	//XN297_HoppingCalib(E016H_NUM_CHANNELS);
+	XN297_RFChannel(E016H_BIND_CHANNEL);
+}
+
+uint16_t E016H_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(packet_period);
+	#endif
+	if(bind_counter)
+	{
+		bind_counter--;
+		if (bind_counter == 0)
+		{
+			XN297_SetTXAddr(rx_tx_addr, E016H_ADDRESS_LENGTH);
+			BIND_DONE;
+		}
+	}
+	E016H_send_packet();
+	return E016H_PACKET_PERIOD;
+}
+
+static void __attribute__((unused)) E016H_initialize_txid()
+{
+	// tx id
+    rx_tx_addr[0] = 0xa5;
+    rx_tx_addr[1] = 0x00;
+
+    // rf channels
+    uint32_t lfsr=random(0xfefefefe);
+    for(uint8_t i=0; i<E016H_NUM_CHANNELS; i++)
+    {
+		hopping_frequency[i] = (lfsr & 0xFF) % 80; 
+		lfsr>>=8;
+	}
+}
+
+void E016H_init()
+{
+	BIND_IN_PROGRESS;
+	E016H_initialize_txid();
+	E016H_RF_init();
+	bind_counter = E016H_BIND_COUNT;
+	hopping_frequency_no = 0;
+}
+
+#endif

Multiprotocol/E01X_cyrf6936.ino

@@ -0,0 +1,239 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// compatible with E012 and E015
+
+#if defined(E01X_CYRF6936_INO)
+
+#include "iface_hs6200.h"
+
+//Protocols constants
+#define E01X_BIND_COUNT			500
+#define E01X_INITIAL_WAIT		500
+#define E01X_ADDRESS_LENGTH		5
+
+#define E012_PACKET_PERIOD		4525
+#define E012_RF_BIND_CHANNEL	0x3c
+#define E012_NUM_RF_CHANNELS	4
+#define E012_PACKET_SIZE		15
+
+//#define E015_FORCE_ID
+#define E015_PACKET_PERIOD		9000
+#define E015_RF_CHANNEL			0x2d	// 2445 MHz
+#define E015_PACKET_SIZE		10
+#define E015_BIND_PACKET_SIZE	9
+
+//Channels
+#define E01X_ARM_SW			CH5_SW
+#define E016H_STOP_SW		CH5_SW
+#define E01X_FLIP_SW		CH6_SW
+#define E01X_LED_SW			CH7_SW
+#define E01X_HEADLESS_SW	CH8_SW
+#define E01X_RTH_SW			CH9_SW
+
+// E012 flags packet[1]
+#define E012_FLAG_FLIP		0x40
+#define E012_FLAG_HEADLESS	0x10
+#define E012_FLAG_RTH		0x04
+// E012 flags packet[7]
+#define E012_FLAG_EXPERT	0x02
+
+// E015 flags packet[6]
+#define E015_FLAG_DISARM	0x80
+#define E015_FLAG_ARM		0x40
+// E015 flags packet[7]
+#define E015_FLAG_FLIP		0x80
+#define E015_FLAG_HEADLESS	0x10
+#define E015_FLAG_RTH		0x08
+#define E015_FLAG_LED		0x04
+#define E015_FLAG_EXPERT	0x02
+#define E015_FLAG_INTERMEDIATE 0x01
+
+static void __attribute__((unused)) E015_check_arming()
+{
+	uint8_t arm_channel = E01X_ARM_SW;
+
+	if (arm_channel != arm_channel_previous)
+	{
+		arm_channel_previous = arm_channel;
+		if (arm_channel)
+		{
+			armed = 1;
+			arm_flags ^= E015_FLAG_ARM;
+		}
+		else
+		{
+			armed = 0;
+			arm_flags ^= E015_FLAG_DISARM;
+		}
+	}
+}
+
+static void __attribute__((unused)) E01X_send_packet()
+{
+	if(sub_protocol==E012)
+	{
+		packet_length=E012_PACKET_SIZE;
+		packet[0] = rx_tx_addr[1];
+		if(IS_BIND_IN_PROGRESS)
+		{
+			rf_ch_num = E012_RF_BIND_CHANNEL;
+			packet[1] = 0xaa;
+			memcpy(&packet[2], hopping_frequency, E012_NUM_RF_CHANNELS);
+			memcpy(&packet[6], rx_tx_addr, E01X_ADDRESS_LENGTH);
+		}
+		else
+		{
+			rf_ch_num = hopping_frequency[hopping_frequency_no++];
+			hopping_frequency_no %= E012_NUM_RF_CHANNELS;
+			packet[1] = 0x01
+				| GET_FLAG(E01X_RTH_SW,			E012_FLAG_RTH)
+				| GET_FLAG(E01X_HEADLESS_SW,	E012_FLAG_HEADLESS)
+				| GET_FLAG(E01X_FLIP_SW,		E012_FLAG_FLIP);
+			packet[2] = convert_channel_16b_limit(AILERON,  0xc8, 0x00); // aileron
+			packet[3] = convert_channel_16b_limit(ELEVATOR, 0x00, 0xc8); // elevator
+			packet[4] = convert_channel_16b_limit(RUDDER,   0xc8, 0x00); // rudder
+			packet[5] = convert_channel_16b_limit(THROTTLE, 0x00, 0xc8); // throttle
+			packet[6] = 0xaa;
+			packet[7] = E012_FLAG_EXPERT;	// rate (0-2)
+			packet[8] = 0x00;
+			packet[9] = 0x00;
+			packet[10]= 0x00;
+		}
+		packet[11] = 0x00;
+		packet[12] = 0x00;
+		packet[13] = 0x56; 
+		packet[14] = rx_tx_addr[2];
+	}
+	else
+	{ // E015
+		rf_ch_num = E015_RF_CHANNEL;
+		if(IS_BIND_IN_PROGRESS)
+		{
+			packet[0] = 0x18;
+			packet[1] = 0x04;
+			packet[2] = 0x06;
+			// data phase address
+			memcpy(&packet[3], rx_tx_addr, E01X_ADDRESS_LENGTH);
+			packet[8] = 0x63;	// unknown calculation
+			// checksum
+			//packet[8] = packet[3];
+			//for(uint8_t i=4; i<8; i++)
+			//	packet[8] += packet[i];
+			packet_length=E015_BIND_PACKET_SIZE;
+		}
+		else
+		{
+			E015_check_arming();
+			packet[0] = convert_channel_16b_limit(THROTTLE,	0, 225); // throttle
+			packet[1] = convert_channel_16b_limit(RUDDER,   225, 0); // rudder
+			packet[2] = convert_channel_16b_limit(AILERON,  0, 225); // aileron
+			packet[3] = convert_channel_16b_limit(ELEVATOR, 225, 0); // elevator
+			packet[4] = 0x20; // elevator trim
+			packet[5] = 0x20; // aileron trim
+			packet[6] = arm_flags;
+			packet[7] = E015_FLAG_EXPERT
+				| GET_FLAG(E01X_FLIP_SW,	E015_FLAG_FLIP)
+				| GET_FLAG(E01X_LED_SW,		E015_FLAG_LED)
+				| GET_FLAG(E01X_HEADLESS_SW,E015_FLAG_HEADLESS)
+				| GET_FLAG(E01X_RTH_SW,		E015_FLAG_RTH);
+			packet[8] = 0;
+			// checksum
+			packet[9] = packet[0];
+			for(uint8_t i=1; i<9; i++)
+				packet[9] += packet[i];
+			packet_length=E015_PACKET_SIZE;
+		}
+	}
+
+	HS6200_RFChannel(rf_ch_num);
+	HS6200_SetPower();
+	delayMicroseconds(270);		// Wait for RF channel to settle
+	HS6200_SendPayload(packet, packet_length);
+}
+
+static void __attribute__((unused)) E01X_RF_init()
+{
+	HS6200_Init(true);	// CRC enabled
+
+	if(sub_protocol==E012)
+		HS6200_SetTXAddr((uint8_t *)"\x55\x42\x9C\x8F\xC9", E01X_ADDRESS_LENGTH);
+	else //E015
+		HS6200_SetTXAddr((uint8_t *)"\x62\x54\x79\x38\x53", E01X_ADDRESS_LENGTH);
+}
+
+uint16_t E01X_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(packet_period);
+	#endif
+	if(bind_counter)
+	{
+		bind_counter--;
+		if (bind_counter == 0)
+		{
+			HS6200_SetTXAddr(rx_tx_addr,  E01X_ADDRESS_LENGTH);
+			BIND_DONE;
+		}
+	}
+	E01X_send_packet();
+	return packet_period;
+}
+
+static void __attribute__((unused)) E012_initialize_txid()
+{
+    // rf channels
+    uint32_t lfsr=random(0xfefefefe);
+    for(uint8_t i=0; i<E012_NUM_RF_CHANNELS; i++)
+    {
+		hopping_frequency[i] = 0x10 + ((lfsr & 0xff) % 0x32); 
+		lfsr>>=8;
+	}
+}
+
+void E01X_init()
+{
+	BIND_IN_PROGRESS;
+	if(sub_protocol==E012)
+	{
+		E012_initialize_txid();
+		packet_period=E012_PACKET_PERIOD;
+	}
+	else //E015
+	{
+		#ifdef E015_FORCE_ID
+			rx_tx_addr[0] = 0x06;
+			rx_tx_addr[1] = 0xC6;
+			rx_tx_addr[2] = 0xB7;
+			rx_tx_addr[3] = 0x56;
+			rx_tx_addr[4] = 0x8A;
+		#endif
+
+		//force the sum to give 0x63 since the id calculation is unknown
+		uint8_t sum=0x63;
+		for(uint8_t i=0; i < 4; i++)
+			sum -= rx_tx_addr[i];
+		rx_tx_addr[4] = sum;
+
+		packet_period=E015_PACKET_PERIOD;
+		armed = 0;
+		arm_flags = 0;
+		arm_channel_previous = E01X_ARM_SW;
+	}
+	E01X_RF_init();
+	bind_counter = E01X_BIND_COUNT;
+	hopping_frequency_no = 0;
+}
+
+#endif

Multiprotocol/E129_cyrf6936.ino

@@ -0,0 +1,177 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(E129_CYRF6936_INO)
+
+#include "iface_rf2500.h"
+
+//#define E129_FORCE_ID
+//#define C186_FORCE_ID
+
+#define E129_BIND_CH		0x2D	//45
+#define E129_PAYLOAD_SIZE	16
+#define C186_PAYLOAD_SIZE	19
+
+static void __attribute__((unused)) E129_build_data_packet()
+{
+	//Build the packet
+	memset(packet,0,packet_length);
+	packet[ 0] = packet_length - 1;						// Packet length
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[ 1] = 0xA4;
+		packet[ 2] = bit_reverse(rx_tx_addr[2]);
+		packet[ 3] = bit_reverse(rx_tx_addr[3]);
+		packet[ 4] = bit_reverse(rx_tx_addr[0]);
+		packet[ 5] = bit_reverse(rx_tx_addr[1]);
+		for(uint8_t i=0; i<4; i++)
+			packet[6+i]=hopping_frequency[i]-2;
+	}
+	else
+	{
+		packet[ 1] = 0xA6;
+		//Flags
+		if(sub_protocol == E129_E129)
+			packet[ 2] = 0xF7;							// High rate 0xF7, low 0xF4
+		else //C186
+		{
+			packet[ 2] = 0xFA;							// High rate 0xFA, medium 0xF7, low 0xF4
+			packet[13] = bit_reverse(rx_tx_addr[2]);
+			packet[14] = bit_reverse(rx_tx_addr[3]);
+			packet[15] = bit_reverse(rx_tx_addr[0]);
+			packet[16] = bit_reverse(rx_tx_addr[1]);
+		}
+		//packet[ 3] = 0x00;							// E129 Mode: short press=0x20->0x00->0x20->..., long press=0x10->0x30->0x10->... => C186 throttle trim is doing the same:up=short press and down=long press
+		packet[ 4] = GET_FLAG(CH5_SW, 0x20)				// Take off/Land 0x20
+				   | GET_FLAG(CH6_SW, 0x04);			// Emergency stop 0x04
+		//Channels and trims
+		uint16_t val = convert_channel_10b(AILERON,false);
+		uint8_t trim = convert_channel_8b(CH7) & 0xFC;
+		packet[ 5] = trim | (val >>8);					// Trim (0x00..0x1F..0x3E) << 2 | channel >> 8
+		packet[ 6] = val;								// channel (0x000...0x200...0x3FF)
+		val = convert_channel_10b(ELEVATOR,false);
+		trim = convert_channel_8b(CH8) & 0xFC;
+		packet[ 7] = trim | (val >>8);					// Trim (0x00..0x1F..0x3E) << 2 | channel >> 8
+		packet[ 8] = val;								// channel (0x000...0x200...0x3FF)
+		if(packet_count>200)
+			val = convert_channel_10b(THROTTLE,false);
+		else
+		{//Allow bind to complete with throttle not centered
+			packet_count++;
+			val=0x200;
+		}
+		packet[ 9] = (0x1F<<2) | (val >>8);				// Trim (0x00..0x1F..0x3E) << 2 | channel >> 8
+		packet[10] = val;								// channel (0x000...0x200...0x3FF)
+		val = convert_channel_10b(RUDDER,false);
+		trim = convert_channel_8b(CH9) & 0xFC;
+		packet[11] = trim | (val >>8);					// Trim (0x00..0x1F..0x3E) << 2 | channel >> 8
+		packet[12] = val;								// channel (0x000...0x200...0x3FF)
+	}
+	//Check
+	if(sub_protocol == E129_E129)
+		packet[packet_length-2] = packet[0] + packet[1];
+	else
+		packet[packet_length-2] = 0x24 + packet[0] + (packet[1]&0x03);	// ??
+	for(uint8_t i=2;i<packet_length-2;i++)
+		packet[packet_length-2] += packet[i];
+		
+	RF2500_BuildPayload(packet);
+}
+
+uint16_t E129_callback()
+{
+	//Set RF channel
+	if(phase==0)
+		RF2500_RFChannel(IS_BIND_IN_PROGRESS ? E129_BIND_CH : hopping_frequency[hopping_frequency_no]);
+
+	//Send packet
+	RF2500_SendPayload();
+	
+	//E129 sends twice on same channel, not the C186 but there is a bug somewhere if I don't send the packets back to back
+	if(phase==0)
+	{
+		phase++;
+		return 1260;
+	}
+
+	//Bind
+	if(bind_counter)
+		if(--bind_counter==0)
+		{
+			BIND_DONE;
+			RF2500_SetTXAddr(rx_tx_addr);	// 4 bytes of address
+		}
+
+	//Build packet
+	E129_build_data_packet();
+	
+	//Set power
+	RF2500_SetPower();
+	
+	//Hopp
+	hopping_frequency_no++;
+	hopping_frequency_no &= 3;
+
+	phase=0;
+	if(sub_protocol==E129_E129)
+		return 5200-1260;
+	return 5500-1260;						//E129_C186
+}
+
+void E129_init()
+{
+	BIND_IN_PROGRESS;						// Autobind protocol
+    bind_counter = 384;						// ~2sec
+
+	//RF2500 emu init
+	packet_length = sub_protocol == E129_E129?E129_PAYLOAD_SIZE:C186_PAYLOAD_SIZE;
+	RF2500_Init(packet_length, true);		// 16/19 bytes, Scrambled
+   
+	//Freq hopping
+	calc_fh_channels(4);
+	for(uint8_t i=0; i<4; i++)
+		if(hopping_frequency[i]==E129_BIND_CH)
+			hopping_frequency[i]++;
+	
+    #ifdef E129_FORCE_ID
+        rx_tx_addr[0]=0xC1;
+        rx_tx_addr[1]=0x22;
+        rx_tx_addr[2]=0x05;
+        rx_tx_addr[3]=0xA3;
+        hopping_frequency[0]=0x3C;			//60
+        hopping_frequency[1]=0x49;			//73
+        hopping_frequency[2]=0x4B;			//75
+        hopping_frequency[3]=0x41;			//65
+    #endif
+    #ifdef C186_FORCE_ID
+        rx_tx_addr[0]=0x91;
+        rx_tx_addr[1]=0x02;
+        rx_tx_addr[2]=0x5D;
+        rx_tx_addr[3]=0x33;
+        hopping_frequency[0]=0x44 + 2;
+        hopping_frequency[1]=0x41 + 2;
+        hopping_frequency[2]=0x43 + 2;
+        hopping_frequency[3]=0x49 + 2;
+    #endif
+
+	RF2500_SetTXAddr((uint8_t*)"\xE2\x32\xE0\xC8");	// 4 bytes of bind address
+
+	E129_build_data_packet();
+	hopping_frequency_no=0;
+	packet_count=0;
+	phase=0;
+}
+
+#endif

Multiprotocol/ESky150_nrf24l01.ino

@@ -0,0 +1,176 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+//  ESky protocol for small models since 2014 (150, 300, 150X, ...)
+
+#if defined(ESKY150_NRF24L01_INO)
+
+#include "iface_nrf24l01.h"
+
+#define ESKY150_PAYLOADSIZE 15
+#define ESKY150_TX_ADDRESS_SIZE 4
+#define ESKY150_BINDING_PACKET_PERIOD	2000
+#define ESKY150_SENDING_PACKET_PERIOD	4800
+
+static void __attribute__((unused)) ESKY150_RF_init()
+{
+	//Original TX always sets for channelx 0x22 and 0x4a
+	// Use channels 2..79
+	hopping_frequency[0] = rx_tx_addr[3]%37+2;
+	hopping_frequency[1] = hopping_frequency[0] + 40;
+
+	NRF24L01_Initialize();
+	NRF24L01_WriteReg(NRF24L01_03_SETUP_AW, 0x02);   // 4-byte RX/TX address
+	NRF24L01_SetBitrate(NRF24L01_BR_2M);
+	NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, ESKY150_PAYLOADSIZE);   // bytes of data payload for pipe 0
+	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, rx_tx_addr, ESKY150_TX_ADDRESS_SIZE);
+
+	NRF24L01_WriteReg(NRF24L01_1C_DYNPD, 1); // Dynamic payload for data pipe 0
+	// Enable: Dynamic Payload Length, Payload with ACK , W_TX_PAYLOAD_NOACK
+	NRF24L01_WriteReg(NRF24L01_1D_FEATURE, _BV(NRF2401_1D_EN_DPL) | _BV(NRF2401_1D_EN_ACK_PAY) | _BV(NRF2401_1D_EN_DYN_ACK));
+
+	NRF24L01_SetTxRxMode(TX_EN);						// Clear data ready, data sent, retransmit and enable CRC 16bits, ready for TX
+}
+
+static void __attribute__((unused)) ESKY150_bind_init()
+{
+	uint8_t ESKY150_addr[ESKY150_TX_ADDRESS_SIZE] = { 0x73, 0x73, 0x74, 0x63 }; //This RX address "sstc" is fixed for ESky2
+
+	// Build packet
+	packet[0]  = rx_tx_addr[0];
+	packet[1]  = rx_tx_addr[1];
+	packet[2]  = rx_tx_addr[2];
+	packet[3]  = rx_tx_addr[3]; 
+	packet[4]  = ESKY150_addr[0];
+	packet[5]  = ESKY150_addr[1];
+	packet[6]  = ESKY150_addr[2];
+	packet[7]  = ESKY150_addr[3];
+	packet[8]  = rx_tx_addr[0];
+	packet[9]  = rx_tx_addr[1];
+	packet[10] = rx_tx_addr[2];
+	packet[11] = rx_tx_addr[3]; 
+	packet[12] = 0;
+	packet[13] = 0;
+	packet[14] = 0;
+
+	// Bind address
+	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, ESKY150_addr, ESKY150_TX_ADDRESS_SIZE);
+	NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0, ESKY150_addr, ESKY150_TX_ADDRESS_SIZE);
+	
+	// Bind Channel 1
+	NRF24L01_WriteReg(NRF24L01_05_RF_CH, 1);
+}
+
+static void __attribute__((unused)) ESKY150_send_packet()
+{
+	// Build packet
+	uint16_t throttle=convert_channel_16b_limit(THROTTLE,1000,2000);
+	uint16_t aileron=convert_channel_16b_limit(AILERON,1000,2000);
+	uint16_t elevator=convert_channel_16b_limit(ELEVATOR,1000,2000);
+	uint16_t rudder=convert_channel_16b_limit(RUDDER,1000,2000);
+	//set unused channels to zero, for compatibility with older 4 channel models
+	uint8_t flight_mode=0;
+	uint16_t aux_ch6=0;
+	uint8_t aux_ch7=0;
+	if(sub_protocol)
+	{ // 7 channels
+		flight_mode=ESKY150_convert_2bit_channel(CH5);
+		aux_ch6=convert_channel_16b_limit(CH6,1000,2000);
+		aux_ch7=ESKY150_convert_2bit_channel(CH7);
+	}
+	packet[0]  = hopping_frequency[0];
+	packet[1]  = hopping_frequency[1];
+	packet[2]  = ((flight_mode << 6) & 0xC0) | ((aux_ch7 << 4) & 0x30) | ((throttle >> 8) & 0xFF);
+	packet[3]  = throttle & 0xFF;
+	packet[4]  = ((aux_ch6 >> 4) & 0xF0) | ((aileron >> 8) & 0xFF); //and 0xFF works as values are anyways not bigger than 12 bits, but faster code like that
+	packet[5]  = aileron  & 0xFF;
+	packet[6]  = (aux_ch6 & 0xF0) | ((elevator >> 8) & 0xFF); //and 0xFF works as values are anyways not bigger than 12 bits, but faster code like that
+	packet[7]  = elevator & 0xFF;
+	packet[8]  = ((aux_ch6 << 4) & 0xF0) | ((rudder >> 8) & 0xFF); //and 0xFF works as values are anyways not bigger than 12 bits, but faster code like that
+	packet[9]  = rudder & 0xFF;
+	// The next 4 Bytes are sint8 trim values (TAER). As trims are already included within normal outputs, these values are set to zero.
+	packet[10] = 0x00;
+	packet[11] = 0x00;
+	packet[12] = 0x00;
+	packet[13] = 0x00;
+	// Calculate checksum:
+	uint8_t sum = 0;
+	for (uint8_t i = 0; i < 14; ++i)
+		sum += packet[i];
+	packet[14] = sum;
+
+	// Hop on 2 channels
+	hopping_frequency_no++;
+	hopping_frequency_no&=0x01;
+	NRF24L01_WriteReg(NRF24L01_05_RF_CH, hopping_frequency[hopping_frequency_no]);
+
+	// Clear packet status bits and TX FIFO
+	NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);
+	NRF24L01_FlushTx();
+
+	// Send packet
+	NRF24L01_WritePayload(packet, ESKY150_PAYLOADSIZE);
+
+	//Keep transmit power updated
+	NRF24L01_SetPower();
+}
+
+uint8_t ESKY150_convert_2bit_channel(uint8_t num)
+{
+	if(Channel_data[num] > CHANNEL_MAX_COMMAND)
+		return 0x03;
+	else
+		if(Channel_data[num] < CHANNEL_MIN_COMMAND)
+			return 0x00;
+		else
+			if(Channel_data[num] > CHANNEL_SWITCH)
+				return 0x02;
+	return 0x01;	
+}
+
+uint16_t ESKY150_callback()
+{
+	if(IS_BIND_DONE)
+	{
+		#ifdef MULTI_SYNC
+			telemetry_set_input_sync(ESKY150_SENDING_PACKET_PERIOD);
+		#endif
+		ESKY150_send_packet();
+	}
+	else
+	{
+		NRF24L01_WritePayload(packet, ESKY150_PAYLOADSIZE);
+		if (--bind_counter == 0)
+		{
+			BIND_DONE;
+			// Change TX address from bind to normal mode
+			NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, rx_tx_addr, ESKY150_TX_ADDRESS_SIZE);
+		}
+		return ESKY150_BINDING_PACKET_PERIOD;
+	}
+	return ESKY150_SENDING_PACKET_PERIOD;
+}
+
+void ESKY150_init(void)
+{
+	ESKY150_RF_init();
+	if(IS_BIND_IN_PROGRESS)
+	{
+		bind_counter=3000;
+		ESKY150_bind_init();
+	}
+	hopping_frequency_no=0;
+}
+
+#endif

Multiprotocol/ESky150v2_cc2500.ino

@@ -0,0 +1,138 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(ESKY150V2_CC2500_INO)
+
+#include "iface_nrf250k.h"
+
+//#define ESKY150V2_FORCE_ID
+
+#define ESKY150V2_PAYLOADSIZE 40
+#define ESKY150V2_BINDPAYLOADSIZE 150
+#define ESKY150V2_NFREQCHANNELS 70
+#define ESKY150V2_TXID_SIZE 4
+#define ESKY150V2_BIND_CHANNEL 0x00
+#define ESKY150V2_PACKET_PERIOD 10000
+#define ESKY150V2_BINDING_PACKET_PERIOD 57000
+
+#ifdef ESKY150V2_FORCE_ID
+const uint8_t PROGMEM ESKY150V2_hop[ESKY150V2_NFREQCHANNELS]= {
+	0x07, 0x47, 0x09, 0x27, 0x0B, 0x42, 0x0D, 0x35, 0x17, 0x40, 0x26, 0x3D, 0x16, 0x43, 0x06, 0x2A, 0x24, 0x44,
+	0x0E, 0x38, 0x20, 0x48, 0x22, 0x2D, 0x2B, 0x39, 0x0F, 0x36, 0x23, 0x46, 0x14, 0x3B, 0x1A, 0x41, 0x10, 0x2E,
+	0x1E, 0x28, 0x0C, 0x49, 0x1D, 0x3E, 0x29, 0x2C, 0x25, 0x30, 0x1C, 0x2F, 0x1B, 0x33, 0x13, 0x31, 0x0A, 0x37,
+	0x12, 0x3C, 0x18, 0x4B, 0x11, 0x45, 0x21, 0x4A, 0x1F, 0x3F, 0x15, 0x32, 0x08, 0x3A, 0x19, 0x34 };
+/*const uint8_t PROGMEM ESKY150V2_hop2[40]= {
+	0x19, 0x23, 0x13, 0x1B, 0x09, 0x22, 0x14, 0x27, 0x06, 0x26, 0x16, 0x24, 0x0B, 0x2A, 0x0E, 0x1C, 0x11, 0x1E,
+	0x08, 0x29, 0x0D, 0x28, 0x18, 0x2D, 0x12, 0x20, 0x0C, 0x1A, 0x10, 0x1D, 0x07, 0x2C, 0x0A, 0x2B, 0x0F, 0x25,
+	0x15, 0x1F, 0x17, 0x21 };*/
+#endif
+
+static void __attribute__((unused)) ESKY150V2_set_freq(void)
+{
+	calc_fh_channels(ESKY150V2_NFREQCHANNELS);
+	
+	#ifdef ESKY150V2_FORCE_ID
+		for(uint8_t i=0; i<ESKY150V2_NFREQCHANNELS; i++)
+			hopping_frequency[i]=pgm_read_byte_near( &ESKY150V2_hop[i] );
+	#endif
+	
+	//Bind channel
+	hopping_frequency[ESKY150V2_NFREQCHANNELS]=ESKY150V2_BIND_CHANNEL;
+	
+	//Calib all channels
+	CC2500_SetFreqOffset();	// Set frequency offset
+	CC2500_250K_HoppingCalib(ESKY150V2_NFREQCHANNELS+1);
+}
+
+static void __attribute__((unused)) ESKY150V2_send_packet()
+{
+	CC2500_SetFreqOffset();	// Set frequency offset
+	CC2500_250K_Hopping(hopping_frequency_no);
+	if (++hopping_frequency_no >= ESKY150V2_NFREQCHANNELS)
+		hopping_frequency_no = 0;
+	CC2500_SetPower();			//Set power level
+
+	packet[0] = 0xFA;		// Unknown
+	packet[1] = 0x41;		// Unknown
+	packet[2] = 0x08;		// Unknown
+	packet[3] = 0x00;		// Unknown
+	for(uint8_t i=0;i<16;i++)
+	{
+		uint16_t channel=convert_channel_16b_limit(CH_TAER[i],200,1000);
+		packet[4+2*i] = channel;
+		packet[5+2*i] = channel>>8;
+	}
+	NRF250K_WritePayload(packet, ESKY150V2_PAYLOADSIZE);
+}
+
+uint16_t ESKY150V2_callback()
+{
+	if(IS_BIND_DONE)
+	{
+		#ifdef MULTI_SYNC
+			telemetry_set_input_sync(ESKY150V2_PACKET_PERIOD);
+		#endif
+		ESKY150V2_send_packet();
+	}
+	else
+	{
+		BIND_DONE;					//Need full power for bind to work...
+		CC2500_SetPower();			//Set power level
+		BIND_IN_PROGRESS;
+		NRF250K_WritePayload(packet, ESKY150V2_BINDPAYLOADSIZE);
+		if (--bind_counter == 0)
+		{
+			BIND_DONE;
+			// Change TX address from bind to normal mode
+			NRF250K_SetTXAddr(rx_tx_addr, ESKY150V2_TXID_SIZE);
+			memset(packet,0x00,ESKY150V2_PAYLOADSIZE);
+		}
+		return 30000; //ESKY150V2_BINDING_PACKET_PERIOD;
+	}
+	return ESKY150V2_PACKET_PERIOD;
+}
+
+void ESKY150V2_init()
+{
+	CC2500_250K_Init();
+	ESKY150V2_set_freq();
+	hopping_frequency_no = 0;
+
+	#ifdef ESKY150V2_FORCE_ID	// ID taken from TX dump
+		rx_tx_addr[0]=0x87;rx_tx_addr[1]=0x5B;rx_tx_addr[2]=0x2C;rx_tx_addr[3]=0x5D;
+	#endif
+
+	memset(packet,0x00,ESKY150V2_BINDPAYLOADSIZE);
+
+	if(IS_BIND_IN_PROGRESS)
+	{
+		NRF250K_SetTXAddr((uint8_t *)"\x73\x73\x74\x63", ESKY150V2_TXID_SIZE);	//Bind address
+		CC2500_250K_Hopping(ESKY150V2_NFREQCHANNELS);	//Bind channel
+		memcpy(packet,"\x73\x73\x74\x63", ESKY150V2_TXID_SIZE);
+		memcpy(&packet[ESKY150V2_TXID_SIZE],rx_tx_addr, ESKY150V2_TXID_SIZE);
+		packet[8]=0x41;								//Unknown
+		packet[9]=0x88;								//Unknown
+		packet[10]=0x41;							//Unknown
+		memset(&packet[11],0xAA,4);					//Unknown
+		memcpy(&packet[15],hopping_frequency,ESKY150V2_NFREQCHANNELS);	// hop table
+		//for(uint8_t i=0; i<40; i++)				// Does not seem to be needed
+		//	packet[i+85]=pgm_read_byte_near( &ESKY150V2_hop2[i] );
+		bind_counter=100;
+	}
+	else
+		NRF250K_SetTXAddr(rx_tx_addr, ESKY150V2_TXID_SIZE);
+}
+
+#endif

Multiprotocol/ESky_nrf24l01.ino

@@ -18,8 +18,13 @@
 
 #include "iface_nrf24l01.h"
 
+//#define ESKY_ET4_FORCE_ID
+
 #define ESKY_BIND_COUNT		1000
-#define ESKY_PACKET_PERIOD	3333
+#define ESKY_STD_PACKET_PERIOD	3333
+#define ESKY_ET4_PACKET_PERIOD	1190
+#define ESKY_ET4_TOTAL_PACKET_PERIOD	20300
+#define ESKY_ET4_BIND_PACKET_PERIOD	5000
 #define ESKY_PAYLOAD_SIZE	13
 #define ESKY_PACKET_CHKTIME	100 // Time to wait for packet to be sent (no ACK, so very short)
 
@@ -30,15 +35,11 @@ static void __attribute__((unused)) ESKY_set_data_address()
 	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR,    rx_tx_addr, 4);
 }
 
-static void __attribute__((unused)) ESKY_init(uint8_t bind)
+static void __attribute__((unused)) ESKY_RF_init()
 {
 	NRF24L01_Initialize();
 
-	// 2-bytes CRC, radio off
-	NRF24L01_WriteReg(NRF24L01_00_CONFIG, _BV(NRF24L01_00_EN_CRC) | _BV(NRF24L01_00_CRCO)); 
-	NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);            // No Auto Acknowledgement
-	NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x01);        // Enable data pipe 0
-	if (bind)
+	if (IS_BIND_IN_PROGRESS)
 	{
 		NRF24L01_WriteReg(NRF24L01_03_SETUP_AW, 0x01);     // 3-byte RX/TX address for bind packets
 		NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0, (uint8_t*)"\x00\x00\x00", 3);
@@ -46,11 +47,7 @@ static void __attribute__((unused)) ESKY_init(uint8_t bind)
 	}
 	else
 		ESKY_set_data_address();
-	NRF24L01_WriteReg(NRF24L01_04_SETUP_RETR, 0);          // No auto retransmission
 	NRF24L01_WriteReg(NRF24L01_05_RF_CH, 50);              // Channel 50 for bind packets
-	NRF24L01_SetBitrate(NRF24L01_BR_1M);                   // 1Mbps
-	NRF24L01_SetPower();
-	NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);           // Clear data ready, data sent, and retransmit
 	NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, ESKY_PAYLOAD_SIZE);  // bytes of data payload for pipe 0
 	NRF24L01_WriteReg(NRF24L01_12_RX_PW_P1, ESKY_PAYLOAD_SIZE);
 	NRF24L01_WriteReg(NRF24L01_13_RX_PW_P2, ESKY_PAYLOAD_SIZE);
@@ -60,11 +57,11 @@ static void __attribute__((unused)) ESKY_init(uint8_t bind)
 	NRF24L01_WriteReg(NRF24L01_17_FIFO_STATUS, 0x00);      // Just in case, no real bits to write here
 }
 
-static void __attribute__((unused)) ESKY_init2()
+static void __attribute__((unused)) ESKY_TXID_init()
 {
 	NRF24L01_FlushTx();
-	packet_sent = 0;
-	hopping_frequency_no = 0;
+	if(sub_protocol==ESKY_STD)
+	{
 		uint16_t channel_ord = rx_tx_addr[0] % 74;
 		hopping_frequency[12] = 10 + (uint8_t)channel_ord;	//channel_code
 		uint8_t channel1, channel2;
@@ -85,6 +82,14 @@ static void __attribute__((unused)) ESKY_init2()
 		hopping_frequency[9] = 6;
 		hopping_frequency[10] = channel1*2;
 		hopping_frequency[11] = channel2*2;
+	}
+	else
+	{ // ESKY_ET4
+		hopping_frequency[0]  = 0x29;	//41
+		hopping_frequency[1]  = 0x12;	//18
+		hopping_frequency[6]  = 0x87;	//135 payload end byte
+		hopping_frequency[12] = 0x84;	//132 indicates which channels to use
+	}
 		
 	// Turn radio power on
 	NRF24L01_SetTxRxMode(TX_EN);
@@ -111,43 +116,59 @@ static void __attribute__((unused)) ESKY_send_packet(uint8_t bind)
 		packet[12] = 0;
 	}
 	else
+	{
+		if (packet_count == 0)
+			for (uint8_t i = 0; i < 6; i++)
+			{
+				uint16_t val=convert_channel_ppm(CH_AETR[i]);
+				packet[i*2]   = val>>8;		//high byte of servo timing(1000-2000us)
+				packet[i*2+1] = val&0xFF;	//low byte of servo timing(1000-2000us)
+			}
+		if(sub_protocol==ESKY_STD)
 		{
 			// Regular packet
 			// Each data packet is repeated 3 times on one channel, and 3 times on another channel
 			// For arithmetic simplicity, channels are repeated in rf_channels array
-		if (hopping_frequency_no == 0)
-		{
-			for (uint8_t i = 0; i < 6; i++)
-			{
-				packet[i*2]   = Servo_data[CH_AETR[i]]>>8;	//high byte of servo timing(1000-2000us)
-				packet[i*2+1] = Servo_data[CH_AETR[i]]&0xFF;	//low byte of servo timing(1000-2000us)
+			rf_ch = hopping_frequency[packet_count];
+			packet[12] = hopping_frequency[packet_count+6];	// end_bytes
+			packet_count++;
+			if (packet_count > 6) packet_count = 0;
 		}
+		else
+		{ // ESKY_ET4
+			// Regular packet
+			// Each data packet is repeated 14 times alternating between 2 channels
+			rf_ch = hopping_frequency[packet_count&1];
+			packet_count++;
+			if(packet_count>14) packet_count=0;
+			packet[12] = hopping_frequency[6];	// end_byte
 		}
-		rf_ch = hopping_frequency[hopping_frequency_no];
-		packet[12] = hopping_frequency[hopping_frequency_no+6];	// end_bytes
-		hopping_frequency_no++;
-		if (hopping_frequency_no > 6) hopping_frequency_no = 0;
 	}
 	NRF24L01_WriteReg(NRF24L01_05_RF_CH, rf_ch);
 	NRF24L01_FlushTx();
 	NRF24L01_WritePayload(packet, ESKY_PAYLOAD_SIZE);
-	packet_sent = 1;
-	if (! rf_ch_num)
 	NRF24L01_SetPower();	//Keep transmit power updated
 }
 
 uint16_t ESKY_callback()
 {
-	if(IS_BIND_DONE_on)
+	if(IS_BIND_DONE)
 	{
-		if (packet_sent && NRF24L01_packet_ack() != PKT_ACKED)
-			return ESKY_PACKET_CHKTIME;
+		#ifdef MULTI_SYNC
+			if(packet_count==0)
+				telemetry_set_input_sync(sub_protocol==ESKY_STD?ESKY_STD_PACKET_PERIOD*6:ESKY_ET4_TOTAL_PACKET_PERIOD);
+		#endif
 		ESKY_send_packet(0);
+		if(sub_protocol==ESKY_ET4)
+		{
+			if(packet_count==0)
+				return ESKY_ET4_TOTAL_PACKET_PERIOD-ESKY_ET4_PACKET_PERIOD*13;
+			else
+				return ESKY_ET4_PACKET_PERIOD;
+		}
 	}
 	else
 	{
-		if (packet_sent && NRF24L01_packet_ack() != PKT_ACKED)
-			return ESKY_PACKET_CHKTIME;
 		ESKY_send_packet(1);
 		if (--bind_counter == 0)
 		{
@@ -155,16 +176,25 @@ uint16_t ESKY_callback()
 			BIND_DONE;
 		}
 	}
-	return ESKY_PACKET_PERIOD;
+	return ESKY_STD_PACKET_PERIOD;
 }
 
-uint16_t initESKY(void)
+void ESKY_init(void)
 {
 	bind_counter = ESKY_BIND_COUNT;
+	rx_tx_addr[2] = rx_tx_addr[3];	// Model match
+	#ifdef ESKY_ET4_FORCE_ID
+	  if(sub_protocol==ESKY_ET4)
+	  {
+		  rx_tx_addr[0]=0x72;
+		  rx_tx_addr[1]=0xBB;
+		  rx_tx_addr[2]=0xCC;
+	  }
+	#endif
 	rx_tx_addr[3] = 0xBB;
-	ESKY_init(IS_AUTOBIND_FLAG_on);
-	ESKY_init2();
-	return 50000;
+	ESKY_RF_init();
+	ESKY_TXID_init();
+	packet_count=0;
 }
 
 #endif

Multiprotocol/FQ777_nrf24l01.ino

@@ -52,24 +52,18 @@ static void __attribute__((unused)) ssv_pack_dpl(uint8_t addr[], uint8_t pid, ui
 	header[0] = (addr[4] >> 7);
 
 	// calculate the crc
-	union 
-	{
-		uint8_t bytes[2];
-		uint16_t val;
-	} crc;
-
-	crc.val=0x3c18;
+	crc=0x3c18;
 	for (i = 0; i < 7; ++i)
-		crc.val=crc16_update(crc.val,header[i]);
+		crc16_update(header[i],8);
 	for (i = 0; i < *len; ++i)
-		crc.val=crc16_update(crc.val,payload[i]);
+		crc16_update(payload[i],8);
 
 	// encode payload and crc
 	// xor with this:
 	for (i = 0; i < *len; ++i)
 		payload[i] ^= ssv_xor[i];
-	crc.bytes[1] ^= ssv_xor[i++];
-	crc.bytes[0] ^= ssv_xor[i++];
+	crc ^= ssv_xor[i++]<<8;
+	crc ^= ssv_xor[i++];
 
 	// pack the pcf, payload, and crc into packed_payload
 	packed_payload[0] = pcf >> 1;
@@ -78,20 +72,20 @@ static void __attribute__((unused)) ssv_pack_dpl(uint8_t addr[], uint8_t pid, ui
 	for (i = 0; i < *len - 1; ++i)
 		packed_payload[i+2] = (payload[i] << 7) | (payload[i+1] >> 1);
 
-	packed_payload[i+2] = (payload[i] << 7) | (crc.val >> 9);
+	packed_payload[i+2] = (payload[i] << 7) | (crc >> 9);
 	++i;
-	packed_payload[i+2] = (crc.val >> 1 & 0x80 ) | (crc.val >> 1 & 0x7F);
+	packed_payload[i+2] = (crc >> 1 & 0x80 ) | (crc >> 1 & 0x7F);
 	++i;
-	packed_payload[i+2] = (crc.val << 7);
+	packed_payload[i+2] = (crc << 7);
 
 	*len += 4;
 }
 
-static void __attribute__((unused)) FQ777_send_packet(uint8_t bind)
+static void __attribute__((unused)) FQ777_send_packet()
 {
 	uint8_t packet_len = FQ777_PACKET_SIZE;
 	uint8_t packet_ori[8];
-	if (bind)
+	if (IS_BIND_IN_PROGRESS)
 	{
 		// 4,5,6 = address fields
 		// last field is checksum of address fields
@@ -125,15 +119,15 @@ static void __attribute__((unused)) FQ777_send_packet(uint8_t bind)
 			else // roll
 				trim_val = 0x60;
 
-		packet_ori[0] = convert_channel_8b_scale(THROTTLE,0,0x64);
-		packet_ori[1] = convert_channel_8b_scale(RUDDER,0,0x64);
-		packet_ori[2] = convert_channel_8b_scale(ELEVATOR,0,0x64);
-		packet_ori[3] = convert_channel_8b_scale(AILERON,0,0x64);
+		packet_ori[0] = convert_channel_16b_limit(THROTTLE,0,0x64);
+		packet_ori[1] = convert_channel_16b_limit(RUDDER,0,0x64);
+		packet_ori[2] = convert_channel_16b_limit(ELEVATOR,0,0x64);
+		packet_ori[3] = convert_channel_16b_limit(AILERON,0,0x64);
 		packet_ori[4] = trim_val; // calculated above
-		packet_ori[5] = GET_FLAG(Servo_AUX1, FQ777_FLAG_FLIP)
-				  | GET_FLAG(Servo_AUX3, FQ777_FLAG_HEADLESS)
-				  | GET_FLAG(!Servo_AUX2, FQ777_FLAG_RETURN)
-				  | GET_FLAG(Servo_AUX4,FQ777_FLAG_EXPERT);
+		packet_ori[5] = GET_FLAG(CH5_SW, FQ777_FLAG_FLIP)
+				  | GET_FLAG(CH7_SW, FQ777_FLAG_HEADLESS)
+				  | GET_FLAG(!CH6_SW, FQ777_FLAG_RETURN)
+				  | GET_FLAG(CH8_SW,FQ777_FLAG_EXPERT);
 		packet_ori[6] = 0x00;
 		// calculate checksum
 		uint8_t checksum = 0;
@@ -144,7 +138,7 @@ static void __attribute__((unused)) FQ777_send_packet(uint8_t bind)
 		packet_count++;
 	}
 
-	ssv_pack_dpl( (0 == bind) ? rx_tx_addr : FQ777_bind_addr, hopping_frequency_no, &packet_len, packet_ori, packet);
+	ssv_pack_dpl( IS_BIND_IN_PROGRESS ? FQ777_bind_addr : rx_tx_addr, hopping_frequency_no, &packet_len, packet_ori, packet);
 	
 	NRF24L01_WriteReg(NRF24L01_00_CONFIG,_BV(NRF24L01_00_PWR_UP));
 	NRF24L01_WriteReg(NRF24L01_05_RF_CH, hopping_frequency[hopping_frequency_no++]);
@@ -156,30 +150,21 @@ static void __attribute__((unused)) FQ777_send_packet(uint8_t bind)
 	NRF24L01_WritePayload(packet, packet_len);
 }
 
-static void __attribute__((unused)) FQ777_init()
+static void __attribute__((unused)) FQ777_RF_init()
 {
 	NRF24L01_Initialize();
-	NRF24L01_SetTxRxMode(TX_EN);
+
 	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, FQ777_bind_addr, 5);
-	NRF24L01_FlushTx();
-	NRF24L01_FlushRx();
-	NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);      // No Auto Acknowledgement on all data pipes
-	NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x00);
-	NRF24L01_WriteReg(NRF24L01_03_SETUP_AW, 0x03);
-	NRF24L01_WriteReg(NRF24L01_04_SETUP_RETR, 0x00); // no retransmits
 	NRF24L01_SetBitrate(NRF24L01_BR_250K);
-	NRF24L01_SetPower();
-    NRF24L01_Activate(0x73);                         // Activate feature register
-    NRF24L01_WriteReg(NRF24L01_1C_DYNPD, 0x00);      // Disable dynamic payload length on all pipes
-    NRF24L01_WriteReg(NRF24L01_1D_FEATURE, 0x01);
-    NRF24L01_Activate(0x73);
 }
 
 uint16_t FQ777_callback()
 {
-	if(bind_counter!=0)
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(FQ777_PACKET_PERIOD);
+	#endif
+	if(bind_counter)
 	{
-		FQ777_send_packet(1);
 		bind_counter--;
 		if (bind_counter == 0)
 		{
@@ -187,12 +172,11 @@ uint16_t FQ777_callback()
 			BIND_DONE;
 		}
 	}
-	else
-		FQ777_send_packet(0);
+	FQ777_send_packet();
 	return FQ777_PACKET_PERIOD;
 }
 
-uint16_t initFQ777(void)
+void FQ777_init(void)
 {
 	BIND_IN_PROGRESS;	// autobind protocol
 	bind_counter = FQ777_BIND_COUNT;
@@ -205,8 +189,7 @@ uint16_t initFQ777(void)
 	rx_tx_addr[2] = 0x00;
 	rx_tx_addr[3] = 0xe7;
 	rx_tx_addr[4] = 0x67;
-	FQ777_init();
-	return	FQ777_INITIAL_WAIT;
+	FQ777_RF_init();
 }
 
 #endif

Multiprotocol/FX_nrf24l01.ino

@@ -0,0 +1,177 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// Compatible with FEI XIONG P38 plane.
+
+#if defined(FX_NRF24L01_INO)
+
+#include "iface_xn297.h"
+
+#define FX_BIND_COUNT				300		//3sec
+#define FX_SWITCH					20
+#define FX_NUM_CHANNELS				4
+
+#define FX816_PACKET_PERIOD			10000
+#define FX816_BIND_CHANNEL			40
+#define FX816_PAYLOAD_SIZE			6
+#define FX816_CH_OFFSET				3
+
+#define FX620_PACKET_PERIOD 		3250
+#define FX620_BIND_PACKET_PERIOD	4500
+#define FX620_BIND_CHANNEL			18
+#define FX620_PAYLOAD_SIZE			7
+#define FX620_CH_OFFSET				1
+
+//#define FORCE_FX620_ID
+
+static void __attribute__((unused)) FX_send_packet()
+{
+	//Hopp
+	if(IS_BIND_DONE)
+	{
+		XN297_Hopping(hopping_frequency_no++);
+		hopping_frequency_no &= 0x03;
+	}
+
+	memset(packet,0x00,packet_length);
+
+	//Channels
+	uint8_t offset=sub_protocol == FX816 ? FX816_CH_OFFSET:FX620_CH_OFFSET;
+	uint8_t val=convert_channel_8b(AILERON);
+	if(val>127+FX_SWITCH)
+		packet[offset] = sub_protocol == FX816 ? 1:0xFF;
+	else if(val<127-FX_SWITCH)
+		packet[offset] = sub_protocol == FX816 ? 2:0x00;
+	else
+		packet[offset] = sub_protocol == FX816 ? 0:0x7F;
+	packet[offset+1] = convert_channel_16b_limit(THROTTLE,0,100);	//FX816:0x00..0x63, FX620:0x00..0x5E but that should work
+
+	//Bind and specifics
+	if(sub_protocol == FX816)
+	{
+		if(IS_BIND_IN_PROGRESS)
+			packet[0] = 0x55;
+		else
+			packet[0] = 0xAA;
+		packet[1] = rx_tx_addr[0];
+		packet[2] = rx_tx_addr[1];
+	}
+	else //FX620
+	{
+		if(IS_BIND_IN_PROGRESS)
+		{
+			memcpy(packet,rx_tx_addr,3);
+			packet[3] = hopping_frequency[0];
+			if(bind_counter > (FX_BIND_COUNT >> 1))
+				packet[5] = 0x78;
+		}
+		else
+		{
+			packet[0] = 0x1F;	// Is it based on ID??
+			packet[5] = 0xAB;	// Is it based on ID??
+		}
+	}
+
+	//Check
+	val=0;
+	for(uint8_t i=0;i<packet_length-1;i++)
+		val+=packet[i];
+	packet[packet_length-1]=val;
+
+	//Debug
+	#if 0
+		for(uint8_t i=0;i<packet_length;i++)
+			debug("%02X ",packet[i]);
+		debugln("");
+	#endif
+	
+	// Send
+	XN297_SetPower();
+	XN297_SetTxRxMode(TX_EN);
+	XN297_WritePayload(packet, packet_length);
+}
+
+static void __attribute__((unused)) FX_RF_init()
+{
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
+	if(sub_protocol == FX816)
+	{
+		XN297_SetTXAddr((uint8_t *)"\xcc\xcc\xcc\xcc\xcc", 5);
+		XN297_RFChannel(FX816_BIND_CHANNEL);
+		packet_period = FX816_PACKET_PERIOD;
+		packet_length = FX816_PAYLOAD_SIZE;
+	}
+	else //FX620
+	{
+		XN297_SetTXAddr((uint8_t *)"\xaa\xbb\xcc", 3);
+		XN297_RFChannel(FX620_BIND_CHANNEL);
+		packet_period = FX620_BIND_PACKET_PERIOD;
+		packet_length = FX620_PAYLOAD_SIZE;
+	}
+}
+
+static void __attribute__((unused)) FX_initialize_txid()
+{
+	if(sub_protocol == FX816)
+	{
+		//Only 8 IDs: the RX led does not indicate frame loss.
+		//I didn't open the plane to find out if I could connect there so this is the best I came up with with few trial and errors...
+		rx_tx_addr[0]=0x35+(rx_tx_addr[3]&0x07);							//Original dump=0x35
+		rx_tx_addr[1]=0x09;													//Original dump=0x09
+		memcpy(hopping_frequency,"\x09\x1B\x30\x42",FX_NUM_CHANNELS);		//Original dump=9=0x09,27=0x1B,48=0x30,66=0x42
+		for(uint8_t i=0;i<FX_NUM_CHANNELS;i++)
+			hopping_frequency[i]+=rx_tx_addr[3]&0x07;
+	}
+	else//FX620
+	{
+		rx_tx_addr[0] = rx_tx_addr[3];
+		hopping_frequency[0] = 0x18 + rx_tx_addr[3]&0x07;	// just to try something
+		#ifdef FORCE_FX620_ID
+			memcpy(rx_tx_addr,(uint8_t*)"\x34\xA9\x32",3);
+			hopping_frequency[0] = 0x18;	//on dump: 24 34 44 54
+		#endif
+		for(uint8_t i=1;i<FX_NUM_CHANNELS;i++)
+			hopping_frequency[i] = i*10 + hopping_frequency[0];
+	}
+}
+
+uint16_t FX_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(packet_period);
+	#endif
+	if(bind_counter)
+		if(--bind_counter==0)
+		{
+			BIND_DONE;
+			if(sub_protocol == FX620)
+			{
+				XN297_SetTXAddr(rx_tx_addr, 3);
+				packet_period = FX620_PACKET_PERIOD;
+			}
+		}
+	FX_send_packet();
+	return packet_period;
+}
+
+void FX_init()
+{
+	BIND_IN_PROGRESS;	// autobind protocol
+	FX_initialize_txid();
+	FX_RF_init();
+	hopping_frequency_no = 0;
+	bind_counter=FX_BIND_COUNT;
+}
+
+#endif

Multiprotocol/FY326_nrf24l01.ino

@@ -43,15 +43,15 @@ static void __attribute__((unused)) FY326_send_packet(uint8_t bind)
 	if(bind)
 		packet[1] = 0x55;
 	else
-		packet[1] =	  GET_FLAG(Servo_AUX3,	0x80)	// Headless
-					| GET_FLAG(Servo_AUX2,	0x40)	// RTH
-					| GET_FLAG(Servo_AUX1,	0x02)	// Flip
-					| GET_FLAG(Servo_AUX5,	0x01)	// Calibrate
-					| GET_FLAG(Servo_AUX4,	0x04);	// Expert
-	packet[2]  = convert_channel_8b_scale(AILERON, 0, 200);	// aileron
-	packet[3]  = convert_channel_8b_scale(ELEVATOR, 0, 200);		// elevator
-	packet[4]  = convert_channel_8b_scale(RUDDER, 0, 200);	// rudder
-	packet[5]  = convert_channel_8b_scale(THROTTLE, 0, 200);		// throttle
+		packet[1] =	  GET_FLAG(CH7_SW,	0x80)	// Headless
+					| GET_FLAG(CH6_SW,	0x40)	// RTH
+					| GET_FLAG(CH5_SW,	0x02)	// Flip
+					| GET_FLAG(CH9_SW,	0x01)	// Calibrate
+					| GET_FLAG(CH8_SW,	0x04);	// Expert
+	packet[2]  = convert_channel_16b_limit(AILERON, 0, 200);	// aileron
+	packet[3]  = convert_channel_16b_limit(ELEVATOR, 0, 200);		// elevator
+	packet[4]  = convert_channel_16b_limit(RUDDER, 0, 200);	// rudder
+	packet[5]  = convert_channel_16b_limit(THROTTLE, 0, 200);		// throttle
 	if(sub_protocol==FY319)
 	{
 		packet[6] = convert_channel_8b(AILERON);
@@ -88,34 +88,25 @@ static void __attribute__((unused)) FY326_send_packet(uint8_t bind)
 	NRF24L01_SetPower();	// Set tx_power
 }
 
-static void __attribute__((unused)) FY326_init()
+static void __attribute__((unused)) FY326_RF_init()
 {
 	NRF24L01_Initialize();
-	NRF24L01_SetTxRxMode(TX_EN);
+
 	if(sub_protocol==FY319)
 		NRF24L01_WriteReg(NRF24L01_03_SETUP_AW, 0x03);   // Five-byte rx/tx address
 	else
 		NRF24L01_WriteReg(NRF24L01_03_SETUP_AW, 0x01);   // Three-byte rx/tx address
 	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR,    (uint8_t *)"\x15\x59\x23\xc6\x29", 5);
 	NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0, (uint8_t *)"\x15\x59\x23\xc6\x29", 5);
-    NRF24L01_FlushTx();
-    NRF24L01_FlushRx();
-    NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);     // Clear data ready, data sent, and retransmit
-    NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);      // No Auto Acknowledgement on all data pipes
-    NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x01);  // Enable data pipe 0 only
     NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, FY326_PACKET_SIZE);
     NRF24L01_WriteReg(NRF24L01_05_RF_CH, FY326_RF_BIND_CHANNEL);
     NRF24L01_SetBitrate(NRF24L01_BR_250K);
-    NRF24L01_SetPower();
 
-	NRF24L01_Activate(0x73);
     NRF24L01_WriteReg(NRF24L01_1C_DYNPD, 0x3f);
     NRF24L01_WriteReg(NRF24L01_1D_FEATURE, 0x07);
-	NRF24L01_Activate(0x73);
 
 	//Switch to RX
 	NRF24L01_SetTxRxMode(TXRX_OFF);
-	NRF24L01_FlushRx();
 	NRF24L01_SetTxRxMode(RX_EN);
 }
 
@@ -188,6 +179,9 @@ uint16_t FY326_callback()
 				return FY326_PACKET_CHKTIME;
 			break;
 		case FY326_DATA:
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(FY326_PACKET_PERIOD);
+			#endif
 			FY326_send_packet(0);
 			break;
 	}
@@ -206,20 +200,19 @@ static void __attribute__((unused)) FY326_initialize_txid()
 			hopping_frequency[i]=rx_tx_addr[0] & ~0x80;
 }
 
-uint16_t initFY326(void)
+void FY326_init(void)
 {
 	BIND_IN_PROGRESS;	// autobind protocol
     rxid = 0xAA;
 	bind_counter = FY326_BIND_COUNT;
 	FY326_initialize_txid();
-	FY326_init();
+	FY326_RF_init();
 	if(sub_protocol==FY319)
 	{
 		phase=FY319_BIND1;
 	}
 	else
 		phase=FY326_BIND1;
-	return	FY326_INITIAL_WAIT;
 }
 
 #endif

Multiprotocol/Fake_nrf24l01.ino

@@ -0,0 +1,108 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(FAKE_NRF24L01_INO)
+
+#include "iface_nrf250k.h"
+
+static void __attribute__((unused)) FAKE_send_packet()
+{
+	for(uint8_t i=0;i<5;i++)
+		packet[i]=i;
+	NRF24L01_WriteReg(NRF24L01_07_STATUS, (_BV(NRF24L01_07_RX_DR) | _BV(NRF24L01_07_TX_DS) | _BV(NRF24L01_07_MAX_RT)));
+	NRF24L01_FlushTx();
+	NRF24L01_WritePayload(packet, 5);
+}
+
+static void __attribute__((unused)) FAKE_init()
+{
+//	BIND_IN_PROGRESS;
+
+	//CC2500
+	option=1;
+	XN297L_Init();
+	CC2500_WriteReg(CC2500_07_PKTCTRL1,	0x01);   // Packet Automation Control
+	CC2500_WriteReg(CC2500_08_PKTCTRL0,	0x00);   // Packet Automation Control
+	CC2500_WriteReg(CC2500_12_MDMCFG2,	0x12);   // Modem Configuration
+	CC2500_WriteReg(CC2500_13_MDMCFG1,	0x13);   // Modem Configuration
+	CC2500_WriteReg(CC2500_04_SYNC1,	0x11);
+	CC2500_WriteReg(CC2500_05_SYNC0,	0x33);
+	CC2500_WriteReg(CC2500_09_ADDR,     0x99);
+	CC2500_WriteReg(CC2500_06_PKTLEN,	10);
+
+	CC2500_SetTxRxMode(RX_EN);
+	CC2500_Strobe(CC2500_SIDLE);
+	CC2500_Strobe(CC2500_SRX);
+	//CC2500_SetTxRxMode(TX_EN);
+	XN297L_RFChannel(0);
+
+	//NRF
+/*	option=0;
+	PE1_on;							//NRF24L01 antenna RF3 by default
+	PE2_off;						//NRF24L01 antenna RF3 by default
+	NRF24L01_Initialize();
+	NRF24L01_WriteReg(NRF24L01_00_CONFIG, 0x7f);
+	NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);//0x3f);       // AA on all pipes
+	NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x3f);   // Enable all pipes
+	NRF24L01_WriteReg(NRF24L01_03_SETUP_AW, 0x03);    // 5-byte address
+	NRF24L01_WriteReg(NRF24L01_04_SETUP_RETR, 0x36);  // retransmit 1ms, 6 times
+	NRF24L01_SetBitrate(NRF24L01_BR_250K);              // 1Mbps
+	NRF24L01_SetPower();
+	NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0, (uint8_t *)"\x99\x33\x11\xAA\xAA", 5);	//Bind address
+	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR,    (uint8_t *)"\x99\x33\x11\xAA\xAA", 5);	//Bind address
+	NRF24L01_WriteReg(NRF24L01_05_RF_CH, 0);
+	NRF24L01_Activate(0x73);                          // Activate feature register
+	NRF24L01_WriteReg(NRF24L01_1C_DYNPD, 0x3f);       // Enable dynamic payload length
+	NRF24L01_WriteReg(NRF24L01_1D_FEATURE, 0x07);     // Enable all features
+*/	
+	/*NRF24L01_FlushTx();
+    NRF24L01_SetTxRxMode(TX_EN);*/
+}
+
+uint16_t FAKE_callback()
+{
+	len = CC2500_ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+	if(len) debug("L=%d, ",len);
+	if(len && len < sizeof(packet_in))
+	{
+		CC2500_ReadData(packet_in, len);
+		debug("P:");
+		for(uint8_t i=0;i<len;i++)
+			debug(" %02X", packet_in[i]);
+	}
+	if(len) debugln("");
+	CC2500_Strobe(CC2500_SFRX);
+	CC2500_Strobe(CC2500_SIDLE);
+	CC2500_Strobe(CC2500_SRX);
+
+	option=0;
+	//FAKE_send_packet();
+	
+	PE1_off;	//antenna RF2
+	PE2_on;
+	/*packet[0]=0x99;
+	for(uint8_t i=1;i<5;i++)
+		packet[i]=i;
+	CC2500_WriteData(packet, 5);*/
+	return 10000;
+}
+
+uint16_t initFAKE()
+{
+	FAKE_init();
+	return 5000;
+}
+
+#endif

Multiprotocol/FlySky_a7105.ino

@@ -12,7 +12,7 @@
  You should have received a copy of the GNU General Public License
  along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
  */
-// Last sync with hexfet new_protocols/flysky_a7105.c dated 2015-09-28
+// Last sync with hexfet new_protocols/FLYSKY_a7105.c dated 2015-09-28
 
 #if defined(FLYSKY_A7105_INO)
 
@@ -53,42 +53,42 @@ enum {
 const uint8_t PROGMEM V912_X17_SEQ[10] =  { 0x14, 0x31, 0x40, 0x49, 0x49,    // sometime first byte is 0x15 ?
 											0x49, 0x49, 0x49, 0x49, 0x49, }; 
 
-static void __attribute__((unused)) flysky_apply_extension_flags()
+static void __attribute__((unused)) FLYSKY_apply_extension_flags()
 {
 	switch(sub_protocol)
 	{
 		case V9X9:
-			if(Servo_AUX1)
+			if(CH5_SW)
 				packet[12] |= FLAG_V9X9_FLIP;
-			if(Servo_AUX2)
+			if(CH6_SW)
 				packet[12] |= FLAG_V9X9_LED;
-			if(Servo_AUX3)
+			if(CH7_SW)
 				packet[10] |= FLAG_V9X9_CAMERA;
-			if(Servo_AUX4)
+			if(CH8_SW)
 				packet[10] |= FLAG_V9X9_VIDEO;
 			break;
 			
 		case V6X6:
 			packet[13] = 0x03; // 3 = 100% rate (0=40%, 1=60%, 2=80%)
 			packet[14] = 0x00;
-			if(Servo_AUX1) 
+			if(CH5_SW) 
 				packet[14] |= FLAG_V6X6_FLIP;
-			if(Servo_AUX2) 
+			if(CH6_SW) 
 				packet[14] |= FLAG_V6X6_LED;
-			if(Servo_AUX3) 
+			if(CH7_SW) 
 				packet[14] |= FLAG_V6X6_CAMERA;
-			if(Servo_AUX4) 
+			if(CH8_SW) 
 				packet[14] |= FLAG_V6X6_VIDEO;
-			if(Servo_AUX5)
+			if(CH9_SW)
 			{ 
 				packet[13] |= FLAG_V6X6_HLESS1;
 				packet[14] |= FLAG_V6X6_HLESS2;
 			}
-			if(Servo_AUX6) //use option to manipulate these bytes
+			if(CH10_SW)
 				packet[14] |= FLAG_V6X6_RTH;
-			if(Servo_AUX7) 
+			if(CH11_SW) 
 				packet[14] |= FLAG_V6X6_XCAL;
-			if(Servo_AUX8) 
+			if(CH12_SW) 
 				packet[14] |= FLAG_V6X6_YCAL;
 			packet[15] = 0x10; // unknown
 			packet[16] = 0x10; // unknown
@@ -105,9 +105,9 @@ static void __attribute__((unused)) flysky_apply_extension_flags()
 			packet[12] |= 0x20; // bit 6 is always set ?
 			packet[13] = 0x00;  // unknown
 			packet[14] = 0x00;
-			if(Servo_AUX1)
+			if(CH5_SW)
 				packet[14]  = FLAG_V912_BTMBTN;
-			if(Servo_AUX2)
+			if(CH6_SW)
 				packet[14] |= FLAG_V912_TOPBTN;
 			packet[15] = 0x27; // [15] and [16] apparently hold an analog channel with a value lower than 1000
 			packet[16] = 0x03; // maybe it's there for a pitch channel for a CP copter ?
@@ -129,55 +129,53 @@ static void __attribute__((unused)) flysky_apply_extension_flags()
 	}
 }
 
-static void __attribute__((unused)) flysky_build_packet(uint8_t init)
+static void __attribute__((unused)) FLYSKY_send_packet()
 {
     uint8_t i;
 	//servodata timing range for flysky.
-	////-100% =~ 0x03e8//=1000us(min)
+	//-100% =~ 0x03e8//=1000us(min)
 	//+100% =~ 0x07ca//=1994us(max)
 	//Center = 0x5d9//=1497us(center)
-	//channel order AIL;ELE;THR;RUD;AUX1;AUX2;AUX3;AUX4
-    packet[0] = init ? 0xaa : 0x55;
+	//channel order AIL;ELE;THR;RUD;CH5;CH6;CH7;CH8
+    packet[0] = IS_BIND_IN_PROGRESS ? 0xaa : 0x55;
     packet[1] = rx_tx_addr[3];
     packet[2] = rx_tx_addr[2];
     packet[3] = rx_tx_addr[1];
     packet[4] = rx_tx_addr[0];
 	for(i = 0; i < 8; i++)
 	{
-		uint16_t temp=Servo_data[CH_AETR[i]];
-		if(sub_protocol == CX20 && CH_AETR[i] == ELEVATOR)
-			temp=servo_mid-temp;		//reverse channel
+		uint16_t temp=convert_channel_ppm(CH_AETR[i]);
+		if(sub_protocol == CX20 && i==CH2) //ELEVATOR
+			temp=3000-temp;
 		packet[5 + i*2]=temp&0xFF;		//low byte of servo timing(1000-2000us)
 		packet[6 + i*2]=(temp>>8)&0xFF;	//high byte of servo timing(1000-2000us)
 	}
-    flysky_apply_extension_flags();
+    FLYSKY_apply_extension_flags();
+
+	A7105_SetPower();
+	A7105_WriteData(21, IS_BIND_IN_PROGRESS ? 0x01:hopping_frequency[hopping_frequency_no & 0x0F]);
+	hopping_frequency_no++;
 }
 
-uint16_t ReadFlySky()
+uint16_t FLYSKY_callback()
 {
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(packet_period);
+	#endif
+	#ifndef FORCE_FLYSKY_TUNING
+		A7105_AdjustLOBaseFreq(1);
+	#endif
 	if(bind_counter)
 	{
-        flysky_build_packet(1);
-        A7105_WriteData(21, 1);
 		bind_counter--;
-        if (! bind_counter)
+		if (bind_counter==0)
 			BIND_DONE;
 	}
-	else
-	{
-		flysky_build_packet(0);
-        A7105_WriteData(21, hopping_frequency[hopping_frequency_no & 0x0F]);
-		A7105_SetPower();
-    }
-    hopping_frequency_no++;
-
-	if(sub_protocol==CX20)
-		return 3984;
-	else
-		return 1510;	//1460 on deviation but not working with the latest V911 bricks... Turnigy 9X v2 is 1533, Flysky TX for 9XR/9XR Pro is 1510, V911 TX is 1490.
+	FLYSKY_send_packet();
+	return packet_period;
 }
 
-const uint8_t PROGMEM tx_channels[8][4] = {
+const uint8_t PROGMEM FLYSKY_tx_channels[8][4] = {
 	{ 0x12, 0x34, 0x56, 0x78},
 	{ 0x18, 0x27, 0x36, 0x45},
 	{ 0x41, 0x82, 0x36, 0x57},
@@ -188,7 +186,7 @@ const uint8_t PROGMEM tx_channels[8][4] = {
 	{ 0x71, 0x86, 0x43, 0x52}
 };
 
-uint16_t initFlySky()
+void FLYSKY_init()
 {
 	uint8_t chanrow;
 	uint8_t chanoffset;
@@ -206,7 +204,7 @@ uint16_t initFlySky()
 	chanoffset=rx_tx_addr[3]/16;
 	for(uint8_t i=0;i<16;i++)
 	{
-		temp=pgm_read_byte_near(&tx_channels[chanrow>>1][i>>2]);
+		temp=pgm_read_byte_near(&FLYSKY_tx_channels[chanrow>>1][i>>2]);
 		if(i&0x02)
 			temp&=0x0F;
 		else
@@ -232,10 +230,13 @@ uint16_t initFlySky()
 	}
 	hopping_frequency_no=0;
 	packet_count=0;
-	if(IS_AUTOBIND_FLAG_on)
+	if(sub_protocol==CX20)
+		packet_period=3984;
+	else
+		packet_period=1510;	//1460 on deviation but not working with the latest V911 bricks... Turnigy 9X v2 is 1533, Flysky TX for 9XR/9XR Pro is 1510, V911 TX is 1490.
+	if(IS_BIND_IN_PROGRESS)
 		bind_counter = FLYSKY_BIND_COUNT;
 	else
 		bind_counter = 0;
-	return 2400;
 }
 #endif

Multiprotocol/FrSkyDVX_common.ino

@@ -0,0 +1,545 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/******************************/
+/**  FrSky D and X routines  **/
+/******************************/
+
+#if defined(FRSKYD_CC2500_INO) || defined(FRSKYX_CC2500_INO) || defined(FRSKYL_CC2500_INO) || defined(FRSKY_RX_CC2500_INO) || defined(FRSKYR9_SX1276_INO)
+	uint8_t FrSkyFormat=0;
+	uint8_t FrSkyX_chanskip;
+#endif
+
+#if defined(FRSKYX_CC2500_INO) || defined(FRSKYL_CC2500_INO) || defined(FRSKY_RX_CC2500_INO) || defined(FRSKYR9_SX1276_INO)
+//**CRC**
+const uint16_t PROGMEM FrSkyX_CRC_Short[]={
+	0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF,
+	0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7 };
+static uint16_t __attribute__((unused)) FrSkyX_CRCTable(uint8_t val)
+{
+	uint16_t word ;
+	word = pgm_read_word(&FrSkyX_CRC_Short[val&0x0F]) ;
+	val /= 16 ;
+	return word ^ (0x1081 * val) ;
+}
+uint16_t FrSkyX_crc(uint8_t *data, uint8_t len, uint16_t init=0)
+{
+	uint16_t crc = init;
+	for(uint8_t i=0; i < len; i++)
+		crc = (crc<<8) ^ FrSkyX_CRCTable((uint8_t)(crc>>8) ^ *data++);
+	return crc;
+}
+#endif
+
+#if defined(FRSKYX_CC2500_INO) || defined(FRSKYR9_SX1276_INO)
+static void __attribute__((unused)) FrSkyX_channels(uint8_t offset)
+{
+	static uint8_t chan_start=0;
+
+	//packet[7] = FLAGS 00 - standard packet
+	//10, 12, 14, 16, 18, 1A, 1C, 1E - failsafe packet
+	//20 - range check packet
+	#ifdef FAILSAFE_ENABLE
+		#define FRSKYX_FAILSAFE_TIMEOUT 1032
+		static uint16_t failsafe_count=0;
+		static uint8_t FS_flag=0,failsafe_chan=0;
+		if (FS_flag == 0  &&  failsafe_count > FRSKYX_FAILSAFE_TIMEOUT  &&  chan_start == 0  &&  IS_FAILSAFE_VALUES_on)
+		{
+			FS_flag = 0x10;
+			failsafe_chan = 0;
+		} else if (FS_flag & 0x10 && failsafe_chan < (FrSkyFormat & 0x01 ? 8-1:16-1))
+		{
+			FS_flag = 0x10 | ((FS_flag + 2) & 0x0F);					//10, 12, 14, 16, 18, 1A, 1C, 1E - failsafe packet
+			failsafe_chan ++;
+		} else if (FS_flag & 0x10)
+		{
+			FS_flag = 0;
+			failsafe_count = 0;
+			FAILSAFE_VALUES_off;
+		}
+		failsafe_count++;
+		if(protocol==PROTO_FRSKY_R9)
+			failsafe_count++;					// R9 is 20ms, X is 9ms
+		packet[offset] = FS_flag;
+	#else
+		packet[offset] = 0;
+	#endif
+	//
+	packet[offset+1] = 0;						//??
+	//
+	uint8_t chan_index = chan_start;
+	uint16_t ch1,ch2;
+	for(uint8_t i = offset+2; i < 12+offset+2 ; i+=3)
+	{//12 bytes of channel data
+		#ifdef FAILSAFE_ENABLE
+			if( (FS_flag & 0x10) && ((failsafe_chan & 0x07) == (chan_index & 0x07)) )
+				ch1 = FrSkyX_scaleForPXX_FS(failsafe_chan);
+			else
+		#endif
+				ch1 = FrSkyX_scaleForPXX(chan_index);
+		chan_index++;
+		//
+		#ifdef FAILSAFE_ENABLE
+			if( (FS_flag & 0x10) && ((failsafe_chan & 0x07) == (chan_index & 0x07)) )
+				ch2 = FrSkyX_scaleForPXX_FS(failsafe_chan);
+			else
+		#endif
+				ch2 = FrSkyX_scaleForPXX(chan_index);
+		chan_index++;
+		//3 bytes per channel
+		packet[i] = ch1;
+		packet[i+1]=(((ch1>>8) & 0x0F)|(ch2 << 4));
+		packet[i+2]=ch2>>4;
+	}
+	if(FrSkyFormat & 0x01)											//In X8 mode send only 8ch every 9ms
+		chan_start = 0 ;
+	else
+		chan_start^=0x08;
+}
+#endif
+
+
+#if defined(FRSKYD_CC2500_INO) || defined(FRSKYX_CC2500_INO) || defined(FRSKYX_CC2500_INO) || defined(FRSKYL_CC2500_INO) || defined(FRSKY_RX_CC2500_INO)
+enum {
+	FRSKY_BIND		= 0,
+	FRSKY_BIND_DONE	= 1000,
+	FRSKY_DATA1,
+	FRSKY_DATA2,
+	FRSKY_DATA3,
+	FRSKY_DATA4,
+	FRSKY_DATA5,
+};
+
+void Frsky_init_hop(void)
+{
+	uint8_t val;
+	uint8_t channel = rx_tx_addr[0]&0x07;
+	uint8_t channel_spacing = rx_tx_addr[1];
+	//Filter bad tables
+	if(channel_spacing<0x02) channel_spacing+=0x02;
+	if(channel_spacing>0xE9) channel_spacing-=0xE7;
+	if(channel_spacing%0x2F==0) channel_spacing++;
+		
+	hopping_frequency[0]=channel;
+	for(uint8_t i=1;i<50;i++)
+	{
+		channel=(channel+channel_spacing) % 0xEB;
+		val=channel;
+		if((val==0x00) || (val==0x5A) || (val==0xDC))
+			val++;
+		hopping_frequency[i]=i>46?0:val;
+	}
+}
+
+void FrSkyX2_init_hop(void)
+{
+	uint16_t id=(rx_tx_addr[2]<<8) + rx_tx_addr[3];
+	//Increment
+	uint8_t inc = (id % 46) + 1;
+	if( inc == 12 || inc ==35 ) inc++;							//Exception list from dumps
+	//Start offset
+	uint8_t offset = id % 5;
+
+	debug("hop: ");
+	uint8_t channel;
+	for(uint8_t i=0; i<47; i++)
+	{
+		channel = 5 * (uint16_t(inc * i) % 47) + offset;
+		//Exception list from dumps
+		if(FrSkyFormat & 2 )// LBT or FCC
+		{//LBT
+			if( channel <=1 || channel == 43 || channel == 44 || channel == 87 || channel == 88 || channel == 129 || channel == 130 || channel == 173 || channel == 174)
+				channel += 2;
+			else if( channel == 216 || channel == 217 || channel == 218)
+				channel += 3;
+		}
+		else //FCC
+			if ( channel == 3 || channel == 4 || channel == 46 || channel == 47 || channel == 90 || channel == 91  || channel == 133 || channel == 134 || channel == 176 || channel == 177 || channel == 220 || channel == 221 )
+				channel += 2;
+		//Store
+		hopping_frequency[i] = channel;
+		debug(" %02X",channel);
+	}
+	debugln("");
+	hopping_frequency[47] = 0;									//Bind freq
+}
+
+void Frsky_init_clone(void)
+{
+	debugln("Clone mode");
+	uint16_t temp = FRSKYD_CLONE_EEPROM_OFFSET;
+	if(protocol==PROTO_FRSKYX)
+		temp=FRSKYX_CLONE_EEPROM_OFFSET;
+	else if(protocol==PROTO_FRSKYX2)
+		temp=FRSKYX2_CLONE_EEPROM_OFFSET;
+	FrSkyFormat=eeprom_read_byte((EE_ADDR)temp++);
+	/*	FRSKY_RX_D8			=0,
+	FRSKY_RX_D16FCC		=1,
+	FRSKY_RX_D16LBT		=2,
+	FRSKY_RX_D16v2FCC	=3,
+	FRSKY_RX_D16v2LBT	=4,*/
+	if(protocol==PROTO_FRSKYX)
+		FrSkyFormat >>= 1;
+	else
+		FrSkyFormat >>= 2;
+	FrSkyFormat <<= 1;	//FCC_16/LBT_16
+	if(sub_protocol==XCLONE_8)
+		FrSkyFormat++;	//FCC_8/LBT_8
+	rx_tx_addr[3] = eeprom_read_byte((EE_ADDR)temp++);
+	rx_tx_addr[2] = eeprom_read_byte((EE_ADDR)temp++);
+	rx_tx_addr[1] = eeprom_read_byte((EE_ADDR)temp++);
+	memset(hopping_frequency,0x00,50);
+	if(protocol!=PROTO_FRSKYX2)
+	{//D8 and D16v1
+		for (uint8_t ch = 0; ch < 47; ch++)
+			hopping_frequency[ch] = eeprom_read_byte((EE_ADDR)temp++);
+	}
+	else
+		FrSkyX2_init_hop();
+}
+
+#endif
+/******************************/
+/**  FrSky V, D and X routines  **/
+/******************************/
+#if defined(FRSKYV_CC2500_INO) || defined(FRSKYD_CC2500_INO) || defined(FRSKYX_CC2500_INO) || defined(FRSKYL_CC2500_INO)
+	const PROGMEM uint8_t FRSKY_common_startreg_cc2500_conf[]= {
+		 CC2500_02_IOCFG0 ,		
+		 CC2500_00_IOCFG2 ,
+		 CC2500_17_MCSM1 ,
+		 CC2500_18_MCSM0 ,
+		 CC2500_06_PKTLEN ,
+		 CC2500_07_PKTCTRL1 ,
+		 CC2500_08_PKTCTRL0 ,
+		 CC2500_3E_PATABLE ,
+		 CC2500_0B_FSCTRL1 ,
+		 CC2500_0C_FSCTRL0 ,	// replaced by option value
+		 CC2500_0D_FREQ2 ,	
+		 CC2500_0E_FREQ1 ,
+		 CC2500_0F_FREQ0 ,
+		 CC2500_10_MDMCFG4 ,		
+		 CC2500_11_MDMCFG3 ,
+		 CC2500_12_MDMCFG2 ,
+		 CC2500_13_MDMCFG1 ,
+		 CC2500_14_MDMCFG0 ,
+		 CC2500_15_DEVIATN  };
+
+	#if defined(FRSKYV_CC2500_INO)
+		const PROGMEM uint8_t FRSKYV_cc2500_conf[]= {
+		/*02_IOCFG0*/  	 0x06 ,		
+		/*00_IOCFG2*/  	 0x06 ,
+		/*17_MCSM1*/   	 0x0c ,
+		/*18_MCSM0*/   	 0x18 ,
+		/*06_PKTLEN*/  	 0xff ,
+		/*07_PKTCTRL1*/	 0x04 ,
+		/*08_PKTCTRL0*/	 0x05 ,
+		/*3E_PATABLE*/ 	 0xfe ,
+		/*0B_FSCTRL1*/ 	 0x08 ,
+		/*0C_FSCTRL0*/ 	 0x00 ,
+		/*0D_FREQ2*/   	 0x5c ,	
+		/*0E_FREQ1*/   	 0x58 ,
+		/*0F_FREQ0*/   	 0x9d ,
+		/*10_MDMCFG4*/ 	 0xAA ,		
+		/*11_MDMCFG3*/ 	 0x10 ,
+		/*12_MDMCFG2*/ 	 0x93 ,
+		/*13_MDMCFG1*/ 	 0x23 ,
+		/*14_MDMCFG0*/ 	 0x7a ,
+		/*15_DEVIATN*/ 	 0x41  };
+	#endif
+
+	#if defined(FRSKYD_CC2500_INO)
+		const PROGMEM uint8_t FRSKYD_cc2500_conf[]= {
+		/*02_IOCFG0*/  	 0x06 ,		
+		/*00_IOCFG2*/  	 0x06 ,
+		/*17_MCSM1*/   	 0x0c ,
+		/*18_MCSM0*/   	 0x18 ,
+		/*06_PKTLEN*/  	 0x19 ,
+		/*07_PKTCTRL1*/	 0x04 ,
+		/*08_PKTCTRL0*/	 0x05 ,
+		/*3E_PATABLE*/ 	 0xff ,
+		/*0B_FSCTRL1*/ 	 0x08 ,
+		/*0C_FSCTRL0*/ 	 0x00 ,
+		/*0D_FREQ2*/   	 0x5c ,	
+		/*0E_FREQ1*/   	 0x76 ,
+		/*0F_FREQ0*/   	 0x27 ,
+		/*10_MDMCFG4*/ 	 0xAA ,		
+		/*11_MDMCFG3*/ 	 0x39 ,
+		/*12_MDMCFG2*/ 	 0x11 ,
+		/*13_MDMCFG1*/ 	 0x23 ,
+		/*14_MDMCFG0*/ 	 0x7a ,
+		/*15_DEVIATN*/ 	 0x42  };
+	#endif
+
+	#if defined(FRSKYX_CC2500_INO) || defined(FRSKYL_CC2500_INO)
+		const PROGMEM uint8_t FRSKYX_cc2500_conf[]= {
+	//FRSKYX
+		/*02_IOCFG0*/  	 0x06 ,
+		/*00_IOCFG2*/  	 0x06 ,
+		/*17_MCSM1*/   	 0x0c ,	//X2->0x0E -> RX stays in RX and TX stays in TX???
+		/*18_MCSM0*/   	 0x18 ,
+		/*06_PKTLEN*/  	 0x1E ,
+		/*07_PKTCTRL1*/	 0x04 ,
+		/*08_PKTCTRL0*/	 0x01 , //X2->0x05 -> CRC enabled
+		/*3E_PATABLE*/ 	 0xff ,
+		/*0B_FSCTRL1*/ 	 0x0A ,
+		/*0C_FSCTRL0*/ 	 0x00 ,
+		/*0D_FREQ2*/   	 0x5c ,	
+		/*0E_FREQ1*/   	 0x76 ,
+		/*0F_FREQ0*/   	 0x27 ,
+		/*10_MDMCFG4*/ 	 0x7B ,
+		/*11_MDMCFG3*/ 	 0x61 ,	//X2->0x84 -> bitrate 70K->77K
+		/*12_MDMCFG2*/ 	 0x13 ,
+		/*13_MDMCFG1*/ 	 0x23 ,
+		/*14_MDMCFG0*/ 	 0x7a ,
+		/*15_DEVIATN*/ 	 0x51  };
+		const PROGMEM uint8_t FRSKYXEU_cc2500_conf[]= {
+		/*02_IOCFG0*/  	 0x06 ,
+		/*00_IOCFG2*/  	 0x06 ,
+		/*17_MCSM1*/   	 0x0E ,
+		/*18_MCSM0*/   	 0x18 ,
+		/*06_PKTLEN*/  	 0x23 ,
+		/*07_PKTCTRL1*/	 0x04 ,
+		/*08_PKTCTRL0*/	 0x01 , //X2->0x05 -> CRC enabled
+		/*3E_PATABLE*/ 	 0xff ,
+		/*0B_FSCTRL1*/ 	 0x08 ,
+		/*0C_FSCTRL0*/ 	 0x00 ,
+		/*0D_FREQ2*/   	 0x5c ,
+		/*0E_FREQ1*/   	 0x80 ,
+		/*0F_FREQ0*/   	 0x00 ,
+		/*10_MDMCFG4*/ 	 0x7B ,
+		/*11_MDMCFG3*/ 	 0xF8 ,
+		/*12_MDMCFG2*/ 	 0x03 ,
+		/*13_MDMCFG1*/ 	 0x23 ,
+		/*14_MDMCFG0*/ 	 0x7a ,
+		/*15_DEVIATN*/ 	 0x53  };
+		const PROGMEM uint8_t FRSKYL_cc2500_conf[]= {
+		/*02_IOCFG0*/  	 0x02 ,
+		/*00_IOCFG2*/  	 0x02 ,
+		/*17_MCSM1*/   	 0x0C ,
+		/*18_MCSM0*/   	 0x18 ,
+		/*06_PKTLEN*/  	 0xFF ,
+		/*07_PKTCTRL1*/	 0x00 ,
+		/*08_PKTCTRL0*/	 0x02 ,
+		/*3E_PATABLE*/ 	 0xFE ,
+		/*0B_FSCTRL1*/ 	 0x0A ,
+		/*0C_FSCTRL0*/ 	 0x00 ,
+		/*0D_FREQ2*/   	 0x5c ,
+		/*0E_FREQ1*/   	 0x76 ,
+		/*0F_FREQ0*/   	 0x27 ,
+		/*10_MDMCFG4*/ 	 0x5C ,
+		/*11_MDMCFG3*/ 	 0x3B ,
+		/*12_MDMCFG2*/ 	 0x00 ,
+		/*13_MDMCFG1*/ 	 0x03 ,
+		/*14_MDMCFG0*/ 	 0x7A ,
+		/*15_DEVIATN*/ 	 0x47  };
+	#endif
+
+	const PROGMEM uint8_t FRSKY_common_end_cc2500_conf[][2]= {
+		{ CC2500_19_FOCCFG,   0x16 },
+		{ CC2500_1A_BSCFG,    0x6c },	
+		{ CC2500_1B_AGCCTRL2, 0x43 },
+		{ CC2500_1C_AGCCTRL1, 0x40 },
+		{ CC2500_1D_AGCCTRL0, 0x91 },
+		{ CC2500_21_FREND1,   0x56 },
+		{ CC2500_22_FREND0,   0x10 },
+		{ CC2500_23_FSCAL3,   0xa9 },
+		{ CC2500_24_FSCAL2,   0x0A },
+		{ CC2500_25_FSCAL1,   0x00 },
+		{ CC2500_26_FSCAL0,   0x11 },
+		{ CC2500_29_FSTEST,   0x59 },
+		{ CC2500_2C_TEST2,    0x88 },
+		{ CC2500_2D_TEST1,    0x31 },
+		{ CC2500_2E_TEST0,    0x0B },
+		{ CC2500_03_FIFOTHR,  0x07 },
+		{ CC2500_09_ADDR,     0x00 } };
+
+	void FRSKY_init_cc2500(const uint8_t *ptr)
+	{
+		for(uint8_t i=0;i<19;i++)
+		{
+			uint8_t reg=pgm_read_byte_near(&FRSKY_common_startreg_cc2500_conf[i]);
+			uint8_t val=pgm_read_byte_near(&ptr[i]);
+			if(reg==CC2500_0C_FSCTRL0)
+				val=option;
+			CC2500_WriteReg(reg,val);
+		}
+		for(uint8_t i=0;i<17;i++)
+		{
+			uint8_t reg=pgm_read_byte_near(&FRSKY_common_end_cc2500_conf[i][0]);
+			uint8_t val=pgm_read_byte_near(&FRSKY_common_end_cc2500_conf[i][1]);
+			CC2500_WriteReg(reg,val);
+		}
+		CC2500_SetTxRxMode(TX_EN);
+		CC2500_SetPower();
+		CC2500_Strobe(CC2500_SIDLE);    // Go to idle...
+	}
+#endif
+
+#if defined(FRSKYX_CC2500_INO) || defined(FRSKYR9_SX1276_INO)
+	uint8_t FrSkyX_TX_Seq, FrSkyX_TX_IN_Seq;
+	uint8_t FrSkyX_RX_Seq ;
+
+	#ifdef SPORT_SEND
+		struct t_FrSkyX_TX_Frame
+		{
+			uint8_t count;
+			uint8_t payload[8];
+		} ;
+		// Store FrskyX telemetry
+		struct t_FrSkyX_TX_Frame FrSkyX_TX_Frames[4] ;
+	#endif
+	
+	static void __attribute__((unused)) FrSkyX_seq_sport(uint8_t start, uint8_t end)
+	{
+		for (uint8_t i=start+1;i<=end;i++)
+			packet[i]=0;
+		packet[start] = FrSkyX_RX_Seq << 4;
+		#ifdef SPORT_SEND
+			if (FrSkyX_TX_IN_Seq!=0xFF)
+			{//RX has replied at least once
+				if (FrSkyX_TX_IN_Seq & 0x08)
+				{//Request init
+					//debugln("Init");
+					FrSkyX_TX_Seq = 0 ;	
+					for(uint8_t i=0;i<4;i++)
+						FrSkyX_TX_Frames[i].count=0;						//Discard frames in current output buffer
+				}
+				else if (FrSkyX_TX_IN_Seq & 0x04)
+				{//Retransmit the requested packet
+					debugln("Retry:%d",FrSkyX_TX_IN_Seq&0x03);
+					packet[start] |= FrSkyX_TX_IN_Seq&0x03;
+					packet[start+1]  = FrSkyX_TX_Frames[FrSkyX_TX_IN_Seq&0x03].count;
+					for (uint8_t i=start+2;i<start+2+FrSkyX_TX_Frames[FrSkyX_TX_IN_Seq&0x03].count;i++)
+						packet[i] = FrSkyX_TX_Frames[FrSkyX_TX_IN_Seq&0x03].payload[i];
+				}
+				else if ( FrSkyX_TX_Seq != 0x08 )
+				{
+					if(FrSkyX_TX_Seq==FrSkyX_TX_IN_Seq)
+					{//Send packet from the incoming radio buffer
+						//debugln("Send:%d",FrSkyX_TX_Seq);
+						packet[start] |= FrSkyX_TX_Seq;
+						uint8_t nbr_bytes=0;
+						for (uint8_t i=start+2;i<=end;i++)
+						{
+							if(SportHead==SportTail)
+								break; //buffer empty
+							packet[i]=SportData[SportHead];
+							FrSkyX_TX_Frames[FrSkyX_TX_Seq].payload[i-start+2]=SportData[SportHead];
+							SportHead=(SportHead+1) & (MAX_SPORT_BUFFER-1);
+							nbr_bytes++;
+						}
+						packet[start+1]=nbr_bytes;
+						FrSkyX_TX_Frames[FrSkyX_TX_Seq].count=nbr_bytes;
+						if(nbr_bytes)
+						{//Check the buffer status
+							uint8_t used = SportTail;
+							if ( SportHead > SportTail )
+								used += MAX_SPORT_BUFFER - SportHead ;
+							else
+								used -= SportHead ;
+							if ( used < (MAX_SPORT_BUFFER>>1) )
+							{
+								DATA_BUFFER_LOW_off;
+								debugln("Ok buf:%d",used);
+							}
+						}
+						FrSkyX_TX_Seq = ( FrSkyX_TX_Seq + 1 ) & 0x03 ;		//Next iteration send next packet
+					}
+					else
+					{//Not in sequence somehow, transmit what the receiver wants but why not asking for retransmit...
+						//debugln("RX_Seq:%d,TX:%d",FrSkyX_TX_IN_Seq,FrSkyX_TX_Seq);
+						packet[start] |= FrSkyX_TX_IN_Seq;
+						packet[start+1] = FrSkyX_TX_Frames[FrSkyX_TX_IN_Seq].count;
+						for (uint8_t i=start+2;i<start+2+FrSkyX_TX_Frames[FrSkyX_TX_IN_Seq].count;i++)
+							packet[i] = FrSkyX_TX_Frames[FrSkyX_TX_IN_Seq].payload[i-start+2];
+					}
+				}
+				else
+					packet[start] |= 0x08 ;									//FrSkyX_TX_Seq=8 at startup
+			}
+			if(packet[start+1])
+			{//Debug
+				debug("SP: ");
+				for(uint8_t i=0;i<packet[start+1];i++)
+					debug("%02X ",packet[start+2+i]);
+				debugln("");
+			}
+		#else
+			packet[start] |= FrSkyX_TX_Seq ;//TX=8 at startup
+			if ( !(FrSkyX_TX_IN_Seq & 0xF8) )
+				FrSkyX_TX_Seq = ( FrSkyX_TX_Seq + 1 ) & 0x03 ;				// Next iteration send next packet
+		#endif // SPORT_SEND
+	}
+
+	static void __attribute__((unused)) FrSkyX_telem_init(void)
+	{
+		FrSkyX_TX_Seq = 0x08 ;				// Request init
+		#ifdef SPORT_SEND
+			FrSkyX_TX_IN_Seq = 0xFF ;		// No sequence received yet
+			for(uint8_t i=0;i<4;i++)
+				FrSkyX_TX_Frames[i].count=0;// discard frames in current output buffer
+			SportHead=SportTail=0;			// empty data buffer
+		#endif
+		FrSkyX_RX_Seq = 0 ;					// Seq 0 to start with
+		#ifdef TELEMETRY
+			telemetry_lost=1;
+			telemetry_link=0;					//Stop sending telemetry
+		#endif
+	}
+#endif
+
+#if defined(FRSKYX_CC2500_INO) || defined(FRSKYL_CC2500_INO)
+static void __attribute__((unused)) FrSkyX_set_start(uint8_t ch )
+{
+	CC2500_Strobe(CC2500_SIDLE);
+	CC2500_WriteReg(CC2500_25_FSCAL1, calData[ch]);
+	CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency[ch]);
+}		
+
+static void __attribute__((unused)) FrSkyX_RF_init()
+{
+	if(protocol==PROTO_FRSKYL)
+		FRSKY_init_cc2500(FRSKYL_cc2500_conf);
+	else
+		FRSKY_init_cc2500((FrSkyFormat&2)?FRSKYXEU_cc2500_conf:FRSKYX_cc2500_conf); // LBT or FCC
+	if(protocol==PROTO_FRSKYX2)
+	{
+		CC2500_WriteReg(CC2500_08_PKTCTRL0, 0x05);		// Enable CRC
+		if(!(FrSkyFormat&2))
+		{ // FCC
+			CC2500_WriteReg(CC2500_17_MCSM1, 0x0E);		//0x0E -> RX stays in RX and TX stays in TX???
+			CC2500_WriteReg(CC2500_11_MDMCFG3, 0x84);	// bitrate 70K->77K
+		}
+	}
+	//
+	for(uint8_t c=0;c < 48;c++)
+	{//calibrate hop channels
+		CC2500_Strobe(CC2500_SIDLE);    
+		CC2500_WriteReg(CC2500_0A_CHANNR,hopping_frequency[c]);
+		CC2500_Strobe(CC2500_SCAL);
+		delayMicroseconds(900);//
+		calData[c] = CC2500_ReadReg(CC2500_25_FSCAL1);
+	}
+	//#######END INIT########		
+}
+
+static void __attribute__((unused)) FrSkyX_initialize_data(uint8_t adr)
+{
+	CC2500_WriteReg(CC2500_18_MCSM0,    0x8);	
+	CC2500_WriteReg(CC2500_09_ADDR, adr ? 0x03 : rx_tx_addr[3]);
+	CC2500_WriteReg(CC2500_07_PKTCTRL1,0x05);	// check address
+}
+
+#endif

Multiprotocol/FrSkyD_cc2500.ino

@@ -17,30 +17,12 @@
 
 #include "iface_cc2500.h"
 
-static void __attribute__((unused)) frsky2way_init(uint8_t bind)
+static void __attribute__((unused)) FRSKYD_RF_init()
 {
-	// Configure cc2500 for tx mode
-	//
-	for(uint8_t i=0;i<36;i++)
-	{
-		uint8_t reg=pgm_read_byte_near(&cc2500_conf[i][0]);
-		uint8_t val=pgm_read_byte_near(&cc2500_conf[i][1]);
+	FRSKY_init_cc2500(FRSKYD_cc2500_conf);	
 
-		if(reg==CC2500_0C_FSCTRL0)
-			val=option;
-		else
-			if(reg==CC2500_1B_AGCCTRL2)
-				val=bind ? 0x43 : 0x03;
-		CC2500_WriteReg(reg,val);
-	}
-	prev_option = option ;
-
-	CC2500_SetTxRxMode(TX_EN);
-	CC2500_SetPower();
-	
-	CC2500_Strobe(CC2500_SIDLE);	
-
-	CC2500_WriteReg(CC2500_09_ADDR, bind ? 0x03 : rx_tx_addr[3]);
+	CC2500_WriteReg(CC2500_1B_AGCCTRL2, IS_BIND_IN_PROGRESS ? 0x43 : 0x03);
+	CC2500_WriteReg(CC2500_09_ADDR, IS_BIND_IN_PROGRESS ? 0x03 : rx_tx_addr[3]);
 	CC2500_WriteReg(CC2500_07_PKTCTRL1, 0x05);
 	CC2500_Strobe(CC2500_SIDLE);	// Go to idle...
 	//
@@ -50,17 +32,7 @@ static void __attribute__((unused)) frsky2way_init(uint8_t bind)
 	//#######END INIT########		
 }
 	
-static uint8_t __attribute__((unused)) get_chan_num(uint16_t idx)
-{
-	uint8_t ret = (idx * 0x1e) % 0xeb;
-	if(idx == 3 || idx == 23 || idx == 47)
-		ret++;
-	if(idx > 47)
-		return 0;
-	return ret;
-}
-
-static void __attribute__((unused)) frsky2way_build_bind_packet()
+static void __attribute__((unused)) FRSKYD_build_bind_packet()
 {
 	//11 03 01 d7 2d 00 00 1e 3c 5b 78 00 00 00 00 00 00 01
 	//11 03 01 19 3e 00 02 8e 2f bb 5c 00 00 00 00 00 00 01
@@ -71,21 +43,21 @@ static void __attribute__((unused)) frsky2way_build_bind_packet()
 	packet[4] = rx_tx_addr[2];
 	uint16_t idx = ((state -FRSKY_BIND) % 10) * 5;
 	packet[5] = idx;
-	packet[6] = get_chan_num(idx++);
-	packet[7] = get_chan_num(idx++);
-	packet[8] = get_chan_num(idx++);
-	packet[9] = get_chan_num(idx++);
-	packet[10] = get_chan_num(idx++);
+	packet[6] = hopping_frequency[idx++];
+	packet[7] = hopping_frequency[idx++];
+	packet[8] = hopping_frequency[idx++];
+	packet[9] = hopping_frequency[idx++];
+	packet[10] = hopping_frequency[idx++];
 	packet[11] = 0x00;
 	packet[12] = 0x00;
 	packet[13] = 0x00;
 	packet[14] = 0x00;
 	packet[15] = 0x00;
 	packet[16] = 0x00;
-	packet[17] = 0x01;
+	packet[17] = rx_tx_addr[1];
 }
 
-static void __attribute__((unused)) frsky2way_data_frame()
+static void __attribute__((unused)) FRSKYD_data_frame()
 {//pachet[4] is telemetry user frame counter(hub)
 	//11 d7 2d 22 00 01 c9 c9 ca ca 88 88 ca ca c9 ca 88 88
 	//11 57 12 00 00 01 f2 f2 f2 f2 06 06 ca ca ca ca 18 18
@@ -99,7 +71,7 @@ static void __attribute__((unused)) frsky2way_data_frame()
 		packet[4] = 0x00;
 	#endif
 
-	packet[5] = 0x01;
+	packet[5] = rx_tx_addr[1];
 	//
 	packet[10] = 0;
 	packet[11] = 0;
@@ -122,40 +94,59 @@ static void __attribute__((unused)) frsky2way_data_frame()
 	}
 } 
 
-uint16_t initFrSky_2way()
+void FRSKYD_init(void)
 {
-	if(IS_AUTOBIND_FLAG_on)
+	//FrskyD init hop
+	if (sub_protocol==DCLONE)
+		Frsky_init_clone();
+	else
 	{
-		frsky2way_init(1);
+		for(uint8_t i=0;i<50;i++)
+		{
+			uint8_t freq = (i * 0x1e) % 0xeb;
+			if(i == 3 || i == 23 || i == 47)
+				freq++;
+			if(i > 47)
+				freq=0;
+			hopping_frequency[i]=freq;
+		}
+		rx_tx_addr[1]=1;		// keep compatibility with already bound RXs
+	}
+	
+	packet_count=0;
+	if(IS_BIND_IN_PROGRESS)
+	{
+		FRSKYD_RF_init();
 		state = FRSKY_BIND;
 	}
 	else
 	{
-		frsky2way_init(0);
-		state = FRSKY_DATA2;
+		state = FRSKY_BIND_DONE;
 	}
-	return 10000;
 }	
 		
-uint16_t ReadFrSky_2way()
+uint16_t FRSKYD_callback(void)
 { 
 	if (state < FRSKY_BIND_DONE)
 	{
-		frsky2way_build_bind_packet();
+		FRSKYD_build_bind_packet();
 		CC2500_Strobe(CC2500_SIDLE);
 		CC2500_WriteReg(CC2500_0A_CHANNR, 0x00);
 		CC2500_WriteReg(CC2500_23_FSCAL3, 0x89);		
 		CC2500_Strobe(CC2500_SFRX);//0x3A
 		CC2500_WriteData(packet, packet[0]+1);
+		if(IS_BIND_DONE)
+			state = FRSKY_BIND_DONE;
+		else
 			state++;
 		return 9000;
 	}
 	if (state == FRSKY_BIND_DONE)
 	{
-		state = FRSKY_DATA2;
-		frsky2way_init(0);
-		counter = 0;
 		BIND_DONE;
+		FRSKYD_RF_init();
+		counter = 0;
+		state = FRSKY_DATA2;
 	}
 	else
 		if (state == FRSKY_DATA5)
@@ -169,7 +160,7 @@ uint16_t ReadFrSky_2way()
 	{	//telemetry receive
 		CC2500_SetTxRxMode(RX_EN);
 		CC2500_Strobe(CC2500_SIDLE);
-		CC2500_WriteReg(CC2500_0A_CHANNR, get_chan_num(counter % 47));
+		CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency[counter % 47]);
 		CC2500_WriteReg(CC2500_23_FSCAL3, 0x89);
 		state++;
 		return 1300;
@@ -178,28 +169,43 @@ uint16_t ReadFrSky_2way()
 	{
 		if (state == FRSKY_DATA1)
 		{
-			len = CC2500_ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
-			if (len && len<=MAX_PKT)//27 bytes
-			{
-				CC2500_ReadData(pkt, len);	//received telemetry packets			
-				#if defined(TELEMETRY)
-				//parse telemetry packet here
-				frsky_check_telemetry(pkt,len);	//check if valid telemetry packets and buffer them.
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(9000);
 			#endif
+			len = CC2500_ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+			if (len && len<=(0x11+3))// 20bytes
+			{		
+				CC2500_ReadData(packet_in, len);				//received telemetry packets
+				#if defined(TELEMETRY)
+					if(packet_in[len-1] & 0x80)
+					{//with valid crc
+						packet_count=0;
+						frsky_process_telemetry(packet_in,len);	//check if valid telemetry packets and buffer them.
+					}
+				#endif
+			}
+			else
+			{
+				packet_count++;
+				// restart sequence on missed packet - might need count or timeout instead of one missed
+				if(packet_count>100)
+				{//~1sec
+					packet_count=0;
+					#if defined TELEMETRY
+						telemetry_link=0;//no link frames
+						packet_in[6]=0;//no user frames.
+					#endif
+				}
 			}
 			CC2500_SetTxRxMode(TX_EN);
 			CC2500_SetPower();	// Set tx_power
 		}
 		CC2500_Strobe(CC2500_SIDLE);
-		CC2500_WriteReg(CC2500_0A_CHANNR, get_chan_num(counter % 47));
-		if ( prev_option != option )
-		{
-			CC2500_WriteReg(CC2500_0C_FSCTRL0,option);	// Frequency offset hack 
-			prev_option = option ;
-		}
+		CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency[counter % 47]);
+		CC2500_SetFreqOffset();
 		CC2500_WriteReg(CC2500_23_FSCAL3, 0x89);
 		CC2500_Strobe(CC2500_SFRX);        
-		frsky2way_data_frame();
+		FRSKYD_data_frame();
 		CC2500_WriteData(packet, packet[0]+1);
 		state++;
 	}				

Multiprotocol/FrSkyL_cc2500.ino

@@ -0,0 +1,257 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#if defined(FRSKYL_CC2500_INO)
+
+#include "iface_cc2500.h"
+
+//#define FRSKYL_FORCE_ID
+#define FRSKYL_PACKET_LEN	256
+#define FRSKYL_PERIOD		18000
+
+uint8_t FrSkyL_buffer[FRSKYL_PACKET_LEN];
+
+static void __attribute__((unused)) FrSkyL_build_bind_packet()
+{
+	//Header
+	packet[0] = 0x4E;				// Unknown but constant
+	//Bind packet
+	memset(&packet[1],0x00,3);
+	//ID
+	packet[4 ] = rx_tx_addr[3];		// ID
+	packet[5 ] = rx_tx_addr[2];		// ID
+	int idx = ((state -FRSKY_BIND) % 10) * 5;
+	packet[6 ] = idx;
+	packet[7 ] = hopping_frequency[idx++];
+	packet[8 ] = hopping_frequency[idx++];
+	packet[9 ] = hopping_frequency[idx++];
+	packet[10] = hopping_frequency[idx++];
+	packet[11] = hopping_frequency[idx++];
+	packet[12] = rx_tx_addr[1];		// ID or hw ver?
+	packet[13] = RX_num;
+	packet[14] = 0x00;				// Unknown but constant
+	//CRC
+	uint16_t lcrc = FrSkyX_crc(&packet[1], 14);
+	packet[15] = lcrc >> 8;
+	packet[16] = lcrc;
+	//Debug
+/*	debug("Bind:");
+	for(uint8_t i=0;i<17;i++)
+		debug(" %02X",packet[i]);
+	debugln("");*/
+}
+
+static void __attribute__((unused)) FrSkyL_build_packet()
+{
+	static uint8_t chan_offset=0;
+	uint16_t chan_0,chan_1;
+
+	//Header
+	packet[0 ] = 0x4E;				// Unknown but constant
+	//ID
+	packet[1 ] = rx_tx_addr[3];		// ID
+	packet[2 ] = rx_tx_addr[2];		// ID
+	packet[3 ] = rx_tx_addr[1];		// ID or hw ver?
+	//skip_hop
+	packet[4 ] = (FrSkyX_chanskip<<6)|hopping_frequency_no; 
+	packet[5 ] = FrSkyX_chanskip>>2;
+	//Channels
+	uint8_t startChan = chan_offset;
+	for(uint8_t i = 0; i <9 ; i+=3)
+	{//9 bytes of channel data
+		chan_0 = FrSkyX_scaleForPXX(startChan,6);
+		startChan++;
+		//
+		chan_1 = FrSkyX_scaleForPXX(startChan,6);
+		startChan++;
+		//
+		packet[6+i] = lowByte(chan_0);									//3 bytes*4
+		packet[6+i+1]=(((chan_0>>8) & 0x0F)|(chan_1 << 4));
+		packet[6+i+2]=chan_1>>4;
+	}
+	if(sub_protocol & 0x01 )											//6ch mode only??
+		chan_offset = 0 ;
+	else
+		chan_offset^=0x06;
+	//CRC
+	uint16_t lcrc = FrSkyX_crc(&packet[1], 14, RX_num);
+	packet[15] = lcrc >> 8;
+	packet[16] = lcrc;
+	//Debug
+	/*debug("Norm:");
+	for(uint8_t i=0;i<17;i++)
+		debug(" %02X",packet[i]);
+	debugln("");*/
+}
+
+static void __attribute__((unused))  FrSkyL_encode_packet(bool type)
+{
+	#define FRSKYL_BIT0 0xED
+	#define FRSKYL_BIT1 0x712
+	
+	uint32_t bits = 0;
+	uint8_t bitsavailable = 0;
+	uint8_t idx = 0,len=6;
+	if(type)
+	{//just replace packet content
+		idx=66;
+		len=17;
+	}
+
+	//debugln("Encode:");
+	for (uint8_t i = 0; i < len; i++)
+	{
+		uint8_t tmp=packet[i];
+		//debug("%02X =",tmp);
+		for(uint8_t j=0;j<8;j++)
+		{
+			bits <<= 11;
+			if(tmp&0x01)
+				bits |= FRSKYL_BIT1;
+			else
+				bits |= FRSKYL_BIT0;
+			tmp >>=1;
+			bitsavailable += 11;
+			while (bitsavailable >= 8) {
+				uint32_t bits_tmp=bits>>(bitsavailable-8);
+				bitsavailable -= 8;
+				FrSkyL_buffer[idx] = bits_tmp;
+				//debug(" %02X",FrSkyL_buffer[idx]);
+				idx++;
+			}
+		}
+		//debugln("");
+	}
+}
+
+uint16_t FRSKYL_callback()
+{
+	static uint8_t written=0, send=0;
+	switch(send)
+	{
+		case 1:
+			CC2500_Strobe(CC2500_SIDLE);
+			CC2500_Strobe(CC2500_SFTX);
+			CC2500_WriteRegisterMulti(CC2500_3F_TXFIFO, FrSkyL_buffer, 64);
+			CC2500_Strobe(CC2500_STX);
+			CC2500_Strobe(CC2500_SIDLE);	// This cancels the current transmission???
+			CC2500_WriteRegisterMulti(CC2500_3F_TXFIFO, FrSkyL_buffer, 64);
+			CC2500_Strobe(CC2500_SFTX);		// This just clears what we've written???
+			CC2500_Strobe(CC2500_STX);
+			CC2500_WriteRegisterMulti(CC2500_3F_TXFIFO, FrSkyL_buffer, 64);
+			written=64;
+			send++;
+			return 2623;
+		case 2:
+			len=FRSKYL_PACKET_LEN-written;
+			if(len>31)
+				len=31;
+			CC2500_WriteRegisterMulti(CC2500_3F_TXFIFO, FrSkyL_buffer+written, len);
+			written+=len;
+			if(len!=31)			//everything has been sent
+			{
+				send=0;
+				return 2936;
+			}
+			return 1984;
+	}
+	
+	switch(state)
+	{	
+		default: 
+			//Bind
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(9000);
+			#endif
+			FrSkyX_set_start(47);
+			CC2500_SetPower();
+			CC2500_Strobe(CC2500_SFRX);
+			//		
+			FrSkyL_build_bind_packet();
+			FrSkyL_encode_packet(true);
+
+			CC2500_Strobe(CC2500_SIDLE);
+			if(IS_BIND_DONE)
+				state = FRSKY_BIND_DONE;
+			else
+			{
+				state++;
+				send=1;
+			}
+			return 537;
+		case FRSKY_BIND_DONE:
+			FrSkyX_initialize_data(0);
+			hopping_frequency_no=0;
+			BIND_DONE;
+			state++;													//FRSKY_DATA1
+			break;
+
+		case FRSKY_DATA1:
+			CC2500_SetFreqOffset();
+			FrSkyX_set_start(hopping_frequency_no);
+			FrSkyL_build_packet();
+			FrSkyL_encode_packet(true);
+			CC2500_SetPower();
+			hopping_frequency_no = (hopping_frequency_no+FrSkyX_chanskip)%47;
+			send=1;
+			return 537;
+	}		
+	return 1;		
+}
+
+void FRSKYL_init()
+{
+	set_rx_tx_addr(MProtocol_id_master);
+	rx_tx_addr[1]=0x02;		// ID related, hw version?
+
+	#ifdef FRSKYL_FORCE_ID
+		rx_tx_addr[3]=0x0E;
+		rx_tx_addr[2]=0x1C;
+		rx_tx_addr[1]=0x02;
+	#endif
+	FrSkyX2_init_hop();
+	
+	while(!FrSkyX_chanskip)
+		FrSkyX_chanskip=random(0xfefefefe)%47;
+
+	FrSkyX_RF_init();
+
+	//Prepare frame
+	memset(FrSkyL_buffer,0x00,FRSKYL_PACKET_LEN-3);
+	memset(&FrSkyL_buffer[FRSKYL_PACKET_LEN-3],0x55,3);
+	memset(packet,0xAA,6);
+	FrSkyL_encode_packet(false);
+	/*debugln("Frame:");
+	for(uint16_t i=0;i<FRSKYL_PACKET_LEN;i++)
+	{
+		debug(" %02X",FrSkyL_buffer[i]);
+		if(i%11==10)
+			debugln("");
+	}
+	debugln("");*/
+	
+	if(IS_BIND_IN_PROGRESS)
+	{	   
+		state = FRSKY_BIND;
+		FrSkyX_initialize_data(1);
+	}
+	else
+	{
+		state = FRSKY_DATA1;
+		FrSkyX_initialize_data(0);
+	}
+}	
+#endif

Multiprotocol/FrSkyR9_sx1276.ino

@@ -0,0 +1,319 @@
+#if defined(FRSKYR9_SX1276_INO)
+#include "iface_sx1276.h"
+
+#define DISP_FREQ_TABLE
+
+#define FLEX_FREQ	29
+#define FCC_FREQ	43
+#define EU_FREQ		19
+
+enum {
+	FRSKYR9_FREQ=0,
+	FRSKYR9_DATA,
+	FRSKYR9_RX1,
+	FRSKYR9_RX2,
+};
+
+void FrSkyR9_set_frequency()
+{
+	uint8_t data[3];
+	uint16_t num=0;
+	hopping_frequency_no += FrSkyX_chanskip;
+	switch(sub_protocol & 0xFD)
+	{
+		case R9_868:
+			if(IS_BIND_DONE)							// if bind is in progress use R9_915 instead
+			{
+				hopping_frequency_no %= FLEX_FREQ;
+				num=hopping_frequency_no;
+				if(hopping_frequency_no>=FLEX_FREQ-2)
+					num+=FrSkyX_chanskip-FLEX_FREQ+2;	// the last 2 values are FrSkyX_chanskip and FrSkyX_chanskip+1
+				num <<= 5;
+				num += 0xD700;
+				break;
+			}//else use R9_915
+		case R9_915:
+			hopping_frequency_no %= FLEX_FREQ;
+			num=hopping_frequency_no;
+			if(hopping_frequency_no>=FLEX_FREQ-2)
+				num+=FrSkyX_chanskip-FLEX_FREQ+2;		// the last 2 values are FrSkyX_chanskip and FrSkyX_chanskip+1
+			num <<= 5;
+			num += 0xE4C0;
+			break;
+		case R9_FCC:
+			hopping_frequency_no %= FCC_FREQ;
+			num=hopping_frequency_no;
+			num <<= 5;
+			num += 0xE200;
+			break;
+		case R9_EU:
+			hopping_frequency_no %= EU_FREQ;
+			num=hopping_frequency_no;
+			num <<= 4;
+			num += 0xD7D0;
+			break;
+	}
+	data[0] = num>>8;
+	data[1] = num&0xFF;
+	data[2] = 0x00;
+
+	#ifdef DISP_FREQ_TABLE
+		if(phase==0xFF)
+			debugln("F%d=%02X%02X%02X=%lu", hopping_frequency_no, data[0], data[1], data[2], (uint32_t)((data[0]<<16)+(data[1]<<8)+data[2])*61);
+	#endif
+	SX1276_WriteRegisterMulti(SX1276_06_FRFMSB, data, 3);
+}
+
+static void __attribute__((unused)) FrSkyR9_build_packet()
+{
+	//ID
+	packet[0] = rx_tx_addr[1];
+	packet[1] = rx_tx_addr[2];
+	packet[2] = rx_tx_addr[3];
+
+	//Hopping
+	packet[3] = hopping_frequency_no;	// current channel index
+	packet[4] = FrSkyX_chanskip;		// step size and last 2 channels start index
+
+	//RX number
+	packet[5] = RX_num;					// receiver number from OpenTX
+
+	//Channels
+	FrSkyX_channels(6);					// Set packet[6]=failsafe, packet[7]=0?? and packet[8..19]=channels data
+
+	//Bind
+	if(IS_BIND_IN_PROGRESS)
+	{// 915 0x01=CH1-8_TELEM_ON 0x41=CH1-8_TELEM_OFF 0xC1=CH9-16_TELEM_OFF 0x81=CH9-16_TELEM_ON
+		packet[6] = 0x01;				// bind indicator
+		if(sub_protocol & 1)
+			packet[6] |= 0x20;			// 868
+		if(binding_idx&0x01)
+			packet[6] |= 0x40;			// telem OFF
+		if(binding_idx&0x02)
+			packet[6] |= 0x80;			// ch9-16
+	}
+
+	//Sequence and send SPort
+	FrSkyX_seq_sport(20,23);			//20=RX|TXseq, 21=bytes count, 22&23=data
+
+	//CRC
+	uint16_t crc = FrSkyX_crc(packet, 24);
+	packet[24] = crc;					// low byte
+	packet[25] = crc >> 8;				// high byte
+}
+
+static uint8_t __attribute__((unused)) FrSkyR9_CRC8(uint8_t *p, uint8_t l)
+{
+	uint8_t crc = 0xFF;
+	for (uint8_t i = 0; i < l; i++)
+    {
+		crc = crc ^ p[i];
+		for ( uint8_t j = 0; j < 8; j++ ) 
+			if ( crc & 0x80 )
+			{
+				crc <<= 1;
+				crc ^= 0x07;
+			}
+			else
+				crc <<= 1;
+	}
+	return crc;
+}
+
+static void __attribute__((unused)) FrSkyR9_build_EU_packet()
+{
+	//ID
+	packet[0] = rx_tx_addr[1];
+	packet[1] = rx_tx_addr[2];
+	packet[2] = rx_tx_addr[3];
+
+	//Hopping
+	packet[3] = FrSkyX_chanskip;		// step size and last 2 channels start index
+
+	//RX number
+	packet[4] = RX_num;					// receiver number from OpenTX
+
+	//Channels
+	//TODO FrSkyX_channels(5,4);			// Set packet[5]=failsafe and packet[6..11]=4 channels data
+
+	//Bind
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[5] = 0x01;				// bind indicator
+		if((sub_protocol & 2) == 0)
+			packet[5] |= 0x10;			// 16CH
+		// if(sub_protocol & 1)
+			// packet[5] |= 0x20;			// 868
+		if(binding_idx&0x01)
+			packet[5] |= 0x40;			// telem OFF
+		if(binding_idx&0x02)
+			packet[5] |= 0x80;			// ch9-16
+	}
+
+	//Sequence and send SPort
+	packet[12] = (FrSkyX_RX_Seq << 4)|0x08;	//TX=8 at startup
+
+	//CRC
+	packet[13] = FrSkyR9_CRC8(packet, 13);
+}
+
+void FRSKYR9_init()
+{
+	//Check frequencies
+	#ifdef DISP_FREQ_TABLE
+		phase=0xFF;
+		FrSkyX_chanskip=1;
+		hopping_frequency_no=0xFF;
+		for(uint8_t i=0;i<FCC_FREQ;i++)
+			FrSkyR9_set_frequency();
+	#endif
+
+	//Reset ID
+	set_rx_tx_addr(MProtocol_id_master);
+
+	//FrSkyX_chanskip
+	FrSkyX_chanskip = 1 + (random(0xfefefefe) % 24);
+	debugln("chanskip=%d", FrSkyX_chanskip);
+	
+	//Set FrSkyFormat
+	if((sub_protocol & 0x02) == 0)
+		FrSkyFormat=0;											// 16 channels
+	else
+		FrSkyFormat=1;											// 8 channels
+	debugln("%dCH", FrSkyFormat&1 ? 8:16);
+	
+	//EU packet length
+	if( (sub_protocol & 0xFD) == R9_EU )
+		packet_length=14;
+	else
+		packet_length=26;
+
+	//SX1276 Init
+	SX1276_SetMode(true, false, SX1276_OPMODE_SLEEP);
+	SX1276_SetMode(true, false, SX1276_OPMODE_STDBY);
+
+	// uint8_t buffer[2];
+	// buffer[0] = 0x00;
+	// buffer[1] = 0x00;
+	// SX1276_WriteRegisterMulti(SX1276_40_DIOMAPPING1, buffer, 2);
+
+	SX1276_SetDetectOptimize(true, SX1276_DETECT_OPTIMIZE_SF6);
+	SX1276_ConfigModem1(SX1276_MODEM_CONFIG1_BW_500KHZ, SX1276_MODEM_CONFIG1_CODING_RATE_4_5, true);
+	SX1276_ConfigModem2(6, false, false);
+	SX1276_ConfigModem3(false, false);
+	SX1276_SetPreambleLength(9);
+	SX1276_SetDetectionThreshold(SX1276_MODEM_DETECTION_THRESHOLD_SF6);
+	SX1276_SetLna(1, true);
+	SX1276_SetHopPeriod(0);										// 0 = disabled, we hop frequencies manually
+	//RF Power
+	SX1276_SetPaDac(false);										// Disable 20dBm mode
+	#if MULTI_5IN1_INTERNAL == JP_T18
+		SX1276_SetPaConfig(true, 7, 0);							// Lowest power for the T18: 2dBm
+	#else
+		SX1276_SetPaConfig(true, 7, option);					// Use PA_HP on PA_BOOST, power=17-(15-option) dBm with option equal or lower to 15
+	#endif
+	SX1276_SetOcp(true,27);										// Set OCP to max 240mA
+	SX1276_SetTxRxMode(TX_EN);									// Set RF switch to TX
+	//Enable all IRQ flags
+	SX1276_WriteReg(SX1276_11_IRQFLAGSMASK,0x00);
+	FrSkyX_telem_init();
+	
+	hopping_frequency_no=0;
+	phase=FRSKYR9_FREQ;
+}
+
+uint16_t FRSKYR9_callback()
+{
+	switch (phase)
+	{
+		case FRSKYR9_FREQ:
+			//Force standby
+			SX1276_SetMode(true, false, SX1276_OPMODE_STDBY);
+			//Set frequency
+			FrSkyR9_set_frequency(); 							// Set current center frequency
+			//Set power
+			// max power: 15dBm (10.8 + 0.6 * MaxPower [dBm])
+			// output_power: 2 dBm ( (if pa_boost_pin == true))
+			#if MULTI_5IN1_INTERNAL != JP_T18
+				if(option != prev_option)
+				{	// Set RF power if it has changed
+					SX1276_SetPaConfig(true, 7, option);		// Use PA_HP on PA_BOOST, power=17-(15-option) dBm with option equal or lower to 15
+					prev_option = option;
+				}
+			#endif
+			//Build packet
+			if( packet_length == 26 )
+				FrSkyR9_build_packet();
+			else
+				FrSkyR9_build_EU_packet();
+			phase++;
+			return 460;											// Frequency settle time
+		case FRSKYR9_DATA:
+			//Set RF switch to TX
+			SX1276_SetTxRxMode(TX_EN);
+			//Send packet
+			SX1276_WritePayloadToFifo(packet, packet_length);
+			SX1276_SetMode(true, false, SX1276_OPMODE_TX);
+#if not defined TELEMETRY
+			phase=FRSKYR9_FREQ;
+			return 20000-460;
+#else
+			phase++;
+			return 11140;										// Packet send time
+		case FRSKYR9_RX1:
+			//Force standby
+			SX1276_SetMode(true, false, SX1276_OPMODE_STDBY);
+			//RX packet size is 13
+			SX1276_WriteReg(SX1276_22_PAYLOAD_LENGTH, 13);
+			//Reset pointer
+			SX1276_WriteReg(SX1276_0D_FIFOADDRPTR, 0x00);
+			//Set RF switch to RX
+			SX1276_SetTxRxMode(RX_EN);
+			//Clear all IRQ flags
+			SX1276_WriteReg(SX1276_12_REGIRQFLAGS,0xFF);
+			//Switch to RX
+			SX1276_WriteReg(SX1276_01_OPMODE, 0x85);
+			phase++;
+			return 7400;
+		case FRSKYR9_RX2:
+			if( (SX1276_ReadReg(SX1276_12_REGIRQFLAGS)&0xF0) == (_BV(SX1276_REGIRQFLAGS_RXDONE) | _BV(SX1276_REGIRQFLAGS_VALIDHEADER)) )
+			{
+				if(SX1276_ReadReg(SX1276_13_REGRXNBBYTES)==13)
+				{
+					SX1276_ReadRegisterMulti(SX1276_00_FIFO,packet_in,13);
+					if( packet_in[9]==rx_tx_addr[1] && packet_in[10]==rx_tx_addr[2] && FrSkyX_crc(packet_in, 11, rx_tx_addr[1]+(rx_tx_addr[2]<<8))==(packet_in[11]+(packet_in[12]<<8)) )
+					{
+						if(packet_in[0]&0x80)
+							RX_RSSI=packet_in[0]<<1;
+						else
+							v_lipo1=(packet_in[0]<<1)+1;
+						//TX_LQI=~(SX1276_ReadReg(SX1276_19_PACKETSNR)>>2)+1;
+						TX_RSSI=SX1276_ReadReg(SX1276_1A_PACKETRSSI)-157;
+						for(uint8_t i=0;i<9;i++)
+							packet[4+i]=packet_in[i];			// Adjust buffer to match FrSkyX
+						frsky_process_telemetry(packet,len);	// Process telemetry packet
+						pps_counter++;
+						if(TX_LQI==0)
+							TX_LQI++;							// Recover telemetry right away
+					}
+				}
+			}
+			if (millis() - pps_timer >= 1000)
+			{//1 packet every 20ms
+				pps_timer = millis();
+				debugln("%d pps", pps_counter);
+				TX_LQI = pps_counter<<1;						// Max=100%
+				pps_counter = 0;
+			}
+			if(TX_LQI==0)
+				FrSkyX_telem_init();							// Reset telemetry
+			else
+				telemetry_link=1;								// Send telemetry out anyway
+			phase=FRSKYR9_FREQ;
+			break;
+#endif
+	}
+	return 1000;
+}
+
+#endif

Multiprotocol/FrSkyV_cc2500.ino

@@ -27,50 +27,6 @@ enum {
 
 
 #include "iface_cc2500.h"
-const PROGMEM uint8_t FRSKYV_cc2500_conf[][2]={
-	{ CC2500_17_MCSM1, 0x0c },
-	{ CC2500_18_MCSM0, 0x18 },
-	{ CC2500_06_PKTLEN, 0xff },
-	{ CC2500_07_PKTCTRL1, 0x04 },
-	{ CC2500_08_PKTCTRL0, 0x05 },
-	{ CC2500_3E_PATABLE, 0xfe },
-	{ CC2500_0B_FSCTRL1, 0x08 },
-	{ CC2500_0C_FSCTRL0, 0x00 },
-	{ CC2500_0D_FREQ2, 0x5c },
-	{ CC2500_0E_FREQ1, 0x58 },
-	{ CC2500_0F_FREQ0, 0x9d },
-	{ CC2500_10_MDMCFG4, 0xaa },
-	{ CC2500_11_MDMCFG3, 0x10 },
-	{ CC2500_12_MDMCFG2, 0x93 },
-	{ CC2500_13_MDMCFG1, 0x23 },
-	{ CC2500_14_MDMCFG0, 0x7a },
-	{ CC2500_15_DEVIATN, 0x41 }
-};
-
-static void __attribute__((unused)) FRSKYV_init()
-{
-	for(uint8_t i=0;i<17;i++)
-	{
-		uint8_t reg=pgm_read_byte_near(&FRSKYV_cc2500_conf[i][0]);
-		uint8_t val=pgm_read_byte_near(&FRSKYV_cc2500_conf[i][1]);
-		if(reg==CC2500_0C_FSCTRL0)
-			val=option;
-		CC2500_WriteReg(reg,val);
-	}
-	prev_option = option ;
-	for(uint8_t i=19;i<36;i++)
-	{
-		uint8_t reg=pgm_read_byte_near(&cc2500_conf[i][0]);
-		uint8_t val=pgm_read_byte_near(&cc2500_conf[i][1]);
-		CC2500_WriteReg(reg,val);
-	}
-	
-	CC2500_SetTxRxMode(TX_EN);
-	CC2500_SetPower();
-
-	CC2500_Strobe(CC2500_SIDLE);    // Go to idle...
-}
-
 static uint8_t __attribute__((unused)) FRSKYV_crc8(uint8_t result, uint8_t *data, uint8_t len)
 {
 	for(uint8_t i = 0; i < len; i++)
@@ -157,17 +113,16 @@ static void __attribute__((unused)) FRSKYV_build_data_packet()
 	packet[14] = FRSKYV_crc8(crc8, packet, 14);
 }
 
-uint16_t ReadFRSKYV()
+uint16_t FRSKYV_callback(void)
 {
-	if(IS_BIND_DONE_on)
+	if(IS_BIND_DONE)
 	{	// Normal operation
+		#ifdef MULTI_SYNC
+			telemetry_set_input_sync(9006);
+		#endif
 		uint8_t chan = FRSKYV_calc_channel();
 		CC2500_Strobe(CC2500_SIDLE);
-		if (option != prev_option)
-		{
-			CC2500_WriteReg(CC2500_0C_FSCTRL0, option);
-			prev_option=option;
-		}
+		CC2500_SetFreqOffset();
 		CC2500_WriteReg(CC2500_0A_CHANNR, chan * 5 + 6);
 		FRSKYV_build_data_packet();
 
@@ -193,17 +148,16 @@ uint16_t ReadFRSKYV()
 	return 53460;
 }
 
-uint16_t initFRSKYV()
+void FRSKYV_init(void)
 {
 	//ID is 15 bits. Using rx_tx_addr[2] and rx_tx_addr[3] since we want to use RX_Num for model match
 	rx_tx_addr[2]&=0x7F;
 	crc8 = FRSKYV_crc8_le(rx_tx_addr+2, 2);
 
-	FRSKYV_init();
+	FRSKY_init_cc2500(FRSKYV_cc2500_conf);
 	seed = 1;
 	binding_idx=0;
 	phase = FRSKYV_DATA1;
-	return 10000;
 }
 
 #endif

Multiprotocol/FrSkyX_cc2500.ino

@@ -1,7 +1,4 @@
-
-/*  **************************
-	* By Midelic on RCGroups *
-	**************************
+/*
  This project is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
@@ -20,318 +17,270 @@
 
 #include "iface_cc2500.h"
 
-uint8_t chanskip;
-uint8_t counter_rst;
-uint8_t ctr;
-uint8_t seq_last_sent;
-uint8_t seq_last_rcvd;
-
-const PROGMEM uint8_t hop_data[]={
-	0x02,	0xD4,	0xBB,	0xA2,	0x89,
-	0x70,	0x57,	0x3E,	0x25,	0x0C,
-	0xDE,	0xC5,	0xAC,	0x93,	0x7A,
-	0x61,	0x48,	0x2F,	0x16,	0xE8,
-	0xCF,	0xB6,	0x9D,	0x84,	0x6B,
-	0x52,	0x39,	0x20,	0x07,	0xD9,
-	0xC0,	0xA7,	0x8E,	0x75,	0x5C,
-	0x43,	0x2A,	0x11,	0xE3,	0xCA,
-	0xB1,	0x98,	0x7F,	0x66,	0x4D,
-	0x34,	0x1B,	0x00,	0x1D,	0x03 
-};
-
-static uint8_t __attribute__((unused)) hop(uint8_t byte)
+static void __attribute__((unused)) FrSkyX_build_bind_packet()
 {
-	return pgm_read_byte_near(&hop_data[byte]);
-}
+	//Header
+	packet[0] = packet_length;				// Number of bytes in the packet (after this one)
+	packet[1] = 0x03;						// Bind packet
+	packet[2] = 0x01;						// Bind packet
 
-static void __attribute__((unused)) set_start(uint8_t ch )
+	//ID
+	packet[3] = rx_tx_addr[3];				// ID
+	packet[4] = rx_tx_addr[2];				// ID
+
+	if(protocol==PROTO_FRSKYX)
 	{
-	CC2500_Strobe(CC2500_SIDLE);
-	CC2500_WriteReg(CC2500_25_FSCAL1, calData[ch]);
-	CC2500_WriteReg(CC2500_0A_CHANNR, ch==47? 0:hop(ch));
-}		
-
-static void __attribute__((unused)) frskyX_init()
-{
-	for(uint8_t i=0;i<36;i++)
-	{
-		uint8_t reg=pgm_read_byte_near(&cc2500_conf[i][0]);
-		uint8_t val=pgm_read_byte_near(&cc2500_conf[i][1]);
-		
-		if(reg==CC2500_06_PKTLEN)
-			val=0x1E;
-		else
-		if(reg==CC2500_08_PKTCTRL0)
-			val=0x01;
-		else
-		if(reg==CC2500_0B_FSCTRL1)
-			val=0x0A;
-		else
-		if(reg==CC2500_10_MDMCFG4)
-			val=0x7B;
-		else
-		if(reg==CC2500_11_MDMCFG3)
-			val=0x61;
-		else
-		if(reg==CC2500_12_MDMCFG2)
-			val=0x13;
-		else
-		if(reg==CC2500_15_DEVIATN)
-			val=0x51;
-		
-		CC2500_WriteReg(reg,val);
-	}
-
-	CC2500_WriteReg(CC2500_07_PKTCTRL1, 0x04);			
-	prev_option = option ;
-	CC2500_WriteReg(CC2500_0C_FSCTRL0, option);
-	CC2500_Strobe(CC2500_SIDLE);    
-	//
-	for(uint8_t c=0;c < 47;c++)
-	{//calibrate hop channels
-		CC2500_Strobe(CC2500_SIDLE);    
-		CC2500_WriteReg(CC2500_0A_CHANNR,hop(c));
-		CC2500_Strobe(CC2500_SCAL);
-		delayMicroseconds(900);//
-		calData[c] = CC2500_ReadReg(CC2500_25_FSCAL1);
-	}
-	CC2500_Strobe(CC2500_SIDLE);    	
-	CC2500_WriteReg(CC2500_0A_CHANNR,0x00);
-	CC2500_Strobe(CC2500_SCAL);
-	delayMicroseconds(900);
-	calData[47] = CC2500_ReadReg(CC2500_25_FSCAL1);
-	//#######END INIT########		
-}
-
-static void __attribute__((unused)) initialize_data(uint8_t adr)
-{
-	CC2500_WriteReg(CC2500_0C_FSCTRL0,option);	// Frequency offset hack 
-	CC2500_WriteReg(CC2500_18_MCSM0,    0x8);	
-	CC2500_WriteReg(CC2500_09_ADDR, adr ? 0x03 : rx_tx_addr[3]);
-	CC2500_WriteReg(CC2500_07_PKTCTRL1,0x05);
-}
-
-//**CRC**
-const uint16_t PROGMEM CRC_Short[]={
-	0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF,
-	0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7 };
-static uint16_t CRCTable(uint8_t val)
-{
-	uint16_t word ;
-	word = pgm_read_word(&CRC_Short[val&0x0F]) ;
-	val /= 16 ;
-	return word ^ (0x1081 * val) ;
-}
-static uint16_t __attribute__((unused)) crc_x(uint8_t *data, uint8_t len)
-{
-	uint16_t crc = 0;
-	for(uint8_t i=0; i < len; i++)
-		crc = (crc<<8) ^ CRCTable((uint8_t)(crc>>8) ^ *data++);
-	return crc;
-}
-
- // 0-2047, 0 = 817, 1024 = 1500, 2047 = 2182
- //64=860,1024=1500,1984=2140//Taranis 125%
-
-static uint16_t  __attribute__((unused)) scaleForPXX( uint8_t i )
-{	//mapped 860,2140(125%) range to 64,1984(PXX values);
-	return (uint16_t)(((Servo_data[i]-servo_min_125)*3)>>1)+64;
-}
-
-static void __attribute__((unused)) frskyX_build_bind_packet()
-{
-	packet[0] = 0x1D;       
-	packet[1] = 0x03;          
-	packet[2] = 0x01;               
-	//	
-	packet[3] = rx_tx_addr[3];
-	packet[4] = rx_tx_addr[2];
 		int idx = ((state -FRSKY_BIND) % 10) * 5;
 		packet[5] = idx;
-	packet[6] = hop(idx++);
-	packet[7] = hop(idx++);
-	packet[8] = hop(idx++);
-	packet[9] = hop(idx++);
-	packet[10] = hop(idx++);
-	packet[11] = 0x02;
+		packet[6] = hopping_frequency[idx++];
+		packet[7] = hopping_frequency[idx++];
+		packet[8] = hopping_frequency[idx++];
+		packet[9] = hopping_frequency[idx++];
+		packet[10] = hopping_frequency[idx++];
+		packet[11] = rx_tx_addr[1];			// ID
 		packet[12] = RX_num;
 		//
-	memset(&packet[13], 0, 15);	
-	uint16_t lcrc = crc_x(&packet[3], 25);	
-	//
-	packet[28] = lcrc >> 8;
-	packet[29] = lcrc;
-	//
+		memset(&packet[13], 0, packet_length - 14);
+		if(binding_idx&0x01)
+			memcpy(&packet[13],(void *)"\x55\xAA\x5A\xA5",4);	// Telem off
+		if(binding_idx&0x02)
+			memcpy(&packet[17],(void *)"\x55\xAA\x5A\xA5",4);	// CH9-16
+	}
+	else
+	{
+		//packet 1D 03 01 0E 1C 02 00 00 32 0B 00 00 A8 26 28 01 A1 00 00 00 3E F6 87 C7 00 00 00 00 C9 C9
+		//Unknown bytes
+		if(state & 0x01)
+			memcpy(&packet[7],"\x00\x18\x0A\x00\x00\xE0\x02\x0B\x01\xD3\x08\x00\x00\x4C\xFE\x87\xC7",17);
+		else
+			memcpy(&packet[7],"\x27\xAD\x02\x00\x00\x64\xC8\x46\x00\x64\x00\x00\x00\xFB\xF6\x87\xC7",17);
+		//ID
+		packet[5] = rx_tx_addr[1];			// ID
+		packet[6] = RX_num;
+		//Bind flags
+		if(binding_idx&0x01)
+			packet[7] |= 0x40;				// Telem off
+		if(binding_idx&0x02)
+			packet[7] |= 0x80;				// CH9-16
+		//Replace the ID
+		packet[20] ^= 0x0E ^ rx_tx_addr[3];	// Update the ID
+		packet[21] ^= 0x1C ^ rx_tx_addr[2];	// Update the ID
+		//Xor
+		for(uint8_t i=3; i<packet_length-1; i++)
+			packet[i] ^= 0xA7;
+	}
+	//CRC
+	uint16_t lcrc = FrSkyX_crc(&packet[3], packet_length-4);
+	packet[packet_length-1] = lcrc >> 8;
+	packet[packet_length]   = lcrc;
+
+	/*//Debug
+	debug("Bind:");
+	for(uint8_t i=0;i<=packet_length;i++)
+		debug(" %02X",packet[i]);
+	debugln("");*/
 }
 
-static void __attribute__((unused)) frskyX_data_frame()
+static void __attribute__((unused)) FrSkyX_build_packet()
 {
 	//0x1D 0xB3 0xFD 0x02 0x56 0x07 0x15 0x00 0x00 0x00 0x04 0x40 0x00 0x04 0x40 0x00 0x04 0x40 0x00 0x04 0x40 0x08 0x00 0x00 0x00 0x00 0x00 0x00 0x96 0x12
+    // data frames sent every 9ms; failsafe every 9 seconds
 	//
-	static uint8_t lpass;
-	uint16_t chan_0 ;
-	uint16_t chan_1 ; 
-	uint8_t startChan = 0;
+	//Header
+	packet[0] = packet_length;			// Number of bytes in the packet (after this one)
+	packet[1] = rx_tx_addr[3];			// ID
+	packet[2] = rx_tx_addr[2];			// ID
+	packet[3] = rx_tx_addr[1];			// Unknown but constant ID?
 	//  
-	packet[0] = 0x1D; 
-	packet[1] = rx_tx_addr[3];
-	packet[2] = rx_tx_addr[2];
-	packet[3] = 0x02;
-	//  
-	packet[4] = (ctr<<6)+hopping_frequency_no; 
-	packet[5] = counter_rst;
+	packet[4] = (FrSkyX_chanskip<<6)|hopping_frequency_no; 
+	packet[5] = FrSkyX_chanskip>>2;
 	packet[6] = RX_num;
-	//packet[7] = FLAGS 00 - standard packet
-	//10, 12, 14, 16, 18, 1A, 1C, 1E - failsafe packet
-	//20 - range check packet
-	packet[7] = 0;
-	packet[8] = 0;		
-	//
-	if ( lpass & 1 )
-		startChan += 8 ;
 
-	for(uint8_t i = 0; i <12 ; i+=3)
-	{//12 bytes
-		chan_0 = scaleForPXX(startChan);		 
-		if(lpass & 1 )
-			chan_0+=2048;			
-		startChan+=1;
-		//
-		chan_1 = scaleForPXX(startChan);		
-		if(lpass & 1 )
-			chan_1+= 2048;		
-		startChan+=1;
-		//
-		packet[9+i] = lowByte(chan_0);//3 bytes*4
-		packet[9+i+1]=(((chan_0>>8) & 0x0F)|(chan_1 << 4));
-		packet[9+i+2]=chan_1>>4;
+	//Channels
+	FrSkyX_channels(7);					// Set packet[7]=failsafe, packet[8]=0?? and packet[9..20]=channels data
+	
+	//Sequence and send SPort
+	FrSkyX_seq_sport(21,packet_length-2);	//21=RX|TXseq, 22=bytes count, 23..packet_length-2=data
+
+	//CRC
+	uint16_t lcrc = FrSkyX_crc(&packet[3], packet_length-4);
+	packet[packet_length-1] = lcrc >> 8;
+	packet[packet_length]   = lcrc;
+
+	/*//Debug
+	debug("Norm:");
+	for(uint8_t i=0;i<=packet_length;i++)
+		debug(" %02X",packet[i]);
+	debugln("");*/
 }
 
-	packet[21] = seq_last_sent << 4 | seq_last_rcvd;//8 at start
-	if (seq_last_sent < 0x08 && seq_last_rcvd < 8)
-		seq_last_sent = (seq_last_sent + 1) % 4;
-	else if (seq_last_rcvd == 0x00)
-		seq_last_sent = 1;
-	
-	if(sub_protocol== CH_8 )// in X8 mode send only 8ch every 9ms
-		lpass = 0 ;
-	else
-		lpass += 1 ;
-	
-	for (uint8_t i=22;i<28;i++)
-		packet[i]=0;
-	uint16_t lcrc = crc_x(&packet[3], 25);
-	
-	packet[28]=lcrc>>8;//high byte
-	packet[29]=lcrc;//low byte
-}
-
-uint16_t ReadFrSkyX()
+uint16_t FRSKYX_callback()
 {
 	switch(state)
 	{	
 		default: 
-			set_start(47);		
+			FrSkyX_set_start(47);		
 			CC2500_SetPower();
 			CC2500_Strobe(CC2500_SFRX);
 			//		
-			frskyX_build_bind_packet();
+			FrSkyX_build_bind_packet();
 			CC2500_Strobe(CC2500_SIDLE);
 			CC2500_WriteData(packet, packet[0]+1);
-			state++;
-			return 9000;
-		case FRSKY_BIND_DONE:
-			initialize_data(0);
-			hopping_frequency_no=0;
-			BIND_DONE;
+			if(IS_BIND_DONE)
+				state = FRSKY_BIND_DONE;
+			else
 				state++;
 			break;
+		case FRSKY_BIND_DONE:
+			FrSkyX_initialize_data(0);
+			hopping_frequency_no=0;
+			BIND_DONE;
+			state++;														//FRSKY_DATA1
+			break;
+
 		case FRSKY_DATA1:
-			if ( prev_option != option )
-			{
-				CC2500_WriteReg(CC2500_0C_FSCTRL0,option);	// Frequency offset hack 
-				prev_option = option ;
+			CC2500_Strobe(CC2500_SIDLE);
+			CC2500_SetFreqOffset();
+			FrSkyX_set_start(hopping_frequency_no);
+			FrSkyX_build_packet();
+			if(FrSkyFormat & 2)
+			{// LBT
+				CC2500_Strobe(CC2500_SRX);									//Acquire RSSI
+				state++;
+				return 400;		// LBT
 			}
-			CC2500_SetTxRxMode(TX_EN);
-			set_start(hopping_frequency_no);
-			CC2500_SetPower();		
-			CC2500_Strobe(CC2500_SFRX);
-			hopping_frequency_no = (hopping_frequency_no+chanskip)%47;
-			CC2500_Strobe(CC2500_SIDLE);		
-			CC2500_WriteData(packet, packet[0]+1);
-			//
-			frskyX_data_frame();
-			state++;
-			return 5500;
 		case FRSKY_DATA2:
-			CC2500_SetTxRxMode(RX_EN);
+			if(FrSkyFormat & 2)
+			{
+				uint16_t rssi=0;
+				for(uint8_t i=0;i<4;i++)
+					rssi += CC2500_ReadReg(CC2500_34_RSSI | CC2500_READ_BURST);	// 0.5 db/count, RSSI value read from the RSSI status register is a 2's complement number
+				rssi>>=2;
+				#if 0
+					uint8_t rssi_level=convert_channel_8b(CH16)>>1;			//CH16 0..127
+					if ( rssi > rssi_level && rssi < 128)					//test rssi level dynamically
+				#else
+					if ( rssi > 14 && rssi < 128)							//if RSSI above -65dBm (12=-70) => ETSI requirement
+				#endif
+				{
+					LBT_POWER_on;											//Reduce to low power before transmitting
+					debugln("Busy %d %d",hopping_frequency_no,rssi);
+				}
+			}
 			CC2500_Strobe(CC2500_SIDLE);
-			state++;
-			return 200;
+			CC2500_Strobe(CC2500_SFTX);										//Flush the TXFIFO
+			CC2500_SetTxRxMode(TX_EN);
+			CC2500_SetPower();
+			hopping_frequency_no = (hopping_frequency_no+FrSkyX_chanskip)%47;
+			CC2500_WriteData(packet, packet[0]+1);
+			state=FRSKY_DATA3;
+			if(FrSkyFormat & 2)
+				return 4000;	// LBT
+			else
+				return 5200;	// FCC
 		case FRSKY_DATA3:
+			CC2500_Strobe(CC2500_SIDLE);
+			CC2500_Strobe(CC2500_SFRX);										//Flush the RXFIFO
+			CC2500_SetTxRxMode(RX_EN);
 			CC2500_Strobe(CC2500_SRX);
 			state++;
-			return 3000;
+			if(FrSkyFormat & 2)
+				return 4200;	// LBT
+			else
+				return 3400;	// FCC
 		case FRSKY_DATA4:
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(9000);
+			#endif
+			#if defined TELEMETRY
 				len = CC2500_ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;	
-			if (len && (len<=(0x0E + 3)))				//Telemetry frame is 17
+				if (len && len <= 17)										//Telemetry frame is 17 bytes
 				{
-				counter=0;
-				CC2500_ReadData(pkt, len);
-				#if defined TELEMETRY
-					frsky_check_telemetry(pkt,len);	//check if valid telemetry packets
-					//parse telemetry packets here
-					//The same telemetry function used by FrSky(D8).
-				#endif
+					//debug("Telem:");
+					CC2500_ReadData(packet_in, len);						//Read what has been received so far
+					if(len<17)
+					{//not all bytes were received
+						uint8_t last_len=CC2500_ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+						if(last_len==17)									//All bytes received
+						{
+							CC2500_ReadData(packet_in+len, last_len-len);	//Finish to read
+							len=17;
 						}
+					}
+					if(len==17 && (protocol==PROTO_FRSKYX || (protocol==PROTO_FRSKYX2 && (packet_in[len-1] & 0x80))) )
+					{//Telemetry received with valid crc for FRSKYX2
+						//Debug
+						//for(uint8_t i=0;i<len;i++)
+						//	debug(" %02X",packet_in[i]);
+						if(frsky_process_telemetry(packet_in,len))			//Check and process telemetry packet
+						{//good packet received
+							pps_counter++;
+							if(TX_LQI==0)
+								TX_LQI++;									//Recover telemetry right away
+						}
+					}
+					//debugln("");
+				}
+				if (millis() - pps_timer >= 900)
+				{//1 packet every 9ms
+					pps_timer = millis();
+					debugln("%d pps", pps_counter);
+					TX_LQI = pps_counter;									//Max=100%
+					pps_counter = 0;
+				}
+				if(TX_LQI==0)
+					FrSkyX_telem_init();									//Reset telemetry
+				else
+					telemetry_link=1;										//Send telemetry out anyway
+			#endif
+			state = FRSKY_DATA1;
+			return 400;	// FCC & LBT
+	}
+	return 9000;
+}
+
+void FRSKYX_init()
+{
+	set_rx_tx_addr(MProtocol_id_master);
+	FrSkyFormat = sub_protocol;
+	
+	if (sub_protocol==XCLONE_16||sub_protocol==XCLONE_8)
+		Frsky_init_clone();
 	else
 	{
-				counter++;
-				// restart sequence on missed packet - might need count or timeout instead of one missed
-				if(counter>100)
-				{//~1sec
-					seq_last_sent = 0;
-					seq_last_rcvd = 8;
-					counter=0;
-					#if defined TELEMETRY
-						telemetry_lost=1;
+		if(protocol==PROTO_FRSKYX)
+			Frsky_init_hop();
+		else
+		{
+			#ifdef FRSKYX2_FORCE_ID
+				rx_tx_addr[3]=0x0E;
+				rx_tx_addr[2]=0x1C;
+				FrSkyX_chanskip=18;
 			#endif
+			FrSkyX2_init_hop();
 		}
-				CC2500_Strobe(CC2500_SFRX);			//flush the RXFIFO
-			}
-			state = FRSKY_DATA1;
-			return 300;
-	}		
-	return 1;		
+		rx_tx_addr[1]=0x02;		// ID related, hw version?
 	}
 	
-uint16_t initFrSkyX()
-{
-	while(!chanskip)
-		chanskip=random(0xfefefefe)%47;
-	while((chanskip-ctr)%4)
-		ctr=(ctr+1)%4;
+	if(protocol==PROTO_FRSKYX && (FrSkyFormat & 2 ))
+		packet_length = 0x20;	// FrSkyX V1 LBT
+	else
+		packet_length = 0x1D;
 
-	counter_rst=(chanskip-ctr)>>2;
-	//for test***************
-	//rx_tx_addr[3]=0xB3;
-	//rx_tx_addr[2]=0xFD;
-	//************************
-	frskyX_init();
-	CC2500_SetTxRxMode(TX_EN);
-	//
-	if(IS_AUTOBIND_FLAG_on)
+	packet_count=0;
+	while(!FrSkyX_chanskip)
+		FrSkyX_chanskip=random(0xfefefefe)%47;
+
+	FrSkyX_RF_init();
+
+	if(IS_BIND_IN_PROGRESS)
 	{	   
+		memset(packet, 0, packet_length);
 		state = FRSKY_BIND;
-		initialize_data(1);
+		FrSkyX_initialize_data(1);
 	}
 	else
-	{
-		state = FRSKY_DATA1;
-		initialize_data(0);
-	}
-	seq_last_sent = 0;
-	seq_last_rcvd = 8;
-	return 10000;
+		state = FRSKY_BIND_DONE;
+	FrSkyX_telem_init();
 }
 #endif

Multiprotocol/FrSky_Rx_cc2500.ino

@@ -0,0 +1,621 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(FRSKY_RX_CC2500_INO)
+
+#include "iface_cc2500.h" 
+
+ #define FRSKY_RX_D16FCC_LENGTH	0x1D+1
+ #define FRSKY_RX_D16LBT_LENGTH	0x20+1
+ #define FRSKY_RX_D16v2_LENGTH	0x1D+1
+ #define FRSKY_RX_D8_LENGTH		0x11+1
+ #define FRSKY_RX_FORMATS		5
+
+enum
+{
+	FRSKY_RX_D8			=0,
+	FRSKY_RX_D16FCC		=1,
+	FRSKY_RX_D16LBT		=2,
+	FRSKY_RX_D16v2FCC	=3,
+	FRSKY_RX_D16v2LBT	=4,
+};
+
+enum {
+	FRSKY_RX_TUNE_START,
+	FRSKY_RX_TUNE_LOW,
+	FRSKY_RX_TUNE_HIGH,
+	FRSKY_RX_BIND,
+	FRSKY_RX_DATA,
+};
+
+const PROGMEM uint8_t FRSKY_RX_common_reg[][2] = {
+	{CC2500_02_IOCFG0, 0x01},
+	{CC2500_18_MCSM0, 0x18},
+	{CC2500_07_PKTCTRL1, 0x05},
+	{CC2500_3E_PATABLE, 0xFF},
+	{CC2500_0C_FSCTRL0, 0},
+	{CC2500_0D_FREQ2, 0x5C},
+	{CC2500_13_MDMCFG1, 0x23},
+	{CC2500_14_MDMCFG0, 0x7A},
+	{CC2500_19_FOCCFG, 0x16},
+	{CC2500_1A_BSCFG, 0x6C},
+	{CC2500_1B_AGCCTRL2, 0x03},
+	{CC2500_1C_AGCCTRL1, 0x40},
+	{CC2500_1D_AGCCTRL0, 0x91},
+	{CC2500_21_FREND1, 0x56},
+	{CC2500_22_FREND0, 0x10},
+	{CC2500_23_FSCAL3, 0xA9},
+	{CC2500_24_FSCAL2, 0x0A},
+	{CC2500_25_FSCAL1, 0x00},
+	{CC2500_26_FSCAL0, 0x11},
+	{CC2500_29_FSTEST, 0x59},
+	{CC2500_2C_TEST2, 0x88},
+	{CC2500_2D_TEST1, 0x31},
+	{CC2500_2E_TEST0, 0x0B},
+	{CC2500_03_FIFOTHR, 0x07},
+	{CC2500_09_ADDR, 0x03},
+};
+
+const PROGMEM uint8_t FRSKY_RX_d16fcc_reg[][2] = {
+	{CC2500_17_MCSM1, 0x0C},
+	{CC2500_0E_FREQ1, 0x76},
+	{CC2500_0F_FREQ0, 0x27},
+	{CC2500_06_PKTLEN, 0x1E},
+	{CC2500_08_PKTCTRL0, 0x01},
+	{CC2500_0B_FSCTRL1, 0x0A},
+	{CC2500_10_MDMCFG4, 0x7B},
+	{CC2500_11_MDMCFG3, 0x61},
+	{CC2500_12_MDMCFG2, 0x13},
+	{CC2500_15_DEVIATN, 0x51},
+};
+
+const PROGMEM uint8_t FRSKY_RX_d16lbt_reg[][2] = {
+	{CC2500_17_MCSM1, 0x0E},
+	{CC2500_0E_FREQ1, 0x80},
+	{CC2500_0F_FREQ0, 0x00},
+	{CC2500_06_PKTLEN, 0x23},
+	{CC2500_08_PKTCTRL0, 0x01},
+	{CC2500_0B_FSCTRL1, 0x08},
+	{CC2500_10_MDMCFG4, 0x7B},
+	{CC2500_11_MDMCFG3, 0xF8},
+	{CC2500_12_MDMCFG2, 0x03},
+	{CC2500_15_DEVIATN, 0x53},
+};
+
+const PROGMEM uint8_t FRSKY_RX_d8_reg[][2] = {
+	{CC2500_17_MCSM1,    0x0C},
+	{CC2500_0E_FREQ1,    0x76},
+	{CC2500_0F_FREQ0,    0x27},
+	{CC2500_06_PKTLEN,   0x19},
+	{CC2500_08_PKTCTRL0, 0x05},
+	{CC2500_0B_FSCTRL1,  0x08},
+	{CC2500_10_MDMCFG4,  0xAA},
+	{CC2500_11_MDMCFG3,  0x39},
+	{CC2500_12_MDMCFG2,  0x11},
+	{CC2500_15_DEVIATN,  0x42},
+};
+
+static uint8_t FRSKY_RX_chanskip;
+static int8_t  FRSKY_RX_finetune;
+static uint8_t FRSKY_RX_format;
+
+static void __attribute__((unused)) FRSKY_RX_strobe_rx()
+{
+	 CC2500_Strobe(CC2500_SIDLE);
+	 CC2500_Strobe(CC2500_SFRX);
+	 CC2500_Strobe(CC2500_SRX);
+}
+
+static void __attribute__((unused)) FRSKY_RX_initialise_cc2500() {
+	const uint8_t FRSKY_RX_length[] = { FRSKY_RX_D8_LENGTH, FRSKY_RX_D16FCC_LENGTH, FRSKY_RX_D16LBT_LENGTH, FRSKY_RX_D16v2_LENGTH, FRSKY_RX_D16v2_LENGTH };
+	packet_length = FRSKY_RX_length[FRSKY_RX_format];
+	CC2500_Reset();
+	CC2500_Strobe(CC2500_SIDLE);
+	for (uint8_t i = 0; i < sizeof(FRSKY_RX_common_reg) / 2; i++)
+		CC2500_WriteReg(pgm_read_byte_near(&FRSKY_RX_common_reg[i][0]), pgm_read_byte_near(&FRSKY_RX_common_reg[i][1]));
+
+	switch (FRSKY_RX_format)
+	{
+		case FRSKY_RX_D16v2FCC:
+		case FRSKY_RX_D16FCC:
+			for (uint8_t i = 0; i < sizeof(FRSKY_RX_d16fcc_reg) / 2; i++)
+				CC2500_WriteReg(pgm_read_byte_near(&FRSKY_RX_d16fcc_reg[i][0]), pgm_read_byte_near(&FRSKY_RX_d16fcc_reg[i][1]));
+			if(FRSKY_RX_format==FRSKY_RX_D16v2FCC)
+			{
+				CC2500_WriteReg(CC2500_08_PKTCTRL0, 0x05);	// Enable CRC
+				CC2500_WriteReg(CC2500_17_MCSM1, 0x0E);		// Go/Stay in RX mode
+				CC2500_WriteReg(CC2500_11_MDMCFG3, 0x84);	// bitrate 70K->77K
+			}
+			break;
+		case FRSKY_RX_D16v2LBT:
+		case FRSKY_RX_D16LBT:
+			for (uint8_t i = 0; i < sizeof(FRSKY_RX_d16lbt_reg) / 2; i++)
+				CC2500_WriteReg(pgm_read_byte_near(&FRSKY_RX_d16lbt_reg[i][0]), pgm_read_byte_near(&FRSKY_RX_d16lbt_reg[i][1]));
+			if(FRSKY_RX_format==FRSKY_RX_D16v2LBT)
+				CC2500_WriteReg(CC2500_08_PKTCTRL0, 0x05);	// Enable CRC
+			break;
+		case FRSKY_RX_D8:
+			for (uint8_t i = 0; i < sizeof(FRSKY_RX_d8_reg) / 2; i++)
+				CC2500_WriteReg(pgm_read_byte_near(&FRSKY_RX_d8_reg[i][0]), pgm_read_byte_near(&FRSKY_RX_d8_reg[i][1]));
+			CC2500_WriteReg(CC2500_23_FSCAL3, 0x89);
+			break;
+	}
+	CC2500_WriteReg(CC2500_0A_CHANNR, 0);  // bind channel
+	rx_disable_lna = IS_POWER_FLAG_on;
+	CC2500_SetTxRxMode(rx_disable_lna ? TXRX_OFF : RX_EN); // lna disable / enable
+	FRSKY_RX_strobe_rx();
+	delayMicroseconds(1000); // wait for RX to activate
+}
+
+static void __attribute__((unused)) FRSKY_RX_set_channel(uint8_t channel)
+{
+	CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency[channel]);
+	if(FRSKY_RX_format == FRSKY_RX_D8)
+		CC2500_WriteReg(CC2500_23_FSCAL3, 0x89);
+	CC2500_WriteReg(CC2500_25_FSCAL1, calData[channel]);
+	FRSKY_RX_strobe_rx();
+}
+
+static void __attribute__((unused)) FRSKY_RX_calibrate()
+{
+	FRSKY_RX_strobe_rx();
+	for (unsigned c = 0; c < 47; c++)
+	{
+		CC2500_Strobe(CC2500_SIDLE);
+		CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency[c]);
+		CC2500_Strobe(CC2500_SCAL);
+		delayMicroseconds(900);
+		calData[c] = CC2500_ReadReg(CC2500_25_FSCAL1);
+	}
+}
+
+static uint8_t __attribute__((unused)) frskyx_rx_check_crc_id(bool bind,bool init)
+{
+	/*debugln("RX");
+	for(uint8_t i=0; i<packet_length;i++)
+		debug(" %02X",packet[i]);
+	debugln("");*/
+	
+	if(bind && packet[0]!=packet_length-1 && packet[1] !=0x03 && packet[2] != 0x01)
+		return false;
+	uint8_t offset=bind?3:1;
+	
+	// Check D8 checksum
+	if (FRSKY_RX_format == FRSKY_RX_D8)
+	{
+		if((packet[packet_length+1] & 0x80) != 0x80)	// Check CRC_OK flag in status byte 2
+			return false; 								// Bad CRC
+		if(init)
+		{//Save TXID
+			rx_tx_addr[3] = packet[3];
+			rx_tx_addr[2] = packet[4];
+			rx_tx_addr[1] = packet[17];
+		}
+		else
+			if(rx_tx_addr[3] != packet[offset] || rx_tx_addr[2] != packet[offset+1] || rx_tx_addr[1] != packet[bind?17:5])
+				return false;							// Bad address
+		return true;									// Full match
+	}
+
+	// Check D16v2 checksum
+	if (FRSKY_RX_format == FRSKY_RX_D16v2LBT || FRSKY_RX_format == FRSKY_RX_D16v2FCC)
+		if((packet[packet_length+1] & 0x80) != 0x80)	// Check CRC_OK flag in status byte 2
+			return false;
+	//debugln("HW Checksum ok");
+
+	// Check D16 checksum
+	uint16_t lcrc = FrSkyX_crc(&packet[3], packet_length - 5);		// Compute crc
+	uint16_t rcrc = (packet[packet_length-2] << 8) | (packet[packet_length-1] & 0xff);	// Received crc
+	if(lcrc != rcrc)
+		return false; 									// Bad CRC
+	//debugln("Checksum ok");
+
+	if (bind && (FRSKY_RX_format == FRSKY_RX_D16v2LBT || FRSKY_RX_format == FRSKY_RX_D16v2FCC))
+		for(uint8_t i=3; i<packet_length-2; i++)		//unXOR bind packet
+			packet[i] ^= 0xA7;
+	
+	uint8_t offset2=0;
+	if (bind && (FRSKY_RX_format == FRSKY_RX_D16LBT || FRSKY_RX_format == FRSKY_RX_D16FCC))
+		offset2=6;
+	if(init)
+	{//Save TXID
+		rx_tx_addr[3] = packet[3];
+		rx_tx_addr[2] = packet[4];
+		rx_tx_addr[1] = packet[5+offset2];
+		rx_tx_addr[0] = packet[6+offset2];				// RXnum
+	}
+	else
+		if(rx_tx_addr[3] != packet[offset] || rx_tx_addr[2] != packet[offset+1] || rx_tx_addr[1] != packet[offset+2+offset2])
+			return false;								// Bad address
+	//debugln("Address ok");
+	
+	if(!bind && rx_tx_addr[0] != packet[6])
+		return false;									// Bad RX num
+	
+	//debugln("Match");
+	return true;										// Full match
+}
+
+static void __attribute__((unused)) FRSKY_RX_build_telemetry_packet()
+{
+	uint16_t raw_channel[8];
+	uint32_t bits = 0;
+	uint8_t bitsavailable = 0;
+	uint8_t idx = 0;
+	uint8_t i;
+
+	if (FRSKY_RX_format == FRSKY_RX_D8)
+	{// decode D8 channels
+		raw_channel[0] = ((packet[10] & 0x0F) << 8 | packet[6]);
+		raw_channel[1] = ((packet[10] & 0xF0) << 4 | packet[7]);
+		raw_channel[2] = ((packet[11] & 0x0F) << 8 | packet[8]);
+		raw_channel[3] = ((packet[11] & 0xF0) << 4 | packet[9]);
+		raw_channel[4] = ((packet[16] & 0x0F) << 8 | packet[12]);
+		raw_channel[5] = ((packet[16] & 0xF0) << 4 | packet[13]);
+		raw_channel[6] = ((packet[17] & 0x0F) << 8 | packet[14]);
+		raw_channel[7] = ((packet[17] & 0xF0) << 4 | packet[15]);
+		for (i = 0; i < 8; i++) {
+			if (raw_channel[i] < 1290)
+				raw_channel[i] = 1290;
+			rx_rc_chan[i] = min(((raw_channel[i] - 1290) << 4) / 15, 2047);
+		}
+	}
+	else
+	{// decode D16 channels
+		raw_channel[0] = ((packet[10] << 8) & 0xF00) | packet[9];
+		raw_channel[1] = ((packet[11] << 4) & 0xFF0) | (packet[10] >> 4);
+		raw_channel[2] = ((packet[13] << 8) & 0xF00) | packet[12];
+		raw_channel[3] = ((packet[14] << 4) & 0xFF0) | (packet[13] >> 4);
+		raw_channel[4] = ((packet[16] << 8) & 0xF00) | packet[15];
+		raw_channel[5] = ((packet[17] << 4) & 0xFF0) | (packet[16] >> 4);
+		raw_channel[6] = ((packet[19] << 8) & 0xF00) | packet[18];
+		raw_channel[7] = ((packet[20] << 4) & 0xFF0) | (packet[19] >> 4);	
+		for (i = 0; i < 8; i++) {
+			// ignore failsafe channels
+			if(packet[7] != 0x10+(i<<1)) {
+				uint8_t shifted = (raw_channel[i] & 0x800)>0;
+				uint16_t channel_value = raw_channel[i] & 0x7FF;
+				if (channel_value < 64)
+					rx_rc_chan[shifted ? i + 8 : i] = 0;
+				else
+					rx_rc_chan[shifted ? i + 8 : i] = min(((channel_value - 64) << 4) / 15, 2047);
+			}
+		}
+	}
+
+	// buid telemetry packet
+	packet_in[idx++] = RX_LQI;
+	packet_in[idx++] = RX_RSSI;
+	packet_in[idx++] = 0;  // start channel
+	packet_in[idx++] = FRSKY_RX_format == FRSKY_RX_D8 ? 8 : 16; // number of channels in packet
+
+	// pack channels
+	for (i = 0; i < packet_in[3]; i++) {
+		bits |= ((uint32_t)rx_rc_chan[i]) << bitsavailable;
+		bitsavailable += 11;
+		while (bitsavailable >= 8) {
+			packet_in[idx++] = bits & 0xff;
+			bits >>= 8;
+			bitsavailable -= 8;
+		}
+	}
+}
+
+static void __attribute__((unused)) FRSKY_RX_data()
+{
+	uint16_t temp = FRSKY_RX_EEPROM_OFFSET;
+	FRSKY_RX_format = eeprom_read_byte((EE_ADDR)temp++) % FRSKY_RX_FORMATS;
+	rx_tx_addr[3] = eeprom_read_byte((EE_ADDR)temp++);
+	rx_tx_addr[2] = eeprom_read_byte((EE_ADDR)temp++);
+	rx_tx_addr[1] = eeprom_read_byte((EE_ADDR)temp++);
+	rx_tx_addr[0] = RX_num;
+	FRSKY_RX_finetune = eeprom_read_byte((EE_ADDR)temp++);
+	debug("format=%d, ", FRSKY_RX_format);
+	debug("addr[3]=%02X, ", rx_tx_addr[3]);
+	debug("addr[2]=%02X, ", rx_tx_addr[2]);
+	debug("addr[1]=%02X, ", rx_tx_addr[1]);
+	debug("rx_num=%02X, ",  rx_tx_addr[0]);
+	debugln("tune=%d", (int8_t)FRSKY_RX_finetune);
+	if(FRSKY_RX_format != FRSKY_RX_D16v2LBT && FRSKY_RX_format != FRSKY_RX_D16v2FCC)
+	{//D8 & D16v1
+		for (uint8_t ch = 0; ch < 47; ch++)
+			hopping_frequency[ch] = eeprom_read_byte((EE_ADDR)temp++);
+	}
+	else
+	{
+		FrSkyFormat=FRSKY_RX_format == FRSKY_RX_D16v2FCC?0:2;
+		FrSkyX2_init_hop();
+	}
+	debug("ch:");
+	for (uint8_t ch = 0; ch < 47; ch++)
+		debug(" %02X", hopping_frequency[ch]);
+	debugln("");
+
+	FRSKY_RX_initialise_cc2500();
+	FRSKY_RX_calibrate();
+	CC2500_WriteReg(CC2500_18_MCSM0, 0x08); // FS_AUTOCAL = manual
+	CC2500_WriteReg(CC2500_09_ADDR, rx_tx_addr[3]); // set address
+	CC2500_WriteReg(CC2500_07_PKTCTRL1, 0x05); // check address
+	if (option == 0)
+		CC2500_WriteReg(CC2500_0C_FSCTRL0, FRSKY_RX_finetune);
+	else
+		CC2500_WriteReg(CC2500_0C_FSCTRL0, option);
+	FRSKY_RX_set_channel(hopping_frequency_no);
+	phase = FRSKY_RX_DATA;
+}
+
+void FRSKY_RX_init()
+{
+	if(sub_protocol == FRSKY_ERASE)
+	{
+		if(IS_BIND_IN_PROGRESS)
+		{// Clear all cloned addresses
+			uint16_t addr[]={ FRSKYD_CLONE_EEPROM_OFFSET+1, FRSKYX_CLONE_EEPROM_OFFSET+1, FRSKYX2_CLONE_EEPROM_OFFSET+1 };
+			for(uint8_t i=0; i<3;i++)
+				for(uint8_t j=0; j<3;j++)
+					eeprom_write_byte((EE_ADDR)(addr[i]+j), 0xFF);
+			packet_count = 100;
+		}			
+	}
+	else
+	{
+		FRSKY_RX_chanskip = 1;
+		hopping_frequency_no = 0;
+		rx_data_started = false;
+		FRSKY_RX_finetune = 0;
+		telemetry_link = 0;
+		packet_count = 0;
+		if (IS_BIND_IN_PROGRESS)
+		{
+			FRSKY_RX_format = FRSKY_RX_D8;
+			FRSKY_RX_initialise_cc2500();
+			phase = FRSKY_RX_TUNE_START;
+			debugln("FRSKY_RX_TUNE_START");
+		}
+		else
+			FRSKY_RX_data();
+	}
+}
+
+uint16_t FRSKY_RX_callback()
+{
+	static int8_t read_retry = 0;
+	static int8_t tune_low, tune_high;
+	uint8_t len, ch;
+
+	if(sub_protocol == FRSKY_ERASE)
+	{
+		if(packet_count)
+			packet_count--;
+		else
+			BIND_DONE;
+		return 10000;	//  Nothing to do...
+	}
+
+	if(IS_BIND_DONE && phase != FRSKY_RX_DATA)
+		FRSKY_RX_init();	// Abort bind
+
+	if ((prev_option != option) && (phase >= FRSKY_RX_DATA))
+	{
+		if (option == 0)
+			CC2500_WriteReg(CC2500_0C_FSCTRL0, FRSKY_RX_finetune);
+		else
+			CC2500_WriteReg(CC2500_0C_FSCTRL0, option);
+		prev_option = option;
+	}
+
+	if (rx_disable_lna != IS_POWER_FLAG_on)
+	{
+		rx_disable_lna = IS_POWER_FLAG_on;
+		CC2500_SetTxRxMode(rx_disable_lna ? TXRX_OFF : RX_EN);
+	}
+
+	len = CC2500_ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+	switch(phase)
+	{
+		case FRSKY_RX_TUNE_START:
+			if (len == packet_length + 2) //+2=RSSI+LQI+CRC
+			{
+				CC2500_ReadData(packet, len);
+				if(frskyx_rx_check_crc_id(true,true))
+				{
+					FRSKY_RX_finetune = -127;
+					CC2500_WriteReg(CC2500_0C_FSCTRL0, FRSKY_RX_finetune);
+					phase = FRSKY_RX_TUNE_LOW;
+					debugln("FRSKY_RX_TUNE_LOW");
+					FRSKY_RX_strobe_rx();
+					state = 0;
+					return 1000;
+				}
+			}
+			FRSKY_RX_format = (FRSKY_RX_format + 1) % FRSKY_RX_FORMATS; // switch to next format (D8, D16FCC, D16LBT, D16v2FCC, D16v2LBT)
+			FRSKY_RX_initialise_cc2500();
+			FRSKY_RX_finetune += 10;
+			CC2500_WriteReg(CC2500_0C_FSCTRL0, FRSKY_RX_finetune);
+			FRSKY_RX_strobe_rx();
+			return 18000;
+
+		case FRSKY_RX_TUNE_LOW:
+			if (len == packet_length + 2) //+2=RSSI+LQI+CRC
+			{
+				CC2500_ReadData(packet, len);
+				if(frskyx_rx_check_crc_id(true,false)) {
+					tune_low = FRSKY_RX_finetune;
+					FRSKY_RX_finetune = 127;
+					CC2500_WriteReg(CC2500_0C_FSCTRL0, FRSKY_RX_finetune);
+					phase = FRSKY_RX_TUNE_HIGH;
+					debugln("FRSKY_RX_TUNE_HIGH");
+					FRSKY_RX_strobe_rx();
+					return 1000;
+				}
+			}
+			FRSKY_RX_finetune += 1;
+			CC2500_WriteReg(CC2500_0C_FSCTRL0, FRSKY_RX_finetune);
+			FRSKY_RX_strobe_rx();
+			return 18000;
+
+		case FRSKY_RX_TUNE_HIGH:
+			if (len == packet_length + 2) //+2=RSSI+LQI+CRC
+			{
+				CC2500_ReadData(packet, len);
+				if(frskyx_rx_check_crc_id(true,false)) {
+					tune_high = FRSKY_RX_finetune;
+					FRSKY_RX_finetune = (tune_low + tune_high) / 2;
+					CC2500_WriteReg(CC2500_0C_FSCTRL0, (int8_t)FRSKY_RX_finetune);
+					if(tune_low < tune_high)
+					{
+						phase = FRSKY_RX_BIND;
+						debugln("FRSKY_RX_TUNE_HIGH");
+					}
+					else
+					{
+						phase = FRSKY_RX_TUNE_START;
+						debugln("FRSKY_RX_TUNE_START");
+					}
+					FRSKY_RX_strobe_rx();
+					return 1000;
+				}
+			}
+			FRSKY_RX_finetune -= 1;
+			CC2500_WriteReg(CC2500_0C_FSCTRL0, FRSKY_RX_finetune);
+			FRSKY_RX_strobe_rx();
+			return 18000;
+
+		case FRSKY_RX_BIND:
+			if (len == packet_length + 2) //+2=RSSI+LQI+CRC
+			{
+				CC2500_ReadData(packet, len);
+				if(frskyx_rx_check_crc_id(true,false)) {
+					if(FRSKY_RX_format != FRSKY_RX_D16v2LBT && FRSKY_RX_format != FRSKY_RX_D16v2FCC)
+					{// D8 & D16v1
+						if(packet[5] <= 0x2D)
+						{
+							for (ch = 0; ch < 5; ch++)
+								hopping_frequency[packet[5]+ch] = packet[6+ch];
+							state |= 1 << (packet[5] / 5);
+						}
+					}
+					else
+						state = 0x3FF; //No hop table for D16v2
+					if (state == 0x3FF)
+					{
+						debugln("Bind complete");
+						BIND_DONE;
+						// store format, finetune setting, txid, channel list
+						uint16_t temp = FRSKY_RX_EEPROM_OFFSET;
+						if(sub_protocol==FRSKY_CLONE)
+						{
+							if(FRSKY_RX_format==FRSKY_RX_D8)
+								temp=FRSKYD_CLONE_EEPROM_OFFSET;
+							else if(FRSKY_RX_format == FRSKY_RX_D16FCC || FRSKY_RX_format == FRSKY_RX_D16LBT)
+								temp=FRSKYX_CLONE_EEPROM_OFFSET;
+							else
+								temp=FRSKYX2_CLONE_EEPROM_OFFSET;
+						}
+						eeprom_write_byte((EE_ADDR)temp++, FRSKY_RX_format);
+						eeprom_write_byte((EE_ADDR)temp++, rx_tx_addr[3]);
+						eeprom_write_byte((EE_ADDR)temp++, rx_tx_addr[2]);
+						eeprom_write_byte((EE_ADDR)temp++, rx_tx_addr[1]);
+						if(sub_protocol == FRSKY_RX || sub_protocol == FRSKY_CPPM)	// FRSKY_RX, FRSKY_CPPM
+							eeprom_write_byte((EE_ADDR)temp++, FRSKY_RX_finetune);
+						if(FRSKY_RX_format != FRSKY_RX_D16v2FCC && FRSKY_RX_format != FRSKY_RX_D16v2LBT)
+							for (ch = 0; ch < 47; ch++)
+								eeprom_write_byte((EE_ADDR)temp++, hopping_frequency[ch]);
+						FRSKY_RX_data();
+						debugln("FRSKY_RX_DATA");
+					}
+				}
+				FRSKY_RX_strobe_rx();
+			}
+			return 1000;
+
+		case FRSKY_RX_DATA:
+			if (len == packet_length + 2) //+2=RSSI+LQI+CRC
+			{
+				CC2500_ReadData(packet, len);
+				if(frskyx_rx_check_crc_id(false,false))
+				{
+					RX_RSSI = packet[len-2];
+					if(RX_RSSI >= 128)
+						RX_RSSI -= 128;
+					else
+						RX_RSSI += 128;
+					bool chanskip_valid=true;
+					// hop to next channel
+					if (FRSKY_RX_format != FRSKY_RX_D8)
+					{//D16v1 & D16v2
+						if(rx_data_started)
+						{
+							if(FRSKY_RX_chanskip != (((packet[4] & 0xC0) >> 6) | ((packet[5] & 0x3F) << 2)))
+							{
+								chanskip_valid=false;	// chanskip value has changed which surely indicates a bad frame
+								packet_count++;
+								if(packet_count>5)		// the TX must have changed chanskip...
+									FRSKY_RX_chanskip = ((packet[4] & 0xC0) >> 6) | ((packet[5] & 0x3F) << 2);	// chanskip init
+							}
+							else
+								packet_count=0;
+						}
+						else
+							FRSKY_RX_chanskip = ((packet[4] & 0xC0) >> 6) | ((packet[5] & 0x3F) << 2);	// chanskip init
+					}
+					hopping_frequency_no = (hopping_frequency_no + FRSKY_RX_chanskip) % 47;
+					FRSKY_RX_set_channel(hopping_frequency_no);
+					if(chanskip_valid)
+					{
+						if ((telemetry_link & 0x7F) == 0)
+						{ // send channels to TX
+							FRSKY_RX_build_telemetry_packet();
+							telemetry_link = 1;
+							#ifdef SEND_CPPM
+								if(sub_protocol == FRSKY_CPPM)
+									telemetry_link |= 0x80;		// Disable telemetry output
+							#endif
+						}
+						pps_counter++;
+					}
+					rx_data_started = true;
+					read_retry = 0;
+				}
+			}
+			
+			// packets per second
+			if (millis() - pps_timer >= 1000) {
+				pps_timer = millis();
+				debugln("%d pps", pps_counter);
+				RX_LQI = pps_counter;
+				if(pps_counter==0)	// no packets for 1 sec or more...
+				{// restart the search
+					rx_data_started=false;
+					packet_count=0;
+				}
+				pps_counter = 0;
+			}
+
+			// skip channel if no packet received in time
+			if (read_retry++ >= 9) {
+				hopping_frequency_no = (hopping_frequency_no + FRSKY_RX_chanskip) % 47;
+				FRSKY_RX_set_channel(hopping_frequency_no);
+				if(rx_data_started)
+					read_retry = 0;
+				else
+					read_retry = -50; // retry longer until first packet is catched
+			}
+			break;
+	}
+	return 1000;
+}
+
+#endif

Multiprotocol/Futaba_cc2500.ino

@@ -14,23 +14,25 @@
  */
 // Last sync with main deviation/sfhss_cc2500.c dated 2016-03-23
 
-#if defined(SFHSS_CC2500_INO)
+#if defined(FUTABA_CC2500_INO)
 
 #include "iface_cc2500.h"
 
+//#define SFHSS_DEBUG_TIMING
+
 #define SFHSS_COARSE	0
 
 #define SFHSS_PACKET_LEN 13
 #define SFHSS_TX_ID_LEN   2
 
-uint8_t	fhss_code; // 0-27
+uint8_t	fhss_code=0; // 0-27
 
 enum {
     SFHSS_START = 0x00,
     SFHSS_CAL   = 0x01,
-    SFHSS_DATA1 = 0x02,	// do not change this value
-    SFHSS_DATA2 = 0x0B,	// do not change this value
-    SFHSS_TUNE  = 0x0F
+    SFHSS_DATA1 = 0x02,
+    SFHSS_DATA2 = 0x03,
+    SFHSS_TUNE  = 0x04
 };
 
 #define SFHSS_FREQ0_VAL 0xC4
@@ -79,7 +81,6 @@ static void __attribute__((unused)) SFHSS_rf_init()
 	for (uint8_t i = 0; i < 39; ++i)
 		CC2500_WriteReg(i, pgm_read_byte_near(&SFHSS_init_values[i]));
 
-	prev_option = option;
 	CC2500_WriteReg(CC2500_0C_FSCTRL0, option);
 	
 	CC2500_SetTxRxMode(TX_EN);
@@ -122,45 +123,96 @@ static void __attribute__((unused)) SFHSS_calc_next_chan()
     }
 }
 
-// Channel values are 10-bit values between 86 and 906, 496 is the middle.
-// Values grow down and to the right, so we just revert every channel.
-static uint16_t __attribute__((unused)) SFHSS_convert_channel(uint8_t num)
+// Channel values are 12-bit values between 1020 and 2020, 1520 is the middle.
+// Futaba @140% is 2070...1520...970
+// Values grow down and to the right.
+static void __attribute__((unused)) SFHSS_send_packet()
 {
-	return (uint16_t) (map(limit_channel_100(num),servo_min_100,servo_max_100,906,86));
+	uint16_t ch[4];
+	// command.bit0 is the packet number indicator: =0 -> SFHSS_DATA1, =1 -> SFHSS_DATA2
+	// command.bit1 is unknown but seems to be linked to the payload[0].bit0 but more dumps are needed: payload[0]=0x82 -> =0, payload[0]=0x81 -> =1
+	// command.bit2 is the failsafe transmission indicator: =0 -> normal data, =1->failsafe data
+	// command.bit3 is the channels indicator: =0 -> CH1-4, =1 -> CH5-8
+	
+	//Coding below matches the Futaba T8J transmission scheme DATA1->CH1-4, DATA2->CH5-8, DATA1->CH5-8, DATA2->CH1-4,...
+	// XK, T10J and TM-FH are different with a classic DATA1->CH1-4, DATA2->CH5-8,...
+	//Failsafe is sent twice every couple of seconds (unknown but >5s) 
+	
+	uint8_t command= (phase == SFHSS_DATA1) ? 0 : 1;	// Building packet for Data1 or Data2
+	counter+=command;
+	#ifdef FAILSAFE_ENABLE
+		if( (counter&0x3FC) == 0x3FC && IS_FAILSAFE_VALUES_on)
+		{	// Transmit failsafe data twice every 7s
+			if( ((counter&1)^(command&1)) == 0 )
+				command|=0x04;							// Failsafe
+		}
+		else
+	#endif
+			command|=0x02;								// Assuming packet[0] == 0x81
+	counter&=0x3FF;										// Reset failsafe counter
+	if(counter&1) command|=0x08;						// Transmit lower and upper channels twice in a row
+
+	uint8_t ch_offset = (command&0x08) >> 1;			// CH1..CH4 or CH5..CH8
+
+	#ifdef FAILSAFE_ENABLE
+		if(command&0x04)
+		{	//Failsafe data are:
+			// 0 to 1023 -> no output on channel
+			// 1024-2047 -> hold output on channel
+			// 2048-4095 -> channel_output=(data&0x3FF)*5/4+880 in µs
+			// Notes:
+			//    2048-2559 -> does not look valid since it only covers the range from 1520µs to 2160µs 
+			//    2560-3583 -> valid for any channel values from 880µs to 2160µs
+			//    3584-4095 -> looks to be used for the throttle channel with values ranging from 880µs to 1520µs
+			for(uint8_t i=0;i<4;i++)
+			{
+				uint16_t val=Failsafe_data[CH_AETR[ch_offset+i]];
+				if(val==FAILSAFE_CHANNEL_HOLD)
+					ch[i]=1024;
+				else if(val==FAILSAFE_CHANNEL_NOPULSES)
+					ch[i]=0;
+				else
+				{ //Use channel value
+					ch[i] = convert_channel_16b_nolimit(CH_AETR[ch_offset+i],3571,2571,true); //3472,2672: not enough throw
+				}
+			}
+		}
+		else
+	#endif
+		{	//Normal data
+			for(uint8_t i=0;i<4;i++)
+				ch[i] = convert_channel_16b_nolimit(CH_AETR[ch_offset+i],2020,1020,false);
 		}
 
-static void __attribute__((unused)) SFHSS_build_data_packet()
-{
-#define spacer1 0x02 //0b10
-#define spacer2 (spacer1 << 4)
-    uint8_t ch_offset = phase == SFHSS_DATA1 ? 0 : 4;
-    uint16_t ch1 = SFHSS_convert_channel(CH_AETR[ch_offset+0]);
-    uint16_t ch2 = SFHSS_convert_channel(CH_AETR[ch_offset+1]);
-    uint16_t ch3 = SFHSS_convert_channel(CH_AETR[ch_offset+2]);
-    uint16_t ch4 = SFHSS_convert_channel(CH_AETR[ch_offset+3]);
 	
+	// XK		[0]=0x81 [3]=0x00 [4]=0x00
+	// T8J		[0]=0x81 [3]=0x42 [4]=0x07
+	// T10J		[0]=0x81 [3]=0x0F [4]=0x09
+	// TM-FH	[0]=0x82 [3]=0x9A [4]=0x06
 	packet[0] = 0x81;	// can be 80 or 81 for Orange, only 81 for XK
 	packet[1] = rx_tx_addr[0];
 	packet[2] = rx_tx_addr[1];
-    packet[3]  = 0;
-    packet[4]  = 0;
-    packet[5]  = (rf_ch_num << 3) | spacer1 | ((ch1 >> 9) & 0x01);
-    packet[6]  = (ch1 >> 1);
-    packet[7]  = (ch1 << 7) | spacer2 | ((ch2 >> 5) & 0x1F /*0b11111*/);
-    packet[8]  = (ch2 << 3) | spacer1  | ((ch3 >> 9) & 0x01);
-    packet[9]  = (ch3 >> 1);
-    packet[10] = (ch3 << 7) | spacer2  | ((ch4 >> 5) & 0x1F /*0b11111*/);
-    packet[11] = (ch4 << 3) | ((fhss_code >> 2) & 0x07 /*0b111 */);
-    packet[12] = (fhss_code << 6) | phase;
-}
+	packet[3] = 0x00;	// unknown but prevents some receivers to bind if not 0
+	packet[4] = 0x00;	// unknown but prevents some receivers to bind if not 0
+	packet[5] = (rf_ch_num << 3) | ((ch[0] >> 9) & 0x07);
+	packet[6] = (ch[0] >> 1);
+	packet[7] = (ch[0] << 7) | ((ch[1] >> 5) & 0x7F );
+	packet[8] = (ch[1] << 3) | ((ch[2] >> 9) & 0x07 );
+	packet[9] = (ch[2] >> 1);
+	packet[10] = (ch[2] << 7) | ((ch[3] >> 5) & 0x7F );
+	packet[11] = (ch[3] << 3) | ((fhss_code >> 2) & 0x07 );
+	packet[12] = (fhss_code << 6) | command;
 
-static void __attribute__((unused)) SFHSS_send_packet()
-{
     CC2500_WriteData(packet, SFHSS_PACKET_LEN);
 }
 
-uint16_t ReadSFHSS()
+uint16_t SFHSS_callback()
 {
+#ifdef SFHSS_DEBUG_TIMING
+	static uint16_t prev_adjust_timing=1024;
+	uint16_t adjust_timing = (Channel_data[CH15]>>3) - (1024>>3);	// +-102 @ 100%
+#endif
+
 	switch(phase)
 	{
 		case SFHSS_START:
@@ -175,28 +227,45 @@ uint16_t ReadSFHSS()
 			else
 			{
 				rf_ch_num = 0;
+				counter = 0;
 				phase = SFHSS_DATA1;
 			}
 			return 2000;
 
-		/* Work cycle, 6.8ms, second packet 1.65ms after first */
+		/* Work cycle: 6.8ms */
+#define SFHSS_PACKET_PERIOD	6800
+#define SFHSS_DATA2_TIMING	1625	// Adjust this value between 1600 and 1650 if your RX(s) are not operating properly
 		case SFHSS_DATA1:
-			SFHSS_build_data_packet();
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(6800);
+			#endif
 			SFHSS_send_packet();
 			phase = SFHSS_DATA2;
-			return 1650;
+#ifdef SFHSS_DEBUG_TIMING
+			return SFHSS_DATA2_TIMING - adjust_timing;
+#else
+			return SFHSS_DATA2_TIMING;								// original 1650
+#endif
 		case SFHSS_DATA2:
-			SFHSS_build_data_packet();
 			SFHSS_send_packet();
 			SFHSS_calc_next_chan();
 			phase = SFHSS_TUNE;
-			return 2000;
+#ifdef SFHSS_DEBUG_TIMING
+			if(prev_adjust_timing != adjust_timing)
+			{
+				debugln("A:%d",(uint16_t)(SFHSS_DATA2_TIMING - adjust_timing));
+				prev_adjust_timing = adjust_timing;
+			}
+			return SFHSS_PACKET_PERIOD -2000 -(SFHSS_DATA2_TIMING - adjust_timing);
+#else
+			return SFHSS_PACKET_PERIOD -2000 -SFHSS_DATA2_TIMING;	// original 2000
+#endif
 		case SFHSS_TUNE:
 			phase = SFHSS_DATA1;
 			SFHSS_tune_freq();
 			SFHSS_tune_chan_fast();
 			CC2500_SetPower();
-			return 3150;
+			return 2000;											// original 3150
 	}
 	return 0;
 }
@@ -204,9 +273,9 @@ uint16_t ReadSFHSS()
 // Generate internal id
 static void __attribute__((unused)) SFHSS_get_tx_id()
 {
-	uint32_t fixed_id;
 	// Some receivers (Orange) behaves better if they tuned to id that has
 	//  no more than 6 consecutive zeros and ones
+	uint32_t fixed_id;
 	uint8_t run_count = 0;
 	// add guard for bit count
 	fixed_id = 1 ^ (MProtocol_id & 1);
@@ -228,20 +297,18 @@ static void __attribute__((unused)) SFHSS_get_tx_id()
 	}
 	//    fixed_id = 0xBC11;
 	rx_tx_addr[0] = fixed_id >> 8;
-	rx_tx_addr[1] = fixed_id;
+	rx_tx_addr[1] = fixed_id >> 0;
 }
 
-uint16_t initSFHSS()
+void SFHSS_init()
 {
 	BIND_DONE;	// Not a TX bind protocol
 	SFHSS_get_tx_id();
 
-	fhss_code=rx_tx_addr[2]%28; // Initialize it to random 0-27 inclusive
+	fhss_code=random(0xfefefefe)%28; // Initialize it to random 0-27 inclusive
 
 	SFHSS_rf_init();
 	phase = SFHSS_START;
-
-	return 10000;
 }
 
 #endif

Multiprotocol/GD00X_ccnrf.ino

@@ -0,0 +1,231 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// Compatible with GD005 C-17 and GD006 DA62 planes.
+
+#if defined(GD00X_CCNRF_INO)
+
+#include "iface_xn297.h"
+
+//#define FORCE_GD00X_ORIGINAL_ID
+
+#define GD00X_INITIAL_WAIT    500
+#define GD00X_PACKET_PERIOD   3500
+#define GD00X_RF_BIND_CHANNEL 2
+#define GD00X_RF_NUM_CHANNELS 4
+#define GD00X_PAYLOAD_SIZE    15
+#define GD00X_BIND_COUNT	  857	//3sec
+
+#define GD00X_V2_BIND_PACKET_PERIOD	5110
+#define GD00X_V2_RF_BIND_CHANNEL	0x43
+#define GD00X_V2_RF_NUM_CHANNELS	2
+#define GD00X_V2_PAYLOAD_SIZE		6
+
+// flags going to packet[11]
+#define	GD00X_FLAG_DR		0x08
+#define	GD00X_FLAG_LIGHT	0x04
+
+// flags going to packet[4]
+#define	GD00X_V2_FLAG_DR	0x40
+#define	GD00X_V2_FLAG_LIGHT	0x80
+
+static void __attribute__((unused)) GD00X_send_packet()
+{
+	static uint8_t prev_CH6=false;
+
+	if(sub_protocol==GD_V1)
+	{
+		packet[0] = IS_BIND_IN_PROGRESS?0xAA:0x55;
+		memcpy(packet+1,rx_tx_addr,4);
+		uint16_t channel=convert_channel_ppm(AILERON);
+		packet[5 ] = channel;
+		packet[6 ] = channel>>8;
+		channel=convert_channel_ppm(THROTTLE);
+		packet[7 ] = channel;
+		packet[8 ] = channel>>8;
+		channel=convert_channel_ppm(CH5);		// TRIM
+		packet[9 ] = channel;
+		packet[10] = channel>>8;
+		packet[11] = GET_FLAG(!CH7_SW, GD00X_FLAG_DR)
+				   | GET_FLAG(CH6_SW, GD00X_FLAG_LIGHT);
+		packet[12] = 0x00;
+		packet[13] = 0x00;
+		packet[14] = 0x00;
+	}
+	else
+	{//GD_V2
+		if(IS_BIND_IN_PROGRESS)
+			for(uint8_t i=0; i<5;i++)
+				packet[i]=rx_tx_addr[i];
+		else
+		{
+			packet[0]=convert_channel_16b_limit(THROTTLE,0,100);	// 0..100
+
+			// Deadband is needed on aileron, 40 gives +-6%
+			packet[1]=convert_channel_8b_limit_deadband(AILERON,0x3F,0x20,0x00,40);	// Aileron: 3F..20..00
+			// Trims must be in a seperate channel for this model
+			packet[2]=0x3F-(convert_channel_8b(CH5)>>2);			// Trim: 0x3F..0x20..0x00
+
+			uint8_t seq=((packet_count*3)/7)%5;
+			packet[4]=seq
+					| GET_FLAG(!CH7_SW, GD00X_V2_FLAG_DR);
+
+			if(CH6_SW!=prev_CH6)
+			{ // LED switch is temporary
+				len=43;
+				prev_CH6=CH6_SW;
+			}
+			if(len)
+			{ // Send the light flag for a couple of packets
+				packet[4] |= GD00X_V2_FLAG_LIGHT;
+				len--;
+			}
+
+			packet[3]=(packet[0]+packet[1]+packet[2]+packet[4])^(crc8);
+
+			if( (packet_count%12) == 0 )
+				hopping_frequency_no ^= 1;			// Toggle between the 2 frequencies
+			packet_count++;
+			if(packet_count>34) packet_count=0;		// Full period
+			if( seq == (((packet_count*3)/7)%5) )
+			{
+				if(packet_period==2700)
+					packet_period=3000;
+				else
+					packet_period=2700;
+			}
+			else
+				packet_period=4300;
+		}
+		packet[5]='D';
+	}
+
+	if(IS_BIND_DONE)
+	{
+		XN297_Hopping(hopping_frequency_no);
+		if(sub_protocol==GD_V1)
+		{
+			hopping_frequency_no++;
+			hopping_frequency_no &= GD00X_RF_NUM_CHANNELS-1;	// 4 RF channels
+		}
+	}
+
+	// Send
+	XN297_SetFreqOffset();
+	XN297_SetPower();
+	XN297_SetTxRxMode(TX_EN);
+	XN297_WritePayload(packet, packet_length);
+}
+
+static void __attribute__((unused)) GD00X_RF_init()
+{
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_250K);
+	if(sub_protocol==GD_V1)
+		XN297_SetTXAddr((uint8_t*)"\xcc\xcc\xcc\xcc\xcc", 5);
+	else
+		XN297_SetTXAddr((uint8_t*)"GDKNx", 5);
+	XN297_HoppingCalib(sub_protocol==GD_V1?GD00X_RF_NUM_CHANNELS:GD00X_V2_RF_NUM_CHANNELS);	// Calibrate all channels
+	XN297_RFChannel(sub_protocol==GD_V1?GD00X_RF_BIND_CHANNEL:GD00X_V2_RF_BIND_CHANNEL);		// Set bind channel
+}
+
+static void __attribute__((unused)) GD00X_initialize_txid()
+{
+	if(sub_protocol==GD_V1)
+	{
+		uint8_t start=76+(rx_tx_addr[0]&0x03);
+		for(uint8_t i=0; i<GD00X_RF_NUM_CHANNELS;i++)
+			hopping_frequency[i]=start-(i<<1);
+		#ifdef FORCE_GD00X_ORIGINAL_ID
+			rx_tx_addr[0]=0x1F;					// or 0xA5 or 0x26
+			rx_tx_addr[1]=0x39;					// or 0x37 or 0x35
+			rx_tx_addr[2]=0x12;					// Constant on 3 TXs
+			rx_tx_addr[3]=0x13;					// Constant on 3 TXs
+			for(uint8_t i=0; i<GD00X_RF_NUM_CHANNELS;i++)
+				hopping_frequency[i]=79-(i<<1);	// or 77 or 78
+		#endif
+	}
+	else
+	{
+		//Generate 64 different IDs
+		rx_tx_addr[1]=0x00;
+		rx_tx_addr[2]=0x00;
+		rx_tx_addr[1+((rx_tx_addr[3]&0x10)>>4)]=rx_tx_addr[3]&0x8F;
+		rx_tx_addr[0]=0x65;
+		rx_tx_addr[3]=0x95;
+		rx_tx_addr[4]=0x47;	//'G'
+
+		crc8=rx_tx_addr[0]^rx_tx_addr[1]^rx_tx_addr[2];
+		//hopping calculation
+		hopping_frequency[0]=(0x15+(crc8^rx_tx_addr[3]))&0x1F;
+		if( hopping_frequency[0] == 0x0F )
+			hopping_frequency[0]=0x0E;
+		else if( (hopping_frequency[0]&0xFE) == 0x10 )
+			hopping_frequency[0]+=2;
+		hopping_frequency[1]=0x20+hopping_frequency[0];
+
+		#ifdef FORCE_GD00X_ORIGINAL_ID
+			//ID 1
+			rx_tx_addr[0]=0x65;
+			rx_tx_addr[1]=0x00;
+			rx_tx_addr[2]=0x00;
+			rx_tx_addr[3]=0x95;
+			rx_tx_addr[4]=0x47;	//'G'
+			hopping_frequency[0]=0x05;
+			hopping_frequency[1]=0x25;
+			//ID 2
+			rx_tx_addr[0]=0xFD;
+			rx_tx_addr[1]=0x09;
+			rx_tx_addr[2]=0x00;
+			rx_tx_addr[3]=0x65;
+			rx_tx_addr[4]=0x47;	//'G'
+			hopping_frequency[0]=0x06;
+			hopping_frequency[1]=0x26;
+			//ID 3
+			rx_tx_addr[0]=0x67;
+			rx_tx_addr[1]=0x0F;
+			rx_tx_addr[2]=0x00;
+			rx_tx_addr[3]=0x69;
+			rx_tx_addr[4]=0x47;	//'G'
+			hopping_frequency[0]=0x16;
+			hopping_frequency[1]=0x36;
+		#endif
+	}
+}
+
+uint16_t GD00X_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(packet_period);
+	#endif
+	if(bind_counter)
+		if(--bind_counter==0)
+			BIND_DONE;
+	GD00X_send_packet();
+	return packet_period;
+}
+
+void GD00X_init()
+{
+	BIND_IN_PROGRESS;	// autobind protocol
+	GD00X_initialize_txid();
+	GD00X_RF_init();
+	hopping_frequency_no = 0;
+	bind_counter=GD00X_BIND_COUNT;
+	packet_period=sub_protocol==GD_V1?GD00X_PACKET_PERIOD:GD00X_V2_BIND_PACKET_PERIOD;
+	packet_length=sub_protocol==GD_V1?GD00X_PAYLOAD_SIZE:GD00X_V2_PAYLOAD_SIZE;
+	packet_count=0;
+	len=0;
+}
+
+#endif

Multiprotocol/GW008_nrf24l01.ino

@@ -0,0 +1,142 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// Compatible with Global Drone GW008 protocol.
+// There are 3 versions of this small quad, this protocol is for the one with a XNS104 IC in the stock Tx and PAN159CY IC in the quad (SOCs with built-in xn297 compatible RF).
+// The xn297 version is compatible with the CX10 protocol (green pcb).
+// The LT8910 version is not supported yet.
+
+#if defined(GW008_NRF24L01_INO)
+
+#include "iface_xn297.h"
+
+#define GW008_INITIAL_WAIT    500
+#define GW008_PACKET_PERIOD   2400
+#define GW008_RF_BIND_CHANNEL 2
+#define GW008_PAYLOAD_SIZE    15
+
+enum {
+	GW008_BIND1,
+	GW008_BIND2,
+	GW008_DATA
+};
+
+static void __attribute__((unused)) GW008_send_packet()
+{
+	packet[0] = rx_tx_addr[0];
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[1] = 0x55;
+		packet[2] = hopping_frequency[0];
+		packet[3] = hopping_frequency[1];
+		packet[4] = hopping_frequency[2];
+		packet[5] = hopping_frequency[3];
+		memset(&packet[6], 0, 7);
+		packet[13] = 0xaa;
+	}
+	else
+	{
+		XN297_Hopping((hopping_frequency_no++)/2);
+		hopping_frequency_no %= 8;
+
+		packet[1] = 0x01 | GET_FLAG(CH5_SW, 0x40); // flip
+		packet[2] = convert_channel_16b_limit(AILERON , 200, 0); // aileron
+		packet[3] = convert_channel_16b_limit(ELEVATOR, 0, 200); // elevator
+		packet[4] = convert_channel_16b_limit(RUDDER  , 200, 0); // rudder
+		packet[5] = convert_channel_16b_limit(THROTTLE, 0, 200); // throttle
+		packet[6] = 0xaa;
+		packet[7] = 0x02; // max rate
+		packet[8] = 0x00;
+		packet[9] = 0x00;
+		packet[10]= 0x00;
+		packet[11]= 0x00;
+		packet[12]= 0x00;
+		packet[13]= rx_tx_addr[2];
+	}
+	packet[14] = rx_tx_addr[1];
+
+	// Send
+	XN297_SetPower();
+	XN297_SetTxRxMode(TX_EN);
+	XN297_WriteEnhancedPayload(packet, GW008_PAYLOAD_SIZE, 0);
+}
+
+static void __attribute__((unused)) GW008_RF_init()
+{
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
+	
+	XN297_SetTXAddr((uint8_t*)"\xcc\xcc\xcc\xcc\xcc", 5);
+	XN297_SetRXAddr((uint8_t*)"\xcc\xcc\xcc\xcc\xcc", GW008_PAYLOAD_SIZE);
+
+	//XN297_HoppingCalib(8);
+	XN297_RFChannel(GW008_RF_BIND_CHANNEL);
+}
+
+static void __attribute__((unused)) GW008_initialize_txid()
+{
+	uint32_t lfsr = random(0xfefefefe) + ((uint32_t)random(0xfefefefe) << 16);
+    for(uint8_t i=0; i<4; i++)
+        hopping_frequency[i] = 0x10 + ((lfsr >> (i*8)) % 0x37);
+}
+
+uint16_t GW008_callback()
+{
+	switch(phase)
+	{
+		case GW008_BIND1:
+			if(XN297_IsRX() &&	// RX fifo data ready
+				XN297_ReadEnhancedPayload(packet, GW008_PAYLOAD_SIZE) == GW008_PAYLOAD_SIZE &&	// check payload size
+				packet[0] == rx_tx_addr[0] && packet[14] == rx_tx_addr[1])			// check tx id
+			{
+				XN297_SetTxRxMode(TXRX_OFF);
+				XN297_SetTxRxMode(TX_EN);
+				rx_tx_addr[2] = packet[13];
+				BIND_DONE;
+				phase = GW008_DATA;
+			}
+			else
+			{
+				XN297_SetTxRxMode(TXRX_OFF);
+				XN297_SetTxRxMode(TX_EN);
+				GW008_send_packet();
+				phase = GW008_BIND2;
+				return 850; // minimum value 750 for STM32
+			}
+			break;
+		case GW008_BIND2:
+			// switch to RX mode
+			XN297_SetTxRxMode(TXRX_OFF);
+			XN297_SetTxRxMode(RX_EN);
+			phase = GW008_BIND1;
+			return 5000;
+		case GW008_DATA:
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(GW008_PACKET_PERIOD);
+			#endif
+			GW008_send_packet();
+			break;
+	}
+	return GW008_PACKET_PERIOD;
+}
+
+void GW008_init()
+{
+	BIND_IN_PROGRESS;	// autobind protocol
+	GW008_initialize_txid();
+	phase = GW008_BIND1;
+	GW008_RF_init();
+	hopping_frequency_no = 0;
+}
+
+#endif

Multiprotocol/H8_3D_nrf24l01.ino

@@ -0,0 +1,244 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// compatible with EAchine 3D X4, CG023/CG031, Attop YD-822/YD-829/YD-829C and H8_3D/JJRC H20/H22
+// Merged CG023 and H8_3D protocols
+// Last sync with hexfet new_protocols/cg023_nrf24l01.c dated 2015-10-03
+// Last sync with hexfet new_protocols/h8_3d_nrf24l01.c dated 2015-11-18
+
+#if defined(H8_3D_NRF24L01_INO)
+
+#include "iface_xn297.h"
+
+#define H8_3D_PACKET_PERIOD		1800
+#define H20H_PACKET_PERIOD		9340
+#define H20MINI_PACKET_PERIOD	3100
+#define H8_3D_INITIAL_WAIT		500
+#define H8_3D_PACKET_SIZE		20
+#define H8_3D_RF_NUM_CHANNELS	4
+#define H20H_BIND_RF			0x49
+#define H8_3D_BIND_COUNT		1000
+
+enum H8_3D_FLAGS {
+    // flags going to packet[17]
+    H8_3D_FLAG_FLIP      = 0x01,
+    H8_3D_FLAG_RATE_MID  = 0x02,
+    H8_3D_FLAG_RATE_HIGH = 0x04,
+    H8_3D_FLAG_LIGTH	 = 0x08, // Light on H22
+    H8_3D_FLAG_HEADLESS  = 0x10, // RTH + headless on H8, headless on JJRC H20, RTH on H22
+    H8_3D_FLAG_RTH		 = 0x20, // 360 flip mode on H8 3D and H22, RTH on JJRC H20
+};
+
+enum H8_3D_FLAGS_2 {
+    // flags going to packet[18]
+    H8_3D_FLAG_VIDEO      = 0x80,
+    H8_3D_FLAG_PICTURE    = 0x40,
+    H8_3D_FLAG_CALIBRATE1 = 0x20,  // H8 3D acc calibration, H20,H20H headless calib
+    H8_3D_FLAG_CALIBRATE2 = 0x10,  // H11D, H20, H20H acc calibration
+    H8_3D_FLAG_CAM_DN     = 0x08,
+    H8_3D_FLAG_CAM_UP     = 0x04,
+};
+
+static void __attribute__((unused)) H8_3D_send_packet()
+{
+	if(sub_protocol==H20H)
+		packet[0] = 0x14;
+	else // H8_3D, H20MINI, H30MINI
+		packet[0] = 0x13;
+
+	packet[1] = rx_tx_addr[0]; 
+	packet[2] = rx_tx_addr[1];
+	packet[3] = rx_tx_addr[2];
+	packet[4] = rx_tx_addr[3];
+	packet[8] = rx_tx_addr[0]+rx_tx_addr[1]+rx_tx_addr[2]+rx_tx_addr[3]; // txid checksum
+	memset(&packet[9], 0, 10);
+	if (IS_BIND_IN_PROGRESS)
+	{    
+		packet[5] = 0x00;
+		packet[6] = 0x00;
+		packet[7] = 0x01;
+	}
+	else
+	{
+		packet[5] = hopping_frequency_no;
+		packet[7] = 0x03;
+
+		rudder = convert_channel_16b_limit(RUDDER,0x44,0xBC);			// yaw right : 0x80 (neutral) - 0xBC (right)
+		if(sub_protocol!=H20H)
+		{ // H8_3D, H20MINI, H30MINI
+			packet[6] = 0x08;
+			packet[9] = convert_channel_8b(THROTTLE);					// throttle  : 0x00 - 0xFF
+			packet[15] = 0x20;	// trims
+			packet[16] = 0x20;	// trims
+			if (rudder<=0x80)
+				rudder=0x80-rudder;										// yaw left  : 0x00 (neutral) - 0x3C (left)
+			if(rudder==0x01 || rudder==0x81)
+				rudder=0x00;	// Small deadband
+		}
+		else
+		{ //H20H
+			packet[6] = hopping_frequency_no == 0 ? 8 - packet_count : 16 - packet_count;
+			packet[9] = convert_channel_16b_limit(THROTTLE, 0x43, 0xBB);	// throttle : 0x43 - 0x7F - 0xBB
+			packet[15]= 0x40;	// trims
+			packet[16]= 0x40;	// trims
+			rudder--;													// rudder : 0x43 - 0x7F - 0xBB
+			if (rudder>=0x7F-1 && rudder<=0x7F+1)
+				rudder=0x7F;	// Small deadband
+		}
+		packet[10] = rudder;
+		packet[11] = convert_channel_16b_limit(ELEVATOR, 0x43, 0xBB);	// elevator : 0x43 - 0x7F - 0xBB
+		packet[12] = convert_channel_16b_limit(AILERON,  0x43, 0xBB);	// aileron  : 0x43 - 0x7F - 0xBB
+		// neutral trims
+		packet[13] = 0x20;
+		packet[14] = 0x20;
+		// flags
+		packet[17] = 					  H8_3D_FLAG_RATE_HIGH
+					| GET_FLAG(CH5_SW,H8_3D_FLAG_FLIP)
+					| GET_FLAG(CH6_SW,H8_3D_FLAG_LIGTH) //H22 light
+					| GET_FLAG(CH9_SW,H8_3D_FLAG_HEADLESS)
+					| GET_FLAG(CH10_SW,H8_3D_FLAG_RTH); // 180/360 flip mode on H8 3D
+		packet[18] =  GET_FLAG(CH7_SW,H8_3D_FLAG_PICTURE)
+					| GET_FLAG(CH8_SW,H8_3D_FLAG_VIDEO)
+					| GET_FLAG(CH11_SW,H8_3D_FLAG_CALIBRATE1)
+					| GET_FLAG(CH12_SW,H8_3D_FLAG_CALIBRATE2);
+		if(Channel_data[CH13]<CHANNEL_MIN_COMMAND)
+			packet[18] |= H8_3D_FLAG_CAM_DN;
+		if(CH13_SW)
+			packet[18] |= H8_3D_FLAG_CAM_UP;
+	}
+	uint8_t  sum = packet[9];
+	for (uint8_t i=10; i < H8_3D_PACKET_SIZE-1; i++)
+		sum += packet[i];
+	packet[19] = sum; // data checksum
+	
+	// RF channel
+	if(sub_protocol!=H20H)
+	{ // H8_3D, H20MINI, H30MINI
+		XN297_RFChannel(IS_BIND_IN_PROGRESS ? hopping_frequency[0] : hopping_frequency[hopping_frequency_no++]);
+		hopping_frequency_no %= H8_3D_RF_NUM_CHANNELS;
+	}
+	else
+	{ // H20H
+		XN297_RFChannel(IS_BIND_IN_PROGRESS ? H20H_BIND_RF : hopping_frequency[packet_count>>3]);  
+		if(IS_BIND_DONE)
+		{
+			packet_count++;
+			if(packet_count>15)
+			{
+				packet_count = 0;
+				hopping_frequency_no = 0;
+			}
+			else
+				if(packet_count > 7)
+					hopping_frequency_no = 1;
+		}
+	}
+	
+	// Send
+	XN297_SetPower();
+	XN297_SetTxRxMode(TX_EN);
+	XN297_WritePayload(packet, H8_3D_PACKET_SIZE);
+}
+
+static void __attribute__((unused)) H8_3D_RF_init()
+{
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
+
+	if(sub_protocol==H20H)
+		XN297_SetTXAddr((uint8_t *)"\xEE\xDD\xCC\xBB\x11", 5);
+	else // H8_3D, H20MINI, H30MINI
+		XN297_SetTXAddr((uint8_t *)"\xC4\x57\x09\x65\x21", 5);
+}
+
+uint16_t H8_3D_callback()
+{
+	if(bind_counter)
+	{
+		bind_counter--;
+		if (bind_counter == 0)
+		{
+			BIND_DONE;
+			packet_count=0;
+		}
+	}
+	#ifdef MULTI_SYNC
+	else
+		telemetry_set_input_sync(packet_period);
+	#endif
+
+	H8_3D_send_packet();
+	return	packet_period;
+}
+
+// captured from H20H stock transmitters
+const uint8_t PROGMEM h20h_tx_rf_map[3][6] = {{/*ID*/0x83, 0x3c, 0x60, 0x00, /*RF*/0x47, 0x3e},
+											  {/*ID*/0x5c, 0x2b, 0x60, 0x00, /*RF*/0x4a, 0x3c},
+											  {/*ID*/0x57, 0x07, 0x00, 0x00, /*RF*/0x41, 0x48} };
+// captured from H20 Mini / H30 Mini stock transmitters
+const uint8_t PROGMEM h20mini_tx_rf_map[4][8] =  {{/*ID*/0xb4, 0xbb, 0x09, 0x00, /*RF*/0x3e, 0x45, 0x47, 0x4a},
+												  {/*ID*/0x94, 0x9d, 0x0b, 0x00, /*RF*/0x3e, 0x43, 0x49, 0x4a},
+												  {/*ID*/0xd1, 0xd0, 0x00, 0x00, /*RF*/0x3f, 0x42, 0x46, 0x4a},
+												  {/*ID*/0xcb, 0xcd, 0x04, 0x00, /*RF*/0x41, 0x43, 0x46, 0x4a}};
+static void __attribute__((unused)) H8_3D_initialize_txid()
+{
+	uint8_t id_num=rx_tx_addr[4];
+	switch(sub_protocol)
+	{
+		case H8_3D:
+            for(uint8_t i=0; i<4; i++)
+                hopping_frequency[i] = 6 + (0x0f*i) + (((rx_tx_addr[i] >> 4) + (rx_tx_addr[i] & 0x0f)) % 0x0f);
+			break;
+		case H20H:
+            id_num%=3; // 3 different IDs
+			for(uint8_t i=0; i<4; i++)
+			{
+				rx_tx_addr[i] = pgm_read_byte_near(&h20h_tx_rf_map[id_num][i]);
+				if(i<2)
+					hopping_frequency[i] = pgm_read_byte_near(&h20h_tx_rf_map[id_num][i+4]);
+			}
+			break;
+		case H20MINI:
+		case H30MINI:
+            id_num%=4; // 4 different IDs
+			for(uint8_t i=0; i<4; i++)
+			{
+				rx_tx_addr[i] = pgm_read_byte_near(&h20mini_tx_rf_map[id_num][i]);
+				hopping_frequency[i] = pgm_read_byte_near(&h20mini_tx_rf_map[id_num][i+4]);
+			}
+			break;
+	}
+}
+
+void H8_3D_init(void)
+{
+	BIND_IN_PROGRESS;	// autobind protocol
+    bind_counter = H8_3D_BIND_COUNT;
+	H8_3D_initialize_txid();
+	H8_3D_RF_init();
+	switch(sub_protocol)
+	{
+        case H8_3D:
+			packet_period=H8_3D_PACKET_PERIOD;
+			break;
+		case H20H:
+			packet_period=H20H_PACKET_PERIOD;
+			break;
+		case H20MINI:
+		case H30MINI:
+			packet_period=H20MINI_PACKET_PERIOD;
+			break;
+	}
+}
+
+#endif

Multiprotocol/HOTT_cc2500.ino

@@ -0,0 +1,546 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(HOTT_CC2500_INO)
+
+#include "iface_cc2500.h"
+
+//#define HOTT_FORCE_ID		// Force ID of original dump
+
+#define HOTT_TX_PACKET_LEN	50
+#define HOTT_RX_PACKET_LEN	22
+#define HOTT_PACKET_PERIOD	10000
+#define HOTT_NUM_RF_CHANNELS 75
+#define HOTT_COARSE	0
+
+enum {
+    HOTT_START = 0x00,
+    HOTT_CAL   = 0x01,
+    HOTT_DATA1 = 0x02,
+    HOTT_DATA2 = 0x03,
+    HOTT_RX1   = 0x04,
+    HOTT_RX2   = 0x05,
+};
+
+#ifdef HOTT_FW_TELEMETRY
+	#define HOTT_SENSOR_TYPE 6
+	#define HOTT_SENSOR_SEARCH_PERIOD 2000
+	uint8_t HOTT_sensor_cur=0;
+	uint8_t HOTT_sensor_pages=0;
+	uint8_t HOTT_sensor_valid=false;
+	uint8_t HOTT_sensor_ok[HOTT_SENSOR_TYPE];
+	uint8_t HOTT_sensor_seq=0;
+#endif
+
+#define HOTT_FREQ0_VAL 0x6E
+
+// Some important initialization parameters, all others are either default,
+// or not important in the context of transmitter
+// FIFOTHR  00
+// SYNC1    D3
+// SYNC0    91
+// PKTLEN   32 - Packet length, 50 bytes
+// PKTCTRL1 04 - APPEND_STATUS on=RSSI+LQI, all other are receive parameters - irrelevant
+// PKTCTRL0 44 - whitening, use FIFO, use CRC, fixed packet length
+// ADDR     00
+// CHANNR   10
+// FSCTRL1  09 - IF 
+// FSCTRL0  00 - zero freq offset
+// FREQ2    5C - synthesizer frequencyfor 26MHz crystal
+// FREQ1    6C
+// FREQ0    B9
+// MDMCFG4  2D - 
+// MDMCFG3  3B - 
+// MDMCFG2  73 - disable DC blocking, MSK, no Manchester code, 32 bits sync word
+// MDMCFG1  A3 - FEC enable, 4 preamble bytes, CHANSPC_E - 03
+// MDMCFG0  AA - CHANSPC_M - AA
+// DEVIATN  47 - 
+// MCSM2    07 - 
+// MCSM1    00 - always use CCA, go to IDLE when done
+// MCSM0    08 - disable autocalibration, PO_TIMEOUT - 64, no pin radio control, no forcing XTAL to stay in SLEEP
+// FOCCFG   1D
+const PROGMEM uint8_t HOTT_init_values[] = {
+  /* 00 */ 0x2F, 0x2E, 0x2F, 0x00, 0xD3, 0x91, 0x32, 0x04,
+  /* 08 */ 0x44, 0x00, 0x00, 0x09, 0x00, 0x5C, 0x6C, HOTT_FREQ0_VAL + HOTT_COARSE,
+  /* 10 */ 0x2D, 0x3B, 0x73, 0xA3, 0xAA, 0x47, 0x07, 0x00,
+  /* 18 */ 0x08, 0x1D, 0x1C, 0xC7, 0x09, 0xF0, 0x87, 0x6B,
+  /* 20 */ 0xF0, 0xB6, 0x10, 0xEA, 0x0A, 0x00, 0x11
+};
+
+static void __attribute__((unused)) HOTT_rf_init()
+{
+	CC2500_Strobe(CC2500_SIDLE);
+
+	for (uint8_t i = 0; i < 39; ++i)
+		CC2500_WriteReg(i, pgm_read_byte_near(&HOTT_init_values[i]));
+
+	CC2500_WriteReg(CC2500_0C_FSCTRL0, option);
+	
+	CC2500_SetTxRxMode(TX_EN);
+	CC2500_SetPower();
+}
+
+static void __attribute__((unused)) HOTT_tune_chan()
+{
+	CC2500_Strobe(CC2500_SIDLE);
+	CC2500_WriteReg(CC2500_0A_CHANNR, (rf_ch_num+1)*3);
+	CC2500_Strobe(CC2500_SCAL);
+}
+
+static void __attribute__((unused)) HOTT_tune_chan_fast()
+{
+	CC2500_Strobe(CC2500_SIDLE);
+	CC2500_WriteReg(CC2500_0A_CHANNR, (rf_ch_num+1)*3);
+	CC2500_WriteReg(CC2500_25_FSCAL1, calData[rf_ch_num]);
+}
+
+static void __attribute__((unused)) HOTT_tune_freq()
+{
+	if ( prev_option != option )
+	{
+		CC2500_WriteReg(CC2500_0C_FSCTRL0, option);
+		CC2500_WriteReg(CC2500_0F_FREQ0, HOTT_FREQ0_VAL + HOTT_COARSE);
+		prev_option = option ;
+		phase = HOTT_START;								// Restart the tune process if option is changed to get good tuned values
+	}
+}
+
+const uint8_t PROGMEM HOTT_hop[][HOTT_NUM_RF_CHANNELS]=
+	{	{ 48, 37, 16, 62, 9, 50, 42, 22, 68, 0, 55, 35, 21, 74, 1, 56, 31, 20, 70, 11, 45, 32, 24, 71, 8, 54, 38, 26, 61, 13, 53, 30, 15, 65, 7, 52, 34, 28, 60, 3, 47, 39, 18, 69, 2, 49, 44, 23, 72, 5, 51, 43, 19, 64, 12, 46, 33, 17, 67, 6, 58, 36, 29, 73, 14, 57, 41, 25, 63, 4, 59, 40, 27, 66, 10 },
+		{ 50, 23, 5, 34, 67, 53, 22, 12, 39, 62, 51, 21, 10, 33, 63, 59, 16, 1, 43, 66, 49, 19, 8, 30, 71, 47, 24, 2, 35, 68, 45, 25, 14, 41, 74, 55, 18, 4, 32, 61, 54, 17, 11, 31, 72, 52, 28, 6, 38, 65, 46, 15, 9, 40, 60, 48, 26, 3, 37, 70, 58, 29, 0, 36, 64, 56, 20, 7, 42, 69, 57, 27, 13, 44, 73 },
+		{ 73, 51, 39, 18, 9, 64, 56, 34, 16, 12, 66, 58, 36, 25, 11, 61, 47, 40, 15, 8, 71, 50, 43, 20, 6, 62, 54, 42, 19, 3, 63, 46, 44, 29, 14, 72, 49, 33, 22, 5, 69, 57, 30, 21, 10, 70, 45, 35, 26, 7, 65, 59, 31, 28, 1, 67, 48, 32, 24, 0, 60, 55, 41, 17, 2, 74, 52, 38, 27, 4, 68, 53, 37, 23, 13 },
+		{ 52, 60, 40, 21, 14, 50, 72, 41, 23, 13, 59, 61, 39, 16, 6, 58, 66, 33, 17, 5, 55, 64, 43, 20, 12, 54, 74, 35, 29, 3, 46, 63, 37, 22, 10, 48, 65, 31, 27, 9, 49, 73, 38, 24, 11, 56, 70, 32, 15, 1, 51, 71, 44, 18, 8, 45, 67, 36, 25, 7, 57, 62, 34, 28, 2, 53, 69, 42, 19, 4, 47, 68, 30, 26, 0 },
+		{ 50, 16, 34, 6, 71, 51, 24, 40, 7, 68, 57, 27, 33, 14, 70, 55, 26, 30, 5, 74, 47, 28, 44, 11, 67, 49, 15, 32, 9, 61, 52, 22, 37, 13, 66, 59, 18, 42, 3, 62, 46, 29, 31, 12, 60, 48, 19, 38, 1, 72, 58, 17, 36, 4, 64, 53, 21, 39, 0, 63, 56, 20, 41, 2, 65, 45, 25, 35, 10, 69, 54, 23, 43, 8, 73 },
+		{ 55, 38, 12, 62, 23, 52, 44, 3, 66, 18, 54, 36, 10, 74, 16, 56, 42, 9, 70, 17, 58, 33, 5, 69, 20, 50, 40, 1, 63, 24, 53, 37, 13, 65, 15, 48, 34, 4, 61, 22, 57, 31, 6, 64, 26, 46, 35, 11, 72, 21, 47, 30, 7, 68, 29, 45, 32, 8, 60, 19, 49, 43, 2, 67, 27, 51, 39, 0, 71, 28, 59, 41, 14, 73, 25 },
+		{ 70, 32, 18, 10, 58, 69, 38, 22, 2, 54, 67, 36, 19, 12, 57, 62, 34, 20, 14, 52, 63, 41, 15, 3, 51, 73, 42, 28, 6, 48, 60, 43, 29, 5, 45, 64, 31, 17, 4, 56, 65, 35, 26, 13, 53, 61, 37, 23, 1, 49, 68, 40, 16, 9, 47, 71, 39, 25, 7, 50, 66, 33, 24, 8, 59, 72, 44, 27, 11, 46, 74, 30, 21, 0, 55 },
+		{ 6, 45, 71, 27, 44, 10, 46, 74, 22, 32, 0, 55, 69, 21, 33, 4, 50, 66, 18, 38, 7, 57, 62, 19, 36, 1, 48, 70, 20, 40, 8, 47, 68, 15, 43, 2, 58, 61, 26, 42, 3, 56, 72, 23, 34, 14, 54, 67, 16, 37, 5, 59, 64, 24, 30, 12, 52, 65, 25, 39, 13, 49, 73, 17, 31, 9, 53, 60, 28, 35, 11, 51, 63, 29, 41 },
+		{ 31, 65, 50, 20, 13, 37, 66, 45, 23, 5, 32, 69, 54, 19, 7, 39, 74, 52, 27, 1, 42, 64, 53, 22, 4, 43, 70, 58, 16, 3, 40, 71, 57, 17, 0, 35, 63, 56, 18, 9, 44, 72, 51, 21, 6, 33, 67, 46, 25, 11, 30, 73, 55, 15, 8, 36, 62, 48, 24, 10, 41, 60, 49, 29, 14, 34, 61, 47, 26, 2, 38, 68, 59, 28, 12 },
+		{ 67, 22, 49, 36, 13, 64, 28, 57, 37, 6, 65, 29, 46, 39, 3, 70, 26, 45, 35, 1, 62, 24, 58, 34, 10, 68, 19, 53, 33, 4, 66, 21, 52, 31, 7, 74, 18, 47, 32, 5, 61, 16, 51, 38, 8, 72, 23, 55, 30, 12, 73, 17, 59, 44, 0, 60, 15, 50, 43, 14, 63, 27, 48, 42, 11, 71, 20, 54, 41, 9, 69, 25, 56, 40, 2 },
+		{ 19, 38, 14, 66, 57, 18, 44, 7, 74, 48, 23, 30, 6, 71, 58, 26, 32, 5, 61, 46, 20, 34, 0, 68, 45, 24, 36, 1, 70, 50, 27, 33, 10, 63, 52, 16, 42, 9, 65, 51, 15, 41, 11, 64, 53, 22, 37, 3, 60, 56, 28, 35, 4, 67, 49, 17, 39, 13, 69, 54, 25, 43, 2, 73, 55, 21, 31, 8, 62, 47, 29, 40, 12, 72, 59 },
+		{ 4, 52, 64, 28, 44, 14, 46, 74, 16, 32, 11, 50, 68, 27, 36, 0, 47, 70, 26, 34, 13, 57, 61, 18, 38, 6, 56, 62, 19, 40, 5, 58, 67, 17, 31, 12, 54, 63, 22, 33, 3, 53, 72, 21, 41, 10, 48, 66, 15, 35, 7, 45, 60, 20, 37, 9, 51, 69, 25, 42, 2, 59, 71, 24, 39, 1, 55, 65, 23, 30, 8, 49, 73, 29, 43 },
+		{ 44, 66, 19, 1, 56, 35, 62, 20, 4, 54, 39, 70, 24, 5, 55, 31, 74, 26, 12, 58, 32, 60, 17, 10, 45, 37, 63, 22, 3, 50, 33, 64, 16, 7, 51, 34, 61, 21, 8, 48, 38, 68, 29, 0, 46, 36, 72, 28, 14, 49, 42, 69, 25, 6, 57, 43, 65, 18, 2, 52, 30, 71, 23, 13, 47, 41, 67, 15, 9, 53, 40, 73, 27, 11, 59 },
+		{ 12, 16, 36, 46, 69, 6, 20, 44, 58, 62, 11, 19, 34, 48, 71, 1, 18, 42, 50, 74, 3, 25, 31, 47, 65, 0, 24, 33, 45, 72, 2, 23, 35, 56, 64, 10, 22, 38, 49, 63, 7, 26, 37, 51, 70, 14, 21, 30, 53, 67, 5, 15, 40, 52, 66, 9, 17, 39, 55, 60, 13, 27, 41, 54, 73, 4, 28, 32, 57, 61, 8, 29, 43, 59, 68 },
+		{ 63, 42, 18, 2, 57, 71, 34, 22, 10, 48, 67, 36, 25, 4, 46, 60, 31, 28, 6, 47, 74, 37, 15, 0, 55, 65, 32, 24, 12, 56, 66, 40, 27, 14, 52, 62, 38, 19, 3, 50, 73, 33, 29, 11, 53, 61, 35, 16, 7, 58, 72, 41, 26, 5, 59, 69, 30, 20, 9, 51, 68, 44, 23, 1, 49, 70, 39, 17, 8, 54, 64, 43, 21, 13, 45 },
+		{ 52, 1, 71, 17, 36, 47, 7, 64, 26, 32, 53, 5, 60, 20, 42, 57, 2, 66, 18, 34, 56, 4, 63, 24, 35, 46, 13, 72, 22, 30, 48, 0, 67, 21, 39, 50, 3, 74, 16, 31, 59, 14, 61, 23, 37, 45, 6, 65, 19, 44, 51, 11, 62, 27, 41, 55, 9, 68, 15, 38, 58, 8, 70, 29, 40, 54, 10, 69, 28, 33, 49, 12, 73, 25, 43 }
+		};
+const uint16_t PROGMEM HOTT_hop_val[] = { 0xC06B, 0xC34A, 0xDB24, 0x8E09, 0x272E, 0x217F, 0x155B, 0xEDE8, 0x1D31, 0x0986, 0x56F7, 0x6454, 0xC42D, 0x01D2, 0xC253, 0x1180 };
+
+static void __attribute__((unused)) HOTT_TXID_init()
+{
+	packet[0] = pgm_read_word_near( &HOTT_hop_val[num_ch] );
+	packet[1] = pgm_read_word_near( &HOTT_hop_val[num_ch] )>>8;
+
+	for(uint8_t i=0; i<HOTT_NUM_RF_CHANNELS; i++)
+		hopping_frequency[i]=pgm_read_byte_near( &HOTT_hop[num_ch][i] );
+	#ifdef HOTT_FORCE_ID
+		memcpy(rx_tx_addr,"\x7C\x94\x00\x0D\x50",5);	//TX1
+		memcpy(rx_tx_addr,"\xEA\x4D\x00\x01\x50",5);	//TX2
+	#endif
+	memset(&packet[30],0xFF,9);
+	packet[39]=0x07;									// unknown and constant
+	if(IS_BIND_IN_PROGRESS)
+	{
+		memset(&packet[40],0xFA,5);
+		memcpy(&packet[45],rx_tx_addr,5);
+	}
+	else
+	{
+		memcpy(&packet[40],rx_tx_addr,5);
+		uint16_t addr=HOTT_EEPROM_OFFSET+RX_num*5;
+		debug("RXID: ");
+		for(uint8_t i=0;i<5;i++)
+		{
+			packet[45+i]=eeprom_read_byte((EE_ADDR)(addr+i));
+			debug(" %02X",packet[45+i]);
+		}
+		debugln("");
+	}
+}
+
+static void __attribute__((unused)) HOTT_prep_data_packet() {
+	static uint8_t upper = 0;								// toggles between sending channels 1..8,9..12 and 1..8,13..16
+	
+	packet[2] = hopping_frequency_no;						// send next frequency to be used
+	packet[3] = upper;										// indicate upper or lower channels (only supporting 16 channels)										
+	
+	#ifdef FAILSAFE_ENABLE
+		static uint8_t failsafe_count = 0;					// failsafe packet state machine (need to send two packets)
+
+		if(IS_FAILSAFE_VALUES_on && IS_BIND_DONE) {			// if TX wants to send failsafe data and RX is connected
+			failsafe_count++;								// prepare to send next packet
+
+			if(failsafe_count >= 3) {						// done sending two failsafe channel data packets
+				FAILSAFE_VALUES_off;					
+				failsafe_count = 0;
+			}
+		}
+		else
+			failsafe_count = 0;
+	#endif
+
+	// Channels value are PPM*2, -100%=1100µs, +100%=1900µs, order TAER
+	//
+	// Note: failsafe packets are differnt to normal operation packets
+	// normal operation toggles between sending channels 1..8,9..12 and 1..8,13..16 using bit0 as high/low indicator in packet[3]
+	// while failsafe packets send channels 1..12, 13..24 (and probably 25..32) using bit0 in packet[3] as packet type indicator
+	// packet[3] = 0x40 -> failsafe packet with data for channels 1..12
+	// packet[3] = 0x41 -> failsafe packet with data for channels 13..24
+	//
+	uint16_t val;
+	for(uint8_t i = 0 ; i < 12*2 ; i += 2) {				// working 12 channels (using 2 bytes per channel)
+		uint8_t chIndex = i >> 1 ;							// normal operation channel number
+		uint8_t fschIndex = chIndex;						// linear channel number for failsafe
+		
+		if(upper && chIndex >= 8) chIndex += 4;				// for normal operation toggle between channels 1..8,9..12 and 1..8,13..16
+		val = Channel_data[chIndex];						// get normal operation channel data
+		val = (((val << 2) + val) >> 2)+ 860*2;				// convert channel data 0..2047 to 1720..4278 <-> -125%<->+125%
+															// val = (val*5/4+860*2)
+
+		#ifdef FAILSAFE_ENABLE
+			if(failsafe_count == 1 || failsafe_count == 2) {// failsafe data needs to be sent to RX
+				uint16_t fs = 0x8000;						// default failsafe mode is hold
+
+				if(failsafe_count == 1) {					// send fail safe packet containing channels 1..12
+					packet[3] = 0x40;						// indicate packet has failsafe values for channels 1..12
+					fs = Failsafe_data[fschIndex];			// get failsafe channel data
+				} else {									// send fail safe packet containing channels 13..24
+					packet[3] = 0x41;						// indicate packet has failsafe values for channels 13..24
+					if(fschIndex < 4)						// we only work 16 channels so send channels 13..16, rest default
+						fs = Failsafe_data[fschIndex+12];	// get failsafe channel data 13..16
+				  } 
+
+				if( fs == FAILSAFE_CHANNEL_HOLD ||			// treat HOLD and NOPULSES as channel hold 
+					fs == FAILSAFE_CHANNEL_NOPULSES)
+					val = 0x8000;							// set channel failsafe mode hold flag
+				else {
+					val = (((fs << 2) + fs) >> 2) +860*2; 	// convert channel data 0..2047 to 1720..4278 <-> -125%<->+125%
+					val |= 0x4000;							// set channel failsafe mode position flag					
+				}
+			} 
+		#endif
+
+		packet[i + 4]   = val;								// first channel data at packet[4] and packet[5]
+		packet[i + 4+1] = val >> 8;
+	}
+
+	upper ^= 0x01;											// toggle to upper and lower channels
+
+	packet[28] = 0x80;										// no sensor
+	packet[29] = 0x02;										// 0x02 when bind starts then when RX replies cycle in sequence 0x1A/22/2A/0A/12, 0x02 during normal packets, 0x01->text config menu, 0x0A->no more RX telemetry
+
+	#ifdef HOTT_FW_TELEMETRY
+		if(IS_BIND_DONE)
+		{
+			static uint8_t prev_SerialRX_val=0;
+			if(HoTT_SerialRX)
+			{//Text mode
+				uint8_t sensor=HoTT_SerialRX_val&0xF0;
+				if((sensor&0x80) && sensor!=0xF0 && (HoTT_SerialRX_val&0x0F) >= 0x07)
+				{//Valid Text query
+					if(sensor==0x80) HoTT_SerialRX_val&=0x0F;	// RX only
+					if(prev_SerialRX_val!=HoTT_SerialRX_val)
+					{
+						prev_SerialRX_val=HoTT_SerialRX_val;
+						packet[28] = HoTT_SerialRX_val;			// send the button being pressed only once
+					}
+					else
+						packet[28] = HoTT_SerialRX_val | 0x0F;	// no button pressed
+				}
+				else
+					packet[28] = 0x0F;							// RX, no button pressed
+				if(sub_protocol == HOTT_SYNC)
+					packet[29] = ((HOTT_sensor_seq+1)<<3) | 1;	// Telemetry packet sequence
+				else
+					packet[29] = 0x01;							// 0x01->Text config menu
+			}
+			else
+			{
+				packet[28] = 0x89+HOTT_sensor_cur;				// 0x89/8A/8B/8C/8D/8E during normal packets
+				if(sub_protocol == HOTT_SYNC)
+					packet[29] = ((HOTT_sensor_seq+1)<<3) | 2;	// Telemetry packet sequence
+			}
+			//debugln("28=%02X,29=%02X",packet[28],packet[29]);
+		}
+	#endif
+
+	CC2500_WriteReg(CC2500_06_PKTLEN, HOTT_TX_PACKET_LEN);
+	CC2500_WriteRegisterMulti(CC2500_3F_TXFIFO, packet, HOTT_TX_PACKET_LEN);
+	#if 0
+		debug("RF:%02X P:",rf_ch_num);
+		for(uint8_t i=0;i<HOTT_TX_PACKET_LEN;i++)
+			debug(" %02X",packet[i]);
+		debugln("");
+	#endif
+	hopping_frequency_no++;
+	hopping_frequency_no %= HOTT_NUM_RF_CHANNELS;
+	rf_ch_num=hopping_frequency[hopping_frequency_no];
+}
+
+uint16_t HOTT_callback()
+{
+	switch(phase)
+	{
+		case HOTT_START:
+			rf_ch_num = 0;
+			HOTT_tune_chan();
+			phase = HOTT_CAL;
+			return 2000;
+		case HOTT_CAL:
+			calData[rf_ch_num]=CC2500_ReadReg(CC2500_25_FSCAL1);
+			if (++rf_ch_num < HOTT_NUM_RF_CHANNELS)
+				HOTT_tune_chan();
+			else
+			{
+				hopping_frequency_no = 0;
+				rf_ch_num=hopping_frequency[hopping_frequency_no];
+				counter = 0;
+				CC2500_SetTxRxMode(RX_EN);
+				phase = HOTT_DATA1;
+			}
+			return 2000;
+
+		/* Work cycle: 10ms */
+		case HOTT_DATA1:
+			//Set RF freq, setup LBT and prep packet
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(HOTT_PACKET_PERIOD);
+			#endif
+			//Clear all
+			CC2500_Strobe(CC2500_SIDLE);
+			CC2500_Strobe(CC2500_SNOP);
+			CC2500_Strobe(CC2500_SFTX);
+			CC2500_Strobe(CC2500_SFRX);
+			CC2500_WriteReg(CC2500_04_SYNC1, 0xD3);
+			CC2500_WriteReg(CC2500_05_SYNC0, 0x91);
+			//Set RF freq
+			HOTT_tune_freq();
+			HOTT_tune_chan_fast();
+			//Setup LBT
+			CC2500_WriteReg(CC2500_1B_AGCCTRL2, 0xFF);
+			CC2500_WriteReg(CC2500_1C_AGCCTRL1, 0x0C);
+			CC2500_Strobe(CC2500_SRX);
+			//Prep packet
+			HOTT_prep_data_packet();
+			//Listen
+			CC2500_WriteReg(CC2500_17_MCSM1, 0x10);		//??
+			CC2500_WriteReg(CC2500_18_MCSM0, 0x18);		//??
+			CC2500_Strobe(CC2500_SRX);					//??
+			phase++;		//HOTT_DATA2
+			return 1095;
+		case HOTT_DATA2:
+			//LBT
+			if((CC2500_ReadReg(CC2500_38_PKTSTATUS | CC2500_READ_BURST)&0x10)==0)
+			{ //Channel is busy
+				LBT_POWER_on;										// Reduce to low power before transmitting
+				debugln("Busy %d",rf_ch_num);
+			}
+			CC2500_WriteReg(CC2500_17_MCSM1, 0x00);		//??
+			CC2500_WriteReg(CC2500_18_MCSM0, 0x08);		//??
+			CC2500_SetPower();
+			//Send packet
+			CC2500_SetTxRxMode(TX_EN);
+			CC2500_Strobe(CC2500_STX);
+			phase++;		//HOTT_RX1
+			return 3880;
+		case HOTT_RX1:
+			//Clear all
+			CC2500_Strobe(CC2500_SIDLE);
+			CC2500_Strobe(CC2500_SFTX);
+			CC2500_Strobe(CC2500_SFRX);
+			//RX
+			if(packet[29] & 0xF8)
+			{// Sync telemetry
+				CC2500_WriteReg(CC2500_04_SYNC1, 0x2C);
+				CC2500_WriteReg(CC2500_05_SYNC0, 0x6E);
+			}
+			CC2500_SetTxRxMode(RX_EN);
+			CC2500_WriteReg(CC2500_1B_AGCCTRL2, 0xC7);
+			CC2500_WriteReg(CC2500_1C_AGCCTRL1, 0x09);
+			CC2500_WriteReg(CC2500_06_PKTLEN, HOTT_RX_PACKET_LEN);
+			CC2500_Strobe(CC2500_SRX);
+			phase++;		//HOTT_RX2
+			return 4025;
+		case HOTT_RX2:
+			//Telemetry
+			len = CC2500_ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+			if (len==HOTT_RX_PACKET_LEN+2)
+			{
+				CC2500_ReadData(packet_in, len);
+				if((packet_in[HOTT_RX_PACKET_LEN+1]&0x80) && memcmp(rx_tx_addr,packet_in,5)==0)
+				{ // CRC OK and TX ID matches
+					if(IS_BIND_IN_PROGRESS)
+					{
+						//GR-16:  D4 20 F2 E6 F6 31 BD 01 00 90 00 FF 03 00 9E 1B 00 00 00 00 00 00
+						//GR-12L: D4 20 F2 E6 F6 6E EE 01 00 B1 00 FF 03 00 0E 08 10 00 02 00 00 00
+						//Vector: D4 20 F2 E6 F6 00 00 3A 01 A1 00 00 1A 24 35 1A 00 24 00 00 00 1A
+						//        -----TXID----- -----RXID----- ---------------Unknown-------------
+						debug("B:");
+						for(uint8_t i=0;i<HOTT_RX_PACKET_LEN;i++)
+							debug(" %02X", packet_in[i]);
+						debugln("");
+						uint16_t addr=HOTT_EEPROM_OFFSET+RX_num*5;
+						for(uint8_t i=0; i<5; i++)
+							eeprom_write_byte((EE_ADDR)(addr+i),packet_in[5+i]);
+						BIND_DONE;
+						HOTT_TXID_init();
+					}
+					#ifdef HOTT_FW_TELEMETRY
+						else
+						{	//Telemetry
+							// [0..4] = TXID
+							// [5..9] = RXID
+							// [10] = holds warnings issued by hott devices
+							// [11] = telmetry pages. For sensors 0x00 to 0x04, for config mennu 0x00 to 0x12.
+							// Normal telem page 0 = 0x55, 0x32, 0x38, 0x55, 0x64, 0x32, 0xD0, 0x07, 0x00, 0x55
+							//   Page 0 [12] = [21] = [15]
+							//   Page 0 [13] = RX_Voltage Cur*10 in V
+							//   Page 0 [14] = Temperature-20 in °C
+							//   Page 0 [15] = RX_RSSI CC2500 formated (a<128:a/2-71dBm, a>=128:(a-256)/2-71dBm)
+							//   Page 0 [16] = RX_LQI in %
+							//   Page 0 [17] = RX_Voltage Min*10 in V
+							//   Page 0 [18,19] = [19]<<8+[18]=max lost packet time in ms, max value seems 2s=0x7D0
+							//   Page 0 [20] = rx events
+							//
+							// Config menu consists of the different telem pages put all together
+							//   Page X [12] = seems like all the telem pages with the same value are going together to make the full config menu text. Seen so far 'a', 'b', 'c', 'd' 
+							//   Page X [13..21] = 9 ascii chars to be displayed, char is highlighted when ascii|0x80
+							//   Screen display is 21 characters large which means that once the first 21 chars are filled go to the begining of the next line
+							//   Menu commands are sent through TX packets:
+							//     packet[28]= 0xXF=>no key press, 0xXD=>down, 0xXB=>up, 0xX9=>enter, 0xXE=>right, 0xX7=>left with X=0 or D
+							//     packet[29]= 0xX1/0xX9 with X=0 or X counting 0,1,1,2,2,..,9,9
+							// Reduce telemetry to 14 bytes
+							packet_in[0]= packet_in[HOTT_RX_PACKET_LEN];
+							packet_in[1]= TX_LQI;
+							uint8_t hott_warnings = packet_in[10];						// save warnings from hott devices
+							bool send_telem=true;
+							HOTT_sensor_seq++;											// Increment RX sequence counter
+							if(packet[29] & 1)
+							{ //Text mode
+								HOTT_sensor_seq %= 19;									// 19 pages in Text mode
+								HOTT_sensor_pages = 0;
+								HOTT_sensor_valid = false;
+								packet_in[10] = 0x80;									// Marking telem Text mode
+								packet_in[12] = 0;
+								for(uint8_t i=0; i<HOTT_SENSOR_TYPE;i++)
+									packet_in[12] |= HOTT_sensor_ok[i]<<i;				// Send detected sensors
+							}
+							else
+							{ //Binary sensor
+								HOTT_sensor_seq %= 5;									// 5 pages in binary mode per sensor
+								if(state==0 && HOTT_sensor_ok[0]==false && HOTT_sensor_ok[1]==false && HOTT_sensor_ok[2]==false && HOTT_sensor_ok[3]==false && HOTT_sensor_ok[4]==false && HOTT_sensor_ok[5]==false)
+									HOTT_sensor_seq=0;									// No sensors always ask page 0
+								if(state)
+									state--;
+								if( packet_in[11]==1 )									// Page 1
+								{
+									if( packet_in[12] == (HOTT_sensor_cur+9)<<4 )
+									{ //Requested sensor is sending: 0x90/A0/B0/C0/D0/E0
+										HOTT_sensor_pages = 0;							// Sensor first page received
+										HOTT_sensor_valid = true;						// Data from the expected sensor is being received
+										HOTT_sensor_ok[(packet_in[12]>>4)-9]=true;					
+									}
+									else
+									{
+										HOTT_sensor_valid = false;
+										HOTT_sensor_pages = 0x1E;						// Switch to next sensor
+									}
+								}
+								if(packet_in[11])
+								{ //Page != 0
+									if(HOTT_sensor_valid)								// Valid
+									{
+										packet_in[10] = HOTT_sensor_cur+9;				// Mark telem with sensor ID
+										HOTT_sensor_pages |= 1<<packet_in[11];			// Page received
+									}
+									else
+										send_telem=false;								// Do not send
+								}
+								else
+									packet_in[10]=0;									// Mark telem with sensor 0=RX
+							}
+							debug("T%d=",send_telem);
+							for(uint8_t i=10;i < HOTT_RX_PACKET_LEN; i++)
+							{
+								packet_in[i-8]=packet_in[i];
+								debug(" %02X",packet_in[i]);
+							}
+							packet_in[14] = hott_warnings;								// restore saved warnings from hott devices
+							debugln("");
+							if(send_telem)
+								telemetry_link=2;
+							if((HOTT_sensor_pages&0x1E) == 0x1E)						// All 4 pages received from the sensor
+							{ //Next sensor
+								uint8_t loop=0;
+								do
+								{
+									HOTT_sensor_cur++;									// Switch to next sensor
+									HOTT_sensor_cur %= HOTT_SENSOR_TYPE;
+									loop++;
+								}
+								while(HOTT_sensor_ok[HOTT_sensor_cur]==false && loop<HOTT_SENSOR_TYPE+1 && state==0);
+								HOTT_sensor_valid=false;
+								HOTT_sensor_pages=0;
+								HOTT_sensor_seq=0;
+								debugln("Sensor:%02X",HOTT_sensor_cur+9);
+							}										
+						}
+						pps_counter++;
+					#endif
+				}
+			}
+			#ifdef HOTT_FW_TELEMETRY
+				packet_count++;
+				if(packet_count>=100)
+				{
+					TX_LQI=pps_counter;
+					if(pps_counter==0)
+					{ // lost connection with RX, power cycle? research sensors again.
+						HOTT_sensor_cur=3;
+						HOTT_sensor_seq=0;
+						HOTT_sensor_valid=false;
+						for(uint8_t i=0; i<HOTT_SENSOR_TYPE;i++)
+							HOTT_sensor_ok[i]=false;	// no sensors detected
+						state=HOTT_SENSOR_SEARCH_PERIOD;
+					}
+					pps_counter=packet_count=0;
+				}
+			#endif
+			phase=HOTT_DATA1;
+			return 1000;
+	}
+	return 0;
+}
+
+void HOTT_init()
+{
+	num_ch=random(0xfefefefe)%16;
+	HOTT_TXID_init();
+	HOTT_rf_init();
+	#ifdef HOTT_FW_TELEMETRY
+		HoTT_SerialRX_val=0;
+		HoTT_SerialRX=false;
+		HOTT_sensor_cur=3;
+		HOTT_sensor_pages=0;
+		HOTT_sensor_valid=false;
+		HOTT_sensor_seq=0;
+		for(uint8_t i=0; i<HOTT_SENSOR_TYPE;i++)
+			HOTT_sensor_ok[i]=false;	// no sensors detected
+		packet_count=0;
+		state=HOTT_SENSOR_SEARCH_PERIOD;
+	#endif
+	phase = HOTT_START;
+}
+
+#endif

Multiprotocol/HS6200_EMU.ino

@@ -0,0 +1,112 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifdef CYRF6936_INSTALLED
+#include "iface_hs6200.h"
+
+static bool HS6200_crc;
+static uint16_t HS6200_crc_init;
+static uint8_t HS6200_address_length, HS6200_tx_addr[5];
+
+static void __attribute__((unused)) HS6200_Init(bool crc_en)
+{
+	CYRF_GFSK1M_Init(32, 1);	//Dummy number of bytes for now
+	HS6200_crc = crc_en;
+}
+
+static void __attribute__((unused)) HS6200_SetTXAddr(const uint8_t* addr, uint8_t addr_len)
+{
+	// precompute address crc
+	crc = 0xffff;
+	for(uint8_t i=0; i<addr_len; i++)
+		crc16_update(addr[addr_len-1-i], 8);
+	HS6200_crc_init=crc;
+	memcpy(HS6200_tx_addr, addr, addr_len);
+	HS6200_address_length = addr_len;
+}
+
+static uint16_t __attribute__((unused)) HS6200_calc_crc(uint8_t* msg, uint8_t len)
+{
+    uint8_t pos;
+    
+	crc = HS6200_crc_init;
+    // pcf + payload
+    for(pos=0; pos < len-1; pos++)
+        crc16_update(msg[pos], 8);
+    // last byte (1 bit only)
+    if(len > 0)
+        crc16_update(msg[pos+1], 1);
+    return crc;
+}
+
+static void __attribute__((unused)) HS6200_SendPayload(uint8_t* msg, uint8_t len)
+{
+	static const uint8_t HS6200_scramble[] = { 0x80,0xf5,0x3b,0x0d,0x6d,0x2a,0xf9,0xbc,0x51,0x8e,0x4c,0xfd,0xc1,0x65,0xd0 }; // todo: find all 32 bytes ...
+	uint8_t payload[32];
+	const uint8_t no_ack = 1; // never ask for an ack
+	static uint8_t pid;
+	uint8_t pos = 0;
+
+	if(len > sizeof(HS6200_scramble))
+		len = sizeof(HS6200_scramble);
+
+	// address
+	for(int8_t i=HS6200_address_length-1; i>=0; i--)
+		payload[pos++] = HS6200_tx_addr[i];
+
+	// guard bytes
+	payload[pos++] = HS6200_tx_addr[0];
+	payload[pos++] = HS6200_tx_addr[0];
+
+	// packet control field
+	payload[pos++] = ((len & 0x3f) << 2) | (pid & 0x03);
+	payload[pos] = (no_ack & 0x01) << 7;
+	pid++;
+
+	// scrambled payload
+	if(len > 0)
+	{
+		payload[pos++] |= (msg[0] ^ HS6200_scramble[0]) >> 1; 
+		for(uint8_t i=1; i<len; i++)
+			payload[pos++] = ((msg[i-1] ^ HS6200_scramble[i-1]) << 7) | ((msg[i] ^ HS6200_scramble[i]) >> 1);
+		payload[pos] = (msg[len-1] ^ HS6200_scramble[len-1]) << 7; 
+	}
+
+	// crc
+	if(HS6200_crc)
+	{
+		uint16_t crc = HS6200_calc_crc(&payload[HS6200_address_length+2], len+2);
+		uint8_t hcrc = crc >> 8;
+		uint8_t lcrc = crc & 0xff;
+		payload[pos++] |= (hcrc >> 1);
+		payload[pos++] = (hcrc << 7) | (lcrc >> 1);
+		payload[pos++] = lcrc << 7;
+	}
+
+	#if 0
+		debug("E:");
+		for(uint8_t i=0; i<pos; i++)
+			debug(" %02X",payload[i]);
+		debugln("");
+	#endif
+
+	//CYRF wants LSB first
+	for(uint8_t i=0; i<pos; i++)
+		payload[i]=bit_reverse(payload[i]);
+	//Send
+	CYRF_WriteRegister(CYRF_01_TX_LENGTH, pos);
+	CYRF_GFSK1M_SendPayload(payload, pos);
+}
+
+#endif

Multiprotocol/Height_a7105.ino

@@ -0,0 +1,111 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// Compatible with FZ-410 TX
+
+#if defined(HEIGHT_A7105_INO)
+
+#include "iface_a7105.h"
+
+//#define HEIGHT_FORCEID
+
+#define HEIGHT_BIND_COUNT	220		// 5 sec
+#define HEIGHT_BIND_CH		0x18	// TX, RX for bind end is 0x17
+
+static void __attribute__((unused)) HEIGHT_build_packet()
+{
+    packet[0] = 0xA5;
+    packet[1] = rx_tx_addr[2];
+    packet[2] = rx_tx_addr[3];
+	packet[3] = convert_channel_8b(AILERON);	//00..80..FF
+	packet[4] = convert_channel_8b(ELEVATOR);	//00..80..FF
+	packet[5] = convert_channel_8b(THROTTLE);	//00..FF
+	packet[6] = convert_channel_8b(RUDDER);		//00..80..FF
+    packet[7] = convert_channel_8b(CH5);		//00..80..FF
+    if(sub_protocol == HEIGHT_8CH)
+	{
+		packet[8] = convert_channel_8b(CH6);	//00..80..FF
+		packet[9] = convert_channel_8b(CH7);	//00..80..FF
+		packet[10] = convert_channel_8b(CH8);	//00..80..FF
+	}
+}
+
+uint16_t HEIGHT_callback()
+{
+	#ifndef FORCE_HEIGHT_TUNING
+		A7105_AdjustLOBaseFreq(1);
+	#endif
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[0] = 0x1B;
+		packet[1] = rx_tx_addr[2];
+		packet[2] = rx_tx_addr[3];
+		A7105_WriteData(3, HEIGHT_BIND_CH);
+		if (bind_counter--==0)
+			BIND_DONE;
+		return 22700;
+	}
+	else
+	{
+		if(phase>19)
+		{
+			phase=0;
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(20*1500);
+			#endif
+			HEIGHT_build_packet();
+			A7105_WriteData(sub_protocol?11:8, hopping_frequency[0]);
+			A7105_SetPower();
+		}
+		else
+		{
+			A7105_WriteReg(A7105_0F_PLL_I, hopping_frequency[(phase&0x02)>>1]);
+			A7105_Strobe(A7105_TX);
+		}
+		phase++;
+	}
+	return 1500;
+}
+
+void HEIGHT_init()
+{
+	A7105_Init();
+
+	hopping_frequency[0]=((random(0xfefefefe) & 0x0F)+2)<<2;
+	hopping_frequency[1]=hopping_frequency[0]+0x50;
+	
+	#ifdef HEIGHT_FORCEID
+		rx_tx_addr[2]=0x35;
+		rx_tx_addr[3]=0xD0;
+		hopping_frequency[0]=0x18;
+		hopping_frequency[1]=0x68;
+	#endif
+	
+	phase=255;
+	bind_counter = HEIGHT_BIND_COUNT;
+}
+#endif
+// Normal packet is 8 bytes: 0xA5 0xAF 0x59 0x84 0x7A 0x00 0x80 0xFF
+// Protocol is using AETR channel order, 1 byte per channel 00..80..FF including trim. Channels are in packet [3,4,5,6].
+// packet[0,1,2,7] values are constant in normal mode.
+// packet[0]=0xA5 -> normal mode
+// packet[1,2] ->ID
+// packet[7]=0xFF -> ???
+// Channel values are updated every 30ms which is quite slow, slower than PPM... 
+// Packets are sent every 1500µs on 2 different channels. 2 times on first channel, 2 times on second channel and restart. The channels are changing between the files 0x08, 0x58 and 0x18, 0x68.
+//
+// Bind is sending 3 bytes on channel 0x18: 0x1B 0x35 0xD0 every 22.7ms
+// packet[0]=0x1B -> bind mode
+// packet[1,2] ->ID
+// It listens for the model on channel 0x17 and recieves 0x1B 0x35 0xD0 when the plane accepts bind.

Multiprotocol/Hisky_nrf24l01.ino

@@ -24,44 +24,7 @@
 //
 uint8_t bind_buf_arry[4][10];
 
-// HiSky protocol uses TX id as an address for nRF24L01, and uses frequency hopping sequence
-// which does not depend on this id and is passed explicitly in binding sequence. So we are free
-// to generate this sequence as we wish. It should be in the range [02..77]
-static void __attribute__((unused)) calc_fh_channels()
-{
-	uint8_t idx = 0;
-	uint32_t rnd = MProtocol_id;
-
-	while (idx < HISKY_FREQUENCE_NUM)
-	{
-		uint8_t i;
-		uint8_t count_2_26 = 0, count_27_50 = 0, count_51_74 = 0;
-
-		rnd = rnd * 0x0019660D + 0x3C6EF35F; // Randomization
-		// Use least-significant byte. 73 is prime, so channels 76..77 are unused
-		uint8_t next_ch = ((rnd >> 8) % 73) + 2;
-		// Keep the distance 2 between the channels - either odd or even
-		if (((next_ch ^ (uint8_t)rx_tx_addr[3]) & 0x01 )== 0)
-			continue;
-		// Check that it's not duplicated and spread uniformly
-		for (i = 0; i < idx; i++) {
-			if(hopping_frequency[i] == next_ch)
-				break;
-			if(hopping_frequency[i] <= 26)
-				count_2_26++;
-			else if (hopping_frequency[i] <= 50)
-				count_27_50++;
-			else
-				count_51_74++;
-		}
-		if (i != idx)
-			continue;
-		if ( (next_ch <= 26 && count_2_26 < 8) || (next_ch >= 27 && next_ch <= 50 && count_27_50 < 8) || (next_ch >= 51 && count_51_74 < 8) )
-			hopping_frequency[idx++] = next_ch;//find hopping frequency
-	}
-}
-
-static void __attribute__((unused)) build_binding_packet(void)
+static void __attribute__((unused)) HISKY_build_binding_packet(void)
 {
 	uint8_t i;
 	uint16_t sum=0;
@@ -95,37 +58,30 @@ static void __attribute__((unused)) build_binding_packet(void)
 	}
 }
 
-static void __attribute__((unused)) hisky_init()
+static void __attribute__((unused)) HISKY_RF_init()
 {
 	NRF24L01_Initialize();
 
-	NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);			// No Auto Acknowledgement
-	NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x01);		// Enable p0 rx
-	NRF24L01_WriteReg(NRF24L01_03_SETUP_AW, 0x03);		// 5-byte RX/TX address (byte -2)
 	NRF24L01_WriteReg(NRF24L01_05_RF_CH, 81);			// binding packet must be set in channel 81
 	NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0, rx_tx_addr, 5);
 	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, rx_tx_addr, 5);
 	NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, 10);		// payload size = 10
 	if(sub_protocol==HK310)
 		NRF24L01_SetBitrate(NRF24L01_BR_250K);			// 250Kbps
-	else
-		NRF24L01_SetBitrate(NRF24L01_BR_1M);				// 1Mbps
-	NRF24L01_SetPower();								// Set power
-	NRF24L01_SetTxRxMode(TX_EN);						// TX mode, 2-bytes CRC, radio on
 }
 
 // HiSky channel sequence: AILE  ELEV  THRO  RUDD  GEAR  PITCH, channel data value is from 0 to 1000
 // Channel 7 - Gyro mode, 0 - 6 axis, 3 - 3 axis 
-static void __attribute__((unused)) build_ch_data()
+static void __attribute__((unused)) HISKY_build_ch_data()
 {
 	uint16_t temp;
 	uint8_t i,j;
 	for (i = 0; i< 8; i++) {
 		j=CH_AETR[i];
-		temp=map(limit_channel_100(j),servo_min_100,servo_max_100,0,1000);            			
-		if (j == THROTTLE) // It is clear that hisky's throttle stick is made reversely, so I adjust it here on purpose
+		temp=convert_channel_16b_limit(j,0,1000);            			
+		if (j == CH3) // It is clear that hisky's throttle stick is made reversely, so I adjust it here on purpose
 			temp = 1000 - temp;
-		if (j == AUX3)
+		if (j == CH7)
 			temp = temp < 400 ? 0 : 3; // Gyro mode, 0 - 6 axis, 3 - 3 axis 
 		packet[i] = (uint8_t)(temp&0xFF);
 		packet[i<4?8:9]>>=2;
@@ -133,7 +89,7 @@ static void __attribute__((unused)) build_ch_data()
 	}
 }
 
-uint16_t hisky_cb()
+uint16_t HISKY_callback()
 {
 	phase++;
 	if(sub_protocol==HK310)
@@ -150,12 +106,29 @@ uint16_t hisky_cb()
 			case 4:
 				phase=6;
 				break;
-			case 7:		// build packet with failsafe every 100ms
-				convert_channel_HK310(hopping_frequency_no!=0?RUDDER:AUX2,&packet[0],&packet[1]);
-				convert_channel_HK310(hopping_frequency_no!=0?THROTTLE:AUX3,&packet[2],&packet[3]);
-				convert_channel_HK310(hopping_frequency_no!=0?AUX1:AUX4,&packet[4],&packet[5]);
-				packet[7]=hopping_frequency_no!=0?0x55:0xAA;
-				packet[8]=hopping_frequency_no!=0?0x67:0x5A;
+			case 7:	// build packet
+				#ifdef MULTI_SYNC
+					telemetry_set_input_sync(5000);
+				#endif
+				#ifdef FAILSAFE_ENABLE
+					if(IS_FAILSAFE_VALUES_on && hopping_frequency_no==0)
+					{ //  send failsafe every 100ms
+						convert_failsafe_HK310(RUDDER,  &packet[0],&packet[1]);
+						convert_failsafe_HK310(THROTTLE,&packet[2],&packet[3]);
+						convert_failsafe_HK310(CH5,    &packet[4],&packet[5]);
+						packet[7]=0xAA;
+						packet[8]=0x5A;
+						FAILSAFE_VALUES_off;
+					}
+					else
+				#endif
+					{
+						convert_channel_HK310(RUDDER,  &packet[0],&packet[1]);
+						convert_channel_HK310(THROTTLE,&packet[2],&packet[3]);
+						convert_channel_HK310(CH5,    &packet[4],&packet[5]);
+						packet[7]=0x55;
+						packet[8]=0x67;
+					}
 				phase=8;
 				break;
 		}
@@ -203,7 +176,10 @@ uint16_t hisky_cb()
 			break;
 		case 7:
 			//Build normal packet
-			build_ch_data();
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(9000);
+			#endif
+			HISKY_build_ch_data();
 			break;
 		case 8:
 			break;
@@ -216,7 +192,7 @@ uint16_t hisky_cb()
 	return 1000;  // send 1 binding packet and 1 data packet per 9ms	
 }
 
-static void __attribute__((unused)) initialize_tx_id()
+static void __attribute__((unused)) HISKY_initialize_tx_id()
 {
 	//Generate frequency hopping table	
 	if(sub_protocol==HK310)
@@ -228,23 +204,25 @@ static void __attribute__((unused)) initialize_tx_id()
 			hopping_frequency[i]=hopping_frequency_no++;	// Sequential order hop channels...
 	}
 	else
-		calc_fh_channels();
+		calc_fh_channels(HISKY_FREQUENCE_NUM);
+		// HiSky air protocol uses TX id as an address for nRF24L01, and uses frequency hopping sequence
+		// which does not depend on this id and is passed explicitly in binding sequence. So we are free
+		// to generate this sequence as we wish. It should be in the range [02..77]
 }
 
-uint16_t initHiSky()
+void HISKY_init()
 {
-	initialize_tx_id();
-	build_binding_packet();
-	hisky_init();
+	HISKY_initialize_tx_id();
+	HISKY_build_binding_packet();
+	HISKY_RF_init();
 	phase = 0;
 	hopping_frequency_no = 0;
 	binding_idx = 0;
 
-	if(IS_AUTOBIND_FLAG_on)
+	if(IS_BIND_IN_PROGRESS)
 		bind_counter = HISKY_BIND_COUNT;
 	else 
 		bind_counter = 0;
-	return 1000;
 }
 
 #endif

Multiprotocol/Hitec_cc2500.ino

@@ -0,0 +1,482 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(HITEC_CC2500_INO)
+
+#include "iface_cc2500.h"
+
+//#define HITEC_FORCE_ID	//Use the ID and hopping table from the original dump
+
+#define HITEC_COARSE			0
+
+#define HITEC_PACKET_LEN		13
+#define HITEC_TX_ID_LEN			2
+#define HITEC_BIND_COUNT		444	// 10sec
+#define HITEC_NUM_FREQUENCE		21
+#define HITEC_BIND_NUM_FREQUENCE 14
+
+enum {
+    HITEC_START = 0x00,
+    HITEC_CALIB = 0x01,
+    HITEC_PREP  = 0x02,
+    HITEC_DATA1 = 0x03,
+    HITEC_DATA2 = 0x04,
+    HITEC_DATA3 = 0x05,
+    HITEC_DATA4	= 0x06,
+    HITEC_RX1	= 0x07,
+    HITEC_RX2	= 0x08,
+};
+
+const PROGMEM uint8_t HITEC_init_values[] = {
+  /* 00 */ 0x2F, 0x2E, 0x2F, 0x07, 0xD3, 0x91, 0xFF, 0x04,
+  /* 08 */ 0x45, 0x00, 0x00, 0x12, 0x00, 0x5C, 0x85, 0xE8 + HITEC_COARSE,
+  /* 10 */ 0x3D, 0x3B, 0x73, 0x73, 0x7A, 0x01, 0x07, 0x30,
+  /* 18 */ 0x08, 0x1D, 0x1C, 0xC7, 0x40, 0xB0, 0x87, 0x6B,
+  /* 20 */ 0xF8, 0xB6, 0x10, 0xEA, 0x0A, 0x00, 0x11
+};
+
+static void __attribute__((unused)) HITEC_CC2500_init()
+{
+	CC2500_Strobe(CC2500_SIDLE);
+
+	for (uint8_t i = 0; i < 39; ++i)
+		CC2500_WriteReg(i, pgm_read_byte_near(&HITEC_init_values[i]));
+
+	CC2500_WriteReg(CC2500_0C_FSCTRL0, option);
+	prev_option = option;
+
+	CC2500_SetTxRxMode(TX_EN);
+	CC2500_SetPower();
+}
+
+// Generate RF channels
+static void __attribute__((unused)) HITEC_RF_channels()
+{
+	//Normal hopping
+	uint8_t idx = 0;
+	uint32_t rnd = MProtocol_id;
+
+	while (idx < HITEC_NUM_FREQUENCE)
+	{
+		uint8_t i;
+		uint8_t count_0_47 = 0, count_48_93 = 0, count_94_140 = 0;
+
+		rnd = rnd * 0x0019660D + 0x3C6EF35F; // Randomization
+		// Use least-significant byte and make sure it's pair.
+		uint8_t next_ch = ((rnd >> 8) % 141) & 0xFE;
+		// Check that it's not duplicated and spread uniformly
+		for (i = 0; i < idx; i++) {
+			if(hopping_frequency[i] == next_ch)
+				break;
+			if(hopping_frequency[i] <= 47)
+				count_0_47++;
+			else if (hopping_frequency[i] <= 93)
+				count_48_93++;
+			else
+				count_94_140++;
+		}
+		if (i != idx)
+			continue;
+		if ( (next_ch <= 47 && count_0_47 < 8) || (next_ch >= 48 && next_ch <= 93 && count_48_93 < 8) || (next_ch >= 94 && count_94_140 < 8) )
+			hopping_frequency[idx++] = next_ch;//find hopping frequency
+	}
+}
+
+static void __attribute__((unused)) HITEC_tune_chan()
+{
+	CC2500_Strobe(CC2500_SIDLE);
+	if(IS_BIND_IN_PROGRESS)
+		CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency_no*10);
+	else
+		CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency[hopping_frequency_no]);
+	CC2500_Strobe(CC2500_SFTX);
+	CC2500_Strobe(CC2500_SCAL);
+	CC2500_Strobe(CC2500_STX);
+}
+
+static void __attribute__((unused)) HITEC_change_chan_fast()
+{
+	CC2500_Strobe(CC2500_SIDLE);
+	if(IS_BIND_IN_PROGRESS)
+		CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency_no*10);
+	else
+		CC2500_WriteReg(CC2500_0A_CHANNR, hopping_frequency[hopping_frequency_no]);
+	CC2500_WriteReg(CC2500_25_FSCAL1, calData[hopping_frequency_no]);
+}
+
+static void __attribute__((unused)) HITEC_build_packet()
+{
+	static boolean F5_frame=false;
+	static uint8_t F5_counter=0;
+	uint8_t offset;
+	
+	packet[1] = rx_tx_addr[1];
+	packet[2] = rx_tx_addr[2];
+	packet[3] = rx_tx_addr[3];
+	packet[22] = 0xEE;			// unknown always 0xEE
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[0] = 0x16;		// 22 bytes to follow
+		memset(packet+5,0x00,14);
+		switch(bind_phase)
+		{
+			case 0x72:			// first part of the hopping table
+				for(uint8_t i=0;i<14;i++)
+					packet[5+i]=hopping_frequency[i]>>1;
+				break;
+			case 0x73:			// second part of the hopping table
+				for(uint8_t i=0;i<7;i++)
+					packet[5+i]=hopping_frequency[i+14]>>1;
+				break;
+			case 0x74:
+				packet[7]=0x55;	// unknown but bind does not complete if not there
+				packet[8]=0x55;	// unknown but bind does not complete if not there
+				break;
+			case 0x7B:
+				packet[5]=hopping_frequency[13]>>1;	// if not there the Optima link is jerky...
+				packet[14]=0x2A;
+				packet[15]=0x46; // unknown but if 0x45 then 17=0x46, if 0x46 then 17=0x46 or 0x47, if 0x47 then 0x45 or 0x46
+				packet[16]=0x2A;
+				packet[17]=0x47;
+				packet[18]=0x2A;
+				break;
+		}
+		if(sub_protocol==MINIMA)
+			packet[4] = bind_phase+0x10;
+		else
+			packet[4] = bind_phase;	// Optima: increments based on RX answer
+		packet[19] = 0x08;		// packet sequence
+		offset=20;				// packet[20] and [21]
+	}
+	else
+	{
+		packet[0] = 0x1A;		// 26 bytes to follow
+		for(uint8_t i=0;i<9;i++)
+		{
+			uint16_t ch = convert_channel_16b_nolimit(i,0x1B87,0x3905,false);
+			packet[4+2*i] = ch >> 8;
+			packet[5+2*i] = ch & 0xFF;
+		}
+		packet[23] = 0x80;		// packet sequence
+		offset=24;				// packet[24] and [25]
+		packet[26] = 0x00;		// unknown always 0 and the RX doesn't seem to care about the value?
+	}
+
+	if(F5_frame)
+	{// No idea what it is but Minima RXs are expecting these frames to work to work
+		packet[offset] = 0xF5;
+		packet[offset+1] = 0xDF;
+		if((F5_counter%9)==0)
+			packet[offset+1] -= 0x04;	// every 8 packets send 0xDB
+		F5_counter++;
+		F5_counter%=59;					// every 6 0xDB packets wait only 4 to resend instead of 8
+		F5_frame=false;					// alternate
+		if(IS_BIND_IN_PROGRESS)
+			packet[offset+1]++;			// when binding the values are 0xE0 and 0xDC
+	}
+	else
+	{
+		packet[offset] = 0x00;
+		packet[offset+1] = 0x00;
+		F5_frame=true;					// alternate
+	}
+/*	debug("P:");
+	for(uint8_t i=0;i<packet[0]+1;i++)
+		debug("%02X,",packet[i]);
+	debugln("");
+*/
+}
+
+static void __attribute__((unused)) HITEC_send_packet()
+{
+	CC2500_WriteData(packet, packet[0]+1);
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[19] >>= 1;	// packet sequence
+		if( (packet[4] & 0xFE) ==0x82 )
+		{ // Minima
+			packet[4] ^= 1;					// alternate 0x82 and 0x83
+			if( packet[4] & 0x01 )
+				for(uint8_t i=0;i<7;i++)	// 0x83
+					packet[5+i]=hopping_frequency[i+14]>>1;
+			else
+				for(uint8_t i=0;i<14;i++)	// 0x82
+					packet[5+i]=hopping_frequency[i]>>1;
+		}
+	}
+	else
+		packet[23] >>= 1;	// packet sequence
+}
+
+uint16_t HITEC_callback()
+{
+	switch(phase)
+	{
+		case HITEC_START:
+			HITEC_CC2500_init();
+			bind_phase=0x72;
+			if(IS_BIND_IN_PROGRESS)
+			{
+				bind_counter = HITEC_BIND_COUNT;
+				rf_ch_num=HITEC_BIND_NUM_FREQUENCE;
+			}
+			else
+			{
+				bind_counter=0;
+				rf_ch_num=HITEC_NUM_FREQUENCE;
+				//Set TXID
+				CC2500_WriteReg(CC2500_05_SYNC0,rx_tx_addr[2]);
+				CC2500_WriteReg(CC2500_04_SYNC1,rx_tx_addr[3]);
+			}
+			hopping_frequency_no=0;
+			HITEC_tune_chan();
+			phase = HITEC_CALIB;
+			return 2000;
+		case HITEC_CALIB:
+			calData[hopping_frequency_no]=CC2500_ReadReg(CC2500_25_FSCAL1);
+			hopping_frequency_no++;
+			if (hopping_frequency_no < rf_ch_num)
+				HITEC_tune_chan();
+			else
+			{
+				hopping_frequency_no = 0;
+				phase = HITEC_PREP;
+			}
+			return 2000;
+
+		/* Work cycle: 22.5ms */
+#define HITEC_PACKET_PERIOD	22500
+#define HITEC_PREP_TIMING	462
+#define HITEC_DATA_TIMING	2736
+#define HITEC_RX1_TIMING	4636
+		case HITEC_PREP:
+			if ( prev_option == option )
+			{	// No user frequency change
+				#ifdef MULTI_SYNC
+					telemetry_set_input_sync(HITEC_PACKET_PERIOD);
+				#endif
+				HITEC_change_chan_fast();
+				hopping_frequency_no++;
+				if(hopping_frequency_no>=rf_ch_num)
+					hopping_frequency_no=0;
+				CC2500_SetPower();
+				CC2500_SetTxRxMode(TX_EN);
+				HITEC_build_packet();
+				phase++;
+			}
+			else
+				phase = HITEC_START;	// Restart the tune process if option is changed to get good tuned values
+			return HITEC_PREP_TIMING;
+		case HITEC_DATA1:
+		case HITEC_DATA2:
+		case HITEC_DATA3:
+		case HITEC_DATA4:
+			HITEC_send_packet();
+			phase++;
+			return HITEC_DATA_TIMING;
+		case HITEC_RX1:
+			CC2500_SetTxRxMode(RX_EN);
+			CC2500_Strobe(CC2500_SRX);	// Turn RX ON
+			phase++;
+			return HITEC_RX1_TIMING;
+		case HITEC_RX2:
+			uint8_t len=CC2500_ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+			if(len && len<TELEMETRY_BUFFER_SIZE)
+			{ // Something has been received
+				CC2500_ReadData(packet_in, len);
+				if( (packet_in[len-1] & 0x80) && packet_in[0]==len-3 && packet_in[1]==rx_tx_addr[1] && packet_in[2]==rx_tx_addr[2] && packet_in[3]==rx_tx_addr[3])
+				{ //valid crc && length ok && tx_id ok
+					debug("RX:l=%d",len);
+					for(uint8_t i=0;i<len;i++)
+						debug(",%02X",packet_in[i]);
+					if(IS_BIND_IN_PROGRESS)
+					{
+						if(len==13)	// Bind packets have a length of 13
+						{ // bind packet: 0A,00,E5,F2,7X,05,06,07,08,09,00
+							debug(",bind");
+							boolean check=true;
+							for(uint8_t i=5;i<10;i++)
+								if(packet_in[i]!=i) check=false;
+							if((packet_in[4]&0xF0)==0x70 && check)
+							{
+								bind_phase=packet_in[4]+1;
+								if(bind_phase==0x7B)
+									bind_counter=164;	// in dumps the RX stops to reply at 0x7B so wait a little and exit
+							}
+						}
+					}
+					else
+						if( len==15 && packet_in[4]==0 && packet_in[12]==0 )
+						{	// Valid telemetry packets
+							// no station:
+							//		0C,1C,A1,2B,00,00,00,00,00,00,00,8D,00,64,8E	-> 00 8D=>RX battery voltage 0x008D/28=5.03V
+							// with HTS-SS:
+							//		0C,1C,A1,2B,00,11,AF,00,2D,00,8D,11,00,4D,96	-> 00 8D=>RX battery voltage 0x008D/28=5.03V
+							//		0C,1C,A1,2B,00,12,00,00,00,00,00,12,00,52,93
+							//		0C,1C,A1,2B,00,13,00,00,00,00,46,13,00,52,8B	-> 46=>temperature2 0x46-0x28=30°C
+							//		0C,1C,A1,2B,00,14,00,00,00,00,41,14,00,2C,93	-> 41=>temperature1 0x41-0x28=25°C
+							//		0C,1C,A1,2B,00,15,00,2A,00,0E,00,15,00,44,96	-> 2A 00=>rpm1=420, 0E 00=>rpm2=140 
+							//		0C,1C,A1,2B,00,16,00,00,00,00,00,16,00,2C,8E
+							//		0C,1C,A1,2B,00,17,00,00,00,42,44,17,00,48,8D	-> 42=>temperature3 0x42-0x28=26°C,44=>temperature4 0x44-0x28=28°C
+							//		0C,1C,A1,2B,00,18,00,00,00,00,00,18,00,50,92
+							debug(",telem,%02x",packet_in[14]&0x7F);
+							#if defined(HITEC_FW_TELEMETRY) || defined(HITEC_HUB_TELEMETRY)
+								TX_RSSI = packet_in[13];
+								if(TX_RSSI >=128)
+									TX_RSSI -= 128;
+								else
+									TX_RSSI += 128;
+								TX_LQI = packet_in[14]&0x7F;
+							#endif
+							#if defined(HITEC_FW_TELEMETRY)
+								if(sub_protocol==OPT_FW)
+								{
+									// 8 bytes telemetry packets => see at the end of this file how to fully decode it
+									packet_in[0]=TX_RSSI;				// TX RSSI
+									packet_in[1]=TX_LQI;				// TX LQI
+									uint8_t offset=packet_in[5]==0?1:0;
+									for(uint8_t i=5;i < 11; i++)
+										packet_in[i-3]=packet_in[i+offset];	// frame number followed by 5 bytes of data
+									telemetry_link=2;			// telemetry forward available
+								}
+							#endif
+							#if defined(HITEC_HUB_TELEMETRY)
+								if(sub_protocol==OPT_HUB)
+								{
+									switch(packet_in[5])		// telemetry frame number
+									{
+										case 0x00:
+											v_lipo1 = (packet_in[10])<<5 | (packet_in[11])>>3;	// calculation in float is volt=(packet_in[10]<<8+packet_in[11])/28
+											break;
+										case 0x11:
+											v_lipo1 = (packet_in[9])<<5 | (packet_in[10])>>3;	// calculation in float is volt=(packet_in[9]<<8+packet_in[10])/28
+											break;
+										case 0x18:
+											v_lipo2 =  (packet_in[6])<<5 | (packet_in[7])>>3;	// calculation in float is volt=(packet_in[6]<<8+packet_in[7])/10
+											break;
+									}
+									telemetry_link=1;			// telemetry hub available
+								}
+							#endif
+						}
+					debugln("");
+				}
+			}
+			CC2500_Strobe(CC2500_SFRX);	// Flush the RX FIFO buffer
+			phase = HITEC_PREP;
+			if(bind_counter)
+			{
+				bind_counter--;
+				if(!bind_counter)
+				{
+					BIND_DONE;
+					phase=HITEC_START;
+				}
+			}
+			return (HITEC_PACKET_PERIOD -HITEC_PREP_TIMING -4*HITEC_DATA_TIMING -HITEC_RX1_TIMING);
+	}
+	return 0;
+}
+
+void HITEC_init()
+{
+	HITEC_RF_channels();
+	#ifdef HITEC_FORCE_ID	// ID and channels taken from dump
+		rx_tx_addr[1]=0x00;
+		rx_tx_addr[2]=0x03;
+		rx_tx_addr[3]=0x6A;
+		memcpy((void *)hopping_frequency,(void *)"\x00\x3A\x4A\x32\x0C\x58\x2A\x10\x26\x20\x08\x60\x68\x70\x78\x80\x88\x56\x5E\x66\x6E",HITEC_NUM_FREQUENCE);
+	#endif
+	phase = HITEC_START;
+}
+
+/* Full telemetry 
+packet[0] = TX RSSI value
+packet[1] = TX LQI value
+packet[2] = frame number
+packet[3-7] telemetry data
+
+The frame number takes the following values: 0x00, 0x11, 0x12, ..., 0x1C. The frames can be present or not, they also do not have to follow each others.
+Here is a description of the telemetry data for each frame number:
+- frame 0x00
+data byte 0 -> 0x00				unknown
+data byte 1 -> 0x00				unknown
+data byte 2 -> 0x00				unknown
+data byte 3 -> RX Batt Volt_H
+data byte 4 -> RX Batt Volt_L => RX Batt=(Volt_H*256+Volt_L)/28
+- frame 0x11
+data byte 0 -> 0xAF				start of frame
+data byte 1 -> 0x00				unknown
+data byte 2 -> 0x2D				station type 0x2D=standard station nitro or electric, 0xAC=advanced station
+data byte 3 -> RX Batt Volt_H
+data byte 4 -> RX Batt Volt_L => RX Batt=(Volt_H*256+Volt_L)/28
+- frame 0x12
+data byte 0 -> Lat_sec_H		GPS : latitude second
+data byte 1 -> Lat_sec_L		signed int : 1/100 of second
+data byte 2 -> Lat_deg_min_H	GPS : latitude degree.minute
+data byte 3 -> Lat_deg_min_L	signed int : +=North, - = south
+data byte 4 -> Time_second		GPS Time
+- frame 0x13
+data byte 0 -> 					GPS Longitude second
+data byte 1 -> 					signed int : 1/100 of second
+data byte 2 -> 					GPS Longitude degree.minute
+data byte 3 -> 					signed int : +=Est, - = west
+data byte 4 -> Temp2			Temperature2=Temp2-40°C
+- frame 0x14
+data byte 0 -> Speed_H
+data byte 1 -> Speed_L			GPS Speed=Speed_H*256+Speed_L km/h
+data byte 2 -> Alti_sea_H
+data byte 3 -> Alti_sea_L		GPS Altitude=Alti_sea_H*256+Alti_sea_L m
+data byte 4 -> Temp1			Temperature1=Temp1-40°C
+- frame 0x15
+data byte 0 -> FUEL
+data byte 1 -> RPM1_L
+data byte 2 -> RPM1_H			RPM1=RPM1_H*256+RPM1_L
+data byte 3 -> RPM2_L
+data byte 4 -> RPM2_H			RPM2=RPM2_H*256+RPM2_L
+- frame 0x16
+data byte 0 -> Date_year		GPS Date
+data byte 1 -> Date_month
+data byte 2 -> Date_day
+data byte 3 -> Time_hour		GPS Time
+data byte 4 -> Time_min
+- frame 0x17
+data byte 0 -> COURSEH
+data byte 1 -> COURSEL			GPS heading = COURSEH*256+COURSEL in degrees
+data byte 2 -> Count			GPS satellites
+data byte 3 -> Temp3			Temperature3=Temp2-40°C
+data byte 4 -> Temp4			Temperature4=Temp3-40°C
+- frame 0x18
+data byte 0 -> Volt_L			Volt=(Volt_H*256+Volt_L)/10 V
+data byte 1 -> Volt_H
+data byte 2 -> AMP_L
+data byte 3 -> AMP_H			Amp=(AMP1_*256+AMP_L -180)/14 in signed A
+- frame 0x19					Servo sensor
+data byte 0 -> AMP_Servo1		Amp=AMP_Servo1/10 in A
+data byte 1 -> AMP_Servo2		Amp=AMP_Servo2/10 in A
+data byte 2 -> AMP_Servo3		Amp=AMP_Servo3/10 in A
+data byte 3 -> AMP_Servo4		Amp=AMP_Servo4/10 in A
+- frame 0x1A
+data byte 2 -> ASpeed_H			Air speed=ASpeed_H*256+ASpeed_L km/h
+data byte 3 -> ASpeed_L
+- frame 0x1B					Variometer sensor
+data byte 0 -> Alti1H
+data byte 1 -> Alti1L			Altitude unfiltered
+data byte 2 -> Alti2H
+data byte 3 -> Alti2L			Altitude filtered
+- frame 0x1C					Unknown
+- frame 0x22					Unknown
+*/
+#endif

Multiprotocol/Hontai_nrf24l01.ino

@@ -15,7 +15,7 @@
 
 #if defined(HONTAI_NRF24L01_INO)
 
-#include "iface_nrf24l01.h"
+#include "iface_xn297.h"	// mix of nrf and xn297 at 1Mb...
 
 #define HONTAI_BIND_COUNT 80
 #define HONTAI_PACKET_PERIOD    13500
@@ -34,151 +34,128 @@ enum{
     HONTAI_FLAG_CALIBRATE = 0x20,
 };
 
-// proudly swiped from http://www.drdobbs.com/implementing-the-ccitt-cyclical-redundan/199904926
-#define HONTAI_POLY 0x8408
-static void __attribute__((unused)) crc16(uint8_t *data_p, uint8_t length)
+static void __attribute__((unused)) HONTAI_send_packet()
 {
-	uint16_t crc = 0xffff;
-
-	length -= 2;
-	do
-	{
-		for (uint8_t i = 0, data = (uint8_t)*data_p++;
-		i < 8;
-		i++, data >>= 1)
-		{
-			if ((crc & 0x01) ^ (data & 0x01))
-				crc = (crc >> 1) ^ HONTAI_POLY;
-			else
-				crc >>= 1;
-		}
-	} while (--length);
-
-	crc = ~crc;
-	*data_p++ = crc & 0xff;
-	*data_p   = crc >> 8;
-}
-
-static void __attribute__((unused)) HONTAI_send_packet(uint8_t bind)
-{
-	if (bind)
+	if (IS_BIND_IN_PROGRESS)
 	{
 		memcpy(packet, rx_tx_addr, 5);
 		memset(&packet[5], 0, 3);
+		packet_length = HONTAI_BIND_PACKET_SIZE;
 	}
 	else
 	{
+		/*if(sub_protocol == JJRCX1)
+			NRF24L01_WriteReg(NRF24L01_05_RF_CH, hopping_frequency[hopping_frequency_no++]);
+		else*/
+			XN297_Hopping(hopping_frequency_no++);
+		hopping_frequency_no %= 3;
 		memset(packet,0,HONTAI_PACKET_SIZE);
-		packet[3] = convert_channel_8b_scale(THROTTLE, 0, 127) << 1;	// Throttle
-		packet[4] = convert_channel_8b_scale(AILERON, 63, 0);			// Aileron
-		packet[5] = convert_channel_8b_scale(ELEVATOR, 0, 63);			// Elevator
-		packet[6] = convert_channel_8b_scale(RUDDER, 0, 63);			// Rudder
-		if(sub_protocol == FORMAT_X5C1)
-			packet[7] = convert_channel_8b_scale(AILERON, 0, 63)-31;	// Aileron trim
+		packet[3] = convert_channel_16b_limit(THROTTLE, 0, 127) << 1;	// Throttle
+		packet[4] = convert_channel_16b_limit(AILERON, 63, 0);			// Aileron
+		packet[5] = convert_channel_16b_limit(ELEVATOR, 0, 63);			// Elevator
+		packet[6] = convert_channel_16b_limit(RUDDER, 0, 63);			// Rudder
+		if(sub_protocol == X5C1)
+			packet[7] = convert_channel_16b_limit(AILERON, 0, 63)-31;	// Aileron trim
 		else
-			packet[7] = convert_channel_8b_scale(AILERON, 0, 32)-16;	// Aileron trim
-		packet[8] = convert_channel_8b_scale(RUDDER, 0, 32)-16;			// Rudder trim
-		if (sub_protocol == FORMAT_X5C1)
-			packet[9] = convert_channel_8b_scale(ELEVATOR, 0, 63)-31;	// Elevator trim
+			packet[7] = convert_channel_16b_limit(AILERON, 0, 32)-16;	// Aileron trim
+		packet[8] = convert_channel_16b_limit(RUDDER, 0, 32)-16;			// Rudder trim
+		if (sub_protocol == X5C1)
+			packet[9] = convert_channel_16b_limit(ELEVATOR, 0, 63)-31;	// Elevator trim
 		else
-			packet[9] = convert_channel_8b_scale(ELEVATOR, 0, 32)-16;	// Elevator trim
+			packet[9] = convert_channel_16b_limit(ELEVATOR, 0, 32)-16;	// Elevator trim
 		switch(sub_protocol)
 		{
-			case FORMAT_HONTAI:
+			case HONTAI:
 				packet[0]  = 0x0B;
-				packet[3] |= GET_FLAG(Servo_AUX3, 0x01);				// Picture
-				packet[4] |= GET_FLAG(Servo_AUX6, 0x80)					// RTH
-						  |  GET_FLAG(Servo_AUX5, 0x40);				// Headless
-				packet[5] |= GET_FLAG(Servo_AUX7, 0x80)					// Calibrate
-						  |  GET_FLAG(Servo_AUX1, 0x40);				// Flip
-				packet[6] |= GET_FLAG(Servo_AUX4, 0x80);				// Video
+				packet[3] |= GET_FLAG(CH7_SW, 0x01);				// Picture
+				packet[4] |= GET_FLAG(CH10_SW, 0x80)					// RTH
+						  |  GET_FLAG(CH9_SW, 0x40);				// Headless
+				packet[5] |= GET_FLAG(CH11_SW, 0x80)					// Calibrate
+						  |  GET_FLAG(CH5_SW, 0x40);				// Flip
+				packet[6] |= GET_FLAG(CH8_SW, 0x80);				// Video
 				break;
-			case FORMAT_JJRCX1:
-				packet[0]  = GET_FLAG(Servo_AUX2, 0x02);				// Arm
-				packet[3] |= GET_FLAG(Servo_AUX3, 0x01);				// Picture
+			case JJRCX1:
+				packet[0]  = GET_FLAG(CH6_SW, 0x02);				// Arm
+				packet[3] |= GET_FLAG(CH7_SW, 0x01);				// Picture
 				packet[4] |= 0x80;										// unknown
-				packet[5] |= GET_FLAG(Servo_AUX7, 0x80)					// Calibrate
-						  |  GET_FLAG(Servo_AUX1, 0x40);				// Flip
-				packet[6] |= GET_FLAG(Servo_AUX4, 0x80);				// Video
+				packet[5] |= GET_FLAG(CH11_SW, 0x80)					// Calibrate
+						  |  GET_FLAG(CH5_SW, 0x40);				// Flip
+				packet[6] |= GET_FLAG(CH8_SW, 0x80);				// Video
 				packet[8]  = 0xC0										// high rate, no rudder trim
-						  |  GET_FLAG(Servo_AUX6, 0x02)					// RTH
-						  |  GET_FLAG(Servo_AUX5, 0x01);				// Headless
+						  |  GET_FLAG(CH10_SW, 0x02)					// RTH
+						  |  GET_FLAG(CH9_SW, 0x01);				// Headless
 				break;
-			case FORMAT_X5C1:
+			case X5C1:
 				packet[0]  = 0x0B;
-				packet[3] |= GET_FLAG(Servo_AUX3, 0x01);				// Picture
+				packet[3] |= GET_FLAG(CH7_SW, 0x01);				// Picture
 				packet[4]  = 0x80										// unknown
-						  |  GET_FLAG(Servo_AUX2, 0x40);				// Lights
-				packet[5] |= GET_FLAG(Servo_AUX7, 0x80)					// Calibrate
-						  |  GET_FLAG(Servo_AUX1, 0x40);				// Flip
-				packet[6] |= GET_FLAG(Servo_AUX4, 0x80);				// Video
+						  |  GET_FLAG(CH6_SW, 0x40);				// Lights
+				packet[5] |= GET_FLAG(CH11_SW, 0x80)					// Calibrate
+						  |  GET_FLAG(CH5_SW, 0x40);				// Flip
+				packet[6] |= GET_FLAG(CH8_SW, 0x80);				// Video
 				packet[8]  = 0xC0										// high rate, no rudder trim
-						  |  GET_FLAG(Servo_AUX6, 0x02)					// RTH
-						  |  GET_FLAG(Servo_AUX5, 0x01);				// Headless
+						  |  GET_FLAG(CH10_SW, 0x02)					// RTH
+						  |  GET_FLAG(CH9_SW, 0x01);				// Headless
 				break;
-			case FORMAT_FQ777_951:
-				packet[0]  = GET_FLAG(Servo_AUX3, 0x01)					// Picture
-						  |  GET_FLAG(Servo_AUX4, 0x02);				// Video
-				packet[3] |= GET_FLAG(Servo_AUX1, 0x01);				// Flip
+			case FQ777_951:
+				packet[0]  = GET_FLAG(CH7_SW, 0x01)					// Picture
+						  |  GET_FLAG(CH8_SW, 0x02);				// Video
+				packet[3] |= GET_FLAG(CH5_SW, 0x01);				// Flip
 				packet[4] |= 0xC0;										// High rate (mid=0xa0, low=0x60)
-				packet[5] |= GET_FLAG(Servo_AUX7, 0x80);				// Calibrate
-				packet[6] |= GET_FLAG(Servo_AUX5, 0x40);				// Headless
+				packet[5] |= GET_FLAG(CH11_SW, 0x80);				// Calibrate
+				packet[6] |= GET_FLAG(CH9_SW, 0x40);				// Headless
 				break;
 		}
+		packet_length = HONTAI_PACKET_SIZE;
 	}
-	crc16(packet, bind ? HONTAI_BIND_PACKET_SIZE:HONTAI_PACKET_SIZE);
+
+	// CRC 16 bits reflected in and out
+	crc=0xFFFF;
+	for(uint8_t i=0; i< packet_length-2; i++)
+		crc16_update(bit_reverse(packet[i]),8);
+	crc ^= 0xFFFF;
+	packet[packet_length-2]=bit_reverse(crc>>8);
+	packet[packet_length-1]=bit_reverse(crc);
 
 	// Power on, TX mode, 2byte CRC
-	if(sub_protocol == FORMAT_JJRCX1)
+	/*if(sub_protocol == JJRCX1)
+	{
+		NRF24L01_SetPower();
 		NRF24L01_SetTxRxMode(TX_EN);
-	else
-		XN297_Configure(_BV(NRF24L01_00_EN_CRC) | _BV(NRF24L01_00_CRCO) | _BV(NRF24L01_00_PWR_UP));
-
-	NRF24L01_WriteReg(NRF24L01_05_RF_CH, bind ? HONTAI_RF_BIND_CHANNEL : hopping_frequency[hopping_frequency_no++]);
-	hopping_frequency_no %= 3;
-
 		NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);
 		NRF24L01_FlushTx();
-
-	if(sub_protocol == FORMAT_JJRCX1)
-		NRF24L01_WritePayload(packet, bind ? HONTAI_BIND_PACKET_SIZE:HONTAI_PACKET_SIZE);
-	else
-		XN297_WritePayload(packet, bind ? HONTAI_BIND_PACKET_SIZE:HONTAI_PACKET_SIZE);
-
-	NRF24L01_SetPower();
+	}
+	else*/
+	{
+		XN297_SetPower();
+		XN297_SetTxRxMode(TX_EN);
 	}
 
-static void __attribute__((unused)) HONTAI_init()
-{
-	NRF24L01_Initialize();
-
-	NRF24L01_SetTxRxMode(TX_EN);
-
-	if(sub_protocol == FORMAT_JJRCX1)
-		NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, (uint8_t*)"\xd2\xb5\x99\xb3\x4a", 5);
+	if(sub_protocol == JJRCX1)
+		NRF24L01_WritePayload(packet, packet_length);
 	else
-		XN297_SetTXAddr((const uint8_t*)"\xd2\xb5\x99\xb3\x4a", 5);
+		XN297_WritePayload(packet, packet_length);
+}
 
-	NRF24L01_FlushTx();
-	NRF24L01_FlushRx();
-	NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);			// Clear data ready, data sent, and retransmit
-	NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);				// No Auto Acknowldgement on all data pipes
-	NRF24L01_SetBitrate(NRF24L01_BR_1M);					// 1Mbps
-	NRF24L01_SetPower();
-	NRF24L01_Activate(0x73);								// Activate feature register
-	if(sub_protocol == FORMAT_JJRCX1)
+static void __attribute__((unused)) HONTAI_RF_init()
 {
+
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);	// this will select the nrf and initialize it, therefore both sub protocols can use common instructions
+	if(sub_protocol == JJRCX1)
+	{
+		//NRF24L01_Initialize();
+		NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, (uint8_t*)"\xd2\xb5\x99\xb3\x4a", 5);
 		NRF24L01_WriteReg(NRF24L01_04_SETUP_RETR, 0xff);	// JJRC uses dynamic payload length
 		NRF24L01_WriteReg(NRF24L01_1C_DYNPD, 0x3f);			// match other stock settings even though AA disabled...
 		NRF24L01_WriteReg(NRF24L01_1D_FEATURE, 0x07);
+		//NRF24L01_WriteReg(NRF24L01_05_RF_CH, HONTAI_RF_BIND_CHANNEL);
 	}
 	else
 	{
-		NRF24L01_WriteReg(NRF24L01_04_SETUP_RETR, 0x00);	// no retransmits
-		NRF24L01_WriteReg(NRF24L01_1C_DYNPD, 0x00);			// Disable dynamic payload length on all pipes
-		NRF24L01_WriteReg(NRF24L01_1D_FEATURE, 0x00);
+		XN297_SetTXAddr((const uint8_t*)"\xd2\xb5\x99\xb3\x4a", 5);
+		//XN297_HoppingCalib(3);
 	}
-	NRF24L01_Activate(0x73);								// Deactivate feature register
+	XN297_RFChannel(HONTAI_RF_BIND_CHANNEL);
 }
 
 const uint8_t PROGMEM HONTAI_hopping_frequency_nonels[][3] = {
@@ -201,21 +178,21 @@ static void __attribute__((unused)) HONTAI_init2()
 	data_tx_addr[2] = pgm_read_byte_near( &HONTAI_addr_vals[2][ rx_tx_addr[4]       & 0x0f]);
 	data_tx_addr[3] = pgm_read_byte_near( &HONTAI_addr_vals[3][(rx_tx_addr[4] >> 4) & 0x0f]);
 	data_tx_addr[4] = 0x24;
-	if(sub_protocol == FORMAT_JJRCX1)
-		NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, data_tx_addr, sizeof(data_tx_addr));
+	if(sub_protocol == JJRCX1)
+		NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, data_tx_addr, 5);
 	else
-		XN297_SetTXAddr(data_tx_addr, sizeof(data_tx_addr));
+		XN297_SetTXAddr(data_tx_addr, 5);
 
 	//Hopping frequency table
 	for(uint8_t i=0;i<3;i++)
-		hopping_frequency[i]=pgm_read_byte_near( &HONTAI_hopping_frequency_nonels[sub_protocol == FORMAT_JJRCX1?1:0][i] );
+		hopping_frequency[i]=pgm_read_byte_near( &HONTAI_hopping_frequency_nonels[sub_protocol == JJRCX1?1:0][i] );
 	hopping_frequency_no=0;
 }
 
 static void __attribute__((unused)) HONTAI_initialize_txid()
 {
 	rx_tx_addr[4] = rx_tx_addr[2]; 
-	if(sub_protocol == FORMAT_HONTAI || sub_protocol == FORMAT_FQ777_951)
+	if(sub_protocol == HONTAI || sub_protocol == FQ777_951)
 	{
 		rx_tx_addr[0] = 0x4c; // first three bytes some kind of model id? - set same as stock tx
 		rx_tx_addr[1] = 0x4b;
@@ -231,9 +208,11 @@ static void __attribute__((unused)) HONTAI_initialize_txid()
 
 uint16_t HONTAI_callback()
 {
-	if(bind_counter!=0)
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(packet_period);
+	#endif
+	if(bind_counter)
 	{
-		HONTAI_send_packet(1);
 		bind_counter--;
 		if (bind_counter == 0)
 		{
@@ -241,18 +220,16 @@ uint16_t HONTAI_callback()
 			BIND_DONE;
 		}
 	}
-	else
-		HONTAI_send_packet(0);
-
-	return sub_protocol == FORMAT_FQ777_951 ? FQ777_951_PACKET_PERIOD : HONTAI_PACKET_PERIOD;
+	HONTAI_send_packet();
+	return packet_period;
 }
 
-uint16_t initHONTAI()
+void HONTAI_init()
 {
 	BIND_IN_PROGRESS;	// autobind protocol
 	bind_counter = HONTAI_BIND_COUNT;
 	HONTAI_initialize_txid();
-	HONTAI_init();
-	return HONTAI_INITIAL_WAIT;
+	HONTAI_RF_init();
+	packet_period = sub_protocol == FQ777_951 ? FQ777_951_PACKET_PERIOD : HONTAI_PACKET_PERIOD;
 }
 #endif

Multiprotocol/Hubsan_a7105.ino

@@ -20,24 +20,55 @@
 #include "iface_a7105.h"
 
 enum{
-    // flags going to packet[9] (Normal)
+	// flags going to packet[9] (H107)
 	HUBSAN_FLAG_VIDEO= 0x01,   // record video
 	HUBSAN_FLAG_FLIP = 0x08,   // enable flips
 	HUBSAN_FLAG_LED  = 0x04    // enable LEDs
 };
 
 enum{
-    // flags going to packet[9] (Plus series)
+	// flags going to packet[9] (H107 Plus series)
 	HUBSAN_FLAG_HEADLESS = 0x08, // headless mode
 };
 
 enum{
-    // flags going to packet[13] (Plus series)
+	// flags going to packet[9] (H301)
+	FLAG_H301_VIDEO = 0x01,
+	FLAG_H301_STAB  = 0x02,
+	FLAG_H301_LED   = 0x10,
+	FLAG_H301_RTH   = 0x40,
+};
+
+enum{
+	// flags going to packet[13] (H107 Plus series)
 	HUBSAN_FLAG_SNAPSHOT  = 0x01,
 	HUBSAN_FLAG_FLIP_PLUS = 0x80,
 };
 
-uint32_t sessionid,id_data;
+enum{
+	// flags going to packet[9] (H501S)
+	FLAG_H501_VIDEO     = 0x01,
+	FLAG_H501_LED       = 0x04,
+	FLAG_H122D_FLIP     = 0x08,	//H122D
+	FLAG_H501_RTH       = 0x20,
+	FLAG_H501_HEADLESS1 = 0x40,
+	FLAG_H501_GPS_HOLD  = 0x80,
+	};
+
+enum{
+	// flags going to packet[11] (H122D & H123D)
+	FLAG_H123D_FMODES   = 0x03,	//H123D 3 FMODES: Sport mode 1, Sport mode 2, Acro
+	FLAG_H122D_OSD	    = 0x20,	//H122D OSD
+};
+
+enum{
+	// flags going to packet[13] (H501S)
+	FLAG_H501_SNAPSHOT  = 0x01,
+	FLAG_H501_HEADLESS2 = 0x02,
+	FLAG_H501_ALT_HOLD  = 0x08,
+};
+
+uint32_t hubsan_id_data;
 
 enum {
 	BIND_1,
@@ -54,7 +85,7 @@ enum {
 	DATA_4,
 	DATA_5,
 };
-#define WAIT_WRITE 0x80
+#define HUBSAN_WAIT_WRITE 0x80
 
 static void __attribute__((unused)) hubsan_update_crc()
 {
@@ -72,11 +103,11 @@ static void __attribute__((unused)) hubsan_build_bind_packet(uint8_t bind_state)
 	memset(packet, 0, 16);
 	packet[0] = bind_state;
 	packet[1] = channel;
-	packet[2] = (sessionid >> 24) & 0xFF;
-	packet[3] = (sessionid >> 16) & 0xFF;
-	packet[4] = (sessionid >>  8) & 0xFF;
-	packet[5] = (sessionid >>  0) & 0xFF;
-	if(id_data == ID_NORMAL)
+	packet[2] = (MProtocol_id >> 24) & 0xFF;
+	packet[3] = (MProtocol_id >> 16) & 0xFF;
+	packet[4] = (MProtocol_id >>  8) & 0xFF;
+	packet[5] = (MProtocol_id >>  0) & 0xFF;
+	if(hubsan_id_data == ID_NORMAL && sub_protocol != H501)
 	{
 		packet[6] = 0x08;
 		packet[7] = 0xe4;
@@ -108,7 +139,7 @@ static void __attribute__((unused)) hubsan_build_bind_packet(uint8_t bind_state)
 //ii : aileron   observed range: 0x45 - 0xc3 (smaller is right)69-195-50%
 static void __attribute__((unused)) hubsan_build_packet()
 {
-	static uint8_t vtx_freq = 0; 
+	static uint8_t vtx_freq = 0, h501_packet = 0; 
 	memset(packet, 0, 16);
 	if(vtx_freq != option || packet_count==100) // set vTX frequency (H107D)
 	{
@@ -127,8 +158,8 @@ static void __attribute__((unused)) hubsan_build_packet()
 	packet[4] = 0xFF - convert_channel_8b(RUDDER);		//Rudder is reversed
 	packet[6] = 0xFF - convert_channel_8b(ELEVATOR);	//Elevator is reversed
 	packet[8] = convert_channel_8b(AILERON);			//Aileron
-	if(id_data == ID_NORMAL)
-	{
+	if(hubsan_id_data == ID_NORMAL && sub_protocol==H107)
+	{// H107/L/C/D, H102D
 		if( packet_count < 100)
 		{
 			packet[9] = 0x02 | HUBSAN_FLAG_LED | HUBSAN_FLAG_FLIP; // sends default value for the 100 first packets
@@ -138,11 +169,11 @@ static void __attribute__((unused)) hubsan_build_packet()
 		{
 			packet[9] = 0x02;
 			// Channel 5
-			if(Servo_AUX1)	packet[9] |= HUBSAN_FLAG_FLIP;
+			if(CH5_SW)	packet[9] |= HUBSAN_FLAG_FLIP;
 			// Channel 6
-			if(Servo_AUX2)	packet[9] |= HUBSAN_FLAG_LED;
+			if(CH6_SW)	packet[9] |= HUBSAN_FLAG_LED;
 			// Channel 8
-			if(Servo_AUX4)	packet[9] |= HUBSAN_FLAG_VIDEO; // H102D
+			if(CH8_SW)	packet[9] |= HUBSAN_FLAG_VIDEO; // H102D
 		}
 		packet[10] = 0x64;
 		//const uint32_t txid = 0xdb042679; 
@@ -150,22 +181,69 @@ static void __attribute__((unused)) hubsan_build_packet()
 		packet[12] = 0x04;
 		packet[13] = 0x26;
 		packet[14] = 0x79;
+	} else 	if(sub_protocol==H301)
+	{// H301
+		if( packet_count < 100)
+		{
+			packet[9] = FLAG_H301_STAB; // sends default value for the 100 first packets
+			packet_count++;
 		}
 		else
-	{ //ID_PLUS
-		packet[3] = 0x64;
-		packet[5] = 0x64;
-		packet[7] = 0x64;
+		{
+            packet[9] = GET_FLAG(CH6_SW, FLAG_H301_LED)
+                      | GET_FLAG(CH7_SW, FLAG_H301_STAB)
+                      | GET_FLAG(CH8_SW, FLAG_H301_VIDEO)
+                      | GET_FLAG(CH5_SW, FLAG_H301_RTH);
+		}
+		packet[10] = 0x18; // ?
+		packet[12] = 0x5c; // ?
+		packet[14] = 0xf6; // ?
+	}
+	else
+	{ //ID_PLUS && H501
+		packet[3] = sub_protocol==H501 ? 0x00:0x64;
+		packet[5] = sub_protocol==H501 ? 0x00:0x64;
+		packet[7] = sub_protocol==H501 ? 0x00:0x64;
+
+		if(sub_protocol==H501)
+		{ // H501S
+			packet[9] = 0x02
+					   | GET_FLAG(CH6_SW, FLAG_H501_LED)
+					   | GET_FLAG(CH8_SW, FLAG_H501_VIDEO)
+					   | GET_FLAG(CH12_SW, FLAG_H122D_FLIP)	// H122D specific -> flip
+					   | GET_FLAG(CH5_SW, FLAG_H501_RTH)
+					   | GET_FLAG(CH10_SW, FLAG_H501_GPS_HOLD)
+					   | GET_FLAG(CH9_SW, FLAG_H501_HEADLESS1);
+			//packet[10]= 0x1A;
+
+			//packet[11] content 0x00 is default
+			//H123D specific -> Flight modes
+			packet[11] = 0x41;	// Sport mode 1
+			if(Channel_data[CH13]>CHANNEL_MAX_COMMAND)
+				packet[11]=0x43;	// Acro
+			else if(Channel_data[CH13]>CHANNEL_MIN_COMMAND)
+				packet[11]=0x42;	// Sport mode 2
+			//H122D specific -> OSD but useless...
+			//packet[11]|= 0x80
+			//		  | GET_FLAG(CHXX_SW,FLAG_H122D_OSD); 
+
+			packet[13] = GET_FLAG(CH9_SW, FLAG_H501_HEADLESS2)
+					   | GET_FLAG(CH11_SW, FLAG_H501_ALT_HOLD)
+					   | GET_FLAG(CH7_SW, FLAG_H501_SNAPSHOT);
+		}
+		else
+		{ // H107P/C+/D+
 			packet[9] = 0x06;
 			//FLIP|LIGHT|PICTURE|VIDEO|HEADLESS
-		if(Servo_AUX4)	packet[9] |= HUBSAN_FLAG_VIDEO;
-		if(Servo_AUX5)	packet[9] |= HUBSAN_FLAG_HEADLESS;
+			if(CH8_SW)	packet[9] |= HUBSAN_FLAG_VIDEO;
+			if(CH9_SW)	packet[9] |= HUBSAN_FLAG_HEADLESS;
 			packet[10]= 0x19;
 			packet[12]= 0x5C; // ghost channel ?
 			packet[13] = 0;
-		if(Servo_AUX3)	packet[13]  = HUBSAN_FLAG_SNAPSHOT;
-		if(Servo_AUX1)	packet[13] |= HUBSAN_FLAG_FLIP_PLUS;
+			if(CH7_SW)	packet[13]  = HUBSAN_FLAG_SNAPSHOT;
+			if(CH5_SW)	packet[13] |= HUBSAN_FLAG_FLIP_PLUS;
 			packet[14]= 0x49; // ghost channel ?
+		}
 		if(packet_count < 100)
 		{ // set channels to neutral for first 100 packets
 			packet[2] = 0x80; // throttle neutral is at mid stick on plus series
@@ -176,6 +254,21 @@ static void __attribute__((unused)) hubsan_build_packet()
 			packet[13]= 0x00;
 			packet_count++;
 		}
+		if(sub_protocol==H501)
+		{ // H501S
+			h501_packet++;
+			if(h501_packet == 10)
+			{
+				memset(packet, 0, 16);
+				packet[0] = 0xe8;
+			}
+			else if(h501_packet == 20)
+			{
+				memset(packet, 0, 16);
+				packet[0] = 0xe9;
+			}
+			if(h501_packet >= 20) h501_packet = 0;
+		}
 	}
 	hubsan_update_crc();
 }
@@ -192,47 +285,51 @@ static uint8_t __attribute__((unused)) hubsan_check_integrity()
 }
 #endif
 
-uint16_t ReadHubsan() 
+uint16_t HUBSAN_callback() 
 {
 #ifdef HUBSAN_HUB_TELEMETRY
 	static uint8_t rfMode=0;
 #endif
 	static uint8_t txState=0;
-	static uint8_t bind_count=0;
 	uint16_t delay;
 	uint8_t i;
 
-	switch(phase) {
-		case BIND_1:
-			bind_count++;
-			if(bind_count >= 20)
+	#ifndef FORCE_HUBSAN_TUNING
+		A7105_AdjustLOBaseFreq(1);
+	#endif
+	switch(phase)
 	{
-				if(id_data == ID_NORMAL)
-					id_data = ID_PLUS;
+		case BIND_1:
+			bind_phase++;
+			if(bind_phase >= 20 && sub_protocol != H501)
+			{
+				if(hubsan_id_data == ID_NORMAL)
+					hubsan_id_data = ID_PLUS;
 				else
-					id_data = ID_NORMAL;
-				A7105_WriteID(id_data);    
-				bind_count = 0;
+					hubsan_id_data = ID_NORMAL;
+				A7105_WriteID(hubsan_id_data);    
+				bind_phase = 0;
 			}
 		case BIND_3:
 		case BIND_5:
 		case BIND_7:
 			hubsan_build_bind_packet(phase == BIND_7 ? 9 : (phase == BIND_5 ? 1 : phase + 1 - BIND_1));
+			A7105_Strobe(A7105_STANDBY);
 			A7105_WriteData(16, channel);
-			phase |= WAIT_WRITE;
+			phase |= HUBSAN_WAIT_WRITE;
 			return 3000;
-		case BIND_1 | WAIT_WRITE:
-		case BIND_3 | WAIT_WRITE:
-		case BIND_5 | WAIT_WRITE:
-		case BIND_7 | WAIT_WRITE:
+		case BIND_1 | HUBSAN_WAIT_WRITE:
+		case BIND_3 | HUBSAN_WAIT_WRITE:
+		case BIND_5 | HUBSAN_WAIT_WRITE:
+		case BIND_7 | HUBSAN_WAIT_WRITE:
 			//wait for completion
 			for(i = 0; i< 20; i++)
 				if(! (A7105_ReadReg(A7105_00_MODE) & 0x01))
 					break;
 			A7105_SetTxRxMode(RX_EN);
 			A7105_Strobe(A7105_RX);
-			phase &= ~WAIT_WRITE;
-			if(id_data == ID_PLUS)
+			phase &= ~HUBSAN_WAIT_WRITE;
+			if(hubsan_id_data == ID_PLUS)
 			{
 				if(phase == BIND_7 && packet[2] == 9)
 				{
@@ -264,7 +361,7 @@ uint16_t ReadHubsan()
 				return 15000; //22.5msec elapsed since last write
 			}
 			A7105_ReadData(16);
-			if(packet[1] == 9 && id_data == ID_NORMAL) {
+			if(packet[1] == 9 && hubsan_id_data == ID_NORMAL) {
 				phase = DATA_1;
 				A7105_WriteReg(A7105_1F_CODE_I, 0x0F);
 				BIND_DONE;
@@ -279,13 +376,22 @@ uint16_t ReadHubsan()
 		case DATA_4:
 		case DATA_5:
 			if( txState == 0) { // send packet
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(10000);
+			#endif
 #ifdef HUBSAN_HUB_TELEMETRY
 				rfMode = A7105_TX;
 #endif
 				if( phase == DATA_1)
 						A7105_SetPower(); //Keep transmit power in sync
 				hubsan_build_packet();
-				A7105_WriteData(16, phase == DATA_5 && id_data == ID_NORMAL ? channel + 0x23 : channel);
+				A7105_Strobe(A7105_STANDBY);
+				uint8_t ch;
+				if((phase == DATA_5 && hubsan_id_data == ID_NORMAL) && sub_protocol == H107)
+					ch = channel + 0x23;
+				else
+					ch = channel;
+				A7105_WriteData(16, ch);
 				if (phase == DATA_5)
 					phase = DATA_1;
 				else
@@ -340,21 +446,27 @@ uint16_t ReadHubsan()
 	return 0;
 }
 
-uint16_t initHubsan() {
+void HUBSAN_init()
+{
 	const uint8_t allowed_ch[] = {0x14, 0x1e, 0x28, 0x32, 0x3c, 0x46, 0x50, 0x5a, 0x64, 0x6e, 0x78, 0x82};
 	A7105_Init();
 
-	sessionid = random(0xfefefefe) + ((uint32_t)random(0xfefefefe) << 16);
-	channel = allowed_ch[random(0xfefefefe) % sizeof(allowed_ch)];
+	channel = allowed_ch[MProtocol_id % sizeof(allowed_ch)];
+	hubsan_id_data=ID_NORMAL;
 
+	if(IS_BIND_IN_PROGRESS || sub_protocol==H107)
+	{
 		BIND_IN_PROGRESS;	// autobind protocol
 		phase = BIND_1;
+	}
+	else 
+	{
+		phase = DATA_1;
+		A7105_WriteID(MProtocol_id);
+		A7105_WriteReg(A7105_1F_CODE_I, 0x0F);
+	}
 	packet_count=0;
-	id_data=ID_NORMAL;
-#ifdef HUBSAN_HUB_TELEMETRY
-	init_hub_telemetry();
-#endif
-	return 10000;
+	bind_phase=0;
 }
 
 #endif

Multiprotocol/IKEA_Ansluta_cc2500.ino

@@ -0,0 +1,122 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// This module makes it possible to bind to and control the IKEA "Ansluta" line
+// of remote-controlled lights.
+// To bind, first switch the receiver into binding mode, then the TX.
+// Once bound, the TX can send one of three commands:
+//   lights off, lights dimmed 50% and lights on.
+// Those are mapped to throttle ranges 0..0x55, 0x56..0xAA, 0xAB..0xFF.
+#if defined(IKEAANSLUTA_CC2500_INO)
+
+#include "iface_cc2500.h"
+
+#define IKEAANSLUTA_BIND_COUNT	30  // ~ 2sec autobind/65ms per loop = 30 binding packets
+
+// Commands
+#define IKEAANSLUTA_LIGHT_OFF 0x01
+#define IKEAANSLUTA_LIGHT_DIM 0x02  // 50% dimmed light
+#define IKEAANSLUTA_LIGHT_ON  0x03
+#define IKEAANSLUTA_PAIR 0xFF
+
+void IKEAANSLUTA_send_command(uint8_t command){
+      CC2500_Strobe(CC2500_SIDLE);
+      packet[4] = option;
+      packet[5] = command;
+      CC2500_WriteData(packet, 8);
+}
+
+uint16_t IKEAANSLUTA_callback(void)
+{
+    if (bind_counter) {
+        IKEAANSLUTA_send_command(IKEAANSLUTA_PAIR);
+        if(--bind_counter == 0) {
+            BIND_DONE;
+            CC2500_SetPower();
+        }
+    }
+    else {
+        uint8_t throttle = convert_channel_8b(THROTTLE);
+        uint8_t cmd = throttle <= 0x55 ? IKEAANSLUTA_LIGHT_OFF : 
+                      throttle <= 0xAA ? IKEAANSLUTA_LIGHT_DIM :
+                      IKEAANSLUTA_LIGHT_ON;
+        IKEAANSLUTA_send_command(cmd);
+    }
+    return 65535; // 65ms loop cycle is more than enough here (we could make it even longer if not for uint16_t)
+}
+
+// Register initialization values as a continuous memory block (to save on flash memory)
+const PROGMEM uint8_t IKEAANSLUTA_init_values[] = {
+  0xFF, // CC2500_06_PKTLEN
+  0x04, // CC2500_07_PKTCTRL1
+  0x05, // CC2500_08_PKTCTRL0
+  0x00, // CC2500_09_ADDR  (unused, default)
+  0x10, // CC2500_0A_CHANNR
+  0x09, // CC2500_0B_FSCTRL1
+  0x00, // CC2500_0C_FSCTRL0
+  0x5D, // CC2500_0D_FREQ2
+  0x93, // CC2500_0E_FREQ1
+  0xB1, // CC2500_0F_FREQ0
+  0x2D, // CC2500_10_MDMCFG4
+  0x3B, // CC2500_11_MDMCFG3
+  0x73, // CC2500_12_MDMCFG2
+  0xA2, // CC2500_13_MDMCFG1
+  0xF8, // CC2500_14_MDMCFG0
+  0x01, // CC2500_15_DEVIATN
+  0x07, // CC2500_16_MCSM2
+  0x30, // CC2500_17_MCSM1
+  0x18, // CC2500_18_MCSM0
+  0x1D, // CC2500_19_FOCCFG
+  0x1C, // CC2500_1A_BSCFG
+  0xC7, // CC2500_1B_AGCCTRL2
+  0x00, // CC2500_1C_AGCCTRL1
+  0xB2, // CC2500_1D_AGCCTRL0
+  0x87, // CC2500_1E_WOREVT1 (unused, default)
+  0x6b, // CC2500_1F_WOREVT0 (unused, default)
+  0xf8, // CC2500_20_WORCTRL (unused, default)
+  0xB6, // CC2500_21_FREND1
+  0x10, // CC2500_22_FREND0
+  0xEA, // CC2500_23_FSCAL3
+  0x0A, // CC2500_24_FSCAL2
+  0x00, // CC2500_25_FSCAL1
+  0x11, // CC2500_26_FSCAL0
+  0x41, // CC2500_27_RCCTRL1
+  0x00, // CC2500_28_RCCTRL0
+};
+
+void IKEAANSLUTA_init(void)
+{
+    if (IS_BIND_DONE) bind_counter = 0;
+    else bind_counter = IKEAANSLUTA_BIND_COUNT;
+
+    // All packets we send are the same
+    packet[0] = 0x06;
+    packet[1] = 0x55;
+    packet[2] = 0x01;
+    // Bytes 3&4 are the transmitter address (to which the RX binds)
+    // Byte 5 is the command.
+    packet[3] = rx_tx_addr[3];  // <pseudorandom tx-fixed value> + <rx_num>
+    // packet[4] = option;
+    // packet[5] = 0x00; // Command goes here
+    packet[6] = 0xAA;
+    packet[7] = 0xFF;
+
+    // Configure & initialize CC2500
+	for (uint8_t i = 0; i <= CC2500_28_RCCTRL0-CC2500_06_PKTLEN; ++i)
+		CC2500_WriteReg(CC2500_06_PKTLEN+i, pgm_read_byte_near(&IKEAANSLUTA_init_values[i]));    
+    CC2500_SetTxRxMode(TX_EN);
+    CC2500_SetPower();
+}
+
+#endif

Multiprotocol/J6Pro_cyrf6936.ino

@@ -59,7 +59,7 @@ static void __attribute__((unused)) j6pro_build_data_packet()
     packet[0] = 0xaa; //FIXME what is this?
     for (i = 0; i < 12; i++)
     {
-        value = convert_channel_10b(CH_AETR[i]);
+        value = convert_channel_10b(CH_AETR[i], false);
         packet[i+1] = value & 0xff;
         upperbits |= (value >> 8) << (i * 2);
     }
@@ -111,7 +111,7 @@ static void __attribute__((unused)) cyrf_datainit()
 {
     /* Use when already bound */
     uint8_t sop_idx = (0xff & (cyrfmfg_id[0] + cyrfmfg_id[1] + cyrfmfg_id[2] + cyrfmfg_id[3] - cyrfmfg_id[5])) % 19;
-    uint16_t crc =  (0xff & (cyrfmfg_id[1] - cyrfmfg_id[4] + cyrfmfg_id[5])) |
+    crc =  (0xff & (cyrfmfg_id[1] - cyrfmfg_id[4] + cyrfmfg_id[5])) |
            ((0xff & (cyrfmfg_id[2] + cyrfmfg_id[3] - cyrfmfg_id[4] + cyrfmfg_id[5])) << 8);
     //CYRF_WriteRegister(CYRF_0F_XACT_CFG, 0x24);
     CYRF_PROGMEM_ConfigSOPCode(DEVO_j6pro_sopcodes[sop_idx]);
@@ -126,9 +126,9 @@ static void __attribute__((unused)) j6pro_set_radio_channels()
     hopping_frequency[3] = hopping_frequency[0];
 }
 
-uint16_t ReadJ6Pro()
+uint16_t J6PRO_callback()
 {
-    uint32_t start;
+    uint16_t start;
 
     switch(phase)
     {
@@ -144,10 +144,10 @@ uint16_t ReadJ6Pro()
             phase = J6PRO_BIND_03_START;
             return 3000; //3msec
         case J6PRO_BIND_03_START:
-            start=micros();
-            while (micros()-start < 500)				// Wait max 500µs
-                if(CYRF_ReadRegister(CYRF_04_TX_IRQ_STATUS) & 0x06)
-                    break;
+            start=(uint16_t)micros();
+            while ((uint16_t)((uint16_t)micros()-(uint16_t)start) < 500)				// Wait max 500µs
+				if((CYRF_ReadRegister(CYRF_02_TX_CTRL) & 0x80) == 0x00)
+					break;										// Packet transmission complete
 			CYRF_ConfigRFChannel(0x53);
             CYRF_SetTxRxMode(RX_EN);
             //CYRF_WriteRegister(CYRF_06_RX_CFG, 0x4a);
@@ -201,6 +201,9 @@ uint16_t ReadJ6Pro()
             cyrf_datainit();
             phase = J6PRO_CHAN_1;
         case J6PRO_CHAN_1:
+			#ifdef MULTI_SYNC
+                telemetry_set_input_sync(24550);
+			#endif
 			//Keep transmit power updated
             CYRF_SetPower(0x28);
             j6pro_build_data_packet();
@@ -223,15 +226,14 @@ uint16_t ReadJ6Pro()
     return 0;
 }
 
-uint16_t initJ6Pro()
+void J6PRO_init()
 {
     j6pro_cyrf_init();
 
-	if(IS_AUTOBIND_FLAG_on)
+	if(IS_BIND_IN_PROGRESS)
         phase = J6PRO_BIND;
     else
         phase = J6PRO_CHANSEL;
-    return 2400;
 }
 
 #endif

Multiprotocol/JJRC345_nrf24l01.ino

@@ -0,0 +1,183 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// compatible with JJRC345
+
+#if defined(JJRC345_NRF24L01_INO)
+
+#include "iface_xn297.h"
+
+//#define JJRC345_FORCE_ID
+
+#define JJRC345_PACKET_PERIOD		7450 // Timeout for callback in uSec
+#define JJRC345_INITIAL_WAIT		500
+#define JJRC345_PACKET_SIZE			16
+#define JJRC345_RF_BIND_CHANNEL		5
+#define SKYTMBLR_RF_BIND_CHANNEL	40
+#define JJRC345_BIND_COUNT			500
+#define JJRC345_NUM_CHANNELS		4
+
+
+enum JJRC345_FLAGS {
+    // flags going to packet[8]
+	JJRC345_FLAG_HEADLESS	= 0x40,
+	JJRC345_FLAG_RTH		= 0x80,
+    // flags going to packet[9]
+	SKYTMBLR_FLAG_UNK1	    = 0x40,
+	SKYTMBLR_FLAG_UNK2	    = 0x80,
+    // flags going to packet[10]
+	SKYTMBLR_FLAG_LED	    = 0x40,
+	SKYTMBLR_FLAG_UNK3	    = 0x80,
+};
+
+static uint8_t __attribute__((unused)) JJRC345_convert_channel(uint8_t num)
+{
+	uint8_t val=convert_channel_8b(num);
+	// 7E..60..41..01, 80 center, 81..C1..E0..FE
+	if(val<0x80)
+	{
+		val=0x80-val;	// 80..01
+		if(val>0x7E)
+			val=0x7E;	// 7E..01
+	}
+	else if(val>0xFE)
+		val=0xFE;			// 81..FE
+	return val;
+}
+
+static void __attribute__((unused)) JJRC345_send_packet()
+{
+	packet[0] = 0x00;
+	packet[2] = 0x00;
+	if (IS_BIND_IN_PROGRESS)
+	{ //00 05 00 0A 46 4A 41 47 00 00 40 46 A5 4A F1 18
+		packet[1]  = (sub_protocol == JJRC345 ? JJRC345_RF_BIND_CHANNEL:SKYTMBLR_RF_BIND_CHANNEL);
+		packet[4]  = hopping_frequency[0];
+		packet[5]  = hopping_frequency[1];
+		packet[6]  = hopping_frequency[2];
+		packet[7]  = hopping_frequency[3];
+		packet[12] = 0xa5;
+	}
+	else
+	{ //00 41 00 0A 00 80 80 80 00 00 40 46 00 49 F1 18
+		XN297_Hopping(hopping_frequency_no);
+		hopping_frequency_no++;
+		hopping_frequency_no %= JJRC345_NUM_CHANNELS;
+		packet[1]  = hopping_frequency[hopping_frequency_no];	// next packet will be sent on this channel
+
+		packet[4]  = convert_channel_8b(THROTTLE);				// throttle: 00..FF
+		packet[5]  = JJRC345_convert_channel(RUDDER);			// rudder: 70..60..41..01, 80 center, 81..C1..E0..F0
+		packet[6]  = JJRC345_convert_channel(ELEVATOR);			// elevator: 70..60..41..01, 80 center, 81..C1..E0..F0
+		packet[7]  = JJRC345_convert_channel(AILERON);			// aileron: 70..60..41..01, 80 center, 81..C1..E0..F0
+
+		if(CH5_SW)	//Flip
+		{
+			if(packet[6]>0xF0)
+				packet[6]=0xFF;
+			else if(packet[6]<0x80 && packet[6]>0x70)
+				packet[6]=0x7F;
+			if(packet[7]>0xF0)
+				packet[7]=0xFF;
+			else if(packet[7]<0x80 && packet[7]>0x70)
+				packet[7]=0x7F;
+		}
+		
+		packet[12] = 0x02;										// Rate: 00-01-02
+	}
+
+	packet[3] = 0x00;											// Checksum upper bits
+
+	packet[8] = 0x00											// Rudder trim, 00 when not used, 01..1F when trimmed left, 20..3F
+				| GET_FLAG(CH6_SW ,JJRC345_FLAG_HEADLESS)		// 0x40 HeadLess
+				| GET_FLAG(CH7_SW ,JJRC345_FLAG_RTH);			// 0x80 RTH
+	packet[9] = 0x00												// Elevator trim, 00 when not used, 20..25 when trimmed up, 0..1F when trimmed down
+				| GET_FLAG(CH9_SW ,SKYTMBLR_FLAG_UNK1)			// 0x40 Unknown
+				| GET_FLAG(CH10_SW,SKYTMBLR_FLAG_UNK2);			// 0x80 Unknown
+	packet[10] = 0x00											// Aileron  trim, 00 when not used, 00..1F when trimmed left, 21..3F when trimmed right
+				| GET_FLAG(!CH8_SW,SKYTMBLR_FLAG_LED)			// 0x40 LED
+				| GET_FLAG(CH11_SW,SKYTMBLR_FLAG_UNK3);			// 0x80 Unknown
+
+	packet[11] = hopping_frequency[0];							// First hopping frequency
+
+	// Checksum
+	uint16_t sum=2;
+	for (uint8_t i = 0; i < 13; i++)
+		sum += packet[i];
+	packet[13]=sum;
+	packet[3]=((sum>>8)<<2)+2;
+	
+	// TX ID
+	packet[14] = rx_tx_addr[2];
+	packet[15] = rx_tx_addr[3];
+
+	// Send
+	XN297_SetPower();
+	XN297_SetTxRxMode(TX_EN);
+	XN297_WritePayload(packet, JJRC345_PACKET_SIZE);
+}
+
+static void __attribute__((unused)) JJRC345_RF_init()
+{
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
+    XN297_SetTXAddr((uint8_t*)"\xcc\xcc\xcc\xcc\xcc", 5);
+	//XN297_HoppingCalib(JJRC345_NUM_CHANNELS);
+	XN297_RFChannel(sub_protocol == JJRC345 ? JJRC345_RF_BIND_CHANNEL:SKYTMBLR_RF_BIND_CHANNEL);	// Bind channel
+}
+
+uint16_t JJRC345_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(JJRC345_PACKET_PERIOD);
+	#endif
+	if(bind_counter)
+	{
+		bind_counter--;
+		if (bind_counter==0)
+			BIND_DONE;
+	}
+	JJRC345_send_packet();
+	return	JJRC345_PACKET_PERIOD;
+}
+
+static void __attribute__((unused)) JJRC345_initialize_txid()
+{
+	calc_fh_channels(JJRC345_NUM_CHANNELS);
+	
+	#ifdef JJRC345_FORCE_ID
+		//TX 1
+		rx_tx_addr[2]=0x1B;
+		rx_tx_addr[3]=0x12;
+        hopping_frequency[0] = 0x3f;
+        hopping_frequency[1] = 0x49;
+        hopping_frequency[2] = 0x47;
+        hopping_frequency[3] = 0x47;
+		//TX 2
+		rx_tx_addr[2]=0xF1;
+		rx_tx_addr[3]=0x18;
+        hopping_frequency[0] = 0x46;
+        hopping_frequency[1] = 0x4A;
+        hopping_frequency[2] = 0x41;
+        hopping_frequency[3] = 0x47;
+	#endif
+}
+
+void JJRC345_init(void)
+{
+	BIND_IN_PROGRESS;	// autobind protocol
+    bind_counter = JJRC345_BIND_COUNT;
+	JJRC345_initialize_txid();
+	JJRC345_RF_init();
+}
+
+#endif

Multiprotocol/Joysway_a7105.ino

@@ -0,0 +1,115 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(JOYSWAY_A7105_INO)
+
+#include "iface_a7105.h"
+
+//#define JOYSWAY_FORCE_ID
+
+static void __attribute__((unused)) JOYSWAY_send_packet()
+{
+	static uint8_t next_ch = 0x30;
+	
+	//RF frequency
+	if (packet_count == 254)
+	{
+		packet_count = 0;
+		A7105_WriteID(0x5475c52a);
+		rf_ch_num = 0x0a;
+	}
+	else if (packet_count == 2)
+	{
+		A7105_WriteID(MProtocol_id);
+		rf_ch_num = 0x30;
+	}
+	else
+	{
+		if (packet_count & 0x01)
+			rf_ch_num = 0x30;
+		else
+			rf_ch_num = next_ch;
+	}
+	if (! (packet_count & 0x01))
+	{
+		next_ch++;
+		if (next_ch >= 0x45)
+			next_ch = 0x30;
+	}
+
+	//Payload
+	packet[0] = packet_count == 0 ? 0xdd : 0xff;
+	//ID
+	packet[1] = rx_tx_addr[0];
+	packet[2] = rx_tx_addr[1];
+	packet[3] = rx_tx_addr[2];
+	packet[4] = rx_tx_addr[3];
+	packet[5] = 0x00;
+	//Channels
+	for (uint8_t i = 0; i < 4; i++)
+		packet[ 6 + (i & 0x01) + ((i & 0x02)<<1)] = convert_channel_16b_limit(i, 0x00, 0xCC);
+	packet[8] = 0x64;
+	packet[9] = 0x64;
+	packet[12] = 0x64;
+	packet[13] = 0x64;
+	packet[14] = packet_count == 0 ? 0x30 : 0xaa;
+	//Check
+	uint8_t value = 0;
+	for (uint8_t i = 0; i < 15; i++)
+		value += packet[i];
+	packet[15] = value;
+
+	//Send
+	#if 0
+		debug("ch=%02X P=",rf_ch_num);
+		for(uint8_t i=0; i<16; i++)
+			debug("%02X ", packet[i]);
+		debugln("");
+	#endif
+	A7105_WriteData(16, rf_ch_num);
+	A7105_SetPower();
+	packet_count++;
+}
+
+uint16_t JOYSWAY_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(6000);
+	#endif
+	#ifndef FORCE_JOYSWAY_TUNING
+		A7105_AdjustLOBaseFreq(1);
+	#endif
+
+	JOYSWAY_send_packet();
+	return 6000;
+}
+
+void JOYSWAY_init()
+{
+	BIND_DONE;		// not a bind protocol
+
+	MProtocol_id &= 0x00FFFFFF;
+	MProtocol_id |= 0xF8000000;
+	#ifdef JOYSWAY_FORCE_ID
+		MProtocol_id = 0xf82dcaa0;
+	#endif
+
+	set_rx_tx_addr(MProtocol_id);
+
+	A7105_Init();
+	
+	packet_count = 2;
+}
+#endif

Multiprotocol/KF606_ccnrf.ino

@@ -0,0 +1,155 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// Compatible with KF606 plane.
+
+#if defined(KF606_CCNRF_INO)
+
+#include "iface_xn297.h"
+
+//#define FORCE_KF606_ORIGINAL_ID
+//#define FORCE_MIG320_ORIGINAL_ID
+
+#define KF606_INITIAL_WAIT    500
+#define KF606_PACKET_PERIOD   3000
+#define KF606_RF_BIND_CHANNEL 7
+#define KF606_PAYLOAD_SIZE    4
+#define KF606_BIND_COUNT	  857	//3sec
+#define KF606_RF_NUM_CHANNELS 2
+
+static void __attribute__((unused)) KF606_send_packet()
+{
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[0] = 0xAA;
+		memcpy(&packet[1],rx_tx_addr,3);
+	}
+	else
+	{
+		XN297_Hopping(hopping_frequency_no);
+		hopping_frequency_no ^= 1;			// 2 RF channels
+
+		packet[0] = 0x55;
+		packet[1] = convert_channel_8b(THROTTLE);					// 0..255
+		// Deadband is needed on aileron, 40 gives +-6%
+		if(sub_protocol == KF606_KF606)
+		{
+			packet[2] = convert_channel_8b_limit_deadband(AILERON,0x20,0x80,0xE0,40);	// Aileron: Max values:20..80..E0, Low rates:50..80..AF, High rates:3E..80..C1
+			packet[3] = convert_channel_16b_limit(CH5,0xC1,0xDF);						// Aileron trim must be on a separated channel C1..D0..DF
+		}
+		else
+		{
+			packet[2] = convert_channel_8b_limit_deadband(AILERON,0x00,0x80,0xFF,40);	// Aileron: High rate:2B..80..DA
+			packet[3] = convert_channel_16b_limit(CH5,0x01,0x1F);						// Aileron trim must be on a separated channel 01..10..1F
+			packet[3] += (packet[2]-0x80)>>3;											// Drive trims for more aileron authority
+			if(packet[3] > 0x80)
+				packet[3] = 0x01;
+			else if(packet[3] > 0x1F)
+				packet[3] = 0x1F;
+			packet[3] |= GET_FLAG(CH6_SW, 0xC0);										// 0xC0 and 0xE0 are both turning the LED off, not sure if there is another hidden feature
+		}
+	}
+
+	uint8_t len = KF606_PAYLOAD_SIZE;
+	if(sub_protocol == KF606_MIG320)
+	{
+		len++;
+		packet[4] = 0;	// additional channel?
+	}
+
+	#if 0
+		for(uint8_t i=0; i<len; i++)
+			debug("%02X ",packet[i]);
+		debugln("");
+	#endif
+
+	// Send
+	XN297_SetPower();
+	XN297_SetFreqOffset();
+	XN297_SetTxRxMode(TX_EN);
+	XN297_WritePayload(packet, len);
+}
+
+static void __attribute__((unused)) KF606_initialize_txid()
+{
+	rx_tx_addr[0]=rx_tx_addr[3];	// Use RX_num;
+	hopping_frequency[0]=(rx_tx_addr[0]&0x3F)+9;
+	hopping_frequency[1]=hopping_frequency[0]+3;
+	#ifdef FORCE_KF606_ORIGINAL_ID
+		//TX1
+		rx_tx_addr[0]=0x57;
+		rx_tx_addr[1]=0x02;
+		rx_tx_addr[2]=0x00;
+		hopping_frequency[0]=0x20;
+		hopping_frequency[1]=0x23;
+		//TX2
+		rx_tx_addr[0]=0x25;
+		rx_tx_addr[1]=0x04;
+		rx_tx_addr[2]=0x00;
+		hopping_frequency[0]=0x2E;
+		hopping_frequency[1]=0x31;
+	#endif
+	#ifdef FORCE_MIG320_ORIGINAL_ID
+		rx_tx_addr[0]=0xBB;
+		rx_tx_addr[1]=0x13;
+		rx_tx_addr[2]=0x00;
+		hopping_frequency[0]=68;
+		hopping_frequency[1]=71;
+	#endif
+}
+
+static void __attribute__((unused)) KF606_RF_init()
+{
+	XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_250K);
+	XN297_SetTXAddr((uint8_t*)"\xe7\xe7\xe7\xe7\xe7", 5);
+	XN297_HoppingCalib(KF606_RF_NUM_CHANNELS);					// Calibrate all channels
+	XN297_RFChannel(KF606_RF_BIND_CHANNEL);						// Set bind channel
+}
+
+uint16_t KF606_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(KF606_PACKET_PERIOD);
+	#endif
+	if(bind_counter)
+		if(--bind_counter==0)
+		{
+			BIND_DONE;
+			XN297_SetTXAddr(rx_tx_addr, 3);
+		}
+	KF606_send_packet();
+	return KF606_PACKET_PERIOD;
+}
+
+void KF606_init()
+{
+	BIND_IN_PROGRESS;	// autobind protocol
+	KF606_initialize_txid();
+	KF606_RF_init();
+	hopping_frequency_no = 0;
+	bind_counter=KF606_BIND_COUNT;
+}
+
+#endif
+
+// MIG320 protocol
+// Bind
+// 250K C=7 S=Y A= E7 E7 E7 E7 E7 P(5)= AA BB 13 00 00
+// 3ms on ch7
+// Normal
+// 250K C=68 S=Y A= BB 13 00 P(5)= 55 00 80 10 00
+// P[1] = THR 00..FF
+// P[2] = AIL 2B..80..DA
+// P[3] = TRIM 01..10..1F
+// channels 68=BB&3F+9 and 71

Multiprotocol/KN_nrf24l01.ino

@@ -125,32 +125,32 @@ static void __attribute__((unused)) kn_bind_init()
 static void __attribute__((unused)) kn_update_packet_control_data()
 {
 	uint16_t value;
-	value = convert_channel_10b(THROTTLE);
+	value = convert_channel_10b(THROTTLE, false);
 	packet[0]  = (value >> 8) & 0xFF;
 	packet[1]  = value & 0xFF;
-	value = convert_channel_10b(AILERON);
+	value = convert_channel_10b(AILERON, false);
 	packet[2]  = (value >> 8) & 0xFF;
 	packet[3]  = value & 0xFF;
-	value = convert_channel_10b(ELEVATOR);
+	value = convert_channel_10b(ELEVATOR, false);
 	packet[4]  = (value >> 8) & 0xFF;
 	packet[5]  = value & 0xFF;
-	value = convert_channel_10b(RUDDER);
+	value = convert_channel_10b(RUDDER, false);
 	packet[6]  = (value >> 8) & 0xFF;
 	packet[7]  = value & 0xFF;
 	// Trims, middle is 0x64 (100) range 0-200
-	packet[8]  = convert_channel_8b_scale(AUX5,0,200); // 0x64; // T
-	packet[9]  = convert_channel_8b_scale(AUX6,0,200); // 0x64; // A
-	packet[10] = convert_channel_8b_scale(AUX7,0,200); // 0x64; // E
+	packet[8]  = convert_channel_16b_limit(CH9,0,200); // 0x64; // T
+	packet[9]  = convert_channel_16b_limit(CH10,0,200); // 0x64; // A
+	packet[10] = convert_channel_16b_limit(CH11,0,200); // 0x64; // E
 	packet[11] = 0x64; // R
 
 	flags=0;
-	if (Servo_AUX1)
+	if (CH5_SW)
 		flags = KN_FLAG_DR;
-	if (Servo_AUX2)
+	if (CH6_SW)
 		flags |= KN_FLAG_TH;
-	if (Servo_AUX3)
+	if (CH7_SW)
 		flags |= KN_FLAG_IDLEUP;
-	if (Servo_AUX4)
+	if (CH8_SW)
 		flags |= KN_FLAG_GYRO3;
 
 	packet[12] = flags;
@@ -239,60 +239,45 @@ static void __attribute__((unused)) kn_calculate_freqency_hopping_channels()
 // V977 needs payload length in the packet. We should configure 24L01 to enable Packet Control Field(PCF)
 //   Some RX reg settings are actually for enable PCF
 //-------------------------------------------------------------------------------------------------
-static void __attribute__((unused)) kn_init()
+static void __attribute__((unused)) KN_RF_init()
 {
 	kn_calculate_tx_addr();
 	kn_calculate_freqency_hopping_channels();
 
 	NRF24L01_Initialize();
 
-	NRF24L01_WriteReg(NRF24L01_00_CONFIG, _BV(NRF24L01_00_EN_CRC) | _BV(NRF24L01_00_CRCO)); 
-	NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x00);      // No Auto Acknoledgement
-	NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x01);  // Enable data pipe 0
-	NRF24L01_WriteReg(NRF24L01_03_SETUP_AW, 0x03);   // 5-byte RX/TX address
-	NRF24L01_WriteReg(NRF24L01_04_SETUP_RETR, 0);    // Disable retransmit
-	NRF24L01_SetPower();
-	NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);     // Clear data ready, data sent, and retransmit
 	NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, 0x20);   // bytes of data payload for pipe 0
-
-
-	NRF24L01_Activate(0x73);
 	NRF24L01_WriteReg(NRF24L01_1C_DYNPD, 1); // Dynamic payload for data pipe 0
 	// Enable: Dynamic Payload Length to enable PCF
 	NRF24L01_WriteReg(NRF24L01_1D_FEATURE, _BV(NRF2401_1D_EN_DPL));
 
-	NRF24L01_SetPower();
-
-	NRF24L01_FlushTx();
-	// Turn radio power on
-	NRF24L01_SetTxRxMode(TX_EN);
-	NRF24L01_SetBitrate(NRF24L01_BR_1M);	//USE1MBPS_YES ? NRF24L01_BR_1M : NRF24L01_BR_250K;
+	NRF24L01_SetTxRxMode(TX_EN);						// Clear data ready, data sent, retransmit and enable CRC 16bits, ready for TX
 }
   
 //================================================================================================
 // Private Functions
 //================================================================================================
-uint16_t initKN()
+void KN_init()
 {
 	if(sub_protocol==WLTOYS)
 	{
 		packet_period = KN_WL_SENDING_PACKET_PERIOD;
 		bind_counter  = KN_WL_BIND_COUNT;
 		packet_count  = KN_WL_PACKET_SEND_COUNT;
+		seed = KN_WL_PACKET_SEND_COUNT * KN_WL_SENDING_PACKET_PERIOD;
 	}
 	else
 	{
 		packet_period = KN_FX_SENDING_PACKET_PERIOD;
 		bind_counter  = KN_FX_BIND_COUNT;
 		packet_count  = KN_FX_PACKET_SEND_COUNT;
+		seed = KN_FX_PACKET_SEND_COUNT * KN_FX_SENDING_PACKET_PERIOD;
 	}
-	kn_init();
-	phase = IS_AUTOBIND_FLAG_on ? KN_PHASE_PRE_BIND : KN_PHASE_PRE_SEND;
-
-	return KN_INIT_WAIT_MS;
+	KN_RF_init();
+	phase = IS_BIND_IN_PROGRESS ? KN_PHASE_PRE_BIND : KN_PHASE_PRE_SEND;
 }
 
-uint16_t kn_callback()
+uint16_t KN_callback()
 {
 	switch (phase)
 	{
@@ -318,6 +303,9 @@ uint16_t kn_callback()
 		case KN_PHASE_SENDING:
 			if(packet_sent >= packet_count)
 			{
+				#ifdef MULTI_SYNC
+					telemetry_set_input_sync(seed);
+				#endif
 				packet_sent = 0;
 				hopping_frequency_no++;
 				if(hopping_frequency_no >= KN_RF_CH_COUNT) hopping_frequency_no = 0;

Multiprotocol/Kyosho2_nrf24l01.ino

@@ -0,0 +1,137 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(KYOSHO2_NRF24L01_INO)
+
+#include "iface_nrf24l01.h"
+
+#define KYOSHO2_PACKET_PERIOD			1120	// 1600 for bind, let's see
+#define KYOSHO2_BIND_COUNT				2000	// about 3sec
+#define KYOSHO2_BIND_CHANNEL			0x50
+#define KYOSHO2_PAYLOAD_SIZE			28
+#define KYOSHO2_RF_CHANNELS				15
+#define KYOSHO2_START_RF_CHANNEL		0x13	// No idea where it comes from... ID or unknown bytes during the bind?
+#define KYOSHO2_NUM_CHANNEL				10		// Only 4 on the dumps but there is space for 10 channels in the payload...
+
+#define FORCE_KYOSHO2_ID
+
+bool KYOSHO2_resend;
+//
+static void __attribute__((unused)) KYOSHO2_send_packet()
+{
+	if(KYOSHO2_resend == true)
+	{
+		NRF24L01_Strobe(NRF24L01_E3_REUSE_TX_PL);
+		if(IS_BIND_DONE)
+			KYOSHO2_resend = false;
+		return;
+	}
+	
+	memset(packet,0x00,KYOSHO2_PAYLOAD_SIZE);
+	
+	if(IS_BIND_IN_PROGRESS)
+	{
+		memcpy(packet, (uint8_t*)"\x01\x02\x05\x08\x1A\x2B\x3C\x4D", 8);	// unknown bytes, parameters on how to build the rf channels?
+		memcpy(&packet[8], rx_tx_addr, 4);
+	}
+	else
+	{
+		memcpy(packet, rx_tx_addr, 4);
+		//Hopp
+		packet[6] = hopping_frequency_no + KYOSHO2_START_RF_CHANNEL;
+		packet[7] = hopping_frequency[hopping_frequency_no];
+		NRF24L01_WriteReg(NRF24L01_05_RF_CH, packet[6+(rf_ch_num&0x01)]);
+		rf_ch_num++;
+		//Channels
+		uint16_t temp;
+		for (uint8_t i = 0; i< KYOSHO2_NUM_CHANNEL; i++)
+		{
+			temp=convert_channel_16b_limit(i,0,0x3FF);
+			packet[8+i*2] = temp >> 8;
+			packet[9+i*2] = temp;
+		}
+	}
+	//Send
+    NRF24L01_WriteReg(NRF24L01_07_STATUS, (_BV(NRF24L01_07_TX_DS) | _BV(NRF24L01_07_MAX_RT)));	// Reset flags
+    NRF24L01_FlushTx();
+	NRF24L01_WritePayload(packet,KYOSHO2_PAYLOAD_SIZE);
+	NRF24L01_SetPower();
+	KYOSHO2_resend = true;
+	
+	#if 0
+		for(uint8_t i=0;i<KYOSHO2_PAYLOAD_SIZE;i++)
+			debug("%02X ", packet[i]);
+		debugln("");
+	#endif
+}
+
+static void __attribute__((unused)) KYOSHO2_RF_init()
+{
+	NRF24L01_Initialize();
+	NRF24L01_WriteReg(NRF24L01_05_RF_CH, KYOSHO2_BIND_CHANNEL);
+	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, (uint8_t*)"\x69\x53\x10\xAC\xEF", 5);
+}
+
+static void __attribute__((unused)) KYOSHO2_initialize_tx_id()
+{
+	hopping_frequency_no = rx_tx_addr[3]%KYOSHO2_RF_CHANNELS;
+	hopping_frequency[0] = 0x4A;
+	#ifdef FORCE_KYOSHO2_ID
+		memcpy(rx_tx_addr, (uint8_t*)"\x0A\xBD\x31\xDF", 4);
+		hopping_frequency[0] = 0x4A;						// No idea where it comes from... ID or unknown bytes during the bind?
+	#endif
+	for(uint8_t i=1;i<KYOSHO2_RF_CHANNELS;i++)
+	{
+		if(hopping_frequency[i-1]+5 < 0x50)
+			hopping_frequency[i] = hopping_frequency[i-1]+5;
+		else
+			hopping_frequency[i] = hopping_frequency[i-1]-0x21;
+	}
+	#if 0
+		for(uint8_t i=0;i<KYOSHO2_RF_CHANNELS;i++)
+			debugln("1:%02X, 2: %02X", i + KYOSHO2_START_RF_CHANNEL, hopping_frequency[i]);
+		debugln("Selected 1:%02X, 2: %02X", hopping_frequency_no + KYOSHO2_START_RF_CHANNEL, hopping_frequency[hopping_frequency_no]);
+	#endif
+}
+
+uint16_t KYOSHO2_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(KYOSHO2_PACKET_PERIOD);
+	#endif
+	if(bind_counter)
+		if(--bind_counter==0)
+		{
+			BIND_DONE;
+			KYOSHO2_resend = false;
+		}
+	KYOSHO2_send_packet();
+	return KYOSHO2_PACKET_PERIOD;
+}
+
+void KYOSHO2_init()
+{
+	KYOSHO2_initialize_tx_id();
+	KYOSHO2_RF_init();
+	rf_ch_num = 0;
+
+	if(IS_BIND_IN_PROGRESS)
+		bind_counter = KYOSHO2_BIND_COUNT;
+	else 
+		bind_counter = 0;
+	KYOSHO2_resend = false;
+}
+
+#endif

Multiprotocol/Kyosho_a7105.ino

@@ -0,0 +1,201 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(KYOSHO_A7105_INO)
+
+#include "iface_a7105.h"
+
+//#define KYOSHO_FORCE_ID_FHSS
+//#define KYOSHO_FORCE_ID_HYPE
+
+//Kyosho constants & variables
+#define KYOSHO_BIND_COUNT 2500
+
+static void __attribute__((unused)) KYOSHO_send_packet()
+{
+	//ID
+	packet[1] = rx_tx_addr[0];
+	packet[2] = rx_tx_addr[1];
+	packet[3] = rx_tx_addr[2];
+	packet[4] = rx_tx_addr[3];
+	//unknown may be RX ID on some other remotes
+	memset(packet+5,0xFF,4);
+	
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[ 0]  = 0xBC;						// bind indicator
+		packet[ 9] &= 0x01;
+		packet[ 9] ^= 0x01;						// high/ low part of the RF table
+		packet[10]  = 0x00;
+		//RF table
+		for(uint8_t i=0; i<16;i++)
+			packet[i+11]=hopping_frequency[i+(packet[9]<<4)];
+		//unknwon
+		packet[27]  = 0x05;
+		packet[28]  = 0x00;
+		memset(packet+29,0xFF,8);
+		//frequency hop during bind
+		if(packet[9])
+			rf_ch_num=0x8C;
+		else
+			rf_ch_num=0x0D;
+	}
+	else
+	{
+		packet[ 0]  = 0x58;						// normal packet
+		//14 channels: steering, throttle, ...
+		for(uint8_t i = 0; i < 14; i++)
+		{
+			uint16_t temp=convert_channel_ppm(i);
+			packet[9 + i*2]=temp&0xFF;			// low byte of servo timing(1000-2000us)
+			packet[10 + i*2]=(temp>>8)&0xFF;	// high byte of servo timing(1000-2000us)
+		}
+		rf_ch_num=hopping_frequency[hopping_frequency_no];
+		hopping_frequency_no++;
+		packet[34] |= (hopping_frequency_no&0x0F)<<4;
+		packet[36] |= (hopping_frequency_no&0xF0);		// last byte is ending with F on the dumps so let's see
+		hopping_frequency_no &= 0x1F;
+	}
+	#if 0
+		debug("ch=%02X P=",rf_ch_num);
+		for(uint8_t i=0; i<37; i++)
+			debug("%02X ", packet[i]);
+		debugln("");
+	#endif
+	A7105_WriteData(37, rf_ch_num);
+}
+
+static void __attribute__((unused)) KYOSHO_hype_send_packet()
+{
+	if(IS_BIND_IN_PROGRESS)
+	{
+		if(packet_sent==0)
+		{//build the packet and send it
+			packet[0] = rx_tx_addr[1];
+			packet[1] = rx_tx_addr[3];
+			//RF table
+			for(uint8_t i=0; i<15;i++)
+				packet[i+2]=hopping_frequency[i];
+			A7105_WriteData(17, 0x01);
+			packet_sent++;
+			packet_period=1421;
+			#if 0
+				debug("ch=01 P=");
+				for(uint8_t i=0; i<17; i++)
+					debug("%02X ", packet[i]);
+				debugln("");
+			#endif
+		}
+		else
+			A7105_Strobe(A7105_TX);	//only send
+	}
+	else
+	{
+		//original TX is only refreshing the packet every 20ms and keep repeating the same packet in between (STROBE_TX) 
+		//build packet=6 channels with order AETR
+		for(uint8_t i=0;i<6;i++)
+			packet[i] = convert_channel_8b(CH_AETR[i]);
+		//set RF channel
+		rf_ch_num=hopping_frequency[hopping_frequency_no];
+		hopping_frequency_no++;
+		if(hopping_frequency_no>14)
+			hopping_frequency_no = 0;
+		//send it
+		A7105_WriteData(6, rf_ch_num);
+		packet_period=931;	//packet period fluctuates a lot on the original TX from one packet to the other but stable if looking over a period of 40ms
+		#if 0
+			debug("ch=%02X P=",rf_ch_num);
+			for(uint8_t i=0; i<6; i++)
+				debug("%02X ", packet[i]);
+			debugln("");
+		#endif
+	}
+}
+
+uint16_t KYOSHO_callback()
+{
+	#ifndef FORCE_KYOSHO_TUNING
+		A7105_AdjustLOBaseFreq(1);
+	#endif
+	if(IS_BIND_IN_PROGRESS)
+	{
+		bind_counter--;
+		if (bind_counter==0)
+		{
+			BIND_DONE;
+			if(sub_protocol==KYOSHO_HYPE)
+			{
+				A7105_WriteID(MProtocol_id);
+				A7105_WriteReg(A7105_03_FIFOI,0x05);
+			}
+		}
+	}
+	else
+	{
+		if(hopping_frequency_no==0)
+			A7105_SetPower();
+		#ifdef MULTI_SYNC
+			telemetry_set_input_sync(packet_period);
+		#endif
+	}
+	if(sub_protocol==KYOSHO_FHSS)
+		KYOSHO_send_packet();
+	else//HYPE
+		KYOSHO_hype_send_packet();
+	return packet_period;
+}
+
+void KYOSHO_init()
+{
+	A7105_Init();
+
+	// compute channels from ID
+	calc_fh_channels(sub_protocol==KYOSHO_FHSS?32:15);
+	hopping_frequency_no=0;
+
+	#ifdef KYOSHO_FORCE_ID_FHSS
+		if(sub_protocol==KYOSHO_FHSS)
+		{
+			memcpy(rx_tx_addr,"\x3A\x39\x37\x00",4);
+			memcpy(hopping_frequency,"\x29\x4C\x67\x92\x31\x1C\x77\x18\x23\x6E\x81\x5C\x8F\x5A\x51\x94\x7A\x12\x45\x6C\x7F\x1E\x0D\x88\x63\x8C\x4F\x37\x26\x61\x2C\x8A",32);
+		}
+	#endif
+	if(sub_protocol==KYOSHO_HYPE)
+	{
+		MProtocol_id &= 0x00FF00FF;
+		rx_tx_addr[0] = 0xAF - (rx_tx_addr[1]&0x0F);
+		rx_tx_addr[2] = 0xFF -  rx_tx_addr[3];
+		MProtocol_id |= (rx_tx_addr[0]<<24) + (rx_tx_addr[2]<<8);
+		#ifdef KYOSHO_FORCE_ID_HYPE
+			MProtocol_id=0xAF90738C;
+			set_rx_tx_addr(MProtocol_id);
+			memcpy(hopping_frequency,"\x27\x1B\x63\x75\x03\x39\x57\x69\x87\x0F\x7B\x3F\x33\x51\x6F",15);
+		#endif
+		if(IS_BIND_IN_PROGRESS)
+			A7105_WriteID(0xAF00FF00);
+		else
+		{
+			A7105_WriteID(MProtocol_id);
+			A7105_WriteReg(A7105_03_FIFOI,0x05);
+		}
+	}
+
+	if(IS_BIND_IN_PROGRESS)
+		bind_counter = KYOSHO_BIND_COUNT;
+
+	packet_sent=0;
+	packet_period=3852;		//FHSS
+}
+#endif

Multiprotocol/LOLI_nrf24l01.ino

@@ -0,0 +1,300 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(LOLI_NRF24L01_INO)
+
+#include "iface_nrf24l01.h"
+
+#define LOLI_BIND_CHANNEL	33
+#define LOLI_PACKET_SIZE	11
+#define LOLI_NUM_CHANNELS	5
+
+static void __attribute__((unused)) LOLI_RF_init()
+{
+	NRF24L01_Initialize();
+
+	NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0, (uint8_t*)"LOVE!", 5);
+	NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, (uint8_t*)"LOVE!", 5);
+	NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, LOLI_PACKET_SIZE);	// RX FIFO size
+	NRF24L01_SetBitrate(NRF24L01_BR_250K);             	// 250Kbps
+}
+
+// flags going to packet[1] for packet type 0xa2 (Rx config)
+#define LOLI_FLAG_PWM7   0x02
+#define LOLI_FLAG_PWM2   0x04
+#define LOLI_FLAG_PWM1   0x08
+#define LOLI_FLAG_SBUS   0x40
+#define LOLI_FLAG_PPM    0x80
+
+// flags going to packet[2] for packet type 0xa2 (Rx config)
+#define LOLI_FLAG_SW8    0x01
+#define LOLI_FLAG_SW7    0x02
+#define LOLI_FLAG_SW6    0x04
+#define LOLI_FLAG_SW5    0x08
+#define LOLI_FLAG_SW4    0x10
+#define LOLI_FLAG_SW3    0x20
+#define LOLI_FLAG_SW2    0x40
+#define LOLI_FLAG_SW1    0x80
+
+#ifdef LOLI_NRF24L01_INO
+	uint8_t LOLI_P1, LOLI_P2;
+#endif
+
+static void __attribute__((unused)) LOLI_send_packet()
+{
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet[0] = 0xa0;
+		memcpy(&packet[1], hopping_frequency, LOLI_NUM_CHANNELS);
+		memcpy(&packet[6], rx_tx_addr, 5);
+		rf_ch_num = LOLI_BIND_CHANNEL;
+	}
+	else
+	{
+		//Check RX config
+		uint8_t P1=0;
+		uint8_t P2=0;
+		//ch1: PWM/PPM
+		if(Channel_data[CH1+8] > CHANNEL_MAX_COMMAND)
+			P1|=LOLI_FLAG_PWM1;
+		else if(Channel_data[CH1+8] > CHANNEL_SWITCH)
+			P1|=LOLI_FLAG_PPM;
+		//ch2: PWM
+		if(Channel_data[CH2+8] > CHANNEL_MAX_COMMAND)
+			P1|=LOLI_FLAG_PWM2;
+		//ch5: SBUS
+		if(Channel_data[CH5+8] > CHANNEL_SWITCH)
+			P1|=LOLI_FLAG_SBUS;
+		//ch7: PWM
+		if(Channel_data[CH7+8] > CHANNEL_MAX_COMMAND)
+			P1|=LOLI_FLAG_PWM7;
+
+		//switches
+		for(uint8_t i=0;i<8;i++)
+			if(Channel_data[i+8]<CHANNEL_MIN_COMMAND)
+				P2 |= 1 << (7-i);
+
+		if(LOLI_P1!=P1 || LOLI_P2!=P2)
+			flags=10;
+		if(flags)
+		{// Send RX config since P1 or P2 have changed
+			LOLI_P1=P1;LOLI_P2=P2;
+			packet[0] = 0xa2;
+			packet[1] = LOLI_P1;	// CH1:LOLI_FLAG_PPM || LOLI_FLAG_PWM1, CH2:LOLI_FLAG_PWM2, CH5:LOLI_FLAG_SBUS, CH7:LOLI_FLAG_PWM7
+			packet[2] = LOLI_P2;	// CHx switch bit(8-x)=1
+			flags--;
+		}
+		else
+		{// Normal packet
+			#ifdef FAILSAFE_ENABLE
+				packet[0] = IS_FAILSAFE_VALUES_on ? 0xa0 : 0xa1;
+			#else
+				packet[0] = 0xa1;
+			#endif
+
+			//Build channels
+			uint8_t ch=0, offset=1;
+			uint16_t val;
+			for(uint8_t i=0;i<2;i++)
+			{
+				val = convert_channel_10b(ch++, IS_FAILSAFE_VALUES_on);
+				packet[offset++] = val >> 2;
+				packet[offset  ] = val << 6;
+				val = convert_channel_10b(ch++, IS_FAILSAFE_VALUES_on);
+				packet[offset++]|= val >> 4;
+				packet[offset  ] = val << 4;
+				val = convert_channel_10b(ch++, IS_FAILSAFE_VALUES_on);
+				packet[offset++]|= val >> 6;
+				packet[offset  ] = val << 2;
+				val = convert_channel_10b(ch++, IS_FAILSAFE_VALUES_on);
+				packet[offset++]|= val >> 8;
+				packet[offset++] = val & 0xff;
+			}
+			FAILSAFE_VALUES_off;	// Failsafe values are sent if they were available
+		}
+
+		if (++hopping_frequency_no > LOLI_NUM_CHANNELS-1)
+			hopping_frequency_no = 0;
+		rf_ch_num = hopping_frequency[hopping_frequency_no];
+	}
+	
+	#if 0
+		debug("P(%02X):",rf_ch_num);
+		for(uint8_t i=0; i<LOLI_PACKET_SIZE; i++)
+			debug(" %02X",packet[i]);
+		debugln("");
+	#endif
+		
+	//Send packet
+	NRF24L01_WriteReg(NRF24L01_05_RF_CH, rf_ch_num);
+	NRF24L01_SetPower();
+	NRF24L01_SetTxRxMode(TXRX_OFF);
+	NRF24L01_SetTxRxMode(TX_EN);
+	NRF24L01_WriteReg(NRF24L01_00_CONFIG, 0x0a);  // 8bit CRC, TX
+	NRF24L01_FlushTx();
+	NRF24L01_WritePayload(packet, LOLI_PACKET_SIZE);
+}
+
+enum{
+	LOLI_BIND1,
+	LOLI_BIND2,
+	LOLI_BIND3,
+	LOLI_PREP_DATA,
+	LOLI_DATA1,
+	LOLI_DATA2,
+	LOLI_SET_RX_CONFIG,
+	LOLI_SET_FAILSAFE
+};
+
+#define LOLI_WRITE_TIME 1000
+
+uint16_t LOLI_callback()
+{
+	switch (phase)
+	{
+		case LOLI_BIND1:
+			if(bind_counter)
+				if(--bind_counter==0)
+				{
+					phase=LOLI_PREP_DATA;
+					break;
+				}
+			// send bind packet
+			NRF24L01_SetTxRxMode(TXRX_OFF);
+			NRF24L01_SetTxRxMode(TX_EN);
+			NRF24L01_WriteReg(NRF24L01_00_CONFIG, 0x0a);  // 8bit CRC, TX
+			LOLI_send_packet();
+			phase++;
+			return 2000;
+		case LOLI_BIND2:
+			// switch to RX mode
+			NRF24L01_SetTxRxMode(TXRX_OFF);
+			NRF24L01_FlushRx();
+			NRF24L01_SetTxRxMode(RX_EN);
+			NRF24L01_WriteReg(NRF24L01_00_CONFIG, 0x3b);  // 8bit CRC, RX
+			phase++;
+			packet_count = 0;
+			return 2000;
+		case LOLI_BIND3:
+			// got bind response ?
+			if (NRF24L01_ReadReg(NRF24L01_07_STATUS) & _BV(NRF24L01_07_RX_DR))
+			{
+				NRF24L01_ReadPayload(packet, LOLI_PACKET_SIZE);
+				if (packet[0] == 'O' && packet[1] == 'K')
+				{
+					debugln("Bind OK");
+					phase++;	// LOLI_PREP_DATA
+					break;
+				}
+			}
+			packet_count++;
+			if (packet_count > 50)
+				phase = LOLI_BIND1;
+			return 1000;
+
+		case LOLI_PREP_DATA:
+			BIND_DONE;
+			NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0, rx_tx_addr, 5);
+			NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, rx_tx_addr, 5);
+			NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);
+			NRF24L01_FlushRx();
+			packet_count = 0;
+			//defaut RX config with servo outputs
+			LOLI_P1=0;LOLI_P2=0;flags=10;
+			phase++;
+
+		case LOLI_DATA1:
+			#ifdef LOLI_HUB_TELEMETRY
+				// Check telemetry
+				if (NRF24L01_ReadReg(NRF24L01_07_STATUS) & _BV(NRF24L01_07_RX_DR))
+				{  // RX fifo data ready
+					NRF24L01_ReadPayload(packet, LOLI_PACKET_SIZE);
+					#if 0
+						debug("T:");
+						for(uint8_t i=0; i<LOLI_PACKET_SIZE; i++)
+							debug(" %02X",packet[i]);
+						debugln("");
+					#endif
+					RX_RSSI = packet[0]<<1;
+					uint16_t val=((packet[1] << 8) | packet[2])/10;
+					if(val > 255) val=255;
+					v_lipo1 = val;
+					val=((packet[3] << 8) | packet[4])/10;
+					if(val > 255) val=255;
+					v_lipo2 = val;
+					telemetry_link = 1;
+					telemetry_counter++;			// TX LQI counter
+					if(telemetry_lost)
+					{
+						telemetry_lost = 0;
+						packet_count = 100;
+						telemetry_counter = 100;
+					}
+				}
+				//LQI
+				packet_count++;
+				if(packet_count>=100)
+				{
+					packet_count=0;
+					TX_LQI=telemetry_counter;
+					if(telemetry_counter==0)
+						telemetry_lost = 1;
+					telemetry_counter = 0;
+				}
+			#endif
+			
+			// Send data packet
+			LOLI_send_packet();
+			
+	#ifdef LOLI_HUB_TELEMETRY
+			phase ++;
+			return LOLI_WRITE_TIME;
+		case LOLI_DATA2:
+			// Wait for packet to be sent
+			while( (NRF24L01_ReadReg(NRF24L01_07_STATUS) & _BV(NRF24L01_07_TX_DS)) == 0);
+			// Switch to RX mode
+			NRF24L01_SetTxRxMode(TXRX_OFF);
+			NRF24L01_FlushRx();
+			NRF24L01_SetTxRxMode(RX_EN);
+			NRF24L01_WriteReg(NRF24L01_00_CONFIG, 0x3b);  // 8bit CRC, RX
+			phase = LOLI_DATA1;
+			return 20000 - LOLI_WRITE_TIME;
+	#else
+			break;
+	#endif
+	}
+	return 20000;
+}
+
+void LOLI_init()
+{
+	rx_tx_addr[1] %= 0x30;
+	calc_fh_channels(LOLI_NUM_CHANNELS);
+	for (uint8_t i=0; i < LOLI_NUM_CHANNELS; i++)
+		if (hopping_frequency[i] == LOLI_BIND_CHANNEL)
+			hopping_frequency[i]++;
+
+	if (IS_BIND_IN_PROGRESS)
+	{
+		bind_counter=250;
+		phase = LOLI_BIND1;
+	}
+	else
+		phase = LOLI_PREP_DATA;
+
+	LOLI_RF_init();
+}
+
+#endif

Multiprotocol/Losi_cyrf6936.ino

@@ -0,0 +1,147 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(LOSI_CYRF6936_INO)
+
+#include "iface_cyrf6936.h"
+
+#define LOSI_FORCE_ID
+
+const uint8_t PROGMEM LOSI_bind_sop_code[] = {0x62, 0xdf, 0xc1, 0x49, 0xdf, 0xb1, 0xc0, 0x49};
+const uint8_t LOSI_data_code[][16] = {
+	{ 0xD7, 0xA1, 0x54, 0xB1, 0x5E, 0x89, 0xAE, 0x86, 0xC9, 0x2C, 0x06, 0x93, 0x86, 0xB9, 0x9E, 0xD7 }, //bind
+/*	{ 0xE1, 0xD6, 0x31, 0x26, 0x5F, 0xBD, 0x40, 0x93, 0xDC, 0x68, 0x08, 0x99, 0x97, 0xAE, 0xAF, 0x8C },
+	{ 0xDC, 0x68, 0x08, 0x99, 0x97, 0xAE, 0xAF, 0x8C, 0xC3, 0x0E, 0x01, 0x16, 0x0E, 0x32, 0x06, 0xBA },
+	{ 0xC3, 0x0E, 0x01, 0x16, 0x0E, 0x32, 0x06, 0xBA, 0xE0, 0x83, 0x01, 0xFA, 0xAB, 0x3E, 0x8F, 0xAC },
+	{ 0xE0, 0x83, 0x01, 0xFA, 0xAB, 0x3E, 0x8F, 0xAC, 0x5C, 0xD5, 0x9C, 0xB8, 0x46, 0x9C, 0x7D, 0x84 },
+	{ 0x5C, 0xD5, 0x9C, 0xB8, 0x46, 0x9C, 0x7D, 0x84, 0xF1, 0xC6, 0xFE, 0x5C, 0x9D, 0xA5, 0x4F, 0xB7 },
+	{ 0xF1, 0xC6, 0xFE, 0x5C, 0x9D, 0xA5, 0x4F, 0xB7, 0x58, 0xB5, 0xB3, 0xDD, 0x0E, 0x28, 0xF1, 0xB0 },
+	{ 0x58, 0xB5, 0xB3, 0xDD, 0x0E, 0x28, 0xF1, 0xB0, 0x5F, 0x30, 0x3B, 0x56, 0x96, 0x45, 0xF4, 0xA1 },*/
+	{ 0x5F, 0x30, 0x3B, 0x56, 0x96, 0x45, 0xF4, 0xA1, 0x03, 0xBC, 0x6E, 0x8A, 0xEF, 0xBD, 0xFE, 0xF8 }	//normal
+};
+
+static uint16_t __attribute__((unused)) LOSI_check(uint16_t val)
+{
+	const uint8_t PROGMEM tab[] = { 0xF1, 0xDA, 0xB6, 0xC8 };
+	uint8_t res = 0x0B, tmp;
+	uint16_t calc = val>>2; 									// don't care about the 2 first bits
+	for(uint8_t i=0; i<5; i++)
+	{
+		tmp=pgm_read_byte_near(&tab[i&0x03]);
+		if(calc&0x0001)
+			res ^= tmp>>4;
+		calc >>= 1;
+		if(calc&0x0001)
+			res ^= tmp;
+		calc >>= 1;
+	}
+	return val ^ (res<<12);
+}
+
+static void __attribute__((unused)) LOSI_send_packet()
+{
+	memcpy(packet, rx_tx_addr, 4);
+	if(IS_BIND_IN_PROGRESS)
+	{
+		memcpy(&packet[4], rx_tx_addr, 4);
+		packet[8] = 0x05;               				    	// CRC?
+		packet[9] = 0x52;                   					// CRC?
+	}
+	else
+	{
+		for(uint8_t i=0; i<3; i++)
+		{
+			uint16_t val = LOSI_check(Channel_data[i]<<1);
+			packet[4+i*2] = val >> 8;
+			packet[5+i*2] = val;
+		}
+	}
+
+	CYRF_SetPower(0x38);
+	CYRF_WriteDataPacketLen(packet, 0x0A);
+	#if 0
+		for(uint8_t i=0; i < 0x0A; i++)
+			debug("%02X ", packet[i]);
+		debugln();
+	#endif
+}
+
+static void __attribute__((unused)) LOSI_cyrf_init()
+{
+	/* Initialise CYRF chip */
+	CYRF_WriteRegister(CYRF_28_CLK_EN, 0x02);
+	CYRF_WriteRegister(CYRF_32_AUTO_CAL_TIME, 0x3C);
+	CYRF_WriteRegister(CYRF_35_AUTOCAL_OFFSET, 0x14);
+	CYRF_WriteRegister(CYRF_06_RX_CFG, 0x48);
+	CYRF_WriteRegister(CYRF_1B_TX_OFFSET_LSB, 0x55);
+	CYRF_WriteRegister(CYRF_1C_TX_OFFSET_MSB, 0x05);
+	//CYRF_WriteRegister(CYRF_0F_XACT_CFG, 0x24);
+	CYRF_SetPower(0x38);
+	CYRF_WriteRegister(CYRF_12_DATA64_THOLD, 0x0A);
+	CYRF_WriteRegister(CYRF_39_ANALOG_CTRL, 0x01);
+	CYRF_WritePreamble(0x333304);
+	//CYRF_WriteRegister(CYRF_27_CLK_OVERRIDE, 0x00);
+	CYRF_WriteRegister(CYRF_10_FRAMING_CFG, 0x4A);
+	CYRF_WriteRegister(CYRF_1F_TX_OVERRIDE, 0x04);				// No CRC
+	//CYRF_WriteRegister(CYRF_1E_RX_OVERRIDE, 0x14);
+	//CYRF_WriteRegister(CYRF_14_EOP_CTRL, 0x02);
+}
+
+uint16_t LOSI_callback()
+{
+	#ifdef MULTI_SYNC
+		telemetry_set_input_sync(19738);
+	#endif
+	LOSI_send_packet();
+	if(bind_counter)
+	{
+		bind_counter--;
+		if(bind_counter==0)
+		{
+			BIND_DONE;
+			CYRF_ConfigDataCode(LOSI_data_code[1], 16);			// Load normal data code
+		}
+		return 8763;
+	}
+	return 19738;
+}
+
+void LOSI_init()
+{
+	LOSI_cyrf_init();
+	//CYRF_FindBestChannels(hopping_frequency, 1, 0, 0x13, 75);	// 75 is unknown since dump stops at 0x27, this routine resets the CRC Seed to 0
+	//CYRF_ConfigRFChannel(hopping_frequency[0] | 1);				// Only odd channels
+
+	#ifdef LOSI_FORCE_ID
+		rx_tx_addr[0] = 0x47;
+		rx_tx_addr[1] = 0x52;
+		rx_tx_addr[2] = 0xAE;
+		rx_tx_addr[3] = 0xAA;
+		CYRF_ConfigRFChannel(0x27);
+	#endif
+
+	if(IS_BIND_IN_PROGRESS)
+	{
+		bind_counter = 300;
+		CYRF_ConfigDataCode(LOSI_data_code[0], 16);				// Load bind data code
+	}
+	else
+	{
+		CYRF_ConfigDataCode(LOSI_data_code[1], 16);				// Load normal data code
+		bind_counter = 0;
+	}
+}
+
+#endif

Multiprotocol/MJXQ_ccnrf.ino

@@ -15,9 +15,9 @@
 // compatible with MJX WLH08, X600, X800, H26D, Eachine E010
 // Last sync with hexfet new_protocols/mjxq_nrf24l01.c dated 2016-01-17
 
-#if defined(MJXQ_NRF24L01_INO)
+#if defined(MJXQ_CCNRF_INO)
 
-#include "iface_nrf24l01.h"
+#include "iface_xn297.h"
 
 #define MJXQ_BIND_COUNT		150
 #define MJXQ_PACKET_PERIOD	4000  // Timeout for callback in uSec
@@ -78,21 +78,22 @@ const uint8_t PROGMEM E010_map_rfchan[][2] = {
 #define MJXQ_PAN_UP			0x04
 #define MJXQ_TILT_DOWN		0x20
 #define MJXQ_TILT_UP		0x10
+
 static uint8_t __attribute__((unused)) MJXQ_pan_tilt_value()
 {
-// Servo_AUX8	PAN			// H26D
-// Servo_AUX9	TILT
+// CH12_SW	PAN			// H26D
+// CH13_SW	TILT
 	uint8_t	pan = 0;
 	packet_count++;
 	if(packet_count & MJXQ_PAN_TILT_COUNT)
 	{
-		if(Servo_data[AUX8]>PPM_MAX_COMMAND)
+		if(CH12_SW)
 			pan=MJXQ_PAN_UP;
-		if(Servo_data[AUX8]<PPM_MIN_COMMAND)
+		if(Channel_data[CH12]<CHANNEL_MIN_COMMAND)
 			pan=MJXQ_PAN_DOWN;
-		if(Servo_data[AUX9]>PPM_MAX_COMMAND)
+		if(CH13_SW)
 			pan+=MJXQ_TILT_UP;
-		if(Servo_data[AUX9]<PPM_MIN_COMMAND)
+		if(Channel_data[CH13]<CHANNEL_MIN_COMMAND)
 			pan+=MJXQ_TILT_DOWN;
 	}
 	return pan;
@@ -101,13 +102,19 @@ static uint8_t __attribute__((unused)) MJXQ_pan_tilt_value()
 #define MJXQ_CHAN2TRIM(X) (((X) & 0x80 ? (X) : 0x7f - (X)) >> 1)
 static void __attribute__((unused)) MJXQ_send_packet(uint8_t bind)
 {
+	//RF freq
+	hopping_frequency_no++;
+	XN297_Hopping(hopping_frequency_no / 2);
+	hopping_frequency_no %= 2 * MJXQ_RF_NUM_CHANNELS;	// channels repeated
+
+	//Build packet
 	packet[0] = convert_channel_8b(THROTTLE);
 	packet[1] = convert_channel_s8b(RUDDER);
 	packet[4] = 0x40;							// rudder does not work well with dyntrim
 	packet[2] = 0x80 ^ convert_channel_s8b(ELEVATOR);
-	packet[5] = GET_FLAG(Servo_AUX5, 1) ? 0x40 : MJXQ_CHAN2TRIM(packet[2]);	// trim elevator
+	packet[5] = (CH9_SW || CH14_SW) ? 0x40 : MJXQ_CHAN2TRIM(packet[2]);	// trim elevator
 	packet[3] = convert_channel_s8b(AILERON);
-	packet[6] = GET_FLAG(Servo_AUX5, 1) ? 0x40 : MJXQ_CHAN2TRIM(packet[3]);	// trim aileron
+	packet[6] = (CH9_SW || CH14_SW) ? 0x40 : MJXQ_CHAN2TRIM(packet[3]);	// trim aileron
 	packet[7] = rx_tx_addr[0];
 	packet[8] = rx_tx_addr[1];
 	packet[9] = rx_tx_addr[2];
@@ -119,15 +126,16 @@ static void __attribute__((unused)) MJXQ_send_packet(uint8_t bind)
 
 	packet[14] = 0xC0;							// bind value
 
-// Servo_AUX1	FLIP
-// Servo_AUX2	LED / ARM
-// Servo_AUX3	PICTURE
-// Servo_AUX4	VIDEO
-// Servo_AUX5	HEADLESS
-// Servo_AUX6	RTH
-// Servo_AUX7	AUTOFLIP	// X800, X600
-// Servo_AUX8	PAN
-// Servo_AUX9	TILT
+// CH5_SW	FLIP
+// CH6_SW	LED / ARM	// H26WH - TDR Phoenix mini
+// CH7_SW	PICTURE
+// CH8_SW	VIDEO
+// CH9_SW	HEADLESS
+// CH10_SW	RTH
+// CH11_SW	AUTOFLIP	// X800, X600
+// CH12_SW	PAN
+// CH13_SW	TILT
+// CH14_SW	XTRM		// Dyntrim, don't use if high.
 	switch(sub_protocol)
 	{
 		case H26WH:
@@ -136,45 +144,52 @@ static void __attribute__((unused)) MJXQ_send_packet(uint8_t bind)
 			// fall through on purpose - no break
 		case WLH08:
 		case E010:
-			packet[10] += GET_FLAG(Servo_AUX6, 0x02)	//RTH
-						| GET_FLAG(Servo_AUX5, 0x01);	//HEADLESS
+		case PHOENIX:
+			packet[10] += GET_FLAG(CH10_SW, 0x02)	//RTH
+						| GET_FLAG(CH9_SW, 0x01);	//HEADLESS
 			if (!bind)
 			{
 				packet[14] = 0x04
-						| GET_FLAG(Servo_AUX1, 0x01)	//FLIP
-						| GET_FLAG(Servo_AUX3, 0x08)	//PICTURE
-						| GET_FLAG(Servo_AUX4, 0x10)	//VIDEO
-						| GET_FLAG(!Servo_AUX2, 0x20);	// LED or air/ground mode
+						| GET_FLAG(CH5_SW, 0x01)	//FLIP
+						| GET_FLAG(CH7_SW, 0x08)	//PICTURE
+						| GET_FLAG(CH8_SW, 0x10)	//VIDEO
+						| GET_FLAG(!CH6_SW, 0x20);	// LED or air/ground mode
+				if(sub_protocol==PHOENIX)
+				{
+					packet[10] |=0x20						//High rate
+							   | GET_FLAG(CH6_SW, 0x80);	// arm
+					packet[14] &= ~0x24;					// unset air/ground & arm flags
+				}
 				if(sub_protocol==H26WH)
 				{
 					packet[10] |=0x40;					//High rate
 					packet[14] &= ~0x24;				// unset air/ground & arm flags
-					packet[14] |= GET_FLAG(Servo_AUX2, 0x02);	// arm
+					packet[14] |= GET_FLAG(CH6_SW, 0x02);	// arm
 				}
 			}
 			break;
 		case X600:
-			packet[10] = GET_FLAG(!Servo_AUX2, 0x02);	//LED
-			packet[11] = GET_FLAG(Servo_AUX6, 0x01);	//RTH
+			packet[10] = GET_FLAG(!CH6_SW, 0x02);	//LED
+			packet[11] = GET_FLAG(CH10_SW, 0x01);	//RTH
 			if (!bind)
 			{
 				packet[14] = 0x02						// always high rates by bit2 = 1
-						| GET_FLAG(Servo_AUX1, 0x04)	//FLIP
-						| GET_FLAG(Servo_AUX7, 0x10)	//AUTOFLIP
-						| GET_FLAG(Servo_AUX5, 0x20);	//HEADLESS
+						| GET_FLAG(CH5_SW, 0x04)	//FLIP
+						| GET_FLAG(CH11_SW, 0x10)	//AUTOFLIP
+						| GET_FLAG(CH9_SW, 0x20);	//HEADLESS
 			}
 			break;
 		case X800:
 		default:
 			packet[10] = 0x10
-					| GET_FLAG(!Servo_AUX2, 0x02)	//LED
-					| GET_FLAG(Servo_AUX7, 0x01);	//AUTOFLIP
+					| GET_FLAG(!CH6_SW, 0x02)	//LED
+					| GET_FLAG(CH11_SW, 0x01);	//AUTOFLIP
 			if (!bind)
 			{
 				packet[14] = 0x02						// always high rates by bit2 = 1
-						| GET_FLAG(Servo_AUX1, 0x04)	//FLIP
-						| GET_FLAG(Servo_AUX3, 0x08)	//PICTURE
-						| GET_FLAG(Servo_AUX4, 0x10);	//VIDEO
+						| GET_FLAG(CH5_SW, 0x04)	//FLIP
+						| GET_FLAG(CH7_SW, 0x08)	//PICTURE
+						| GET_FLAG(CH8_SW, 0x10);	//VIDEO
 			}
 			break;
 	}
@@ -183,64 +198,58 @@ static void __attribute__((unused)) MJXQ_send_packet(uint8_t bind)
 	for (uint8_t i=1; i < MJXQ_PACKET_SIZE-1; i++) sum += packet[i];
 	packet[15] = sum;
 
-	NRF24L01_WriteReg(NRF24L01_05_RF_CH, hopping_frequency[hopping_frequency_no++ / 2]);
-	hopping_frequency_no %= 2 * MJXQ_RF_NUM_CHANNELS;	// channels repeated
-
-	NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);
-	NRF24L01_FlushTx();
-
-	// Power on, TX mode, 2byte CRC and send packet
+	// Send
+	XN297_SetTxRxMode(TX_EN);
+	XN297_SetPower();
+#ifdef NRF24L01_INSTALLED
 	if (sub_protocol == H26D || sub_protocol == H26WH)
 	{
-		NRF24L01_SetTxRxMode(TX_EN);
+		//NRF24L01_WriteReg(NRF24L01_05_RF_CH, hopping_frequency[hopping_frequency_no / 2]);
+		//NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70);
+		//NRF24L01_FlushTx();
+		//NRF24L01_SetTxRxMode(TX_EN);
+		//NRF24L01_SetPower();
 		NRF24L01_WritePayload(packet, MJXQ_PACKET_SIZE);
 	}
 	else
-	{
-		XN297_Configure(_BV(NRF24L01_00_EN_CRC) | _BV(NRF24L01_00_CRCO) | _BV(NRF24L01_00_PWR_UP));
+#endif
+	{//E010, PHOENIX, WLH08, X600, X800
+		XN297_SetFreqOffset();
 		XN297_WritePayload(packet, MJXQ_PACKET_SIZE);
 	}
-	NRF24L01_SetPower();
 }
 
-static void __attribute__((unused)) MJXQ_init()
+static void __attribute__((unused)) MJXQ_RF_init()
 {
 	uint8_t addr[MJXQ_ADDRESS_LENGTH];
 	memcpy(addr, "\x6d\x6a\x77\x77\x77", MJXQ_ADDRESS_LENGTH);
 	if (sub_protocol == WLH08)
 		memcpy(hopping_frequency, "\x12\x22\x32\x42", MJXQ_RF_NUM_CHANNELS);
 	else
-		if (sub_protocol == H26D || sub_protocol == H26D || sub_protocol == E010)
+		if (sub_protocol == H26D || sub_protocol == H26WH || sub_protocol == E010 || sub_protocol == PHOENIX)
 			memcpy(hopping_frequency, "\x2e\x36\x3e\x46", MJXQ_RF_NUM_CHANNELS);
 		else
 		{
 			memcpy(hopping_frequency, "\x0a\x35\x42\x3d", MJXQ_RF_NUM_CHANNELS);
 			memcpy(addr, "\x6d\x6a\x73\x73\x73", MJXQ_ADDRESS_LENGTH);
 		}
-	
-	NRF24L01_Initialize();
-	NRF24L01_SetTxRxMode(TX_EN);
-
-	if (sub_protocol == H26D || sub_protocol == H26WH)
+	if (sub_protocol == E010 || sub_protocol == PHOENIX)
 	{
-		NRF24L01_WriteReg(NRF24L01_03_SETUP_AW,		0x03);		// 5-byte RX/TX address
-		NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, addr, MJXQ_ADDRESS_LENGTH);
+		XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_250K);
+		XN297_SetTXAddr(addr, MJXQ_ADDRESS_LENGTH);
+		XN297_HoppingCalib(MJXQ_RF_NUM_CHANNELS);
 	}
 	else
-		XN297_SetTXAddr(addr, MJXQ_ADDRESS_LENGTH);
-
-	NRF24L01_FlushTx();
-	NRF24L01_FlushRx();
-	NRF24L01_WriteReg(NRF24L01_07_STATUS,		0x70);		// Clear data ready, data sent, and retransmit
-	NRF24L01_WriteReg(NRF24L01_01_EN_AA,		0x00);		// No Auto Acknowledgment on all data pipes
-	NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR,	0x01);		// Enable data pipe 0 only
-	NRF24L01_WriteReg(NRF24L01_04_SETUP_RETR,	0x00);		// no retransmits
-	NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0,		MJXQ_PACKET_SIZE);
-	if (sub_protocol == E010)
-		NRF24L01_SetBitrate(NRF24L01_BR_250K);				// 250K
+	{
+		XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);	// this will select the nrf and initialize it, therefore both H26 sub protocols can use common instructions
+#ifdef NRF24L01_INSTALLED
+		if (sub_protocol == H26D || sub_protocol == H26WH)
+			NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, addr, MJXQ_ADDRESS_LENGTH);
 		else
-		NRF24L01_SetBitrate(NRF24L01_BR_1M);				// 1Mbps
-	NRF24L01_SetPower();
+#endif
+			XN297_SetTXAddr(addr, MJXQ_ADDRESS_LENGTH);
+		//NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0,		MJXQ_PACKET_SIZE);	// no RX???
+	}
 }
 
 static void __attribute__((unused)) MJXQ_init2()
@@ -254,11 +263,13 @@ static void __attribute__((unused)) MJXQ_init2()
 			memcpy(hopping_frequency, "\x37\x32\x47\x42", MJXQ_RF_NUM_CHANNELS);
 			break;
 		case E010:
+		case PHOENIX:
 			for(uint8_t i=0;i<2;i++)
 			{
 				hopping_frequency[i]=pgm_read_byte_near( &E010_map_rfchan[rx_tx_addr[3]&0x0F][i] );
 				hopping_frequency[i+2]=hopping_frequency[i]+0x10;
 			}
+			XN297_HoppingCalib(MJXQ_RF_NUM_CHANNELS);
 			break;
 		case WLH08:
 			// do nothing
@@ -278,6 +289,7 @@ static void __attribute__((unused)) MJXQ_initialize_txid()
 			memcpy(rx_tx_addr, "\xa4\x03\x00", 3); 
 			break;
 		case E010:
+		case PHOENIX:
 			for(uint8_t i=0;i<2;i++)
 				rx_tx_addr[i]=pgm_read_byte_near( &E010_map_txid[rx_tx_addr[3]&0x0F][i] );
 			if((rx_tx_addr[3]&0x0E) == 0x0E)
@@ -298,8 +310,13 @@ static void __attribute__((unused)) MJXQ_initialize_txid()
 
 uint16_t MJXQ_callback()
 {
-	if(IS_BIND_DONE_on)
+	if(IS_BIND_DONE)
+	{
+		#ifdef MULTI_SYNC
+			telemetry_set_input_sync(MJXQ_PACKET_PERIOD);
+		#endif
 		MJXQ_send_packet(0);
+	}
 	else
 	{
 		if (bind_counter == 0)
@@ -317,14 +334,13 @@ uint16_t MJXQ_callback()
     return MJXQ_PACKET_PERIOD;
 }
 
-uint16_t initMJXQ(void)
+void MJXQ_init(void)
 {
 	BIND_IN_PROGRESS;	// autobind protocol
 	bind_counter = MJXQ_BIND_COUNT;
     MJXQ_initialize_txid();
-    MJXQ_init();
+    MJXQ_RF_init();
 	packet_count=0;
-	return MJXQ_INITIAL_WAIT+MJXQ_PACKET_PERIOD;
 }
 
 #endif

Multiprotocol/MLINK_cyrf6936.ino

@@ -0,0 +1,608 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(MLINK_CYRF6936_INO)
+
+#include "iface_cyrf6936.h"
+
+//#define MLINK_FORCE_ID
+#define MLINK_BIND_COUNT	696	// around 20s
+#define MLINK_NUM_FREQ		78
+#define MLINK_BIND_CHANNEL	0x01
+#define MLINK_PACKET_SIZE	8
+
+enum {
+	MLINK_BIND_TX=0,
+	MLINK_BIND_PREP_RX,
+	MLINK_BIND_RX,
+	MLINK_PREP_DATA,
+	MLINK_SEND1,
+	MLINK_SEND2,
+	MLINK_SEND3,
+	MLINK_CHECK3,
+	MLINK_RX,
+	MLINK_BUILD4,
+};
+
+uint8_t MLINK_Data_Code[16], MLINK_CRC_Init, MLINK_Unk_6_2;
+
+const uint8_t PROGMEM MLINK_init_vals[][2] = {
+	//Init from dump
+	{ CYRF_01_TX_LENGTH,	0x08 },	// Length of packet
+	{ CYRF_02_TX_CTRL,		0x40 },	// Clear TX Buffer
+	{ CYRF_03_TX_CFG,		0x3C }, //0x3E in normal mode, 0x3C in bind mode: SDR 64 chip codes (=8 bytes data code used)
+	{ CYRF_05_RX_CTRL,		0x00 },
+	{ CYRF_06_RX_CFG,		0x93 },	// AGC enabled, overwrite enable, valid flag enable
+	{ CYRF_0B_PWR_CTRL,		0x00 },
+	//{ CYRF_0C_XTAL_CTRL,	0x00 },	// Set to GPIO on reset
+	//{ CYRF_0D_IO_CFG,		0x00 },	// Set to GPIO on reset
+	//{ CYRF_0E_GPIO_CTRL,	0x00 }, // Set by the CYRF_SetTxRxMode function
+	{ CYRF_0F_XACT_CFG,		0x04 },	// end state idle
+	{ CYRF_10_FRAMING_CFG,	0x00 },	// SOP disabled
+	{ CYRF_11_DATA32_THOLD,	0x05 }, // not used???
+	{ CYRF_12_DATA64_THOLD,	0x0F }, // 64 Chip Data PN Code Correlator Threshold
+	{ CYRF_14_EOP_CTRL,		0x05 }, // 5 consecutive noncorrelations symbol for EOP
+	{ CYRF_15_CRC_SEED_LSB,	0x00 }, // not used???
+	{ CYRF_16_CRC_SEED_MSB,	0x00 }, // not used???
+	{ CYRF_1B_TX_OFFSET_LSB,0x00 },
+	{ CYRF_1C_TX_OFFSET_MSB,0x00 },
+	{ CYRF_1D_MODE_OVERRIDE,0x00 },
+	{ CYRF_1E_RX_OVERRIDE,	0x14 },	// RX CRC16 is disabled and Force Receive Data Rate
+	{ CYRF_1F_TX_OVERRIDE,	0x04 }, // TX CRC16 is disabled
+	{ CYRF_26_XTAL_CFG,		0x08 },
+	{ CYRF_29_RX_ABORT,		0x00 },
+	{ CYRF_32_AUTO_CAL_TIME,0x3C },
+	{ CYRF_35_AUTOCAL_OFFSET,0x14 },
+	{ CYRF_39_ANALOG_CTRL,	0x03 },	// Receive invert and all slow
+};
+
+static void __attribute__((unused)) MLINK_cyrf_config()
+{
+	for(uint8_t i = 0; i < sizeof(MLINK_init_vals) / 2; i++)	
+		CYRF_WriteRegister(pgm_read_byte_near(&MLINK_init_vals[i][0]), pgm_read_byte_near(&MLINK_init_vals[i][1]));
+	CYRF_WritePreamble(0x333304);
+	CYRF_SetTxRxMode(TX_EN);
+}
+
+static void __attribute__((unused)) MLINK_send_bind_packet()
+{
+	uint8_t p_c=packet_count>>1;
+	
+	memset(packet, p_c<0x16?0x00:0xFF, MLINK_PACKET_SIZE-1);
+	packet[0]=0x0F;	// bind
+	packet[1]=p_c;
+	switch(p_c)
+	{
+		case 0x00:
+			packet[2]=0x40;			//unknown but seems constant
+			packet[4]=0x01;			//unknown but seems constant
+			packet[5]=0x03;			//unknown but seems constant
+			packet[6]=0xE3;			//unknown but seems constant
+			break;
+		case 0x05:
+			packet[6]=MLINK_CRC_Init;	//CRC init value
+			break;
+		case 0x06:
+			packet[2]=MLINK_Unk_6_2;	//unknown and different
+			//Start of hopping frequencies
+			for(uint8_t i=0;i<4;i++)
+				packet[i+3]=hopping_frequency[i];
+			break;
+		case 0x15:
+			packet[6]=0x51;			//unknown but seems constant
+			break;
+		case 0x16:
+			packet[2]=0x51;			//unknown but seems constant
+			packet[3]=0xEC;			//unknown but seems constant
+			packet[4]=0x05;			//unknown but seems constant
+			break;
+		case 0x1A:
+			packet[1]=0xFF;
+			memset(&packet[2],0x00,5);
+			break;
+	}
+	if(p_c>=0x01 && p_c<=0x04)
+	{//DATA_CODE
+		uint8_t p_c_5=(p_c-1)*5;
+		for(uint8_t i=0;i<5;i++)
+			if(i+p_c_5<16)
+				packet[i+2]=MLINK_Data_Code[i+p_c_5];
+	}
+	else
+		if(p_c>=0x07 && p_c<=0x15)
+		{//Hopping frequencies
+			uint8_t p_c_5=5*(p_c-6)-1;
+			for(uint8_t i=0;i<5;i++)
+				if(i+p_c_5<MLINK_NUM_FREQ)
+					packet[i+2]=hopping_frequency[i+p_c_5];
+		}
+		else
+			if(p_c>0x19)
+			{
+				packet[1]=0xFF;
+				memset(&packet[2], 0x00, MLINK_PACKET_SIZE-3);
+			}
+
+	//Calculate CRC
+	crc8=0xFF;	// Init = 0xFF
+	for(uint8_t i=0;i<MLINK_PACKET_SIZE-1;i++)
+		crc8_update(bit_reverse(packet[i]));
+	packet[7] = bit_reverse(crc8);			// CRC reflected out
+
+	//Debug
+	#if 0
+		debug("P(%02d):",p_c);
+		for(uint8_t i=0;i<8;i++)
+			debug(" %02X",packet[i]);
+		debugln("");
+	#endif
+
+	//Send packet
+	CYRF_WriteDataPacketLen(packet, MLINK_PACKET_SIZE);
+}
+
+static void __attribute__((unused)) MLINK_send_data_packet()
+{
+	static uint8_t tog=0;
+	uint8_t start;
+	
+#ifdef FAILSAFE_ENABLE
+	static uint8_t fs=0;
+	if(IS_FAILSAFE_VALUES_on && phase==MLINK_SEND1)
+	{
+		fs=10;	// Original radio is sending 70 packets
+		FAILSAFE_VALUES_off;
+	}
+	if(fs)
+	{// Failsafe packets
+		switch(phase)
+		{
+			case MLINK_SEND2:
+				packet[0]=0x06;
+				start=17;
+				break;
+			case MLINK_SEND3:
+				packet[0]=0x84;
+				start=5;
+				fs--;
+				break;
+			default: //MLINK_SEND1:
+				packet[0]=0x05;
+				start=11;
+				break;
+		}
+		//Pack 6 channels per packet
+		for(uint8_t i=0;i<6;i++)
+		{
+			uint8_t val=start<16 ? convert_channel_16b_nolimit(start,426 >> 4,3448 >> 4,true) : 0x00;
+			start--;	// switch to next channel
+			packet[i+1]=val;
+		}
+	}
+	else
+#endif
+	{// Normal packets
+		if(hopping_frequency_no==0)
+			tog=1;
+		//Channels to be sent
+		if(phase==MLINK_SEND1 || ((hopping_frequency_no%5==0) && (phase==MLINK_SEND2)))
+		{
+			if((hopping_frequency_no&1)==0)
+				packet[0] = 0x09;	//10,8,6
+			else
+				packet[0] = 0x01;	//11,9,7
+		}
+		else
+			if(phase==MLINK_SEND2)
+			{
+				if(tog)
+					packet[0] = 0x02;	//x,15,13
+				else
+					packet[0] = 0x0A;	//x,14,12
+				tog^=1;
+			}
+			else
+			{//phase==MLINK_SEND3
+				if((hopping_frequency_no&1)==0)
+					packet[0] = 0x88;	//4,2,0
+				else
+					packet[0] = 0x80;	//5,3,1
+			}
+
+		//Start channel
+		start=4+6*(packet[0]&3);
+		if((packet[0]&0x08)==0)
+			start++;
+		
+		//Channels 426..1937..3448
+		for(uint8_t i=0;i<3;i++)
+		{
+			uint16_t val=start<16 ? convert_channel_16b_nolimit(start,426,3448,false) : 0x0000;
+			start-=2;	// switch to next channel
+			packet[i*2+1]=val>>8;
+			packet[i*2+2]=val;
+		}
+	}
+
+	//Calculate CRC
+	crc8=bit_reverse(hopping_frequency_no + MLINK_CRC_Init);	// Init = relected freq index + offset
+	for(uint8_t i=0;i<MLINK_PACKET_SIZE-1;i++)
+		crc8_update(bit_reverse(packet[i]));
+	packet[7] = bit_reverse(crc8);			// CRC reflected out
+
+	//Send
+	CYRF_WriteDataPacketLen(packet, MLINK_PACKET_SIZE);
+
+	//Debug
+	#if 0
+		debug("P(%02d):",hopping_frequency_no);
+		for(uint8_t i=0;i<8;i++)
+			debug(" %02X",packet[i]);
+		debugln("");
+	#endif
+}
+
+#ifdef MLINK_HUB_TELEMETRY
+	static void __attribute__((unused)) MLINK_Send_Telemetry()
+	{ // not sure how MLINK telemetry works, the 2 RXs I have are sending something completly different...
+		telemetry_counter += 2;				// TX LQI counter
+		telemetry_link = 1;
+
+		if(packet_in[0]==0x13)
+		{ // RX-9-DR : 13 1A C8 00 01 64 00
+			uint8_t id;
+			for(uint8_t i=1; i<5; i+=3)
+			{//2 sensors per packet
+				id=0x00;
+				switch(packet_in[i]&0x0F)
+				{
+					case 1: //voltage
+						if((packet_in[i]&0xF0) == 0x00)
+							v_lipo1 = packet_in[i+1];		// Rx_Batt*20
+						else
+							v_lipo2 = packet_in[i+1];
+						break;
+					case 2: //current
+						id = 0x28;
+						break;
+					case 3: //vario
+						id = 0x30;
+						break;
+					case 5: //rpm
+						id = 0x03;
+						break;
+					case 6: //temp
+						id = 0x02;
+						break;
+					case 10: //lqi
+						RX_RSSI=RX_LQI=packet_in[i+1]>>1;
+						break;
+				}
+				#if defined HUB_TELEMETRY
+					if(id)
+					{
+						uint16_t val=((packet_in[i+2]&0x80)<<8)|((packet_in[i+2]&0x7F)<<7)|(packet_in[i+1]>>1);	//remove the alarm LSB bit, move the sign bit to MSB
+						frsky_send_user_frame(id, val, val>>8);
+					}
+				#endif
+			}
+		}
+		else
+			if(packet_in[0]==0x03)
+			{ // RX-5 :    03 15 23 00 00 01 02
+				//Incoming packet values
+				RX_RSSI = packet_in[2]<<1;	// Looks to be the RX RSSI value
+				RX_LQI  = packet_in[5];		// Looks to be connection lost
+			}
+			else
+				RX_RSSI = TX_LQI;
+
+		// Read TX RSSI
+		TX_RSSI = CYRF_ReadRegister(CYRF_13_RSSI)&0x1F;
+
+		if(telemetry_lost)
+		{
+			telemetry_lost = 0;
+			packet_count = 50;
+			telemetry_counter = 100;
+		}
+	}
+#endif
+
+#ifdef MLINK_FW_TELEMETRY
+	static void __attribute__((unused)) MLINK_Send_Telemetry()
+	{
+		telemetry_counter += 2;				// TX LQI counter
+		telemetry_link = 4;
+
+		// Read TX RSSI
+		TX_RSSI = CYRF_ReadRegister(CYRF_13_RSSI)&0x1F;
+
+		if(telemetry_lost)
+		{
+			telemetry_lost = 0;
+			packet_count = 50;
+			telemetry_counter = 100;
+		}
+	}
+#endif
+
+uint16_t MLINK_callback()
+{
+	uint8_t status;
+	uint16_t start;
+
+	switch(phase)
+	{
+		case MLINK_BIND_RX:
+			//debugln("RX");
+			status=CYRF_ReadRegister(CYRF_05_RX_CTRL);
+			if( (status&0x80) == 0 )
+			{//Packet received
+				len=CYRF_ReadRegister(CYRF_09_RX_COUNT);
+				debugln("L=%02X",len)
+				if( len==8 )
+				{
+					CYRF_ReadDataPacketLen(packet, len*2);
+					debug("RX=");
+					for(uint8_t i=0;i<8;i++)
+						debug(" %02X",packet[i*2]);
+					debugln("");
+					//Check CRC
+					crc8=0xFF;	// Init = 0xFF
+					for(uint8_t i=0;i<MLINK_PACKET_SIZE-1;i++)
+						crc8_update(bit_reverse(packet[i<<1]));
+					if(packet[14] == bit_reverse(crc8))
+					{// CRC is ok
+						debugln("CRC ok");
+						if(packet[0]==0x7F)
+							packet_count=3;					// Start sending bind payload
+						else if(packet_count > 0x19*2)
+						{
+							if(packet[0] == 0x8F)
+								packet_count++;
+							else if(packet[0] == 0x9F)
+								packet_count=0x80;			// End bind
+							else
+								packet_count=0;				// Restart bind...
+						}
+					}
+				}
+			}
+			else
+				packet_count=0;
+			CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x20);		// Enable RX abort
+			CYRF_WriteRegister(CYRF_0F_XACT_CFG, 0x24);		// Force end state
+			CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x00);		// Disable RX abort
+			phase=MLINK_BIND_TX;							// Retry sending bind packet
+			CYRF_SetTxRxMode(TX_EN);						// Transmit mode
+			if(packet_count)
+				return 18136;
+		case MLINK_BIND_TX:
+			if(--bind_counter==0 || packet_count>=0x1B*2)
+			{ // Switch to normal mode
+				BIND_DONE;
+				phase=MLINK_PREP_DATA;
+				return 22720;
+			}
+			MLINK_send_bind_packet();
+			if(packet_count == 0 || packet_count > 0x19*2)
+			{
+				phase++;		// MLINK_BIND_PREP_RX
+				return 4700;	// Original is 4900
+			}
+			packet_count++;
+			if(packet_count&1)
+				return 6000;
+			return 22720;
+		case MLINK_BIND_PREP_RX:
+			start=micros();
+			while ((uint16_t)((uint16_t)micros()-(uint16_t)start) < 200)	// Wait max 200µs for TX to finish
+				if((CYRF_ReadRegister(CYRF_02_TX_CTRL) & 0x80) == 0x00)
+					break;										// Packet transmission complete
+			CYRF_SetTxRxMode(RX_EN);							// Receive mode
+			CYRF_WriteRegister(CYRF_05_RX_CTRL, 0x82);			// Prepare to receive
+			phase++;	//MLINK_BIND_RX
+			if(packet_count > 0x19*2)
+				return 28712;									// Give more time to the RX to confirm that the bind is ok...
+			return 28712-4700;
+
+
+		case MLINK_PREP_DATA:
+			CYRF_ConfigDataCode(MLINK_Data_Code,16);
+			MLINK_CRC_Init += 0xED;
+			hopping_frequency_no = 0x00;
+			CYRF_ConfigRFChannel(hopping_frequency[hopping_frequency_no]);
+			CYRF_SetPower(0x38);
+			#if defined(MLINK_HUB_TELEMETRY) || defined(MLINK_FW_TELEMETRY)
+				packet_count = 0;
+				telemetry_lost = 1;
+			#endif
+			phase++;
+
+
+		case MLINK_SEND1:
+			MLINK_send_data_packet();
+			phase++;
+			return 4880+1111;
+		case MLINK_SEND2:
+			MLINK_send_data_packet();
+			phase++;
+			if(hopping_frequency_no%5==0)
+				return 4617+1017;
+			return 4617+1422;
+		case MLINK_SEND3:
+			MLINK_send_data_packet();
+			phase++;
+			return 4611;
+		case MLINK_CHECK3:
+			//Switch to next channel
+			hopping_frequency_no++;
+			if(hopping_frequency_no>=MLINK_NUM_FREQ)
+				hopping_frequency_no=0;
+			CYRF_ConfigRFChannel(hopping_frequency[hopping_frequency_no]);
+			
+			//Receive telemetry
+			if(hopping_frequency_no%5==0)
+			{//Receive telemetry
+				CYRF_SetTxRxMode(RX_EN);							// Receive mode
+				CYRF_WriteRegister(CYRF_05_RX_CTRL, 0x82);			// Prepare to receive
+				phase++;	//MLINK_RX
+				return 8038+2434+410-1000;
+			}
+			else
+				CYRF_SetPower(0x38);
+			phase=MLINK_SEND1;
+			return 4470;
+		case MLINK_RX:
+			#if defined(MLINK_HUB_TELEMETRY) || defined(MLINK_FW_TELEMETRY)
+				//TX LQI calculation
+				packet_count++;
+				if(packet_count>=50)
+				{
+					packet_count=0;
+					TX_LQI=telemetry_counter;
+					if(telemetry_counter==0)
+						telemetry_lost = 1;
+					telemetry_counter = 0;
+				}
+			#endif
+			status=CYRF_ReadRegister(CYRF_05_RX_CTRL);
+			debug("T(%02X):",status);
+			if( (status&0x80) == 0 )
+			{//Packet received
+				len=CYRF_ReadRegister(CYRF_09_RX_COUNT);
+				debug("(%X)",len)
+				if( len && len <= MLINK_PACKET_SIZE )
+				{
+					CYRF_ReadDataPacketLen(packet_in, len*2);
+					#if defined(MLINK_HUB_TELEMETRY) || defined(MLINK_FW_TELEMETRY)
+						if(len==MLINK_PACKET_SIZE)
+						{
+							for(uint8_t i=0;i<8;i++)
+							//Check CRC
+							crc8=bit_reverse(MLINK_CRC_Init);
+							for(uint8_t i=0;i<MLINK_PACKET_SIZE-1;i++)
+							{
+								packet_in[i]=packet_in[i<<1];
+								crc8_update(bit_reverse(packet_in[i]));
+								debug(" %02X",packet_in[i]);
+							}
+							if(packet_in[14] == bit_reverse(crc8))	// Packet CRC is ok
+								MLINK_Send_Telemetry();
+							else
+								debug(" NOK");
+						}
+					#endif
+				}
+			}
+			debugln("");
+			CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x20);		// Enable RX abort
+			CYRF_WriteRegister(CYRF_0F_XACT_CFG, 0x24);		// Force end state
+			CYRF_WriteRegister(CYRF_29_RX_ABORT, 0x00);		// Disable RX abort
+			CYRF_SetTxRxMode(TX_EN);						// Transmit mode
+			phase=MLINK_SEND2;
+			return 1000;
+	}
+	return 1000;
+}
+
+static void __attribute__((unused)) MLINK_shuffle_freqs(uint32_t seed, uint8_t *hop)
+{
+	randomSeed(seed);
+	
+	for(uint8_t i=0; i < MLINK_NUM_FREQ/2; i++)
+	{
+		uint8_t r   = random(0xfefefefe) % (MLINK_NUM_FREQ/2);
+		uint8_t tmp = hop[r];
+		hop[r] = hop[i];
+		hop[i] = tmp;
+	}
+}
+
+void MLINK_init()
+{ 
+	MLINK_cyrf_config();
+
+	//Init ID and RF freqs
+	for(uint8_t i=0; i < MLINK_NUM_FREQ/2; i++)
+	{
+		hopping_frequency[i                 ] = (i<<1) + 3;
+		hopping_frequency[i+MLINK_NUM_FREQ/2] = (i<<1) + 3;
+	}
+	// part1
+	memcpy(MLINK_Data_Code  ,rx_tx_addr,4);
+	MLINK_shuffle_freqs(MProtocol_id, hopping_frequency);
+
+	// part2
+	MProtocol_id ^= 0x6FBE3201;
+	set_rx_tx_addr(MProtocol_id);
+	memcpy(MLINK_Data_Code+4,rx_tx_addr,4);
+	MLINK_shuffle_freqs(MProtocol_id, &hopping_frequency[MLINK_NUM_FREQ/2]);
+	
+	// part3
+	MLINK_CRC_Init = rx_tx_addr[3];		//value sent during bind then used to init the CRC
+	MLINK_Unk_6_2  = 0x3A;		//unknown value sent during bind but doesn't seem to matter
+	
+	#ifdef MLINK_FORCE_ID
+		if(RX_num)
+		{
+			//Cockpit SX
+			memcpy(MLINK_Data_Code,"\x4C\x97\x9D\xBF\xB8\x3D\xB5\xBE",8);
+			memcpy(hopping_frequency,"\x0D\x41\x09\x43\x17\x2D\x05\x31\x13\x3B\x1B\x3D\x0B\x41\x11\x45\x09\x2B\x17\x4D\x19\x3F\x03\x3F\x0F\x37\x1F\x47\x1B\x49\x07\x35\x27\x2F\x15\x33\x23\x39\x1F\x33\x19\x45\x0D\x2D\x11\x35\x0B\x47\x25\x3D\x21\x37\x1D\x3B\x05\x2F\x21\x39\x23\x4B\x03\x31\x25\x29\x07\x4F\x1D\x4B\x15\x4D\x13\x4F\x0F\x49\x29\x2B\x27\x43",MLINK_NUM_FREQ);
+			MLINK_Unk_6_2  = 0x3A;		//unknown value sent during bind but doesn't seem to matter
+			MLINK_CRC_Init = 0x07;		//value sent during bind then used to init the CRC
+		}
+		else
+		{
+			//HFM3
+			memcpy(MLINK_Data_Code,"\xC0\x90\x8F\xBB\x7C\x8E\x2B\x8E",8);
+			memcpy(hopping_frequency,"\x05\x41\x27\x4B\x17\x33\x11\x39\x0F\x3F\x05\x2F\x13\x2D\x25\x31\x1F\x2D\x25\x35\x03\x41\x1B\x43\x09\x3D\x1F\x29\x1D\x35\x0D\x3B\x19\x49\x23\x3B\x17\x47\x1D\x2B\x13\x37\x0B\x31\x23\x33\x29\x3F\x07\x37\x07\x43\x11\x2B\x1B\x39\x0B\x4B\x03\x4F\x21\x47\x0F\x4D\x15\x45\x21\x4F\x09\x3D\x19\x2F\x15\x45\x0D\x49\x27\x4D",MLINK_NUM_FREQ);
+			MLINK_Unk_6_2  = 0x02;		//unknown value but doesn't seem to matter
+			MLINK_CRC_Init = 0x3E;		//value sent during bind then used to init the CRC
+		}
+		//Other TX
+		//MLINK_Unk_6_2  = 0x7e;		//unknown value but doesn't seem to matter
+		//MLINK_CRC_Init = 0xA2;		//value sent during bind then used to init the CRC
+	#endif
+
+	for(uint8_t i=0;i<8;i++)
+		MLINK_Data_Code[i+8]=MLINK_Data_Code[7-i];
+
+	debug("ID:")
+	for(uint8_t i=0;i<16;i++)
+		debug(" %02X", MLINK_Data_Code[i]);
+	debugln("");
+
+	debugln("CRC init: %02X", MLINK_CRC_Init)
+
+	debug("RF:")
+	for(uint8_t i=0;i<MLINK_NUM_FREQ;i++)
+		debug(" %02X", hopping_frequency[i]);
+	debugln("");
+	
+	if(IS_BIND_IN_PROGRESS)
+	{
+		packet_count = 0;
+		bind_counter = MLINK_BIND_COUNT;
+		CYRF_ConfigDataCode((uint8_t*)"\x6F\xBE\x32\x01\xDB\xF1\x2B\x01\xE3\x5C\xFA\x02\x97\x93\xF9\x02",16); //Bind data code
+		CYRF_ConfigRFChannel(MLINK_BIND_CHANNEL);
+		phase = MLINK_BIND_TX;
+	}
+	else
+		phase = MLINK_PREP_DATA;
+}
+
+#endif

Multiprotocol/MT99xx_ccnrf.ino

@@ -0,0 +1,540 @@
+/*
+ This project is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Multiprotocol is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Multiprotocol.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// compatible with MT99xx, Eachine H7, Yi Zhan i6S and LS114/124
+// Last sync with Goebish mt99xx_nrf24l01.c dated 2016-01-29
+
+#if defined(MT99XX_CCNRF_INO)
+
+#include "iface_xn297.h"
+
+#define MT99XX_BIND_COUNT			928
+#define MT99XX_PACKET_PERIOD_FY805	2460
+#define MT99XX_PACKET_PERIOD_MT		2625
+#define MT99XX_PACKET_PERIOD_YZ		3125
+#define MT99XX_PACKET_PERIOD_A180	3400	// timing changes between the packets 2 x 27220 then 1x 26080, it seems that it is only on the first RF channel which jitters by 1.14ms but hard to pinpoint with XN297dump
+#define MT99XX_PACKET_PERIOD_DRAGON	1038	// there is a pause of 2x1038 between two packets, no idea why and how since it is not even stable on a same dump...
+#define MT99XX_PACKET_PERIOD_DRAGON_TELEM	10265	// long pause to receive the telemetry packets, 3 are sent by the RX one after the other
+#define MT99XX_PACKET_PERIOD_F949G	3450
+#define MT99XX_PACKET_PERIOD_PA18	1338
+#define MT99XX_INITIAL_WAIT			500
+#define MT99XX_PACKET_SIZE			9
+
+//#define FORCE_A180_ID
+//#define FORCE_DRAGON_ID
+//#define FORCE_F949G_ID
+#define FORCE_PA18_ID1
+//#define FORCE_PA18_ID2
+
+enum {
+    MT99XX_DATA,
+    MT99XX_RX,
+    MT99XX_CHECK,
+};
+
+enum{
+    // flags going to packet[6] (MT99xx, H7)
+    FLAG_MT_RATE1   = 0x01, // (H7 & A180 high rate)
+    FLAG_MT_RATE2   = 0x02, // (MT9916 only)
+    FLAG_MT_VIDEO   = 0x10,
+    FLAG_MT_SNAPSHOT= 0x20,
+    FLAG_MT_FLIP    = 0x80,
+};
+
+enum{
+    // flags going to packet[6] (LS)
+    FLAG_LS_INVERT  = 0x01,
+    FLAG_LS_RATE    = 0x02,
+    FLAG_LS_HEADLESS= 0x10,
+    FLAG_LS_SNAPSHOT= 0x20,
+    FLAG_LS_VIDEO   = 0x40,
+    FLAG_LS_FLIP    = 0x80,
+};
+
+enum{
+    // flags going to packet[7] (FY805)
+    FLAG_FY805_HEADLESS= 0x10,
+};
+
+enum{
+    // flags going to packet[6] (A180)
+    FLAG_A180_3D6G	= 0x01,
+    FLAG_A180_RATE	= 0x02,
+};
+
+enum{
+    // flags going to packet[6] (DRAGON)
+    FLAG_DRAGON_RATE	= 0x01,
+    FLAG_DRAGON_RTH		= 0x80,
+    FLAG_DRAGON_UNK		= 0x04,
+};
+
+enum{
+    // flags going to packet[6] (F949G)
+    FLAG_F949G_LIGHT	= 0x01,
+    FLAG_F949G_3D6G		= 0x20,
+};
+enum{
+    // flags going to packet[6] (PA18)
+	FLAG_PA18_RTH		= 0x08,
+	FLAG_PA18_FLIP		= 0x80,
+};
+
+const uint8_t h7_mys_byte[] = {
+	0x01, 0x11, 0x02, 0x12, 0x03, 0x13, 0x04, 0x14, 
+	0x05, 0x15, 0x06, 0x16, 0x07, 0x17, 0x00, 0x10
+};
+
+const uint8_t ls_mys_byte[] = {
+	0x05, 0x15, 0x25, 0x06, 0x16, 0x26,
+	0x07, 0x17, 0x27, 0x00, 0x10, 0x20,
+	0x01, 0x11, 0x21, 0x02, 0x12, 0x22,
+	0x03, 0x13, 0x23, 0x04, 0x14, 0x24
+};
+
+const uint8_t yz_p4_seq[] = {0xa0, 0x20, 0x60};
+
+#ifdef MT99XX_HUB_TELEMETRY
+	const uint8_t DRAGON_seq[] = {0x20, 0x60, 0x20, 0x80};
+#endif
+
+static void __attribute__((unused)) MT99XX_send_packet()
+{
+	static uint8_t seq_num=0;
+
+	//Set RF freq
+	if(sub_protocol == LS)
+		XN297_RFChannel(0x2D); 			// LS always transmits on the same channel
+	else
+		if(sub_protocol==FY805)
+			XN297_RFChannel(0x4B);		// FY805 always transmits on the same channel
+		else // MT99 & H7 & YZ & A180 & DRAGON & F949G & PA18
+			XN297_Hopping(hopping_frequency_no);
+
+	if(IS_BIND_IN_PROGRESS)
+	{
+		//Bind packet
+		packet[0] = 0x20;
+		switch(sub_protocol)
+		{
+			case YZ:
+				packet[1] = 0x15;
+				packet[2] = 0x05;
+				packet[3] = 0x06;
+				break;
+			case LS:
+				packet[1] = 0x14;
+				packet[2] = 0x05;
+				packet[3] = 0x11;
+				break;
+			case FY805:
+				packet[1] = 0x15;
+				packet[2] = 0x12;
+				packet[3] = 0x17;
+				break;
+			default:	// MT99 & H7 & A180 & DRAGON & F949G & PA18
+				packet[1] = 0x14;
+				packet[2] = 0x03;
+				packet[3] = 0x25;
+				break;
+		}
+		packet[4] = rx_tx_addr[0];
+		packet[5] = rx_tx_addr[1];
+		packet[6] = rx_tx_addr[2];
+		if(sub_protocol == PA18+8)
+		{
+			packet[7] = num_ch;											// checksum offset
+			packet[8] = 0x55;											// fixed
+		}
+		else
+		{ // all others
+			packet[7] = crc8;											// checksum offset
+			if(sub_protocol != F949G)
+				packet[8] = 0xAA;										// fixed
+			else
+				packet[8] = 0x00;
+		}
+	}
+	else
+	{
+		if(sub_protocol != YZ)
+		{ // MT99XX & H7 & LS & FY805 & A180 & DRAGON & F949G & PA18
+			packet[0] = convert_channel_16b_limit(THROTTLE,0xE1,0x00);	// throttle
+			packet[1] = convert_channel_16b_limit(RUDDER  ,0x00,0xE1);	// rudder
+			packet[2] = convert_channel_16b_limit(AILERON ,0xE1,0x00);	// aileron
+			packet[3] = convert_channel_16b_limit(ELEVATOR,0x00,0xE1);	// elevator
+			packet[4] = 0x20; 											// pitch trim (0x3f-0x20-0x00)
+			packet[5] = 0x20; 											// roll trim (0x00-0x20-0x3f)
+			packet[6] = GET_FLAG( CH5_SW, FLAG_MT_FLIP );
+			if(sub_protocol != PA18+8)
+				packet[7] = h7_mys_byte[hopping_frequency_no];			// next rf channel index ?
+			else
+				packet[7] = (packet[7]&0xBF)|0x20;
+			switch(sub_protocol)
+			{
+				case MT99:
+					packet[6] |= 0x40 | FLAG_MT_RATE2					// max rate on MT99xx
+					  | GET_FLAG( CH7_SW, FLAG_MT_SNAPSHOT )
+					  | GET_FLAG( CH8_SW, FLAG_MT_VIDEO );
+					break;
+				case H7:
+					packet[6] |= FLAG_MT_RATE1; 						// max rate on H7
+					break;
+				case LS:
+					packet[6] |= FLAG_LS_RATE							// max rate
+						| GET_FLAG( CH6_SW, FLAG_LS_INVERT )			// invert
+						| GET_FLAG( CH7_SW, FLAG_LS_SNAPSHOT )			// snapshot
+						| GET_FLAG( CH8_SW, FLAG_LS_VIDEO )				// video
+						| GET_FLAG( CH9_SW, FLAG_LS_HEADLESS );			// Headless
+					packet[7] = ls_mys_byte[seq_num++];
+					if(seq_num >= sizeof(ls_mys_byte))
+						seq_num=0;
+					break;
+				case FY805:
+					packet[6]=0x20;
+					//Rate 0x01?
+					//Flip ?
+					packet[7]=0x01
+						|GET_FLAG( CH5_SW, FLAG_MT_FLIP )
+						|GET_FLAG( CH9_SW, FLAG_FY805_HEADLESS );		//HEADLESS
+					crc8=0;
+					break;
+				case A180:
+					packet[6] = GET_FLAG( !CH6_SW,FLAG_A180_RATE)		// 0x02, A180=RATE,  F949S=LED
+							   |GET_FLAG( CH5_SW, FLAG_A180_3D6G )		// 0x01, A180=3D_6G, F949S=RATE
+							   |GET_FLAG( CH7_SW, 0x20 );				// 0x20, F949S=3D_6G
+					packet[7] = 0x00;
+					break;
+				case DRAGON:
+					if(CH5_SW)											// Advanced mode
+						packet[5] |= 0x80;
+					else
+						if(Channel_data[CH5] > CHANNEL_MIN_COMMAND)		// Beginner mode
+							packet[5] |= 0x40;
+					packet[6] = FLAG_DRAGON_RATE
+						| GET_FLAG( CH6_SW, FLAG_DRAGON_RTH );
+					
+					#ifdef MT99XX_HUB_TELEMETRY
+						//Telemetry
+						if(hopping_frequency_no == 0)
+						{
+							seq_num++;
+							seq_num &= 0x03;
+							packet_count++;
+							if(packet_count > 11)
+								packet_count = 0;
+						}
+						if(packet_count > 10)							// Telemetry packet request every 10 or 11 packets
+						{
+							packet[6] |= 0x04;							// Request telemetry flag
+							phase = MT99XX_RX;
+						}
+						packet[7] = DRAGON_seq[seq_num];				// seq: 20 80 20 60 20 80 20 60... 80 changes to 80+batt from telem
+						if(seq_num==3)
+							packet[7] |= v_lipo1;
+					#else
+						packet[7] = 0x20;
+					#endif
+					break;
+				case F949G:
+					packet[6] = 0x02
+							  | GET_FLAG( CH5_SW, FLAG_F949G_3D6G )
+							  | GET_FLAG( CH6_SW, FLAG_F949G_LIGHT );
+					packet[7] = 0x00;
+					break;
+				case PA18+8:
+					if(Channel_data[CH5] > CHANNEL_MAX_COMMAND)			// Expert mode
+						packet[5] = 0xA0;
+					else
+						if(Channel_data[CH5] > CHANNEL_MIN_COMMAND)		// Intermediate mode
+							packet[5] = 0x60;
+					packet[6] = GET_FLAG( CH6_SW, FLAG_PA18_FLIP )		// Flip
+							  | GET_FLAG( CH7_SW, FLAG_PA18_RTH );		// RTH
+					if(hopping_frequency_no == 0)
+						packet[7] ^= 0x40;
+					break;
+			}
+			uint8_t result=crc8;
+			for(uint8_t i=0; i<8; i++)
+				result += packet[i];
+			if(sub_protocol == PA18+8)
+				result += num_ch;
+			packet[8] = result;
+		}
+		else
+		{ // YZ
+			packet[0] = convert_channel_16b_limit(THROTTLE,0x00,0x64);		// throttle
+			packet[1] = convert_channel_16b_limit(RUDDER  ,0x64,0x00);		// rudder
+			packet[2] = convert_channel_16b_limit(ELEVATOR,0x00,0x64);		// elevator
+			packet[3] = convert_channel_16b_limit(AILERON ,0x64,0x00);		// aileron
+			if(packet_count++ >= 23)
+			{
+				seq_num ++;
+				if(seq_num > 2)
+					seq_num = 0;
+				packet_count=0;
+			}
+			packet[4] = yz_p4_seq[seq_num];
+			packet[5] = 0x02 // expert ? (0=unarmed, 1=normal)
+						| GET_FLAG(CH8_SW, 0x10)							//VIDEO
+						| GET_FLAG(CH5_SW, 0x80)							//FLIP
+						| GET_FLAG(CH9_SW, 0x04)							//HEADLESS
+						| GET_FLAG(CH7_SW, 0x20);							//SNAPSHOT
+			packet[6] =   GET_FLAG(CH6_SW, 0x80);							//LED
+			packet[7] = packet[0];            
+			for(uint8_t idx = 1; idx < MT99XX_PACKET_SIZE-2; idx++)
+				packet[7] += packet[idx];
+			packet[8] = 0xff;
+		}
+	}
+
+	//Hopp
+	hopping_frequency_no++;
+	if(sub_protocol == YZ || sub_protocol == A180 || sub_protocol == DRAGON || sub_protocol == F949G || sub_protocol == PA18+8)
+		hopping_frequency_no++; // skip every other channel
+	if(hopping_frequency_no > 15)
+		hopping_frequency_no = 0;
+
+	// Send
+	XN297_SetPower();
+	XN297_SetFreqOffset();
+	XN297_SetTxRxMode(TX_EN);
+	XN297_WritePayload(packet, MT99XX_PACKET_SIZE);
+	
+	#if 0
+		for(uint8_t i=0; i<MT99XX_PACKET_SIZE; i++)
+			debug(" %02X",packet[i]);
+		debugln();
+	#endif
+}
+
+static void __attribute__((unused)) MT99XX_RF_init()
+{
+    if(sub_protocol == YZ)
+		XN297_Configure(XN297_CRCEN, XN297_UNSCRAMBLED, XN297_250K);
+	else if(sub_protocol == F949G)
+		XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_250K);
+	else
+		XN297_Configure(XN297_CRCEN, XN297_SCRAMBLED, XN297_1M);
+    XN297_SetTXAddr((uint8_t *)"\xCC\xCC\xCC\xCC\xCC", 5);
+	XN297_HoppingCalib(16);
+	#ifdef MT99XX_HUB_TELEMETRY
+		XN297_SetRXAddr(rx_tx_addr, MT99XX_PACKET_SIZE);
+	#endif
+
+}
+
+static void __attribute__((unused)) MT99XX_initialize_txid()
+{
+	num_ch = rx_tx_addr[1];			// PA18
+	rx_tx_addr[1] = rx_tx_addr[3];	// RX_Num
+	switch(sub_protocol)
+	{
+		case YZ:
+			rx_tx_addr[0] = 0x53;	// test (SB id)
+			rx_tx_addr[1] = 0x00;
+			rx_tx_addr[2] = 0x00;
+			break;
+		case FY805:
+			rx_tx_addr[0] = 0x81;	// test (SB id)
+			rx_tx_addr[1] = 0x0F;
+			rx_tx_addr[2] = 0x00;
+			break;
+		case LS:
+			rx_tx_addr[0] = 0xCC;
+			break;
+	#ifdef FORCE_A180_ID
+		case A180:
+			rx_tx_addr[0] = 0x84;	// MikeHRC ID
+			rx_tx_addr[1] = 0x62;
+			rx_tx_addr[2] = 0x4A;
+			//crc8 = 0x30
+			//channel_offset  = 0x03;
+			break;
+	#endif
+	#ifdef FORCE_DRAGON_ID
+		case DRAGON:
+			rx_tx_addr[0] = 0x6C;	// Laurie ID
+			rx_tx_addr[1] = 0x00;
+			rx_tx_addr[2] = 0x22;
+			//crc8 = 0x8E
+			//channel_offset  = 0x06
+			break;
+	#endif
+	#ifdef FORCE_F949G_ID
+		case F949G:
+			rx_tx_addr[0] = 0x7E;	// LilTeo14 ID
+			rx_tx_addr[1] = 0x2F;
+			rx_tx_addr[2] = 0x29;
+			//crc8 = 0xD6
+			//channel_offset  = 0x03
+			break;
+	#endif
+	#ifdef FORCE_PA18_ID1
+		case PA18+8:
+			rx_tx_addr[0] = 0xC9;	// zebble ID
+			rx_tx_addr[1] = 0x02;
+			rx_tx_addr[2] = 0x13;
+			num_ch = 0x89;			// additional crc init. How is this calculated? or could it be random?
+			//crc8 = 0xDE
+			//channel_offset  = 0x03
+			//1Mb C=5 S=Y A= C9 02 13 CC CC P(9)= E1 70 70 70 20 20 00 20 1A -> 0x91 + 0x89 => 0x1A
+			//        S=Y A= C9 02 13 CC CC P(9)= E1 70 70 70 20 A0 00 20 9A -> 0x11 + 0x89 => 0x9A
+			//bind    S=Y A= CC CC CC CC CC P(9)= 20 14 03 25 C9 02 13 89 55
+			break;
+	#endif
+	#ifdef FORCE_PA18_ID2
+		case PA18+8:
+			rx_tx_addr[0] = 0x0E;
+			rx_tx_addr[1] = 0x05;
+			rx_tx_addr[2] = 0x13;
+			num_ch = 0xD1;			// additional crc init. How is this calculated? or could it be random?
+			//crc8 = 0x28
+			//channel_offset  = 0x00
+			//1Mb C=2 S=Y A= 0E 05 13 CC CC P(9)= E1 70 70 70 20 60 00 60 E2 -> 0x11 + 0xD1 => 0xE2
+			//bind    S=Y A= CC CC CC CC CC P(9)= 20 14 03 25 0E 05 13 D1 55
+			break;
+	#endif
+		default: //MT99 & H7 & A180 & DRAGON & F949G & PA18
+			rx_tx_addr[2] = 0x00;
+			if(sub_protocol == PA18+8)
+				rx_tx_addr[2] = 0x13;
+			break;
+	}
+	
+	rx_tx_addr[3] = 0xCC;
+	rx_tx_addr[4] = 0xCC;
+
+	crc8 = rx_tx_addr[0] + rx_tx_addr[1] + rx_tx_addr[2];
+
+	//memcpy(hopping_frequency,"\x02\x48\x0C\x3e\x16\x34\x20\x2A\x2A\x20\x34\x16\x3e\x0c\x48\x02",16);
+	for(uint8_t i=0; i<8; i++)
+	{
+		hopping_frequency[(i<<1)  ]=0x02 + (10*i);
+		hopping_frequency[(i<<1)+1]=0x48 - (10*i);
+	}
+	hopping_frequency_no=0;
+}
+
+uint16_t MT99XX_callback()
+{
+	switch(phase)
+	{
+		case MT99XX_DATA:
+			#ifdef MULTI_SYNC
+				telemetry_set_input_sync(packet_period);
+			#endif
+			if(bind_counter)
+			{
+				bind_counter--;
+				if (bind_counter == 0)
+				{
+					// set tx address for data packets
+					XN297_SetTXAddr(rx_tx_addr, 5);
+					// set rf channels
+					uint8_t channel_offset = ((crc8>>4) + (crc8 & 0x0f)) % 8;
+					for(uint8_t i=0;i<16;i++)
+						hopping_frequency[i] += channel_offset;
+					XN297_HoppingCalib(16);
+					BIND_DONE;
+				}
+			}
+			MT99XX_send_packet();
+			break;
+		#ifdef MT99XX_HUB_TELEMETRY
+		case MT99XX_RX:
+			//Switch to RX
+			XN297_SetTxRxMode(TXRX_OFF);
+			XN297_SetTxRxMode(RX_EN);
+			phase++;
+			return MT99XX_PACKET_PERIOD_DRAGON_TELEM - MT99XX_PACKET_PERIOD_DRAGON - 500;
+		case MT99XX_CHECK:
+			//Check telem
+			if(XN297_IsRX())
+			{
+				//debug("RX");
+				if(XN297_ReadPayload(packet_in, MT99XX_PACKET_SIZE))
+				{
+					// C=48 S=Y A= 6C 00 22 CC CC P(9)= 6C 00 22 27 00 00 00 00 60
+					// C=48 S=Y A= 6C 00 22 CC CC P(9)= 6C 00 22 28 00 00 00 00 61
+					// C=18 S=Y A= 6C 00 22 CC CC P(9)= 6C 00 22 24 00 00 00 00 5D
+					// 6C 00 22 = TX address, 27/28/24=vbatt, check = sum(P[0..7]) + AB
+					// D2 EE 00 25 00 00 00 00 90 -> check also + AB
+					//for(uint8_t i=0; i<MT99XX_PACKET_SIZE; i++)
+					//	debug(" %02X",packet_in[i]);
+					uint8_t check=0xAB;
+					for(uint8_t i=0; i<8; i++)
+						check += packet_in[i];
+					if(packet_in[8] == check && packet_in[0] == rx_tx_addr[0] && packet_in[1] == rx_tx_addr[1] && packet_in[2] == rx_tx_addr[2])
+					{ // checksum and address are ok
+					//	debug(" OK");
+						v_lipo1 = packet_in[3] & 0x7F;	// Batt
+						v_lipo2 = packet_in[3] & 0x80;	// Low batt flag
+						RX_RSSI=100;
+						telemetry_link = 1;
+					}
+				}
+				//debugln("");
+			}
+			//Switch to TX
+			XN297_SetTxRxMode(TXRX_OFF);
+			XN297_SetTxRxMode(TX_EN);
+			phase=MT99XX_DATA;
+			return 500;
+		#endif
+	}
+	return packet_period;
+}
+
+void MT99XX_init(void)
+{
+	if(protocol == PROTO_MT99XX2)
+		sub_protocol|=0x08;		// Increase the number of sub_protocols for MT99XX
+
+    bind_counter = MT99XX_BIND_COUNT;
+	if(IS_BIND_DONE)
+	{		
+		if(sub_protocol != A180 && sub_protocol != DRAGON && sub_protocol != F949G && sub_protocol != PA18+8)
+			BIND_IN_PROGRESS;	// autobind protocol
+		else
+		    bind_counter = 1;
+	}
+
+	MT99XX_initialize_txid();
+	MT99XX_RF_init();
+
+	switch(sub_protocol)
+	{
+		case YZ:
+			packet_period = MT99XX_PACKET_PERIOD_YZ;
+			break;
+		case FY805:
+			packet_period = MT99XX_PACKET_PERIOD_FY805;
+			break;
+		case F949G:
+		case A180:
+			packet_period = MT99XX_PACKET_PERIOD_A180;
+			break;
+		case PA18+8:
+			packet_period = MT99XX_PACKET_PERIOD_PA18;
+			break;
+		default:
+			packet_period = MT99XX_PACKET_PERIOD_MT;
+			break;
+	}
+
+	packet_count=0;
+	phase=MT99XX_DATA;
+}
+#endif