diff --git a/radio/src/functions.cpp b/radio/src/functions.cpp
index 39bc882bf..b57fb9e0c 100644
--- a/radio/src/functions.cpp
+++ b/radio/src/functions.cpp
@@ -235,7 +235,7 @@ void evalFunctions(const CustomFunctionData * functions, CustomFunctionsContext
           {
             unsigned int moduleIndex = CFN_PARAM(cfn);
             if (moduleIndex < NUM_MODULES) {
-              moduleSettings[moduleIndex].mode = 1 + CFN_FUNC(cfn) - FUNC_RANGECHECK;
+              moduleState[moduleIndex].mode = 1 + CFN_FUNC(cfn) - FUNC_RANGECHECK;
             }
             break;
           }
@@ -406,7 +406,7 @@ void evalFunctions(const CustomFunctionData * functions, CustomFunctionsContext
             {
               unsigned int moduleIndex = CFN_PARAM(cfn);
               if (moduleIndex < NUM_MODULES) {
-                moduleSettings[moduleIndex].mode = 0;
+                moduleState[moduleIndex].mode = 0;
               }
               break;
             }
diff --git a/radio/src/gui/128x64/model_module_options.cpp b/radio/src/gui/128x64/model_module_options.cpp
index 45fb3dda1..3e6faf8ec 100644
--- a/radio/src/gui/128x64/model_module_options.cpp
+++ b/radio/src/gui/128x64/model_module_options.cpp
@@ -27,15 +27,10 @@ extern uint8_t g_moduleIdx;
 
 void onTxOptionsUpdateConfirm(const char * result)
 {
-  if (result == STR_OK) {
-    reusableBuffer.hardwareAndSettings.moduleSettings.state = PXX2_SETTINGS_WRITE;
-    reusableBuffer.hardwareAndSettings.moduleSettings.dirty = 2;
-    reusableBuffer.hardwareAndSettings.moduleSettings.timeout = 0;
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_MODULE_SETTINGS;
-  }
-  else {
+  if (result == STR_OK)
+    moduleState[g_moduleIdx].readModuleSettings(&reusableBuffer.hardwareAndSettings.moduleSettings);
+  else
     popMenu();
-  }
 }
 
 enum {
@@ -90,21 +85,18 @@ void menuModelModuleOptions(event_t event)
 #if defined(SIMU)
     reusableBuffer.hardwareAndSettings.moduleSettings.state = PXX2_SETTINGS_OK;
 #else
-    // no need to initialize reusableBuffer.hardwareAndSettings.moduleSettings.state to PXX2_HARDWARE_INFO
-    reusableBuffer.hardwareAndSettings.modules[g_moduleIdx].current = PXX2_HW_INFO_TX_ID;
-    reusableBuffer.hardwareAndSettings.modules[g_moduleIdx].maximum = PXX2_HW_INFO_TX_ID;
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_GET_HARDWARE_INFO;
+    // no need to initialize reusableBuffer.hardwareAndSettings.moduleState.state to PXX2_HARDWARE_INFO
+    moduleState[g_moduleIdx].readModuleInformation(&reusableBuffer.hardwareAndSettings.modules[g_moduleIdx], PXX2_HW_INFO_TX_ID, PXX2_HW_INFO_TX_ID);
 #endif
   }
 
-  if (reusableBuffer.hardwareAndSettings.moduleSettings.state == PXX2_HARDWARE_INFO && moduleSettings[g_moduleIdx].mode == MODULE_MODE_NORMAL) {
-    reusableBuffer.hardwareAndSettings.moduleSettings.state = PXX2_SETTINGS_READ;
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_MODULE_SETTINGS;
+  if (reusableBuffer.hardwareAndSettings.moduleSettings.state == PXX2_HARDWARE_INFO && moduleState[g_moduleIdx].mode == MODULE_MODE_NORMAL) {
+    moduleState[g_moduleIdx].readModuleSettings(&reusableBuffer.hardwareAndSettings.moduleSettings);
   }
 
   if (menuEvent) {
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_NORMAL;
-    if (reusableBuffer.hardwareAndSettings.moduleSettings.dirty) {
+    moduleState[g_moduleIdx].mode = MODULE_MODE_NORMAL;
+    if (reusableBuffer.hardwareAndSettings.moduleSettingsDirty) {
       abortPopMenu();
       POPUP_CONFIRMATION("Update TX options?", onTxOptionsUpdateConfirm);
     }
@@ -113,15 +105,13 @@ void menuModelModuleOptions(event_t event)
     }
   }
 
-  if (event == EVT_KEY_LONG(KEY_ENTER) && reusableBuffer.hardwareAndSettings.moduleSettings.dirty) {
+  if (event == EVT_KEY_LONG(KEY_ENTER) && reusableBuffer.hardwareAndSettings.moduleSettingsDirty) {
     killEvents(event);
-    reusableBuffer.hardwareAndSettings.moduleSettings.state = PXX2_SETTINGS_WRITE;
-    reusableBuffer.hardwareAndSettings.moduleSettings.dirty = 0;
-    reusableBuffer.hardwareAndSettings.moduleSettings.timeout = 0;
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_MODULE_SETTINGS;
+    reusableBuffer.hardwareAndSettings.moduleSettingsDirty = 0;
+    moduleState[g_moduleIdx].writeModuleSettings(&reusableBuffer.hardwareAndSettings.moduleSettings);
   }
 
-  if (reusableBuffer.hardwareAndSettings.moduleSettings.dirty == 2 && reusableBuffer.hardwareAndSettings.moduleSettings.state == PXX2_SETTINGS_OK) {
+  if (reusableBuffer.hardwareAndSettings.moduleSettingsDirty == 2 && reusableBuffer.hardwareAndSettings.moduleSettings.state == PXX2_SETTINGS_OK) {
     popMenu();
   }
 
@@ -155,7 +145,7 @@ void menuModelModuleOptions(event_t event)
           if (attr) {
             reusableBuffer.hardwareAndSettings.moduleSettings.rfProtocol = checkIncDec(event, reusableBuffer.hardwareAndSettings.moduleSettings.rfProtocol, RF_PROTO_X16, RF_PROTO_LAST, 0, nullptr);
             if (checkIncDec_Ret) {
-              reusableBuffer.hardwareAndSettings.moduleSettings.dirty = true;
+              reusableBuffer.hardwareAndSettings.moduleSettingsDirty = true;
             }
           }
           break;
@@ -163,7 +153,7 @@ void menuModelModuleOptions(event_t event)
         case ITEM_MODULE_SETTINGS_EXTERNAL_ANTENNA:
           reusableBuffer.hardwareAndSettings.moduleSettings.externalAntenna = editCheckBox(reusableBuffer.hardwareAndSettings.moduleSettings.externalAntenna, RECEIVER_OPTIONS_2ND_COLUMN, y, "Ext. antenna", attr, event);
           if (attr && checkIncDec_Ret) {
-            reusableBuffer.hardwareAndSettings.moduleSettings.dirty = true;
+            reusableBuffer.hardwareAndSettings.moduleSettingsDirty = true;
           }
           break;
 
@@ -176,7 +166,7 @@ void menuModelModuleOptions(event_t event)
           if (attr) {
             reusableBuffer.hardwareAndSettings.moduleSettings.txPower = checkIncDec(event, reusableBuffer.hardwareAndSettings.moduleSettings.txPower, 0, 30, 0, &isPowerAvailable);
             if (checkIncDec_Ret) {
-              reusableBuffer.hardwareAndSettings.moduleSettings.dirty = true;
+              reusableBuffer.hardwareAndSettings.moduleSettingsDirty = true;
             }
           }
           break;
diff --git a/radio/src/gui/128x64/model_receiver_options.cpp b/radio/src/gui/128x64/model_receiver_options.cpp
index 2b90c9811..f96b276fc 100644
--- a/radio/src/gui/128x64/model_receiver_options.cpp
+++ b/radio/src/gui/128x64/model_receiver_options.cpp
@@ -30,7 +30,7 @@ void onRxOptionsUpdateConfirm(const char * result)
     reusableBuffer.hardwareAndSettings.receiverSettings.state = PXX2_SETTINGS_WRITE;
     reusableBuffer.hardwareAndSettings.receiverSettings.dirty = 2;
     reusableBuffer.hardwareAndSettings.receiverSettings.timeout = 0;
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_RECEIVER_SETTINGS;
+    moduleState[g_moduleIdx].mode = MODULE_MODE_RECEIVER_SETTINGS;
   }
   else {
     popMenu();
@@ -57,19 +57,17 @@ void menuModelReceiverOptions(event_t event)
     reusableBuffer.hardwareAndSettings.receiverSettings.outputsCount = 8;
 #else
     // no need to initialize reusableBuffer.hardwareAndSettings.receiverSettings.state to PXX2_HARDWARE_INFO
-    reusableBuffer.hardwareAndSettings.modules[g_moduleIdx].current = reusableBuffer.hardwareAndSettings.receiverSettings.receiverId;
-    reusableBuffer.hardwareAndSettings.modules[g_moduleIdx].maximum = reusableBuffer.hardwareAndSettings.receiverSettings.receiverId;
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_GET_HARDWARE_INFO;
+    moduleState[g_moduleIdx].readModuleInformation(&reusableBuffer.hardwareAndSettings.modules[g_moduleIdx], reusableBuffer.hardwareAndSettings.receiverSettings.receiverId, reusableBuffer.hardwareAndSettings.receiverSettings.receiverId);
 #endif
   }
 
-  if (reusableBuffer.hardwareAndSettings.receiverSettings.state == PXX2_HARDWARE_INFO && moduleSettings[g_moduleIdx].mode == MODULE_MODE_NORMAL) {
+  if (reusableBuffer.hardwareAndSettings.receiverSettings.state == PXX2_HARDWARE_INFO && moduleState[g_moduleIdx].mode == MODULE_MODE_NORMAL) {
     reusableBuffer.hardwareAndSettings.receiverSettings.state = PXX2_SETTINGS_READ;
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_RECEIVER_SETTINGS;
+    moduleState[g_moduleIdx].mode = MODULE_MODE_RECEIVER_SETTINGS;
   }
 
   if (menuEvent) {
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_NORMAL;
+    moduleState[g_moduleIdx].mode = MODULE_MODE_NORMAL;
     if (reusableBuffer.hardwareAndSettings.receiverSettings.dirty) {
       abortPopMenu();
       POPUP_CONFIRMATION("Update RX options?", onRxOptionsUpdateConfirm);
@@ -84,7 +82,7 @@ void menuModelReceiverOptions(event_t event)
     reusableBuffer.hardwareAndSettings.receiverSettings.state = PXX2_SETTINGS_WRITE;
     reusableBuffer.hardwareAndSettings.receiverSettings.dirty = 0;
     reusableBuffer.hardwareAndSettings.receiverSettings.timeout = 0;
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_RECEIVER_SETTINGS;
+    moduleState[g_moduleIdx].mode = MODULE_MODE_RECEIVER_SETTINGS;
   }
 
   if (reusableBuffer.hardwareAndSettings.receiverSettings.dirty == 2 && reusableBuffer.hardwareAndSettings.receiverSettings.state == PXX2_SETTINGS_OK) {
diff --git a/radio/src/gui/128x64/model_setup.cpp b/radio/src/gui/128x64/model_setup.cpp
index 5a42b4813..06c2dd292 100644
--- a/radio/src/gui/128x64/model_setup.cpp
+++ b/radio/src/gui/128x64/model_setup.cpp
@@ -238,7 +238,6 @@ enum MenuModelSetupItems {
 #endif
 
 #if defined(PXX2)
-
 bool isPXX2ReceiverEmpty(uint8_t moduleIdx, uint8_t receiverIdx)
 {
   return is_memclear(g_model.moduleData[moduleIdx].pxx2.receiverName[receiverIdx], PXX2_LEN_RX_NAME);
@@ -258,17 +257,85 @@ void removePXX2ReceiverIfEmpty(uint8_t moduleIdx, uint8_t receiverIdx)
   }
 }
 
-void onPXX2BindMenu(const char * result)
+const char * STR_BIND_8CH_WITH_TELEM = TR("8CH with telem.", "8CH with telemetry");
+const char * STR_BIND_16CH_WITH_TELEM = TR("16CH with telem.", "16CH with telemetry");
+const char * STR_BIND_16CH_WITHOUT_TELEM = TR("16CH without telem.", "16CH without telemetry");
+const char * STR_BIND_FLEX_868 = "Flex 868MHz";
+const char * STR_BIND_FLEX_915 = "Flex 915MHz";
+
+void onPXX2R9MBindModeMenu(const char * result)
 {
-  if (result != STR_EXIT) {
-    reusableBuffer.moduleSetup.pxx2.bindSelectedReceiverIndex = (result - reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversNames[0]) / sizeof(reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversNames[0]);
-    reusableBuffer.moduleSetup.pxx2.bindStep = BIND_RX_NAME_SELECTED;
+  if (result == STR_BIND_8CH_WITH_TELEM) {
+    reusableBuffer.moduleSetup.pxx2.bindLbtMode = 0;
+  }
+  else if (result == STR_BIND_16CH_WITH_TELEM) {
+    reusableBuffer.moduleSetup.pxx2.bindLbtMode = 1;
+  }
+  else if (result == STR_BIND_16CH_WITHOUT_TELEM) {
+    reusableBuffer.moduleSetup.pxx2.bindLbtMode = 2;
+  }
+  else if (result == STR_BIND_FLEX_868) {
+    reusableBuffer.moduleSetup.pxx2.bindFlexMode = 0;
+  }
+  else if (result == STR_BIND_FLEX_915) {
+    reusableBuffer.moduleSetup.pxx2.bindFlexMode = 1;
   }
   else {
     // the user pressed [Exit]
     uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition - HEADER_LINE);
     uint8_t receiverIdx = CURRENT_RECEIVER_EDITED(menuVerticalPosition - HEADER_LINE);
-    moduleSettings[moduleIdx].mode = MODULE_MODE_NORMAL;
+    moduleState[moduleIdx].mode = MODULE_MODE_NORMAL;
+    removePXX2ReceiverIfEmpty(moduleIdx, receiverIdx);
+    return;
+  }
+
+#if defined(SIMU)
+  uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition - HEADER_LINE);
+  memcpy(g_model.moduleData[moduleIdx].pxx2.receiverName[reusableBuffer.moduleSetup.pxx2.bindReceiverIndex], reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversNames[reusableBuffer.moduleSetup.pxx2.bindSelectedReceiverIndex], PXX2_LEN_RX_NAME);
+  storageDirty(EE_MODEL);
+  moduleState[moduleIdx].mode = MODULE_MODE_NORMAL;
+  reusableBuffer.moduleSetup.pxx2.bindStep = BIND_OK;
+  POPUP_INFORMATION(STR_BIND_OK);
+#else
+  reusableBuffer.moduleSetup.pxx2.bindStep = BIND_OPTIONS_SELECTED;
+#endif
+}
+
+void onPXX2BindMenu(const char * result)
+{
+  if (result != STR_EXIT) {
+    uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition - HEADER_LINE);
+    reusableBuffer.moduleSetup.pxx2.bindSelectedReceiverIndex = (result - reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversNames[0]) / sizeof(reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversNames[0]);
+    if (isModuleR9M2(moduleIdx) && reusableBuffer.moduleSetup.pxx2.moduleInformation.information.variant == PXX2_VARIANT_EU) {
+      reusableBuffer.moduleSetup.pxx2.bindStep = BIND_RX_NAME_SELECTED;
+      POPUP_MENU_ADD_ITEM(STR_BIND_8CH_WITH_TELEM);
+      POPUP_MENU_ADD_ITEM(STR_BIND_16CH_WITH_TELEM);
+      POPUP_MENU_ADD_ITEM(STR_BIND_16CH_WITHOUT_TELEM);
+      POPUP_MENU_START(onPXX2R9MBindModeMenu);
+    }
+    else if (isModuleR9M2(moduleIdx) && reusableBuffer.moduleSetup.pxx2.moduleInformation.information.variant == PXX2_VARIANT_FLEX) {
+      reusableBuffer.moduleSetup.pxx2.bindStep = BIND_RX_NAME_SELECTED;
+      POPUP_MENU_ADD_ITEM(STR_BIND_FLEX_868);
+      POPUP_MENU_ADD_ITEM(STR_BIND_FLEX_915);
+      POPUP_MENU_START(onPXX2R9MBindModeMenu);
+    }
+    else {
+#if defined(SIMU)
+      memcpy(g_model.moduleData[moduleIdx].pxx2.receiverName[reusableBuffer.moduleSetup.pxx2.bindReceiverIndex], result, PXX2_LEN_RX_NAME);
+      storageDirty(EE_MODEL);
+      moduleState[moduleIdx].mode = MODULE_MODE_NORMAL;
+      reusableBuffer.moduleSetup.pxx2.bindStep = BIND_OK;
+      POPUP_INFORMATION(STR_BIND_OK);
+#else
+      reusableBuffer.moduleSetup.pxx2.bindStep = BIND_OPTIONS_SELECTED;
+#endif
+    }
+  }
+  else {
+    // the user pressed [Exit]
+    uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition - HEADER_LINE);
+    uint8_t receiverIdx = CURRENT_RECEIVER_EDITED(menuVerticalPosition - HEADER_LINE);
+    moduleState[moduleIdx].mode = MODULE_MODE_NORMAL;
     removePXX2ReceiverIfEmpty(moduleIdx, receiverIdx);
   }
 }
@@ -278,7 +345,7 @@ void onResetReceiverConfirm(const char * result)
   if (result == STR_OK) {
     uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition - HEADER_LINE);
     uint8_t receiverIdx = CURRENT_RECEIVER_EDITED(menuVerticalPosition - HEADER_LINE);
-    moduleSettings[moduleIdx].mode = MODULE_MODE_RESET;
+    moduleState[moduleIdx].mode = MODULE_MODE_RESET;
     removePXX2Receiver(moduleIdx, receiverIdx);
   }
 }
@@ -297,12 +364,27 @@ void onPXX2ReceiverMenu(const char * result)
   else if (result == STR_BIND) {
     memclear(&reusableBuffer.moduleSetup.pxx2, sizeof(reusableBuffer.moduleSetup.pxx2));
     reusableBuffer.moduleSetup.pxx2.bindReceiverIndex = receiverIdx;
-    moduleSettings[moduleIdx].mode = MODULE_MODE_BIND;
+#if defined(SIMU)
+    reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversCount = 2;
+    strcpy(reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversNames[0], "SimuRX1");
+    strcpy(reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversNames[1], "SimuRX2");
+#endif
+    if (isModuleR9M2(moduleIdx)) {
+#if defined(SIMU)
+      reusableBuffer.moduleSetup.pxx2.moduleInformation.information.modelID = 1;
+      reusableBuffer.moduleSetup.pxx2.moduleInformation.information.variant = 2;
+#else
+      moduleState[moduleIdx].readModuleInformation(&reusableBuffer.moduleSetup.pxx2.moduleInformation, PXX2_HW_INFO_TX_ID, PXX2_HW_INFO_TX_ID);
+#endif
+    }
+    else {
+      moduleState[moduleIdx].mode = MODULE_MODE_BIND;
+    }
     s_editMode = 1;
   }
   else if (result == STR_SHARE) {
     reusableBuffer.moduleSetup.pxx2.shareReceiverIndex = receiverIdx;
-    moduleSettings[moduleIdx].mode = MODULE_MODE_SHARE;
+    moduleState[moduleIdx].mode = MODULE_MODE_SHARE;
     s_editMode = 1;
   }
   else if (result == STR_DELETE || result == STR_RESET) {
@@ -341,7 +423,7 @@ void onBindMenu(const char * result)
     return;
   }
 
-  moduleSettings[moduleIdx].mode = MODULE_MODE_BIND;
+  moduleState[moduleIdx].mode = MODULE_MODE_BIND;
 }
 
 enum PopupRegisterItems {
@@ -428,7 +510,7 @@ void runPopupRegister(event_t event)
 void startRegisterDialog(uint8_t module)
 {
   memclear(&reusableBuffer.moduleSetup.pxx2, sizeof(reusableBuffer.moduleSetup.pxx2));
-  moduleSettings[module].mode = MODULE_MODE_REGISTER;
+  moduleState[module].mode = MODULE_MODE_REGISTER;
   s_editMode = 0;
   POPUP_INPUT("", runPopupRegister);
 }
@@ -541,9 +623,9 @@ void menuModelSetup(event_t event)
 
 #if (defined(DSM2) || defined(PXX))
   if (menuEvent) {
-    moduleSettings[0].mode = 0;
+    moduleState[0].mode = 0;
 #if NUM_MODULES > 1
-    moduleSettings[1].mode = 0;
+    moduleState[1].mode = 0;
 #endif
   }
 #endif
@@ -1277,18 +1359,18 @@ void menuModelSetup(event_t event)
         lcdDrawText(MODEL_SETUP_2ND_COLUMN, y, STR_REGISTER_BUTTON, (menuHorizontalPosition == 0 ? attr : 0));
         lcdDrawText(lcdLastRightPos + 3, y, STR_MODULE_RANGE, (menuHorizontalPosition == 1 ? attr : 0));
         if (attr) {
-          if (moduleSettings[moduleIdx].mode == MODULE_MODE_NORMAL && s_editMode > 0) {
+          if (moduleState[moduleIdx].mode == MODULE_MODE_NORMAL && s_editMode > 0) {
             if (menuHorizontalPosition == 0 && event == EVT_BUTTON_PRESSED()) {
               startRegisterDialog(moduleIdx);
             }
             else if (menuHorizontalPosition == 1) {
-              moduleSettings[moduleIdx].mode = MODULE_MODE_RANGECHECK;
+              moduleState[moduleIdx].mode = MODULE_MODE_RANGECHECK;
             }
           }
           if (s_editMode == 0 && !warningText) {
-            moduleSettings[moduleIdx].mode = MODULE_MODE_NORMAL;
+            moduleState[moduleIdx].mode = MODULE_MODE_NORMAL;
           }
-          if (moduleSettings[moduleIdx].mode == MODULE_MODE_NORMAL) {
+          if (moduleState[moduleIdx].mode == MODULE_MODE_NORMAL) {
             // REGISTER finished
             s_editMode = 0;
           }
@@ -1335,9 +1417,14 @@ void menuModelSetup(event_t event)
 
         drawReceiverName(MODEL_SETUP_2ND_COLUMN, y, moduleIdx, receiverIdx, attr);
 
-        if (attr && (moduleSettings[moduleIdx].mode == 0 || s_editMode == 0)) {
-          if (moduleSettings[moduleIdx].mode) {
-            moduleSettings[moduleIdx].mode = 0;
+        if (s_editMode && isModuleR9M2(moduleIdx) && moduleState[moduleIdx].mode == MODULE_MODE_NORMAL && reusableBuffer.moduleSetup.pxx2.moduleInformation.information.modelID) {
+          reusableBuffer.moduleSetup.pxx2.moduleInformation.information.modelID = 0;
+          moduleState[moduleIdx].mode = MODULE_MODE_BIND;
+        }
+
+        if (attr && (moduleState[moduleIdx].mode == 0 || s_editMode == 0)) {
+          if (moduleState[moduleIdx].mode) {
+            moduleState[moduleIdx].mode = 0;
             removePXX2ReceiverIfEmpty(moduleIdx, receiverIdx);
             killEvents(event); // we stopped BIND / SHARE, we don't want to re-open the menu
             event = 0;
@@ -1345,7 +1432,7 @@ void menuModelSetup(event_t event)
           s_editMode = 0;
         }
 
-        if (moduleSettings[moduleIdx].mode == MODULE_MODE_BIND) {
+        if (moduleState[moduleIdx].mode == MODULE_MODE_BIND) {
           if (reusableBuffer.moduleSetup.pxx2.bindStep == BIND_START && reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversCount > 0) {
             popupMenuItemsCount = min<uint8_t>(reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversCount, PXX2_MAX_RECEIVERS_PER_MODULE);
             for (uint8_t i=0; i<popupMenuItemsCount; i++) {
@@ -1497,7 +1584,7 @@ void menuModelSetup(event_t event)
                       POPUP_MENU_START(onBindMenu);
                       continue;
                     }
-                    if (moduleSettings[moduleIdx].mode == MODULE_MODE_BIND) {
+                    if (moduleState[moduleIdx].mode == MODULE_MODE_BIND) {
                       newFlag = MODULE_MODE_BIND;
                     }
                     else {
@@ -1523,7 +1610,7 @@ void menuModelSetup(event_t event)
                 newFlag = MODULE_MODE_RANGECHECK;
             }
 #endif
-            moduleSettings[moduleIdx].mode = newFlag;
+            moduleState[moduleIdx].mode = newFlag;
 
 #if defined(MULTIMODULE)
             if (newFlag == MODULE_MODE_BIND) {
diff --git a/radio/src/gui/128x64/radio_version.cpp b/radio/src/gui/128x64/radio_version.cpp
index 47824378d..0127f31ee 100644
--- a/radio/src/gui/128x64/radio_version.cpp
+++ b/radio/src/gui/128x64/radio_version.cpp
@@ -58,8 +58,8 @@ void drawPXX2FullVersion(coord_t x, coord_t y, PXX2Version hwVersion, PXX2Versio
 void menuRadioModulesVersion(event_t event)
 {
   if (menuEvent) {
-    moduleSettings[INTERNAL_MODULE].mode = MODULE_MODE_NORMAL;
-    moduleSettings[EXTERNAL_MODULE].mode = MODULE_MODE_NORMAL;
+    moduleState[INTERNAL_MODULE].mode = MODULE_MODE_NORMAL;
+    moduleState[EXTERNAL_MODULE].mode = MODULE_MODE_NORMAL;
     return;
   }
 
@@ -71,15 +71,11 @@ void menuRadioModulesVersion(event_t event)
     memclear(&reusableBuffer.hardwareAndSettings.modules, sizeof(reusableBuffer.hardwareAndSettings.modules));
 
     if (isModulePXX2(INTERNAL_MODULE) && IS_INTERNAL_MODULE_ON()) {
-      reusableBuffer.hardwareAndSettings.modules[INTERNAL_MODULE].current = PXX2_HW_INFO_TX_ID;
-      reusableBuffer.hardwareAndSettings.modules[INTERNAL_MODULE].maximum = PXX2_MAX_RECEIVERS_PER_MODULE - 1;
-      moduleSettings[INTERNAL_MODULE].mode = MODULE_MODE_GET_HARDWARE_INFO;
+      moduleState[INTERNAL_MODULE].readModuleInformation(&reusableBuffer.hardwareAndSettings.modules[INTERNAL_MODULE], PXX2_HW_INFO_TX_ID, PXX2_MAX_RECEIVERS_PER_MODULE - 1);
     }
 
     if (isModulePXX2(EXTERNAL_MODULE) && IS_EXTERNAL_MODULE_ON()) {
-      reusableBuffer.hardwareAndSettings.modules[EXTERNAL_MODULE].current = PXX2_HW_INFO_TX_ID;
-      reusableBuffer.hardwareAndSettings.modules[EXTERNAL_MODULE].maximum = PXX2_MAX_RECEIVERS_PER_MODULE - 1;
-      moduleSettings[EXTERNAL_MODULE].mode = MODULE_MODE_GET_HARDWARE_INFO;
+      moduleState[EXTERNAL_MODULE].readModuleInformation(&reusableBuffer.hardwareAndSettings.modules[EXTERNAL_MODULE], PXX2_HW_INFO_TX_ID, PXX2_MAX_RECEIVERS_PER_MODULE - 1);
     }
 
     reusableBuffer.hardwareAndSettings.updateTime = get_tmr10ms() + 1000 /* 10s*/;
diff --git a/radio/src/gui/128x64/view_main.cpp b/radio/src/gui/128x64/view_main.cpp
index 6be26d9e9..a2ffe0913 100644
--- a/radio/src/gui/128x64/view_main.cpp
+++ b/radio/src/gui/128x64/view_main.cpp
@@ -568,7 +568,7 @@ void menuMainView(event_t event)
 #endif
 
 #if defined(DSM2)
-  if (moduleSettings[0].mode == MODULE_MODE_BIND) {
+  if (moduleState[0].mode == MODULE_MODE_BIND) {
     // Issue 98
     lcdDrawText(15*FW, 0, "BIND", 0);
   }
diff --git a/radio/src/gui/212x64/model_setup.cpp b/radio/src/gui/212x64/model_setup.cpp
index aa38e7c22..d4a254590 100644
--- a/radio/src/gui/212x64/model_setup.cpp
+++ b/radio/src/gui/212x64/model_setup.cpp
@@ -130,7 +130,7 @@ void onBindMenu(const char * result)
     return;
   }
 
-  moduleSettings[moduleIdx].mode = MODULE_MODE_BIND;
+  moduleState[moduleIdx].mode = MODULE_MODE_BIND;
 }
 
 void copySelection(char * dst, const char * src, uint8_t size)
@@ -309,8 +309,8 @@ void menuModelSetup(event_t event)
 
 #if (defined(DSM2) || defined(PXX))
   if (menuEvent) {
-    moduleSettings[0].mode = 0;
-    moduleSettings[1].mode = 0;
+    moduleState[0].mode = 0;
+    moduleState[1].mode = 0;
   }
 #endif
 
@@ -1062,7 +1062,7 @@ void menuModelSetup(event_t event)
                       POPUP_MENU_START(onBindMenu);
                       continue;
                     }
-                    if (moduleSettings[moduleIdx].mode == MODULE_MODE_BIND) {
+                    if (moduleState[moduleIdx].mode == MODULE_MODE_BIND) {
                       newFlag = MODULE_MODE_BIND;
                     }
                     else {
@@ -1080,7 +1080,7 @@ void menuModelSetup(event_t event)
                 }
               }
             }
-            moduleSettings[moduleIdx].mode = newFlag;
+            moduleState[moduleIdx].mode = newFlag;
 #if defined(MULTIMODULE)
             if (newFlag == MODULE_MODE_BIND)
               multiBindStatus = MULTI_BIND_INITIATED;
diff --git a/radio/src/gui/480x272/model_setup.cpp b/radio/src/gui/480x272/model_setup.cpp
index 7bd55fd67..f68716aa4 100644
--- a/radio/src/gui/480x272/model_setup.cpp
+++ b/radio/src/gui/480x272/model_setup.cpp
@@ -141,7 +141,7 @@ void onBindMenu(const char * result)
     return;
   }
 
-  moduleSettings[moduleIdx].mode = MODULE_MODE_BIND;
+  moduleState[moduleIdx].mode = MODULE_MODE_BIND;
 }
 
 void onModelSetupBitmapMenu(const char * result)
@@ -300,8 +300,8 @@ bool menuModelSetup(event_t event)
   }
 
   if (menuEvent) {
-    moduleSettings[0].mode = 0;
-    moduleSettings[1].mode = 0;
+    moduleState[0].mode = 0;
+    moduleState[1].mode = 0;
   }
 
   int sub = menuVerticalPosition;
@@ -949,8 +949,8 @@ bool menuModelSetup(event_t event)
                 }
               }
             }
-            drawButton(MODEL_SETUP_2ND_COLUMN+xOffsetBind, y, STR_MODULE_BIND, (moduleSettings[moduleIdx].mode == MODULE_MODE_BIND ? BUTTON_ON : BUTTON_OFF) | (l_posHorz==1 ? attr : 0));
-            drawButton(MODEL_SETUP_2ND_COLUMN+MODEL_SETUP_RANGE_OFS+xOffsetBind, y, STR_MODULE_RANGE, (moduleSettings[moduleIdx].mode == MODULE_MODE_RANGECHECK ? BUTTON_ON : BUTTON_OFF) | (l_posHorz==2 ? attr : 0));
+            drawButton(MODEL_SETUP_2ND_COLUMN+xOffsetBind, y, STR_MODULE_BIND, (moduleState[moduleIdx].mode == MODULE_MODE_BIND ? BUTTON_ON : BUTTON_OFF) | (l_posHorz==1 ? attr : 0));
+            drawButton(MODEL_SETUP_2ND_COLUMN+MODEL_SETUP_RANGE_OFS+xOffsetBind, y, STR_MODULE_RANGE, (moduleState[moduleIdx].mode == MODULE_MODE_RANGECHECK ? BUTTON_ON : BUTTON_OFF) | (l_posHorz==2 ? attr : 0));
             uint8_t newFlag = 0;
 #if defined(MULTIMODULE)
             if (multiBindStatus == MULTI_BIND_FINISHED) {
@@ -986,7 +986,7 @@ bool menuModelSetup(event_t event)
                       POPUP_MENU_START(onBindMenu);
                       continue;
                     }
-                    if (moduleSettings[moduleIdx].mode == MODULE_MODE_BIND) {
+                    if (moduleState[moduleIdx].mode == MODULE_MODE_BIND) {
                       newFlag = MODULE_MODE_BIND;
                     }
                     else {
@@ -1004,7 +1004,7 @@ bool menuModelSetup(event_t event)
                 }
               }
             }
-            moduleSettings[moduleIdx].mode = newFlag;
+            moduleState[moduleIdx].mode = newFlag;
 #if defined(MULTIMODULE)
             if (newFlag == MODULE_MODE_BIND)
               multiBindStatus = MULTI_BIND_INITIATED;
diff --git a/radio/src/gui/common/stdlcd/radio_power_meter.cpp b/radio/src/gui/common/stdlcd/radio_power_meter.cpp
index 9b8275781..54044dcaf 100644
--- a/radio/src/gui/common/stdlcd/radio_power_meter.cpp
+++ b/radio/src/gui/common/stdlcd/radio_power_meter.cpp
@@ -49,18 +49,18 @@ void menuRadioPowerMeter(event_t event)
   if (menuEvent) {
     lcdDrawCenteredText(LCD_H/2, STR_STOPPING);
     lcdRefresh();
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_NORMAL;
+    moduleState[g_moduleIdx].mode = MODULE_MODE_NORMAL;
     /* wait 1s to resume normal operation before leaving */
     watchdogSuspend(1000);
     RTOS_WAIT_MS(1000);
     return;
   }
 
-  if (moduleSettings[g_moduleIdx].mode != MODULE_MODE_POWER_METER) {
+  if (moduleState[g_moduleIdx].mode != MODULE_MODE_POWER_METER) {
     memclear(&reusableBuffer.powerMeter, sizeof(reusableBuffer.powerMeter));
     reusableBuffer.powerMeter.freq = 2400000000;
     reusableBuffer.powerMeter.attn = 4;
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_POWER_METER;
+    moduleState[g_moduleIdx].mode = MODULE_MODE_POWER_METER;
   }
 
   // The warning
diff --git a/radio/src/gui/common/stdlcd/radio_spectrum_analyser.cpp b/radio/src/gui/common/stdlcd/radio_spectrum_analyser.cpp
index 053e4ad87..b686902d8 100644
--- a/radio/src/gui/common/stdlcd/radio_spectrum_analyser.cpp
+++ b/radio/src/gui/common/stdlcd/radio_spectrum_analyser.cpp
@@ -44,19 +44,19 @@ void menuRadioSpectrumAnalyser(event_t event)
   if (menuEvent) {
     lcdDrawCenteredText(LCD_H/2, STR_STOPPING              );
     lcdRefresh();
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_NORMAL;
+    moduleState[g_moduleIdx].mode = MODULE_MODE_NORMAL;
     /* wait 1s to resume normal operation before leaving */
     watchdogSuspend(1000);
     RTOS_WAIT_MS(1000);
     return;
   }
 
-  if (moduleSettings[g_moduleIdx].mode != MODULE_MODE_SPECTRUM_ANALYSER) {
+  if (moduleState[g_moduleIdx].mode != MODULE_MODE_SPECTRUM_ANALYSER) {
     memclear(reusableBuffer.spectrumAnalyser.bars, sizeof(reusableBuffer.spectrumAnalyser.bars));
     reusableBuffer.spectrumAnalyser.span = 40000000;  // 40MHz
     reusableBuffer.spectrumAnalyser.freq = 2440000000;  // 2440MHz
     reusableBuffer.spectrumAnalyser.step = reusableBuffer.spectrumAnalyser.span / LCD_W;
-    moduleSettings[g_moduleIdx].mode = MODULE_MODE_SPECTRUM_ANALYSER;
+    moduleState[g_moduleIdx].mode = MODULE_MODE_SPECTRUM_ANALYSER;
   }
 
   for (uint8_t i=0; i<SPECTRUM_FIELDS_MAX; i++) {
diff --git a/radio/src/gui/common/stdlcd/radio_tools.cpp b/radio/src/gui/common/stdlcd/radio_tools.cpp
index ad3e3bb23..a764b9e7d 100644
--- a/radio/src/gui/common/stdlcd/radio_tools.cpp
+++ b/radio/src/gui/common/stdlcd/radio_tools.cpp
@@ -45,9 +45,7 @@ void menuRadioTools(event_t event)
 #if defined(PXX2)
     for (uint8_t module = 0; module < NUM_MODULES; module++) {
       if (isModulePXX2(module) && (module == INTERNAL_MODULE ? IS_INTERNAL_MODULE_ON() : IS_EXTERNAL_MODULE_ON())) {
-        reusableBuffer.hardwareAndSettings.modules[module].current = PXX2_HW_INFO_TX_ID;
-        reusableBuffer.hardwareAndSettings.modules[module].maximum = PXX2_HW_INFO_TX_ID;
-        moduleSettings[module].mode = MODULE_MODE_GET_HARDWARE_INFO;
+        moduleState[module].readModuleInformation(&reusableBuffer.hardwareAndSettings.modules[module], PXX2_HW_INFO_TX_ID, PXX2_HW_INFO_TX_ID);
       }
     }
 #endif
diff --git a/radio/src/opentx.cpp b/radio/src/opentx.cpp
index 41281fd70..55b80bea3 100644
--- a/radio/src/opentx.cpp
+++ b/radio/src/opentx.cpp
@@ -1502,9 +1502,9 @@ void doMixerCalculations()
     static uint8_t countRangecheck = 0;
     for (uint8_t i=0; i<NUM_MODULES; ++i) {
 #if defined(MULTIMODULE)
-      if ((moduleSettings[i].mode != MODULE_MODE_NORMAL && moduleSettings[i].mode != MODULE_MODE_SPECTRUM_ANALYSER)  || (i == EXTERNAL_MODULE && multiModuleStatus.isBinding())) {
+      if ((moduleState[i].mode != MODULE_MODE_NORMAL && moduleState[i].mode != MODULE_MODE_SPECTRUM_ANALYSER)  || (i == EXTERNAL_MODULE && multiModuleStatus.isBinding())) {
 #else
-      if (moduleSettings[i].mode >= MODULE_MODE_BEEP_FIRST) {
+      if (moduleState[i].mode >= MODULE_MODE_BEEP_FIRST) {
 #endif
         if (++countRangecheck >= 250) {
           countRangecheck = 0;
diff --git a/radio/src/opentx.h b/radio/src/opentx.h
index cae58fd8c..a1e5e08e9 100644
--- a/radio/src/opentx.h
+++ b/radio/src/opentx.h
@@ -1143,12 +1143,15 @@ union ReusableBuffer
       char bindCandidateReceiversNames[PXX2_MAX_RECEIVERS_PER_MODULE][PXX2_LEN_RX_NAME + 1];
       uint8_t bindCandidateReceiversCount;
       uint8_t bindReceiverIndex;
+      uint8_t bindLbtMode;
+      uint8_t bindFlexMode;
       union {
         uint8_t bindSelectedReceiverIndex;
         uint8_t shareReceiverIndex;
         uint8_t resetReceiverIndex;
       };
       uint8_t resetReceiverFlags;
+      ModuleInformation moduleInformation;
     } pxx2;
 #if defined(BLUETOOTH)
     struct {
@@ -1186,40 +1189,16 @@ union ReusableBuffer
 #endif
 
   struct {
-    struct {
-      int8_t current;
-      int8_t maximum;
-      uint8_t timeout;
-      PXX2HardwareInformation information;
-      struct {
-        PXX2HardwareInformation information;
-      } receivers[PXX2_MAX_RECEIVERS_PER_MODULE];
-    } modules[NUM_MODULES];
-
+    ModuleInformation modules[NUM_MODULES];
     uint32_t updateTime;
 
     union {
-      struct {
-        uint8_t state;  // 0x00 = READ 0x40 = WRITE
-        tmr10ms_t timeout;
-        uint8_t dirty;
-        uint8_t rfProtocol;
-        uint8_t externalAntenna;
-        int8_t txPower;
-      } moduleSettings;
-
-      struct {
-        uint8_t state;  // 0x00 = READ 0x40 = WRITE
-        tmr10ms_t timeout;
-        uint8_t receiverId;
-        uint8_t dirty;
-        uint8_t telemetryDisabled;
-        uint8_t pwmRate;
-        uint8_t outputsCount;
-        uint8_t outputsMapping[24];
-      } receiverSettings;
+      ModuleSettings moduleSettings;
+      ReceiverSettings receiverSettings;
     };
 
+    uint8_t moduleSettingsDirty;
+
   } hardwareAndSettings;
 
   struct {
diff --git a/radio/src/pulses/dsm2.cpp b/radio/src/pulses/dsm2.cpp
index 306c3b466..3612f60db 100644
--- a/radio/src/pulses/dsm2.cpp
+++ b/radio/src/pulses/dsm2.cpp
@@ -124,7 +124,7 @@ void setupPulsesDSM2()
 
   extmodulePulsesData.dsm2.ptr = extmodulePulsesData.dsm2.pulses;
 
-  switch (moduleSettings[EXTERNAL_MODULE].protocol) {
+  switch (moduleState[EXTERNAL_MODULE].protocol) {
     case PROTOCOL_CHANNELS_DSM2_LP45:
       dsmDat[0] = 0x00;
       break;
@@ -140,21 +140,21 @@ void setupPulsesDSM2()
   if (dsm2BindTimer > 0) {
     dsm2BindTimer--;
     if (switchState(SW_DSM2_BIND)) {
-      moduleSettings[EXTERNAL_MODULE].mode = MODULE_MODE_BIND;
+      moduleState[EXTERNAL_MODULE].mode = MODULE_MODE_BIND;
       dsmDat[0] |= DSM2_SEND_BIND;
     }
   }
-  else if (moduleSettings[EXTERNAL_MODULE].mode == MODULE_MODE_RANGECHECK) {
+  else if (moduleState[EXTERNAL_MODULE].mode == MODULE_MODE_RANGECHECK) {
     dsmDat[0] |= DSM2_SEND_RANGECHECK;
   }
   else {
-    moduleSettings[EXTERNAL_MODULE].mode = 0;
+    moduleState[EXTERNAL_MODULE].mode = 0;
   }
 #else
-  if (moduleSettings[EXTERNAL_MODULE].mode == MODULE_MODE_BIND) {
+  if (moduleState[EXTERNAL_MODULE].mode == MODULE_MODE_BIND) {
     dsmDat[0] |= DSM2_SEND_BIND;
   }
-  else if (moduleSettings[EXTERNAL_MODULE].mode == MODULE_MODE_RANGECHECK) {
+  else if (moduleState[EXTERNAL_MODULE].mode == MODULE_MODE_RANGECHECK) {
     dsmDat[0] |= DSM2_SEND_RANGECHECK;
   }
 #endif
diff --git a/radio/src/pulses/multi.cpp b/radio/src/pulses/multi.cpp
index 055a74f9c..c5a58729f 100644
--- a/radio/src/pulses/multi.cpp
+++ b/radio/src/pulses/multi.cpp
@@ -154,16 +154,16 @@ void sendFrameProtocolHeader(uint8_t port, bool failsafe)
   int8_t optionValue = g_model.moduleData[port].multi.optionValue;
 
   uint8_t protoByte = 0;
-  if (moduleSettings[port].mode == MODULE_MODE_BIND)
+  if (moduleState[port].mode == MODULE_MODE_BIND)
     protoByte |= MULTI_SEND_BIND;
-  else if (moduleSettings[port].mode ==  MODULE_MODE_RANGECHECK)
+  else if (moduleState[port].mode ==  MODULE_MODE_RANGECHECK)
     protoByte |= MULTI_SEND_RANGECHECK;
 
   // rfProtocol
   if (g_model.moduleData[port].getMultiProtocol(true) == MM_RF_PROTO_DSM2) {
 
     // Autobinding should always be done in DSMX 11ms
-    if (g_model.moduleData[port].multi.autoBindMode && moduleSettings[port].mode == MODULE_MODE_BIND)
+    if (g_model.moduleData[port].multi.autoBindMode && moduleState[port].mode == MODULE_MODE_BIND)
       subtype = MM_RF_DSM2_SUBTYPE_AUTO;
 
     // Multi module in DSM mode wants the number of channels to be used as option value
diff --git a/radio/src/pulses/pulses.cpp b/radio/src/pulses/pulses.cpp
index 581836797..53119a12d 100755
--- a/radio/src/pulses/pulses.cpp
+++ b/radio/src/pulses/pulses.cpp
@@ -23,7 +23,7 @@
 #include "pulses/pxx2.h"
 
 uint8_t s_pulses_paused = 0;
-ModuleSettings moduleSettings[NUM_MODULES];
+ModuleState moduleState[NUM_MODULES];
 InternalModulePulsesData intmodulePulsesData __DMA;
 ExternalModulePulsesData extmodulePulsesData __DMA;
 TrainerPulsesData trainerPulsesData __DMA;
@@ -94,7 +94,7 @@ uint8_t getRequiredProtocol(uint8_t module)
       // The module is set to OFF during one second before BIND start
       {
         static tmr10ms_t bindStartTime = 0;
-        if (moduleSettings[module].mode == MODULE_MODE_BIND) {
+        if (moduleState[module].mode == MODULE_MODE_BIND) {
           if (bindStartTime == 0) bindStartTime = get_tmr10ms();
           if ((tmr10ms_t)(get_tmr10ms() - bindStartTime) < 100) {
             protocol = PROTOCOL_CHANNELS_NONE;
@@ -125,7 +125,7 @@ uint8_t getRequiredProtocol(uint8_t module)
 
 #if 0
   // will need an EEPROM conversion
-  if (moduleSettings[module].mode == MODULE_OFF) {
+  if (moduleState[module].mode == MODULE_OFF) {
     protocol = PROTOCOL_CHANNELS_NONE;
   }
 #endif
@@ -263,7 +263,7 @@ void setupPulsesInternalModule(uint8_t protocol)
 #if defined(PXX2)
     case PROTOCOL_CHANNELS_PXX2:
       intmodulePulsesData.pxx2.setupFrame(INTERNAL_MODULE);
-      scheduleNextMixerCalculation(INTERNAL_MODULE, moduleSettings[INTERNAL_MODULE].mode == MODULE_MODE_SPECTRUM_ANALYSER || moduleSettings[INTERNAL_MODULE].mode == MODULE_MODE_POWER_METER ? 1 : PXX2_PERIOD);
+      scheduleNextMixerCalculation(INTERNAL_MODULE, moduleState[INTERNAL_MODULE].mode == MODULE_MODE_SPECTRUM_ANALYSER || moduleState[INTERNAL_MODULE].mode == MODULE_MODE_POWER_METER ? 1 : PXX2_PERIOD);
       break;
 #endif
 
@@ -362,9 +362,9 @@ bool setupPulses(uint8_t module)
 
   heartbeat |= (HEART_TIMER_PULSES << module);
 
-  if (moduleSettings[module].protocol != protocol) {
-    disablePulses(module, moduleSettings[module].protocol);
-    moduleSettings[module].protocol = protocol;
+  if (moduleState[module].protocol != protocol) {
+    disablePulses(module, moduleState[module].protocol);
+    moduleState[module].protocol = protocol;
     enablePulses(module, protocol);
     return false;
   }
diff --git a/radio/src/pulses/pulses.h b/radio/src/pulses/pulses.h
index ffce56216..4ab767adf 100644
--- a/radio/src/pulses/pulses.h
+++ b/radio/src/pulses/pulses.h
@@ -28,9 +28,9 @@
 #include "pulses/pxx2.h"
 
 #if NUM_MODULES > 1
-  #define IS_RANGECHECK_ENABLE()             (moduleSettings[0].mode == MODULE_MODE_RANGECHECK || moduleSettings[1].mode == MODULE_MODE_RANGECHECK)
+  #define IS_RANGECHECK_ENABLE()             (moduleState[0].mode == MODULE_MODE_RANGECHECK || moduleState[1].mode == MODULE_MODE_RANGECHECK)
 #else
-  #define IS_RANGECHECK_ENABLE()             (moduleSettings[0].mode == MODULE_MODE_RANGECHECK)
+  #define IS_RANGECHECK_ENABLE()             (moduleState[0].mode == MODULE_MODE_RANGECHECK)
 #endif
 
 #if defined(PCBSKY9X) && defined(DSM2)
@@ -79,15 +79,82 @@ enum ModuleSettingsMode
   MODULE_MODE_RESET
 };
 
-PACK(struct ModuleSettings {
+
+PACK(struct PXX2Version {
+  uint8_t major;
+  uint8_t revision:4;
+  uint8_t minor:4;
+});
+
+PACK(struct PXX2HardwareInformation {
+  uint8_t modelID;
+  PXX2Version hwVersion;
+  PXX2Version swVersion;
+  uint8_t variant;
+});
+
+PACK(struct ModuleInformation {
+  int8_t current;
+  int8_t maximum;
+  uint8_t timeout;
+  PXX2HardwareInformation information;
+  struct {
+    PXX2HardwareInformation information;
+  } receivers[PXX2_MAX_RECEIVERS_PER_MODULE];
+});
+
+struct ModuleSettings {
+  uint8_t state;  // 0x00 = READ 0x40 = WRITE
+  tmr10ms_t retryTime;
+  uint8_t rfProtocol;
+  uint8_t externalAntenna;
+  int8_t txPower;
+};
+
+struct ReceiverSettings {
+  uint8_t state;  // 0x00 = READ 0x40 = WRITE
+  tmr10ms_t timeout;
+  uint8_t receiverId;
+  uint8_t dirty;
+  uint8_t telemetryDisabled;
+  uint8_t pwmRate;
+  uint8_t outputsCount;
+  uint8_t outputsMapping[24];
+};
+
+PACK(struct ModuleState {
   uint8_t protocol:4;
   uint8_t mode:4;
   uint8_t paused:1;
   uint8_t spare:7;
   uint16_t counter;
+  union {
+    ModuleInformation * moduleInformation;
+    ModuleSettings * moduleSettings;
+  };
+  void readModuleInformation(ModuleInformation * destination, int8_t first, int8_t last)
+  {
+    moduleInformation = destination;
+    moduleInformation->current = first;
+    moduleInformation->maximum = last;
+    mode = MODULE_MODE_GET_HARDWARE_INFO;
+  }
+  void readModuleSettings(ModuleSettings * destination)
+  {
+    moduleSettings = destination;
+    moduleSettings->state = PXX2_SETTINGS_READ;
+    mode = MODULE_MODE_MODULE_SETTINGS;
+  }
+  void writeModuleSettings(ModuleSettings * source)
+  {
+    moduleSettings = source;
+    moduleSettings->state = PXX2_SETTINGS_WRITE;
+    moduleSettings->retryTime = 0;
+    mode = MODULE_MODE_MODULE_SETTINGS;
+  }
 });
 
-extern ModuleSettings moduleSettings[NUM_MODULES];
+extern ModuleState moduleState[NUM_MODULES];
 
 template<class T> struct PpmPulsesData {
   T pulses[20];
@@ -241,16 +308,16 @@ enum ChannelsProtocols {
   PROTOCOL_CHANNELS_PXX2
 };
 
-inline bool pulsesStarted() { return moduleSettings[0].protocol != PROTOCOL_CHANNELS_UNINITIALIZED; }
+inline bool pulsesStarted() { return moduleState[0].protocol != PROTOCOL_CHANNELS_UNINITIALIZED; }
 inline void pausePulses() { s_pulses_paused = true; }
 inline void resumePulses() { s_pulses_paused = false; }
 
-#define SEND_FAILSAFE_NOW(idx) moduleSettings[idx].counter = 1
+#define SEND_FAILSAFE_NOW(idx) moduleState[idx].counter = 1
 
 inline void SEND_FAILSAFE_1S()
 {
   for (int i=0; i<NUM_MODULES; i++) {
-    moduleSettings[i].counter = 100;
+    moduleState[i].counter = 100;
   }
 }
 
diff --git a/radio/src/pulses/pxx1.cpp b/radio/src/pulses/pxx1.cpp
index e11642b4e..592fc285b 100644
--- a/radio/src/pulses/pxx1.cpp
+++ b/radio/src/pulses/pxx1.cpp
@@ -60,22 +60,22 @@ template <class PxxTransport>
 uint8_t Pxx1Pulses<PxxTransport>::addFlag1(uint8_t module)
 {
   uint8_t flag1 = (g_model.moduleData[module].rfProtocol << 6);
-  if (moduleSettings[module].mode == MODULE_MODE_BIND) {
+  if (moduleState[module].mode == MODULE_MODE_BIND) {
     flag1 |= (g_eeGeneral.countryCode << 1) | PXX_SEND_BIND;
   }
-  else if (moduleSettings[module].mode == MODULE_MODE_RANGECHECK) {
+  else if (moduleState[module].mode == MODULE_MODE_RANGECHECK) {
     flag1 |= PXX_SEND_RANGECHECK;
   }
   else {
     bool failsafeNeeded = g_model.moduleData[module].failsafeMode != FAILSAFE_NOT_SET && g_model.moduleData[module].failsafeMode != FAILSAFE_RECEIVER;
-    if (moduleSettings[module].counter-- == 0) {
+    if (moduleState[module].counter-- == 0) {
       // counter is also used for knowing if the frame is odd / even
-      moduleSettings[module].counter = 1000;
+      moduleState[module].counter = 1000;
       if (failsafeNeeded) {
         flag1 |= PXX_SEND_FAILSAFE;
       }
     }
-    if (failsafeNeeded && moduleSettings[module].counter == 0 && g_model.moduleData[module].channelsCount > 0) {
+    if (failsafeNeeded && moduleState[module].counter == 0 && g_model.moduleData[module].channelsCount > 0) {
       flag1 |= PXX_SEND_FAILSAFE;
     }
   }
@@ -219,7 +219,7 @@ void Pxx1Pulses<PxxTransport>::setupFrame(uint8_t module)
   PxxTransport::initFrame(PXX_PULSES_PERIOD);
 
 #if defined(PXX_FREQUENCY_HIGH)
-  if (moduleSettings[module].protocol == PROTOCOL_CHANNELS_PXX1_SERIAL) {
+  if (moduleState[module].protocol == PROTOCOL_CHANNELS_PXX1_SERIAL) {
     add8ChannelsFrame(module, 0);
     if (sentModuleChannels(module) > 8) {
       add8ChannelsFrame(module, 8);
@@ -229,7 +229,7 @@ void Pxx1Pulses<PxxTransport>::setupFrame(uint8_t module)
 #endif
 
   uint8_t sendUpperChannels = 0;
-  if (moduleSettings[module].counter & 0x01) {
+  if (moduleState[module].counter & 0x01) {
     sendUpperChannels = g_model.moduleData[module].channelsCount;
   }
 
diff --git a/radio/src/pulses/pxx2.cpp b/radio/src/pulses/pxx2.cpp
index 1bf0bc58e..39d841750 100644
--- a/radio/src/pulses/pxx2.cpp
+++ b/radio/src/pulses/pxx2.cpp
@@ -25,11 +25,11 @@ uint8_t Pxx2Pulses::addFlag0(uint8_t module)
 {
   uint8_t flag0 = g_model.header.modelId[module] & 0x3F;
   if (g_model.moduleData[module].failsafeMode != FAILSAFE_NOT_SET && g_model.moduleData[module].failsafeMode != FAILSAFE_RECEIVER) {
-    if (moduleSettings[module].counter == 0) {
+    if (moduleState[module].counter == 0) {
       flag0 |= PXX2_CHANNELS_FLAG0_FAILSAFE;
     }
   }
-  if (moduleSettings[module].mode == MODULE_MODE_RANGECHECK) {
+  if (moduleState[module].mode == MODULE_MODE_RANGECHECK) {
     flag0 |= PXX2_CHANNELS_FLAG0_RANGECHECK;
   }
   Pxx2Transport::addByte(flag0);
@@ -130,20 +130,22 @@ void Pxx2Pulses::setupTelemetryFrame(uint8_t module)
 
 void Pxx2Pulses::setupHardwareInfoFrame(uint8_t module)
 {
-  if (reusableBuffer.hardwareAndSettings.modules[module].timeout == 0) {
-    if (reusableBuffer.hardwareAndSettings.modules[module].current <= reusableBuffer.hardwareAndSettings.modules[module].maximum) {
+  ModuleInformation * destination = moduleState[module].moduleInformation;
+
+  if (destination->timeout == 0) {
+    if (destination->current <= destination->maximum) {
       addFrameType(PXX2_TYPE_C_MODULE, PXX2_TYPE_ID_HW_INFO);
-      Pxx2Transport::addByte(reusableBuffer.hardwareAndSettings.modules[module].current);
-      reusableBuffer.hardwareAndSettings.modules[module].timeout = 60; /* 300ms */
-      reusableBuffer.hardwareAndSettings.modules[module].current++;
+      Pxx2Transport::addByte(destination->current);
+      destination->timeout = 60; /* 300ms */
+      destination->current++;
     }
     else {
-      moduleSettings[module].mode = MODULE_MODE_NORMAL;
+      moduleState[module].mode = MODULE_MODE_NORMAL;
       setupChannelsFrame(module);
     }
   }
   else {
-    reusableBuffer.hardwareAndSettings.modules[module].timeout--;
+    destination->timeout--;
     setupChannelsFrame(module);
   }
 }
@@ -169,20 +171,22 @@ void Pxx2Pulses::setupRegisterFrame(uint8_t module)
 
 void Pxx2Pulses::setupModuleSettingsFrame(uint8_t module)
 {
-  if (get_tmr10ms() > reusableBuffer.hardwareAndSettings.moduleSettings.timeout) {
+  ModuleSettings * destination = moduleState[module].moduleSettings;
+
+  if (get_tmr10ms() > destination->retryTime) {
     addFrameType(PXX2_TYPE_C_MODULE, PXX2_TYPE_ID_TX_SETTINGS);
     uint8_t flag0 = 0;
-    if (reusableBuffer.hardwareAndSettings.moduleSettings.state == PXX2_SETTINGS_WRITE)
+    if (destination->state == PXX2_SETTINGS_WRITE)
       flag0 |= PXX2_TX_SETTINGS_FLAG0_WRITE;
     Pxx2Transport::addByte(flag0);
-    if (reusableBuffer.hardwareAndSettings.moduleSettings.state == PXX2_SETTINGS_WRITE) {
-      uint8_t flag1 = reusableBuffer.hardwareAndSettings.moduleSettings.rfProtocol << 4;
-      if (reusableBuffer.hardwareAndSettings.moduleSettings.externalAntenna)
+    if (destination->state == PXX2_SETTINGS_WRITE) {
+      uint8_t flag1 = destination->rfProtocol << 4;
+      if (destination->externalAntenna)
         flag1 |= PXX2_TX_SETTINGS_FLAG1_EXTERNAL_ANTENNA;
       Pxx2Transport::addByte(flag1);
-      Pxx2Transport::addByte(reusableBuffer.hardwareAndSettings.moduleSettings.txPower);
+      Pxx2Transport::addByte(destination->txPower);
     }
-    reusableBuffer.hardwareAndSettings.moduleSettings.timeout = get_tmr10ms() + 200/*next try in 2s*/;
+    destination->retryTime = get_tmr10ms() + 200/*next try in 2s*/;
   }
   else {
     setupChannelsFrame(module);
@@ -220,7 +224,7 @@ void Pxx2Pulses::setupBindFrame(uint8_t module)
 {
   if (reusableBuffer.moduleSetup.pxx2.bindStep == BIND_WAIT) {
     if (get_tmr10ms() > reusableBuffer.moduleSetup.pxx2.bindWaitTimeout) {
-      moduleSettings[module].mode = MODULE_MODE_NORMAL;
+      moduleState[module].mode = MODULE_MODE_NORMAL;
       reusableBuffer.moduleSetup.pxx2.bindStep = BIND_OK;
       POPUP_INFORMATION(STR_BIND_OK);
     }
@@ -229,7 +233,7 @@ void Pxx2Pulses::setupBindFrame(uint8_t module)
 
   addFrameType(PXX2_TYPE_C_MODULE, PXX2_TYPE_ID_BIND);
 
-  if (reusableBuffer.moduleSetup.pxx2.bindStep == BIND_RX_NAME_SELECTED) {
+  if (reusableBuffer.moduleSetup.pxx2.bindStep == BIND_OPTIONS_SELECTED) {
     Pxx2Transport::addByte(0x01);
     for (uint8_t i=0; i<PXX2_LEN_RX_NAME; i++) {
       Pxx2Transport::addByte(reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversNames[reusableBuffer.moduleSetup.pxx2.bindSelectedReceiverIndex][i]);
@@ -250,17 +254,17 @@ void Pxx2Pulses::setupResetFrame(uint8_t module)
   addFrameType(PXX2_TYPE_C_MODULE, PXX2_TYPE_ID_RESET);
   Pxx2Transport::addByte(reusableBuffer.moduleSetup.pxx2.resetReceiverIndex);
   Pxx2Transport::addByte(reusableBuffer.moduleSetup.pxx2.resetReceiverFlags);
-  moduleSettings[module].mode = MODULE_MODE_NORMAL;
+  moduleState[module].mode = MODULE_MODE_NORMAL;
 }
 
 void Pxx2Pulses::setupSpectrumAnalyser(uint8_t module)
 {
-  if (moduleSettings[module].counter > 1000) {
-    moduleSettings[module].counter = 1002;
+  if (moduleState[module].counter > 1000) {
+    moduleState[module].counter = 1002;
     return;
   }
 
-  moduleSettings[module].counter = 1002;
+  moduleState[module].counter = 1002;
 
   addFrameType(PXX2_TYPE_C_POWER_METER, PXX2_TYPE_ID_SPECTRUM);
   Pxx2Transport::addByte(0x00);
@@ -271,12 +275,12 @@ void Pxx2Pulses::setupSpectrumAnalyser(uint8_t module)
 
 void Pxx2Pulses::setupPowerMeter(uint8_t module)
 {
-  if (moduleSettings[module].counter > 1000) {
-    moduleSettings[module].counter = 1002;
+  if (moduleState[module].counter > 1000) {
+    moduleState[module].counter = 1002;
     return;
   }
 
-  moduleSettings[module].counter = 1002;
+  moduleState[module].counter = 1002;
 
   addFrameType(PXX2_TYPE_C_POWER_METER, PXX2_TYPE_ID_POWER_METER);
   Pxx2Transport::addByte(0x00);
@@ -294,7 +298,7 @@ void Pxx2Pulses::setupFrame(uint8_t module)
 {
   initFrame();
 
-  switch (moduleSettings[module].mode) {
+  switch (moduleState[module].mode) {
     case MODULE_MODE_GET_HARDWARE_INFO:
       setupHardwareInfoFrame(module);
       break;
@@ -333,8 +337,8 @@ void Pxx2Pulses::setupFrame(uint8_t module)
       break;
   }
 
-  if (moduleSettings[module].counter-- == 0) {
-    moduleSettings[module].counter = 1000;
+  if (moduleState[module].counter-- == 0) {
+    moduleState[module].counter = 1000;
   }
 
   endFrame();
diff --git a/radio/src/pulses/pxx2.h b/radio/src/pulses/pxx2.h
index a0fcd83df..9d3a39801 100644
--- a/radio/src/pulses/pxx2.h
+++ b/radio/src/pulses/pxx2.h
@@ -124,6 +124,7 @@ enum PXX2RegisterSteps {
 enum PXX2BindSteps {
   BIND_START,
   BIND_RX_NAME_SELECTED,
+  BIND_OPTIONS_SELECTED,
   BIND_WAIT,
   BIND_OK
 };
@@ -270,19 +271,4 @@ class Pxx2Pulses: public PxxPulses<Pxx2Transport> {
     }
 };
 
-PACK(struct PXX2Version
-{
-  uint8_t major;
-  uint8_t revision:4;
-  uint8_t minor:4;
-});
-
-PACK(struct PXX2HardwareInformation
-{
-  uint8_t modelID;
-  PXX2Version hwVersion;
-  PXX2Version swVersion;
-  uint8_t variant;
-});
-
 #endif
diff --git a/radio/src/targets/common/arm/stm32/intmodule_serial_driver.cpp b/radio/src/targets/common/arm/stm32/intmodule_serial_driver.cpp
index ab8e897b0..8d254a7b4 100755
--- a/radio/src/targets/common/arm/stm32/intmodule_serial_driver.cpp
+++ b/radio/src/targets/common/arm/stm32/intmodule_serial_driver.cpp
@@ -134,7 +134,7 @@ void intmoduleSendBuffer(const uint8_t * data, uint8_t size)
 
 void intmoduleSendNextFrame()
 {
-  switch(moduleSettings[INTERNAL_MODULE].protocol) {
+  switch(moduleState[INTERNAL_MODULE].protocol) {
 #if defined(PXX2)
     case PROTOCOL_CHANNELS_PXX2:
       intmoduleSendBuffer(intmodulePulsesData.pxx2.getData(), intmodulePulsesData.pxx2.getSize());
diff --git a/radio/src/targets/horus/extmodule_driver.cpp b/radio/src/targets/horus/extmodule_driver.cpp
index a65100484..74229349d 100644
--- a/radio/src/targets/horus/extmodule_driver.cpp
+++ b/radio/src/targets/horus/extmodule_driver.cpp
@@ -212,7 +212,7 @@ void extmoduleSendBuffer(const uint8_t * data, uint8_t size)
 
 void extmoduleSendNextFrame()
 {
-  if (moduleSettings[EXTERNAL_MODULE].protocol == PROTOCOL_CHANNELS_PPM) {
+  if (moduleState[EXTERNAL_MODULE].protocol == PROTOCOL_CHANNELS_PPM) {
 #if defined(PCBX10) || PCBREV >= 13
     EXTMODULE_TIMER->CCR3 = GET_MODULE_PPM_DELAY(EXTERNAL_MODULE)*2;
     EXTMODULE_TIMER->CCER = TIM_CCER_CC3E | (GET_MODULE_PPM_POLARITY(EXTERNAL_MODULE) ? TIM_CCER_CC3P : 0);
@@ -232,7 +232,7 @@ void extmoduleSendNextFrame()
     EXTMODULE_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
   }
 #if defined(PXX1)
-  else if (moduleSettings[EXTERNAL_MODULE].protocol == PROTOCOL_CHANNELS_PXX1_PULSES) {
+  else if (moduleState[EXTERNAL_MODULE].protocol == PROTOCOL_CHANNELS_PXX1_PULSES) {
     EXTMODULE_TIMER->CCR2 = extmodulePulsesData.pxx.getLast() - 4000; // 2mS in advance
     EXTMODULE_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
 #if defined(PCBX10) || PCBREV >= 13
@@ -245,25 +245,25 @@ void extmoduleSendNextFrame()
     EXTMODULE_DMA_STREAM->NDTR = extmodulePulsesData.pxx.getSize();
     EXTMODULE_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
   }
-  else if (moduleSettings[EXTERNAL_MODULE].protocol == PROTOCOL_CHANNELS_PXX1_SERIAL) {
+  else if (moduleState[EXTERNAL_MODULE].protocol == PROTOCOL_CHANNELS_PXX1_SERIAL) {
     #warning "Take it from 2.2"
   }
 #endif
 #if defined(PXX2)
-  else if (moduleSettings[EXTERNAL_MODULE].protocol == PROTOCOL_CHANNELS_PXX2) {
+  else if (moduleState[EXTERNAL_MODULE].protocol == PROTOCOL_CHANNELS_PXX2) {
     // TODO
   }
 #endif
-  else if (IS_DSM2_PROTOCOL(moduleSettings[EXTERNAL_MODULE].protocol) || IS_MULTIMODULE_PROTOCOL(moduleSettings[EXTERNAL_MODULE].protocol) || IS_SBUS_PROTOCOL(moduleSettings[EXTERNAL_MODULE].protocol)) {
+  else if (IS_DSM2_PROTOCOL(moduleState[EXTERNAL_MODULE].protocol) || IS_MULTIMODULE_PROTOCOL(moduleState[EXTERNAL_MODULE].protocol) || IS_SBUS_PROTOCOL(moduleState[EXTERNAL_MODULE].protocol)) {
     EXTMODULE_TIMER->CCR2 = *(extmodulePulsesData.dsm2.ptr - 1) - 4000; // 2mS in advance
     EXTMODULE_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
 #if defined(PCBX10) || PCBREV >= 13
     EXTMODULE_DMA_STREAM->CR |= EXTMODULE_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | DMA_SxCR_PSIZE_0 | DMA_SxCR_MSIZE_0 | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
-    if (IS_SBUS_PROTOCOL(moduleSettings[EXTERNAL_MODULE].protocol))
+    if (IS_SBUS_PROTOCOL(moduleState[EXTERNAL_MODULE].protocol))
       EXTMODULE_TIMER->CCER = TIM_CCER_CC3E | (GET_SBUS_POLARITY(EXTERNAL_MODULE) ? TIM_CCER_CC3P : 0); // reverse polarity for Sbus if needed
 #else
     EXTMODULE_DMA_STREAM->CR |= EXTMODULE_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | DMA_SxCR_PSIZE_1 | DMA_SxCR_MSIZE_1 | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
-    if (IS_SBUS_PROTOCOL(moduleSettings[EXTERNAL_MODULE].protocol))
+    if (IS_SBUS_PROTOCOL(moduleState[EXTERNAL_MODULE].protocol))
       EXTMODULE_TIMER->CCER = TIM_CCER_CC1E | (GET_SBUS_POLARITY(EXTERNAL_MODULE) ? TIM_CCER_CC1P : 0); // reverse polarity for Sbus if needed
 #endif
     EXTMODULE_DMA_STREAM->PAR = CONVERT_PTR_UINT(&EXTMODULE_TIMER->ARR);
diff --git a/radio/src/targets/simu/simpgmspace.cpp b/radio/src/targets/simu/simpgmspace.cpp
index 67d02cb4f..09d3d1805 100644
--- a/radio/src/targets/simu/simpgmspace.cpp
+++ b/radio/src/targets/simu/simpgmspace.cpp
@@ -336,7 +336,7 @@ void StartSimu(bool tests, const char * sdPath, const char * settingsPath)
   if (simu_running)
     return;
 
-  moduleSettings[0].protocol = PROTOCOL_CHANNELS_UNINITIALIZED;
+  moduleState[0].protocol = PROTOCOL_CHANNELS_UNINITIALIZED;
   menuLevel = 0;
 
   simu_start_mode = (tests ? 0 : 0x02 /* OPENTX_START_NO_CHECKS */);
diff --git a/radio/src/targets/sky9x/pulses_driver.cpp b/radio/src/targets/sky9x/pulses_driver.cpp
index 07970d5bc..839e3a958 100644
--- a/radio/src/targets/sky9x/pulses_driver.cpp
+++ b/radio/src/targets/sky9x/pulses_driver.cpp
@@ -262,7 +262,7 @@ extern "C" void PWM_IRQHandler(void)
 
   if (reason & PWM_ISR1_CHID3) {
     // Use the current protocol, don't switch until set_up_pulses
-    switch (moduleSettings[EXTERNAL_MODULE].protocol) {
+    switch (moduleState[EXTERNAL_MODULE].protocol) {
       case PROTOCOL_CHANNELS_PXX1_PULSES:
         // Alternate periods of 6.5mS and 2.5 mS
         period = pwmptr->PWM_CH_NUM[3].PWM_CPDR;
diff --git a/radio/src/targets/taranis/extmodule_driver.cpp b/radio/src/targets/taranis/extmodule_driver.cpp
index 10b3ecfad..ee991fbaf 100644
--- a/radio/src/targets/taranis/extmodule_driver.cpp
+++ b/radio/src/targets/taranis/extmodule_driver.cpp
@@ -269,7 +269,7 @@ void extmodulePxxSerialStart()
 
 void extmoduleSendNextFrame()
 {
-  switch(moduleSettings[EXTERNAL_MODULE].protocol) {
+  switch(moduleState[EXTERNAL_MODULE].protocol) {
     case PROTOCOL_CHANNELS_PPM:
       EXTMODULE_TIMER->CCR1 = GET_MODULE_PPM_DELAY(EXTERNAL_MODULE) * 2;
       EXTMODULE_TIMER->CCER = EXTMODULE_TIMER_OUTPUT_ENABLE | (GET_MODULE_PPM_POLARITY(EXTERNAL_MODULE) ? EXTMODULE_TIMER_OUTPUT_POLARITY : 0); //     // we are using complementary output so logic has to be reversed here
diff --git a/radio/src/targets/taranis/intmodule_pulses_driver.cpp b/radio/src/targets/taranis/intmodule_pulses_driver.cpp
index 719c0ff21..8ff260044 100644
--- a/radio/src/targets/taranis/intmodule_pulses_driver.cpp
+++ b/radio/src/targets/taranis/intmodule_pulses_driver.cpp
@@ -34,7 +34,7 @@ void intmoduleStop()
 
 void intmoduleSendNextFrame()
 {
-  switch (moduleSettings[INTERNAL_MODULE].protocol) {
+  switch (moduleState[INTERNAL_MODULE].protocol) {
 #if defined(PXX1)
     case PROTOCOL_CHANNELS_PXX1_PULSES:
       INTMODULE_TIMER->CCR2 = intmodulePulsesData.pxx.getLast() - 4000; // 2mS in advance
diff --git a/radio/src/tasks.cpp b/radio/src/tasks.cpp
index ae51c8f9f..7697294e8 100644
--- a/radio/src/tasks.cpp
+++ b/radio/src/tasks.cpp
@@ -75,7 +75,7 @@ bool isForcePowerOffRequested()
 
 bool isModuleSynchronous(uint8_t module)
 {
-  uint8_t protocol = moduleSettings[module].protocol;
+  uint8_t protocol = moduleState[module].protocol;
   if (protocol == PROTOCOL_CHANNELS_PXX2 || protocol == PROTOCOL_CHANNELS_CROSSFIRE || protocol == PROTOCOL_CHANNELS_NONE)
     return true;
 #if defined(INTMODULE_USART) || defined(EXTMODULE_USART)
diff --git a/radio/src/telemetry/frsky_pxx2.cpp b/radio/src/telemetry/frsky_pxx2.cpp
index be690fc6e..f017c97be 100644
--- a/radio/src/telemetry/frsky_pxx2.cpp
+++ b/radio/src/telemetry/frsky_pxx2.cpp
@@ -45,39 +45,42 @@ class Pxx2Telemetry
 
 void processGetHardwareInfoFrame(uint8_t module, uint8_t * frame)
 {
-  if (moduleSettings[module].mode != MODULE_MODE_GET_HARDWARE_INFO) {
+  if (moduleState[module].mode != MODULE_MODE_GET_HARDWARE_INFO) {
     return;
   }
 
+  ModuleInformation * destination = moduleState[module].moduleInformation;
+
   uint8_t index = frame[3];
   if (index == 0xFF)
-    memcpy(&reusableBuffer.hardwareAndSettings.modules[module].information, &frame[4], sizeof(PXX2HardwareInformation));
+    memcpy(&destination->information, &frame[4], sizeof(PXX2HardwareInformation));
   else if (index < PXX2_MAX_RECEIVERS_PER_MODULE)
-    memcpy(&reusableBuffer.hardwareAndSettings.modules[module].receivers[index].information, &frame[4], sizeof(PXX2HardwareInformation));
+    memcpy(&destination->receivers[index].information, &frame[4], sizeof(PXX2HardwareInformation));
 }
 
 void processModuleSettingsFrame(uint8_t module, uint8_t * frame)
 {
-  if (moduleSettings[module].mode != MODULE_MODE_MODULE_SETTINGS) {
+  if (moduleState[module].mode != MODULE_MODE_MODULE_SETTINGS) {
     return;
   }
 
+  ModuleSettings * destination = moduleState[module].moduleSettings;
+
   // Flag1
-  reusableBuffer.hardwareAndSettings.moduleSettings.txPower = frame[4] >> 4;
   if (frame[4] & PXX2_TX_SETTINGS_FLAG1_EXTERNAL_ANTENNA)
-    reusableBuffer.hardwareAndSettings.moduleSettings.externalAntenna = 1;
+    destination->externalAntenna = 1;
 
   // Power
-  reusableBuffer.hardwareAndSettings.moduleSettings.txPower = frame[5];
+  destination->txPower = frame[5];
 
-  reusableBuffer.hardwareAndSettings.moduleSettings.state = PXX2_SETTINGS_OK;
-  reusableBuffer.hardwareAndSettings.moduleSettings.timeout = 0;
-  moduleSettings[module].mode = MODULE_MODE_NORMAL;
+  destination->state = PXX2_SETTINGS_OK;
+  destination->retryTime = 0;
+  moduleState[module].mode = MODULE_MODE_NORMAL;
 }
 
 void processReceiverSettingsFrame(uint8_t module, uint8_t * frame)
 {
-  if (moduleSettings[module].mode != MODULE_MODE_RECEIVER_SETTINGS) {
+  if (moduleState[module].mode != MODULE_MODE_RECEIVER_SETTINGS) {
     return;
   }
 
@@ -95,12 +98,12 @@ void processReceiverSettingsFrame(uint8_t module, uint8_t * frame)
 
   reusableBuffer.hardwareAndSettings.receiverSettings.state = PXX2_SETTINGS_OK;
   reusableBuffer.hardwareAndSettings.receiverSettings.timeout = 0;
-  moduleSettings[module].mode = MODULE_MODE_NORMAL;
+  moduleState[module].mode = MODULE_MODE_NORMAL;
 }
 
 void processRegisterFrame(uint8_t module, uint8_t * frame)
 {
-  if (moduleSettings[module].mode != MODULE_MODE_REGISTER) {
+  if (moduleState[module].mode != MODULE_MODE_REGISTER) {
     return;
   }
 
@@ -120,7 +123,7 @@ void processRegisterFrame(uint8_t module, uint8_t * frame)
         if (cmpStrWithZchar((char *)&frame[4], reusableBuffer.moduleSetup.pxx2.registerRxName, PXX2_LEN_RX_NAME) &&
             cmpStrWithZchar((char *)&frame[12], g_model.modelRegistrationID, PXX2_LEN_REGISTRATION_ID)) {
           reusableBuffer.moduleSetup.pxx2.registerStep = REGISTER_OK;
-          moduleSettings[module].mode = MODULE_MODE_NORMAL;
+          moduleState[module].mode = MODULE_MODE_NORMAL;
           POPUP_INFORMATION(STR_REG_OK);
         }
       }
@@ -130,7 +133,7 @@ void processRegisterFrame(uint8_t module, uint8_t * frame)
 
 void processBindFrame(uint8_t module, uint8_t * frame)
 {
-  if (moduleSettings[module].mode != MODULE_MODE_BIND) {
+  if (moduleState[module].mode != MODULE_MODE_BIND) {
     return;
   }
 
@@ -151,7 +154,7 @@ void processBindFrame(uint8_t module, uint8_t * frame)
       break;
 
     case 0x01:
-      if (reusableBuffer.moduleSetup.pxx2.bindStep == BIND_RX_NAME_SELECTED) {
+      if (reusableBuffer.moduleSetup.pxx2.bindStep == BIND_OPTIONS_SELECTED) {
         if (memcmp(&reusableBuffer.moduleSetup.pxx2.bindCandidateReceiversNames[reusableBuffer.moduleSetup.pxx2.bindSelectedReceiverIndex], &frame[4], PXX2_LEN_RX_NAME) == 0) {
           memcpy(g_model.moduleData[module].pxx2.receiverName[reusableBuffer.moduleSetup.pxx2.bindReceiverIndex], &frame[4], PXX2_LEN_RX_NAME);
           storageDirty(EE_MODEL);
@@ -165,7 +168,7 @@ void processBindFrame(uint8_t module, uint8_t * frame)
 
 void processResetFrame(uint8_t module, uint8_t * frame)
 {
-  if (moduleSettings[module].mode != MODULE_MODE_RESET) {
+  if (moduleState[module].mode != MODULE_MODE_RESET) {
     return;
   }
 
@@ -173,7 +176,7 @@ void processResetFrame(uint8_t module, uint8_t * frame)
     memclear(g_model.moduleData[module].pxx2.receiverName[reusableBuffer.moduleSetup.pxx2.resetReceiverIndex], PXX2_LEN_RX_NAME);
   }
 
-  moduleSettings[module].mode = MODULE_MODE_NORMAL;
+  moduleState[module].mode = MODULE_MODE_NORMAL;
 }
 
 void processTelemetryFrame(uint8_t module, uint8_t * frame)
@@ -184,7 +187,7 @@ void processTelemetryFrame(uint8_t module, uint8_t * frame)
 
 void processSpectrumAnalyserFrame(uint8_t module, uint8_t * frame)
 {
-  if (moduleSettings[module].mode != MODULE_MODE_SPECTRUM_ANALYSER) {
+  if (moduleState[module].mode != MODULE_MODE_SPECTRUM_ANALYSER) {
     return;
   }
 
@@ -207,7 +210,7 @@ void processSpectrumAnalyserFrame(uint8_t module, uint8_t * frame)
 
 void processPowerMeterFrame(uint8_t module, uint8_t * frame)
 {
-  if (moduleSettings[module].mode != MODULE_MODE_POWER_METER) {
+  if (moduleState[module].mode != MODULE_MODE_POWER_METER) {
     return;
   }
 
diff --git a/radio/src/telemetry/spektrum.cpp b/radio/src/telemetry/spektrum.cpp
index 96c7102d0..7e72933e6 100644
--- a/radio/src/telemetry/spektrum.cpp
+++ b/radio/src/telemetry/spektrum.cpp
@@ -400,7 +400,7 @@ void processDSMBindPacket(const uint8_t *packet)
   setTelemetryValue(TELEM_PROTO_SPEKTRUM, (I2C_PSEUDO_TX << 8) + 4, 0, 0, debugval, UNIT_RAW, 0);
 
   /* Finally stop binding as the rx just told us that it is bound */
-  if (g_model.moduleData[EXTERNAL_MODULE].type == MODULE_TYPE_MULTIMODULE && g_model.moduleData[EXTERNAL_MODULE].getMultiProtocol(true) == MM_RF_PROTO_DSM2 && moduleSettings[EXTERNAL_MODULE].mode == MODULE_MODE_BIND) {
+  if (g_model.moduleData[EXTERNAL_MODULE].type == MODULE_TYPE_MULTIMODULE && g_model.moduleData[EXTERNAL_MODULE].getMultiProtocol(true) == MM_RF_PROTO_DSM2 && moduleState[EXTERNAL_MODULE].mode == MODULE_MODE_BIND) {
     multiBindStatus=MULTI_BIND_FINISHED;
   }
 }