diagram.json

// Based on the work by DFRobot

#include "microLiquidCrystal_I2C.h"
#include <inttypes.h>
#if defined(ARDUINO) && ARDUINO >= 100

#include "Arduino.h"

#define printIIC(args)	Wire.write(args)
inline size_t LiquidCrystal_I2C::write(uint8_t value) {
	send(value, Rs);
	return 1;
}

#else
#include "WProgram.h"

#define printIIC(args)	Wire.send(args)
inline void LiquidCrystal_I2C::write(uint8_t value) {
	send(value, Rs);
}

#endif
#include "microWire.h"



// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set: 
//    DL = 1; 8-bit interface data 
//    N = 0; 1-line display 
//    F = 0; 5x8 dot character font 
// 3. Display on/off control: 
//    D = 0; Display off 
//    C = 0; Cursor off 
//    B = 0; Blinking off 
// 4. Entry mode set: 
//    I/D = 1; Increment by 1
//    S = 0; No shift 
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that its in that state when a sketch starts (and the
// LiquidCrystal constructor is called).

LiquidCrystal_I2C::LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows)
{
  _Addr = lcd_Addr;
  _cols = lcd_cols;
  _rows = lcd_rows;
  _backlightval = LCD_NOBACKLIGHT;
}

void LiquidCrystal_I2C::init(){
	init_priv();
}

void LiquidCrystal_I2C::init_priv()
{
	Wire.begin();
	_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
	begin(_cols, _rows);  
}

void LiquidCrystal_I2C::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {
	if (lines > 1) {
		_displayfunction |= LCD_2LINE;
	}
	_numlines = lines;

	// for some 1 line displays you can select a 10 pixel high font
	if ((dotsize != 0) && (lines == 1)) {
		_displayfunction |= LCD_5x10DOTS;
	}

	// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
	// according to datasheet, we need at least 40ms after power rises above 2.7V
	// before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
	delay(50); 
  
	// Now we pull both RS and R/W low to begin commands
	expanderWrite(_backlightval);	// reset expanderand turn backlight off (Bit 8 =1)
	delay(1000);

  	//put the LCD into 4 bit mode
	// this is according to the hitachi HD44780 datasheet
	// figure 24, pg 46
	
	  // we start in 8bit mode, try to set 4 bit mode
   write4bits(0x03 << 4);
   delayMicroseconds(4500); // wait min 4.1ms
   
   // second try
   write4bits(0x03 << 4);
   delayMicroseconds(4500); // wait min 4.1ms
   
   // third go!
   write4bits(0x03 << 4); 
   delayMicroseconds(150);
   
   // finally, set to 4-bit interface
   write4bits(0x02 << 4); 


	// set # lines, font size, etc.
	command(LCD_FUNCTIONSET | _displayfunction);  
	
	// turn the display on with no cursor or blinking default
	_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
	display();
	
	// clear it off
	clear();
	
	// Initialize to default text direction (for roman languages)
	_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
	
	// set the entry mode
	command(LCD_ENTRYMODESET | _displaymode);
	
	home();
  
}

/********** high level commands, for the user! */
void LiquidCrystal_I2C::clear(){
	command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero
	delayMicroseconds(2000);  // this command takes a long time!
}

void LiquidCrystal_I2C::home(){
	command(LCD_RETURNHOME);  // set cursor position to zero
	delayMicroseconds(2000);  // this command takes a long time!
}

void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){
	int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
	if ( row > _numlines ) {
		row = _numlines-1;    // we count rows starting w/0
	}
	command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}

// Turn the display on/off (quickly)
void LiquidCrystal_I2C::noDisplay() {
	_displaycontrol &= ~LCD_DISPLAYON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::display() {
	_displaycontrol |= LCD_DISPLAYON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turns the underline cursor on/off
void LiquidCrystal_I2C::noCursor() {
	_displaycontrol &= ~LCD_CURSORON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::cursor() {
	_displaycontrol |= LCD_CURSORON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turn on and off the blinking cursor
void LiquidCrystal_I2C::noBlink() {
	_displaycontrol &= ~LCD_BLINKON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::blink() {
	_displaycontrol |= LCD_BLINKON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// These commands scroll the display without changing the RAM
void LiquidCrystal_I2C::scrollDisplayLeft(void) {
	command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystal_I2C::scrollDisplayRight(void) {
	command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}

// This is for text that flows Left to Right
void LiquidCrystal_I2C::leftToRight(void) {
	_displaymode |= LCD_ENTRYLEFT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// This is for text that flows Right to Left
void LiquidCrystal_I2C::rightToLeft(void) {
	_displaymode &= ~LCD_ENTRYLEFT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'right justify' text from the cursor
void LiquidCrystal_I2C::autoscroll(void) {
	_displaymode |= LCD_ENTRYSHIFTINCREMENT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'left justify' text from the cursor
void LiquidCrystal_I2C::noAutoscroll(void) {
	_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// Allows us to fill the first 8 CGRAM locations
// with custom characters
void LiquidCrystal_I2C::createChar(uint8_t location, uint8_t charmap[]) {
	location &= 0x7; // we only have 8 locations 0-7
	command(LCD_SETCGRAMADDR | (location << 3));
	for (int i=0; i<8; i++) {
		write(charmap[i]);
	}
}

//createChar with PROGMEM input
void LiquidCrystal_I2C::createChar(uint8_t location, const char *charmap) {
	location &= 0x7; // we only have 8 locations 0-7
	command(LCD_SETCGRAMADDR | (location << 3));
	for (int i=0; i<8; i++) {
	    	write(pgm_read_byte_near(charmap++));
	}
}

// Turn the (optional) backlight off/on
void LiquidCrystal_I2C::noBacklight(void) {
	_backlightval=LCD_NOBACKLIGHT;
	expanderWrite(0);
}

void LiquidCrystal_I2C::backlight(void) {
	_backlightval=LCD_BACKLIGHT;
	expanderWrite(0);
}



/*********** mid level commands, for sending data/cmds */

inline void LiquidCrystal_I2C::command(uint8_t value) {
	send(value, 0);
}


/************ low level data pushing commands **********/

// write either command or data
void LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) {
	uint8_t highnib=value&0xf0;
	uint8_t lownib=(value<<4)&0xf0;
       write4bits((highnib)|mode);
	write4bits((lownib)|mode); 
}

void LiquidCrystal_I2C::write4bits(uint8_t value) {
	expanderWrite(value);
	pulseEnable(value);
}

void LiquidCrystal_I2C::expanderWrite(uint8_t _data){                                        
	Wire.beginTransmission(_Addr);
	printIIC((int)(_data) | _backlightval);
	Wire.endTransmission();   
}

void LiquidCrystal_I2C::pulseEnable(uint8_t _data){
	expanderWrite(_data | En);	// En high
	delayMicroseconds(1);		// enable pulse must be >450ns
	
	expanderWrite(_data & ~En);	// En low
	delayMicroseconds(50);		// commands need > 37us to settle
} 


// Alias functions

void LiquidCrystal_I2C::cursor_on(){
	cursor();
}

void LiquidCrystal_I2C::cursor_off(){
	noCursor();
}

void LiquidCrystal_I2C::blink_on(){
	blink();
}

void LiquidCrystal_I2C::blink_off(){
	noBlink();
}

void LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows){
		createChar(char_num, rows);
}

void LiquidCrystal_I2C::setBacklight(uint8_t new_val){
	if(new_val){
		backlight();		// turn backlight on
	}else{
		noBacklight();		// turn backlight off
	}
}

void LiquidCrystal_I2C::printstr(const char c[]){
	//This function is not identical to the function used for "real" I2C displays
	//it's here so the user sketch doesn't have to be changed 
	print(c);
}


// unsupported API functions
void LiquidCrystal_I2C::off(){}
void LiquidCrystal_I2C::on(){}
void LiquidCrystal_I2C::setDelay (int cmdDelay,int charDelay) {}
uint8_t LiquidCrystal_I2C::status(){return 0;}
uint8_t LiquidCrystal_I2C::keypad (){return 0;}
uint8_t LiquidCrystal_I2C::init_bargraph(uint8_t graphtype){return 0;}
void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end){}
void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end){}
void LiquidCrystal_I2C::setContrast(uint8_t new_val){}

	


microLiquidCrystal_I2C.cpp

// лёгкая версия библиотеки дисплея на microWire.h
// Основано на https://github.com/johnrickman/LiquidCrystal_I2C

//YWROBOT
#ifndef microLiquidCrystal_I2C_h
#define microLiquidCrystal_I2C_h

#include <inttypes.h>
#include "Print.h" 
#include "microWire.h"

// commands
#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80

// flags for display entry mode
#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00

// flags for display on/off control
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00

// flags for display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 0x00

// flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00

// flags for backlight control
#define LCD_BACKLIGHT 0x08
#define LCD_NOBACKLIGHT 0x00

#define En B00000100  // Enable bit
#define Rw B00000010  // Read/Write bit
#define Rs B00000001  // Register select bit

class LiquidCrystal_I2C : public Print {
public:
  LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows);
  void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS );
  void clear();
  void home();
  void noDisplay();
  void display();
  void noBlink();
  void blink();
  void noCursor();
  void cursor();
  void scrollDisplayLeft();
  void scrollDisplayRight();
  void printLeft();
  void printRight();
  void leftToRight();
  void rightToLeft();
  void shiftIncrement();
  void shiftDecrement();
  void noBacklight();
  void backlight();
  void autoscroll();
  void noAutoscroll(); 
  void createChar(uint8_t, uint8_t[]);
  void createChar(uint8_t location, const char *charmap);
  // Example: 	const char bell[8] PROGMEM = {B00100,B01110,B01110,B01110,B11111,B00000,B00100,B00000};
  
  void setCursor(uint8_t, uint8_t); 
#if defined(ARDUINO) && ARDUINO >= 100
  virtual size_t write(uint8_t);
#else
  virtual void write(uint8_t);
#endif
  void command(uint8_t);
  void init();

////compatibility API function aliases
void blink_on();						// alias for blink()
void blink_off();       					// alias for noBlink()
void cursor_on();      	 					// alias for cursor()
void cursor_off();      					// alias for noCursor()
void setBacklight(uint8_t new_val);				// alias for backlight() and nobacklight()
void load_custom_character(uint8_t char_num, uint8_t *rows);	// alias for createChar()
void printstr(const char[]);

////Unsupported API functions (not implemented in this library)
uint8_t status();
void setContrast(uint8_t new_val);
uint8_t keypad();
void setDelay(int,int);
void on();
void off();
uint8_t init_bargraph(uint8_t graphtype);
void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end);
void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end);
	 

private:
  void init_priv();
  void send(uint8_t, uint8_t);
  void write4bits(uint8_t);
  void expanderWrite(uint8_t);
  void pulseEnable(uint8_t);
  uint8_t _Addr;
  uint8_t _displayfunction;
  uint8_t _displaycontrol;
  uint8_t _displaymode;
  uint8_t _numlines;
  uint8_t _cols;
  uint8_t _rows;
  uint8_t _backlightval;
};

#endif


microLiquidCrystal_I2C.h

#ifndef _VARS_H
#define _VARS_H
#include <Arduino.h>

extern const uint16_t default_temperature;
extern const uint16_t temp_max;
extern const uint16_t temp_minC;
extern const uint16_t temp_maxC;
extern const uint16_t temp_minF;
extern const uint16_t temp_maxF;
extern const uint16_t temp_tip[3];
extern const uint16_t ambient_tempC;
extern const uint16_t ambient_tempF;

#endif


vars.h

#include "vars.h"

const uint16_t default_temperature = 240;       // Default value of IRON temperature
const uint16_t temp_max  = 950;                 // Maximum possible temperature in internal units
const uint16_t temp_minC = 180;                 // Minimum calibration temperature in degrees of Celsius
const uint16_t temp_maxC = 450;                 // Maximum calibration temperature in degrees of Celsius
const uint16_t temp_minF = (temp_minC *9 + 32*5 + 2)/5;
const uint16_t temp_maxF = (temp_maxC *9 + 32*5 + 2)/5;
const uint16_t temp_tip[3] = {200, 300, 400};   // Reference temperatures for tip calibration (Celsius)
const uint16_t ambient_tempC = 25;              // Default ambient temperature in Celsius
const uint16_t ambient_tempF = (ambient_tempC *9 + 32*5 + 2)/5;


vars.cpp

#ifndef _STAT_H_
#define _STAT_H_
#include <Arduino.h>

// Exponential average
class EMP_AVERAGE {
    public:
        EMP_AVERAGE(uint8_t h_length = 8)               { emp_k = h_length; emp_data = 0; }
        void            length(uint8_t h_length)        { emp_k = h_length; emp_data = 0; }
        void            reset(void)                     { emp_data = 0; }
        int32_t         average(int32_t value);
        void            update(int32_t value);
        int32_t         read(void);
    private:
        volatile    uint8_t     emp_k       = 8;
        volatile    uint32_t    emp_data    = 0;
};

//------------------------------------------ class HISTORY ----------------------------------------------------
#define H_LENGTH 16
class HISTORY {
    public:
        HISTORY(void)                           { len = 0; }
        void     init(void)                     { len = 0; }
        uint16_t read(void);
        uint16_t top(void)                      { return queue[0]; }
        void     update(uint16_t item);         // Put new entry to the history
        uint16_t average(void);                 // calculate the average value
        float    dispersion(void);              // calculate the math dispersion
    private:
        volatile uint16_t queue[H_LENGTH];
        volatile uint8_t len;                   // The number of elements in the queue
        volatile uint8_t index;                 // The current element position, use ring buffer
};

#endif


stat.h

#include "stat.h"

int32_t EMP_AVERAGE::average(int32_t value) {
    uint8_t round_v = emp_k >> 1;
    update(value);
    return (emp_data + round_v) / emp_k;
}

void EMP_AVERAGE::update(int32_t value) {
    uint8_t round_v = emp_k >> 1;
    emp_data += value - (emp_data + round_v) / emp_k;
}

int32_t EMP_AVERAGE::read(void) {
    uint8_t round_v = emp_k >> 1;
    return (emp_data + round_v) / emp_k;
}

//------------------------------------------ class HISTORY ----------------------------------------------------
void HISTORY::update(uint16_t item) {
    if (len < H_LENGTH) {
        queue[len++] = item;
    } else {
        queue[index ] = item;
        if (++index >= H_LENGTH) index = 0;     // Use ring buffer
    }
}

uint16_t HISTORY::read(void) {
    uint8_t i = H_LENGTH - 1;
    if (index)
        i = index - 1;
    return queue[i];
}

uint16_t HISTORY::average(void) {
    uint32_t sum = 0;
    if (len == 0) return 0;
    if (len == 1) return queue[0];
    for (uint8_t i = 0; i < len; ++i) sum += queue[i];
    sum += len >> 1;                            // round the average
    sum /= len;
    return uint16_t(sum);
}

float HISTORY::dispersion(void) {
    if (len < 3) return 1000;
    uint32_t sum = 0;
    uint32_t avg = average();
    for (uint8_t i = 0; i < len; ++i) {
        int32_t q = queue[i];
        q -= avg;
        q *= q;
        sum += q;
    }
    sum += len << 1;
    float d = (float)sum / (float)len;
    return d;
}


stat.cpp

#ifndef _IRON_TIPS_H_
#define _IRON_TIPS_H_

#include <Arduino.h>

// The length of the tip name
#define	 	tip_name_sz		(5)

/*
 * The custip TIP structure, 12 bytes
 * The lower EEPROM area reserved for storing upto MAX_CUSTOM_TIPS configuration data
 * When some tip is activated, new structure is allocated for it in the lower EEPROM Area
 * The Active tips are stored concequently in this area, tip index is the number of tip
 * in the custom area.
 * Whe tip disabled, the tip configuration data is kept in the EEPROM area till space 
 * required for another tip data.
 */
typedef struct s_tip TIP;
struct s_tip {
    char        tip_name[tip_name_sz];                          // The TIP name
    uint32_t    calibration_data;                               // The temperature calibration data for soldering tips. (3 reference points: 200, 300, 400 Centigrades)
    uint8_t     mask;                                           // The bit mask: TIP_ACTIVE + TIP_CALIBRATED
    int8_t      ambient;                                        // The ambient temperature in Celsius when the tip being calibrated
    uint8_t     crc;                                            // CRC checksum
};

typedef enum tip_status { TIP_ACTIVE = 1, TIP_CALIBRATED = 2 } TIP_STATUS;

class TIPS {
	public:
		TIPS()										            { }
		uint16_t		tipsLoaded(void);
		bool            name(char tip_n[tip_name_sz], uint8_t index);
        int8_t          index(const char name[tip_name_sz]);    // Tip idex in global list or -1 if not found
};


#endif


iron_tips.h

#include <string.h>
#include "iron_tips.h"

static const char tip_names[][tip_name_sz] PROGMEM = {
		{'B', '\0', '\0', '\0', '\0'},
		{'B', '1',  '\0', '\0', '\0'},
		{'B', '2',  '\0', '\0', '\0'},
		{'B', '3',  '\0', '\0', '\0'},
		{'B', '4',  '\0', '\0', '\0'},
		{'B', '2',  'Z',  '\0', '\0'},
		{'B', 'C',  '1',  '\0', '\0'},
		{'B', 'C',  '1',  '.' ,  '5'},
		{'B', 'C',  '2',  '\0', '\0'},
		{'B', 'C',  '3',  '\0', '\0'},
		{'B', 'C',  '1',  'Z',  '\0'},
		{'B', 'C',  '2',  'Z',  '\0'},
		{'B', 'C',  '4',  'Z',  '\0'},
		{'B', 'C',  'F',  '1',  '\0'},
		{'B', 'C',  'F',  '2',  '\0'},
		{'B', 'C',  'F',  '3',  '\0'},
		{'B', 'C',  'F',  '4',  '\0'},
		{'B', 'C',  'F',  '1',   'Z'},
		{'B', 'C',  'F',  '2',   'Z'},
		{'B', 'C',  'F',  '3',   'Z'},
		{'B', 'C',  'M',  '2',  '\0'},
		{'B', 'C',  'M',  '3',  '\0'},
		{'B', 'L', '\0', '\0',  '\0'},
		{'B', 'Z', '\0', '\0',  '\0'},
		{'C', '1', '\0', '\0',  '\0'},
		{'C', '2', '\0', '\0',  '\0'},
		{'C', '3', '\0', '\0',  '\0'},
		{'C', '4', '\0', '\0',  '\0'},
		{'D', '0',  '8', '\0',  '\0'},
		{'D', '1',  '2', '\0',  '\0'},
		{'D', '1',  '6', '\0',  '\0'},
		{'D', '2',  '4', '\0',  '\0'},
		{'D', '5',  '2', '\0',  '\0'},
		{'D', '4', '\0', '\0',  '\0'},
		{'D', 'L',  '1',  '2',  '\0'},
		{'D', 'L',  '3',  '2',  '\0'},
		{'D', 'L',  '5',  '2',  '\0'},
		{'D', '1',  '2',  'Z',  '\0'},
		{'D', '2',  '4',  'Z',  '\0'},
		{'D', '4',  'Z', '\0',  '\0'},
		{'I', '\0', '\0', '\0', '\0'},
		{'I',  'L', '\0', '\0', '\0'},
		{'I',  'L',  'S', '\0', '\0'},
		{'J',  '0',  '2', '\0', '\0'},
		{'J',  'L',  '0',  '2', '\0'},
		{'J',  'S',  '0',  '2', '\0'},
		{'K', '\0', '\0', '\0', '\0'},
		{'K',  'F', '\0', '\0', '\0'},
		{'K',  'L', '\0', '\0', '\0'},
		{'K',  'R', '\0', '\0', '\0'},
		{'K',  'F',  'Z', '\0', '\0'},
		{'K',  'R',  'Z', '\0', '\0'},
		{'K',  'U', '\0', '\0', '\0'},
		{'W',  'B',  '2', '\0', '\0'},
		{'W',  'D',  '0',  '8', '\0'},
		{'W',  'D',  '1',  '2', '\0'},
		{'W',  'D',  '1',  '6', '\0'},
		{'W',  'D',  '5',  '2', '\0'},
		{'W',  'I', '\0', '\0', '\0'},
		{'N',  '1',  '-',  '0',  '6'},
		{'N',  '1',  '-',  '0',  '8'},
		{'N',  '1',  '-',  '1',  '0'},
		{'N',  '1',  '-',  '1',  '3'},
		{'N',  '1',  '-',  '1',  '6'},
		{'N',  '1',  '-',  '2',  '0'},
		{'N',  '1',  '-',  '2',  '3'},
		{'N',  '1',  '-',  'L',  '1'},
		{'1',  '0',  '0',  '1', '\0'},
		{'1',  '0',  '0',  '2', '\0'},
		{'1',  '0',  '0',  '3', '\0'},
		{'1',  '0',  '0',  '4', '\0'},
		{'1',  '0',  '0',  '5', '\0'},
		{'1',  '0',  '0',  '6', '\0'},
		{'1',  '0',  '0',  '7', '\0'},
		{'1',  '0',  '0',  '8', '\0'},
		{'1',  '0',  '0',  '9', '\0'},
		{'1',  '0',  '1',  '0', '\0'},
		{'1',  '2',  '0',  '1', '\0'},
		{'1',  '2',  '0',  '2', '\0'},
		{'1',  '2',  '0',  '3', '\0'},
		{'1',  '2',  '0',  '4', '\0'},
		{'1',  '2',  '0',  '5', '\0'},
		{'1',  '2',  '0',  '6', '\0'},
		{'1',  '2',  '0',  '7', '\0'},
		{'1',  '2',  '0',  '8', '\0'},
		{'1',  '2',  '0',  '9', '\0'},
		{'1',  '4',  '0',  '1', '\0'},
		{'1',  '4',  '0',  '2', '\0'},
		{'1',  '4',  '0',  '3', '\0'},
		{'1',  '4',  '0',  '4', '\0'},
		{'1',  '4',  '0',  '5', '\0'},
		{'1',  '4',  '0',  '6', '\0'}
};

static uint16_t tip_number	= sizeof(tip_names) / tip_name_sz;

uint16_t TIPS::tipsLoaded(void) {
	return tip_number;
}

bool TIPS::name(char tip_n[tip_name_sz], uint8_t index) {
	if (index < tip_number) {
        for (uint8_t c = 0; c < tip_name_sz; ++c)
            tip_n[c] = pgm_read_byte(&tip_names[index][c]);
		return true;
	} else {
        for (uint8_t c = 0; c < tip_name_sz; ++c)
            tip_n[c] = '?';
	}
	return false;
}

int8_t TIPS::index(const char name[tip_name_sz]) {
    for (uint16_t i = 0; i < tip_number; ++i) {
        char tip_n[tip_name_sz];
        for (uint8_t c = 0; c < tip_name_sz; ++c)
            tip_n[c] = pgm_read_byte(&tip_names[i][c]);
        if (strncmp(name, tip_n, tip_name_sz) == 0) {
            return i;
        }
    }
    return -1;
}


iron_tips.cpp

#ifndef _ENCODER_H_
#define _ENCODER_H_
#include "stat.h"

//------------------------------------------ class BUTTON ------------------------------------------------------
class BUTTON {
    public:
        BUTTON(uint8_t b_pin, uint16_t timeout_ms = 3000);
        uint8_t     buttonCheck(void);
        void        setTimeout(uint16_t to = 3000);
        bool        setTick(uint16_t to);
        void        init(void)                              { pinMode(b_pin, INPUT_PULLUP); }
    private:
        uint8_t     buttonTick(void);
        EMP_AVERAGE         avg;                            // Do average the button readings to mainain the button status
        uint16_t            over_press;                     // Maximum time in ms the button can be pressed
        volatile bool       i_b_rel         = false;        // Ignore button release event
        bool                b_on            = false;        // The button current position: true - pressed
        uint32_t            bpt             = 0;            // Time in ms when the button was pressed (press time)
        uint32_t            b_check         = 0;            // Time in ms when the button should be checked
        uint32_t            tick_time       = 0;            // Time in ms when the last 'tick' was generated
        uint8_t             b_pin           = 0;            // The PIN number of the button
        uint16_t            tick_period     = 0;            // Repeat 'tick' period
        const uint8_t       trigger_on      = 100;          // avg limit to change button status to on
        const uint8_t       trigger_off     = 50;           // avg limit to change button status to off
        const uint8_t       avg_length      = 4;            // avg length
        const uint8_t       b_check_period  = 20;           // The button check period, ms
        const uint16_t      long_press      = 1500;         // If the button was pressed more that this timeout, we assume the long button press
        const uint16_t      def_over_press  = 2500;         // Default value for button overpress timeout (ms)
};

//------------------------------------------ class ENCODER ------------------------------------------------------
class RENC : public BUTTON {
    public:
        RENC(uint8_t main_pin, uint8_t slave_pin, uint8_t button_pin, int16_t init_pos = 0);
        void        init(void);
        void        set_increment(uint8_t inc)      { increment = inc; }
        uint8_t     get_increment(void)             { return increment; }
        int16_t     read(void)                      { return pos; }
        void        reset(int16_t init_pos, int16_t low, int16_t upp, uint8_t inc = 1, uint8_t fast_inc = 0, bool looped = false);
        bool        write(int16_t initPos);
        void        encoderIntr(void);
    private:
        int32_t     min_pos, max_pos;
        uint8_t     m_pin, s_pin;                   // The pin numbers connected to the main channel and to the socondary channel
        bool        is_looped;                      // Whether the encoder is looped
        uint8_t     increment;                      // The value to add or subtract for each encoder tick
        uint8_t     fast_increment;                 // The value to change encoder when in runs quickly
        volatile uint32_t   pt;                     // Time in ms when the encoder was rotaded
        volatile uint32_t   changed;                // Time in ms when the value was changed
        volatile bool       ch_b;
        volatile int16_t    pos;                    // Encoder current position
        const uint16_t      fast_timeout    = 300;  // Time in ms to change encoder quickly
        const uint16_t      over_press      = 1000;
};

#endif


encoder.h

#include "encoder.h"

//------------------------------------------ class BUTTON ------------------------------------------------------
BUTTON::BUTTON(uint8_t b_pin, uint16_t to = 3000) {
    this->b_pin = b_pin; 
    setTimeout(to);
}

/*
 * The Encoder button current status
 * 0    - not pressed
 * 1    - short press
 * 2    - long press
 */
uint8_t BUTTON::buttonCheck(void) {
    if (millis() >= b_check) {                                  // It is time to check the button status
        b_check = millis() + b_check_period;
        uint8_t s = 0;
        if (!digitalRead(b_pin))                               // if port state is low, the button pressed
            s = trigger_on << 1;
        if (b_on) {
            if (avg.average(s) < trigger_off)
                b_on = false;
        } else {
            if (avg.average(s) > trigger_on)
                b_on = true;
        }

        if (b_on) {                                             // Button status is 'pressed'
            uint32_t n = millis() - bpt;
            if ((bpt == 0) || (n > over_press)) {
                bpt = millis();
            } else if (n > long_press) {                        // Long press
                if (i_b_rel) {
                    return 0;
                } else{
                    if (tick_period)
                        return buttonTick();
                    i_b_rel = true;
                    return 2;
                }
            }
        } else {                                                // Button status is 'not pressed'
            if (bpt == 0 || i_b_rel) {
                bpt = 0;
                i_b_rel = false;
                return 0;
            }
            uint32_t e = millis() - bpt;
            bpt = 0;                                            // Ready for next press
            if (e < over_press) {                               // Long press already managed
                return 1;
            }
        }
    }
    return 0;
}

void BUTTON::setTimeout(uint16_t to) {
    over_press = constrain(to, def_over_press, 5000);
    tick_period = 0;
}

bool BUTTON::setTick(uint16_t to) {
    if (to > 0) {                                               // Setup tick period
        tick_period = constrain(to, 100, 300);
        over_press  = 16000;
        return true;
    } else {                                                    // disable tick
        tick_period = 0;
        over_press  = def_over_press;
    }
    return false;
}

uint8_t BUTTON::buttonTick(void) {
    uint32_t now_t = millis();
    if (now_t - tick_time > tick_period) {
        tick_time = now_t;
        return (bpt != 0);
    }
    return 0;
}

//------------------------------------------ class ENCODER ------------------------------------------------------
RENC::RENC(uint8_t main_pin, uint8_t slave_pin, uint8_t button_pin, int16_t init_pos) : BUTTON(button_pin) {
    pt = 0; m_pin = main_pin; s_pin = slave_pin; pos = init_pos;
    min_pos = -32767; max_pos = 32766; ch_b = false; increment = 1;
    changed = 0;
    is_looped = false;
}

void RENC::init(void) {
    BUTTON::init();
    pinMode(m_pin, INPUT_PULLUP);
    pinMode(s_pin, INPUT_PULLUP);
}

bool RENC::write(int16_t init_pos) {
    if ((init_pos >= min_pos) && (init_pos <= max_pos)) {
        pos = init_pos;
        return true;
    }
    return false;
}

void RENC::reset(int16_t init_pos, int16_t low, int16_t upp, uint8_t inc, uint8_t fast_inc, bool looped) {
    min_pos = low; max_pos = upp;
    if (!write(init_pos)) init_pos = min_pos;
    increment = fast_increment = inc;
    if (fast_inc > increment) fast_increment = fast_inc;
    is_looped = looped;
}

void RENC::encoderIntr(void) {                                  // Interrupt function, called when the channel A of encoder changed
    bool rUp = digitalRead(m_pin);
    unsigned long now_t = millis();
    if (!rUp) {                                                 // The channel A has been "pressed"
        if ((pt == 0) || (now_t - pt > over_press)) {
            pt = now_t;
            ch_b = digitalRead(s_pin);
        }
    } else {
        if (pt > 0) {
            uint8_t inc = increment;
            if ((now_t - pt) < over_press) {
                if ((now_t - changed) < fast_timeout) inc = fast_increment;
                changed = now_t;
                if (ch_b) pos -= inc; else pos += inc;
                if (pos > max_pos) { 
                    if (is_looped)
                        pos = min_pos;
                    else 
                        pos = max_pos;
                }
                if (pos < min_pos) {
                    if (is_looped)
                        pos = max_pos;
                    else
                        pos = min_pos;
                }
            }
            pt = 0; 
        }
    }
}


encoder.cpp

#ifndef _CFG_H
#define _CFG_H
#include <Arduino.h>
#include "iron_tips.h"
#include "vars.h"
/*
 * First 504 bytes of EEPROM are allocated to store the calibration tip data (see iron_tips.h)
 * The EEPROM space starting from 512 is used to store the controller configuration data
 * in the following format. Each record requires 13 bytes, and it will rounded to 16 bytes.
 * 
 * uint32_t ID                                  The ID of the record. Each time incremented by 1
 * struct cfg                                   config data, 8 bytes
 * uint8_t CRC                                  the checksum
 */
struct cfg {
    uint16_t    temp;                           // The preset temperature of the IRON (Celsius or Fahrenheit)
    uint8_t     tip;                            // Current tip index [0 - MAX_CUSTOM_TIPS]
    uint16_t    low_temp;                       // The low power temperature (C) or 0 if the tilt sensor is disabled
    uint8_t     low_to;                         // The low power timeout (seconds)
    uint8_t     off_timeout;                    // The Automatic switch-off timeout in minutes [0 - 30]
    uint8_t     bit_mask;                       // See description below
};

/*
 * The configuration bit map:
 * 0: CFG_CELSIUS       - The temperature units: Celsius (1) or Fahrenheit (0)
 * 1: CFG_BUZZER        - Is the Buzzer Enabled (1)
 * 2: CFG_SWITCH        - The hardware switch type: tilt/vibro/mercury (0) or reed (1)
 * 3: CFG_THERM         - The ambient thermistor used (1) or disabled (0)
 */
typedef enum { CFG_CELSIUS = 1, CFG_BUZZER = 2, CFG_SWITCH = 4, CFG_THERM = 8 } CFG_BIT_MASK;

//------------------------------------------ Configuration data ------------------------------------------------
class CONFIG {
    public:
        CONFIG(uint8_t max_custom_tips);
        void    init();
        bool    load(void);
        void    getConfig(struct cfg &Cfg);     // Copy config structure from this class
        void    updateConfig(struct cfg &Cfg);  // Copy updated config into this class
        bool    save(void);                     // Save current config copy to the EEPROM
        bool    saveConfig(struct cfg &Cfg);    // write updated config into the EEPROM
    protected:
        struct      cfg Config;
    private:
        bool        readRecord(uint16_t addr, uint32_t &rec_ID);
        bool        can_write;                  // The flag indicates that data can be saved
        uint16_t    start_addr = 0;             // The first address in EEPROM to start configuration record
        uint16_t    r_addr;                     // Address of thecorrect record in EEPROM to be read
        uint16_t    w_addr;                     // Address in the EEPROM to start write new record
        uint16_t    e_length;                   // Length of the EEPROM, depends on arduino model
        uint32_t    next_rec_ID;                // next record ID
        uint8_t     record_size;                // The size of one record in bytes
};

//------------------------------------------ class IRON CONFIG -------------------------------------------------
class IRON_CFG : public CONFIG, public TIPS {
    public:
        IRON_CFG(uint8_t max_custom_tips) : CONFIG(max_custom_tips) { }
        void        init(void);
        bool        isCelsius(void)             { return Config.bit_mask & CFG_CELSIUS; }
        bool        isBuzzer(void)              { return Config.bit_mask & CFG_BUZZER;  }
        uint16_t    tempPresetHuman(void)       { return Config.temp;                   }
        uint8_t     tipIndex(void)              { return tip_index;                     }
        bool        isCalibrated(void)          { return tip_mask & TIP_CALIBRATED;     }
        uint8_t     getOffTimeout(void)         { return Config.off_timeout;            }
        uint8_t     getLowTemp(void)            { return Config.low_temp;               }
        uint8_t     getLowTimeout(void)         { return Config.low_to;                 }
        char        *tipName(void)              { return tip_name;                      }
        uint16_t    lowTemp(void)               { return Config.low_temp;               }
        uint8_t     lowTimeout(void)            { return Config.low_to;                 }
        bool        isReedType(void)            { return Config.bit_mask & CFG_SWITCH;  }
        bool        isAmbientSensor(void)       { return Config.bit_mask & CFG_THERM;   }
        void        setLowPower(uint16_t low_temp, uint8_t low_to, bool reed);
        uint16_t    humanToTemp(uint16_t temp, int16_t ambient); // Translate the human readable temperature into internal value
        uint16_t    tempToHuman(uint16_t temp, int16_t ambient); // Translate temperature from internal units to the human readable value (Celsius or Fahrenheit)
        uint8_t     selectTip(uint8_t index);   // Select new tip, return selected tip index
        bool        savePresetTempHuman(uint16_t temp); // Save preset temperature in the human readable units
        bool        savePresetTemp(uint16_t temp); // Save preset temperature in the internal units (convert it to the human readable units)
        void        applyCalibration(uint16_t tip[3]);  // Apply calibration data, used during calibration procedure
        void        saveConfig(uint8_t off, bool cels, bool buzzer, bool ambient); // Save global configuration parameters
        void        getCalibrationData(uint16_t tip[3]);
        void        saveCalibrationData(uint16_t tip[3], int8_t ambient);
        uint8_t     nextTip(uint8_t index, bool forward = true);    // look for next customized tip
        bool        isTipActive(uint8_t global_index);
        bool        toggleTipActivation(uint8_t global_index);
    private:
        bool        save(void);                 // Save configuration data (if updated)
        bool        checkTipCRC(TIP& tip_data, bool write = false);
        bool        loadTipData(TIP* tip_data, uint8_t index);
        bool        validateTip(TIP& tip_data); // Validate the IRON tip calibration
        void        setDefaults(void);          // Set default parameter values if failed to load data from EEPROM
        void        unpackTipCalibration(uint16_t tip[3], uint32_t cd);
        int8_t      calibratedTipIndex(const char name[tip_name_sz]);   // Tip idex in EEPROM area or -1 if not found
        int8_t      emptyTipSlot(void);         // Unused Tip slot idex in EEPROM area or -1 if not found
        void        removeTipDuplication(void);
        char        tip_name[tip_name_sz+1];
        struct cfg  previous_cfg;               // The loaded config
        uint16_t    t_tip[3]    = {0};          // The current tip calibration
        uint8_t     tip_index   = 0;            // The current tip index (EEPROM customized  array)
        uint8_t     tip_mask    = 0;            // The current tip status (see TIP_STATUS in iron_tips.h)
        int8_t      tip_ambient = ambient_tempC;// The ambient temperature when tip was calibrated
        const uint16_t def_tip[3] = {279, 501, 700};// Default values of internal sensor readings at reference temperatures
};

#endif


cfg.h

#include <EEPROM.h>
#include "cfg.h"
#include "vars.h"
#include "config.h"

//------------------------------------------ Configuration data ------------------------------------------------
CONFIG::CONFIG(uint8_t max_custom_tips) {
    uint8_t rs = sizeof(struct cfg) + 5;        // The total config record size
    // Select appropriate record size; The record size should be power of 2, i.e. 8, 16, 32, 64, ... bytes
    for (record_size = 8; record_size < rs; record_size <<= 1);
    uint16_t custom_tips_area = sizeof(TIP) * MAX_CUSTOM_TIPS;
    uint8_t  rest = custom_tips_area % record_size;
    start_addr = custom_tips_area;              // Address in EEPROM when configuration records are saved
    if (rest) start_addr += record_size - rest;
    can_write       = false;
    r_addr = w_addr = start_addr;
    e_length        = 0;
    next_rec_ID     = 0;
}

// Read the records until the last one, point w_addr (write address) after the last record
void CONFIG::init(void) {
    e_length = EEPROM.length();
    uint32_t rec_ID;
    uint32_t min_rec_ID     = 0xffffffff;
    uint16_t min_rec_addr   = 0;
    uint32_t max_rec_ID     = 0;
    uint16_t max_rec_addr   = 0;
    uint8_t records         = 0;

  next_rec_ID = 0;

    // read all the records in the EEPROM, find min and max record ID
    for (uint16_t addr = start_addr; addr < e_length; addr += record_size) {
        if (readRecord(addr, rec_ID)) {
            ++records;
            if (min_rec_ID > rec_ID) {
                min_rec_ID = rec_ID;
                min_rec_addr = addr;
            }
            if (max_rec_ID < rec_ID) {
                max_rec_ID = rec_ID;
                max_rec_addr = addr;
            }
        } else {
            break;
        }
    }

    if (records == 0) {
        w_addr = r_addr = start_addr;
        can_write = true;
        return;
    }
    r_addr = max_rec_addr;
    if (records < ((e_length - start_addr)/ record_size)) {   // The EEPROM is not full
        w_addr = r_addr + record_size;
        if (w_addr > e_length) w_addr = start_addr;
    } else {
        w_addr = min_rec_addr;
    }
    can_write = true;
}

void CONFIG::getConfig(struct cfg &Cfg) {
    memcpy(&Cfg, &Config, sizeof(struct cfg));
}

void CONFIG::updateConfig(struct cfg &Cfg) {
    memcpy(&Config, &Cfg, sizeof(struct cfg));
}

bool CONFIG::saveConfig(struct cfg &Cfg) {
    updateConfig(Cfg);
    return save();                              // Save new data into the EEPROM
}

bool CONFIG::save(void) {
    if (!can_write) return can_write;
    if (next_rec_ID == 0) next_rec_ID = 1;

    uint16_t start_write = w_addr;
    uint32_t nxt = next_rec_ID;
    uint8_t summ = 0;
    for (uint8_t i = 0; i < 4; ++i) {
        EEPROM.write(start_write++, nxt & 0xff);
        summ <<=2; summ += nxt;
        nxt >>= 8;
    }
    uint8_t* p = (uint8_t *)&Config;
    for (uint8_t i = 0; i < sizeof(struct cfg); ++i) {
        summ <<= 2; summ += p[i];
        EEPROM.write(start_write++, p[i]);
    }
    summ ++;                                    // To avoid empty records
    EEPROM.write(w_addr+record_size-1, summ);

    r_addr = w_addr;
    w_addr += record_size;
    if (w_addr > EEPROM.length()) w_addr = 0;
    next_rec_ID ++;                             // Get ready to write next record
    return true;
}

bool CONFIG::load(void) {
    bool is_valid = readRecord(r_addr, next_rec_ID);
    next_rec_ID ++;
    return is_valid;
}

bool CONFIG::readRecord(uint16_t addr, uint32_t &rec_ID) {
    uint8_t buff[record_size];

    for (uint8_t i = 0; i < record_size; ++i) 
        buff[i] = EEPROM.read(addr+i);
  
    uint8_t summ = 0;
    for (uint8_t i = 0; i < sizeof(struct cfg) + 4; ++i) {
        summ <<= 2; summ += buff[i];
    }
    summ ++;                                    // To avoid empty fields
    if (summ == buff[record_size-1]) {          // Checksumm is correct
        uint32_t ts = 0;
        for (int8_t i = 3; i >= 0; --i) {
            ts <<= 8;
            ts |= buff[uint8_t(i)];
        }
        rec_ID = ts;
        memcpy(&Config, &buff[4], sizeof(struct cfg));
        return true;
    }
    return false;
}

//------------------------------------------ class IRON CONFIG -------------------------------------------------
void IRON_CFG::init(void) {
    CONFIG::init();
    if (!CONFIG::load()) {                      // If failed to load the data from EEPROM, initialize the config data with the default values
        setDefaults();
    }
    removeTipDuplication();
    tip_index = selectTip(Config.tip);
    memcpy(&previous_cfg, &Config, sizeof(struct cfg));
}

void IRON_CFG::setLowPower(uint16_t low_temp, uint8_t low_to, bool reed) {
    Config.low_temp = low_temp;
    Config.low_to   = low_to;
    Config.bit_mask &= ~CFG_SWITCH;
    if (reed)
        Config.bit_mask |= CFG_SWITCH;
}

// Translate the human readable temperature into internal value
uint16_t IRON_CFG::humanToTemp(uint16_t t, int16_t ambient) {
    if (tip_mask & CFG_THERM == 0) ambient = ambient_tempC;
    if (isCelsius()) {
        t = constrain(t, temp_minC, temp_maxC);
    } else {
        t = constrain(t, temp_minF, temp_maxF);
        t = map(t, temp_minF, temp_maxF, temp_minC, temp_maxC);
    }

    uint16_t left   = 0;
    uint16_t right  = temp_max;
    uint16_t temp = map(t, temp_tip[0], temp_tip[2], t_tip[0], t_tip[2]);

    if (temp > (left+right)/ 2) {
        temp -= (right-left) / 4;
    } else {
        temp += (right-left) / 4;
    }

    for (uint8_t i = 0; i < 20; ++i) {
        uint16_t tempH = tempToHuman(temp, ambient);
        if (tempH == t) {
            return temp;
        }
        uint16_t new_temp;
        if (tempH < t) {
            left = temp;
             new_temp = (left+right)/2;
            if (new_temp == temp)
                new_temp = temp + 1;
        } else {
            right = temp;
            new_temp = (left+right)/2;
            if (new_temp == temp)
                new_temp = temp - 1;
        }
        temp = new_temp;
    }
    return temp;
}

// Thanslate temperature from internal units to the human readable value (Celsius or Fahrenheit)
uint16_t IRON_CFG::tempToHuman(uint16_t temp, int16_t ambient) {
    if (tip_mask & CFG_THERM == 0) ambient = ambient_tempC;
    // The temperature difference between current ambient temperature and ambient temperature during tip calibration
    int d = ambient - tip_ambient;
    uint16_t tempH = 0;
    if (temp < t_tip[0]) {
        tempH = map(temp, 0, t_tip[0], ambient, temp_tip[0]+d);
    } else if (temp >= t_tip[1]) {
        tempH = map(temp, t_tip[1], t_tip[2], temp_tip[1]+d, temp_tip[2]+d);
    } else {
        tempH = map(temp, t_tip[0], t_tip[1], temp_tip[0]+d, temp_tip[1]+d);
    }
    if ((Config.bit_mask & CFG_CELSIUS) == 0)
        tempH = map(tempH, temp_minC, temp_maxC, temp_minF, temp_maxF);
    return tempH;
}

uint8_t IRON_CFG::selectTip(uint8_t index) {
    if (index >= MAX_CUSTOM_TIPS)               // Keep current TIP
        return tip_index;
    TIP tmp;                                    // Load the TIP configuration here
    if (loadTipData(&tmp, index) && validateTip(tmp)) { // If TIP calibration is valid, load it
        tip_mask        = tmp.mask;
        tip_ambient     = tmp.ambient;
        if (tip_mask & CFG_THERM == 0)
            tip_ambient     = ambient_tempC;
        unpackTipCalibration(t_tip, tmp.calibration_data);
        for (uint8_t i = 0; i < tip_name_sz; ++i) {
            tip_name[i] = tmp.tip_name[i];
        }
        tip_name[tip_name_sz] = '\0';
    } else {                                    // The selected tip is not calibrated
        tip_mask        = TIP_ACTIVE;
        tip_ambient     = ambient_tempC;
        t_tip[0]        = def_tip[0];
        t_tip[1]        = def_tip[1];
        t_tip[2]        = def_tip[2];
        TIPS::name(tip_name, index);
    }
    tip_index  = index;
    return index;
}

bool IRON_CFG::savePresetTempHuman(uint16_t temp) {
    if (Config.temp == temp && Config.tip  == tip_index) return false;
    Config.temp = temp;
    // When the tip changed, tip_index updated, but congiguration data remained the same
    Config.tip  = tip_index;
    return save();
}

bool IRON_CFG::savePresetTemp(uint16_t temp) {
    // temp - in internal units should be converted into Celsius or Fahrenheit
    uint16_t tempH;
    if (temp >= t_tip[1]) {                     // Approximate the temperature between t_mid and t_max 
        tempH = map(temp, t_tip[1], t_tip[2], temp_tip[1], temp_tip[2]);
    } else {
        tempH = map(temp, t_tip[0], t_tip[1], temp_tip[0], temp_tip[1]);
    }
    if (!Config.bit_mask & CFG_CELSIUS)
        tempH = map(temp, temp_minC, temp_maxC, temp_minF, temp_maxF);
    if (tempH == Config.temp || Config.tip == tip_index)
        return true;
    return savePresetTempHuman(tempH);
}

void IRON_CFG::applyCalibration(uint16_t tip[3]) {
    for (uint8_t i = 0; i < 3; ++i)
        t_tip[i] = tip[i];
}

void IRON_CFG::saveConfig(uint8_t off, bool cels, bool buzzer, bool ambient) {
    if (off > 30) off = 0;
    Config.off_timeout = off;
    bool cfg_celsius = Config.bit_mask & CFG_CELSIUS;
    Config.bit_mask = 0;
    if (cfg_celsius != cels) {                  // Need to translate preset temperature
        if (cels) {                             // Convert the preset temperature from Fahrenheit to Celsius
            Config.temp = map(Config.temp, temp_minF, temp_maxF, temp_minC, temp_maxC);
        } else {                                // Convert the preset temperature from Celsius to Fahrenheit
            Config.temp = map(Config.temp, temp_minC, temp_maxC, temp_minF, temp_maxF);
        }
    }
    if (cels)    Config.bit_mask |= CFG_CELSIUS;
    if (buzzer)  Config.bit_mask |= CFG_BUZZER;
    if (ambient) Config.bit_mask |= CFG_THERM;
    save();                                     // Save new data into the EEPROM
}

void IRON_CFG::getCalibrationData(uint16_t tip[3]) {
    tip[0] = t_tip[0];
    tip[1] = t_tip[1];
    tip[2] = t_tip[2];
}

void IRON_CFG::saveCalibrationData(uint16_t tip[3], int8_t ambient) {
    if (tip[3] > temp_max) tip[3] = temp_max;
    uint32_t cd = tip[2] & 0x3FF; cd <<= 10;    // Pack tip calibration data in one 32-bit word: 10-bits per value
    cd |= tip[1] & 0x3FF; cd <<= 10;
    cd |= tip[0];
    TIP tip_data;
    for (uint8_t i = 0; i < tip_name_sz; ++i)   // Make sure to write tip name also
        tip_data.tip_name[i] = tip_name[i];
    tip_data.calibration_data   = cd;
    tip_data.mask               = TIP_ACTIVE | TIP_CALIBRATED;
    tip_data.ambient            = ambient;
    checkTipCRC(tip_data, true);
    uint16_t addr = tip_index * sizeof(TIP);
    uint8_t *p = (uint8_t *)&tip_data;
    for (uint8_t i = 0; i < sizeof(TIP); ++i)   // Save TIP configuration data to EEPROM 
        EEPROM.write(addr+i, *p++);
    selectTip(tip_index);                       // Reload the configuration
}

/*
 * look for next customized tip
 * Here index is the tip number in EEPROM tip configuration area
 * 
 */
uint8_t IRON_CFG::nextTip(uint8_t index, bool forward) {
    uint8_t next = index;
    TIP tip_data;
    while (true) {
        if (forward) {
            next ++;
            if (next >= MAX_CUSTOM_TIPS)
                next = 0;
        } else {
            if (next > 0)
                next --;
            else
                next = MAX_CUSTOM_TIPS - 1;
        }
        if (next == index)                      // All the list checked
            break;
        if (loadTipData(&tip_data, next) && tip_data.mask & TIP_ACTIVE) {
            break;
        }
    }
    return next;
}

bool IRON_CFG::isTipActive(uint8_t global_index) {
    char tip_n[tip_name_sz];                    // Put here the tip name
    TIPS::name(tip_n, global_index);
    int8_t indx = calibratedTipIndex(tip_n);
    if (indx >= 0) {                            // tip calibration data found in the EEPROM
        TIP tip_data;
        if (loadTipData(&tip_data, indx)) {
            return tip_data.mask & TIP_ACTIVE;
        }
    }
    return false;
}

bool IRON_CFG::toggleTipActivation(uint8_t global_index) {
    char tip_n[tip_name_sz];                    // Put here the tip name
    TIPS::name(tip_n, global_index);
    int8_t indx = calibratedTipIndex(tip_n);
    TIP tip_data;
    bool init_tip_data = true;                  // Flag: initialize tip structure for new tip
    if (indx >= 0) {                            // tip calibration data found in EEPROM
        if (loadTipData(&tip_data, indx)) {     // The tip calibration data is valid
            tip_data.mask   ^= TIP_ACTIVE;      // Toggle tip activation flag
            init_tip_data   = false;
        }        
    } else {
        indx = emptyTipSlot();
        if (indx < 0) return false;             // Failed to save yet another tip calibration data
    }
    if (init_tip_data) {
        TIPS::name(tip_data.tip_name, global_index);
        uint32_t cd = def_tip[2] & 0x3FF; cd <<= 10; // Pack tip calibration data in one 32-bit word: 10-bits per value
        cd |= def_tip[1] & 0x3FF; cd <<= 10;
        cd |= def_tip[0];
        tip_data.calibration_data = cd;
        tip_data.mask       = TIP_ACTIVE;
        tip_data.ambient    = ambient_tempC;
    }
    checkTipCRC(tip_data, true);
    uint8_t *p = (uint8_t *)&tip_data;
    uint16_t addr = indx * sizeof(TIP);
    for (uint8_t i = 0; i < sizeof(TIP); ++i)   // Save TIP configuration data to EEPROM 
        EEPROM.write(addr+i, *p++);
    return tip_data.mask & TIP_ACTIVE;
}

bool IRON_CFG::save(void) {
    if (memcmp(&Config, &previous_cfg, sizeof(struct cfg)) != 0) {
Serial.print(F("update temp: ")); Serial.print(Config.temp);
Serial.print(F(", tip: ")); Serial.print(Config.tip);
Serial.print(F(", lo_temp: ")); Serial.print(Config.low_temp);
Serial.print(F(", lo_to: ")); Serial.print(Config.low_to);
Serial.print(F(", off: ")); Serial.print(Config.off_timeout);
Serial.print(F(", mask: ")); Serial.println(Config.bit_mask, BIN);
        CONFIG::save();
        memcpy(&previous_cfg, &Config, sizeof(struct cfg));
    }
}

bool IRON_CFG::checkTipCRC(TIP& tip_data, bool write) {
    uint8_t *buff = (uint8_t *)&tip_data;
    uint8_t summ = 17;                          // Do not allow all-zero data
    for (uint8_t i = 0; i < sizeof(TIP)-1; ++i) {
        summ <<= 2; summ += buff[i];
    }
    if (write) {
        tip_data.crc = summ;
    }
    return (tip_data.crc == summ);
}
    
bool IRON_CFG::loadTipData(TIP* tip_data, uint8_t index) {
    uint16_t addr = index * sizeof(TIP);        // Start address of TIP configuration in EEPROM
    uint8_t *p = (uint8_t *)tip_data;
    for (uint8_t i = 0; i < sizeof(TIP); ++i)   // Read TIP configuration data from EEPROM 
        *p++ = EEPROM.read(addr+i);
    return checkTipCRC(*tip_data);
}

bool IRON_CFG::validateTip(TIP& tip_data) {
    uint32_t cd = tip_data.calibration_data;
    if (cd == 0) return false;
    uint16_t tip[3];                            // Tip calibration data, unpacked
    unpackTipCalibration(tip, cd);
    bool valid = ((tip[0] < tip[1]) && (tip[1] < tip[2]) && (tip[2] <= temp_max));
    uint16_t delta = temp_tip[1] - temp_tip[0];
    delta <<= 1; delta /= 3;                    // 2/3 delta
    if ((tip[0] + delta) > tip[1]) valid = false;
    delta = temp_tip[2] - temp_tip[1];
    delta <<= 1; delta /= 3;
    if ((tip[1] + delta) > tip[2]) valid = false;
    return valid;
}

void IRON_CFG::setDefaults(void) {
    Config.temp         = default_temperature;
    Config.tip          = 0;
    Config.low_temp     = 0;
    Config.low_to       = 0;
    Config.off_timeout  = 0;                    // Default automatic switch-off timeout (disabled)
    Config.bit_mask     = 0b11;                 // Celsius, buzzer is enabled
}

void IRON_CFG::unpackTipCalibration(uint16_t tip[3], uint32_t cd) {
    tip[0] = cd & 0x3FF; cd >>= 10;             // 10 bits per calibration parameter, because the ADC readings are 10 bits
    tip[1] = cd & 0x3FF; cd >>= 10;
    tip[2] = cd & 0x3FF;
}

int8_t IRON_CFG::calibratedTipIndex(const char name[tip_name_sz]) {
    for (uint8_t i = 0; i < MAX_CUSTOM_TIPS; ++i) {
        TIP tmp;
        if (loadTipData(&tmp, i)) {
            if (strncmp(name, tmp.tip_name, tip_name_sz) == 0) {
                return i;
            }
        }
    }
    return -1;
}

int8_t IRON_CFG::emptyTipSlot(void) {
    for (uint8_t i = 0; i < MAX_CUSTOM_TIPS; ++i) {
        TIP tmp;
        if (loadTipData(&tmp, i)) {
            if (!(tmp.mask & TIP_ACTIVE))
                return i;
        } else {
            return i;
        }
    }
    return -1;
}

void IRON_CFG::removeTipDuplication(void) {
    uint8_t global_index[MAX_CUSTOM_TIPS];
    uint8_t tips = TIPS::tipsLoaded();
    for (uint8_t i = 0; i < MAX_CUSTOM_TIPS; ++i)
        global_index[i] = tips;

    for (uint8_t i = 0; i < MAX_CUSTOM_TIPS; ++i) {
        TIP tmp;
        if (loadTipData(&tmp, i)) {
            uint8_t g_index = TIPS::index(tmp.tip_name);
            for (uint8_t j = 0; j < i; ++j) {
                if (global_index[j] == g_index) { // Duplicated records found!
                    uint16_t addr = i * sizeof(TIP);
                    for (uint8_t c = 0; c < sizeof(TIP); ++c)
                        EEPROM.write(addr+c, 0xff);
                } else {
                    global_index[i] = g_index;
                }
            }
        }
    }
}


cfg.cpp

#include <microWire.h>

//#include "microLiquidCrystal_I2C.h"

#ifndef _DSPL1602_H
#define _DSPL1602_H
#include "config.h"
#include <LiquidCrystal.h>

//#include <Wire.h> 
//#include <LiquidCrystal_I2C.h>


#ifdef DISPLAY_1602


// The LCD 1602 parallel interface
const uint8_t  LCD_RS_PIN     = 13;
const uint8_t  LCD_E_PIN      = 12;
const uint8_t  LCD_DB4_PIN    = 5;
const uint8_t  LCD_DB5_PIN    = 6;
const uint8_t  LCD_DB6_PIN    = 7;
const uint8_t  LCD_DB7_PIN    = 8;

//------------------------------------------ class lcd DSPLay for soldering IRON -----------------------------
class DSPL : public LiquidCrystal {
    public:
        DSPL(void) : LiquidCrystal(LCD_RS_PIN, LCD_E_PIN, LCD_DB4_PIN, LCD_DB5_PIN, LCD_DB6_PIN, LCD_DB7_PIN) { }
        //DSPL(void) : LiquidCrystal_I2C (0x3f,16,2) {}
   
        void    beginN(void);
        void    begin(void)                          { /*LiquidCrystal::begin();*/ }
        void    clear(void)                         { LiquidCrystal::clear(); }
        void    tip(const char *tip_name, bool top);// Show the current tip (on top line)
        void    tSet(uint16_t t, bool celsuis);     // Show the temperature set
        void    tCurr(uint16_t t);                  // Show The current temperature
		void    tCurr(uint16_t t, bool celsius);    // Show The current temperature with degrees
		void    tCurrTune(uint16_t t, bool celsius);// Show The current temperature with degrees
        void    pSet(uint8_t  p);                   // Show the power set
	    void    tRef(uint8_t ref);					// Show the reference temperature index
        void    timeToOff(uint8_t  sec);            // Show the time to automatic off the IRON
        void    msgReady(void);                     // Show 'Ready' message
        void    msgWorking(void);                   // Show 'Working' message
        void    msgOn(void);                        // Show 'On' message
        void    msgOff(void);                       // Show 'Off' message
        void    msgStandby(void);                   // Show 'stb' message
        void    msgCold(void);                      // Show 'Cold' message
        void    msgFail(void);                      // Show 'Fail' message
        void    msgTune(void);                      // Show 'Tune' message
        void    msgCelsius(void);                   // Show 'Celsius' message
        void    msgFarneheit(void);                 // Show 'Fahren.' message
        void    msgDefault();                       // Show 'default' message (load default configuration)
        void    msgSelectTip(void);                 // Show 'iron tip' message
        void    msgActivateTip(void);               // Show 'act. tip' message
        void    setupMode(uint8_t  mode, bool tune, uint16_t  p = 0); // Show the configuration mode [0 - 11]
        void    percent(uint8_t  Power);            // Show the percentage
        void    markCalibrated(char sym, bool calibrated);  // Show mark sign if calibrated
		void    markActivated(char sym, bool on);   // Show mark sign if activated
    private:
        bool full_second_line;                      // Whether the second line is full with the message
	const uint8_t DEGREE_CHAR = 1;
	const uint8_t PWM_CHAR = 2;
	const uint8_t SET_CHAR = 3;
	const uint8_t TIP_CHAR = 4;
};

#endif
#endif


dspl_1602.h

#ifndef _CONFIG_H
#define _CONFIG_H

#include <Arduino.h>
// Select appropriate display type

//#define DISPLAY_0802
#define DISPLAY_1602
//#define DISPLAY_1602_I2C

#ifdef DISPLAY_1602_I2C
#include "dspl_1602_i2c.h"
#endif

#ifdef DISPLAY_0802
#include "dspl_0802.h"
#endif

#ifdef DISPLAY_1602
#include "dspl_1602.h"
#endif

/*
 * Maximum supported custom tips for controller, see iron_tips.h and cfg.h
 * Each custom tip data requires 12 bytes in EEPROM, 504 bytes per 42 tips are required.
 * 
 */
#define MAX_CUSTOM_TIPS (42)

#endif


config.h

#include "config.h"
#include "dspl_1602.h"
#include "iron_tips.h"

// Custom LCD Characters
// Special Characters
// Temperature Degree Character
byte degreeChar[8] = { 0b00100, 0b01010, 0b00100, 0b00000, 0b00000, 0b00000,
    0b00000, 0b00000 };

// Head Character
byte headChar[8] = { 0b00100, 0b01110, 0b11111, 0b00100, 0b00100, 0b00100,
    0b00100, 0b00100 };

// PWM Character
byte pwmChar[8] = { 0b10111, 0b10101, 0b10101, 0b10101, 0b10101, 0b10101,
    0b11101, 0b00000 };

// SET Char
byte setChar[8] = { 0b00100, 0b01010, 0b01010, 0b01010, 0b10001, 0b10001,
    0b01110, 0b00000 };

// TIP Char
byte tipChar[8] = { 0b01110, 0b01010, 0b01010, 0b01010, 0b11011, 0b01110,
    0b00100, 0b00000 };

#ifdef DISPLAY_1602

void DSPL::beginN(void) {
    LiquidCrystal::begin(16, 2);
    //LiquidCrystal::backlight();
    LiquidCrystal::clear();
	  LiquidCrystal::createChar(PWM_CHAR, pwmChar);
    LiquidCrystal::createChar(DEGREE_CHAR, degreeChar);
    LiquidCrystal::createChar(SET_CHAR, setChar);
    LiquidCrystal::createChar(TIP_CHAR, tipChar);
    full_second_line = false;
}

void DSPL::tip(const char *tip_name, bool top) {
    uint8_t  y = 1; if (top) y = 0;
    LiquidCrystal::setCursor(8, 0);
    LiquidCrystal::print(tip_name);
    for (uint8_t i = strlen(tip_name); i < 8; ++i)
        LiquidCrystal::print(' ');
}

void DSPL::msgSelectTip(void) {
    LiquidCrystal::setCursor(0, 0);
    LiquidCrystal::print(F("   TIP:"));
}

void DSPL::msgActivateTip(void) {
    LiquidCrystal::setCursor(0, 0);
    LiquidCrystal::print(F("act. tip"));
}

void DSPL::tSet(uint16_t t, bool celsius) {
    char buff[10];
    char units = 'C';
    if (!celsius) units = 'F';
    LiquidCrystal::setCursor(0, 0);
    sprintf(buff, "%c%3d%c%c", ((uint8_t) SET_CHAR), t, ((uint8_t) DEGREE_CHAR), units);
    LiquidCrystal::print(buff);
}

void DSPL::tCurr(uint16_t t, bool celsius) {
  char buff[10];
  char units = 'C';		
  if (!celsius) units = 'F';  
  LiquidCrystal::setCursor(0, 1);
  if (t < 1000) {
    sprintf(buff, "%c%3d%c%c", ((uint8_t) TIP_CHAR), t, ((uint8_t) DEGREE_CHAR), units);									
  } else {
    LiquidCrystal::print(F("xxx"));
    return;
  }
  LiquidCrystal::print(buff);
  if (full_second_line) {
    LiquidCrystal::print(F("            "));
    full_second_line = false;
  }
}


void DSPL::tCurr(uint16_t t) {
    char buff[4];
    LiquidCrystal::setCursor(0, 1);
    if (t < 1000) {
        sprintf(buff, "%3d", t);
    } else {
        LiquidCrystal::print(F("xxx"));
        return;
    }
    LiquidCrystal::print(buff);
    if (full_second_line) {
        LiquidCrystal::print(F("    "));
        full_second_line = false;
    }
}

void DSPL::tCurrTune(uint16_t t, bool celsius) {
  char buff[10];
  char units = 'C';		
  if (!celsius) units = 'F';  
  LiquidCrystal::setCursor(10, 0);
  if (t < 1000) {
    sprintf(buff, "%c%3d%c%c", ((uint8_t) TIP_CHAR), t, ((uint8_t) DEGREE_CHAR), units);									
  } else {
    LiquidCrystal::print(F("xxx"));
    return;
  }
  LiquidCrystal::print(buff);
  if (full_second_line) {
    LiquidCrystal::print(F("            "));
    full_second_line = false;
  }
}

void DSPL::pSet(uint8_t  p) {
    char buff[6];
    sprintf(buff, "P:%3d", p);
    LiquidCrystal::setCursor(0, 0);
    LiquidCrystal::print(buff);
}

void DSPL::tRef(uint8_t ref) {
    char buff[11];
    LiquidCrystal::setCursor(0, 0);
    sprintf(buff, "Ref.P. #%1d ", ref+1);
    LiquidCrystal::print(buff);
}

void DSPL::timeToOff(uint8_t  sec) {
    char buff[5];
    sprintf(buff, " %3d", sec);
    LiquidCrystal::setCursor(12, 0);
    LiquidCrystal::print(buff);
	  LiquidCrystal::setCursor(7, 0);
  LiquidCrystal::print(F("AutoOFF"));
}

void DSPL::msgReady(void) {
    LiquidCrystal::setCursor(12, 0);
    LiquidCrystal::print(F("RDY "));
}

void DSPL::msgWorking(void) {
    LiquidCrystal::setCursor(12, 0);
    LiquidCrystal::print(F("WORK"));
}

void DSPL::msgOn(void) {
    LiquidCrystal::setCursor(12, 0);
    LiquidCrystal::print(F("ON  "));
}

void DSPL::msgOff(void) {
    LiquidCrystal::setCursor(12, 0);
    LiquidCrystal::print(F("OFF "));
}

void DSPL::msgStandby(void) {
    LiquidCrystal::setCursor(12, 0);
    LiquidCrystal::print(F("STBY"));
}

void DSPL::msgCold(void) {
    LiquidCrystal::setCursor(2, 1);
    LiquidCrystal::print(F("COLD"));
    full_second_line = true;
}

void DSPL::msgFail(void) {
    LiquidCrystal::setCursor(0, 1);
    LiquidCrystal::print(F("   FAILED  "));
}

void DSPL::msgTune(void) {
    LiquidCrystal::setCursor(0, 0);
    LiquidCrystal::print(F("TUNE"));
}

void DSPL::msgCelsius(void) {
    LiquidCrystal::setCursor(0, 1);
    LiquidCrystal::print(F("Celsius "));
}

void DSPL::msgFarneheit(void) {
    LiquidCrystal::setCursor(0, 1);
    LiquidCrystal::print(F("Fahrenheit      "));
}

void DSPL::msgDefault() {
    LiquidCrystal::setCursor(0, 1);
    LiquidCrystal::print(F(" DEFAULT        "));
}

void DSPL::setupMode(uint8_t mode, bool tune, uint16_t p) {
    char buff[5];
    LiquidCrystal::clear();
    if (!tune) {
        LiquidCrystal::print(F("SETUP"));
        LiquidCrystal::setCursor(1,1);
    }
    switch (mode) {
        case 0:                                 // C/F. In-line editing
            LiquidCrystal::print(F("UNITS"));
            LiquidCrystal::setCursor(7, 1);
            if (p)
                LiquidCrystal::print("C");
            else
                LiquidCrystal::print("F");
            break;
        case 1:                                 // Buzzer
            LiquidCrystal::print(F("BUZZER"));
            if (tune) {
                LiquidCrystal::setCursor(1,1);
                if (p)
                    LiquidCrystal::print(F("ON"));
                else
                    LiquidCrystal::print(F("OFF"));
            }
            break;
        case 2:                                 // Switch type
            LiquidCrystal::print(F("SWITCH TYPE"));
            if (tune) {
                LiquidCrystal::setCursor(1,1);
                if (p)
                    LiquidCrystal::print(F("REED"));
                else
                    LiquidCrystal::print(F("TILT"));
            }
            break;
        case 3:                                 // ambient temperature sensor
            LiquidCrystal::print(F("AMBIENT TEMP"));
            if (tune) {
                LiquidCrystal::setCursor(1,1);
                if (p)
                    LiquidCrystal::print(F("ON"));
                else
                    LiquidCrystal::print(F("OFF"));
            }
            break;
        case 4:                                 // standby temperature
            LiquidCrystal::print(F("ST-BY TEMP"));
            if (tune) {
                LiquidCrystal::setCursor(1,1);
                if (p > 0) {
                    sprintf(buff, "%3d", p);
                    LiquidCrystal::print(buff);
                } else {
                    LiquidCrystal::print(" NO");
                }   
            }
            break;
        case 5:                                 // Standby Time
            LiquidCrystal::print(F("ST-BY TIME"));
            if (tune) {
                LiquidCrystal::setCursor(1,1);
                sprintf(buff, "%3ds", p);
                LiquidCrystal::print(buff);
            }
            break;
        case 6:                                 // off-timeout
            LiquidCrystal::print(F("AutoOFF TIME"));
            if (tune) {
                LiquidCrystal::setCursor(1,1);
                if (p > 0) {
                    sprintf(buff, "%2dm", p);
                    LiquidCrystal::print(buff);
                } else {
                    LiquidCrystal::print(" NO");
                }   
            }
            break;
        case 7:                                 // Tip calibrage
            LiquidCrystal::print(F("TIP CALIBRATION"));
            break;
        case 8:                                 // Activate tip
            LiquidCrystal::print(F("ACTIVATE TIPS"));
            break;
        case 9:                                 // Tune controller
            LiquidCrystal::print(F("TUNE"));
            break;
        case 10:                                // save
            LiquidCrystal::print(F("APPLY"));
            break;
        case 11:                                // cancel
            LiquidCrystal::print(F("CANCEL"));
        default:
            break;
    }
}

void DSPL::percent(uint8_t  Power) {
    char buff[6];
    sprintf(buff, "%c%3d%c",((uint8_t) PWM_CHAR),Power,'%');
    LiquidCrystal::setCursor(11, 1);
    LiquidCrystal::print(buff);
}

void DSPL::markCalibrated(char sym, bool calibrated) {
    char buff[5];
    for (uint8_t  i = 0; i < 4; ++i) buff[i] = ' ';
    if (calibrated) buff[3] = sym;
    buff[4] = '\0';
	//LiquidCrystal::setCursor(0, 1);
	//LiquidCrystal::print (buff);
	LiquidCrystal::setCursor(0, 0);
    LiquidCrystal::print(F("   TIP:"));
    LiquidCrystal::setCursor(0, 1);
	if (calibrated) {
    LiquidCrystal::print("  *Calibrated* ");
    }else{
    LiquidCrystal::print(" *Uncalibrated*");
	}
}

void DSPL::markActivated(char sym, bool on) {
    char buff[5];
    for (uint8_t  i = 0; i < 4; ++i) buff[i] = ' ';
    if (on) buff[3] = sym;
    buff[4] = '\0';
	//LiquidCrystal::setCursor(0, 1);
	//LiquidCrystal::print (buff);
	LiquidCrystal::setCursor(0, 0);
    LiquidCrystal::print(F("   TIP:"));
    LiquidCrystal::setCursor(0, 1);
	if (on) {
    LiquidCrystal::print("  *Activated* ");
    }else{
    LiquidCrystal::print("  *Deactivated*");
	}
}
#endif


dspl_1602.cpp

sketch.ino

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

microWire
LiquidCrystal

libraries.txt

#include <Arduino.h>

void mark() {
  static size_t i = 0;
  Serial.print("Debug mark ");
  Serial.println(i++);
}