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

Clean outdated and unused pxx2 code (#6458)

Browse source 
Remove outdated PXX2 code from X10 / X12S
This commit is contained in:
3djc 2019-05-29 15:42:28 +02:00 • committed by Bertrand Songis
parent fe1777e270
commit 1b71b7fcbc
13 changed files with 71 additions and 1026 deletions
Download patch file Download diff file Expand all files Collapse all files

4
radio/src/gui/128x64/radio_setup.cpp
View file

@ -94,7 +94,7 @@ enum MenuRadioSetupItems {
CASE_GPS(ITEM_SETUP_TIMEZONE)
ITEM_SETUP_ADJUST_RTC,
CASE_GPS(ITEM_SETUP_GPSFORMAT)
CASE_PXX(ITEM_SETUP_COUNTRYCODE)
CASE_PXX1(ITEM_SETUP_COUNTRYCODE)
ITEM_SETUP_LANGUAGE,
ITEM_SETUP_IMPERIAL,
IF_FAI_CHOICE(ITEM_SETUP_FAI)
@ -164,7 +164,7 @@ void menuRadioSetup(event_t event)
CASE_GPS(0)
0, CASE_GPS(0)
CASE_PXX(0)
CASE_PXX1(0)
0, 0, IF_FAI_CHOICE(0)
0,
CASE_STM32(0) // USB mode

4
radio/src/gui/212x64/radio_setup.cpp
View file

@ -82,7 +82,7 @@ enum MenuRadioSetupItems {
CASE_GPS(ITEM_SETUP_TIMEZONE)
CASE_GPS(ITEM_SETUP_ADJUST_RTC)
CASE_GPS(ITEM_SETUP_GPSFORMAT)
CASE_PXX(ITEM_SETUP_COUNTRYCODE)
CASE_PXX1(ITEM_SETUP_COUNTRYCODE)
ITEM_SETUP_LANGUAGE,
ITEM_SETUP_IMPERIAL,
IF_FAI_CHOICE(ITEM_SETUP_FAI)
@ -116,7 +116,7 @@ void menuRadioSetup(event_t event)
}
#endif
MENU(STR_MENURADIOSETUP, menuTabGeneral, MENU_RADIO_SETUP, ITEM_SETUP_MAX, { 2, 2, 0, 1, LABEL(SOUND), 0, 0, 0, 0, 0, 0, 0, CASE_VARIO(LABEL(VARIO)) CASE_VARIO(0) CASE_VARIO(0) CASE_VARIO(0) CASE_VARIO(0) CASE_HAPTIC(LABEL(HAPTIC)) CASE_HAPTIC(0) CASE_HAPTIC(0) CASE_HAPTIC(0) 0, LABEL(ALARMS), 0, 0, 0, 0, 0, LABEL(BACKLIGHT), 0, 0, 0, CASE_PCBX9E_PCBX9DP(0) 0, CASE_SPLASH_PARAM(0) CASE_GPS(LABEL(GPS)) CASE_GPS(0) CASE_GPS(0) CASE_GPS(0) CASE_PXX(0) 0, 0, IF_FAI_CHOICE(0) 0, 0, 0, LABEL(TX_MODE), 0, 1/*to force edit mode*/ });
MENU(STR_MENURADIOSETUP, menuTabGeneral, MENU_RADIO_SETUP, ITEM_SETUP_MAX, { 2, 2, 0, 1, LABEL(SOUND), 0, 0, 0, 0, 0, 0, 0, CASE_VARIO(LABEL(VARIO)) CASE_VARIO(0) CASE_VARIO(0) CASE_VARIO(0) CASE_VARIO(0) CASE_HAPTIC(LABEL(HAPTIC)) CASE_HAPTIC(0) CASE_HAPTIC(0) CASE_HAPTIC(0) 0, LABEL(ALARMS), 0, 0, 0, 0, 0, LABEL(BACKLIGHT), 0, 0, 0, CASE_PCBX9E_PCBX9DP(0) 0, CASE_SPLASH_PARAM(0) CASE_GPS(LABEL(GPS)) CASE_GPS(0) CASE_GPS(0) CASE_GPS(0) CASE_PXX1(0) 0, 0, IF_FAI_CHOICE(0) 0, 0, 0, LABEL(TX_MODE), 0, 1/*to force edit mode*/ });
if (event == EVT_ENTRY) {
reusableBuffer.generalSettings.stickMode = g_eeGeneral.stickMode;

8
radio/src/gui/480x272/lcd.cpp
View file

@ -511,11 +511,3 @@ void DMABitmapConvert(uint16_t * dest, const uint8_t * src, uint16_t w, uint16_t
}
}
#endif
void drawReceiverName(coord_t x, coord_t y, uint8_t moduleIdx, uint8_t receiverIdx, LcdFlags flags)
{
if (g_model.moduleData[moduleIdx].pxx2.receiverName[receiverIdx][0] != '\0')
lcdDrawSizedText(x, y, g_model.moduleData[moduleIdx].pxx2.receiverName[receiverIdx], effectiveLen(g_model.moduleData[moduleIdx].pxx2.receiverName[receiverIdx], PXX2_LEN_RX_NAME), flags);
else
lcdDrawText(x, y, "---", flags);
}

3
radio/src/gui/480x272/menu_radio.cpp
View file

@ -23,9 +23,6 @@
const MenuHandlerFunc menuTabGeneral[MENU_RADIO_PAGES_COUNT] = {
menuRadioSetup,
menuRadioSdManager,
#if defined(PXX2)
menuRadioTools,
#endif
menuRadioSpecialFunctions,
menuRadioTrainer,
menuRadioHardware,

8
radio/src/gui/480x272/menus.h
View file

@ -165,8 +165,6 @@ const uint8_t MONITOR_ICONS[] = {
bool menuModelSetup(event_t event);
bool menuModelFailsafe(event_t event);
bool menuModelModuleOptions(event_t event);
bool menuModelReceiverOptions(event_t event);
bool menuModelHeli(event_t event);
bool menuModelFlightModesAll(event_t event);
bool menuModelExposAll(event_t event);
@ -187,9 +185,6 @@ extern const MenuHandlerFunc menuTabModel[MENU_MODEL_PAGES_COUNT];
enum EnumTabRadio {
MENU_RADIO_SETUP,
MENU_RADIO_SD_MANAGER,
#if defined(PXX2)
MENU_RADIO_TOOLS,
#endif
MENU_RADIO_SPECIAL_FUNCTIONS,
MENU_RADIO_TRAINER,
MENU_RADIO_HARDWARE,
@ -201,9 +196,6 @@ const uint8_t RADIO_ICONS[MENU_RADIO_PAGES_COUNT + 1] = {
ICON_RADIO,
ICON_RADIO_SETUP,
ICON_RADIO_SD_BROWSER,
#if defined(PXX2)
ICON_RADIO_SETUP,
#endif
ICON_RADIO_GLOBAL_FUNCTIONS,
ICON_RADIO_TRAINER,
ICON_RADIO_HARDWARE,

166
radio/src/gui/480x272/model_module_options.cpp
View file

@ -1,166 +0,0 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <opentx.h>
#include <math.h>
#define RECEIVER_OPTIONS_2ND_COLUMN (200)
extern uint8_t g_moduleIdx;
void onTxOptionsUpdateConfirm(const char * result)
{
if (result == STR_OK)
moduleState[g_moduleIdx].readModuleSettings(&reusableBuffer.hardwareAndSettings.moduleSettings);
else
popMenu();
}
enum {
ITEM_MODULE_SETTINGS_EXTERNAL_ANTENNA,
ITEM_MODULE_SETTINGS_POWER,
ITEM_MODULE_SETTINGS_COUNT
};
#define IF_MODULE_OPTIONS(option, count) uint8_t(isModuleOptionAvailable(modelId, option) ? count : HIDDEN_ROW)
bool isPowerAvailable(int value)
{
uint8_t modelId = reusableBuffer.hardwareAndSettings.modules[g_moduleIdx].information.modelID;
uint8_t variant = reusableBuffer.hardwareAndSettings.modules[g_moduleIdx].information.variant;
if (modelId == PXX2_MODULE_R9M_LITE) {
if (variant == PXX2_VARIANT_EU)
return (value == 14 /* 25 mW */ ||
value == 20 /* 100 mW */);
else
return value == 20; /* 100 mW */
}
else if (modelId == PXX2_MODULE_R9M || modelId == PXX2_MODULE_R9M_LITE_PRO) {
if (variant == PXX2_VARIANT_EU)
return (value == 14 /* 25 mW */ ||
value == 23 /* 200 mW */ ||
value == 27 /* 500 mW */);
else
return (value == 10 /* 10 mW */ ||
value == 20 /* 100 mW */ ||
value == 27 /* 500 mW */ ||
value == 30 /* 1000 mW */);
}
else {
return (value <= 20); /* 100 mW max for XJTs */
}
}
bool menuModelModuleOptions(event_t event)
{
uint8_t modelId = reusableBuffer.hardwareAndSettings.modules[g_moduleIdx].information.modelID;
// uint8_t variant = reusableBuffer.hardwareAndSettings.modules[g_moduleIdx].information.variant;
SUBMENU("Module Options", ICON_RADIO, ITEM_MODULE_SETTINGS_COUNT, {
IF_MODULE_OPTIONS(MODULE_OPTION_EXTERNAL_ANTENNA, 0),
IF_MODULE_OPTIONS(MODULE_OPTION_POWER, 0),
});
if (event == EVT_ENTRY) {
#if defined(SIMU)
reusableBuffer.hardwareAndSettings.moduleSettings.state = PXX2_SETTINGS_OK;
#else
// 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 && moduleState[g_moduleIdx].mode == MODULE_MODE_NORMAL) {
moduleState[g_moduleIdx].readModuleSettings(&reusableBuffer.hardwareAndSettings.moduleSettings);
}
if (menuEvent) {
moduleState[g_moduleIdx].mode = MODULE_MODE_NORMAL;
if (reusableBuffer.hardwareAndSettings.moduleSettingsDirty) {
abortPopMenu();
POPUP_CONFIRMATION(STR_UPDATE_TX_OPTIONS, onTxOptionsUpdateConfirm);
}
else {
return true;
}
}
if (event == EVT_KEY_LONG(KEY_ENTER) && reusableBuffer.hardwareAndSettings.moduleSettingsDirty) {
killEvents(event);
reusableBuffer.hardwareAndSettings.moduleSettingsDirty = 0;
moduleState[g_moduleIdx].writeModuleSettings(&reusableBuffer.hardwareAndSettings.moduleSettings);
}
if (reusableBuffer.hardwareAndSettings.moduleSettingsDirty == 2 && reusableBuffer.hardwareAndSettings.moduleSettings.state == PXX2_SETTINGS_OK) {
popMenu();
}
if (modelId != 0 && mstate_tab[menuVerticalPosition] == HIDDEN_ROW) {
menuVerticalPosition = 0;
while (menuVerticalPosition < ITEM_MODULE_SETTINGS_COUNT && mstate_tab[menuVerticalPosition] == HIDDEN_ROW) {
++menuVerticalPosition;
}
}
int8_t sub = menuVerticalPosition;
lcdDrawText(300, 0, PXX2modulesModels[modelId] );
if (reusableBuffer.hardwareAndSettings.moduleSettings.state == PXX2_SETTINGS_OK) {
for (uint8_t k=0; k<NUM_BODY_LINES+1; k++) {
coord_t y = MENU_HEADER_HEIGHT + 1 + k*FH;
uint8_t i = k + menuVerticalOffset;
for (int j=0; j<=i; ++j) {
if (j<(int)DIM(mstate_tab) && mstate_tab[j] == HIDDEN_ROW) {
++i;
}
}
LcdFlags attr = (sub==i ? (s_editMode>0 ? BLINK|INVERS : INVERS) : 0);
switch (i) {
case ITEM_MODULE_SETTINGS_EXTERNAL_ANTENNA:
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_EXT_ANTENNA);
reusableBuffer.hardwareAndSettings.moduleSettings.externalAntenna = editCheckBox(reusableBuffer.hardwareAndSettings.moduleSettings.externalAntenna, RECEIVER_OPTIONS_2ND_COLUMN, y, attr, event);
if (attr && checkIncDec_Ret) {
reusableBuffer.hardwareAndSettings.moduleSettingsDirty = true;
}
break;
case ITEM_MODULE_SETTINGS_POWER:
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_POWER);
lcdDrawNumber(RECEIVER_OPTIONS_2ND_COLUMN, y, reusableBuffer.hardwareAndSettings.moduleSettings.txPower, attr);
lcdDrawText(lcdNextPos, y, "dBm(");
drawPower(lcdNextPos, y, reusableBuffer.hardwareAndSettings.moduleSettings.txPower);
lcdDrawText(lcdNextPos, y, ")");
if (attr) {
reusableBuffer.hardwareAndSettings.moduleSettings.txPower = checkIncDec(event, reusableBuffer.hardwareAndSettings.moduleSettings.txPower, 0, 30, 0, &isPowerAvailable);
if (checkIncDec_Ret) {
reusableBuffer.hardwareAndSettings.moduleSettingsDirty = true;
}
}
break;
}
}
}
else {
lcdDrawCenteredText(LCD_H/2, STR_WAITING_FOR_TX);
}
return true;
}

157
radio/src/gui/480x272/model_receiver_options.cpp
View file

@ -1,157 +0,0 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <opentx.h>
#define RECEIVER_OPTIONS_2ND_COLUMN 200
extern uint8_t g_moduleIdx;
void onRxOptionsUpdateConfirm(const char * result)
{
if (result == STR_OK) {
reusableBuffer.hardwareAndSettings.receiverSettings.state = PXX2_SETTINGS_WRITE;
reusableBuffer.hardwareAndSettings.receiverSettings.dirty = 2;
reusableBuffer.hardwareAndSettings.receiverSettings.timeout = 0;
moduleState[g_moduleIdx].mode = MODULE_MODE_RECEIVER_SETTINGS;
}
else {
popMenu();
}
}
enum {
ITEM_RECEIVER_TELEMETRY,
ITEM_RECEIVER_PWM_RATE,
ITEM_RECEIVER_PINMAP_FIRST
};
bool menuModelReceiverOptions(event_t event)
{
const int lim = (g_model.extendedLimits ? (512 * LIMIT_EXT_PERCENT / 100) : 512) * 2;
uint8_t wbar = LCD_W / 2 - 20;
auto outputsCount = min<uint8_t>(16, reusableBuffer.hardwareAndSettings.receiverSettings.outputsCount);
SIMPLE_SUBMENU(STR_RECEIVER_OPTIONS, ICON_RADIO, ITEM_RECEIVER_PINMAP_FIRST + outputsCount);
if (event == EVT_ENTRY) {
#if defined(SIMU)
reusableBuffer.hardwareAndSettings.receiverSettings.state = PXX2_SETTINGS_OK;
reusableBuffer.hardwareAndSettings.receiverSettings.outputsCount = 8;
#else
// no need to initialize reusableBuffer.hardwareAndSettings.receiverSettings.state to PXX2_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 && moduleState[g_moduleIdx].mode == MODULE_MODE_NORMAL) {
reusableBuffer.hardwareAndSettings.receiverSettings.state = PXX2_SETTINGS_READ;
moduleState[g_moduleIdx].mode = MODULE_MODE_RECEIVER_SETTINGS;
}
if (menuEvent) {
moduleState[g_moduleIdx].mode = MODULE_MODE_NORMAL;
if (reusableBuffer.hardwareAndSettings.receiverSettings.dirty) {
abortPopMenu();
POPUP_CONFIRMATION(STR_UPDATE_RX_OPTIONS, onRxOptionsUpdateConfirm);
}
else {
return true;
}
}
if (event == EVT_KEY_LONG(KEY_ENTER) && reusableBuffer.hardwareAndSettings.receiverSettings.dirty) {
killEvents(event);
reusableBuffer.hardwareAndSettings.receiverSettings.state = PXX2_SETTINGS_WRITE;
reusableBuffer.hardwareAndSettings.receiverSettings.dirty = 0;
reusableBuffer.hardwareAndSettings.receiverSettings.timeout = 0;
moduleState[g_moduleIdx].mode = MODULE_MODE_RECEIVER_SETTINGS;
}
if (reusableBuffer.hardwareAndSettings.receiverSettings.dirty == 2 && reusableBuffer.hardwareAndSettings.receiverSettings.state == PXX2_SETTINGS_OK) {
popMenu();
return true;
}
int8_t sub = menuVerticalPosition;
drawReceiverName(130, 0, g_moduleIdx, reusableBuffer.hardwareAndSettings.receiverSettings.receiverId);
if (reusableBuffer.hardwareAndSettings.receiverSettings.state == PXX2_SETTINGS_OK) {
for (uint8_t k=0; k<NUM_BODY_LINES+1; k++) {
coord_t y = MENU_HEADER_HEIGHT + 1 + k*FH;
uint8_t i = k + menuVerticalOffset;
LcdFlags attr = (sub==i ? (s_editMode>0 ? BLINK|INVERS : INVERS) : 0);
switch (i) {
case ITEM_RECEIVER_TELEMETRY:
lcdDrawText(MENUS_MARGIN_LEFT, y, "Telemetry disabled");
reusableBuffer.hardwareAndSettings.receiverSettings.telemetryDisabled = editCheckBox(reusableBuffer.hardwareAndSettings.receiverSettings.telemetryDisabled, RECEIVER_OPTIONS_2ND_COLUMN, y, attr, event);
if (attr && checkIncDec_Ret) {
reusableBuffer.hardwareAndSettings.receiverSettings.dirty = true;
}
break;
case ITEM_RECEIVER_PWM_RATE:
lcdDrawText(MENUS_MARGIN_LEFT, y, isModuleR9M2(g_moduleIdx) ? "6.67ms PWM": "9ms PWM");
reusableBuffer.hardwareAndSettings.receiverSettings.pwmRate = editCheckBox(reusableBuffer.hardwareAndSettings.receiverSettings.pwmRate, RECEIVER_OPTIONS_2ND_COLUMN, y, attr, event);
if (attr && checkIncDec_Ret) {
reusableBuffer.hardwareAndSettings.receiverSettings.dirty = true;
}
break;
default:
// Pin
{
uint8_t pin = i - ITEM_RECEIVER_PINMAP_FIRST;
if (pin < reusableBuffer.hardwareAndSettings.receiverSettings.outputsCount) {
uint8_t channel = g_model.moduleData[g_moduleIdx].channelsStart + reusableBuffer.hardwareAndSettings.receiverSettings.outputsMapping[pin];
int32_t channelValue = channelOutputs[channel];
lcdDrawText(MENUS_MARGIN_LEFT, y, "Pin");
lcdDrawNumber(lcdNextPos + 1, y, pin + 1);
putsChn(80, y, channel + 1, attr);
// Channel
if (attr) {
channel = checkIncDec(event, channel, 0, sentModuleChannels(g_moduleIdx) - 1);
if (checkIncDec_Ret) {
reusableBuffer.hardwareAndSettings.receiverSettings.outputsMapping[pin] = channel;
reusableBuffer.hardwareAndSettings.receiverSettings.dirty = true;
}
}
// Bargraph
#if !defined(PCBX7) // X7 LCD doesn't like too many horizontal lines
lcdDrawRect(LCD_W - 3 - wbar, y + 1, wbar + 1, 4);
#endif
const uint8_t lenChannel = limit<uint8_t>(1, (abs(channelValue) * wbar / 2 + lim / 2) / lim, wbar / 2);
const coord_t xChannel = (channelValue > 0) ? LCD_W - 3 - wbar / 2 : LCD_W - 2 - wbar / 2 - lenChannel;
lcdDrawHorizontalLine(xChannel, y + 2, lenChannel, SOLID, 0);
lcdDrawHorizontalLine(xChannel, y + 3, lenChannel, SOLID, 0);
}
break;
}
}
}
}
else {
lcdDrawCenteredText(LCD_H/2, "Waiting for RX...");
}
return true;
}

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

@ -23,13 +23,6 @@
uint8_t g_moduleIdx;
// TODO find why we need this (for REGISTER at least)
#if defined(PCBXLITE)
#define EVT_BUTTON_PRESSED() EVT_KEY_FIRST(KEY_ENTER)
#else
#define EVT_BUTTON_PRESSED() EVT_KEY_BREAK(KEY_ENTER)
#endif
enum MenuModelSetupItems {
ITEM_MODEL_NAME,
ITEM_MODEL_BITMAP,
@ -69,19 +62,12 @@ enum MenuModelSetupItems {
ITEM_MODEL_SLIDERS_WARNING,
ITEM_MODEL_BEEP_CENTER,
ITEM_MODEL_USE_GLOBAL_FUNCTIONS,
ITEM_MODEL_REGISTRATION_ID,
ITEM_MODEL_INTERNAL_MODULE_LABEL,
ITEM_MODEL_INTERNAL_MODULE_MODE,
ITEM_MODEL_INTERNAL_MODULE_CHANNELS,
ITEM_MODEL_INTERNAL_MODULE_NPXX2_BIND,
ITEM_MODEL_INTERNAL_MODULE_PXX2_MODEL_NUM,
ITEM_MODEL_INTERNAL_MODULE_BIND,
ITEM_MODEL_INTERNAL_MODULE_FAILSAFE,
ITEM_MODEL_INTERNAL_MODULE_ANTENNA,
ITEM_MODEL_INTERNAL_MODULE_PXX2_REGISTER_RANGE,
ITEM_MODEL_INTERNAL_MODULE_PXX2_OPTIONS,
ITEM_MODEL_INTERNAL_MODULE_PXX2_RECEIVER_1,
ITEM_MODEL_INTERNAL_MODULE_PXX2_RECEIVER_2,
ITEM_MODEL_INTERNAL_MODULE_PXX2_RECEIVER_3,
ITEM_MODEL_EXTERNAL_MODULE_LABEL,
ITEM_MODEL_EXTERNAL_MODULE_MODE,
#if defined(MULTIMODULE)
@ -91,11 +77,6 @@ enum MenuModelSetupItems {
ITEM_MODEL_EXTERNAL_MODULE_CHANNELS,
ITEM_MODEL_EXTERNAL_MODULE_BIND,
ITEM_MODEL_EXTERNAL_MODULE_FAILSAFE,
ITEM_MODEL_EXTERNAL_MODULE_PXX2_REGISTER_RANGE,
ITEM_MODEL_EXTERNAL_MODULE_PXX2_OPTIONS,
ITEM_MODEL_EXTERNAL_MODULE_PXX2_RECEIVER_1,
ITEM_MODEL_EXTERNAL_MODULE_PXX2_RECEIVER_2,
ITEM_MODEL_EXTERNAL_MODULE_PXX2_RECEIVER_3,
ITEM_MODEL_EXTERNAL_MODULE_OPTIONS,
#if defined(MULTIMODULE)
ITEM_MODEL_EXTERNAL_MODULE_AUTOBIND,
@ -117,156 +98,6 @@ enum MenuModelSetupItems {
#define MODEL_SETUP_SLIDPOT_SPACING 45
#define CURRENT_MODULE_EDITED(k) (k >= ITEM_MODEL_EXTERNAL_MODULE_LABEL ? EXTERNAL_MODULE : INTERNAL_MODULE)
#define CURRENT_RECEIVER_EDITED(k) (k - (k >= ITEM_MODEL_EXTERNAL_MODULE_LABEL ? ITEM_MODEL_EXTERNAL_MODULE_PXX2_RECEIVER_1 : ITEM_MODEL_INTERNAL_MODULE_PXX2_RECEIVER_1))
bool isPXX2ReceiverEmpty(uint8_t moduleIdx, uint8_t receiverIdx)
{
return is_memclear(g_model.moduleData[moduleIdx].pxx2.receiverName[receiverIdx], PXX2_LEN_RX_NAME);
}
void removePXX2Receiver(uint8_t moduleIdx, uint8_t receiverIdx)
{
memclear(g_model.moduleData[moduleIdx].pxx2.receiverName[receiverIdx], PXX2_LEN_RX_NAME);
g_model.moduleData[moduleIdx].pxx2.receivers &= ~(1 << receiverIdx);
storageDirty(EE_MODEL);
}
void removePXX2ReceiverIfEmpty(uint8_t moduleIdx, uint8_t receiverIdx)
{
if (isPXX2ReceiverEmpty(moduleIdx, receiverIdx)) {
removePXX2Receiver(moduleIdx, receiverIdx);
}
}
void onPXX2R9MBindModeMenu(const char * result)
{
if (result == STR_8CH_WITH_TELEMETRY) {
reusableBuffer.moduleSetup.bindInformation.lbtMode = 0;
}
else if (result == STR_16CH_WITH_TELEMETRY) {
reusableBuffer.moduleSetup.bindInformation.lbtMode = 1;
}
else if (result == STR_16CH_WITHOUT_TELEMETRY) {
reusableBuffer.moduleSetup.bindInformation.lbtMode = 2;
}
else if (result == STR_FLEX_868) {
reusableBuffer.moduleSetup.bindInformation.flexMode = 0;
}
else if (result == STR_FLEX_915) {
reusableBuffer.moduleSetup.bindInformation.flexMode = 1;
}
else {
// the user pressed [Exit]
uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition);
uint8_t receiverIdx = CURRENT_RECEIVER_EDITED(menuVerticalPosition);
moduleState[moduleIdx].mode = MODULE_MODE_NORMAL;
removePXX2ReceiverIfEmpty(moduleIdx, receiverIdx);
return;
}
#if defined(SIMU)
uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition);
uint8_t receiverIdx = CURRENT_RECEIVER_EDITED(menuVerticalPosition);
memcpy(g_model.moduleData[moduleIdx].pxx2.receiverName[receiverIdx], reusableBuffer.moduleSetup.bindInformation.candidateReceiversNames[reusableBuffer.moduleSetup.bindInformation.selectedReceiverIndex], PXX2_LEN_RX_NAME);
storageDirty(EE_MODEL);
moduleState[moduleIdx].mode = MODULE_MODE_NORMAL;
reusableBuffer.moduleSetup.bindInformation.step = BIND_OK;
POPUP_INFORMATION(STR_BIND_OK);
#else
reusableBuffer.moduleSetup.bindInformation.step = BIND_START;
#endif
}
enum PopupRegisterItems {
ITEM_REGISTER_PASSWORD,
ITEM_REGISTER_MODULE_INDEX,
ITEM_REGISTER_RECEIVER_NAME,
ITEM_REGISTER_BUTTONS
};
#define REGISTER_POPUP_MARGIN 80
void runPopupRegister(event_t event)
{
uint8_t backupVerticalPosition = menuVerticalPosition;
uint8_t backupHorizontalPosition = menuHorizontalPosition;
uint8_t backupVerticalOffset = menuVerticalOffset;
int8_t backupEditMode = s_editMode;
menuVerticalPosition = reusableBuffer.moduleSetup.pxx2.registerPopupVerticalPosition;
menuHorizontalPosition = reusableBuffer.moduleSetup.pxx2.registerPopupHorizontalPosition;
s_editMode = reusableBuffer.moduleSetup.pxx2.registerPopupEditMode;
switch (event) {
case EVT_KEY_BREAK(KEY_ENTER):
if (menuVerticalPosition != ITEM_REGISTER_BUTTONS) {
break;
}
else if (reusableBuffer.moduleSetup.pxx2.registerStep >= REGISTER_RX_NAME_RECEIVED && menuHorizontalPosition == 0) {
// [Enter] pressed
reusableBuffer.moduleSetup.pxx2.registerStep = REGISTER_RX_NAME_SELECTED;
backupEditMode = EDIT_MODIFY_FIELD; // so that the [Register] button blinks and the REGISTER process can continue
}
// no break
case EVT_KEY_LONG(KEY_EXIT):
s_editMode = 0;
// no break;
case EVT_KEY_BREAK(KEY_EXIT):
if (s_editMode <= 0) {
warningText = nullptr;
}
break;
}
if (warningText) {
const uint8_t dialogRows[] = { 0, 0, uint8_t(reusableBuffer.moduleSetup.pxx2.registerStep < REGISTER_RX_NAME_RECEIVED ? READONLY_ROW : 0), uint8_t(reusableBuffer.moduleSetup.pxx2.registerStep < REGISTER_RX_NAME_RECEIVED ? 0 : 1)};
check(event, 0, nullptr, 0, dialogRows, 3, 4); // TODO add a comment for 3 - HEADER_LINE once understood
showMessageBox(warningText);
// registration password
lcdDrawText(WARNING_LINE_X, WARNING_LINE_Y - 4, STR_REG_ID);
editName(WARNING_LINE_X + REGISTER_POPUP_MARGIN, WARNING_LINE_Y - 4, g_model.modelRegistrationID, PXX2_LEN_REGISTRATION_ID, event, menuVerticalPosition == ITEM_REGISTER_PASSWORD);
// loop index (will be removed in future)
lcdDrawText(WARNING_LINE_X, WARNING_LINE_Y - 4 + FH, "UID");
lcdDrawNumber(WARNING_LINE_X + REGISTER_POPUP_MARGIN, WARNING_LINE_Y - 4 + FH, reusableBuffer.moduleSetup.pxx2.registerLoopIndex, menuVerticalPosition == ITEM_REGISTER_MODULE_INDEX ? (s_editMode ? INVERS + BLINK : INVERS) : 0);
if (menuVerticalPosition == ITEM_REGISTER_MODULE_INDEX && s_editMode) {
CHECK_INCDEC_MODELVAR_ZERO(event, reusableBuffer.moduleSetup.pxx2.registerLoopIndex, 2);
}
// RX name
if (reusableBuffer.moduleSetup.pxx2.registerStep < REGISTER_RX_NAME_RECEIVED) {
lcdDrawText(WARNING_LINE_X, WARNING_LINE_Y - 4 + 2 * FH, STR_WAITING);
lcdDrawText(WARNING_LINE_X, WARNING_LINE_Y - 2 + 3 * FH, TR_EXIT, menuVerticalPosition == ITEM_REGISTER_BUTTONS ? INVERS : 0);
}
else {
lcdDrawText(WARNING_LINE_X, WARNING_LINE_Y - 4 + 2 * FH, STR_RX_NAME);
editName(WARNING_LINE_X + REGISTER_POPUP_MARGIN, WARNING_LINE_Y - 4 + 2 * FH, reusableBuffer.moduleSetup.pxx2.registerRxName, PXX2_LEN_RX_NAME, event, menuVerticalPosition == ITEM_REGISTER_RECEIVER_NAME);
lcdDrawText(WARNING_LINE_X, WARNING_LINE_Y - 2 + 3 * FH, TR_ENTER, menuVerticalPosition == ITEM_REGISTER_BUTTONS && menuHorizontalPosition == 0 ? INVERS : 0);
lcdDrawText(WARNING_LINE_X + REGISTER_POPUP_MARGIN, WARNING_LINE_Y - 2 + 3 * FH, TR_EXIT, menuVerticalPosition == ITEM_REGISTER_BUTTONS && menuHorizontalPosition == 1 ? INVERS : 0);
}
reusableBuffer.moduleSetup.pxx2.registerPopupVerticalPosition = menuVerticalPosition;
reusableBuffer.moduleSetup.pxx2.registerPopupHorizontalPosition = menuHorizontalPosition;
reusableBuffer.moduleSetup.pxx2.registerPopupEditMode = s_editMode;
}
menuVerticalPosition = backupVerticalPosition;
menuHorizontalPosition = backupHorizontalPosition;
menuVerticalOffset = backupVerticalOffset;
s_editMode = backupEditMode;
}
void startRegisterDialog(uint8_t module)
{
memclear(&reusableBuffer.moduleSetup.pxx2, sizeof(reusableBuffer.moduleSetup.pxx2));
moduleState[module].mode = MODULE_MODE_REGISTER;
s_editMode = 0;
POPUP_INPUT("", runPopupRegister);
}
void checkModelIdUnique(uint8_t moduleIdx)
{
@ -285,99 +116,6 @@ void checkModelIdUnique(uint8_t moduleIdx)
}
}
void onPXX2BindMenu(const char * result)
{
if (result != STR_EXIT) {
uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition);
reusableBuffer.moduleSetup.bindInformation.selectedReceiverIndex = (result - reusableBuffer.moduleSetup.bindInformation.candidateReceiversNames[0]) / sizeof(reusableBuffer.moduleSetup.bindInformation.candidateReceiversNames[0]);
if (isModuleR9M2(moduleIdx) && reusableBuffer.moduleSetup.pxx2.moduleInformation.information.variant == PXX2_VARIANT_EU) {
reusableBuffer.moduleSetup.bindInformation.step = BIND_RX_NAME_SELECTED;
POPUP_MENU_ADD_ITEM(STR_8CH_WITH_TELEMETRY);
POPUP_MENU_ADD_ITEM(STR_16CH_WITH_TELEMETRY);
POPUP_MENU_ADD_ITEM(STR_16CH_WITHOUT_TELEMETRY);
POPUP_MENU_START(onPXX2R9MBindModeMenu);
}
else if (isModuleR9M2(moduleIdx) && reusableBuffer.moduleSetup.pxx2.moduleInformation.information.variant == PXX2_VARIANT_FLEX) {
reusableBuffer.moduleSetup.bindInformation.step = BIND_RX_NAME_SELECTED;
POPUP_MENU_ADD_ITEM(STR_FLEX_868);
POPUP_MENU_ADD_ITEM(STR_FLEX_915);
POPUP_MENU_START(onPXX2R9MBindModeMenu);
}
else {
#if defined(SIMU)
uint8_t receiverIdx = CURRENT_RECEIVER_EDITED(menuVerticalPosition);
memcpy(g_model.moduleData[moduleIdx].pxx2.receiverName[receiverIdx], result, PXX2_LEN_RX_NAME);
storageDirty(EE_MODEL);
moduleState[moduleIdx].mode = MODULE_MODE_NORMAL;
reusableBuffer.moduleSetup.bindInformation.step = BIND_OK;
POPUP_INFORMATION(STR_BIND_OK);
#else
reusableBuffer.moduleSetup.bindInformation.step = BIND_START;
#endif
}
}
else {
// the user pressed [Exit]
uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition);
uint8_t receiverIdx = CURRENT_RECEIVER_EDITED(menuVerticalPosition);
moduleState[moduleIdx].mode = MODULE_MODE_NORMAL;
removePXX2ReceiverIfEmpty(moduleIdx, receiverIdx);
}
}
void onResetReceiverConfirm(const char * result)
{
if (result == STR_OK) {
uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition);
uint8_t receiverIdx = CURRENT_RECEIVER_EDITED(menuVerticalPosition);
moduleState[moduleIdx].mode = MODULE_MODE_RESET;
removePXX2Receiver(moduleIdx, receiverIdx);
}
}
void onPXX2ReceiverMenu(const char * result)
{
uint8_t moduleIdx = CURRENT_MODULE_EDITED(menuVerticalPosition);
uint8_t receiverIdx = CURRENT_RECEIVER_EDITED(menuVerticalPosition);
if (result == STR_OPTIONS) {
memclear(&reusableBuffer.hardwareAndSettings, sizeof(reusableBuffer.hardwareAndSettings));
reusableBuffer.hardwareAndSettings.receiverSettings.receiverId = receiverIdx;
g_moduleIdx = moduleIdx;
pushMenu(menuModelReceiverOptions);
}
else if (result == STR_BIND) {
memclear(&reusableBuffer.moduleSetup.bindInformation, sizeof(BindInformation));
reusableBuffer.moduleSetup.bindInformation.rxUid = receiverIdx;
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].startBind(&reusableBuffer.moduleSetup.bindInformation);
}
s_editMode = 1;
}
else if (result == STR_SHARE) {
reusableBuffer.moduleSetup.pxx2.shareReceiverIndex = receiverIdx;
moduleState[moduleIdx].mode = MODULE_MODE_SHARE;
s_editMode = 1;
}
else if (result == STR_DELETE || result == STR_RESET) {
memclear(&reusableBuffer.moduleSetup.pxx2, sizeof(reusableBuffer.moduleSetup.pxx2));
reusableBuffer.moduleSetup.pxx2.resetReceiverIndex = receiverIdx;
reusableBuffer.moduleSetup.pxx2.resetReceiverFlags = (result == STR_RESET ? 0xFF : 0x01);
POPUP_CONFIRMATION(result == STR_RESET ? STR_RECEIVER_RESET : STR_RECEIVER_DELETE, onResetReceiverConfirm);
}
else {
removePXX2ReceiverIfEmpty(moduleIdx, receiverIdx);
}
}
void onBindMenu(const char * result)
{
uint8_t moduleIdx = (menuVerticalPosition >= ITEM_MODEL_EXTERNAL_MODULE_LABEL ? EXTERNAL_MODULE : INTERNAL_MODULE);
@ -495,7 +233,7 @@ int getSwitchWarningsCount()
#define IF_INTERNAL_MODULE_ON(x) (IS_INTERNAL_MODULE_ENABLED() ? (uint8_t)(x) : HIDDEN_ROW)
#define IF_EXTERNAL_MODULE_ON(x) (IS_EXTERNAL_MODULE_ENABLED() ? (uint8_t)(x) : HIDDEN_ROW)
#define INTERNAL_MODULE_MODE_ROWS isModulePXX2(INTERNAL_MODULE) ? (uint8_t)0 : (uint8_t)1
#define INTERNAL_MODULE_MODE_ROWS (uint8_t)0
#define PORT_CHANNELS_ROWS(x) (x==INTERNAL_MODULE ? INTERNAL_MODULE_CHANNELS_ROWS : (x==EXTERNAL_MODULE ? EXTERNAL_MODULE_CHANNELS_ROWS : 1))
#define TIMER_ROWS(x) NAVIGATION_LINE_BY_LINE|1, 0, 0, 0, g_model.timers[x].countdownBeep != COUNTDOWN_SILENT ? (uint8_t)1 : (uint8_t)0
@ -503,11 +241,11 @@ int getSwitchWarningsCount()
#define EXTERNAL_MODULE_MODE_ROWS (isModuleXJT(EXTERNAL_MODULE) || isModuleR9M(EXTERNAL_MODULE) || isModuleDSM2(EXTERNAL_MODULE) || isModuleMultimodule(EXTERNAL_MODULE)) ? (uint8_t)1 : (uint8_t)0
#if TIMERS == 1
#define TIMERS_ROWS TIMER_ROWS(0)
#define TIMERS_ROWS TIMER_ROWS(0)
#elif TIMERS == 2
#define TIMERS_ROWS TIMER_ROWS(0), TIMER_ROWS(1)
#define TIMERS_ROWS TIMER_ROWS(0), TIMER_ROWS(1)
#elif TIMERS == 3
#define TIMERS_ROWS TIMER_ROWS(0), TIMER_ROWS(1), TIMER_ROWS(2)
#define TIMERS_ROWS TIMER_ROWS(0), TIMER_ROWS(1), TIMER_ROWS(2)
#endif
#define SW_WARN_ITEMS() uint8_t(NAVIGATION_LINE_BY_LINE|(getSwitchWarningsCount()-1))
@ -519,9 +257,6 @@ int getSwitchWarningsCount()
#define TRAINER_LINE1_ROWS (g_model.trainerData.mode == TRAINER_MODE_SLAVE ? (uint8_t)1 : (g_model.trainerData.mode == TRAINER_MODE_MASTER_BLUETOOTH ? TRAINER_LINE1_BLUETOOTH_M_ROWS : (g_model.trainerData.mode == TRAINER_MODE_SLAVE_BLUETOOTH ? (uint8_t)1 : HIDDEN_ROW)))
#define TRAINER_LINE2_ROWS (g_model.trainerData.mode == TRAINER_MODE_SLAVE ? (uint8_t)2 : HIDDEN_ROW)
#define IF_PXX2_MODULE(module, xxx) (isModulePXX2(module) ? (uint8_t)(xxx) : HIDDEN_ROW)
#define IF_NOT_PXX2_MODULE(module, xxx) (isModulePXX2(module) ? HIDDEN_ROW : (uint8_t)(xxx))
bool menuModelSetup(event_t event)
{
bool CURSOR_ON_CELL = (menuHorizontalPosition >= 0);
@ -537,36 +272,21 @@ bool menuModelSetup(event_t event)
{ 0, 0, TIMERS_ROWS, 0, 1, 0, 0,
LABEL(Throttle), 0, 0, 0,
LABEL(PreflightCheck), 0, 0, SW_WARN_ITEMS(), POT_WARN_ROWS, (g_model.potsWarnMode ? POT_WARN_ITEMS() : HIDDEN_ROW), (g_model.potsWarnMode ? SLIDER_WARN_ITEMS() : HIDDEN_ROW), NAVIGATION_LINE_BY_LINE|(NUM_STICKS+NUM_POTS+NUM_SLIDERS-1), 0,
uint8_t((isDefaultModelRegistrationID() || (warningText && popupFunc == runPopupRegister)) ? HIDDEN_ROW : READONLY_ROW), // Registration ID
LABEL(InternalModule),
INTERNAL_MODULE_MODE_ROWS, // module mode (PXX(2) / None)
INTERNAL_MODULE_CHANNELS_ROWS, // Channels min and count
IF_NOT_PXX2_MODULE(INTERNAL_MODULE, IF_INTERNAL_MODULE_ON(HAS_RF_PROTOCOL_MODELINDEX(g_model.moduleData[INTERNAL_MODULE].rfProtocol) ? (uint8_t)2 : (uint8_t)1)), // RxNum + Bind
IF_PXX2_MODULE(INTERNAL_MODULE, 0), // RxNum
IF_INTERNAL_MODULE_ON(FAILSAFE_ROWS(INTERNAL_MODULE)), // Failsafe
IF_NOT_PXX2_MODULE(INTERNAL_MODULE, IF_INTERNAL_MODULE_ON(0)), // Antenna
IF_PXX2_MODULE(INTERNAL_MODULE, 1), // Range check and Register buttons
IF_PXX2_MODULE(INTERNAL_MODULE, 0), // Module options
IF_PXX2_MODULE(INTERNAL_MODULE, 0), // Receiver 1
IF_PXX2_MODULE(INTERNAL_MODULE, 0), // Receiver 2
IF_PXX2_MODULE(INTERNAL_MODULE, 0), // Receiver 3
INTERNAL_MODULE_MODE_ROWS,
INTERNAL_MODULE_CHANNELS_ROWS,
IF_INTERNAL_MODULE_ON(isModuleXJT(INTERNAL_MODULE) ? (HAS_RF_PROTOCOL_MODELINDEX(g_model.moduleData[INTERNAL_MODULE].rfProtocol) ? (uint8_t)2 : (uint8_t)1) : (isModulePPM(INTERNAL_MODULE) ? (uint8_t)1 : HIDDEN_ROW)),
IF_INTERNAL_MODULE_ON((isModuleXJT(INTERNAL_MODULE)) ? FAILSAFE_ROWS(INTERNAL_MODULE) : HIDDEN_ROW),
IF_INTERNAL_MODULE_ON(0),
LABEL(ExternalModule),
EXTERNAL_MODULE_MODE_ROWS, // module mode (PXX(2) / None)
EXTERNAL_MODULE_MODE_ROWS,
MULTIMODULE_STATUS_ROWS
EXTERNAL_MODULE_CHANNELS_ROWS, // Channels min and count
((isModuleXJT(EXTERNAL_MODULE) && !HAS_RF_PROTOCOL_MODELINDEX(g_model.moduleData[EXTERNAL_MODULE].rfProtocol)) || isModuleSBUS(EXTERNAL_MODULE)) ? (uint8_t)1 : (isModulePPM(EXTERNAL_MODULE) || isModulePXX(EXTERNAL_MODULE) || isModuleDSM2(EXTERNAL_MODULE) || isModuleMultimodule(EXTERNAL_MODULE)) ? (uint8_t)2 : HIDDEN_ROW, // RxNum + Bind
EXTERNAL_MODULE_CHANNELS_ROWS,
((isModuleXJT(EXTERNAL_MODULE) && !HAS_RF_PROTOCOL_MODELINDEX(g_model.moduleData[EXTERNAL_MODULE].rfProtocol)) || isModuleSBUS(EXTERNAL_MODULE)) ? (uint8_t)1 : (isModulePPM(EXTERNAL_MODULE) || isModulePXX(EXTERNAL_MODULE) || isModuleDSM2(EXTERNAL_MODULE) || isModuleMultimodule(EXTERNAL_MODULE)) ? (uint8_t)2 : HIDDEN_ROW,
FAILSAFE_ROWS(EXTERNAL_MODULE),
IF_PXX2_MODULE(EXTERNAL_MODULE, 1), // Range check and Register buttons
IF_PXX2_MODULE(EXTERNAL_MODULE, 0), // Module options
IF_PXX2_MODULE(EXTERNAL_MODULE, 0), // Receiver 1
IF_PXX2_MODULE(EXTERNAL_MODULE, 0), // Receiver 2
IF_PXX2_MODULE(EXTERNAL_MODULE, 0), // Receiver 3
EXTERNAL_MODULE_OPTION_ROW,
MULTIMODULE_MODULE_ROWS
EXTERNAL_MODULE_POWER_ROW,
LABEL(Trainer),
0,
TRAINER_LINE1_ROWS,
@ -927,166 +647,19 @@ bool menuModelSetup(event_t event)
case ITEM_MODEL_INTERNAL_MODULE_MODE:
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MODE);
lcdDrawTextAtIndex(MODEL_SETUP_2ND_COLUMN, y, STR_INTERNAL_MODULE_PROTOCOLS, g_model.moduleData[INTERNAL_MODULE].type, menuHorizontalPosition==0 ? attr : 0);
if (isModuleXJT(INTERNAL_MODULE))
lcdDrawTextAtIndex(MODEL_SETUP_3RD_COLUMN, y, STR_ACCST_RF_PROTOCOLS, 1+g_model.moduleData[INTERNAL_MODULE].rfProtocol, menuHorizontalPosition==1 ? attr : 0);
lcdDrawTextAtIndex(MODEL_SETUP_2ND_COLUMN, y, STR_ACCST_RF_PROTOCOLS, 1+g_model.moduleData[INTERNAL_MODULE].rfProtocol, attr);
if (attr) {
if (menuHorizontalPosition == 0) {
uint8_t moduleType = checkIncDec(event, g_model.moduleData[INTERNAL_MODULE].type, MODULE_TYPE_NONE, MODULE_TYPE_MAX, EE_MODEL, isInternalModuleAvailable);
if (checkIncDec_Ret) {
// TODO this code should be common, in module.h (X10_new_UI branch)
memclear(&g_model.moduleData[INTERNAL_MODULE], sizeof(ModuleData));
g_model.moduleData[INTERNAL_MODULE].type = moduleType;
g_model.moduleData[INTERNAL_MODULE].channelsCount = defaultModuleChannels_M8(INTERNAL_MODULE);
}
}
else if (isModuleXJT(INTERNAL_MODULE)) {
g_model.moduleData[INTERNAL_MODULE].rfProtocol = checkIncDec(event, g_model.moduleData[INTERNAL_MODULE].rfProtocol, MODULE_SUBTYPE_PXX1_ACCST_D16, MODULE_SUBTYPE_PXX1_LAST, EE_MODEL, isRfProtocolAvailable);
if (checkIncDec_Ret) {
g_model.moduleData[INTERNAL_MODULE].rfProtocol = checkIncDec(event, g_model.moduleData[INTERNAL_MODULE].rfProtocol, MODULE_SUBTYPE_PXX1_OFF, MODULE_SUBTYPE_PXX1_LAST, EE_MODEL, isRfProtocolAvailable);
if (checkIncDec_Ret) {
g_model.moduleData[0].type = MODULE_TYPE_XJT_PXX1;
g_model.moduleData[0].channelsStart = 0;
g_model.moduleData[0].channelsCount = defaultModuleChannels_M8(INTERNAL_MODULE);
}
g_model.moduleData[0].channelsStart = 0;
g_model.moduleData[0].channelsCount = defaultModuleChannels_M8(INTERNAL_MODULE);
if (g_model.moduleData[INTERNAL_MODULE].rfProtocol == MODULE_SUBTYPE_PXX1_OFF)
g_model.moduleData[INTERNAL_MODULE].type = MODULE_TYPE_NONE;
}
}
break;
case ITEM_MODEL_REGISTRATION_ID:
lcdDrawText(MENUS_MARGIN_LEFT,y, STR_REG_ID);
if (isDefaultModelRegistrationID())
lcdDrawText(MODEL_SETUP_2ND_COLUMN, y, STR_PXX2_DEFAULT);
else
lcdDrawSizedText(MODEL_SETUP_2ND_COLUMN, y, g_model.modelRegistrationID, PXX2_LEN_REGISTRATION_ID, ZCHAR);
break;
case ITEM_MODEL_INTERNAL_MODULE_PXX2_MODEL_NUM:
{
uint8_t moduleIdx = CURRENT_MODULE_EDITED(k);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_RECEIVER_NUM);
lcdDrawNumber(MODEL_SETUP_2ND_COLUMN, y, g_model.header.modelId[moduleIdx], attr | LEADING0 | LEFT, 2);
if (attr) {
CHECK_INCDEC_MODELVAR_ZERO(event, g_model.header.modelId[moduleIdx], MAX_RX_NUM(moduleIdx));
if (event == EVT_KEY_LONG(KEY_ENTER)) {
killEvents(event);
uint8_t newVal = modelslist.findNextUnusedModelId(moduleIdx);
if (newVal != g_model.header.modelId[moduleIdx]) {
g_model.header.modelId[moduleIdx] = newVal;
storageDirty(EE_MODEL);
}
}
}
}
break;
case ITEM_MODEL_INTERNAL_MODULE_PXX2_REGISTER_RANGE:
case ITEM_MODEL_EXTERNAL_MODULE_PXX2_REGISTER_RANGE:
{
uint8_t moduleIdx = CURRENT_MODULE_EDITED(k);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MODULE);
lcdDrawText(MODEL_SETUP_2ND_COLUMN, y, BUTTON(TR_REGISTER), (menuHorizontalPosition == 0 ? attr : 0));
lcdDrawText(lcdNextPos + 3, y, STR_MODULE_RANGE, (menuHorizontalPosition == 1 ? attr : 0));
if (attr) {
if (moduleState[moduleIdx].mode == MODULE_MODE_NORMAL && s_editMode > 0) {
if (menuHorizontalPosition == 0 && event == EVT_BUTTON_PRESSED()) {
startRegisterDialog(moduleIdx);
}
else if (menuHorizontalPosition == 1) {
moduleState[moduleIdx].mode = MODULE_MODE_RANGECHECK;
}
}
if (s_editMode == 0 && !warningText) {
moduleState[moduleIdx].mode = MODULE_MODE_NORMAL;
}
if (moduleState[moduleIdx].mode == MODULE_MODE_NORMAL) {
// REGISTER finished
s_editMode = 0;
}
}
}
break;
case ITEM_MODEL_INTERNAL_MODULE_PXX2_OPTIONS:
case ITEM_MODEL_EXTERNAL_MODULE_PXX2_OPTIONS:
lcdDrawText(INDENT_WIDTH, y, STR_OPTIONS);
lcdDrawText(MODEL_SETUP_2ND_COLUMN, y, STR_SET, attr);
if (event == EVT_KEY_BREAK(KEY_ENTER) && attr) {
g_moduleIdx = CURRENT_MODULE_EDITED(k);
memclear(&reusableBuffer.hardwareAndSettings, sizeof(reusableBuffer.hardwareAndSettings));
pushMenu(menuModelModuleOptions);
}
break;
case ITEM_MODEL_INTERNAL_MODULE_PXX2_RECEIVER_1:
case ITEM_MODEL_INTERNAL_MODULE_PXX2_RECEIVER_2:
case ITEM_MODEL_INTERNAL_MODULE_PXX2_RECEIVER_3:
case ITEM_MODEL_EXTERNAL_MODULE_PXX2_RECEIVER_1:
case ITEM_MODEL_EXTERNAL_MODULE_PXX2_RECEIVER_2:
case ITEM_MODEL_EXTERNAL_MODULE_PXX2_RECEIVER_3:
{
uint8_t moduleIdx = CURRENT_MODULE_EDITED(k);
uint8_t receiverIdx = CURRENT_RECEIVER_EDITED(k);
drawStringWithIndex(INDENT_WIDTH, y, STR_RECEIVER, receiverIdx + 1);
if (!(g_model.moduleData[moduleIdx].pxx2.receivers & (1 << receiverIdx))) {
lcdDrawText(MODEL_SETUP_2ND_COLUMN, y, STR_MODULE_BIND, attr);
if (attr && s_editMode > 0) {
s_editMode = 0;
killEvents(event);
g_model.moduleData[moduleIdx].pxx2.receivers |= (1 << receiverIdx);
memclear(g_model.moduleData[moduleIdx].pxx2.receiverName[receiverIdx], PXX2_LEN_RX_NAME);
storageDirty(EE_MODEL);
}
else {
break;
}
}
drawReceiverName(MODEL_SETUP_2ND_COLUMN, y, moduleIdx, receiverIdx, attr);
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].startBind(&reusableBuffer.moduleSetup.bindInformation);
}
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;
}
s_editMode = 0;
}
if (moduleState[moduleIdx].mode == MODULE_MODE_BIND) {
if (reusableBuffer.moduleSetup.bindInformation.step == BIND_INIT && reusableBuffer.moduleSetup.bindInformation.candidateReceiversCount > 0) {
popupMenuItemsCount = min<uint8_t>(reusableBuffer.moduleSetup.bindInformation.candidateReceiversCount, PXX2_MAX_RECEIVERS_PER_MODULE);
for (uint8_t i=0; i<popupMenuItemsCount; i++) {
popupMenuItems[i] = reusableBuffer.moduleSetup.bindInformation.candidateReceiversNames[i];
}
//popupMenuTitle = STR_PXX2_SELECT_RX; // TODO : fix
POPUP_MENU_START(onPXX2BindMenu);
}
}
if (attr && EVT_KEY_MASK(event) == KEY_ENTER) {
killEvents(event);
if (!isSimu() && isPXX2ReceiverEmpty(moduleIdx, receiverIdx)) {
onPXX2ReceiverMenu(STR_BIND);
}
else {
POPUP_MENU_ADD_ITEM(STR_BIND);
POPUP_MENU_ADD_ITEM(STR_OPTIONS);
POPUP_MENU_ADD_ITEM(STR_SHARE);
POPUP_MENU_ADD_ITEM(STR_DELETE);
POPUP_MENU_ADD_ITEM(STR_RESET);
}
POPUP_MENU_START(onPXX2ReceiverMenu);
}
}
break;
case ITEM_MODEL_INTERNAL_MODULE_ANTENNA:
{
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_ANTENNASELECTION);
@ -1125,7 +698,7 @@ bool menuModelSetup(event_t event)
else if (isModuleR9M(EXTERNAL_MODULE))
lcdDrawTextAtIndex(MODEL_SETUP_3RD_COLUMN, y, STR_R9M_REGION, g_model.moduleData[EXTERNAL_MODULE].subType, (menuHorizontalPosition==1 ? attr : 0));
#if defined(MULTIMODULE)
else if (isModuleMultimodule(EXTERNAL_MODULE)) {
else if (isModuleMultimodule(EXTERNAL_MODULE)) {
int multi_rfProto = g_model.moduleData[EXTERNAL_MODULE].getMultiProtocol(false);
if (g_model.moduleData[EXTERNAL_MODULE].multi.customProto) {
lcdDrawText(MODEL_SETUP_3RD_COLUMN, y, STR_MULTI_CUSTOM, menuHorizontalPosition == 1 ? attr : 0);
@ -1160,16 +733,16 @@ bool menuModelSetup(event_t event)
if (isModuleDSM2(EXTERNAL_MODULE))
CHECK_INCDEC_MODELVAR(event, g_model.moduleData[EXTERNAL_MODULE].rfProtocol, DSM2_PROTO_LP45, DSM2_PROTO_DSMX);
#if defined(MULTIMODULE)
else if (isModuleMultimodule(EXTERNAL_MODULE)) {
int multiRfProto = g_model.moduleData[EXTERNAL_MODULE].multi.customProto == 1 ? MODULE_SUBTYPE_MULTI_CUSTOM : g_model.moduleData[EXTERNAL_MODULE].getMultiProtocol(false);
CHECK_INCDEC_MODELVAR(event, multiRfProto, MODULE_SUBTYPE_MULTI_FIRST, MODULE_SUBTYPE_MULTI_LAST);
else if (isModuleMultimodule(EXTERNAL_MODULE)) {
int multiRfProto = g_model.moduleData[EXTERNAL_MODULE].multi.customProto == 1 ? MM_RF_PROTO_CUSTOM : g_model.moduleData[EXTERNAL_MODULE].getMultiProtocol(false);
CHECK_INCDEC_MODELVAR(event, multiRfProto, MM_RF_PROTO_FIRST, MM_RF_PROTO_LAST);
if (checkIncDec_Ret) {
g_model.moduleData[EXTERNAL_MODULE].multi.customProto = (multiRfProto == MODULE_SUBTYPE_MULTI_CUSTOM);
g_model.moduleData[EXTERNAL_MODULE].multi.customProto = (multiRfProto == MM_RF_PROTO_CUSTOM);
if (!g_model.moduleData[EXTERNAL_MODULE].multi.customProto)
g_model.moduleData[EXTERNAL_MODULE].setMultiProtocol(multiRfProto);
g_model.moduleData[EXTERNAL_MODULE].subType = 0;
// Sensible default for DSM2 (same as for ppm): 7ch@22ms + Autodetect settings enabled
if (g_model.moduleData[EXTERNAL_MODULE].getMultiProtocol(true) == MODULE_SUBTYPE_MULTI_DSM2) {
if (g_model.moduleData[EXTERNAL_MODULE].getMultiProtocol(true) == MM_RF_PROTO_DSM2) {
g_model.moduleData[EXTERNAL_MODULE].multi.autoBindMode = 1;
}
else {
@ -1286,7 +859,7 @@ bool menuModelSetup(event_t event)
CHECK_INCDEC_MODELVAR(event, moduleData.channelsCount, -4, min<int8_t>(maxModuleChannels_M8(moduleIdx), 32-8-moduleData.channelsStart));
if ((k == ITEM_MODEL_EXTERNAL_MODULE_CHANNELS && g_model.moduleData[EXTERNAL_MODULE].type == MODULE_TYPE_PPM)
|| (k == ITEM_MODEL_TRAINER_LINE1)
)
)
SET_DEFAULT_PPM_FRAME_LENGTH(moduleIdx);
break;
}
@ -1315,7 +888,7 @@ bool menuModelSetup(event_t event)
}
break;
case ITEM_MODEL_INTERNAL_MODULE_NPXX2_BIND:
case ITEM_MODEL_INTERNAL_MODULE_BIND:
case ITEM_MODEL_EXTERNAL_MODULE_BIND:
{
uint8_t moduleIdx = CURRENT_MODULE_EDITED(k);
@ -1402,7 +975,7 @@ bool menuModelSetup(event_t event)
POPUP_MENU_ADD_ITEM(STR_BINDING_1_8_TELEM_ON);
POPUP_MENU_ADD_ITEM(STR_BINDING_1_8_TELEM_OFF);
if (BIND_TELEM_ALLOWED(moduleIdx) && BIND_CH9TO16_ALLOWED(moduleIdx))
POPUP_MENU_ADD_ITEM(STR_BINDING_9_16_TELEM_ON);
POPUP_MENU_ADD_ITEM(STR_BINDING_9_16_TELEM_ON);
if (BIND_CH9TO16_ALLOWED(moduleIdx))
POPUP_MENU_ADD_ITEM(STR_BINDING_9_16_TELEM_OFF);
}
@ -1501,15 +1074,15 @@ bool menuModelSetup(event_t event)
if (pdef->optionsstr)
lcdDrawText(MENUS_MARGIN_LEFT, y, pdef->optionsstr);
if (multi_proto == MODULE_SUBTYPE_MULTI_FS_AFHDS2A)
if (multi_proto == MM_RF_PROTO_FS_AFHDS2A)
optionValue = 50 + 5 * optionValue;
lcdDrawNumber(MODEL_SETUP_2ND_COLUMN, y, optionValue, LEFT | attr);
if (attr) {
if (multi_proto == MODULE_SUBTYPE_MULTI_FS_AFHDS2A) {
if (multi_proto == MM_RF_PROTO_FS_AFHDS2A) {
CHECK_INCDEC_MODELVAR(event, g_model.moduleData[moduleIdx].multi.optionValue, 0, 70);
}
else if (multi_proto == MODULE_SUBTYPE_MULTI_OLRS) {
else if (multi_proto == MM_RF_PROTO_OLRS) {
CHECK_INCDEC_MODELVAR(event, g_model.moduleData[moduleIdx].multi.optionValue, -1, 7);
}
else {
@ -1523,7 +1096,7 @@ bool menuModelSetup(event_t event)
drawValueWithUnit(MODEL_SETUP_4TH_COLUMN, y, getBatteryVoltage(), UNIT_VOLTS, attr|PREC2|LEFT);
}
}
break;
break;
case ITEM_MODEL_EXTERNAL_MODULE_POWER:
{
@ -1555,11 +1128,11 @@ bool menuModelSetup(event_t event)
}
#endif
}
break;
break;
#if defined(MULTIMODULE)
case ITEM_MODEL_EXTERNAL_MODULE_AUTOBIND:
if (g_model.moduleData[EXTERNAL_MODULE].getMultiProtocol(true) == MODULE_SUBTYPE_MULTI_DSM2)
case ITEM_MODEL_EXTERNAL_MODULE_AUTOBIND:
if (g_model.moduleData[EXTERNAL_MODULE].getMultiProtocol(true) == MM_RF_PROTO_DSM2)
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MULTI_DSM_AUTODTECT);
else
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MULTI_AUTOBIND);
@ -1596,25 +1169,25 @@ bool menuModelSetup(event_t event)
if (mod_cell) {
switch(menuVerticalPosition) {
case ITEM_MODEL_NAME:
mod_cell->setModelName(g_model.header.name);
break;
case ITEM_MODEL_INTERNAL_MODULE_NPXX2_BIND:
if (menuHorizontalPosition != 0)
case ITEM_MODEL_NAME:
mod_cell->setModelName(g_model.header.name);
break;
case ITEM_MODEL_INTERNAL_MODULE_MODE:
mod_cell->setRfData(&g_model);
checkModelIdUnique(INTERNAL_MODULE);
break;
case ITEM_MODEL_EXTERNAL_MODULE_BIND:
if (menuHorizontalPosition != 0)
case ITEM_MODEL_INTERNAL_MODULE_BIND:
if (menuHorizontalPosition != 0)
break;
case ITEM_MODEL_INTERNAL_MODULE_MODE:
mod_cell->setRfData(&g_model);
checkModelIdUnique(INTERNAL_MODULE);
break;
case ITEM_MODEL_EXTERNAL_MODULE_MODE:
mod_cell->setRfData(&g_model);
if (g_model.moduleData[EXTERNAL_MODULE].type != MODULE_TYPE_NONE)
checkModelIdUnique(EXTERNAL_MODULE);
case ITEM_MODEL_EXTERNAL_MODULE_BIND:
if (menuHorizontalPosition != 0)
break;
case ITEM_MODEL_EXTERNAL_MODULE_MODE:
mod_cell->setRfData(&g_model);
if (g_model.moduleData[EXTERNAL_MODULE].type != MODULE_TYPE_NONE)
checkModelIdUnique(EXTERNAL_MODULE);
}
}
}

13
radio/src/gui/480x272/radio_setup.cpp
View file

@ -66,12 +66,11 @@ enum menuRadioSetupItems {
ITEM_SETUP_BRIGHTNESS,
ITEM_SETUP_DIM_LEVEL,
ITEM_SETUP_FLASH_BEEP,
ITEM_RADIO_OWNER_ID,
CASE_GPS(ITEM_SETUP_LABEL_GPS)
CASE_GPS(ITEM_SETUP_TIMEZONE)
CASE_GPS(ITEM_SETUP_ADJUST_RTC)
CASE_GPS(ITEM_SETUP_GPSFORMAT)
CASE_PXX(ITEM_SETUP_COUNTRYCODE)
CASE_PXX1(ITEM_SETUP_COUNTRYCODE)
ITEM_SETUP_LANGUAGE,
ITEM_SETUP_IMPERIAL,
IF_FAI_CHOICE(ITEM_SETUP_FAI)
@ -115,9 +114,8 @@ bool menuRadioSetup(event_t event)
CASE_HAPTIC(LABEL(HAPTIC)) CASE_HAPTIC(0) CASE_HAPTIC(0) CASE_HAPTIC(0)
LABEL(ALARMS), 0, 0, 0, 0,
LABEL(BACKLIGHT), 0, 0, 0, 0, 0,
0 /* owner registration ID */,
CASE_GPS(LABEL(GPS)) CASE_GPS(0) CASE_GPS(0) CASE_GPS(0)
CASE_PXX(0) 0, 0, FAI_CHOICE_ROW 0, 0, 0, 0, 1/*to force edit mode*/ }); // Country code - Voice Language - Units - Fai choice - Play delay - USB mode - Chan order - Mode (1 to 4)
CASE_PXX1(0) 0, 0, FAI_CHOICE_ROW 0, 0, 0, 0, 1/*to force edit mode*/ }); // Country code - Voice Language - Units - Fai choice - Play delay - USB mode - Chan order - Mode (1 to 4)
if (event == EVT_ENTRY) {
reusableBuffer.generalSettings.stickMode = g_eeGeneral.stickMode;
@ -366,11 +364,6 @@ bool menuRadioSetup(event_t event)
g_eeGeneral.alarmsFlash = editCheckBox(g_eeGeneral.alarmsFlash, RADIO_SETUP_2ND_COLUMN, y, attr, event ) ;
break;
case ITEM_RADIO_OWNER_ID:
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_OWNER_ID);
editName(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.ownerRegistrationID, PXX2_LEN_REGISTRATION_ID, event, attr);
break;
case ITEM_SETUP_BACKLIGHT_DELAY:
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BLDELAY);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.lightAutoOff*5, attr|LEFT, 0, NULL, "s");
@ -407,7 +400,7 @@ bool menuRadioSetup(event_t event)
g_eeGeneral.gpsFormat = editChoice(RADIO_SETUP_2ND_COLUMN, y, STR_GPSFORMAT, g_eeGeneral.gpsFormat, 0, 1, attr, event);
break;
#if defined(PXX)
#if defined(PXX1)
case ITEM_SETUP_COUNTRYCODE:
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_COUNTRYCODE);
g_eeGeneral.countryCode = editChoice(RADIO_SETUP_2ND_COLUMN, y, STR_COUNTRYCODES, g_eeGeneral.countryCode, 0, 2, attr, event);

105
radio/src/gui/480x272/radio_spectrum_analyser.cpp
View file

@ -1,105 +0,0 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "opentx.h"
extern uint8_t g_moduleIdx;
enum SpectrumFields {
SPECTRUM_FREQUENCY,
SPECTRUM_SPAN,
SPECTRUM_FIELDS_MAX
};
bool menuRadioSpectrumAnalyser(event_t event)
{
SIMPLE_SUBMENU(STR_MENU_SPECTRUM_ANALYSER, ICON_RADIO, 1);
if (TELEMETRY_STREAMING()) {
lcdDrawCenteredText(LCD_H/2, STR_TURN_OFF_RECEIVER );
if (event == EVT_KEY_FIRST(KEY_EXIT)) {
killEvents(event);
popMenu();
}
return true;
}
if (menuEvent) {
lcdDrawCenteredText(LCD_H/2, STR_STOPPING );
lcdRefresh();
moduleState[g_moduleIdx].mode = MODULE_MODE_NORMAL;
/* wait 1s to resume normal operation before leaving */
watchdogSuspend(1000);
RTOS_WAIT_MS(1000);
return true;
}
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;
moduleState[g_moduleIdx].mode = MODULE_MODE_SPECTRUM_ANALYSER;
}
for (uint8_t i=0; i<SPECTRUM_FIELDS_MAX; i++) {
LcdFlags attr = (menuHorizontalPosition == i ? (s_editMode>0 ? INVERS|BLINK : INVERS) : 0);
switch (i) {
case SPECTRUM_FREQUENCY: {
uint16_t frequency = reusableBuffer.spectrumAnalyser.freq / 1000000;
lcdDrawText(1, MENU_CONTENT_TOP + 10, "F:", 0);
lcdDrawNumber(lcdNextPos + 2, 10, frequency, attr);
lcdDrawText(lcdNextPos + 2, 10, "MHz", 0);
if (attr) {
reusableBuffer.spectrumAnalyser.freq = uint32_t(checkIncDec(event, frequency, 2400, 2485, 0)) * 1000000;
}
break;
}
case SPECTRUM_SPAN:
uint8_t span = reusableBuffer.spectrumAnalyser.span / 1000000;
lcdDrawText(lcdNextPos + 5, MENU_CONTENT_TOP + 10, "S:", 0);
lcdDrawNumber(lcdNextPos + 2, MENU_CONTENT_TOP + 10, reusableBuffer.spectrumAnalyser.span/1000000, attr);
lcdDrawText(lcdNextPos + 2, MENU_CONTENT_TOP + 10, "MHz", 0);
if (attr) {
reusableBuffer.spectrumAnalyser.span = checkIncDec(event, span, 1, 80, 0) * 1000000;
}
break;
}
}
uint8_t peak_y = 1;
uint8_t peak_x = 0;
for (coord_t i=0; i<LCD_W; i++) {
uint8_t h = min<uint8_t >(reusableBuffer.spectrumAnalyser.bars[i] >> 1, 128);
if (h > peak_y) {
peak_x = i;
peak_y = h;
}
lcdDrawSolidVerticalLine(i, LCD_H - h, h, TEXT_COLOR);
}
int8_t y = max<int8_t>(FH, LCD_H - peak_y - FH);
lcdDrawNumber(min<uint8_t>(100, peak_x), y, ((reusableBuffer.spectrumAnalyser.freq - reusableBuffer.spectrumAnalyser.span / 2) + peak_x * (reusableBuffer.spectrumAnalyser.span / 128)) / 1000000, TINSIZE);
lcdDrawText(lcdNextPos, y, "M", TINSIZE);
return true;
}

80
radio/src/gui/480x272/radio_tools.cpp
View file

@ -1,80 +0,0 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "opentx.h"
extern uint8_t g_moduleIdx;
void addRadioTool(uint8_t index, const char * label, bool (* tool)(event_t), uint8_t module)
{
int8_t sub = menuVerticalPosition;
LcdFlags attr = (sub == index ? INVERS : 0);
coord_t y = MENU_CONTENT_TOP + index * FH;
lcdDrawNumber(3, y, index + 1, LEADING0|LEFT, 2);
lcdDrawText(30, y, label, (sub == index ? INVERS : 0));
if (attr && s_editMode > 0) {
s_editMode = 0;
g_moduleIdx = module;
pushMenu(tool);
}
}
bool menuRadioTools(event_t event)
{
uint8_t spectrum_modules = 0, power_modules = 0;
if (event == EVT_ENTRY || event == EVT_ENTRY_UP) {
memclear(&reusableBuffer.hardwareAndSettings, sizeof(reusableBuffer.hardwareAndSettings));
for (uint8_t module = 0; module < NUM_MODULES; module++) {
if (isModulePXX2(module) && (module == INTERNAL_MODULE ? IS_INTERNAL_MODULE_ON() : IS_EXTERNAL_MODULE_ON())) {
moduleState[module].readModuleInformation(&reusableBuffer.hardwareAndSettings.modules[module], PXX2_HW_INFO_TX_ID, PXX2_HW_INFO_TX_ID);
}
}
}
for (uint8_t module = 0; module < NUM_MODULES; module++) {
if (isModuleOptionAvailable(reusableBuffer.hardwareAndSettings.modules[module].information.modelID, MODULE_OPTION_SPECTRUM_ANALYSER)) {
spectrum_modules++;
}
if (isModuleOptionAvailable(reusableBuffer.hardwareAndSettings.modules[module].information.modelID, MODULE_OPTION_POWER_METER)) {
power_modules++;
}
}
MENU(STR_MENUTOOLS, RADIO_ICONS, menuTabGeneral, MENU_RADIO_TOOLS, spectrum_modules + power_modules, {0,0,0,0});
uint8_t menu_index = 0;
if (isModuleOptionAvailable(reusableBuffer.hardwareAndSettings.modules[INTERNAL_MODULE].information.modelID, MODULE_OPTION_SPECTRUM_ANALYSER))
addRadioTool(menu_index++, STR_SPECTRUM_ANALYSER_INT, menuRadioSpectrumAnalyser, INTERNAL_MODULE);
if (isModuleOptionAvailable(reusableBuffer.hardwareAndSettings.modules[INTERNAL_MODULE].information.modelID, MODULE_OPTION_POWER_METER))
addRadioTool(menu_index++, STR_POWER_METER_INT, menuRadioPowerMeter, INTERNAL_MODULE);
if (isModuleOptionAvailable(reusableBuffer.hardwareAndSettings.modules[EXTERNAL_MODULE].information.modelID, MODULE_OPTION_SPECTRUM_ANALYSER))
addRadioTool(menu_index++, STR_SPECTRUM_ANALYSER_EXT, menuRadioSpectrumAnalyser, EXTERNAL_MODULE);
if (isModuleOptionAvailable(reusableBuffer.hardwareAndSettings.modules[EXTERNAL_MODULE].information.modelID, MODULE_OPTION_POWER_METER))
addRadioTool(menu_index++, STR_POWER_METER_EXT, menuRadioPowerMeter, EXTERNAL_MODULE);
return true;
}

10
radio/src/gui/CMakeLists.txt
View file

@ -11,8 +11,6 @@ set(GUI_SRC
model_setup.cpp
model_outputs.cpp
model_failsafe.cpp
model_module_options.cpp
model_receiver_options.cpp
model_logical_switches.cpp
model_special_functions.cpp
model_telemetry.cpp
@ -33,6 +31,14 @@ set(SRC
gui/navigation/common.cpp
)
if (PXX2)
set(GUI_SRC
${GUI_SRC}
model_module_options.cpp
model_receiver_options.cpp
)
endif()
string(TOUPPER ${NAVIGATION_TYPE} NAVIGATION_TYPE)
add_definitions(-DNAVIGATION_${NAVIGATION_TYPE})

6
radio/src/opentx.h
View file

@ -125,10 +125,10 @@
#define CASE_FRSKY(x)
#endif
#if defined(PXX)
#define CASE_PXX(x) x,
#if defined(PXX1)
#define CASE_PXX1(x) x,
#else
#define CASE_PXX(x)
#define CASE_PXX1(x)
#endif
#if defined(PXX2)