chaos-hip/Maiskolben
3
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
Maiskolben/Maiskolben_TFT.ino
maggi 4dc9422923 Initial commit
2020-08-20 16:16:56 +02:00

1047 lines
29 KiB
C++
Raw Blame History

#include <SPI.h>
#include <TFT_ILI9163C.h>
#include <PID_v1.h>
#include <EEPROM.h>
#include <TimerOne.h>
#include "definitions.h"
/*
If your display stays white, uncomment this.
Cut reset trace (on THT on upper layer/0R), connect STBY_NO (A1) with reset of TFT (at 4050).
See also readme in mechanical folder for reference.
*/
#define USE_TFT_RESET // Benötigt
/*
If red is blue and blue is red change this
If not sure, leave commented, you will be shown a setup screen
*/
// #define HARDWARE_DEFINED_TFT 2
/*
Based on your Hardware-Revision there may be modifications to the PCB.
In V3 and up is a second voltage measurement circuit.
HW REVS:
1.5 - 2.8:
For THT this should be set to anything < 3
Normally leave this commented as it is stored in EEPROM
*/
// V 1.5 - 2.11, Maiskolben THT2
//#define HARDWARE_REVISION 2
// V 3.0 and 3.1
//#define HARDWARE_REVISION 3
/*
Only used for testing, do not use.
*/
// #define INSTALL
// #define TEST_ADC
volatile boolean off = true, stby = true, stby_layoff = false, sw_stby_old = false, sw_up_old = false, sw_down_old = false, clear_display = true, store_invalid = true, menu = false;
volatile uint8_t pwm, threshold_counter;
volatile int16_t cur_t, last_measured;
volatile error_type error = NO_ERROR;
error_type error_old;
int16_t stored[3] = {300, 350, 450}, set_t = TEMP_MIN, set_t_old, cur_t_old, target_t;
double pid_val, cur_td, set_td;
uint8_t store_to = 255;
p_source power_source, power_source_old = NO_INIT;
boolean blink;
uint16_t cnt_measure_voltage, cnt_compute, cnt_sw_poll, cnt_but_press, cnt_off_press, cnt_but_store;
float v_c1, v_c2, v_c3, v_in, v;
uint8_t array_index, array_count;
uint32_t sendNext;
uint32_t last_temperature_drop;
uint32_t last_on_state;
boolean wasOff = true, old_stby = false;
boolean autopower = true, bootheat = false, fahrenheit = false;
uint8_t revision = 1;
boolean menu_dismissed = false;
boolean autopower_repeat_under = false;
boolean force_redraw = false;
boolean power_down = false;
uint16_t charge = 0;
float adc_offset = ADC_TO_TEMP_OFFSET;
float adc_gain = ADC_TO_TEMP_GAIN;
#define RGB_DISP 0x0
#define BGR_DISP 0x2
#ifdef USE_TFT_RESET
TFT_ILI9163C tft = TFT_ILI9163C(TFT_CS, TFT_DC, STBY_NO);
#else
TFT_ILI9163C tft = TFT_ILI9163C(TFT_CS, TFT_DC);
#endif
#define BLACK 0x0000
#define RED 0x001F // Blue
#define BLUE 0xF800 // Red
#define GREEN 0x07E0
#define YELLOW 0x07FF // Cyan
#define MAGENTA 0xF81F
#define CYAN 0xFFE0 // Yellow
#define WHITE 0xFFFF
#define GRAY 0x94B2
PID heaterPID(&cur_td, &pid_val, &set_td, kp, ki, kd, DIRECT);
void setup(void) {
digitalWrite(HEATER_PWM, LOW);
pinMode(HEATER_PWM, OUTPUT);
pinMode(POWER, INPUT_PULLUP);
pinMode(HEAT_LED, OUTPUT);
digitalWrite(HEAT_LED, HIGH);
pinMode(TEMP_SENSE, INPUT);
pinMode(SW_T1, INPUT_PULLUP);
pinMode(SW_T2, INPUT_PULLUP);
pinMode(SW_T3, INPUT_PULLUP);
pinMode(SW_UP, INPUT_PULLUP);
pinMode(SW_DOWN, INPUT_PULLUP);
pinMode(STBY_NO, INPUT_PULLUP);
pinMode(SW_STBY, INPUT_PULLUP);
pinMode(TFT_CS, OUTPUT);
digitalWrite(TFT_CS, HIGH);
Serial.begin(115200);
boolean force_menu = false;
if (EEPROM.read(0) != EEPROM_CHECK) {
EEPROM.update(0, EEPROM_CHECK);
updateEEPROM();
force_menu = true;
}
tft.begin();
#ifdef HARDWARE_DEFINED_TFT
#if HARDWARE_DEFINED_TFT == 1
EEPROM.update(EEPROM_DISPLAY, RGB_DISP);
setDisplayMode(0);
#else
EEPROM.update(EEPROM_DISPLAY, BGR_DISP);
setDisplayMode(1);
#endif
#else
if (force_menu || EEPROM.read(EEPROM_VERSION) < 23 || EEPROM.read(EEPROM_VERSION) == 255 || (EEPROM.read(EEPROM_DISPLAY) != BGR_DISP && EEPROM.read(EEPROM_DISPLAY) != RGB_DISP)) {
tft.fillScreen(BLACK);
setDisplayMode(1);
tft.setTextSize(2);
tft.setCursor(0, 0);
tft.setTextColor(WHITE);
tft.print(F("What color is displayed?"));
tft.setCursor(10, 112);
tft.setTextColor(RED);
tft.print("RED BLUE");
while (true) {
if (!digitalRead(SW_T1)) {
EEPROM.update(EEPROM_DISPLAY, BGR_DISP);
setDisplayMode(1);
break;
}
if (!digitalRead(SW_T3)) {
EEPROM.update(EEPROM_DISPLAY, RGB_DISP);
setDisplayMode(0);
break;
}
}
tft.fillScreen(BLACK);
tft.setTextColor(YELLOW);
tft.drawBitmap(0, 20, maiskolben, 160, 64, YELLOW);
tft.setCursor(20, 86);
tft.setTextColor(YELLOW);
tft.setTextSize(2);
tft.print("Maiskolben");
tft.setCursor(35, 104);
tft.print("Welcome!");
delay(4000);
while (!digitalRead(SW_T3) || !digitalRead(SW_T1)) delay(100);
} else {
setDisplayMode(EEPROM.read(EEPROM_DISPLAY) == BGR_DISP);
}
#endif
#ifdef INSTALL
if (EEPROM.read(EEPROM_INSTALL) != EEPROM_CHECK) {
tft.fillScreen(BLACK);
tft.setTextColor(RED, BLACK);
tft.setCursor(0, 0);
tft.setTextSize(2);
tft.println("Installation");
for (int16_t i = -255; i < 256; i++) {
analogWrite(HEAT_LED, 255 - abs(i));
delay(1);
}
uint16_t adc1 = 0, adc2 = 0;
while (digitalRead(SW_STBY)) {
int t = getTemperature();
uint16_t adc = analogRead(TEMP_SENSE);
Serial.println(t);
digitalWrite(HEATER_PWM, !digitalRead(SW_T1) | !digitalRead(SW_T2) | !digitalRead(SW_T3)/* | !digitalRead(SW_UP) | !digitalRead(SW_DOWN)*/);
if (!digitalRead(SW_DOWN)) {
if (!adc) {
digitalWrite(HEATER_PWM, HIGH);
} else {
adc1 = adc;
}
}
if (!digitalRead(SW_UP)) {
if (!adc) {
digitalWrite(HEATER_PWM, HIGH);
} else {
adc2 = adc;
}
}
tft.setCursor(0, 18);
tft.print(t);
tft.println(" ");
tft.print(adc);
tft.println(" ");
tft.println(adc * adc_gain + adc_offset);
if (adc1 != 0 && adc2 != 0) {
adc_gain = DELTA_REF_T / (float)(adc2 - adc1);
adc_offset = REF_T1 - adc_gain * adc1;
tft.println(adc_gain);
tft.println(adc_offset);
}
delay(50);
}
EEPROM.update(EEPROM_OPTIONS, (fahrenheit << 2) | (bootheat << 1) | autopower);
EEPROM.update(EEPROM_VERSION, EE_VERSION);
EEPROM.update(EEPROM_INSTALL, EEPROM_CHECK);
EEPROM.put(EEPROM_ADCTTG, adc_gain);
EEPROM.put(EEPROM_ADCOFF, adc_offset);
tft.println("done.");
delay(1000);
asm volatile("jmp 0");
}
#endif
if (EEPROM.read(EEPROM_VERSION) != EE_VERSION) {
force_menu = true;
}
tft.fillScreen(BLACK);
uint8_t options = EEPROM.read(EEPROM_OPTIONS);
autopower = options & 1;
bootheat = options & 2;
fahrenheit = options & 4;
if (force_menu) {
optionMenu();
} else {
updateRevision();
tft.drawBitmap(0, 20, maiskolben, 160, 64, YELLOW);
tft.setCursor(20, 86);
tft.setTextColor(YELLOW);
tft.setTextSize(2);
tft.print("Maiskolben");
tft.setCursor(50, 110);
tft.setTextSize(1);
tft.print("Version ");
tft.print(VERSION);
tft.setCursor(46, 120);
tft.print("HW Revision ");
tft.print(revision);
//Allow Options to be set at startup
delay(100);
attachInterrupt(digitalPinToInterrupt(SW_STBY), optionMenu, LOW);
for (int i = 0; i < 10 && !menu_dismissed; i++) {
digitalWrite(HEAT_LED, i % 2);
delay(250);
}
detachInterrupt(digitalPinToInterrupt(SW_STBY));
}
/*
lower frequency = noisier tip
higher frequency = needs higher pwm
*/
//PWM Prescaler = 1024 31Hz
//TCCR2B = (TCCR2B & 0b11111000) | 7;
//PWM Prescaler = 256 122Hz
//TCCR2B = (TCCR2B & 0b11111000) | 6;
//PWM Prescaler = 128 245Hz
//TCCR2B = (TCCR2B & 0b11111000) | 5; // Orginal
//PWM Prescaler = 64 490Hz
//TCCR2B = (TCCR2B & 0b11111000) | 4;
//PWM Prescaler = 32 980Hz
//TCCR2B = (TCCR2B & 0b11111000) | 3;
//PWM Prescaler = 8 3.9kHz
//TCCR2B = (TCCR2B & 0b11111000) | 2
//PWM Prescaler = 1 31kHz - no Noise
TCCR2B = (TCCR2B & 0b11111000) | 1;
stby = EEPROM.read(1);
for (uint8_t i = 0; i < 3; i++) {
stored[i] = EEPROM.read(2 + i * 2) << 8;
stored[i] |= EEPROM.read(3 + i * 2);
}
set_t = EEPROM.read(EEPROM_SET_T) << 8;
set_t |= EEPROM.read(EEPROM_SET_T + 1);
for (uint8_t i = 0; i < 50; i++)
measureVoltage(); //measure average 50 times to get realistic results
tft.fillScreen(BLACK);
for (uint8_t i = 0; i <= 160; i++) { // Fix for remaining Corn-Bitmap
tft.drawFastVLine(i,0,128,BLACK);
}
last_measured = getTemperature();
Timer1.initialize(1000);
Timer1.attachInterrupt(timer_isr);
heaterPID.SetMode(AUTOMATIC);
sendNext = millis();
if (bootheat) {
threshold_counter = TEMP_UNDER_THRESHOLD;
setOff(false);
}
if (EEPROM.read(EEPROM_ADCTTG) == 255) { //Override unset values from older versions
EEPROM.put(EEPROM_ADCTTG, adc_gain);
EEPROM.put(EEPROM_ADCOFF, adc_offset);
}
EEPROM.get(EEPROM_ADCTTG, adc_gain);
EEPROM.get(EEPROM_ADCOFF, adc_offset);
}
void updateRevision(void) {
#if (HARDWARE_REVISION > 2)
EEPROM.update(EEPROM_REVISION, HARDWARE_REVISION);
revision = 3;
#else
if (EEPROM.read(EEPROM_VERSION) < 26 || EEPROM.read(EEPROM_REVISION) > 100) {
EEPROM.update(EEPROM_REVISION, 2);
revision = 2;
} else {
revision = EEPROM.read(EEPROM_REVISION);
}
#endif
}
void setDisplayMode(boolean bgr) {
// tft.colorSpace(bgr);
tft.setRotation(1); // 3
}
void optionMenu(void) {
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, (opt + 2) * 18);
tft.setTextColor(WHITE);
tft.print(">");
redraw = false;
}
if (!digitalRead(SW_UP)) {
tft.setCursor(0, (opt + 2) * 18);
tft.setTextColor(BLACK);
tft.print(">");
opt = (opt + options - 1) % options;
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;
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;
}
redraw = true;
}
if (!digitalRead(SW_T2)) {
switch (opt) {
case 0: autopower = 0; break;
case 1: bootheat = 0; break;
case 2: fahrenheit = 0; break;
}
redraw = true;
}
if (!digitalRead(SW_T3)) {
break;
}
}
EEPROM.update(EEPROM_OPTIONS, (fahrenheit << 2) | (bootheat << 1) | autopower);
updateRevision();
EEPROM.update(EEPROM_VERSION, EE_VERSION);
if (EEPROM.read(EEPROM_VERSION) < 30) {
EEPROM.put(EEPROM_ADCTTG, ADC_TO_TEMP_GAIN);
EEPROM.put(EEPROM_ADCOFF, ADC_TO_TEMP_OFFSET);
}
menu_dismissed = true;
}
void updateEEPROM(void) {
EEPROM.update(1, stby);
for (uint8_t i = 0; i < 3; i++) {
EEPROM.update(2 + i * 2, stored[i] >> 8);
EEPROM.update(3 + i * 2, stored[i] & 0xFF);
}
EEPROM.update(8, set_t >> 8);
EEPROM.update(9, set_t & 0xFF);
EEPROM.update(EEPROM_OPTIONS, (fahrenheit << 2) | (bootheat << 1) | autopower);
}
void powerDown(void) {
if (power_source != POWER_LIPO) {
power_down = false;
return;
}
//Timer1.stop();
setOff(true);
delay(10);
tft.fillScreen(BLACK);
tft.setTextSize(4);
tft.setTextColor(RED);
tft.setCursor(50, 40);
tft.print("OFF");
delay(3000);
SPI.end();
digitalWrite(POWER, LOW);
pinMode(POWER, OUTPUT);
delay(100);
force_redraw = true;
power_down = false;
Timer1.start(); //unsuccessful
}
float toFahrenheit(float t) {
return t * 1.8 + 32;
}
int getTemperature(void) {
analogRead(TEMP_SENSE);//Switch ADC MUX
uint16_t adc = median(TEMP_SENSE);
#ifdef TEST_ADC
Serial.println(adc);
#endif
if (adc >= 900) { //Illegal value, tip not plugged in - would be around 560deg
analogWrite(HEATER_PWM, 0);
if (!off) {
setError(NO_TIP);
return 999;
}
} else {
analogWrite(HEATER_PWM, pwm); //switch heater back to last value
}
//return round(adc < 210 ? (((float)adc) * 0.530805 + 38.9298) : (((float)adc) * 0.415375 + 64.6123)); //old conversion
return round(((float) adc) * adc_gain + adc_offset);
}
void measureVoltage(void) {
analogRead(BAT_C1); //Switch analog MUX before measuring
v_c1 = v_c1 * .9 + (analogRead(BAT_C1) * 5 / 1024.0) * .1; //no divisor
analogRead(BAT_C2);
v_c2 = v_c2 * .9 + (analogRead(BAT_C2) * 5 / 512.0) * .1; //divisor 1:1 -> /2
analogRead(BAT_C3);
v_c3 = v_c3 * .9 + (analogRead(BAT_C3) * (5.0 * 3.0) / 1024.0) * .1; //maximum measurable is ~15V
v = v_c3;
if (revision < 3) {
return;
}
#ifdef VIN
analogRead(VIN);
v_in = v_in * .9 + (analogRead(VIN) * 25 / 1024.0) * .1; //maximum measurable is ~24.5V
v = v_in; //backwards compatibility
#endif
}
uint16_t median(uint8_t analogIn) {
uint16_t adcValue[3];
for (uint8_t i = 0; i < 3; i++) {
adcValue[i] = analogRead(analogIn); // read the input 3 times
}
uint16_t tmp;
if (adcValue[0] > adcValue[1]) {
tmp = adcValue[0];
adcValue[0] = adcValue[1];
adcValue[1] = tmp;
}
if (adcValue[1] > adcValue[2]) {
tmp = adcValue[1];
adcValue[1] = adcValue[2];
adcValue[2] = tmp;
}
if (adcValue[0] > adcValue[1]) {
tmp = adcValue[0];
adcValue[0] = adcValue[1];
adcValue[1] = tmp;
}
return adcValue[1];
}
void timer_sw_poll(void) {
if (power_down) {
return;
}
if (!digitalRead(SW_STBY)) {
if (cnt_off_press == 100) {
setOff(!off);
}
if (cnt_off_press == 200 && power_source == POWER_LIPO) {
setOff(true);
power_down = true;
return;
}
cnt_off_press = min(201, cnt_off_press + 1);
} else {
if (cnt_off_press > 0 && cnt_off_press <= 100) {
setStandby(!stby);
}
cnt_off_press = 0;
}
boolean t1 = !digitalRead(SW_T1);
boolean t2 = !digitalRead(SW_T2);
boolean t3 = !digitalRead(SW_T3);
//simultanious push of multiple buttons
if (t1 + t2 + t3 > 1) {
store_to = 255;
store_invalid = true;
} else if (error != NO_ERROR) {
if (!(t1 | t2 | t3)) {
store_invalid = false;
} else if (!store_invalid && t3) {
error = NO_ERROR; //dismiss
set_t_old = 0; //refresh set_t display
store_invalid = true; //wait for release
}
} else {
//all buttons released
if (!(t1 | t2 | t3)) {
if (store_to != 255) {
if (cnt_but_store <= 100) {
set_t = stored[store_to];
setStandby(false);
updateEEPROM();
}
}
store_to = 255;
store_invalid = false;
cnt_but_store = 0;
} else
//one button pressed
if (!store_invalid) {
store_to = t2 + 2 * t3;
if (cnt_but_store > 100) {
if (set_t != stored[store_to] && !stby) {
stored[store_to] = set_t;
cnt_but_store = 100;
updateEEPROM();
}
}
cnt_but_store++;
}
}
boolean sw_up = !digitalRead(SW_UP);
boolean sw_down = !digitalRead(SW_DOWN);
boolean sw_changed = (sw_up != sw_up_old) || (sw_down != sw_down_old);
sw_up_old = sw_up;
sw_down_old = sw_down;
if ((sw_up && sw_down) || !(sw_up || sw_down)) {
cnt_but_press = 0;
return;
}
if (sw_up || sw_down) {
cnt_but_press++;
if ((cnt_but_press >= 100) || sw_changed) {
setStandby(false);
if (sw_up && set_t < TEMP_MAX) {
set_t++;
}
else if (sw_down && set_t > TEMP_MIN) {
set_t--;
}
if (!sw_changed) {
cnt_but_press = 97;
}
updateEEPROM();
}
}
}
void setStandby(boolean state) {
if (stby_layoff) {
return;
}
if (state == stby) {
return;
}
stby = state;
last_measured = cur_t;
last_temperature_drop = millis();
last_on_state = millis() / 1000;
EEPROM.update(1, stby);
}
void setStandbyLayoff(boolean state) {
if (state == stby_layoff) {
return;
}
stby_layoff = state;
stby = false;
last_measured = cur_t;
last_on_state = millis() / 1000;
}
void setOff(boolean state) {
if (state == off) {
return;
}
if (!state) {
analogWrite(HEATER_PWM, 0);
} else {
setStandby(false);
}
if (power_source == POWER_USB && !state) {
state = true; //don't switch on, if powered via USB
setError(USB_ONLY);
}
last_on_state = millis() / 1000;
off = state;
wasOff = true;
last_measured = cur_t;
}
void printTemp(float t) {
if (fahrenheit) {
t = toFahrenheit(t);
}
if (t < 100) {
tft.write(' ');
}
tft.print((int)t);
}
void display(void) {
if (force_redraw) {
tft.fillScreen(BLACK);
}
int16_t temperature = cur_t; //buffer volatile value
boolean yell = stby || (stby_layoff && blink);
tft.drawCircle(20, 63, 8, off ? RED : yell ? YELLOW : GREEN);
tft.drawCircle(20, 63, 7, off ? RED : yell ? YELLOW : GREEN);
tft.fillRect(19, 55, 3, 3, BLACK);
tft.drawFastVLine(20, 53, 10, off ? RED : yell ? YELLOW : GREEN);
if (error != NO_ERROR) {
if (error != error_old || force_redraw) {
error_old = error;
tft.setTextSize(1);
tft.setTextColor(RED, BLACK);
tft.setCursor(0, 96);
switch (error) {
case EXCESSIVE_FALL:
tft.print(F("Error: Temperature dropped\nTip slipped out?"));
break;
case NOT_HEATING:
tft.print(F("Error: Not heating\nWeak power source or short"));
break;
case BATTERY_LOW:
tft.print(F("Error: Battery low\nReplace or charge"));
break;
case USB_ONLY:
tft.print(F("Error: Power too low\nConnect power >5V"));
break;
case NO_TIP:
tft.print(F("Error: No tip connected\nTip slipped out?"));
break;
}
tft.setTextSize(2);
tft.setTextColor(YELLOW, BLACK);
tft.setCursor(10, 112);
tft.print(F(" OK "));
tft.setTextColor(RED, BLACK);
tft.setCursor(36, 26);
tft.setTextSize(3);
tft.print(F(" ERR "));
}
} else {
if (error != error_old || force_redraw) {
tft.fillRect(0, 96, 160, 16, BLACK);
error_old = NO_ERROR;
}
tft.setTextSize(2);
tft.setCursor(15, 112);
tft.setTextColor(WHITE, BLACK);
printTemp(stored[0]);
tft.write(' ');
printTemp(stored[1]);
tft.write(' ');
printTemp(stored[2]);
if (set_t_old != set_t || old_stby != (stby || stby_layoff) || force_redraw) {
tft.setCursor(36, 26);
tft.setTextSize(3);
if (stby || stby_layoff) {
old_stby = true;
tft.setTextColor(YELLOW, BLACK);
tft.print(F("STBY "));
} else {
old_stby = false;
set_t_old = set_t;
tft.setTextColor(WHITE, BLACK);
tft.write(' ');
printTemp(set_t);
tft.write(247);
tft.write(fahrenheit ? 'F' : 'C');
tft.fillTriangle(149, 50, 159, 50, 154, 38, (set_t < TEMP_MAX) ? WHITE : GRAY);
tft.fillTriangle(149, 77, 159, 77, 154, 90, (set_t > TEMP_MIN) ? WHITE : GRAY);
}
}
if (!off) {
#ifdef SHUTOFF_ACTIVE
if (autopower) {
int16_t tout;
if (stby || stby_layoff) {
tout = min(max(0, (last_on_state + OFF_TIMEOUT - (millis()) / 1000)), OFF_TIMEOUT);
} else {
tout = min(max(0, (last_temperature_drop + STANDBY_TIMEOUT - (millis()) / 1000)), STANDBY_TIMEOUT);
}
tft.setTextColor(stby ? RED : YELLOW, BLACK);
tft.setTextSize(2);
tft.setCursor(46, 78);
if (tout < 600) {
tft.write('0');
}
tft.print(tout / 60);
tft.write(':');
if (tout % 60 < 10) {
tft.write('0');
}
tft.print(tout % 60);
}
#endif
} else if (temperature != 999) {
tft.fillRect(46, 78, 60, 20, BLACK);
}
}
if (cur_t_old != temperature || force_redraw) {
tft.setCursor(36, 52);
tft.setTextSize(3);
if (temperature == 999) {
tft.setTextColor(RED, BLACK);
tft.print(F(" ERR "));
tft.setCursor(44, 76);
tft.setTextSize(2);
tft.print(F("NO TIP"));
} else {
if (cur_t_old == 999) {
tft.fillRect(44, 76, 72, 16, BLACK);
}
tft.setTextColor(off ? temperature < TEMP_COLD ? CYAN : RED : tft.Color565(min(10, abs(temperature - target_t)) * 25, 250 - min(10, max(0, (abs(temperature - target_t) - 10))) * 25, 0), BLACK);
if (temperature < TEMP_COLD) {
tft.print(F("COLD "));
} else {
tft.write(' ');
printTemp(temperature);
tft.write(247);
tft.write(fahrenheit ? 'F' : 'C');
}
}
if (temperature < cur_t_old) {
tft.fillRect(max(0, (temperature - TEMP_COLD) / 2.4), 0, 160 - max(0, (temperature - TEMP_COLD) / 2.4), BAR_HEIGHT, BLACK);
} else if (cur_t != 999) {
for (int16_t i = max(0, (cur_t_old - TEMP_COLD) / 2.4); i < max(0, (temperature - TEMP_COLD) / 2.4); i++) {
tft.drawFastVLine(i, 0, BAR_HEIGHT, tft.Color565(min(255, max(0, i * 5)), min(255, max(0, 450 - i * 2.5)), 0));
}
}
cur_t_old = temperature;
}
if (v_c3 > 1.0) {
tft.setTextColor(YELLOW, BLACK);
tft.setCursor(122, 5);
tft.setTextSize(2);
int power = min(15, v) * min(15, v) / 4.8 * pwm / 255;
if (power < 10) {
tft.write(' ');
}
tft.print(power);
tft.write('W');
if (v < 5.0) {
power_source = POWER_USB;
} else if (v_c2 < 1.0) {
power_source = POWER_CORD;
} else {
power_source = POWER_LIPO; //Set charging later to not redraw if charging mode toggles
}
if (power_source != power_source_old || force_redraw) {
tft.fillRect(0, 5, 128, 20, BLACK);
tft.fillRect(11, 25, 21, 20, BLACK);
switch (power_source) {
case POWER_CHARGING:
case POWER_LIPO:
for (uint8_t i = 0; i < 3; i++) {
tft.drawRect(11, 5 + i * 14, 20, 12, WHITE);
//tft.fillRect(12, 6+i*14, 18, 10, BLACK);
tft.drawFastVLine(31, 8 + i * 14, 6, WHITE);
}
break;
case POWER_USB:
tft.setTextSize(1);
tft.setTextColor(RED, BLACK);
tft.setCursor(0, 5);
tft.print("USB power only\nConnect power supply.");
if (!off) {
setError(USB_ONLY);
}
break;
}
power_source_old = power_source;
}
if (power_source == POWER_CORD) {
/*if (v > v_c3) {
tft.setTextSize(2);
tft.setTextColor(GREEN, BLACK);
tft.setCursor(0,5);
tft.print(v);
tft.print("V ");
} else {*/
tft.drawBitmap(0, 5, power_cord, 24, 9, tft.Color565(max(0, min(255, (14.5 - v) * 112)), max(0, min(255, (v - 11) * 112)), 0));
//}
} else if (power_source == POWER_LIPO || power_source == POWER_CHARGING) {
float volt[] = {v_c1, v_c2 - v_c1, v_c3 - v_c2};
uint8_t volt_disp[] = {max(1, min(16, (volt[0] - 3.0) * 14.2)), max(1, min(16, (volt[1] - 3.0) * 14.2)), max(1, min(16, (volt[2] - 3.0) * 14.2))};
if (power_source == POWER_CHARGING) {
uint8_t p = min(16, (millis() / 100) % 20);
for (uint8_t i = 0; i < 3; i++) {
volt_disp[i] = max(0, min(volt_disp[i], p));
}
}
for (uint8_t i = 0; i < 3; i++) {
if (volt[i] < 3.20) {
setError(BATTERY_LOW);
tft.fillRect(13, 7 + 14 * i, volt_disp[i], 8, blink ? RED : BLACK);
} else {
tft.fillRect(13, 7 + 14 * i, volt_disp[i], 8, tft.Color565(250 - min(250, max(0, (volt[i] - 3.4) * 1000.0)), max(0, min(250, (volt[i] - 3.15) * 1000.0)), 0));
}
tft.fillRect(13 + volt_disp[i], 7 + 14 * i, 17 - volt_disp[i], 8, BLACK);
}
}
}
#ifdef SHUTOFF_ACTIVE
if (autopower) {
if (!stby_layoff) {
if (pwm > max(20, (cur_t - 150) / 50 * round(25 - min(15, v))) + 5) {
//if (target_t-cur_t > 0.715*exp(0.0077*target_t)) {
//if (cur_t / (double)target_t < STANDBY_TEMPERATURE_DROP) {
if (autopower_repeat_under || stby) {
if (stby && !wasOff) {
setStandby(false);
} else {
last_temperature_drop = millis() / 1000;
}
}
autopower_repeat_under = true;
} else if (wasOff) {
wasOff = false;
} else {
autopower_repeat_under = false; //over the max pwm for at least two times
}
}
if (!off && !stby && millis() / 1000 > (last_temperature_drop + STANDBY_TIMEOUT)) {
setStandby(true);
}
if (!off && (stby || stby_layoff) && millis() / 1000 > (last_on_state + OFF_TIMEOUT)) {
setOff(true);
}
}
#endif
blink = !blink;
force_redraw = false;
}
void compute(void) {
#ifndef USE_TFT_RESET
setStandbyLayoff(!digitalRead(STBY_NO)); //do not measure while heater is active, potential is not neccessary == GND
#endif
cur_t = getTemperature();
if (off) {
target_t = 0;
if (cur_t < adc_offset + TEMP_RISE) {
threshold_counter = TEMP_UNDER_THRESHOLD; //reset counter
}
} else {
if (stby_layoff || stby) {
target_t = TEMP_STBY;
} else {
target_t = set_t;
}
if (cur_t - last_measured <= -30 && last_measured != 999) {
setError(EXCESSIVE_FALL); //decrease of more than 30 degree is uncommon, short of ring and gnd is possible.
}
if (cur_t < adc_offset + TEMP_RISE) {
if (threshold_counter == 0) {
setError(NOT_HEATING); //temperature is not reached in desired time, short of sensor and gnd too?
} else {
threshold_counter--;
}
} else {
threshold_counter = THRES_MAX_DECEED; //reset counter to a smaller value to allow small oscillation of temperature
}
}
set_td = target_t;
cur_td = cur_t;
last_measured = cur_t;
heaterPID.Compute();
if (error != NO_ERROR || off) {
pwm = 0;
} else {
pwm = min(255, pid_val * 255);
}
analogWrite(HEATER_PWM, pwm);
}
void timer_isr(void) {
if (cnt_compute >= TIME_COMPUTE_IN_MS) {
analogWrite(HEATER_PWM, 0); //switch off heater to let the low pass settle
if (cnt_compute >= TIME_COMPUTE_IN_MS + DELAY_BEFORE_MEASURE) {
compute();
cnt_compute = 0;
}
}
cnt_compute++;
if (cnt_sw_poll >= TIME_SW_POLL_IN_MS) {
timer_sw_poll();
cnt_sw_poll = 0;
}
cnt_sw_poll++;
if (cnt_measure_voltage >= TIME_MEASURE_VOLTAGE_IN_MS) {
measureVoltage();
cnt_measure_voltage = 0;
}
cnt_measure_voltage++;
}
void setError(error_type e) {
error = e;
setOff(true);
}
uint16_t serialReadTemp(void) {
uint16_t t;
uint8_t n;
n = Serial.read() - '0';
t = min(9, max(0, n)) * 100;
n = Serial.read() - '0';
t += min(9, max(0, n)) * 10;
n = Serial.read() - '0';
t += min(9, max(0, n)) * 1;
return t;
}
void loop(void) {
analogWrite(HEAT_LED, pwm);
//Switch to following if the oscillation of the led bothers you
//digitalWrite(HEAT_LED, cur_t+5 < target || (abs((int16_t)cur_t-(int16_t)target) <= 5 && (millis()/(stby?1000:500))%2));
if (sendNext <= millis()) {
sendNext += 100;
#ifndef TEST_ADC
Serial.print(stored[0]);
Serial.print(";");
Serial.print(stored[1]);
Serial.print(";");
Serial.print(stored[2]);
Serial.print(";");
Serial.print(off ? 0 : 1);
Serial.print(";");
Serial.print(error);
Serial.print(";");
Serial.print(stby ? 1 : 0);
Serial.print(";");
Serial.print(stby_layoff ? 1 : 0);
Serial.print(";");
Serial.print(set_t);
Serial.print(";");
Serial.print(cur_t);
Serial.print(";");
Serial.print(pid_val);
Serial.print(";");
Serial.print(v_c2 > 1.0 ? v_c1 : 0.0);
Serial.print(";");
Serial.print(v_c2);
Serial.print(";");
Serial.println(v);
#endif
Serial.flush();
display();
}
if (Serial.available()) {
uint16_t t = 0;
switch (Serial.read()) {
//Set new Temperature (eg. S350 to set to 350C)
case 'T':
if (Serial.available() >= 3) {
t = serialReadTemp();
//Serial.println(t);
if (t <= TEMP_MAX && t >= TEMP_MIN) {
set_t = t;
updateEEPROM();
}
}
break;
//Store new Preset (eg. P1200 to store 200C to Preset 1, NOT 0 indexed)
case 'P':
if (Serial.available() >= 4) {
uint8_t slot = Serial.read() - '1';
if (slot < 3) {
t = serialReadTemp();
if (t <= TEMP_MAX && t >= TEMP_MIN) {
stored[slot] = t;
updateEEPROM();
}
}
}
break;
//Clear errors
case 'C':
error = NO_ERROR;
break;
//Set standby
case 'S':
setStandby(Serial.read() == '1');
break;
//Set on/off
case 'O':
setOff(Serial.read() == '0');
break;
}
}
delay(DELAY_MAIN_LOOP);
if (power_down) {
powerDown();
}
}
Reference in a new issue View git blame Copy permalink