radio/src/gui/128x64/model_outputs.cpp

   1 /*
   2  * Copyright (C) OpenTX
   3  *
   4  * Based on code named
   5  *   th9x - http://code.google.com/p/th9x
   6  *   er9x - http://code.google.com/p/er9x
   7  *   gruvin9x - http://code.google.com/p/gruvin9x
   8  *
   9  * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #include "opentx.h"
  22
  23 enum MenuModelOutputsItems {
  24   ITEM_OUTPUTS_OFFSET,
  25   ITEM_OUTPUTS_MIN,
  26   ITEM_OUTPUTS_MAX,
  27   ITEM_OUTPUTS_DIRECTION,
  28   ITEM_OUTPUTS_CURVE,
  29 #if defined(PPM_LIMITS_SYMETRICAL)
  30   ITEM_OUTPUTS_SYMETRICAL,
  31 #endif
  32   ITEM_OUTPUTS_COUNT,
  33   ITEM_OUTPUTS_MAXROW = ITEM_OUTPUTS_COUNT-1
  34 };
  35
  36 #if defined(PPM_UNIT_US)
  37   #define LIMITS_MIN_POS          12*FW+1
  38   #define PREC_THRESHOLD          804
  39 #else
  40   #define LIMITS_MIN_POS          12*FW-2
  41   #define PREC_THRESHOLD          0
  42 #endif
  43
  44 #define LIMITS_OFFSET_POS         8*FW-1
  45
  46 #if defined(PPM_LIMITS_SYMETRICAL)
  47   #if defined(PPM_CENTER_ADJUSTABLE)
  48     #define LIMITS_MAX_POS        15*FW+3
  49     #define LIMITS_REVERT_POS     16*FW-1
  50     #define LIMITS_PPM_CENTER_POS 20*FW+1
  51   #else
  52     #define LIMITS_DIRECTION_POS  12*FW+4
  53     #define LIMITS_MAX_POS        16*FW+4
  54     #define LIMITS_REVERT_POS     17*FW
  55   #endif
  56 #else
  57   #if defined(PPM_CENTER_ADJUSTABLE)
  58     #define LIMITS_MAX_POS        16*FW
  59     #define LIMITS_REVERT_POS     17*FW-2
  60     #define LIMITS_PPM_CENTER_POS 21*FW+2
  61   #else
  62     #define LIMITS_MAX_POS        17*FW
  63     #define LIMITS_REVERT_POS     18*FW
  64     #define LIMITS_DIRECTION_POS  12*FW+5
  65   #endif
  66 #endif
  67
  68 #define LIMITS_CURVE_POS          17*FW+1
  69 #define LIMITS_MIN_MAX_OFFSET 1000
  70 #define CONVERT_US_MIN_MAX(x) ((int16_t(x)*128)/25)
  71 #define MIN_MAX_ATTR          attr
  72
  73 #if defined(PPM_UNIT_US)
  74   #define SET_MIN_MAX(x, val)   x = ((val)*250)/128
  75   #define MIN_MAX_DISPLAY(x)    CONVERT_US_MIN_MAX(x)
  76 #else
  77   #define MIN_MAX_DISPLAY(x)    (x)
  78   #define SET_MIN_MAX(x, val)   x = (val)
  79 #endif
  80
  81 enum MenuModelOutputsOneItems {
  82   ITEM_OUTPUTONE_CH_NAME,
  83   ITEM_OUTPUTONE_OFFSET,
  84   ITEM_OUTPUTONE_MIN,
  85   ITEM_OUTPUTONE_MAX,
  86   ITEM_OUTPUTONE_DIR,
  87   ITEM_OUTPUTONE_CURVE,
  88 #if defined(PPM_CENTER_ADJUSTABLE)
  89   ITEM_OUTPUTONE_PPM_CENTER,
  90 #endif
  91 #if defined(PPM_LIMITS_SYMETRICAL)
  92   ITEM_OUTPUTONE_SYMETRICAL,
  93 #endif
  94   ITEM_OUTPUTONE_MAXROW
  95 };
  96
  97 #define LIMITS_ONE_2ND_COLUMN (13*FW)
  98
  99 void menuModelLimitsOne(event_t event)
 100 {
 101   title(STR_MENULIMITS);
 102   LimitData * ld = limitAddress(s_currIdx);
 103
 104   putsChn(11*FW, 0, s_currIdx+1, 0);
 105   lcdDrawNumber(19*FW, 0, PPM_CH_CENTER(s_currIdx)+channelOutputs[s_currIdx]/2, RIGHT);
 106   lcdDrawText(19*FW, 0, STR_US);
 107
 108   SUBMENU_NOTITLE(ITEM_OUTPUTONE_MAXROW, { 0, 0, 0, 0, 0, 0 , 0  /*, 0...*/ });
 109
 110   int8_t sub = menuVerticalPosition;
 111
 112   for (uint8_t k=0; k<LCD_LINES-1; k++) {
 113     coord_t y = MENU_HEADER_HEIGHT + 1 + k*FH;
 114     uint8_t i = k + menuVerticalOffset;
 115     uint8_t attr = (sub==i ? (s_editMode>0 ? BLINK|INVERS : INVERS) : 0);
 116     uint8_t active = (attr && s_editMode > 0) ;
 117     int limit = (g_model.extendedLimits ? LIMIT_EXT_MAX : 1000);
 118
 119     switch (i) {
 120       case ITEM_OUTPUTONE_CH_NAME:
 121         editSingleName(LIMITS_ONE_2ND_COLUMN, y, STR_NAME, ld->name, sizeof(ld->name), event, attr);
 122         break;
 123
 124       case ITEM_OUTPUTONE_OFFSET:
 125         lcdDrawTextAlignedLeft(y, TR_LIMITS_HEADERS_SUBTRIM);
 126         ld->offset = GVAR_MENU_ITEM(LIMITS_ONE_2ND_COLUMN, y, ld->offset, -1000, 1000, PREC1 | attr, 0, event);
 127         break;
 128
 129       case ITEM_OUTPUTONE_MIN:
 130         lcdDrawTextAlignedLeft(y, STR_MIN);
 131         if (GV_IS_GV_VALUE(ld->min, -GV_RANGELARGE, GV_RANGELARGE) || (attr && event == EVT_KEY_LONG(KEY_ENTER))) {
 132            ld->min = GVAR_MENU_ITEM(LIMITS_ONE_2ND_COLUMN, y, ld->min, -LIMIT_EXT_MAX, LIMIT_EXT_MAX, attr|PREC1, 0, event);
 133            break;
 134         }
 135         lcdDrawNumber(LIMITS_ONE_2ND_COLUMN, y, MIN_MAX_DISPLAY(ld->min-LIMITS_MIN_MAX_OFFSET), attr|PREC1);
 136         if (active) {
 137           ld->min = LIMITS_MIN_MAX_OFFSET + checkIncDec(event, ld->min-LIMITS_MIN_MAX_OFFSET, -limit, 0, EE_MODEL, NULL, stops1000);
 138         }
 139         break;
 140
 141       case ITEM_OUTPUTONE_MAX:
 142         lcdDrawTextAlignedLeft(y, STR_MAX);
 143         if (GV_IS_GV_VALUE(ld->max, -GV_RANGELARGE, GV_RANGELARGE) || (attr && event == EVT_KEY_LONG(KEY_ENTER))) {
 144             ld->max = GVAR_MENU_ITEM(LIMITS_ONE_2ND_COLUMN, y, ld->max, -LIMIT_EXT_MAX, LIMIT_EXT_MAX, attr|PREC1, 0, event);
 145             break;
 146         }
 147         lcdDrawNumber(LIMITS_ONE_2ND_COLUMN, y, MIN_MAX_DISPLAY(ld->max+LIMITS_MIN_MAX_OFFSET), attr|PREC1);
 148         if (active) {
 149           ld->max = -LIMITS_MIN_MAX_OFFSET + checkIncDec(event, ld->max+LIMITS_MIN_MAX_OFFSET, 0, +limit, EE_MODEL, NULL, stops1000);
 150         }
 151         break;
 152
 153       case ITEM_OUTPUTONE_DIR:
 154       {
 155         lcdDrawTextAlignedLeft(y, TR_LIMITS_HEADERS_DIRECTION);
 156         lcdDrawTextAtIndex(LIMITS_ONE_2ND_COLUMN, y, STR_MMMINV, ld->revert, attr);
 157         if (active) {
 158           CHECK_INCDEC_MODELVAR_ZERO(event, ld->revert, 1);
 159         }
 160         break;
 161       }
 162
 163       case ITEM_OUTPUTONE_CURVE:
 164         lcdDrawTextAlignedLeft(y, STR_CURVE);
 165         drawCurveName(LIMITS_ONE_2ND_COLUMN, y, ld->curve, attr);
 166         if (active) {
 167           CHECK_INCDEC_MODELVAR(event, ld->curve, -MAX_CURVES, +MAX_CURVES);
 168         }
 169         break;
 170
 171 #if defined(PPM_CENTER_ADJUSTABLE)
 172       case ITEM_OUTPUTONE_PPM_CENTER:
 173         lcdDrawTextAlignedLeft(y, TR_LIMITS_HEADERS_PPMCENTER);
 174         lcdDrawNumber(LIMITS_ONE_2ND_COLUMN, y, PPM_CENTER+ld->ppmCenter, attr);
 175         if (active) {
 176           CHECK_INCDEC_MODELVAR(event, ld->ppmCenter, -PPM_CENTER_MAX, +PPM_CENTER_MAX);
 177         }
 178         break;
 179 #endif
 180
 181 #if defined(PPM_LIMITS_SYMETRICAL)
 182       case ITEM_OUTPUTONE_SYMETRICAL:
 183         lcdDrawTextAlignedLeft(y, TR_LIMITS_HEADERS_SUBTRIMMODE);
 184         lcdDrawChar(LIMITS_ONE_2ND_COLUMN, y, ld->symetrical ? '=' : '\306', attr);
 185         if (active) {
 186           CHECK_INCDEC_MODELVAR_ZERO(event, ld->symetrical, 1);
 187         }
 188         break;
 189 #endif
 190     }
 191   }
 192 }
 193
 194 void onLimitsMenu(const char *result)
 195 {
 196   s_currIdx = menuVerticalPosition - HEADER_LINE;
 197   if (result == STR_RESET) {
 198     LimitData *ld = limitAddress(s_currIdx);
 199     ld->min = 0;
 200     ld->max = 0;
 201     ld->offset = 0;
 202     ld->ppmCenter = 0;
 203     ld->revert = false;
 204     ld->curve = 0;
 205     storageDirty(EE_MODEL);
 206   }
 207   else if (result == STR_COPY_STICKS_TO_OFS) {
 208     copySticksToOffset(s_currIdx);
 209     storageDirty(EE_MODEL);
 210   }
 211   else if (result == STR_COPY_TRIMS_TO_OFS) {
 212     copyTrimsToOffset(s_currIdx);
 213     storageDirty(EE_MODEL);
 214   }
 215   else if (result == STR_EDIT) {
 216     pushMenu(menuModelLimitsOne);
 217   }
 218 }
 219
 220 void menuModelLimits(event_t event)
 221 {
 222   uint8_t sub = menuVerticalPosition - HEADER_LINE;
 223
 224   if (sub < MAX_OUTPUT_CHANNELS) {
 225     lcdDrawNumber(13*FW, 0, PPM_CH_CENTER(sub)+channelOutputs[sub]/2, RIGHT);
 226     lcdDrawText(13*FW, 0, STR_US);
 227   }
 228
 229   SIMPLE_MENU(STR_MENULIMITS, menuTabModel, MENU_MODEL_OUTPUTS, HEADER_LINE+MAX_OUTPUT_CHANNELS+1);
 230
 231   for (uint8_t i=0; i<LCD_LINES-1; i++) {
 232     coord_t y = MENU_HEADER_HEIGHT + 1 + i*FH;
 233     uint8_t k = i+menuVerticalOffset;
 234     LcdFlags attr = (sub==MAX_OUTPUT_CHANNELS) ? INVERS : 0;
 235
 236     if (sub==k && event==EVT_KEY_FIRST(KEY_ENTER) && !READ_ONLY() && (k != MAX_OUTPUT_CHANNELS) ) {
 237       killEvents(event);
 238       s_editMode = 0;
 239       POPUP_MENU_ADD_ITEM(STR_EDIT);
 240       POPUP_MENU_ADD_ITEM(STR_RESET);
 241       POPUP_MENU_ADD_ITEM(STR_COPY_TRIMS_TO_OFS);
 242       POPUP_MENU_ADD_ITEM(STR_COPY_STICKS_TO_OFS);
 243       POPUP_MENU_START(onLimitsMenu);
 244     }
 245
 246     if (k == MAX_OUTPUT_CHANNELS) {
 247       // last line available - add the "copy trim menu" line
 248       lcdDrawText(CENTER_OFS, y, STR_TRIMS2OFFSETS, NO_HIGHLIGHT() ? 0 : attr);
 249       if (attr) {
 250         s_editMode = 0;
 251         if (event == EVT_KEY_LONG(KEY_ENTER)) {
 252           START_NO_HIGHLIGHT();
 253           killEvents(event);
 254           moveTrimsToOffsets(); // if highlighted and menu pressed - move trims to offsets
 255         }
 256       }
 257       return;
 258     }
 259
 260     LimitData * ld = limitAddress(k);
 261
 262     if (ld->name[0] == 0) {
 263       putsChn(0, y, k+1, (sub==k) ? INVERS : 0);
 264     }
 265     else {
 266       lcdDrawSizedText(0, y, ld->name, sizeof(ld->name), ((sub==k) ? INVERS : 0) | ZCHAR | LEFT);
 267     }
 268
 269     for (uint8_t j=0; j<ITEM_OUTPUTS_COUNT; j++) {
 270       switch (j) {
 271         case ITEM_OUTPUTS_OFFSET:
 272 #if defined(PPM_UNIT_US)
 273           lcdDrawNumber(LIMITS_OFFSET_POS, y, ((int32_t)ld->offset*128) / 25, PREC1|RIGHT);
 274 #else
 275 #if defined(GVARS)
 276           if (GV_IS_GV_VALUE(ld->offset, -GV_RANGELARGE, GV_RANGELARGE)) {
 277             drawGVarName(LIMITS_OFFSET_POS, y, ld->offset, attr|PREC1|RIGHT);
 278             break;
 279           }
 280 #endif
 281           if (abs(ld->offset) >= 1000) {
 282             lcdDrawNumber(LIMITS_OFFSET_POS, y, ld->offset/10, RIGHT);
 283           }
 284           else {
 285             lcdDrawNumber(LIMITS_OFFSET_POS, y, ld->offset, PREC1|RIGHT);
 286           }
 287 #endif
 288           break;
 289
 290         case ITEM_OUTPUTS_MIN:
 291 #if defined(GVARS)
 292           if (GV_IS_GV_VALUE(ld->min, -GV_RANGELARGE, GV_RANGELARGE)) {
 293             drawGVarName(LIMITS_MIN_POS, y, ld->min, attr|PREC1|RIGHT);
 294             break;
 295           }
 296 #endif
 297           if (ld->min <= PREC_THRESHOLD) {
 298             lcdDrawNumber(LIMITS_MIN_POS, y, MIN_MAX_DISPLAY(ld->min-LIMITS_MIN_MAX_OFFSET)/10, RIGHT);
 299           }
 300           else {
 301             lcdDrawNumber(LIMITS_MIN_POS, y, MIN_MAX_DISPLAY(ld->min-LIMITS_MIN_MAX_OFFSET), attr|PREC1|RIGHT);
 302           }
 303           break;
 304
 305         case ITEM_OUTPUTS_MAX:
 306 #if defined(GVARS)
 307           if (GV_IS_GV_VALUE(ld->max, -GV_RANGELARGE, GV_RANGELARGE)) {
 308             drawGVarName(LIMITS_MAX_POS, y, ld->max, attr|PREC1|RIGHT);
 309             break;
 310           }
 311 #endif
 312           if (ld->max >= -PREC_THRESHOLD) {
 313             lcdDrawNumber(LIMITS_MAX_POS, y, MIN_MAX_DISPLAY(ld->max+LIMITS_MIN_MAX_OFFSET)/10, RIGHT);
 314           }
 315           else {
 316             lcdDrawNumber(LIMITS_MAX_POS, y, MIN_MAX_DISPLAY(ld->max+LIMITS_MIN_MAX_OFFSET), attr|PREC1|RIGHT);
 317           }
 318           break;
 319
 320         case ITEM_OUTPUTS_DIRECTION:
 321           lcdDrawChar(LIMITS_REVERT_POS, y, ld->revert ? 127 : 126, 0);
 322           break;
 323
 324         case ITEM_OUTPUTS_CURVE:
 325           drawCurveName(LIMITS_CURVE_POS, y, ld->curve, 0);
 326           break;
 327
 328         case ITEM_OUTPUTS_SYMETRICAL:
 329           lcdDrawChar(LCD_W-FW, y, ld->symetrical ? '=' : '\306', 0);
 330           break;
 331       }
 332     }
 333   }
 334 }