sv/IronOS
1
0
Fork 0
forked from me/IronOS
Code Pull Requests Activity

Pass one settings refactor

Browse Source
This commit is contained in:
Ben V. Brown
2021-09-12 13:31:03 +10:00
parent fc47c71ec3
commit eb2a748e3f
10 changed files with 452 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files

398
source/Core/Src/gui.cpp
View File

@@ -311,18 +311,13 @@ static int userConfirmation(const char *message) {
return 0;
}
#ifdef POW_DC
static bool settings_setInputVRange(void) {
systemSettings.minDCVoltageCells = (systemSettings.minDCVoltageCells + 1) % 5;
if (systemSettings.minDCVoltageCells == 1 && systemSettings.minVoltageCells < 30)
systemSettings.minVoltageCells = 30;
return systemSettings.minDCVoltageCells == 4;
}
static bool settings_setInputVRange(void) { return nextSettingValue(SettingsOptions::MinDCVoltageCells); }
static bool settings_displayInputVRange(void) {
printShortDescription(SettingsItemIndex::DCInCutoff, 6);
if (systemSettings.minDCVoltageCells) {
OLED::printNumber(2 + systemSettings.minDCVoltageCells, 1, FontStyle::LARGE);
if (getSettingValue(SettingsOptions::MinDCVoltageCells)) {
OLED::printNumber(2 + getSettingValue(SettingsOptions::MinDCVoltageCells), 1, FontStyle::LARGE);
OLED::print(SymbolCellCount, FontStyle::LARGE);
} else {
OLED::print(SymbolDC, FontStyle::LARGE);
@@ -330,21 +325,14 @@ static bool settings_displayInputVRange(void) {
return false;
}
static bool settings_setInputMinVRange(void) {
systemSettings.minVoltageCells = (systemSettings.minVoltageCells + 1) % 38;
if (systemSettings.minDCVoltageCells == 1 && systemSettings.minVoltageCells < 30)
systemSettings.minVoltageCells = 30;
else if (systemSettings.minVoltageCells < 24)
systemSettings.minVoltageCells = 24;
return systemSettings.minVoltageCells == 37;
}
static bool settings_setInputMinVRange(void) { return nextSettingValue(SettingsOptions::MinVoltageCells); }
static bool settings_displayInputMinVRange(void) {
if (systemSettings.minDCVoltageCells) {
if (getSettingValue(SettingsOptions::MinDCVoltageCells)) {
printShortDescription(SettingsItemIndex::MinVolCell, 4);
OLED::printNumber(systemSettings.minVoltageCells / 10, 2, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::MinVoltageCells) / 10, 2, FontStyle::LARGE);
OLED::print(SymbolDot, FontStyle::LARGE);
OLED::printNumber(systemSettings.minVoltageCells % 10, 1, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::MinVoltageCells) % 10, 1, FontStyle::LARGE);
} else {
printShortDescription(SettingsItemIndex::MinVolCell, 5);
OLED::print(translatedString(Tr->SettingNAChar), FontStyle::LARGE);
@@ -368,7 +356,7 @@ static bool settings_displayQCInputV(void) {
printShortDescription(SettingsItemIndex::QCMaxVoltage, 5);
// 0 = 9V, 1=12V, 2=20V (Fixed Voltages)
// These are only used in QC modes
switch (systemSettings.QCIdealVoltage) {
switch (getSettingValue(SettingsOptions::QCIdealVoltage)) {
case 0:
OLED::printNumber(9, 2, FontStyle::LARGE);
OLED::print(SymbolVolts, FontStyle::LARGE);
@@ -390,192 +378,159 @@ static bool settings_displayQCInputV(void) {
#endif
#ifdef POW_PD
static bool settings_setPDNegTimeout(void) {
systemSettings.PDNegTimeout = (systemSettings.PDNegTimeout + 1) % 50;
return systemSettings.PDNegTimeout == 49;
}
static bool settings_setPDNegTimeout(void) { return nextSettingValue(SettingsOptions::PDNegTimeout); }
static bool settings_displayPDNegTimeout(void) {
printShortDescription(SettingsItemIndex::PDNegTimeout, 5);
OLED::printNumber(systemSettings.PDNegTimeout, 2, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::PDNegTimeout), 2, FontStyle::LARGE);
return systemSettings.PDNegTimeout == 49;
return false;
}
#endif
#ifndef NO_SLEEP_MODE
static bool settings_setSleepTemp(void) {
// If in C, 10 deg, if in F 20 deg
if (systemSettings.temperatureInF) {
systemSettings.SleepTemp += 20;
if (systemSettings.SleepTemp > 580)
systemSettings.SleepTemp = 60;
return systemSettings.SleepTemp == 580;
uint16_t temp = getSettingValue(SettingsOptions::SleepTemp);
if (getSettingValue(SettingsOptions::TemperatureInF)) {
temp += 20;
if (temp > 580)
temp = 60;
setSettingValue(SettingsOptions::SleepTemp, temp);
return temp == 580;
} else {
systemSettings.SleepTemp += 10;
if (systemSettings.SleepTemp > 300)
systemSettings.SleepTemp = 10;
return systemSettings.SleepTemp == 300;
temp += 10;
if (temp > 300)
temp = 10;
setSettingValue(SettingsOptions::SleepTemp, temp);
return temp == 300;
}
}
static bool settings_displaySleepTemp(void) {
printShortDescription(SettingsItemIndex::SleepTemperature, 5);
OLED::printNumber(systemSettings.SleepTemp, 3, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::SleepTemp), 3, FontStyle::LARGE);
return false;
}
static bool settings_setSleepTime(void) {
systemSettings.SleepTime++; // Go up 1 minute at a time
if (systemSettings.SleepTime >= 16) {
systemSettings.SleepTime = 0; // can't set time over 10 mins
}
// Remember that ^ is the time of no movement
if (DetectedAccelerometerVersion == NO_DETECTED_ACCELEROMETER)
systemSettings.SleepTime = 0; // Disable sleep on no accel
return systemSettings.SleepTime == 15;
}
static bool settings_setSleepTime(void) { return nextSettingValue(SettingsOptions::SleepTime); }
static bool settings_displaySleepTime(void) {
printShortDescription(SettingsItemIndex::SleepTimeout, 5);
if (systemSettings.SleepTime == 0) {
if (getSettingValue(SettingsOptions::SleepTime) == 0) {
OLED::print(translatedString(Tr->OffString), FontStyle::LARGE);
} else if (systemSettings.SleepTime < 6) {
OLED::printNumber(systemSettings.SleepTime * 10, 2, FontStyle::LARGE);
} else if (getSettingValue(SettingsOptions::SleepTime) < 6) {
OLED::printNumber(getSettingValue(SettingsOptions::SleepTime) * 10, 2, FontStyle::LARGE);
OLED::print(SymbolSeconds, FontStyle::LARGE);
} else {
OLED::printNumber(systemSettings.SleepTime - 5, 2, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::SleepTime) - 5, 2, FontStyle::LARGE);
OLED::print(SymbolMinutes, FontStyle::LARGE);
}
return false;
}
#endif
static bool settings_setShutdownTime(void) {
systemSettings.ShutdownTime++;
if (systemSettings.ShutdownTime > 60) {
systemSettings.ShutdownTime = 0; // wrap to off
}
if (DetectedAccelerometerVersion == NO_DETECTED_ACCELEROMETER)
systemSettings.ShutdownTime = 0; // Disable shutdown on no accel
return systemSettings.ShutdownTime == 60;
}
static bool settings_setShutdownTime(void) { return nextSettingValue(SettingsOptions::ShutdownTime); }
static bool settings_displayShutdownTime(void) {
printShortDescription(SettingsItemIndex::ShutdownTimeout, 5);
if (systemSettings.ShutdownTime == 0) {
if (getSettingValue(SettingsOptions::ShutdownTime) == 0) {
OLED::print(translatedString(Tr->OffString), FontStyle::LARGE);
} else {
OLED::printNumber(systemSettings.ShutdownTime, 2, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::ShutdownTime), 2, FontStyle::LARGE);
OLED::print(SymbolMinutes, FontStyle::LARGE);
}
return false;
}
static bool settings_setTempF(void) {
systemSettings.temperatureInF = !systemSettings.temperatureInF;
if (systemSettings.temperatureInF) {
nextSettingValue(SettingsOptions::SleepTime);
uint16_t BoostTemp = getSettingValue(SettingsOptions::BoostTemp);
uint16_t SolderingTemp = getSettingValue(SettingsOptions::SolderingTemp);
uint16_t SleepTemp = getSettingValue(SettingsOptions::SleepTemp);
if (getSettingValue(SettingsOptions::TemperatureInF)) {
// Change sleep, boost and soldering temps to the F equiv
// C to F == F= ( (C*9) +160)/5
systemSettings.BoostTemp = ((systemSettings.BoostTemp * 9) + 160) / 5;
systemSettings.SolderingTemp = ((systemSettings.SolderingTemp * 9) + 160) / 5;
systemSettings.SleepTemp = ((systemSettings.SleepTemp * 9) + 160) / 5;
BoostTemp = ((BoostTemp * 9) + 160) / 5;
SolderingTemp = ((SolderingTemp * 9) + 160) / 5;
SleepTemp = ((SleepTemp * 9) + 160) / 5;
} else {
// Change sleep, boost and soldering temps to the C equiv
// F->C == C = ((F-32)*5)/9
systemSettings.BoostTemp = ((systemSettings.BoostTemp - 32) * 5) / 9;
systemSettings.SolderingTemp = ((systemSettings.SolderingTemp - 32) * 5) / 9;
systemSettings.SleepTemp = ((systemSettings.SleepTemp - 32) * 5) / 9;
BoostTemp = ((BoostTemp - 32) * 5) / 9;
SolderingTemp = ((SolderingTemp - 32) * 5) / 9;
SleepTemp = ((SleepTemp - 32) * 5) / 9;
}
// Rescale both to be multiples of 10
systemSettings.BoostTemp = systemSettings.BoostTemp / 10;
systemSettings.BoostTemp *= 10;
systemSettings.SolderingTemp = systemSettings.SolderingTemp / 10;
systemSettings.SolderingTemp *= 10;
systemSettings.SleepTemp = systemSettings.SleepTemp / 10;
systemSettings.SleepTemp *= 10;
BoostTemp = BoostTemp / 10;
BoostTemp *= 10;
SolderingTemp = SolderingTemp / 10;
SolderingTemp *= 10;
SleepTemp = SleepTemp / 10;
SleepTemp *= 10;
setSettingValue(SettingsOptions::BoostTemp, BoostTemp);
setSettingValue(SettingsOptions::SolderingTemp, SolderingTemp);
setSettingValue(SettingsOptions::SleepTemp, SleepTemp);
return false;
}
static bool settings_displayTempF(void) {
printShortDescription(SettingsItemIndex::TemperatureUnit, 7);
OLED::print((systemSettings.temperatureInF) ? SymbolDegF : SymbolDegC, FontStyle::LARGE);
OLED::print((getSettingValue(SettingsOptions::TemperatureInF)) ? SymbolDegF : SymbolDegC, FontStyle::LARGE);
return false;
}
static bool settings_setSensitivity(void) {
systemSettings.sensitivity++;
systemSettings.sensitivity = systemSettings.sensitivity % 10;
return systemSettings.sensitivity == 9;
}
static bool settings_setSensitivity(void) { return nextSettingValue(SettingsOptions::Sensitivity); }
static bool settings_displaySensitivity(void) {
printShortDescription(SettingsItemIndex::MotionSensitivity, 7);
OLED::printNumber(systemSettings.sensitivity, 1, FontStyle::LARGE, false);
OLED::printNumber(getSettingValue(SettingsOptions::Sensitivity), 1, FontStyle::LARGE, false);
return false;
}
static bool settings_setAdvancedSolderingScreens(void) {
systemSettings.detailedSoldering = !systemSettings.detailedSoldering;
return false;
}
static bool settings_setAdvancedSolderingScreens(void) { return nextSettingValue(SettingsOptions::DetailedSoldering); }
static bool settings_displayAdvancedSolderingScreens(void) {
printShortDescription(SettingsItemIndex::AdvancedSoldering, 7);
OLED::drawCheckbox(systemSettings.detailedSoldering);
OLED::drawCheckbox(getSettingValue(SettingsOptions::DetailedSoldering));
return false;
}
static bool settings_setAdvancedIDLEScreens(void) {
systemSettings.detailedIDLE = !systemSettings.detailedIDLE;
return false;
}
static bool settings_setAdvancedIDLEScreens(void) { return nextSettingValue(SettingsOptions::DetailedIDLE); }
static bool settings_displayAdvancedIDLEScreens(void) {
printShortDescription(SettingsItemIndex::AdvancedIdle, 7);
OLED::drawCheckbox(systemSettings.detailedIDLE);
OLED::drawCheckbox(getSettingValue(SettingsOptions::DetailedIDLE));
return false;
}
static bool settings_setPowerLimit(void) {
systemSettings.powerLimit += POWER_LIMIT_STEPS;
if (systemSettings.powerLimit > MAX_POWER_LIMIT)
systemSettings.powerLimit = 0;
return systemSettings.powerLimit + POWER_LIMIT_STEPS > MAX_POWER_LIMIT;
}
static bool settings_setPowerLimit(void) { return nextSettingValue(SettingsOptions::PowerLimit); }
static bool settings_displayPowerLimit(void) {
printShortDescription(SettingsItemIndex::PowerLimit, 5);
if (systemSettings.powerLimit == 0) {
if (getSettingValue(SettingsOptions::PowerLimit) == 0) {
OLED::print(translatedString(Tr->OffString), FontStyle::LARGE);
} else {
OLED::printNumber(systemSettings.powerLimit, 2, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::PowerLimit), 2, FontStyle::LARGE);
OLED::print(SymbolWatts, FontStyle::LARGE);
}
return false;
}
static bool settings_setScrollSpeed(void) {
if (systemSettings.descriptionScrollSpeed == 0)
systemSettings.descriptionScrollSpeed = 1;
else
systemSettings.descriptionScrollSpeed = 0;
return false;
}
static bool settings_setScrollSpeed(void) { return nextSettingValue(SettingsOptions::DescriptionScrollSpeed); }
static bool settings_displayScrollSpeed(void) {
printShortDescription(SettingsItemIndex::ScrollingSpeed, 7);
OLED::print(translatedString((systemSettings.descriptionScrollSpeed) ? Tr->SettingFastChar : Tr->SettingSlowChar), FontStyle::LARGE);
OLED::print(translatedString((getSettingValue(SettingsOptions::DescriptionScrollSpeed)) ? Tr->SettingFastChar : Tr->SettingSlowChar), FontStyle::LARGE);
return false;
}
#ifndef NO_DISPLAY_ROTATE
static bool settings_setDisplayRotation(void) {
systemSettings.OrientationMode++;
systemSettings.OrientationMode = systemSettings.OrientationMode % 3;
switch (systemSettings.OrientationMode) {
bool res = nextSettingValue(SettingsOptions::OrientationMode);
switch (getSettingValue(SettingsOptions::OrientationMode)) {
case 0:
OLED::setRotation(false);
break;
@@ -588,13 +543,13 @@ static bool settings_setDisplayRotation(void) {
default:
break;
}
return systemSettings.OrientationMode == 2;
return res;
}
static bool settings_displayDisplayRotation(void) {
printShortDescription(SettingsItemIndex::DisplayRotation, 7);
switch (systemSettings.OrientationMode) {
switch (getSettingValue(SettingsOptions::OrientationMode)) {
case 0:
OLED::print(translatedString(Tr->SettingRightChar), FontStyle::LARGE);
break;
@@ -612,50 +567,48 @@ static bool settings_displayDisplayRotation(void) {
}
#endif
static bool settings_setBoostTemp(void) {
if (systemSettings.temperatureInF) {
if (systemSettings.BoostTemp == 0) {
systemSettings.BoostTemp = MIN_BOOST_TEMP_F; // loop back at 480
uint16_t value = getSettingValue(SettingsOptions::BoostTemp);
if (getSettingValue(SettingsOptions::TemperatureInF)) {
if (value == 0) {
value = MIN_BOOST_TEMP_F; // loop back at 480
} else {
systemSettings.BoostTemp += 20; // Go up 20F at a time
value += 20; // Go up 20F at a time
}
if (systemSettings.BoostTemp > MAX_TEMP_F) {
systemSettings.BoostTemp = 0; // jump to off
if (value > MAX_TEMP_F) {
value = 0; // jump to off
}
return systemSettings.BoostTemp == MAX_TEMP_F - 10;
} else {
if (systemSettings.BoostTemp == 0) {
systemSettings.BoostTemp = MIN_BOOST_TEMP_C; // loop back at 250
} else {
systemSettings.BoostTemp += 10; // Go up 10C at a time
}
if (systemSettings.BoostTemp > MAX_TEMP_C) {
systemSettings.BoostTemp = 0; // Go to off state
}
return systemSettings.BoostTemp == MAX_TEMP_C;
setSettingValue(SettingsOptions::BoostTemp, value);
return value == MAX_TEMP_F - 10;
}
if (value == 0) {
value = MIN_BOOST_TEMP_C; // loop back at 250
} else {
value += 10; // Go up 10C at a time
}
if (value > MAX_TEMP_C) {
value = 0; // Go to off state
}
setSettingValue(SettingsOptions::BoostTemp, value);
return value == MAX_TEMP_C;
}
static bool settings_displayBoostTemp(void) {
printShortDescription(SettingsItemIndex::BoostTemperature, 5);
if (systemSettings.BoostTemp) {
OLED::printNumber(systemSettings.BoostTemp, 3, FontStyle::LARGE);
if (getSettingValue(SettingsOptions::BoostTemp)) {
OLED::printNumber(getSettingValue(SettingsOptions::BoostTemp), 3, FontStyle::LARGE);
} else {
OLED::print(translatedString(Tr->OffString), FontStyle::LARGE);
}
return false;
}
static bool settings_setAutomaticStartMode(void) {
systemSettings.autoStartMode++;
systemSettings.autoStartMode %= 4;
return systemSettings.autoStartMode == 3;
}
static bool settings_setAutomaticStartMode(void) { return nextSettingValue(SettingsOptions::AutoStartMode); }
static bool settings_displayAutomaticStartMode(void) {
printShortDescription(SettingsItemIndex::AutoStart, 7);
switch (systemSettings.autoStartMode) {
switch (getSettingValue(SettingsOptions::AutoStartMode)) {
case 0:
OLED::print(translatedString(Tr->SettingStartNoneChar), FontStyle::LARGE);
break;
@@ -675,16 +628,12 @@ static bool settings_displayAutomaticStartMode(void) {
return false;
}
static bool settings_setLockingMode(void) {
systemSettings.lockingMode++;
systemSettings.lockingMode %= 3;
return systemSettings.lockingMode == 2;
}
static bool settings_setLockingMode(void) { return nextSettingValue(SettingsOptions::LockingMode); }
static bool settings_displayLockingMode(void) {
printShortDescription(SettingsItemIndex::LockingMode, 7);
switch (systemSettings.lockingMode) {
switch (getSettingValue(SettingsOptions::LockingMode)) {
case 0:
OLED::print(translatedString(Tr->SettingLockDisableChar), FontStyle::LARGE);
break;
@@ -701,14 +650,11 @@ static bool settings_displayLockingMode(void) {
return false;
}
static bool settings_setCoolingBlinkEnabled(void) {
systemSettings.coolingTempBlink = !systemSettings.coolingTempBlink;
return false;
}
static bool settings_setCoolingBlinkEnabled(void) { return nextSettingValue(SettingsOptions::CoolingTempBlink); }
static bool settings_displayCoolingBlinkEnabled(void) {
printShortDescription(SettingsItemIndex::CooldownBlink, 7);
OLED::drawCheckbox(systemSettings.coolingTempBlink);
OLED::drawCheckbox(getSettingValue(SettingsOptions::CoolingTempBlink));
return false;
}
@@ -726,12 +672,12 @@ static bool settings_displayResetSettings(void) {
}
static void setTipOffset() {
systemSettings.CalibrationOffset = 0;
uint16_t setoffset = 0;
// If the thermo-couple at the end of the tip, and the handle are at
// equilibrium, then the output should be zero, as there is no temperature
// differential.
while (systemSettings.CalibrationOffset == 0) {
while (setoffset == 0) {
uint32_t offset = 0;
for (uint8_t i = 0; i < 16; i++) {
offset += getTipRawTemp(1);
@@ -744,12 +690,13 @@ static void setTipOffset() {
OLED::refresh();
osDelay(100);
}
systemSettings.CalibrationOffset = TipThermoModel::convertTipRawADCTouV(offset / 16);
setoffset = TipThermoModel::convertTipRawADCTouV(offset / 16);
}
setSettingValue(SettingsOptions::CalibrationOffset, setoffset);
OLED::clearScreen();
OLED::setCursor(0, 0);
OLED::drawCheckbox(true);
OLED::printNumber(systemSettings.CalibrationOffset, 4, FontStyle::LARGE);
OLED::printNumber(setoffset, 4, FontStyle::LARGE);
OLED::refresh();
osDelay(1200);
}
@@ -777,27 +724,25 @@ static bool settings_setCalibrateVIN(void) {
for (;;) {
OLED::setCursor(0, 0);
OLED::printNumber(getInputVoltageX10(systemSettings.voltageDiv, 0) / 10, 2, FontStyle::LARGE);
uint16_t voltage = getInputVoltageX10(getSettingValue(SettingsOptions::VoltageDiv), 0);
OLED::printNumber(voltage / 10, 2, FontStyle::LARGE);
OLED::print(SymbolDot, FontStyle::LARGE);
OLED::printNumber(getInputVoltageX10(systemSettings.voltageDiv, 0) % 10, 1, FontStyle::LARGE, false);
OLED::printNumber(voltage % 10, 1, FontStyle::LARGE, false);
OLED::print(SymbolVolts, FontStyle::LARGE);
ButtonState buttons = getButtonState();
switch (buttons) {
switch (getButtonState()) {
case BUTTON_F_SHORT:
systemSettings.voltageDiv++;
nextSettingValue(SettingsOptions::VoltageDiv);
break;
case BUTTON_B_SHORT:
systemSettings.voltageDiv--;
prevSettingValue(SettingsOptions::VoltageDiv);
break;
case BUTTON_BOTH:
case BUTTON_F_LONG:
case BUTTON_B_LONG:
saveSettings();
OLED::setCursor(0, 0);
OLED::printNumber(systemSettings.voltageDiv, 3, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::VoltageDiv), 3, FontStyle::LARGE);
OLED::refresh();
waitForButtonPressOrTimeout(1 * TICKS_SECOND);
return false;
@@ -808,108 +753,60 @@ static bool settings_setCalibrateVIN(void) {
OLED::refresh();
osDelay(40);
// Cap to sensible values
#if defined(MODEL_TS80) + defined(MODEL_TS80P) > 0
if (systemSettings.voltageDiv < 500) {
systemSettings.voltageDiv = 500;
} else if (systemSettings.voltageDiv > 900) {
systemSettings.voltageDiv = 900;
}
#else
if (systemSettings.voltageDiv < 360) {
systemSettings.voltageDiv = 360;
} else if (systemSettings.voltageDiv > 520) {
systemSettings.voltageDiv = 520;
}
#endif
}
return false;
}
static bool settings_setReverseButtonTempChangeEnabled(void) {
systemSettings.ReverseButtonTempChangeEnabled = !systemSettings.ReverseButtonTempChangeEnabled;
return false;
}
static bool settings_setReverseButtonTempChangeEnabled(void) { return nextSettingValue(SettingsOptions::ReverseButtonTempChangeEnabled); }
static bool settings_displayReverseButtonTempChangeEnabled(void) {
printShortDescription(SettingsItemIndex::ReverseButtonTempChange, 7);
OLED::drawCheckbox(systemSettings.ReverseButtonTempChangeEnabled);
OLED::drawCheckbox(getSettingValue(SettingsOptions::ReverseButtonTempChangeEnabled));
return false;
}
static bool settings_setTempChangeShortStep(void) {
systemSettings.TempChangeShortStep += TEMP_CHANGE_SHORT_STEP;
if (systemSettings.TempChangeShortStep > TEMP_CHANGE_SHORT_STEP_MAX) {
systemSettings.TempChangeShortStep = TEMP_CHANGE_SHORT_STEP; // loop back at TEMP_CHANGE_SHORT_STEP_MAX
}
return systemSettings.TempChangeShortStep == TEMP_CHANGE_SHORT_STEP_MAX;
}
static bool settings_setTempChangeShortStep(void) { return nextSettingValue(SettingsOptions::TempChangeShortStep); }
static bool settings_displayTempChangeShortStep(void) {
printShortDescription(SettingsItemIndex::TempChangeShortStep, 6);
OLED::printNumber(systemSettings.TempChangeShortStep, 2, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::TempChangeShortStep), 2, FontStyle::LARGE);
return false;
}
static bool settings_setTempChangeLongStep(void) {
if (systemSettings.TempChangeLongStep == TEMP_CHANGE_SHORT_STEP) {
systemSettings.TempChangeLongStep = TEMP_CHANGE_LONG_STEP / 2;
} else if (systemSettings.TempChangeLongStep == TEMP_CHANGE_LONG_STEP / 2) {
systemSettings.TempChangeLongStep = TEMP_CHANGE_LONG_STEP;
} else {
systemSettings.TempChangeLongStep += TEMP_CHANGE_LONG_STEP;
}
if (systemSettings.TempChangeLongStep > TEMP_CHANGE_LONG_STEP_MAX) {
systemSettings.TempChangeLongStep = TEMP_CHANGE_SHORT_STEP; // loop back at TEMP_CHANGE_LONG_STEP_MAX
}
return systemSettings.TempChangeLongStep == TEMP_CHANGE_LONG_STEP_MAX;
}
static bool settings_setTempChangeLongStep(void) { return nextSettingValue(SettingsOptions::TempChangeLongStep); }
static bool settings_displayTempChangeLongStep(void) {
printShortDescription(SettingsItemIndex::TempChangeLongStep, 6);
OLED::printNumber(systemSettings.TempChangeLongStep, 2, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::TempChangeLongStep), 2, FontStyle::LARGE);
return false;
}
static bool settings_setPowerPulse(void) {
systemSettings.KeepAwakePulse += POWER_PULSE_INCREMENT;
systemSettings.KeepAwakePulse %= POWER_PULSE_MAX;
return systemSettings.KeepAwakePulse == POWER_PULSE_MAX - 1;
}
static bool settings_setPowerPulse(void) { return nextSettingValue(SettingsOptions::KeepAwakePulse); }
static bool settings_displayPowerPulse(void) {
printShortDescription(SettingsItemIndex::PowerPulsePower, 5);
if (systemSettings.KeepAwakePulse) {
OLED::printNumber(systemSettings.KeepAwakePulse / 10, 1, FontStyle::LARGE);
if (getSettingValue(SettingsOptions::KeepAwakePulse)) {
OLED::printNumber(getSettingValue(SettingsOptions::KeepAwakePulse) / 10, 1, FontStyle::LARGE);
OLED::print(SymbolDot, FontStyle::LARGE);
OLED::printNumber(systemSettings.KeepAwakePulse % 10, 1, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::KeepAwakePulse) % 10, 1, FontStyle::LARGE);
} else {
OLED::print(translatedString(Tr->OffString), FontStyle::LARGE);
}
return false;
}
static bool settings_setAnimationLoop(void) {
systemSettings.animationLoop = !systemSettings.animationLoop;
return false;
}
static bool settings_setAnimationLoop(void) { return nextSettingValue(SettingsOptions::AnimationLoop); }
static bool settings_displayAnimationLoop(void) {
printShortDescription(SettingsItemIndex::AnimLoop, 7);
OLED::drawCheckbox(systemSettings.animationLoop);
OLED::drawCheckbox(getSettingValue(SettingsOptions::AnimationLoop));
return false;
}
static bool settings_setAnimationSpeed(void) {
systemSettings.animationSpeed++;
systemSettings.animationSpeed %= settingOffSpeed_t::MAX_VALUE;
return systemSettings.animationSpeed == (uint8_t)settingOffSpeed_t::FAST;
}
static bool settings_setAnimationSpeed(void) { return nextSettingValue(SettingsOptions::AnimationSpeed); }
static bool settings_displayAnimationSpeed(void) {
printShortDescription(SettingsItemIndex::AnimSpeed, 7);
switch (systemSettings.animationSpeed) {
switch (getSettingValue(SettingsOptions::AnimationSpeed)) {
case settingOffSpeed_t::SLOW:
OLED::print(translatedString(Tr->SettingSlowChar), FontStyle::LARGE);
break;
@@ -926,20 +823,12 @@ static bool settings_displayAnimationSpeed(void) {
return false;
}
static bool settings_setPowerPulseWait(void) {
// Constrain to range 1 to POWER_PULSE_WAIT_MAX inclusive
auto &wait = systemSettings.KeepAwakePulseWait;
if (++wait > POWER_PULSE_WAIT_MAX) {
wait = 1;
}
return wait == POWER_PULSE_WAIT_MAX;
}
static bool settings_setPowerPulseWait(void) { return nextSettingValue(SettingsOptions::KeepAwakePulseWait); }
static bool settings_displayPowerPulseWait(void) {
if (systemSettings.KeepAwakePulse) {
if (getSettingValue(SettingsOptions::KeepAwakePulse)) {
printShortDescription(SettingsItemIndex::PowerPulseWait, 7);
OLED::printNumber(systemSettings.KeepAwakePulseWait, 1, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::KeepAwakePulseWait), 1, FontStyle::LARGE);
return false;
} else {
return true; // skip
@@ -948,18 +837,13 @@ static bool settings_displayPowerPulseWait(void) {
static bool settings_setPowerPulseDuration(void) {
// Constrain to range 1 to POWER_PULSE_DURATION_MAX inclusive
auto &duration = systemSettings.KeepAwakePulseDuration;
if (++duration > POWER_PULSE_DURATION_MAX) {
duration = 1;
}
return duration == POWER_PULSE_DURATION_MAX;
return nextSettingValue(SettingsOptions::KeepAwakePulseDuration);
}
static bool settings_displayPowerPulseDuration(void) {
if (systemSettings.KeepAwakePulse) {
if (getSettingValue(SettingsOptions::KeepAwakePulse)) {
printShortDescription(SettingsItemIndex::PowerPulseDuration, 7);
OLED::printNumber(systemSettings.KeepAwakePulseDuration, 1, FontStyle::LARGE);
OLED::printNumber(getSettingValue(SettingsOptions::KeepAwakePulseDuration), 1, FontStyle::LARGE);
return false;
} else {
return true; // skip
@@ -969,7 +853,7 @@ static bool settings_displayPowerPulseDuration(void) {
#ifdef HALL_SENSOR
static bool settings_displayHallEffect(void) {
printShortDescription(SettingsItemIndex::HallEffSensitivity, 7);
switch (systemSettings.hallEffectSensitivity) {
switch (getSettingValue(SettingsOptions::HallEffectSensitivity)) {
case 1:
OLED::print(translatedString(Tr->SettingSensitivityLow), FontStyle::LARGE);
break;
@@ -986,13 +870,7 @@ static bool settings_displayHallEffect(void) {
}
return false;
}
static bool settings_setHallEffect(void) {
// To keep life simpler for now, we have a few preset sensitivity levels
// Off, Low, Medium, High
systemSettings.hallEffectSensitivity++;
systemSettings.hallEffectSensitivity %= 4;
return systemSettings.hallEffectSensitivity == 3;
}
static bool settings_setHallEffect(void) { return nextSettingValue(SettingsOptions::HallEffectSensitivity); }
#endif
// Indicates whether a menu transition is in progress, so that the menu icon
@@ -1003,13 +881,10 @@ static void displayMenu(size_t index) {
// Call into the menu
// Draw title
OLED::printWholeScreen(translatedString(Tr->SettingsMenuEntries[index]));
// Draw symbol
// 16 pixel wide image
// 2 pixel wide scrolling indicator
static TickType_t menuSwitchLoopTick = 0;
static size_t menuCurrentIndex = sizeof(rootSettingsMenu) + 1;
TickType_t step = TICKS_100MS * 5;
switch (systemSettings.animationSpeed) {
switch (getSettingValue(SettingsOptions::AnimationSpeed)) {
case settingOffSpeed_t::FAST:
step = TICKS_100MS * 3;
break;
@@ -1020,13 +895,13 @@ static void displayMenu(size_t index) {
break;
}
size_t currentFrame;
if (!animOpenState && systemSettings.animationSpeed != settingOffSpeed_t::OFF) {
if (!animOpenState && (getSettingValue(SettingsOptions::AnimationSpeed) != settingOffSpeed_t::OFF)) {
if (menuCurrentIndex != index) {
menuCurrentIndex = index;
menuSwitchLoopTick = xTaskGetTickCount();
}
currentFrame = ((xTaskGetTickCount() - menuSwitchLoopTick) / step);
if (systemSettings.animationLoop) {
if (getSettingValue(SettingsOptions::AnimationLoop)) {
currentFrame %= 3;
} else if (currentFrame > 2) {
currentFrame = 2;
@@ -1035,8 +910,11 @@ static void displayMenu(size_t index) {
// We want the animation to restart after completing the transition.
menuCurrentIndex = sizeof(rootSettingsMenu) + 1;
// Always draw the last frame if icon animation is disabled.
currentFrame = systemSettings.animationSpeed == settingOffSpeed_t::OFF ? 2 : 0;
currentFrame = getSettingValue(SettingsOptions::AnimationSpeed) == settingOffSpeed_t::OFF ? 2 : 0;
}
// Draw symbol
// 16 pixel wide image
// 2 pixel wide scrolling indicator
OLED::drawArea(OLED_WIDTH - 16 - 2, 0, 16, 16, (&SettingsMenuIcons[index][(16 * 2) * currentFrame]));
}