Skip to content

Feature refactor options handling #17

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
coldtobi wants to merge 3 commits into
base: master
Choose a base branch
from
Open

Feature refactor options handling #17

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
e4c8bef
Refactor OptionMenu() to be table-driven and to allow more options.
Jan 2, 2026
70bbd92
Make maximum tip power configurable via Options.
Jan 2, 2026
9818eb8
Fix EEPROM overlap.
Jan 3, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
211 changes: 169 additions & 42 deletions Maiskolben_TFT/Maiskolben_TFT.ino
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -64,6 +64,8 @@ uint16_t charge = 0;
float adc_offset = ADC_TO_TEMP_OFFSET;
float adc_gain = ADC_TO_TEMP_GAIN;

uint8_t maxpower = 40;

#define RGB_DISP 0x0
#define BGR_DISP 0x2

Expand Down Expand Up @@ -201,6 +203,7 @@ void setup(void) {
delay(50);
}
EEPROM.update(EEPROM_OPTIONS, (fahrenheit << 2) | (bootheat << 1) | autopower);
EEPROM.update(EEPROM_POWER, maxpower);
EEPROM.update(EEPROM_VERSION, EE_VERSION);
EEPROM.update(EEPROM_INSTALL, EEPROM_CHECK);
EEPROM.put(EEPROM_ADCTTG, adc_gain);
Expand All @@ -219,6 +222,8 @@ void setup(void) {
autopower = options & 1;
bootheat = options & 2;
fahrenheit = options & 4;
maxpower = EEPROM.read(EEPROM_POWER);

if (force_menu) optionMenu();
else {
updateRevision();
Expand Down Expand Up @@ -309,77 +314,190 @@ void setDisplayMode(boolean bgr) {
tft.setRotation(3);
}

#ifdef SHUTOFF_ACTIVE
#define OPT_BIT_SHUTOFF OPT_BIT
#else
#define OPT_BIT_SHUTOFF OPT_BIT_DISABLED
#endif

#ifdef BOOTHEAT_ACTIVE
#define OPT_BIT_BHEAT OPT_BIT
#else
#define OPT_BIT_BHEAT OPT_BIT_DISABLED
#endif

void optionMenu(void) {
uint8_t first_option = 0; // The current option displayed on the top-line.
uint8_t opt = 0; // The current line on the display that is selected.

// for the declaration table.
enum optiontype {
OPT_BIT,
OPT_BIT_DISABLED,
OPT_8BIT_VALUE,
};

// defined options.
struct optionslist {
char *title;
enum optiontype type;

uint8_t min_or_bit; // bitmask to be orded / deleted on option toggle or min value for 8-bit value
uint8_t max; // max value for 8-bit-value
uint8_t stepsize; // step size for +/- for 8-bit-value
uint8_t *target; // target variable.
} optionslist[] = {
// title type min max step target
// mask
{ "Autoshutdown", OPT_BIT_SHUTOFF, 1, 0, 0, (uint8_t *)&autopower },
{ "Heat on boot", OPT_BIT_BHEAT, 1, 0, 0, (uint8_t *)&bootheat },
{ "Fahrenheit", OPT_BIT, 1, 0, 0, (uint8_t *)&fahrenheit },
{ "Pmax", OPT_8BIT_VALUE, 10, 110, 5, &maxpower }
};

// how many chars do fit into a line?
constexpr uint8_t chars_per_line = 13; // number of chars per line.
constexpr uint8_t displayed_options = 3; // number of option-lines on display
constexpr uint8_t num_options = 4; // total number of options in optionlist[]

// sanitize 8-bit values
for (int i = 0; i < num_options; i++) {
if (optionslist[i].type != OPT_8BIT_VALUE) continue;
uint8_t value = *(optionslist[i].target);
if (value < optionslist[i].min_or_bit) value = optionslist[i].min_or_bit;
if (value > optionslist[i].max) value = optionslist[i].max;
*(optionslist[i].target) = value;
}

const char *onoffexit = "ON OFF EXIT";
const char *plusminusexit = " + - EXIT";

// Prepare Screen
tft.fillScreen(BLACK);
digitalWrite(HEAT_LED, LOW);
tft.setTextSize(2);
tft.setCursor(0,0);
tft.setTextColor(WHITE);
tft.println("Options\n");
tft.setTextColor(WHITE);
tft.setCursor(10,112);
tft.print("ON OFF EXIT");
uint8_t options = 3;
uint8_t opt = 0;

boolean redraw = true;
while (true) {
if (redraw) {
tft.setCursor(0,36);
#ifdef SHUTOFF_ACTIVE
tft.setTextColor(autopower?GREEN:RED);
#else
tft.setTextColor(GRAY);
#endif
tft.println(" Autoshutdown");
#ifdef BOOTHEAT_ACTIVE
tft.setTextColor(bootheat?GREEN:RED);
#else
tft.setTextColor(GRAY);
#endif
tft.println(" Heat on boot");
tft.setTextColor(fahrenheit?GREEN:RED);
tft.println(" Fahrenheit");
tft.setCursor(0, 2 * 18);
// Render options from first_option on.
for (uint8_t i = 0; i < displayed_options; i++) {
uint8_t printed = 0;
uint8_t entry = i + first_option;
uint16_t color = GRAY;
bool is_enabled = 0;
if (optionslist[entry].type == OPT_BIT) {
uint8_t value = optionslist[entry].min_or_bit & *(optionslist[entry].target);
if (value) color = GREEN;
else color = RED;
} else if (optionslist[entry].type == OPT_8BIT_VALUE) {
color = GREEN;
}
if (opt == i) tft.setTextColor(WHITE);
else tft.setTextColor(BLACK);
tft.print(">");
tft.setTextColor(color, BLACK);
tft.print(optionslist[entry].title);
printed = 1 + strlen(optionslist[entry].title);

tft.setCursor(0, (opt+2)*18);
tft.setTextColor(WHITE);
tft.print(">");
if (optionslist[entry].type == OPT_8BIT_VALUE) {
uint8_t val = *(optionslist[entry].target);
tft.print(" ");
if (val < 100) tft.print(" ");
if (val < 10) tft.print(" ");
tft.print(val);
printed += 3;
}
for (uint8_t j = printed; j < chars_per_line; j++) tft.print(" ");
tft.println("");
}

// Render operationstext
tft.setTextColor(WHITE, BLACK);
tft.setCursor(10, 112);
if (optionslist[opt + first_option].type == OPT_8BIT_VALUE) {
tft.print(plusminusexit);
} else {
tft.print(onoffexit);
}

// Render hints that there are more options
if (first_option) tft.setTextColor(YELLOW, BLACK);
else tft.setTextColor(BLACK, BLACK);
tft.setCursor(142, 1 * 18);
tft.print((char)0x18); // "arrow up"

if (num_options - first_option > displayed_options) tft.setTextColor(YELLOW, BLACK);
else tft.setTextColor(BLACK, BLACK);
tft.setCursor(142, (displayed_options + 2) * 18);
tft.print((char)0x19); // "arrow down"

redraw = false;
}

// Button handling.
// opt is current line on screen.
if (!digitalRead(SW_UP)) {
tft.setCursor(0, (opt+2)*18);
tft.setTextColor(BLACK);
tft.print(">");
opt = (opt+options-1)%options;
if (opt == 0 && first_option) {
first_option--;
} else if (opt) {
opt--;
}
while (!digitalRead(SW_UP)) delay(100);
redraw = true;
}
if (!digitalRead(SW_DOWN)) {
tft.setCursor(0, (opt+2)*18);
tft.setTextColor(BLACK);
tft.print(">");
opt = (opt+1)%options;
if (displayed_options - 1 > opt) {
opt++;
} else if (num_options - 1 > opt + first_option) {
first_option++;
}
while (!digitalRead(SW_DOWN)) delay(100);
redraw = true;
}

if (!digitalRead(SW_T1)) {
switch (opt) {
case 0: autopower = 1; break;
case 1: bootheat = 1; break;
case 2: fahrenheit = 1; break;
uint8_t entry = opt + first_option;
enum optiontype type = optionslist[entry].type;
switch (type) {
case OPT_BIT:
*(optionslist[entry].target) |= optionslist[entry].min_or_bit;
break;
case OPT_8BIT_VALUE:
uint8_t value = *(optionslist[entry].target) + optionslist[entry].stepsize;
if (value > optionslist[entry].max) value = optionslist[entry].max;
*(optionslist[entry].target) = value;
break;
}
redraw = true;
}

if (!digitalRead(SW_T2)) {
switch (opt) {
case 0: autopower = 0; break;
case 1: bootheat = 0; break;
case 2: fahrenheit = 0; break;
uint8_t entry = opt + first_option;
enum optiontype type = optionslist[entry].type;
switch (type) {
case OPT_BIT:
*(optionslist[entry].target) &= ~(optionslist[entry].min_or_bit);
break;
case OPT_8BIT_VALUE:
uint8_t value = *(optionslist[entry].target);
if (value >= optionslist[entry].stepsize) value -= optionslist[entry].stepsize;
else value = 0;
if (value < optionslist[entry].min_or_bit) value = optionslist[entry].min_or_bit;
*(optionslist[entry].target) = value;
}
redraw = true;
}

if (!digitalRead(SW_T3)) break;
}

EEPROM.update(EEPROM_OPTIONS, (fahrenheit << 2) | (bootheat << 1) | autopower);
EEPROM.update(EEPROM_POWER, maxpower);
updateRevision();
EEPROM.update(EEPROM_VERSION, EE_VERSION);
if (EEPROM.read(EEPROM_VERSION) < 30) {
Expand Down Expand Up @@ -872,10 +990,19 @@ void compute(void) {
last_measured = cur_t;

heaterPID.Compute();
if (error != NO_ERROR || off)

// Power limitation.
// Tips are rated for 40W, do not exceed that.
// note t-hat we have inherently only 50% PWM, as we have it on 10ms and then wait with pwm off for another 10ms.
// Formula: P = 0.5 * ( U^2 / ( R )) * (pwm)
float pwm_max = 2 * maxpower / ((v * v) / 2.4);
if (pwm_max > pid_val) pwm_max = pid_val;

if (error != NO_ERROR || off) {
pwm = 0;
else
pwm = min(255,pid_val*255);
} else {
pwm = min(255, pwm_max * 255);
}
analogWrite(HEATER_PWM, pwm);
}

Expand Down
10 changes: 9 additions & 1 deletion Maiskolben_TFT/definitions.h
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
#define VERSION "3.1"
#define EE_VERSION 31
#define EE_VERSION 32
#define EEPROM_CHECK 42

#define BAR_HEIGHT 4 //Should be no bigger than 5
Expand Down Expand Up @@ -77,6 +77,14 @@
#define EEPROM_ADCTTG 14
#define EEPROM_ADCOFF (EEPROM_ADCTTG + sizeof(float))

// EEPROM Version 32
#define EEPROM_POWER 22
#define EEPROM_STBYTEMP 23
#define EEPROM_STBYTIME 25
#define EEPROM_MINTEMP 27
#define EEPROM_MAXTEMP 29


#define EEPROM_INSTALL 42
#define REF_T1 275
#define REF_T2 410
Expand Down