diagram.json

// smooth algorytm for ADC reading
uint16_t digitalSmooth(uint16_t rawIn, uint16_t *sensSmoothArray){     // "int *sensSmoothArray" passes an array to the function - the asterisk indicates the array name is a pointer
  uint16_t j, k, temp, top, bottom;
  unsigned long total;
  static int i;
  static uint16_t strtod[filterSamples];
  boolean done;

  i = (i + 1) % filterSamples;    // increment counter and roll over if necc. -  % (modulo operator) rolls over variable
  sensSmoothArray[i] = rawIn;                 // input new data into the oldest slot

  for (j=0; j<filterSamples; j++){     // transfer data array into anther array for sorting and averaging
    strtod[j] = sensSmoothArray[j];
  }

  done = 0;                // flag to know when we're done sorting              
  while(done != 1){        // simple swap sort, sorts numbers from lowest to highest
    done = 1;
    for (j = 0; j < (filterSamples - 1); j++){
      if (strtod[j] > strtod[j + 1]){     // numbers are out of order - swap
        temp = strtod[j + 1];
        strtod [j+1] =  strtod[j] ;
        strtod [j] = temp;
        done = 0;
      }
    }
  }

  // throw out top and bottom 15% of samples - limit to throw out at least one from top and bottom
  bottom = max(((filterSamples * 15)  / 100), 1); 
  top = min((((filterSamples * 85) / 100) + 1  ), (filterSamples - 1));   // the + 1 is to make up for asymmetry caused by integer rounding
  k = 0;
  total = 0;
  for ( j = bottom; j< top; j++){
    total += strtod[j];  // total remaining indices
    k++; 
  }

  return total / k;    // divide by number of samples
}

adc.ino

#define MENU_ITEMS	9

void configureParams(){
	#ifdef DEBUG
	Serial.println(F("Enter Config"));
	#endif
	uint8_t item = 1;
//	int value = pid_P;	// print first parameter value
	boolean edit = false;
	printConfParam(item, edit); 

	waitUntilButtonReleased();
	
	// wait for encoder
	char encVal = 0;  // signed value - nothing is pressed
	while (1) {
		encVal = rotaryEncRead();
		if(encVal!=0 && encVal!=127) {
			if(!edit){
				item=constrain(item + encVal,1, MENU_ITEMS);
			} else {
				// adjust selected value
				switch (item) {
					case 1:
						pid_P = constrain(pid_P+encVal*10,0,990);
						break;
					case 2:
						pid_I = constrain(pid_I+encVal,0,100);
						break;
					case 3:
						pid_D = constrain(pid_D+encVal*10,0,990);
						break;
					case 4:	// Preheat temperature
						auto_preheatTemp = constrain(auto_preheatTemp+encVal,20,300);
						break;
					case 5: // Preheat time in seconds or minutes
						auto_preheatTime = constrain(auto_preheatTime+encVal*10,10,990);
						break;
					case 6: // Reflow temperature
						auto_reflowTemp = constrain(auto_reflowTemp+encVal,20,300);
						break;
					case 7: // Reflow time in seconds or minutes
						auto_reflowTime = constrain(auto_reflowTime+encVal*10,10,990);
						break;
					case 8: // Manual temperature
						manual_temp = constrain(manual_temp+encVal*10,20,300);
						break;
				} 
			}
		}
		if(encVal==127){ // button is pressed
			if(item==MENU_ITEMS){
				printSavingSettings();
				store_settingsEEPROM();
				#ifdef DEBUG
				Serial.println(F("Exit Config"));
				#endif
				while(1){}	// reboot board
			}
			// switch edit mode
			edit=!edit;
			waitUntilButtonReleased();
		}
		WDT_Init();
		printConfParam(item, edit);
	}
}

void printSavingSettings(){
	#ifdef OLED
	u8g2.clearBuffer();
	u8g2.setCursor(0, 24);
	u8g2.print(F("Saving..."));
	u8g2.sendBuffer();
	#endif
	
}

// item - number of configurable item
// edit - if TRUE, then highlight the edited value
void printConfParam(uint8_t item, boolean edit){
	#ifdef OLED
	u8g2.clearBuffer();
	u8g2.setDrawColor(2);	//inverse mode
	if(edit && item != MENU_ITEMS){
		u8g2.drawBox(95,6,128-95,32-5*2);
	}
	u8g2.setCursor(0, 24);
	switch (item) {
		case 1:
			u8g2.print(F("PID P"));
			break;
		case 2:
			u8g2.print(F("PID I"));
			break;
		case 3:
			u8g2.print(F("PID D"));
			break;
		case 4:	// Preheat temperature
			u8g2.print(F("Soak t"));
			break;
		case 5: // Preheat time in seconds
      #ifdef TIMER_MINUTES
        u8g2.print(F("Soak m"));
      #else
        u8g2.print(F("Soak s"));
      #endif
			break;
		case 6: // Reflow temperature
			u8g2.print(F("Reflow t"));
			break;
		case 7: // Reflow time in seconds
      #ifdef TIMER_MINUTES
  			u8g2.print(F("Reflow m"));
      #else
        u8g2.print(F("Reflow s"));
      #endif
			break;
		case 8: // Manual target temperature
			u8g2.print(F("Manual t"));
			break;
		case 9: // Save settings and exit
			u8g2.print(F("Save & Exit"));
			break;
	} 
	if(item!=MENU_ITEMS){
		u8g2.setCursor(95, 24);
		u8g2.print(getValueForConfigItem(item));
	}
	u8g2.sendBuffer();
	#endif
	#ifdef DEBUG
	Serial.println(F("Change Config"));
	Serial.print(F("item: "));Serial.println(item);
	Serial.print(F("value: "));Serial.println(getValueForConfigItem(item));
	Serial.print(F("edit: "));Serial.println(edit);
	#endif
	
}

uint16_t getValueForConfigItem(uint8_t item) {
	switch (item) {
		case 1:
			return pid_P;
			break;
		case 2:
			return pid_I;
			break;
		case 3:
			return pid_D;
			break;
		case 4:	// Preheat temperature
			return auto_preheatTemp;
			break;
		case 5: // Preheat time in seconds
			return auto_preheatTime;
			break;
		case 6: // Reflow temperature
			return auto_reflowTemp;
			break;
		case 7: // Reflow time in seconds
			return auto_reflowTime;
			break;
		case 8: // Manual target temperature
			return manual_temp;
	} 
}


config.ino

void restore_settingsEEPROM(){
	pid_P = constrain(readEEPROMint(EEPROM_PID_P),0,990);
	pid_I = constrain(readEEPROMint(EEPROM_PID_I),0,100);
	pid_D = constrain(readEEPROMint(EEPROM_PID_D),0,990);
	manual_temp = constrain(readEEPROMint(EEPROM_MANUAL_TEMP),20,300);
	auto_preheatTemp = constrain(readEEPROMint(EEPROM_AUTO_PREHEAT_TEMP),20,300);
	auto_preheatTime = constrain(readEEPROMint(EEPROM_AUTO_PREHEAT_TIME),10,990);
	auto_reflowTemp = constrain(readEEPROMint(EEPROM_AUTO_REFLOW_TEMP),20,300);
	auto_reflowTime = constrain(readEEPROMint(EEPROM_AUTO_REFLOW_TIME),10,990);
	ControlType = constrain(EEPROM.read(EEPROM_CONTROLTYPE), 0, 1);

	#ifdef DEBUG
		Serial.println(F("Restore EEPROM Settings"));
		Serial.print(F("pid_P: "));Serial.println(pid_P);
		Serial.print(F("pid_I: "));Serial.println(pid_I);
		Serial.print(F("pid_D: "));Serial.println(pid_D);
		Serial.print(F("manual_temp: "));Serial.println(manual_temp);
		Serial.print(F("auto_preheatTemp: "));Serial.println(auto_preheatTemp);
		Serial.print(F("auto_preheatTime: "));Serial.println(auto_preheatTime);
		Serial.print(F("auto_reflowTemp: "));Serial.println(auto_reflowTemp);
		Serial.print(F("auto_reflowTime: "));Serial.println(auto_reflowTime);
		Serial.print(F("ControlType: "));Serial.println(ControlType);
	#endif
	
}

void store_settingsEEPROM(){
	#ifdef DEBUG
		Serial.println(F("Write EEPROM Settings"));
		Serial.print(F("pid_P: "));Serial.println(pid_P);
		Serial.print(F("pid_I: "));Serial.println(pid_I);
		Serial.print(F("pid_D: "));Serial.println(pid_D);
		Serial.print("manual_temp: ");Serial.println(manual_temp);
		Serial.print(F("auto_preheatTemp: "));Serial.println(auto_preheatTemp);
		Serial.print(F("auto_preheatTime: "));Serial.println(auto_preheatTime);
		Serial.print(F("auto_reflowTemp: "));Serial.println(auto_reflowTemp);
		Serial.print(F("auto_reflowTime: "));Serial.println(auto_reflowTime);
		//Serial.print("ControlType: ");Serial.println(ControlType);
	#endif

	writeEEPROMint(EEPROM_PID_P,pid_P);
	writeEEPROMint(EEPROM_PID_I,pid_I);
	writeEEPROMint(EEPROM_PID_D,pid_D);
	writeEEPROMint(EEPROM_MANUAL_TEMP,manual_temp);
	writeEEPROMint(EEPROM_AUTO_PREHEAT_TEMP,auto_preheatTemp);
	writeEEPROMint(EEPROM_AUTO_PREHEAT_TIME,auto_preheatTime);
	writeEEPROMint(EEPROM_AUTO_REFLOW_TEMP,auto_reflowTemp);
	writeEEPROMint(EEPROM_AUTO_REFLOW_TIME,auto_reflowTime);
	//EEPROM.update(EEPROM_CONTROLTYPE, ControlType); // don't need to write it while it written already
}

uint16_t readEEPROMint(uint8_t addr){
	return EEPROM.read(addr)+EEPROM.read(addr+1)*256;
}

void writeEEPROMint(uint8_t addr, uint16_t value){
	EEPROM.update(addr, lowByte(value));
	EEPROM.update(addr+1, highByte(value));
}



eeprom.ino

//*********************
// * HW CONFIGURATION *
//*********************
//#define DEBUG	// output the results to Serial

// Enable only one of the temperature sensors
//#define MAX31855
//#define MAX6675
#define NTC // using Temperature table

#define OLED	// Use OLED display
//#define VIRTUALTEMPERATURE	//For debug purposes, when temp sensor is disconnected
//#define SOFTRESET	// If your Arduino has broken bootloader (watchdog is not working) then enable this dirty trick or better - flash optiboot to your arduino.
//#define TIMER_MINUTES // Count in minutes/hours. If not defined then seconds/minutes
//*********************

#include "encoder.h"
#include "adc.h"
#include <PID_v2.h>
#include <EEPROM.h>
#include "eeprom.h"
#include <avr/wdt.h>

#ifdef OLED
	#include <U8g2lib.h>
	#include "oled.h"
#endif



#define MOSFET_PIN 		6
#define LED_PIN 		13
#define TEMPSENSOR_PIN 	A0

#define encoderPinA   3	// Interrupt pin (coupled with capacitor to GND)
#define encoderPinB   4 // Interrupt pin (coupled with capacitor to GND)
#define BUTTON_PIN   12 // Pin for knob button

#define FAN_PIN   2 // FAN for cooling stage


// RAMP can always be 3 deg per second

#ifdef TIMER_MINUTES
  #define TIMER_DIVIDER (uint16_t)(1000 * 60)
#else
  #define TIMER_DIVIDER 1000
#endif

// ADC=1023 - temp sensor is not connected

// some macros: 
// mosfet (HIGH - OFF, LOW - ON)
#define H_ON 	digitalWrite(MOSFET_PIN,HIGH);digitalWrite(LED_PIN, HIGH);
#define H_OFF 	digitalWrite(MOSFET_PIN,LOW);digitalWrite(LED_PIN, LOW);

uint8_t ControlType;		// 0 - Manual or 1 - Auto
//uint8_t ProcessStage;		// 0 - just hold manual temperature; 1 - Ramp to Preheat; 2 - Preheat; 3 - Ramp to Reflow; 4 - Reflow; 5 - Cool down; 255 - finished

// PID global variables
#define PID_WINDOWSIZE 500	// upper limit of PID output
#define PID_ABSTEMPDIFFERENCE 10	// Difference in set and current temperature when PID should not work.
#define PID_P_FACTOR 1.0	//PID values are stored in EEPROM in int format. So, scale them (div) before use.
#define PID_I_FACTOR 10.0	//PID values are stored in EEPROM in int format. So, scale them (div) before use.
#define PID_D_FACTOR 1.0	//PID values are stored in EEPROM in int format. So, scale them (div) before use.

double currentTemp=0;
double setPoint=0;
double outputVal;

int pid_P, pid_I, pid_D; // PID values
int auto_preheatTemp, auto_preheatTime, auto_reflowTemp, auto_reflowTime, manual_temp;

unsigned long soft_pwm_millis;

//input/output variables passed by reference, so they are updated automatically
PID myPID(&currentTemp, &outputVal, &setPoint, 0, 0, 0, DIRECT); // PID values will be set later

unsigned long timer_millis;
int timer_counter;
boolean timer_active=false;
uint8_t value_editable=0;	// Edit Preset temperature or Timer on the fly (0 - nothing editable, 1 - Preset Temp, 2 - Timer)
unsigned long value_editable_millis;


#ifdef DEBUG
	unsigned long serial_ms = 0;
#endif

#ifdef VIRTUALTEMPERATURE
	unsigned long virtualTemperature_ms = 0;
	boolean virtualTemperature_Direction = true;
#endif

void setup(){
	
	wdt_disable();
	pinMode(MOSFET_PIN,OUTPUT);
	pinMode(LED_PIN,OUTPUT);
  pinMode(FAN_PIN,OUTPUT);
  digitalWrite(FAN_PIN,LOW);
	H_OFF

	#ifdef DEBUG
		Serial.begin(115200);
	#endif
	
	#ifdef OLED
		u8g2.begin();
		u8g2.setDrawColor(2);	// Xor is default mode across all sketch.
		u8g2.setFontMode(1);	// Or is default mode
	#endif
	
	Temperature_init();
		
	#ifdef DEBUG
		Serial.print(F("Temperature Sensor: "));
		Serial.println(getTemperature());
	#endif
	
	// read PID values from EEPROM
	restore_settingsEEPROM();
	// we use FACTOR for PID values to get rid of comas in interface.
	myPID.SetTunings((float)pid_P / PID_P_FACTOR,(float)pid_I / PID_I_FACTOR,(float)pid_D / PID_D_FACTOR);
	myPID.SetOutputLimits(0, PID_WINDOWSIZE);	//set PID output range

	initEncoder();
		
	waitUntilButtonReleased(); // in case it was

	// main screen (choose Manual/Auto)
	#ifdef OLED
	drawMenu_AutoManual(ControlType);
	#endif
	#ifdef DEBUG
	Serial.print(F("ControlType is: "));Serial.println(ControlType);
	#endif
	char encVal = 0;  // signed value - nothing is pressed
	while (encVal != 127) {
		#ifdef OLED
		drawMenu_AutoManual(ControlType);
		#endif
		encVal = rotaryEncRead();
		if(encVal!=127 && encVal!=0) {
			if(encVal>0){ControlType=0;}else{ControlType=1;}
			#ifdef DEBUG
			Serial.print(F("ControlType is: "));Serial.println(ControlType);
			#endif
		}
		currentTemp = getTemperature();
	}
	EEPROM.update(EEPROM_CONTROLTYPE,ControlType);	// store selected Control Type for the next time
	#ifdef OLED
	u8g2.clearDisplay();
	#endif
	// wait until button released
	encoderLongPressmillis=millis();
	while(rotaryEncRead() == 127){
		if(is_rotaryEncLongPress()){
			// go to config menu
			configureParams();
			encoderLongPressmillis=millis();
		}
	}	

	if(ControlType==0){
		setPoint=manual_temp;	// last saved temperature.
		#ifdef DEBUG
		Serial.println(F("Start Manual mode"));
		#endif
	}else{
		setPoint=auto_preheatTemp;
		#ifdef DEBUG
		Serial.println(F("Start Automatic mode"));
		#endif
	}

	timer_counter=0;
	timer_active=false;

	myPID.SetMode(AUTOMATIC); // turn on PID
	
	
	#ifdef VIRTUALTEMPERATURE
		currentTemp=setPoint-PID_ABSTEMPDIFFERENCE*2;
	#endif
	
	soft_pwm_millis = millis()-50000;	// Before turning on the heater wait for some seconds
		
}

void loop() {
	
	// Exit by holding button for 2 seconds...
	WDT_Init();	// keep system alive
	
	#ifdef VIRTUALTEMPERATURE
	if (virtualTemperature_ms+TIMER_DIVIDER < millis()) {
		virtualTemperature_ms = millis();
		currentTemp += (virtualTemperature_Direction ? 0.4: -0.4);
		if(virtualTemperature_Direction && currentTemp>setPoint+PID_ABSTEMPDIFFERENCE){virtualTemperature_Direction=false;}
		if(!virtualTemperature_Direction && currentTemp<setPoint-PID_ABSTEMPDIFFERENCE-1){virtualTemperature_Direction=true;}
	}
	#else
	currentTemp = getTemperature();
	#endif

	
	// use PID only when difference is small (to prevent windup of I)
	if(abs(setPoint-currentTemp)<PID_ABSTEMPDIFFERENCE){
		myPID.Compute();
	}else{
		outputVal = (setPoint > currentTemp ? PID_WINDOWSIZE : 0); // ON/OFF control
	}
	doSoftwarePWM((uint16_t)outputVal);	// make slow PWM to prevent unnecessary mosfet heating 

	if(ControlType==0){
		adjustValues(1);	//adjust values on the fly (only preset temp to adjust)
		doManualReflow();
	}else{
		adjustValues(2);	//adjust values on the fly (adjust both, preset temp and timer)
		doAutoReflow();
	}
	
	// debug 
	#ifdef DEBUG
	if (serial_ms+1000 < millis()) {
		serial_ms = millis();
		Serial.print(F("Set: "));Serial.print(setPoint);
		Serial.print(F(", Actual: "));Serial.print(currentTemp);
		Serial.print(F(", PWM: "));Serial.print(outputVal);
		Serial.print(F(", Timer: "));Serial.println(timer_counter);
	}	
	#endif	
	
	// increment or decrement timer
	if(timer_millis+TIMER_DIVIDER<millis()) {
		uint16_t seconds_passed=(uint16_t)((unsigned long)(millis()-timer_millis)/TIMER_DIVIDER);
		timer_millis=millis();
		if(timer_active){timer_counter+=(ControlType==0 ? seconds_passed : -seconds_passed);} // increment only in manual mode.
	}

}


// PWM output 
void doSoftwarePWM(uint16_t pwm_val){
	if (millis() - soft_pwm_millis > PID_WINDOWSIZE)
	  { //time to shift the Relay Window
		soft_pwm_millis += PID_WINDOWSIZE;
	  }
	if (pwm_val < millis() - soft_pwm_millis){H_OFF}else{H_ON}
		
}

void doManualReflow(){
	// draw screen
	#if defined (OLED)
	u8g2.clearBuffer();
	printManual();

	if(value_editable==1){
		u8g2.drawBox(46,0,33,10);
	}

	printPresetTemperature();
	printTime(timer_counter);
	printCurrentTemperature();

	inlineLogger_fill();
	inlineLogger_draw();
		
	printHeaterState(); //print icon of the heater ON/OFF state

	u8g2.sendBuffer();
	#endif
	
	if(currentTemp>=(setPoint-2)){timer_active=true;} else {timer_active=false;}	// Timer running if temperature near or reached preset temp.
}

void doAutoReflow(){
	// process current step (variable ControlType)
	switch (ControlType) {
		case 1:	// ramp to preheat temperature
			// setpoint is already set...
			// wait until temperature is reached the auto_preheatTemp. Then go to the next step
			if(currentTemp>=(setPoint-2)){
				timer_counter=auto_preheatTime;
				timer_active=true;
				timer_millis = millis(); // reset timer
				ControlType=2;	// go to the next step
			}
			break;
		case 2:	// wait for timer
			if(timer_counter<=0){
				timer_counter=0;
				timer_active=false;
				setPoint=auto_reflowTemp;	// set temperature for next step
				ControlType=3;	// go to the next step
			}
			break;
		case 3:	// ramp to reflow temperature
			// wait until temperature is reached the auto_preheatTemp. Then go to the next step
			if(currentTemp>=(setPoint-2)){
				timer_counter=auto_reflowTime;
				timer_active=true;
				timer_millis = millis(); // reset timer
				ControlType=4;	// go to the next step
			}
			break;
		case 4:	// wait for timer
			if(timer_counter<=0){
				timer_counter=0;
				timer_active=false;
				setPoint=20;	// Cool down
				digitalWrite(FAN_PIN,HIGH);
				ControlType=5;	// go to the next step
			}
			break;
		case 5:	// wait for cooling down
			if(currentTemp<50){
				//ControlType=6; // on the next step do nothing
				digitalWrite(FAN_PIN,LOW);
				while(1){}	// reboot board - exit to menu
			}	
	}	

	#ifdef OLED
	u8g2.clearBuffer();
	printAuto();
	if(value_editable==1){
		u8g2.drawBox(46,0,33,10);
	}else if(value_editable==2){
		u8g2.drawBox(85,0,33,10);
	}
	printPresetTemperature();
	printTime(timer_counter);
	printCurrentTemperature();
	printHeaterState(); //print icon of the heater ON/OFF state
	
	printStepTextGraphic();

	u8g2.sendBuffer();
	#endif
}

void adjustValues(uint8_t vals) {
	int val_adjust=0;	// for adjusting temperature or time on the fly
	char encVal = 127;  // signed value - just enter to the loop
	while (encVal == 127) { //loop here while button is pressed (waiting longer than 2 seconds will reset the board (Exit to the init menu).
		encVal = rotaryEncRead();
		if(encVal!=127 && value_editable>0) {
			val_adjust = encVal;
		}else if(encVal==127){
			H_OFF	// turn off heater, because we will freeze here for some time...
			waitUntilButtonReleased();
			value_editable++;	// change edit mode
			if(value_editable>vals){value_editable=0;}
			value_editable_millis=millis();		// start timer for edit time within 3 seconds
		}
	}
	// adjust current temperature or timer
	if(val_adjust!=0 && ControlType<5){
		val_adjust*=10; // adjust in 10's steps
		if(value_editable==2){
			timer_counter=constrain(timer_counter+val_adjust,0,990);
		}else if(value_editable==1){
			setPoint=constrain((int)setPoint+val_adjust,20,300);
		}
		value_editable_millis=millis();
	}
	// reset timer_editable flag if edit time expired
	if(value_editable>0 && value_editable_millis+3000<millis()) {value_editable=0;}
}	


HeaterControlV2.ino

#define LOGGER_XPOS 127-68
#define LOGGER_YPOS 31-10	// center


//9X5
static const uint8_t u8g_plus10_bits[] U8X8_PROGMEM = { 0xD0, 0x01, 0x52, 0x01, 0x57, 0x01, 0x52, 0x01, 0xD0, 0x01, };
//9X5
static const uint8_t u8g_minus10_bits[] U8X8_PROGMEM = { 0xD0, 0x01, 0x50, 0x01, 0x57, 0x01, 0x50, 0x01, 0xD0, 0x01, };

unsigned long loggerMillis=millis();
byte logvalues[60];	// 60 elements (-127:+127)
byte loggerXcoord=0;

	
void inlineLogger_fill(){
	if(loggerMillis+1000<millis()){	// step every 2 seconds
		loggerMillis=millis();
		int curTmp = round(currentTemp);
		int setPnt = setPoint;

		int tempDiff = abs(curTmp-setPnt);
		if (tempDiff>10 || loggerXcoord>59){
			clearLogArray();
			loggerXcoord=0;
		} else {
			logvalues[loggerXcoord]=curTmp-setPnt;
		}
		loggerXcoord++;
	}
}

void inlineLogger_draw(){
	#ifdef OLED
	u8g2.setDrawColor(1);
	// draw dots in middle of 128x32 OLED
	for(uint8_t i=0;i<60;i+=4){
		u8g2.drawPixel(LOGGER_XPOS+i,LOGGER_YPOS);
	}
	u8g2.drawXBMP(127-9, LOGGER_YPOS-3-5, 9, 5, u8g_plus10_bits);
	u8g2.drawXBMP(127-9, LOGGER_YPOS+3, 9, 5, u8g_minus10_bits);
	for(uint8_t i=0;i<60;i++){
		byte tmpVal=logvalues[i];
		if(tmpVal!=127){
			u8g2.drawPixel(LOGGER_XPOS+i,LOGGER_YPOS-tmpVal);
		}
	}
	u8g2.setDrawColor(2); //restore mode
	#endif
}

void clearLogArray(){
	for(uint8_t i=0;i<60;i++){
		logvalues[i]=127;
	}
}



logger.ino

#ifdef OLED
//8X10
static const uint8_t u8g_clear_bits[] U8X8_PROGMEM = {
	0b00000000,
	0b00000000,
	0b00000000,
	0b00000000,
	0b00000000,
	0b00000000,
	0b00000000,
	0b00000000,
	0b00000000,
	0b00000000
};
//8X10
static const uint8_t u8g_heating_bits[] U8X8_PROGMEM = {
	0b01001000,
	0b00100100,
	0b00100100,
	0b01001000,
	0b10010000,
	0b10010000,
	0b01001000,
	0b00100100,
	0b00000000,
	0b11111110
};

//40x10 (manual)
static const uint8_t u8g_manual_bits[] U8X8_PROGMEM = {
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0xFF, 0xFF, 
  0xFF, 0xFF, 0xEF, 0x03, 0x8E, 0xE3, 0x36, 0xEE, 0xDB, 0x7E, 0xDB, 0xF6, 
  0xED, 0xDB, 0x0E, 0xDB, 0x36, 0xEC, 0xDB, 0x76, 0xDB, 0xD6, 0xED, 0xDB, 
  0x76, 0xDB, 0xD6, 0xED, 0xDB, 0x0E, 0xDB, 0x30, 0xEC, 0xFF, 0xFF, 0xFF, 
  0xFF, 0xFF
};

// 8X9 (Celsius)
static const uint8_t u8g_celsius_bits[] U8X8_PROGMEM = {
	0b00000010,
	0b01100101,
	0b10010010,
	0b00010000,
	0b00010000,
	0b00010000,
	0b00010000,
	0b10010000,
	0b01100000
};

//16X18
static const uint8_t u8g_bigCelsius_bits[] U8X8_PROGMEM = {
	0b00001110,0b00000000,
	0b00011011,0b01111000,
	0b00010001,0b11111110,
	0b10011011,0b10001111,
	0b10001110,0b00000011,
	0b11000000,0b00000001,
	0b11000000,0b00000001,
	0b11100000,0b00000000,
	0b11100000,0b00000000,
	0b11100000,0b00000000,
	0b11100000,0b00000000,
	0b11100000,0b00000000,
	0b11100000,0b00000000,
	0b11000000,0b00000001,
	0b11000000,0b00000011,
	0b10000000,0b10000111,
	0b00000000,0b11111111,
	0b00000000,0b01111100
};

//10X10
static const uint8_t u8g_autoStepNotActive_bits[] U8X8_PROGMEM = {
	0b10101010,0b00000010,
	0b00000001,0b00000000,
	0b00000000,0b00000010,
	0b00000001,0b00000000,
	0b00000000,0b00000010,
	0b00000001,0b00000000,
	0b00000000,0b00000010,
	0b00000001,0b00000000,
	0b00000000,0b00000010,
	0b01010101,0b00000001
};

//66X18
static const uint8_t u8g_reflow_txt_bits[] U8X8_PROGMEM = {
  0x00, 0x00, 0x00, 0xDE, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0xDF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC7, 0x01, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC3, 0x01, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x80, 0xC3, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 
  0xC3, 0x01, 0x00, 0x00, 0x00, 0x00, 0x77, 0xF8, 0xE0, 0xDF, 0xC1, 0x0F, 
  0x07, 0x87, 0x03, 0x7F, 0xFC, 0xE3, 0xDF, 0xE1, 0x1F, 0x07, 0x87, 0x03, 
  0x0F, 0x8E, 0x83, 0xC3, 0x71, 0x38, 0x8E, 0x87, 0x01, 0x0F, 0x07, 0x87, 
  0xC3, 0x79, 0x70, 0x8E, 0xC7, 0x01, 0x07, 0x07, 0x87, 0xC3, 0x39, 0x70, 
  0x8E, 0xCF, 0x01, 0x07, 0xFF, 0x87, 0xC3, 0x39, 0x70, 0xCC, 0xCC, 0x00, 
  0x07, 0xFF, 0x87, 0xC3, 0x39, 0x70, 0xDC, 0xCC, 0x00, 0x07, 0x07, 0x80, 
  0xC3, 0x39, 0x70, 0xDC, 0xEC, 0x00, 0x07, 0x07, 0x80, 0xC3, 0x79, 0x70, 
  0x58, 0x78, 0x00, 0x07, 0x0E, 0x82, 0xC3, 0x71, 0x38, 0x78, 0x78, 0x00, 
  0x07, 0xFC, 0x83, 0xC3, 0xE1, 0x1F, 0x78, 0x78, 0x00, 0x07, 0xF8, 0x81, 
  0xC3, 0xC1, 0x0F, 0x78, 0x78, 0x00
};

//59X12
static const uint8_t u8g_warm_txt_bits[] U8X8_PROGMEM = {
  0x07, 0x87, 0xE3, 0x0F, 0xEE, 0x9C, 0xE3, 0x01, 0x07, 0x87, 0xF3, 0x1F, 
  0xFE, 0xFC, 0xF7, 0x03, 0x8E, 0x87, 0x31, 0x3C, 0x1E, 0x3C, 0x9F, 0x07, 
  0x8E, 0xC7, 0x01, 0x38, 0x1E, 0x1C, 0x0E, 0x07, 0x8E, 0xCF, 0x81, 0x3F, 
  0x0E, 0x1C, 0x0E, 0x07, 0xCC, 0xCC, 0xF0, 0x3F, 0x0E, 0x1C, 0x0E, 0x07, 
  0xDC, 0xCC, 0xF8, 0x38, 0x0E, 0x1C, 0x0E, 0x07, 0xDC, 0xEC, 0x38, 0x38, 
  0x0E, 0x1C, 0x0E, 0x07, 0x58, 0x78, 0x38, 0x38, 0x0E, 0x1C, 0x0E, 0x07, 
  0x78, 0x78, 0x78, 0x3C, 0x0E, 0x1C, 0x0E, 0x07, 0x78, 0x78, 0xF0, 0x3F, 
  0x0E, 0x1C, 0x0E, 0x07, 0x78, 0x78, 0xE0, 0x39, 0x0E, 0x1C, 0x0E, 0x07 
  };

//49X17
static const uint8_t u8g_soak_txt_bits[] U8X8_PROGMEM = {
  0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 
  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xFC, 
  0xE0, 0x07, 0xFC, 0xC1, 0xE1, 0x01, 0xFE, 0xF0, 0x0F, 0xFE, 0xC3, 0xF1, 
  0x00, 0x87, 0x38, 0x1C, 0x86, 0xC7, 0x71, 0x00, 0x07, 0x3C, 0x38, 0x00, 
  0xC7, 0x39, 0x00, 0x0F, 0x1C, 0x38, 0xF0, 0xC7, 0x1D, 0x00, 0x7E, 0x1C, 
  0x38, 0xFE, 0xC7, 0x0F, 0x00, 0xF8, 0x1C, 0x38, 0x1F, 0xC7, 0x0F, 0x00, 
  0xE0, 0x1D, 0x38, 0x07, 0xC7, 0x1D, 0x00, 0xC0, 0x3D, 0x38, 0x07, 0xC7, 
  0x39, 0x00, 0xC1, 0x39, 0x1C, 0x8F, 0xC7, 0x71, 0x00, 0xFF, 0xF0, 0x0F, 
  0xFE, 0xC7, 0xF1, 0x00, 0x7F, 0xE0, 0x07, 0x3C, 0xC7, 0xE1, 0x01
};

//43X18
static const uint8_t u8g_cool_txt_bits[] U8X8_PROGMEM = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 
  0xF8, 0xC1, 0x0F, 0xF0, 0x03, 0x07, 0xFC, 0xE1, 0x1F, 0xF8, 0x07, 0x07, 
  0x1E, 0x71, 0x38, 0x1C, 0x0E, 0x07, 0x0E, 0x78, 0x70, 0x1E, 0x1C, 0x07, 
  0x07, 0x38, 0x70, 0x0E, 0x1C, 0x07, 0x07, 0x38, 0x70, 0x0E, 0x1C, 0x07, 
  0x07, 0x38, 0x70, 0x0E, 0x1C, 0x07, 0x07, 0x38, 0x70, 0x0E, 0x1C, 0x07, 
  0x0F, 0x78, 0x70, 0x1E, 0x1C, 0x07, 0x1E, 0x71, 0x38, 0x1C, 0x0E, 0x07, 
  0xFC, 0xE1, 0x1F, 0xF8, 0x07, 0x07, 0xF8, 0xC0, 0x0F, 0xF0, 0x03, 0x07, 
  };

  
// Draw initial menu with selected item (1 - Auto, 2 - Manual)
void drawMenu_AutoManual(uint8_t sel) {
	u8g2.clearBuffer();
	u8g2.setDrawColor(1);
	u8g2.drawXBMP(3, 5, 8, 9, u8g_celsius_bits);
	uint16_t curval=(int)currentTemp;
	uint16_t tmpcoord = (curval<100 ? 3 : 0);	// two or three digits number
	u8g2.setCursor(tmpcoord, 27);
	u8g2.setFont(u8g2_font_profont12_tn);	//numeric font for preset temperature and timer
	u8g2.print(curval);

	if(sel==1){
		u8g2.drawRBox(0+22,4,51,25,4);
		u8g2.drawRFrame(55+22,4,51,25,4);
	}else{
		u8g2.drawRFrame(0+22,4,51,25,4);
		u8g2.drawRBox(55+22,4,51,25,4);
	}
	u8g2.setDrawColor(2);	// restore default mode
	u8g2.setFont(u8g2_font_t0_22_mf);
	u8g2.drawStr(3+22,24,"Auto");
	u8g2.drawStr(59+22,24,"Man.");
	u8g2.sendBuffer();
}

// this routine is a part of other routine, so no sendBuffer...
void printManual(){
	u8g2.drawXBMP( 0, 0, 40, 10, u8g_manual_bits);
}

// this routine is a part of other routine, so no sendBuffer...	
void printPresetTemperature(){
	u8g2.setFont(u8g2_font_profont12_tn);	//numeric font for preset temperature and timer
	//u8g2.setFontMode(1);
	u8g2.setCursor(48, 9);
	uint16_t curval=(int)setPoint;
	u8g2.print(curval);
	uint16_t tmpcoord = 49+6*(curval<100 ? 2 : 3);	// two or three digits number
	u8g2.setBitmapMode(1);
	u8g2.drawXBMP(tmpcoord, 0, 8, 9, u8g_celsius_bits);
}

// this routine is a part of other routine, so no sendBuffer...	
// mm:ss
void printTime(uint16_t t) {
	//u8g2.setFontMode(1);
	u8g2.setCursor(87, 9);
	t = t % 3600;	// cut off hours
	uint8_t m = t / 60;
	uint8_t s = t % 60;
	printNumber00(m);
	u8g2.print(':');
	printNumber00(s);
}
// this routine is a part of other routine, so no sendBuffer...	
void printNumber00(uint8_t n) {
	if (n<10) {u8g2.print('0');}
	u8g2.print(n);
}

void printHeaterState(){
	if(digitalRead(MOSFET_PIN)){
		u8g2.drawXBMP( 120, 0, 8, 10, u8g_heating_bits);
	}else{
		u8g2.drawXBMP( 120, 0, 8, 10, u8g_clear_bits);
	}
}

// this routine is a part of other routine, so no sendBuffer...	
void printCurrentTemperature(){
	u8g2.setFont(u8g2_font_timR18_tn);	//numeric font for current temperature
	u8g2.setCursor(0, 31);
	uint16_t curval=round(currentTemp);
	u8g2.print(curval);
	uint16_t tmpcoord = 12*(curval<100 ? 2 : 3)+2;	// two or three digits number
	u8g2.drawXBMP(tmpcoord, 13, 16, 18, u8g_bigCelsius_bits);
}

void printAuto(){
	for(uint8_t i=0;i<3;i++){
		uint8_t curtype=0;
		switch (i) {
			case 0:	// Preheat
				if(ControlType==1){curtype=1;}else{curtype=2;}
				break;
			case 1:	// reflow
				if(ControlType==3){curtype=1;}else if(ControlType>3){curtype=2;}
				break;
			case 2:	// cool down
				if(ControlType==5){curtype=1;}else if(ControlType>5){curtype=2;}
		}
		printAutoStateBox(i*12,0,i,curtype); // x,y,step,type
	}
}

void printAutoStateBox(uint8_t x, uint8_t y, uint8_t step, uint8_t type){
// three types of boxes
// 0 - dotted box
// 1 - solid line box
// 2 - filled box
	switch (type) {
		case 0:
			u8g2.drawXBMP(x, y, 10, 10, u8g_autoStepNotActive_bits);
			break;
		case 1:
			u8g2.drawFrame(x, y, 10,10);
			break;
		case 2:
			u8g2.drawBox(x, y, 10,10);
	}
	// print step number (range: 0-2)
	u8g2.setFont(u8g2_font_5x7_tn);	//numeric font for step numbers
	//u8g2.setFontMode(1);
	u8g2.setCursor(x+3,y+8);
	u8g2.print(step+1);
	
	
}
	

void printStepTextGraphic(){
	switch (ControlType) {
		case 1:	// ramp to preheat temperature
			u8g2.drawXBMP(127-59, 31-12, 59, 12, u8g_warm_txt_bits);
			break;
		case 2:	// wait for timer
			u8g2.drawXBMP(127-49, 31-17, 49, 17, u8g_soak_txt_bits);
			break;
		case 3:	// ramp to reflow temperature
			u8g2.drawXBMP(127-59, 31-12, 59, 12, u8g_warm_txt_bits);
			break;
		case 4:	// wait for timer
			u8g2.drawXBMP(127-66, 31-18, 66, 18, u8g_reflow_txt_bits);
			break;
		case 5:	// wait for cooling down
			u8g2.drawXBMP(127-43, 31-18, 43, 18, u8g_cool_txt_bits);
	}	

}
	
#endif


oled.ino

#ifdef MAX6675
	#define MAXSCK_PIN  7
	#define MAXCS_PIN   8
	#define MAXDO_PIN   9

	unsigned long max6675_ms = millis();
	float lastTemperature = 0;

	void Temperature_init(void) {
		digitalWrite(MAXCS_PIN,LOW);
		digitalWrite(MAXSCK_PIN,LOW);
		pinMode(MAXCS_PIN, INPUT); // pin to high
		pinMode(MAXSCK_PIN, OUTPUT); // pin to low 
		pinMode(MAXDO_PIN, INPUT);
		for(uint8_t i=0;i<filterSamples*2;i++){getTemperature();}
	}

	// only positive temperatures
	// timer is messed up (x8 faster), but using delay(1) here is no problem, because 1/8ms is still too much (actually delays can be as low as 100ns)
	int readMAX6675(void) { 
	  uint16_t d = 0;

		pinMode(MAXCS_PIN, OUTPUT); // pin to low
		delay(1);
		pinMode(MAXSCK_PIN, OUTPUT); // pin to low 
		delay(1);
		// we need only 11 bytes of data (Actually it is 10, because sign bit reads always 0). It is no sense with thermocouple to have .00 precision.
		for (byte i=0; i<11; i++) {
			pinMode(MAXSCK_PIN, OUTPUT); // pin to low 
			delay(1);
			d <<= 1;
			if (digitalRead(MAXDO_PIN)){d |= 1;}
			pinMode(MAXSCK_PIN, INPUT); // pin to high 
			delay(1);
		}
		pinMode(MAXCS_PIN, INPUT); // pin to high
		return digitalSmooth(d, BSmoothArray); 
	}

	// did not found conversion time in datasheet so, lets assume it is the same as MAX31855
	float getTemperature(void){
		if(max6675_ms+80 < millis()) {
			max6675_ms = millis();
			lastTemperature = readMAX6675();
		}
		return lastTemperature;
	}
#endif

temperature_MAX6675.ino

#ifdef MAX31855
	#define MAXSCK_PIN  7
	#define MAXCS_PIN   8
	#define MAXDO_PIN   9

	unsigned long max31855_ms = millis();
	float lastTemperature = 0;

	void Temperature_init(void) {
		digitalWrite(MAXCS_PIN,LOW);
		digitalWrite(MAXSCK_PIN,LOW);
		pinMode(MAXCS_PIN, INPUT); // pin to high
		pinMode(MAXSCK_PIN, OUTPUT); // pin to low 
		pinMode(MAXDO_PIN, INPUT);
		for(uint8_t i=0;i<filterSamples*2;i++){getTemperature();}
	}

	// only positive temperatures
	// timer is messed up (x8 faster), but using delay(1) here is no problem, because 1/8ms is still too much (actually delays can be as low as 100ns)
	// the conversion time is about 70-100ms
	int readMAX31855(void) { 
	  uint16_t d = 0;

		pinMode(MAXCS_PIN, OUTPUT); // pin to low
		delay(1);
		pinMode(MAXSCK_PIN, OUTPUT); // pin to low 
		delay(1);
		// we need only 12 bytes of data. It is no sense with thermocouple to have .00 precision.
		for (byte i=0; i<12; i++) {
			pinMode(MAXSCK_PIN, OUTPUT); // pin to low 
			delay(1);
			d <<= 1;
			if (digitalRead(MAXDO_PIN)){d |= 1;}
			pinMode(MAXSCK_PIN, INPUT); // pin to high 
			delay(1);
		}
		pinMode(MAXCS_PIN, INPUT); // pin to high
		return digitalSmooth((d>1400 ? 0 : d), BSmoothArray); // higher than 1400 means negative temperature
	}

	// the conversion time is about 70-100ms
	float getTemperature(void){
		if(max31855_ms+80 < millis()) {
			max31855_ms = millis();
			lastTemperature = readMAX31855();
		}
		return lastTemperature;
	}
#endif

temperature_MAX31855.ino

#ifdef NTC
	// QU-BD silicone bed QWG-104F-3950 thermistor
	// (nppc) Table adjusted to reflect Chinese thermistor
	#define OVERSAMPLENR 	4	// 12 bit resolution
	#define tt_len 			50	// items in tt table

	const short TEMPTABLE[][2] PROGMEM = {
	  {    1 * OVERSAMPLENR, 700 },   // 938
	  {   31 * OVERSAMPLENR, 261 },   // 314
	  {   41 * OVERSAMPLENR, 256 },   // 290
	  {   51 * OVERSAMPLENR, 241 },   // 272
	  {   61 * OVERSAMPLENR, 230 },   // 258
	  {   71 * OVERSAMPLENR, 221 },   // 247
	  {   81 * OVERSAMPLENR, 212 },   // 237
	  {   91 * OVERSAMPLENR, 206 },   // 229
	  {  101 * OVERSAMPLENR, 199 },   // 221
	  {  111 * OVERSAMPLENR, 194 },   // 215
	  {  121 * OVERSAMPLENR, 189 },   // 209
	  {  131 * OVERSAMPLENR, 185 },   // 204
	  {  141 * OVERSAMPLENR, 181 },   // 199
	  {  151 * OVERSAMPLENR, 178 },   // 195
	  {  161 * OVERSAMPLENR, 174 },   // 190
	  {  171 * OVERSAMPLENR, 170 },   // 187
	  {  181 * OVERSAMPLENR, 167 },   // 183
	  {  191 * OVERSAMPLENR, 164 },   // 179
	  {  201 * OVERSAMPLENR, 160 },   // 176
	  {  221 * OVERSAMPLENR, 156 },   // 170
	  {  241 * OVERSAMPLENR, 151 },   // 165
	  {  261 * OVERSAMPLENR, 148 },   // 160
	  {  281 * OVERSAMPLENR, 144 },   // 155
	  {  301 * OVERSAMPLENR, 141 },   // 150
	  {  331 * OVERSAMPLENR, 138 },   // 144
	  {  361 * OVERSAMPLENR, 134 },   // 139
	  {  391 * OVERSAMPLENR, 130 },   // 133
	  {  421 * OVERSAMPLENR, 126 },   // 128
	  {  451 * OVERSAMPLENR, 122 },   // 123
	  {  491 * OVERSAMPLENR, 117 },   // 117
	  {  531 * OVERSAMPLENR, 113 },   // 111
	  {  571 * OVERSAMPLENR, 107 },   // 105
	  {  611 * OVERSAMPLENR, 102 },   // 100
	  {  641 * OVERSAMPLENR,  97 },   //  95
	  {  681 * OVERSAMPLENR,  92 },   //  90
	  {  711 * OVERSAMPLENR,  87 },   //  85
	  {  751 * OVERSAMPLENR,  81 },   //  79
	  {  791 * OVERSAMPLENR,  75 },   //  72
	  {  811 * OVERSAMPLENR,  70 },   //  69
	  {  831 * OVERSAMPLENR,  66 },   //  65
	  {  871 * OVERSAMPLENR,  60 },   //  57
	  {  881 * OVERSAMPLENR,  57 },   //  55
	  {  901 * OVERSAMPLENR,  52 },   //  51
	  {  921 * OVERSAMPLENR,  47 },   //  45
	  {  941 * OVERSAMPLENR,  39 },   //  39
	  {  971 * OVERSAMPLENR,  32 },   //  28
	  {  981 * OVERSAMPLENR,  25 },   //  23
	  {  991 * OVERSAMPLENR,  18 },   //  17
	  { 1001 * OVERSAMPLENR,  12 },   //   9
	  { 1021 * OVERSAMPLENR, -24 }    // -27
	};

	static void* heater_ttbl_map = (void*)TEMPTABLE;

	#define PGM_RD_W(x)   (short)pgm_read_word(&x)

	float analog2temp(uint16_t raw) {
		if (raw>(1020 * OVERSAMPLENR)) {	// consider sensor is disconnected
			return 999.0;	// return high but 3 digit number
		}
		float celsius = 0;
		uint8_t i;
		short(*tt)[][2] = (short(*)[][2])(heater_ttbl_map);

		for (i = 1; i < tt_len; i++) {
		  if (PGM_RD_W((*tt)[i][0]) > raw) {
			celsius = PGM_RD_W((*tt)[i - 1][1]) +
					  (raw - PGM_RD_W((*tt)[i - 1][0])) *
					  (float)(PGM_RD_W((*tt)[i][1]) - PGM_RD_W((*tt)[i - 1][1])) /
					  (float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i - 1][0]));
			break;
		  }
		}

		// Overflow: Set to last value in the table
		if (i == tt_len) celsius = PGM_RD_W((*tt)[i - 1][1]);

		return celsius;
	}

	float getTemperature(void){
		uint16_t smoothADC = digitalSmooth(collectADCraw(TEMPSENSOR_PIN), BSmoothArray);
		return analog2temp(smoothADC);
	}
	
	int collectADCraw(uint8_t sensor) {
		int sumADC;
		sumADC = analogRead(sensor);	// dummy read
		sumADC = 0;
		for (uint8_t i = 0; i < OVERSAMPLENR; i++) {
			sumADC+=analogRead(sensor);
		}
		return sumADC;
	}

	void Temperature_init(void) {
		for(uint8_t i=0;i<filterSamples*2;i++){getTemperature();}
	}
#endif

temperature_NTC.ino

void WDT_Init() {
	cli();
	wdt_reset();
	WDTCSR = (1<<WDCE)|(1<<WDE); 
#ifdef SOFTRESET
	WDTCSR = (1<<WDIE)|(1<<WDE)|(1<<WDP2)|(1<<WDP1)|(1<<WDP0); //Start watchdog timer with 2s prescaller
#else
	WDTCSR = (0<<WDIE)|(1<<WDE)|(1<<WDP2)|(1<<WDP1)|(1<<WDP0); //Start watchdog timer with 2s prescaller
#endif
	sei();
}


#ifdef SOFTRESET
ISR(WDT_vect) {
	asm volatile ("jmp 0");
}
#endif

watchdog.ino

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

PID_v2
U8g2

libraries.txt

// Encoder routines. Uses one Interrupt.

void initEncoder() {    
	pinMode(encoderPinA, INPUT_PULLUP); 
    pinMode(encoderPinB, INPUT_PULLUP); 
    pinMode(BUTTON_PIN, INPUT_PULLUP); 
    attachInterrupt(1, INT_doEncoder, FALLING);  // encoder pin on interrupt 1 - pin 3
}

char rotaryEncRead() {
  noInterrupts();
  char tmp = encoderPos;
  encoderPos=0;  // reset encoder
  interrupts();
  if(!digitalRead(BUTTON_PIN)){tmp=127;} // read button
  return tmp;
}

void INT_doEncoder() {
    // If interrupts come faster than 5ms, assume it's a bounce and ignore
    if (millis() - encodermillis > 5) {
        if (!digitalRead(encoderPinB))
            encoderPos++;
        else
            encoderPos--;

		has_encoderChange = HIGH;
        }
    encodermillis = millis();
}

// determine if rotary encoder was pressed longer than 2 seconds
bool is_rotaryEncLongPress() {
	 if(digitalRead(BUTTON_PIN)){
		 // button is not pressed
		 encoderLongPressmillis=millis();
	 }else{
		 // button is pressed
		 // how long?
		 if((encoderLongPressmillis+2000)<millis()){
			 // Long press engaged
			 return true;
			 encoderLongPressmillis=millis();	// reset counter
		 }
	 }
	 return false;
}

void waitUntilButtonReleased(){
	// wait until button is depressed
	while(rotaryEncRead() == 127){}
	delay(50); // wait for noise is gone from button contacts
}

encoder.ino

volatile char encoderPos = 0;	// accumulate encoder ticks in Interrupt.
volatile bool has_encoderChange = LOW;	// Indicates that Encoder has changed
unsigned long encodermillis = 0;
unsigned long encoderLongPressmillis = 0;


encoder.h

#ifdef NTC
	#define filterSamples   25
#else
	#define filterSamples   9
#endif
uint16_t BSmoothArray[filterSamples];

adc.h

// *** EEPROM variables ***
#define EEPROM_PID_P				 2 // int P value for PID control
#define EEPROM_PID_I				 4 // int I value for PID control
#define EEPROM_PID_D				 6 // int D value for PID control
#define EEPROM_CONTROLTYPE     		10 // byte Store temperature controlling method (AUTO or MANUAL)
#define EEPROM_MANUAL_TEMP 			12 // int Preset temperature for manual control.
#define EEPROM_AUTO_PREHEAT_TEMP	14 // int Preheat temperature in Auto mode
#define EEPROM_AUTO_REFLOW_TEMP		16 // int Reflow temperature in Auto mode
#define EEPROM_AUTO_PREHEAT_TIME	18 // byte Seconds for Preheat stage in Auto mode
#define EEPROM_AUTO_REFLOW_TIME		20 // byte Seconds for Reflow stage in Auto mode

eeprom.h

#ifdef OLED
	U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0);
#endif
