Mirror/opentx
1
0
Fork 0
mirror of https://github.com/opentx/opentx.git synced 2025-07-19 06:15:10 +03:00
Code Issues Wiki Activity

[PXX2] R9M/R9 BIND options added

Browse source
This commit is contained in:
Bertrand Songis 2019-04-24 11:13:29 +02:00
parent 2df7002b43
commit 3a99fcd826
29 changed files with 335 additions and 227 deletions
Download patch file Download diff file Expand all files Collapse all files

4
radio/src/functions.cpp
View file

@ -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;
}

42
radio/src/gui/128x64/model_module_options.cpp
View file

@ -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;

14
radio/src/gui/128x64/model_receiver_options.cpp
View file

@ -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) {

133
radio/src/gui/128x64/model_setup.cpp
View file

@ -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) {

12
radio/src/gui/128x64/radio_version.cpp
View file

@ -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*/;

2
radio/src/gui/128x64/view_main.cpp
View file

@ -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);
}

10
radio/src/gui/212x64/model_setup.cpp
View file

@ -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;

14
radio/src/gui/480x272/model_setup.cpp
View file

@ -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;

6
radio/src/gui/common/stdlcd/radio_power_meter.cpp
View file

@ -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

6
radio/src/gui/common/stdlcd/radio_spectrum_analyser.cpp
View file

@ -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++) {

4
radio/src/gui/common/stdlcd/radio_tools.cpp
View file

@ -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

4
radio/src/opentx.cpp
View file

@ -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;

37
radio/src/opentx.h
View file

@ -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 {

12
radio/src/pulses/dsm2.cpp
View file

@ -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

6
radio/src/pulses/multi.cpp
View file

@ -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

14
radio/src/pulses/pulses.cpp
View file

@ -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;
}

81
radio/src/pulses/pulses.h
View file

@ -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;
}
}

14
radio/src/pulses/pxx1.cpp
View file

@ -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;
}

60
radio/src/pulses/pxx2.cpp
View file

@ -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();

16
radio/src/pulses/pxx2.h
View file

@ -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

2
radio/src/targets/common/arm/stm32/intmodule_serial_driver.cpp
View file

@ -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());

14
radio/src/targets/horus/extmodule_driver.cpp
View file

@ -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);

2
radio/src/targets/simu/simpgmspace.cpp
View file

@ -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 */);

2
radio/src/targets/sky9x/pulses_driver.cpp
View file

@ -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;

2
radio/src/targets/taranis/extmodule_driver.cpp
View file

@ -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

2
radio/src/targets/taranis/intmodule_pulses_driver.cpp
View file

@ -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

2
radio/src/tasks.cpp
View file

@ -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)

43
radio/src/telemetry/frsky_pxx2.cpp
View file

@ -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;
}

2
radio/src/telemetry/spektrum.cpp
View file

@ -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;
}
}