204 lines
6.2 KiB
C++
204 lines
6.2 KiB
C++
/*
|
|
* Copyright (C) EdgeTX
|
|
*
|
|
* Based on code named
|
|
* opentx - https://github.com/opentx/opentx
|
|
* 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"
|
|
|
|
#if defined(GVARS_IN_CURVES_SCREEN)
|
|
#warning "define still not added to CMakeLists.txt"
|
|
#define CURVE_SELECTED() (sub >= 0 && sub < MAX_CURVES)
|
|
#define GVAR_SELECTED() (sub >= MAX_CURVES)
|
|
#else
|
|
#define CURVE_SELECTED() (sub >= 0)
|
|
#endif
|
|
|
|
void drawCurve(coord_t offset)
|
|
{
|
|
drawFunction(applyCurrentCurve, offset);
|
|
|
|
CurveHeader & crv = g_model.curves[s_currIdxSubMenu];
|
|
for (uint8_t i = 0; i < crv.points + 5; i++) {
|
|
point_t point = getPoint(i);
|
|
lcdDrawFilledRect(point.x - 1 - offset, point.y - 1, 3, 3, SOLID, FORCE); // do markup square
|
|
}
|
|
}
|
|
|
|
void menuModelCurvesAll(event_t event)
|
|
{
|
|
uint8_t old_editMode = s_editMode;
|
|
|
|
#if defined(GVARS_IN_CURVES_SCREEN)
|
|
SIMPLE_MENU(STR_MENUCURVES, menuTabModel, MENU_MODEL_CURVES, HEADER_LINE+MAX_CURVES+MAX_GVARS);
|
|
#else
|
|
SIMPLE_MENU(STR_MENUCURVES, menuTabModel, MENU_MODEL_CURVES, HEADER_LINE+MAX_CURVES);
|
|
#endif
|
|
|
|
int8_t sub = menuVerticalPosition - HEADER_LINE;
|
|
|
|
switch (event) {
|
|
#if defined(ROTARY_ENCODER_NAVIGATION)
|
|
case EVT_ROTARY_BREAK:
|
|
#endif
|
|
#if !defined(PCBTARANIS)
|
|
case EVT_KEY_FIRST(KEY_RIGHT):
|
|
#endif
|
|
case EVT_KEY_FIRST(KEY_ENTER):
|
|
if (CURVE_SELECTED() && !READ_ONLY()) {
|
|
s_currIdxSubMenu = sub;
|
|
s_currSrcRaw = MIXSRC_NONE;
|
|
pushMenu(menuModelCurveOne);
|
|
}
|
|
break;
|
|
}
|
|
|
|
for (uint8_t i=0; i<LCD_LINES-1; i++) {
|
|
coord_t y = MENU_HEADER_HEIGHT + 1 + i*FH;
|
|
uint8_t k = i + menuVerticalOffset;
|
|
LcdFlags attr = (sub == k ? INVERS : 0);
|
|
#if defined(GVARS_IN_CURVES_SCREEN)
|
|
if (k >= MAX_CURVES) {
|
|
drawStringWithIndex(0, y, STR_GV, k-MAX_CURVES+1);
|
|
if (GVAR_SELECTED()) {
|
|
if (attr && s_editMode>0) attr |= BLINK;
|
|
lcdDrawNumber(10*FW, y, GVAR_VALUE(k-MAX_CURVES, -1), attr);
|
|
if (attr) g_model.gvars[k-MAX_CURVES] = checkIncDec(event, g_model.gvars[k-MAX_CURVES], -1000, 1000, EE_MODEL);
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
drawStringWithIndex(0, y, STR_CV, k+1, attr);
|
|
CurveHeader & crv = g_model.curves[k];
|
|
editName(4*FW, y, crv.name, sizeof(crv.name), 0, 0, 0, old_editMode);
|
|
#if LCD_W >= 212
|
|
lcdDrawNumber(11*FW, y, 5+crv.points, LEFT);
|
|
lcdDrawText(lcdLastRightPos, y, STR_PTS, 0);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (CURVE_SELECTED()) {
|
|
s_currIdxSubMenu = sub;
|
|
#if LCD_W >= 212
|
|
drawCurve(23);
|
|
#else
|
|
drawCurve(10);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static const char* _curve_types[] = {"Diff","Expo","Func","Cstm"};
|
|
|
|
void editCurveRef(coord_t x, coord_t y, CurveRef & curve, event_t event, LcdFlags flags)
|
|
{
|
|
coord_t x1 = x;
|
|
LcdFlags flags1 = flags;
|
|
if (flags & RIGHT) {
|
|
x1 -= 9*FW;
|
|
flags1 -= RIGHT;
|
|
}
|
|
else {
|
|
x += 5*FW;
|
|
}
|
|
|
|
uint8_t active = (flags & INVERS);
|
|
|
|
if (menuHorizontalPosition == 0) {
|
|
flags = flags & RIGHT;
|
|
}
|
|
else {
|
|
flags1 = 0;
|
|
}
|
|
|
|
lcdDrawTextAtIndex(x1, y, _curve_types, curve.type, flags1);
|
|
|
|
if (active && menuHorizontalPosition==0) {
|
|
CHECK_INCDEC_MODELVAR_ZERO(event, curve.type, CURVE_REF_CUSTOM);
|
|
if (checkIncDec_Ret) curve.value = 0;
|
|
}
|
|
switch (curve.type) {
|
|
case CURVE_REF_DIFF:
|
|
case CURVE_REF_EXPO:
|
|
curve.value = GVAR_MENU_ITEM(x, y, curve.value, -100, 100, LEFT | flags, 0, event);
|
|
break;
|
|
case CURVE_REF_FUNC:
|
|
lcdDrawTextAtIndex(x, y, STR_VCURVEFUNC, curve.value, flags);
|
|
if (active && menuHorizontalPosition==1) CHECK_INCDEC_MODELVAR_ZERO(event, curve.value, CURVE_BASE-1);
|
|
break;
|
|
case CURVE_REF_CUSTOM:
|
|
drawCurveName(x, y, curve.value, flags);
|
|
if (active && menuHorizontalPosition == 1) {
|
|
if (event == EVT_KEY_LONG(KEY_ENTER) && curve.value != 0) {
|
|
s_currIdxSubMenu = abs(curve.value) - 1;
|
|
pushMenu(menuModelCurveOne);
|
|
}
|
|
else {
|
|
CHECK_INCDEC_MODELVAR(event, curve.value, -MAX_CURVES, MAX_CURVES);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void drawFunction(FnFuncP fn, uint8_t offset)
|
|
{
|
|
lcdDrawVerticalLine(CURVE_CENTER_X - offset, CURVE_CENTER_Y-CURVE_SIDE_WIDTH, CURVE_SIDE_WIDTH * 2, 0xee);
|
|
lcdDrawHorizontalLine(CURVE_CENTER_X - CURVE_SIDE_WIDTH - offset, CURVE_CENTER_Y, CURVE_SIDE_WIDTH * 2, 0xee);
|
|
|
|
coord_t prev_yv = (coord_t) - 1;
|
|
|
|
for (int xv = -CURVE_SIDE_WIDTH; xv <= CURVE_SIDE_WIDTH; xv++) {
|
|
coord_t yv = (LCD_H - 1) - (((uint16_t)RESX + fn(xv * (RESX/CURVE_SIDE_WIDTH))) / 2 * (LCD_H - 1) / RESX);
|
|
if (prev_yv != (coord_t) - 1) {
|
|
if (abs((int8_t)yv-prev_yv) <= 1) {
|
|
lcdDrawPoint(CURVE_CENTER_X + xv - offset - 1, prev_yv, FORCE);
|
|
}
|
|
else {
|
|
uint8_t tmp = (prev_yv < yv ? 0 : 1);
|
|
lcdDrawSolidVerticalLine(CURVE_CENTER_X + xv - offset - 1, yv + tmp, prev_yv - yv);
|
|
}
|
|
}
|
|
prev_yv = yv;
|
|
}
|
|
}
|
|
|
|
void drawCursor(FnFuncP fn, uint8_t offset)
|
|
{
|
|
int x512 = getValue(s_currSrcRaw);
|
|
if (s_currSrcRaw >= MIXSRC_FIRST_TELEM) {
|
|
if (s_currScale > 0)
|
|
x512 = (x512 * 1024) / convertTelemValue(s_currSrcRaw - MIXSRC_FIRST_TELEM + 1, s_currScale);
|
|
drawSensorCustomValue(LCD_W - FW - offset, 6 * FH, (s_currSrcRaw - MIXSRC_FIRST_TELEM) / 3, x512, 0);
|
|
}
|
|
else {
|
|
lcdDrawNumber(LCD_W - FW - offset, 6*FH, calcRESXto1000(x512), RIGHT | PREC1);
|
|
}
|
|
x512 = limit(-1024, x512, 1024);
|
|
int y512 = fn(x512);
|
|
y512 = limit(-1024, y512, 1024);
|
|
lcdDrawNumber(CURVE_CENTER_X - FWNUM - offset, 1*FH, calcRESXto1000(y512), RIGHT | PREC1);
|
|
|
|
x512 = CURVE_CENTER_X + x512/(RESX / CURVE_SIDE_WIDTH);
|
|
y512 = (LCD_H - 1) - ((y512 + RESX) / 2) * (LCD_H - 1) / RESX;
|
|
|
|
lcdDrawSolidVerticalLine(x512 - offset, y512-3, 3 * 2 + 1);
|
|
lcdDrawSolidHorizontalLine(x512 - 3 - offset, y512, 3 * 2 + 1);
|
|
}
|