chpc/CHPC_firmware.ino

/*
	Cheap Heat Pump Controller (CHPC) firmware.
	Copyright (C) 2018-2019 Gonzho (gonzho@web.de)

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
	
	See https://github.com/gonzho000/chpc/ for more details
*/



//-----------------------USER OPTIONS-----------------------
#define BOARD_TYPE_G 				//Type "G"
//#define BOARD_TYPE_F				//Type "F"

//#define DISPLAY_096 		1		//1st tests, support WILL BE DROPPED OUT SOON! small OLEDs support
#define DISPLAY_1602 		2 		//if only 1st character appears: patch 1602 library "inline size_t LiquidCrystal_I2C::write(uint8_t value)"  "return 1" instead of "return 0"
//#define DISPLAY_NONE		-1

#define INPUTS_AS_BUTTONS	1  		//pulldown resistors required!

//#define RS485_PYTHON		1  	
#define RS485_HUMAN   	2
//#define RS485_NONE		3

#define EEV_SUPPORT
//#define	EEV_ONLY				//NO target, no relays. Oly EEV, Tae, Tbe, current sensor and may be additional T sensors

#define HUMAN_AUTOINFO	10000			//print stats to console

#define WATCHDOG          			//only if u know what to do
//-----------------------TUNING OPTIONS -----------------------
#define MAX_WATTS		1170.0		//user for power protection

#define DEFFERED_STOP_HOTCIRCLE	3000000		//50 mins

#define POWERON_PAUSE     	300000    	//5 mins
#define MINCYCLE_POWEROFF 	300000    	//5 mins
#define MINCYCLE_POWERON  	3600000  	//60 mins
#define POWERON_HIGHTIME	10000		//10 sec, defines time after start when power consumption can be 2 times greater than normal

//EEV
#define EEV_MAXPULSES		480

#define EEV_PULSE_FCLOSE_MILLIS	20		//fast close, set waiting pos., close on danger
#define EEV_PULSE_CLOSE_MILLIS	50000		//precise close
#define EEV_PULSE_WOPEN_MILLIS	20		//waiting pos. set
#define EEV_PULSE_FOPEN_MILLIS	1300		//fast open, fast search 
#define EEV_PULSE_OPEN_MILLIS	60000		//precise open

#define EEV_STOP_HOLD		500		//0.1..1sec for Sanhua
#define EEV_CLOSE_ADD_PULSES	8		//read below, close algo
#define EEV_OPEN_AFTER_CLOSE	47		//0 - close to zero position, than close on EEV_CLOSE_ADD_PULSES
						//N - close to zero position, than close on EEV_CLOSE_ADD_PULSES, than open on EEV_OPEN_AFTER_CLOSE pulses
#define EEV_MINWORKPOS		52		//position will be not less during normal work
#define EEV_PRECISE_START	8.6		//T difference, threshold: make slower pulses if less
#define EEV_EMERG_DIFF		2.5		//if dangerous condition: diff =< (target_diff - EEV_EMERG_DIFF) occured, ex: target diff 5.0, emerg. diff 2.0, if calculated nowtime diff <= 3.0 then EEV will be closed
#define EEV_HYSTERESIS		0.6		//must be less than EEV_PRECISE_START, ex: target difference = 4.0, hysteresis = 0.1, when difference in range 4.0..4.1 no EEV pulses will be done; 
#define EEV_CLOSEEVERY		86400000	//86400000: every 24 hours, done while HP is NOT working
#define EEV_TARGET_TEMP_DIFF	4.0		//target difference between Before Evaporator and After Evaporator
//#define EEV_DEBUG				//used to debug during fine tuning, "RS485_HUMAN" only

#define MAGIC     		0x46   		//change if u want to reinit T sensors
//-----------------------USER OPTIONS END -----------------------

//#define INPUTS_AS_INPUTS	2  		//
//#define RS485_MACHINE 	3 		//?? or part of Python?

//-----------------------changelog-----------------------
/*
v1.0:
- Displays support
- define TYPE F/G and rearrange ports
- multi-DS18b20 support on lane
- skip non-important DS18B20 during init
- rewrite Main Cycle to unification: some sensors can be absent, ex: T_hot_out can be absent because i'ts used as target
- 2 on-board buttons support: +/- aim
- DISPLAY: indication: real and aim
- RS485_HUMAN: remote commands +,-,G,0x20/?/Enter
- buttons: < > increase_decrease t
- simpliest thermostat scheme: only T target
- rename all procs
- RS485_PYTHON: print to console inspite of mode diring init proc
- faster wattage overload processing
- write aim value to EE if needed, period: 15 mins (eq. 1041 days)
- deferred stop of hot side circle
- 80 microseconds at 9600

v1.1, 15 Apr 2019:
- HUMAN_AUTOINFO time
- EEV_ONLY mode
- EEV_Support
- EEV auto poweron/poweroff every 10 sec
- EEV_recalibration_time to stop HP and recalibrate EEV from zero level ex: every 24 hours

v1.2, 16 Apr 2019:
- "Type F" support

v1.3, 30 Apr 2019:
- EEV changed "overheating" to "delta T"
- EEV algo v1.1

//TODO:
- liquid ref. protection: start cold circle and sump heater if tsump =< tco/tci+1
- periodical start of hot side circle
- valve_4way
- emergency jumper support
- inputs support
- ? rewite re-init proc from MAGIC to emergency jumper removal at board start
- ? EEV target to EEPROM
- ? list T and other things on screen with buttons
- ? EEV define maximum working position
- ? few devices at same lane for RS485_HUMAN
*/
//-----------------------changelog END-----------------------

// DS18B20 pins: GND DATA VDD

//Connections:
//DS18B20 Pinout (Left to Right, pins down, flat side toward you)
//- Left   = Ground
//- Center = Signal (Pin N of arduino):  (with 3.3K to 4.7K resistor to +5 or 3.3 )
//- Right  = +5 or +3.3 V   
//


//
// high volume scheme:        +---- +5V (12V not tested)
//                            |
//                       +----+
//                    1MOhm   piezo
//                       +----+
//                            |(C)
// pin -> 1.6 kOhms -> (B) 2n2222        < front here
//                            |(E)
//                            +--- GND
//

/*
scheme SCT-013-000:

2 pins used: tip and sleeve, center (ring) not used http://cms.35g.tw/coding/wp-content/uploads/2014/09/SCT-013-000_UNO-1.jpg
pins are interchangeable due to AC

32 Ohms (22+10) between sensor pins  (35 == ideal)

Pin1: 
- via elect. cap. to GND
- via ~10K..470K resistor to GND
- via ~10K..470K resistor to +5 (same as prev.)
if 10K+10K used: current is 25mA
use 100K+100K for 3 phases

Pin2:
- to analog pin
- via 32..35 Ohms resistor to Pin1

+5 -------------------------+
                            |                  
                            |                                            
                            # R1 10K+                        
                            |                                
                            |                                
                            |~2.5 at this point              
            +---------------+--------------------------------------+----+
            |               |                                      |    |
            #_ elect. cap.  # R2 10K+ (same as R1)     SCT-013-000 $    # R3 = 35 Ohms (ideal case), 32 used  
            |               |                                      |    |
GND --------+---------------+                                      +----+--------> to Analog pin


WARNING: calibrate 3 sensors together, from different sellers, due to case of incorrectly worked 1 of 3 sensor

P(watts)=220*220/R(Ohms)
*/

//
//MAX 485 voltage - 5V
//
// use resistor at RS-485 GND
// 1st test: 10k result lot of issues
// 2nd test: 1k, issues
// 3rd test: 100, see discussions


//16-ch Multiplexer EN pin: active LOW, connect to GND

//used pins:
//!!! ACTUALISE
//2: Z
//3: S3
//4: S2
//5: S1
//6: S0
//7: relay 2
//8: relay 3
//9: speaker
//10: relay 4
//11-13: rs485
//A0: relay 1
//A1: power monitor

/*
relay 1: heat pump
relay 2: hot side pump
relay 3: cold side pump
relay 4: (future) heatpump sump heater

t0: room
t1: heatpump sump
t2: cold in
t3: cold out
t4: hot in
t5: hot out
t6: before condenser
t7: condenser-evaporator
t8: after evaporator
t9: outer
tA: warm floor

wattage1

*/

String fw_version = "1.4";

#ifdef DISPLAY_096
	#define DISPLAY DISPLAY_096
	#include <Wire.h>
	#include "SSD1306Ascii.h"
	#include "SSD1306AsciiWire.h"
	#define I2C_ADDRESS 0x3C
	SSD1306AsciiWire oled;
#endif 

#ifdef DISPLAY_1602
	#define DISPLAY DISPLAY_1602
	#include <Wire.h>
	#include "LiquidCrystal_I2C.h"
	LiquidCrystal_I2C lcd(0x3f,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display
#endif 

#ifdef DISPLAY_NONE
	#define DISPLAY DISPLAY_NONE
#endif 

#ifndef DISPLAY
	#define DISPLAY -1
#endif

//

#ifdef INPUTS_AS_BUTTONS
	#define  INPUTS INPUTS_AS_BUTTONS
#endif 

#ifdef INPUTS_AS_INPUTS
	#define  INPUTS INPUTS_AS_INPUTS
#endif 

//

#ifdef RS485_PYTHON
	#define  RS485 RS485_PYTHON
	char ishuman = 0;
#endif

#ifdef RS485_HUMAN
	#define  RS485 RS485_HUMAN
	char ishuman = 1;
#endif

#ifdef RS485_NONE
	char ishuman = 0;
#endif

//hardware resources
#define OW_BUS_ALLTSENSORS    12
#define SerialTxControl       13   //RS485 Direction control DE and RE to this pin
#define speakerOut            6
#define em_pin1               A6
#define EMERGENCY_PIN         A7



#ifdef BOARD_TYPE_G
	String hw_version = "Type G v1.x";
	#define RELAY_HEATPUMP        	8
	#define RELAY_HOTSIDE_CIRCLE  	9
	#define RELAY_COLDSIDE_CIRCLE 	7
	#define RELAY_SUMP_HEATER     	10
	#define RELAY_4WAY_VALVE      	11
	#ifdef INPUTS_AS_BUTTONS
		#define BUT_RIGHT 	A3
		#define BUT_LEFT  	A2
	#endif
	#ifdef EEV_SUPPORT
		#define EEV_1		2
		#define EEV_2		4
		#define EEV_3		3
		#define EEV_4		5
	#endif
#endif
#ifdef BOARD_TYPE_F
	String hw_version = "Type F v1.x";
	#define RELAY_HEATPUMP        	7
	#define RELAY_COLDSIDE_CIRCLE  	8
	#define LATCH_595 		10
	#define CLK_595 		11
	#define DATA_595 		9
	//595.0: relay 3 RELAY_HOTSIDE_CIRCLE, 595.1: relay 4 RELAY_SUMP_HEATER, 595.2: relay 5 RELAY_4WAY_VALVE, 595.3: uln 6, 595.4: uln 7, 595.5: uln 8, 595.6: uln 9, 595.7: uln 10 
	#ifdef EEV_SUPPORT
		#define EEV_1		5
		#define EEV_2		3
		#define EEV_3		4
		#define EEV_4		2
	#endif
	#ifdef INPUTS_AS_BUTTONS		//not sure
		#define BUT_RIGHT 	A3
		#define BUT_LEFT  	A2
	#endif
	
#endif
//---------------------------memory debug
#ifdef __arm__
	// should use uinstd.h to define sbrk but Due causes a conflict
	extern "C" char* sbrk(int incr);
#else // __ARM__
	extern char *__brkval;
#endif // __arm__
     
int freeMemory() {
	char top;
	#ifdef __arm__
		return &top - reinterpret_cast<char*>(sbrk(0));
	#elif defined(CORE_TEENSY) || (ARDUINO > 103 && ARDUINO != 151)
		return &top - __brkval;
	#else // __arm__
		return __brkval ? &top - __brkval : &top - __malloc_heap_start;
	#endif // __arm__
}
//---------------------------memory debug END

    
#include <avr/wdt.h>
#include <EEPROM.h>
//#include <FastCRC.h>
/*FastCRC16 CRC16;
union _crc {
	unsigned int   integer;
	char           bytes[2];
} crc;
*/

#include <SoftwareSerial.h>

#define SerialRX        0   //RX connected to RO - Receiver Output  
#define SerialTX        1   //TX connected to DI - Driver Output Pin
#define RS485Transmit    HIGH
#define RS485Receive     LOW

const char devID  = 0x41;
const char hostID = 0x30;

SoftwareSerial RS485Serial(SerialRX, SerialTX); // RX, TX

#include <OneWire.h>
#include <DallasTemperature.h>
//library's DEVICE_DISCONNECTED_C -127.0

OneWire ow_ALLTSENSORS(OW_BUS_ALLTSENSORS);
DallasTemperature s_allTsensors(&ow_ALLTSENSORS);

typedef struct {
	DeviceAddress addr;
	bool e;	//enabled
	double        T;
} st_tsens;

DeviceAddress dev_addr;		//temp

st_tsens Tae	;
st_tsens Tbe	;
st_tsens Ttarget;
st_tsens Tsump;
st_tsens Tci	;
st_tsens Tco	;
st_tsens Thi	;
st_tsens Tho	;
st_tsens Tbc	;
st_tsens Tac	;
st_tsens Touter;
st_tsens Ts1	;
st_tsens Ts2	;

#define BIT_Tae   	0
#define BIT_Tbe     	1
#define BIT_Ttarget 	2
#define BIT_Tsump   	3
#define BIT_Tci     	4
#define BIT_Tco     	5
#define BIT_Thi     	6
#define BIT_Tho     	7
#define BIT_Tbc     	8
#define BIT_Tac     	9
#define BIT_Touter  	10
#define BIT_Ts1     	11
#define BIT_Ts2     	12

unsigned int used_sensors = 0	;    			//bit array

double T_setpoint 			= 26.5;
double T_setpoint_lastsaved		= T_setpoint;
double T_EEV_setpoint 			= EEV_TARGET_TEMP_DIFF;  
double T_EEV_dt				= 0.0;		//real, used during run
const double cT_setpoint_max 		= 45.0;  
const double cT_hotcircle_delta_min 	= 2.0;
const double cT_sump_min 		= 9.0;
const double cT_sump_max 		= 110.0;
const double cT_sump_heat_threshold 	= 16.0;
//const double cT_sump_outerT_threshold	= 18.0;    	//?? seems to be not useful
const double cT_before_condenser_max 	= 108.0;      
const double cT_after_evaporator_min 	= -7.0;      	// working evaporation presure ~= -10, it is constant due to large evaporator volume     // waterhouse v1: -12 is too high
const double cT_cold_min 		= -8.0;
const double cT_hotout_max 		= 50.0;
//const double cT_workingOK_cold_delta_min = 0.5; 	// 0.7 - 1st try, 2nd try 0.5
const double cT_workingOK_hot_delta_min	= 0.5;   
const double cT_workingOK_sump_min 	= 30.0;        	//need to be not very high to normal start after deep freeze
const double c_wattage_max 		= MAX_WATTS;   	//FUNAI: 1000W seems to be normal working wattage INCLUDING 1(one) CR25/4 at 3rd speed
							//PH165X1CY : 920 Watts, 4.2 A  
const double c_workingOK_wattage_min 	= c_wattage_max/2.5;     //

bool heatpump_state    		= 0;
bool hotside_circle_state  	= 0;
bool coldside_circle_state 	= 0;
bool sump_heater_state    	= 0;

const long poweron_pause     	= POWERON_PAUSE    ;    	//default 5 mins
const long mincycle_poweroff 	= MINCYCLE_POWEROFF;    	//default 5 mins
const long mincycle_poweron  	= MINCYCLE_POWERON ;  		//default 60 mins
bool _1st_start_sleeped 		= 0;
//??? TODO: periodical start ?
//const long floor_circle_maxhalted = 6000000;  //circle NOT works max 100 minutes
const long deffered_stop_hotcircle = DEFFERED_STOP_HOTCIRCLE;

int EEV_cur_pos		= 0;	
int EEV_apulses		= 0;		//for async
bool EEV_adonotcare	= 0;		
const unsigned char EEV_steps[4] = {0b1010, 0b0110, 0b0101, 0b1001};
char EEV_cur_step 	= 0;
bool EEV_fast		= 0;		

//main cycle vars
unsigned long millis_prev	= 0;
unsigned long millis_now	= 0;
unsigned long millis_cycle	= 1000;

unsigned long millis_last_heatpump_on  = 0;
unsigned long millis_last_heatpump_off = 0;

unsigned long millis_notification  		= 0;
unsigned long millis_notification_interval 	= 33000;

unsigned long millis_displ_update          	= 0;
unsigned long millis_displ_update_interval 	= 10000;

unsigned long millis_escinput	=  0;  
unsigned long millis_charinput 	=  0;  

unsigned long millis_lasteesave	=  0;  

unsigned long millis_last_printstats = 0;

unsigned long millis_eev_last_close 	=  0;
unsigned long millis_eev_last_on  	=  0;
unsigned long millis_eev_last_step 	= 0;

int skipchars = 0;

#define ERR_HZ 2500

char inData[50];      // Allocate some space for the string, do not change that size!
char inChar= -1;      // space to store the character read
byte index = 0;       // Index into array; where to store the character

//-------------temporary variables
char temp[10];
int i	= 0;
int z	= 0;
int x	= 0;
int y	= 0;
double tempdouble	= 0.0;
int tempint       	= 0;

String outString;
//-------------EEPROM
int eeprom_magic_read = 0x00;
int eeprom_addr       = 0x00;      
//initial values, saved to EEPROM and can be modified later
//CHANGE eeprom_magic after correction!
const int eeprom_magic = MAGIC;

//-------------ERROR states
#define ERR_OK       	0
#define ERR_T_SENSOR   	1
#define ERR_HOT_PUMP 	2
#define ERR_COLD_PUMP 	3
#define ERR_HEATPUMP 	4
#define ERR_WATTAGE  	5

int errorcode 		= 0;

//--------------------------- for wattage 
#define ADC_BITS 10                      //10 fo regular arduino
#define ADC_COUNTS (1<<ADC_BITS)
float em_calibration  	= 62.5;
int em_samplesnum   	= 2960;   	// Calculate Irms only 1480 == full 14 periods for 50Hz
//double Irms       	= 0;      	//for tests with original procedure
int supply_voltage   	= 0;
int em_i            	= 0;
//phase 1
int sampleI_1       	= 0;
double filteredI_1  	= 0;
double offsetI_1    	= ADC_COUNTS>>1;	//Low-pass filter output
double sqI_1,sumI_1 	= 0;            	//sq = squared, sum = Sum, inst = instantaneous
double async_Irms_1 	= 0;
double async_wattage 	= 0;
//--------------------------- for wattage END

//--------------------------- functions
long ReadVcc() {
	// Read 1.1V reference against AVcc
	// set the reference to Vcc and the measurement to the internal 1.1V reference
	#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
		ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
	#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
		ADMUX = _BV(MUX5) | _BV(MUX0);
	#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
		ADMUX = _BV(MUX3) | _BV(MUX2);
	#else
		ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
	#endif  

	delay(2); // Wait for Vref to settle
	ADCSRA |= _BV(ADSC); // Start conversion
	while (bit_is_set(ADCSRA,ADSC)); // measuring
	
	uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH  
	uint8_t high = ADCH; // unlocks both
	
	long result = (high<<8) | low;
	//constant NOT same as in battery controller!
	result = 1126400L / result; // Calculate Vcc (in mV); (me: !!) 1125300  (!!) = 1.1*1023*1000
	return result; // Vcc in millivolts
}

char CheckAddrExists(void) { 
	/*
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Tae.addr[i]) break;	}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Tbe.addr[i]) break;	}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Ttarget.addr[i]) break;}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Tsump.addr[i]) break;}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Tci.addr[i]) break;}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Tco.addr[i]) break;}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Thi.addr[i]) break;}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Tho.addr[i]) break;}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Tbc.addr[i]) break;}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Tac.addr[i]) break;}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Touter.addr[i]) break;}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Ts1.addr[i]) break;}
	if (i == 8) return 1;
	for (i = 0; i < 8; i++) {	if (dev_addr[i] != Ts2.addr[i]) break;}
	if (i == 8) return 1;
	return 0;	
	*/
	//!!!!! optimised v1.4, untested !!!!!
	for (i = 0; i < 8; i++) {	
		if (	(dev_addr[i] != Tae.addr[i]) 	&&
			(dev_addr[i] != Tbe.addr[i]) 	&&
			(dev_addr[i] != Ttarget.addr[i]) &&
			(dev_addr[i] != Tsump.addr[i]) 	&&
			(dev_addr[i] != Tci.addr[i]) 	&&
			(dev_addr[i] != Tco.addr[i]) 	&&
			(dev_addr[i] != Thi.addr[i]) 	&&
			(dev_addr[i] != Tho.addr[i]) 	&&
			(dev_addr[i] != Tbc.addr[i]) 	&&
			(dev_addr[i] != Tac.addr[i]) 	&&
			(dev_addr[i] != Touter.addr[i]) &&
			(dev_addr[i] != Ts1.addr[i]) 	&&
			(dev_addr[i] != Ts2.addr[i]) 
		)
			break;	
	}
	if (i == 8) return 1;
	return 0;	
}

void InitS_and_D(void) {
	#ifdef  DISPLAY_096
		Wire.begin();
		oled.begin(&Adafruit128x64, I2C_ADDRESS);
		oled.setFont(Adafruit5x7);
	#endif
	#ifdef   DISPLAY_1602
		lcd.init();            // initialize the lcd 
		lcd.backlight();       // not really needed
	#endif
	RS485Serial.begin(9600);
}

void PrintS (String str) {
	#ifdef RS485_HUMAN
		char *outChar=&str[0];  
		digitalWrite(SerialTxControl, RS485Transmit);
		delay(1);    
		RS485Serial.print(outChar);
		RS485Serial.println();
		RS485Serial.flush();
		digitalWrite(SerialTxControl, RS485Receive);  
	#endif
}

void PrintS_and_D (String str, int printSerial = 1) {
	char *outChar=&str[0];  
	//#ifdef RS485_HUMAN
	if (ishuman != 0) {
		if (printSerial == 1) {
			digitalWrite(SerialTxControl, RS485Transmit);
			delay(1);    
			RS485Serial.print(outChar);
			RS485Serial.println();
			RS485Serial.flush();
			digitalWrite(SerialTxControl, RS485Receive);  
		}
	}
	//#endif
	if (str == "") {
		return;
	}
	#ifdef  DISPLAY_096
		oled.clear();
		oled.println(str);
	#endif
	#ifdef   DISPLAY_1602
		lcd.backlight();     
		lcd.clear();
		lcd.print(str);
	#endif
}

void Print_D2 () {
	#ifdef   DISPLAY_1602
		lcd.setCursor(0, 1);
		lcd.print(outString);
	#endif
}



void _PrintHelp(void) {   
	PrintS( "CHPC, https://github.com/gonzho000/chpc/ fw: " + fw_version  + " board: "+ hw_version);
	PrintS(F("Commands: \n (?) help\n (+) increase aim T\n (-) decrease aim T\n \n"));		
	#ifdef EEV_SUPPORT
		PrintS(F("(<) decrease EEV T diff \n(>) increase EEV T diff"));
	#endif
	PrintS(F("(G) get stats"));
}

void PrintS_and_D_double (double double_to_print) {
	dtostrf(double_to_print,1,2,temp);
	PrintS_and_D(temp);
}

int Inc_T (void) {
	if (T_setpoint + 0.5 > cT_setpoint_max) {
		PrintS_and_D(F("Max!"));	
		delay (200);
		return 0;
	}
	T_setpoint += 0.5;
	PrintS_and_D_double(T_setpoint);	
	return 1;	
}

int Dec_T (void) {
	if (T_setpoint - 0.5 < 1.0) {
		PrintS_and_D(F("Min!"));	
		delay (200);
		return 0;
	}
	T_setpoint -= 0.5;
	PrintS_and_D_double(T_setpoint);	
	return 1;
}

int Inc_E (void) {		///!!!!!! unprotected
	T_EEV_setpoint += 0.25;
	PrintS_and_D_double(T_EEV_setpoint);
	return 1;	
}

int Dec_E (void) {		///!!!!!! unprotected
	T_EEV_setpoint -= 0.25;
	PrintS_and_D_double(T_EEV_setpoint);
	return 1;
}

void print_Serial_SaD (double num) {	//global string + double
	RS485Serial.print(outString);
	RS485Serial.println(num);
}

void PrintStats_Serial (void) {
	#ifdef RS485_HUMAN
		digitalWrite(SerialTxControl, RS485Transmit);
		delay(1);    
		if (Tae.e == 1)		{outString = "Tae: "	; print_Serial_SaD(Tae.T);	}
		if (Tbe.e == 1) 	{outString= "Tbe: "	; print_Serial_SaD(Tbe.T);   	}
		if (Ttarget.e == 1) 	{outString = "Ttarget: "; print_Serial_SaD(Ttarget.T);	} 
		if (Tsump.e == 1)  	{outString = "Tsump: "	; print_Serial_SaD(Tsump.T);   	}
		if (Tci.e == 1)  	{outString = "Tci: "	; print_Serial_SaD(Tci.T);  	}
		if (Tco.e == 1)  	{outString = "Tco: "	; print_Serial_SaD(Tco.T);   	}
		if (Thi.e == 1)  	{outString = "Thi: "	; print_Serial_SaD(Thi.T);   	}
		if (Tho.e == 1)  	{outString = "Tho: "	; print_Serial_SaD(Tho.T);   	}
		if (Tbc.e == 1)  	{outString = "Tbc: "	; print_Serial_SaD(Tbc.T);   	}
		if (Tac.e == 1)  	{outString = "Tac: "	; print_Serial_SaD(Tac.T);   	}
		if (Touter.e == 1)  	{outString = "Touter: "	; print_Serial_SaD(Touter.T);  	}
		if (Ts1.e == 1)  	{outString = "Ts1: "	; print_Serial_SaD(Ts1.T);   	}
		if (Ts2.e == 1)  	{outString = "Ts2: "	; print_Serial_SaD(Ts2.T);   	}
		outString = "Err: " + String(errorcode) + "\n\rWatts:" + String(async_wattage) + "\n\rAim: ";	print_Serial_SaD(T_setpoint); 
		#ifdef EEV_SUPPORT
			outString = "EEV_pos:" + String (EEV_cur_pos);
			RS485Serial.print(outString);
		#endif
		RS485Serial.println();
		RS485Serial.flush();
		digitalWrite(SerialTxControl, RS485Receive);  
	#endif
}

void ReadEECheckAddr(unsigned char *to_addr) {
	for (i=0 ; i<8 ; i++) { 
		to_addr[i] = EEPROM.read(eeprom_addr);       
		eeprom_addr++;
	}
	i = 0;
	CheckIsInvalidCRCAddr(to_addr);
	if (i != 0) {
		while (1) { 
			//PrintAddr(to_addr);
			PrintS_and_D(F("Err:EEPROM, reinit!"));
			delay(5000);
		}
	}
}

void CheckIsInvalidCRCAddr(unsigned char *addr) {
	if (OneWire::crc8( addr, 7) != addr[7] ) {
		i+= 1;
	}
}

void CopyAddrStoreEE(unsigned char *addr_to, int bit_offset) {  //get result from dev_addr, autoincrement eeprom_addr    
	//dev_addr and z from globals used
	for (i=0 ; i<8 ; i++) {       //no matter
		if (z == 0) {
			dev_addr[i] = 0x00;
		}
		addr_to[i] = dev_addr[i];       
		EEPROM.write(eeprom_addr, dev_addr[i]);         
		eeprom_addr++;
	}
	bitWrite(used_sensors, bit_offset, z);
}

void WriteFloatEEPROM(int addr, float val) { 
	byte *x = (byte *)&val;
	for(byte u = 0; u < 4; u++) EEPROM.write(u+addr, x[u]);
}
 
float ReadFloatEEPROM(int addr) {   
	byte x[4];
	for(byte u = 0; u < 4; u++) x[u] = EEPROM.read(u+addr);
	float *y = (float *)&x;
	return y[0];
}

void SaveSetpointEE(void) {
	if(  	(T_setpoint_lastsaved != T_setpoint) && 
		( ((unsigned long)(millis_now - millis_lasteesave) > 15*60*1000 )  ||  (millis_lasteesave == 0) )  ) {
			eeprom_addr = 1;
			WriteFloatEEPROM(eeprom_addr, T_setpoint);
			millis_lasteesave = millis_now;
			T_setpoint_lastsaved = T_setpoint;
		}
}

void PrintAddr(unsigned char *str) {
	outString = "";
	for (i = 0; i < 8; i++) {
		if (str[i] < 0x10) outString += "0";
		outString += String(str[i], HEX);
	}
	PrintS_and_D(outString);
}

unsigned char FindAddr(String what, int required = 0) {
	i = 1;
	while (RS485Serial.available() > 0) {
		inChar = RS485Serial.read();
		delay(1);
	}
	inChar = 0x00;
	while (1) {
		while (!s_allTsensors.getAddress(dev_addr, 0)) {
			if (required == 0) {
				PrintS_and_D(F("Press > to skip"));
				delay(500);
				while (RS485Serial.available() > 0) {
					inChar = RS485Serial.read();
					if (inChar == 0x3E) {
						PrintS_and_D("Skipped: " + what);
						return 0;
					}
				}
				#ifdef INPUTS_AS_BUTTONS
					i = digitalRead(BUT_RIGHT);
					if (i == 1) {
						PrintS_and_D("Skipped: " + what);
						delay(4000);
						return 0;
					}
				#endif
			}
			PrintS_and_D("Insert " + what);
			delay(1000);
		}
		if ( OneWire::crc8( dev_addr, 7) != dev_addr[7]) {
			PrintS_and_D(F("Invalid CRC! Remove and insert same sensor!\n"));
			delay(200);
			continue;
		} else if (CheckAddrExists() == 1) {
			PrintS_and_D(F("USED! Remove!"));
			delay(1000);
			continue;
		}  else {
			break;
		}
	}
	while (1) {
		//PrintAddr(dev_addr);
		delay(1000);
		if (s_allTsensors.getAddress(dev_addr, 0)) {
			PrintS_and_D("OK! Remove " + what);
			delay(1000);
		} else {
			delay(100);
			break;
		}
	}
	return i;
}

double GetT (unsigned char *str) {
	tempdouble = -127.0;
	for ( i = 0; i < 8; i++) {
		#ifdef WATCHDOG
			wdt_reset();
		#endif
		if ( (tempdouble == 85.0) || (tempdouble == -127.0) ) {
			if ( tempdouble == 85.0 ) {    //initial value in dallas register after poweron
				delay (375);              //375 actual for 11 bits resolution, 2-3 retries OK for 12-bits resolution
			} else {
				delay (37);
			}
			tempdouble = s_allTsensors.getTempC(str);
		} else {
			break;
		}
	}
	return tempdouble;
}

void Get_Temperatures(void) {
	if (Tae.e) 	Tae.T 	= GetT(Tae.addr);
	if (Tbe.e) 	Tbe.T 	= GetT(Tbe.addr);
	if (Ttarget.e) 	Ttarget.T = GetT(Ttarget.addr);
	if (Tsump.e) 	Tsump.T = GetT(Tsump.addr);
	if (Tci.e) 	Tci.T 	= GetT(Tci.addr);
	if (Tco.e) 	Tco.T 	= GetT(Tco.addr);
	if (Thi.e) 	Thi.T 	= GetT(Thi.addr);
	if (Tho.e) 	Tho.T 	= GetT(Tho.addr);
	if (Tbc.e) 	Tbc.T 	= GetT(Tbc.addr);
	if (Tac.e) 	Tac.T 	= GetT(Tac.addr);
	if (Touter.e) 	Touter.T = GetT(Touter.addr);
	if (Ts1.e) 	Ts1.T 	= GetT(Ts1.addr);
	if (Ts2.e) 	Ts2.T 	= GetT(Ts2.addr);
	s_allTsensors.requestTemperatures();  //global request
	//---------DEBUG and self-test !!!--------  
	/*PrintS_and_D("");
	PrintS_and_D_double(Tae.T);
	PrintS_and_D_double(Tbe.T);
	PrintS_and_D_double(Ttarget.T);
	PrintS_and_D_double(Tsump.T);
	PrintS_and_D("");*/
	/*
	PrintS_and_D("Sensor 1 ");
	PrintS_and_D_double(tr_sens_1);
	PrintS_and_D(",\tci ");
	PrintS_and_D_double(tr_cold_in);
	PrintS_and_D(",\tcout ");
	PrintS_and_D_double(tr_cold_out);
	PrintS_and_D(",\thin ");
	PrintS_and_D_double(tr_hot_in);    
	PrintS_and_D(",\tho ");
	PrintS_and_D_double(tr_hot_out);
	PrintS_and_D(",\tbcond ");
	PrintS_and_D_double(tr_before_condenser);    
	PrintS_and_D(",\t outer ");
	PrintS_and_D_double(tr_outer);
	PrintS_and_D(",\t Sensor 2 ");
	PrintS_and_D_double(tr_sens_2);
	*/
	
	//---------DEBUG END--------  
}

#ifdef EEV_SUPPORT
void on_EEV(){	//1 = do not take care of position
	x = EEV_steps[EEV_cur_step];
	digitalWrite	(EEV_1,	bitRead(x, 0));
	digitalWrite	(EEV_2,	bitRead(x, 1));
	digitalWrite	(EEV_3,	bitRead(x, 2));
	digitalWrite	(EEV_4,	bitRead(x, 3));
}

void off_EEV(){	//1 = do not take care of position
	digitalWrite	(EEV_1,	0);
	digitalWrite	(EEV_2,	0);
	digitalWrite	(EEV_3,	0);
	digitalWrite	(EEV_4,	0);
	//PrintS_and_D("off_EEV");
}

#endif

void halifise(void){
	#ifdef BOARD_TYPE_F
		/*#define LATCH_595 = 10;
		#define CLK_595 = 11;
		#DEFINE DATA_595 = 9;
		//595.0: relay 3 RELAY_HOTSIDE_CIRCLE, 595.1: relay 4 RELAY_SUMP_HEATER, 595.2: relay 5 RELAY_4WAY_VALVE, 595.3: uln 6, 595.4: uln 7, 595.5: uln 8, 595.6: uln 9, 595.7: uln 10 
		*/
		digitalWrite(LATCH_595, 0);
		//7
		digitalWrite(CLK_595, 0);
		digitalWrite(DATA_595, 0);
		digitalWrite(CLK_595, 1);
		__asm__ __volatile__ ("nop\n\t");
		//6
		digitalWrite(CLK_595, 0);
		digitalWrite(DATA_595, 0);
		digitalWrite(CLK_595, 1);
		__asm__ __volatile__ ("nop\n\t");
		//5
		digitalWrite(CLK_595, 0);
		digitalWrite(DATA_595, 0);
		digitalWrite(CLK_595, 1);
		__asm__ __volatile__ ("nop\n\t");
		//4
		digitalWrite(CLK_595, 0);
		digitalWrite(DATA_595, 0);
		digitalWrite(CLK_595, 1);
		__asm__ __volatile__ ("nop\n\t");
		//3
		digitalWrite(CLK_595, 0);
		digitalWrite(DATA_595, 0);	
		digitalWrite(CLK_595, 1);
		__asm__ __volatile__ ("nop\n\t");
		//2
		digitalWrite(CLK_595, 0);
		digitalWrite(DATA_595, 0); //4way valve here
		digitalWrite(CLK_595, 1);
		__asm__ __volatile__ ("nop\n\t");
		//1
		digitalWrite(CLK_595, 0);
		digitalWrite(DATA_595, sump_heater_state);
		digitalWrite(CLK_595, 1);
		__asm__ __volatile__ ("nop\n\t");
		//0
		digitalWrite(CLK_595, 0);
		digitalWrite(DATA_595, hotside_circle_state);
		digitalWrite(CLK_595, 1);
		__asm__ __volatile__ ("nop\n\t");
		digitalWrite(CLK_595, 0);
		//
		digitalWrite(LATCH_595, 1);
		
		
	#endif
	#ifdef BOARD_TYPE_G
		digitalWrite	(RELAY_SUMP_HEATER, sump_heater_state);
		digitalWrite	(RELAY_HOTSIDE_CIRCLE,	hotside_circle_state);
	#endif
}


//--------------------------- functions END

void setup(void) {
	pinMode		(RELAY_HEATPUMP, 	OUTPUT);
	pinMode		(RELAY_COLDSIDE_CIRCLE, OUTPUT);
	digitalWrite	(RELAY_HEATPUMP,	LOW);
	digitalWrite	(RELAY_COLDSIDE_CIRCLE,	LOW);
	
	#ifdef BOARD_TYPE_G
		pinMode		(RELAY_SUMP_HEATER, 	OUTPUT);
		pinMode		(RELAY_HOTSIDE_CIRCLE, 	OUTPUT);
		digitalWrite	(RELAY_SUMP_HEATER,	LOW);
		digitalWrite	(RELAY_HOTSIDE_CIRCLE,	LOW);
	#endif
	#ifdef BOARD_TYPE_F
		pinMode		(LATCH_595, 	OUTPUT);
		pinMode		(CLK_595, 	OUTPUT);
		pinMode		(DATA_595, 	OUTPUT);
		digitalWrite	(LATCH_595, 	LOW);
		digitalWrite	(CLK_595, 	LOW);
		digitalWrite	(DATA_595, 	LOW);
	#endif
	
	#ifdef WATCHDOG
		wdt_disable();
		delay(2000);
	#endif
	
	InitS_and_D();
	pinMode(SerialTxControl, OUTPUT);    
	digitalWrite(SerialTxControl, RS485Receive);
	//digitalWrite(SerialTxControl, RS485Transmit);
	//RS485Serial.println("starting...");	//!!!debug
	delay(100);
	PrintS_and_D("ID: 0x" + String(devID, HEX));
	//Print_Lomem(C_ID);
	delay(200);
	#ifdef EEV_SUPPORT
		pinMode	(EEV_1, 	OUTPUT);
		pinMode	(EEV_2, 	OUTPUT);
		pinMode	(EEV_3, 	OUTPUT);
		pinMode	(EEV_4, 	OUTPUT);
		off_EEV();
	#endif
	
	pinMode	(em_pin1, INPUT);
	
	//PrintS_and_D("setpoint (C):");
	//PrintS_and_D(setpoint);
	
	//PrintS_and_D(String(freeMemory()));  //!!! debug
	
	s_allTsensors.begin();
	s_allTsensors.setWaitForConversion(false);  //ASYNC mode, request before get, see Dallas library for details
	
	eeprom_magic_read = EEPROM.read(eeprom_addr);
	#ifdef INPUTS_AS_BUTTONS
		pinMode		(BUT_RIGHT, INPUT);
		//digitalWrite	(BUT_RIGHT, LOW);
		pinMode		(BUT_LEFT, INPUT);
		//digitalWrite	(BUT_LEFT, LOW);       
	#endif
	//EEPROM content: 
	//0x00 - magic,   
	//0x01  .. 0x04 Target value, 
	//0x05 and 0x06 if sensor enabled or not, used_sensors HI and LO
	//0x07  .. 0x0e 1st addr, etc..
	
	// tr_after_evaporator(0);       tr_before_evaporator(1);     tr_target(2);             tr_sump(3);
	// tr_cold_in(4);                tr_cold_out(5);              tr_hot_in(6);             tr_hot_out(7);
	// tr_before_condenser(8);       tr_after_condenser(9);       tr_outer(10);              tr_sens_1(11);
	// tr_sens_2(12);
	
	eeprom_addr = 0x00;
	if (eeprom_magic_read == eeprom_magic) {
		eeprom_addr += 1;
		T_setpoint = ReadFloatEEPROM(eeprom_addr);
		eeprom_addr += 4;
		//PrintS_and_D("EEPROM->T " + String(T_setpoint));
		
		z = EEPROM.read(eeprom_addr);  //high
		eeprom_addr += 1;
		i = EEPROM.read(eeprom_addr);  //lo
		eeprom_addr += 1;
		used_sensors= word (z,i);
	
		Tae.e     = bitRead(used_sensors, BIT_Tae	);
		Tbe.e     = bitRead(used_sensors, BIT_Tbe	);
		Ttarget.e = bitRead(used_sensors, BIT_Ttarget	);
		Tsump.e   = bitRead(used_sensors, BIT_Tsump	);
		Tci.e     = bitRead(used_sensors, BIT_Tci	);
		Tco.e     = bitRead(used_sensors, BIT_Tco	);
		Thi.e     = bitRead(used_sensors, BIT_Thi	);
		Tho.e     = bitRead(used_sensors, BIT_Tho	);
		Tbc.e     = bitRead(used_sensors, BIT_Tbc	);
		Tac.e     = bitRead(used_sensors, BIT_Tac	);
		Touter.e  = bitRead(used_sensors, BIT_Touter	);
		Ts1.e     = bitRead(used_sensors, BIT_Ts1	);
		Ts2.e     = bitRead(used_sensors, BIT_Ts2	);
		#ifdef EEV_SUPPORT
			if (Tae.e != 1 || Tbe.e != 1) {
				while (1) {
					PrintS_and_D("ERR: no Tae or Tbe for EEV!");
					delay (1000);
				}
			}
		#endif
		ReadEECheckAddr(Tae.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Tae");
		ReadEECheckAddr(Tbe.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Tbe");
		ReadEECheckAddr(Ttarget.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Ttarget");
		ReadEECheckAddr(Tsump.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Tsump");
		ReadEECheckAddr(Tci.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Tci");
		ReadEECheckAddr(Tco.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Tco");
		ReadEECheckAddr(Thi.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Thi");
		ReadEECheckAddr(Tho.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Tho");
		ReadEECheckAddr(Tbc.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Tbc");
		ReadEECheckAddr(Tac.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Tac");
		ReadEECheckAddr(Touter.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Touter");
		ReadEECheckAddr(Ts1.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Ts1");
		ReadEECheckAddr(Ts2.addr);  //eeprom_addr incremeneted here
		//PrintS_and_D("k:Ts2");
		
		/*
		//?code duplicated, see ReadEECheckAddr
		i = 0;
		if (Tae.e == 1) 	CheckIsInvalidCRCAddr(Tae.addr	);
		if (Tbe.e == 1) 	CheckIsInvalidCRCAddr(Tbe.addr	);
		if (Ttarget.e == 1) 	CheckIsInvalidCRCAddr(Ttarget.addr);
		if (Tsump.e == 1) 	CheckIsInvalidCRCAddr(Tsump.addr);
		if (Tci.e == 1) 	CheckIsInvalidCRCAddr(Tci.addr	);
		if (Tco.e == 1) 	CheckIsInvalidCRCAddr(Tco.addr	);
		if (Thi.e == 1) 	CheckIsInvalidCRCAddr(Thi.addr	);
		if (Tho.e == 1) 	CheckIsInvalidCRCAddr(Tho.addr	);
		if (Tbc.e == 1) 	CheckIsInvalidCRCAddr(Tbc.addr	);
		if (Tac.e == 1) 	CheckIsInvalidCRCAddr(Tac.addr	);
		if (Touter.e == 1) 	CheckIsInvalidCRCAddr(Touter.addr);
		if (Ts1.e == 1) 	CheckIsInvalidCRCAddr(Ts1.addr	);
		if (Ts2.e == 1) 	CheckIsInvalidCRCAddr(Ts2.addr	);
		if (i != 0) {
			while ( 1 ) { PrintS_and_D(F("EEPROM err1!")); delay (1000); }
		}
		*/
	} else {
		eeprom_addr += 1;
		ishuman += 1;
		WriteFloatEEPROM(eeprom_addr, T_setpoint);
		//PrintS_and_D(F("init EEPROM"));
		eeprom_addr += 4;
		eeprom_addr += 2; //used sensors, skip
		//Ttarget -needed, other - optional
		#ifdef EEV_SUPPORT
			z = FindAddr("Tae", 1);       //holds result in dev_addr, returns "is used"
		#else 
			z = FindAddr("Tae");          //holds result in dev_addr, returns "is used"
		#endif
		Tae.e = z;
		CopyAddrStoreEE (Tae.addr, BIT_Tae);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		#ifdef EEV_SUPPORT        
			z = FindAddr("Tbe", 1);
		#else
			z = FindAddr("Tbe");
		#endif		
		Tbe.e = z;
		CopyAddrStoreEE (Tbe.addr, BIT_Tbe);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
		
		#ifdef EEV_ONLY
			//z = FindAddr("Ttarget");
			z = 0;
		#else
			z = FindAddr("Ttarget", 1);
		#endif
		Ttarget.e = z;
		CopyAddrStoreEE (Ttarget.addr, BIT_Ttarget);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		z = FindAddr("Tsump");
		Tsump.e = z;
		CopyAddrStoreEE (Tsump.addr, BIT_Tsump);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		z = FindAddr("Tci");
		Tci.e = z;
		CopyAddrStoreEE (Tci.addr, BIT_Tci);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		z = FindAddr("Tco");
		Tco.e = z;
		CopyAddrStoreEE (Tco.addr, BIT_Tco);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		z = FindAddr("Thi");
		Thi.e = z;
		CopyAddrStoreEE (Thi.addr, BIT_Thi);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		z = FindAddr("Tho");
		Tho.e = z;
		CopyAddrStoreEE (Tho.addr, BIT_Tho);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		z = FindAddr("Tbc");
		Tbc.e = z;
		CopyAddrStoreEE (Tbc.addr, BIT_Tbc);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		z = FindAddr("Tac");
		Tac.e = z;
		CopyAddrStoreEE (Tac.addr, BIT_Tac);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		z = FindAddr("Touter");
		Touter.e = z;
		CopyAddrStoreEE (Touter.addr, BIT_Touter);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		z = FindAddr("Ts1");
		Ts1.e = z;
		CopyAddrStoreEE (Ts1.addr, BIT_Ts1);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		z = FindAddr("Ts2");
		Ts2.e = z;
		CopyAddrStoreEE (Ts2.addr, BIT_Ts2);  //dev_addr and z used by proc, autoincrement eeprom_addr, store bit
	
		//
		//final, off-the-sequence
		EEPROM.write(0+1+4+0,highByte(used_sensors)); 
		EEPROM.write(0+1+4+1,lowByte(used_sensors));  
		EEPROM.write(0x00, eeprom_magic);
		ishuman -= 1;
	}
	T_setpoint_lastsaved = T_setpoint;
	//s_allTsensors.setResolution(ad_Tae, 12);
	/*PrintAddr(Tae.addr);
	PrintAddr(Tbe.addr);
	PrintAddr(Ttarget.addr);
	PrintAddr(Tsump.addr);
	PrintAddr(Tci.addr);
	PrintAddr(Tco.addr);
	PrintAddr(Thi.addr);
	PrintAddr(Tho.addr);
	PrintAddr(Tbc.addr);
	PrintAddr(Tac.addr);
	PrintAddr(Touter.addr);
	PrintAddr(Ts1.addr);
	PrintAddr(Ts2.addr);*/

	#ifdef WATCHDOG
		wdt_enable (WDTO_8S);
	#endif
	
	Get_Temperatures();
	
	tone(speakerOut, 2250);
	delay (1500); // like ups power on
	noTone(speakerOut);
		
	outString.reserve(200);
	//PrintS_and_D(String(freeMemory()));  //!!! debug
}

 
void loop(void) {  
	digitalWrite(SerialTxControl, RS485Receive);
	millis_now = millis();

	//----------------------------- self-test !!!
	/*
	digitalWrite(RELAY_HEATPUMP,HIGH);
	delay(300);
	digitalWrite(RELAY_HOTSIDE_CIRCLE,HIGH);
	delay(300);
	digitalWrite(RELAY_COLDSIDE_CIRCLE,HIGH);
	delay(300);
	digitalWrite(RELAY_SUMP_HEATER,HIGH);
	delay(2000);
	digitalWrite(RELAY_HEATPUMP,LOW);
	delay(300);
	digitalWrite(RELAY_HOTSIDE_CIRCLE,LOW);
	delay(300);
	digitalWrite(RELAY_COLDSIDE_CIRCLE,LOW);
	delay(300);
	digitalWrite(RELAY_SUMP_HEATER,LOW);
	*/

	// step one revolution  in one direction:
	//!!! write self-test for EEV
	//----------------------------- self-test END
	#ifdef RS485_HUMAN
		if (((unsigned long)(millis_now - millis_last_printstats) > HUMAN_AUTOINFO)   ||   (millis_last_printstats == 0)  ) {
			PrintStats_Serial();
			millis_last_printstats = millis_now;
		}
	#endif
	//--------------------async fuctions start
	if (em_i == 0) {  
		supply_voltage = ReadVcc();
	}
	if (em_i < em_samplesnum) {
		sampleI_1 = analogRead(em_pin1);
		// Digital low pass filter extracts the 2.5 V or 1.65 V dc offset, then subtract this - signal is now centered on 0 counts.
		offsetI_1 = (offsetI_1 + (sampleI_1-offsetI_1)/1024);
		filteredI_1 = sampleI_1 - offsetI_1;
	
		// Root-mean-square method current
		// 1) square current values
		sqI_1 = filteredI_1 * filteredI_1;
		// 2) sum
		sumI_1 += sqI_1;
		
		em_i += 1;
	} else {
		em_i = 0;
		double I_RATIO = em_calibration *((supply_voltage/1000.0) / (ADC_COUNTS));
		async_Irms_1 = I_RATIO * sqrt(sumI_1 / em_samplesnum);
		async_wattage = async_Irms_1*220.0;
	
		//Reset accumulators
		sumI_1 = 0;
		
		//----------------------------- self-test !!!
		/*
		PrintS_and_D("Async impl. results 1:  ");
		PrintS_and_D(String(async_wattage));	           // Apparent power
		PrintS_and_D(" ");
		PrintS_and_D(String(async_Irms_1));	           // Irms
		PrintS_and_D(" voltage: ");
		PrintS_and_D(String(supply_voltage));
		*/
		//----------------------------- self-test END
		
	}
	#ifdef EEV_SUPPORT
		if (  	((( EEV_apulses < 0 ) && (EEV_fast == 1))						&&	 ((unsigned long)(millis_now - millis_eev_last_step) > (EEV_PULSE_FCLOSE_MILLIS))  	)	||
			((( EEV_apulses < 0 ) && (EEV_fast == 0))						&&	 ((unsigned long)(millis_now - millis_eev_last_step) > (EEV_PULSE_CLOSE_MILLIS)	) 	)	||
			((( EEV_apulses > 0 ) && 			(EEV_cur_pos < EEV_MINWORKPOS  	))	&&	 ((unsigned long)(millis_now - millis_eev_last_step) > (EEV_PULSE_WOPEN_MILLIS)	) 	)	||
			((( EEV_apulses > 0 ) && (EEV_fast == 1) &&  	(EEV_cur_pos >= EEV_MINWORKPOS	)) 	&&	 ((unsigned long)(millis_now - millis_eev_last_step) > (EEV_PULSE_FOPEN_MILLIS) )	)	||	
			((( EEV_apulses > 0 ) && (EEV_fast == 0) &&  	(EEV_cur_pos >= EEV_MINWORKPOS	)) 	&&	 ((unsigned long)(millis_now - millis_eev_last_step) > (EEV_PULSE_OPEN_MILLIS)  )	)	||
			(millis_eev_last_step == 0)
			) {
			if ( EEV_apulses != 0 ) {
				if ( EEV_apulses > 0 ) {
					if (EEV_cur_pos + 1 <= EEV_MAXPULSES) {
						EEV_cur_pos += 1;
						EEV_cur_step += 1;
						EEV_apulses -= 1;
					} else {
						EEV_apulses = 0;
						//PrintS_and_D("EEmax!");
					}
				}
				if ( EEV_apulses < 0 ) {
					if (	(EEV_cur_pos - 1 >= EEV_MINWORKPOS)	|| (EEV_adonotcare == 1) ) {
						EEV_cur_pos -= 1;
						EEV_cur_step -= 1;
						EEV_apulses += 1;
					} else {
						EEV_apulses = 0;
						//PrintS_and_D("EEmin!");
					}
				}
				if (EEV_cur_step  > 3) EEV_cur_step = 0;
				if (EEV_cur_step  < 0) EEV_cur_step = 3;
				x = EEV_steps[EEV_cur_step];
				digitalWrite	(EEV_1,	bitRead(x, 0));
				digitalWrite	(EEV_2,	bitRead(x, 1));
				digitalWrite	(EEV_3,	bitRead(x, 2));
				digitalWrite	(EEV_4,	bitRead(x, 3));
			}
			if (EEV_cur_pos < 0) { 
				EEV_cur_pos = 0;	
			}
			millis_eev_last_step = millis_now;
			#ifdef EEV_DEBUG 
				PrintS(String(EEV_cur_pos));	
			#endif
		}
	#endif
	//--------------------async fuctions END    
	
	if ( heatpump_state == 1   &&  async_wattage > c_wattage_max  ) {
		if (  ((unsigned long)(millis_now - millis_last_heatpump_off) > POWERON_HIGHTIME )	||	(async_wattage > c_wattage_max*2)) {
			#ifdef RS485_HUMAN 
				PrintS(("Overload." + String(async_wattage)));
			#endif
			millis_last_heatpump_on = millis_now;
			heatpump_state = 0;
			digitalWrite(RELAY_HEATPUMP, heatpump_state);
		}
	}
	
	//-------------------buttons processing
	#ifdef INPUTS_AS_BUTTONS
		
			z = digitalRead(BUT_LEFT);
			i = digitalRead(BUT_RIGHT);
			if ( (z == 1) && ( i == 1) ) {
				//
			} else if ( (z == 1) || ( i == 1) ) {
				#ifndef EEV_ONLY
					if ( z == 1 ) {
						x = Dec_T();
					} 
					if ( i == 1 ) {
						x = Inc_T();
					}
					if (x == 1) {
						PrintS_and_D("New aim: " + String(T_setpoint));
						delay(300);
					}
				#else
					if ( z == 1 ) {
						T_EEV_setpoint -= 0.25;
					}
					if ( i == 1 ) {
						T_EEV_setpoint += 0.25;
					}
					PrintS_and_D("New EEV Td: " + String(T_EEV_setpoint));
					delay(300);
				#endif
			}
			
	#endif
	//-------------------buttons processing END
	
	//-------------------display
	#if (DISPLAY == 2) || (DISPLAY == 1)
		if(  ((unsigned long)(millis_now - millis_displ_update) > millis_displ_update_interval )  ||  (millis_displ_update == 0) ) {
			//EEV_ONLY SUPPORT!!!!!!!
			#ifndef EEV_ONLY
				outString = "A:" + String(T_setpoint, 1) + " Real:";
				if (Ttarget.e == 1) {
					outString +=  String(Ttarget.T, 1);
				} else {
					outString +=  "ERR";
				}
				PrintS_and_D(outString, 1);    //do not print serial
				
				//2
				//#ifdef EEV_SUPPORT
				//	outString = "Tbe:" + String(Tbe.T, 1) + "Tae:" + String(Tbe.T, 1);
				//	Print_D2();
				//#endif
				if (Touter.e == 1){
					outString = "Outer:" + String(Touter.T, 1);
					Print_D2();
				}
			#else
				outString = "be:";
				if (Tbe.e == 1){
					outString += String(Tbe.T, 1);
				}
				outString += " ae:";
				if (Tae.e == 1){
					outString += String(Tae.T, 1);
				}
				PrintS_and_D(outString, 1);    //do not print serial
				
			#endif
			millis_displ_update = millis_now;
		}
	#endif
	//-------------------display END
	
	//-------------------check cycle
	if(  ((unsigned long)(millis_now - millis_prev) > millis_cycle )  ||  (millis_prev == 0) ) {
		millis_prev = millis_now;
		Get_Temperatures();  //      wdt_reset here due to 85.0'C filtration
		SaveSetpointEE();
	
		//--------------------important logic
		//check T sensors
		if ( ( errorcode == ERR_OK )     && (   (Tae.e == 1 && Tae.T == -127 )  	|| 
							(Tbe.e == 1 && Tbe.T == -127 )		|| 
							(Ttarget.e == 1 && Ttarget.T == -127 )	||
							(Tsump.e == 1 && Tsump.T == -127 ) 	|| 
							(Tci.e == 1 && Tci.T == -127 )		|| 
							(Tco.e == 1 && Tco.T == -127 )		|| 
							(Thi.e == 1 && Thi.T == -127 )		|| 
							(Tho.e == 1 && Tho.T == -127 )		|| 
							(Tbc.e == 1 && Tbc.T == -127 )		|| 
							(Tac.e == 1 && Tac.T == -127 )		|| 
							(Touter.e == 1 && Touter.T == -127 ) 	|| 
							(Ts1.e == 1 && Ts1.T == -127 )		|| 
							(Ts2.e == 1 && Ts2.T == -127 )          ) ) {
										errorcode = ERR_T_SENSOR;
										#ifdef RS485_HUMAN 
											PrintS_and_D("ERR:T.sens." + String(errorcode)); 
										#endif
		}
		//auto-clean sensor error on sensor appear	
		// add 1xor enable here!
		if ( ( errorcode == ERR_T_SENSOR ) && ( ( (Tae.e == 1 	&& Tae.T != -127 )	||(Tae.e	^1) )	&&
							( (Tbe.e == 1 	&& Tbe.T != -127 )	||(Tbe.e	^1) )	&&
							( (Ttarget.e == 1 && Ttarget.T != -127) ||(Ttarget.e	^1) )	&&
							( (Tsump.e == 1 && Tsump.T != -127 ) 	||(Tsump.e	^1) )	&&
							( (Tci.e == 1 	&& Tci.T != -127 ) 	||(Tci.e	^1) )	&&
							( (Tco.e == 1 	&& Tco.T != -127 )	||(Tco.e	^1) )	&& 
							( (Thi.e == 1 	&& Thi.T != -127 )	||(Thi.e	^1) )	&& 
							( (Tho.e == 1 	&& Tho.T != -127 )	||(Tho.e	^1) )	&& 
							( (Tbc.e == 1 	&& Tbc.T != -127 )	||(Tbc.e	^1) )	&& 
							( (Tac.e == 1 	&& Tac.T != -127 )	||(Tac.e	^1) )	&& 
							( (Touter.e == 1 && Touter.T != -127 ) 	||(Touter.e	^1) )	&&
							( (Ts1.e == 1 	&& Ts1.T != -127 )	||(Ts1.e	^1) )	&&
							( (Ts2.e == 1 	&& Ts2.T != -127 )      ||(Ts2.e	^1) )   ) ) {
										errorcode = ERR_OK;
		}
			
		//process errors
		//beep N times error
		if ( errorcode != ERR_OK ) {
			if (  ((unsigned long)(millis_now - millis_notification) > millis_notification_interval)  ||  millis_notification == 0 ) {
				millis_notification = millis_now;
				#ifdef RS485_HUMAN 
					PrintS_and_D("Error:" + String(errorcode));
				#endif
				for ( i = 0; i < errorcode; i++) {
					tone(speakerOut, ERR_HZ);  	delay (500);      
					noTone(speakerOut);      	delay (500);
				}
			}
		}

		//-------------- EEV cycle
		#ifdef EEV_SUPPORT
			/*
			//v1 algo
			if ( EEV_apulses == 0 )	{
				if ( 	((async_wattage < c_workingOK_wattage_min) && ((unsigned long)(millis_now - millis_eev_last_close) > EEV_CLOSEEVERY))		||  millis_eev_last_close == 0  ){
					PrintS_and_D("EEV: FULL closing");//!!!
					if ( millis_eev_last_close != 0 ) {
						EEV_apulses =  -(EEV_cur_pos + EEV_CLOSE_ADD_PULSES);
					} else {
						EEV_apulses =  -(EEV_MAXPULSES + EEV_CLOSE_ADD_PULSES);
					}
					EEV_adonotcare = 1;
					EEV_fast = 1;
					//delay(EEV_STOP_HOLD);
					millis_eev_last_close = millis_now;
				} else if (errorcode != 0 || async_wattage <= c_workingOK_wattage_min) {		//err or sleep
					PrintS_and_D("EEV: err or sleep");//!!!
					if (EEV_cur_pos <= 0 && EEV_OPEN_AFTER_CLOSE != 0) {				//set waiting pos
						EEV_apulses = +EEV_OPEN_AFTER_CLOSE;
						EEV_adonotcare = 0;
						EEV_fast = 1;
					}
					if (EEV_cur_pos > 0  && EEV_cur_pos != EEV_OPEN_AFTER_CLOSE && EEV_cur_pos <= EEV_MAXPULSES) {	//waiting pos. set
						PrintS_and_D("EEV: close");//!!!
						EEV_apulses =  -(EEV_cur_pos + EEV_CLOSE_ADD_PULSES);
						EEV_adonotcare = 1;
						EEV_fast = 1;
					}
				} else if (errorcode == 0 && async_wattage > c_workingOK_wattage_min) {
					T_EEV_dt = Tae.T - Tbe.T;
					PrintS_and_D("EEV: driving " + String(T_EEV_dt));//!!!
					if (EEV_cur_pos <= 0){
						PrintS_and_D("EEV: full close protection");	
						if (EEV_OPEN_AFTER_CLOSE != 0) {				//full close protection
							EEV_apulses = +EEV_OPEN_AFTER_CLOSE;
							EEV_adonotcare = 0;
							EEV_fast = 1;
						}
					} else if (EEV_cur_pos > 0) {
						if (T_EEV_dt  < (T_EEV_setpoint - EEV_EMERG_DIFF) ) {				//emerg!
							PrintS_and_D("EEV: emergency closing!");//!!!
							EEV_apulses = -EEV_EMERG_STEPS;
							EEV_adonotcare = 0;
							EEV_fast = 1;
						} else if (T_EEV_dt  < T_EEV_setpoint) {					//too
							PrintS_and_D("EEV: closing");//!!!
							//EEV_apulses = -EEV_NONPRECISE_STEPS;
							EEV_apulses = -1;
							EEV_adonotcare = 0;
							EEV_fast = 0;
						} else if (T_EEV_dt  > T_EEV_setpoint + EEV_HYSTERESIS + EEV_PRECISE_START) {	//very
							PrintS_and_D("EEV: fast opening");//!!!
							//EEV_apulses =  +EEV_NONPRECISE_STEPS;
							EEV_apulses =  +1;
							EEV_adonotcare = 0;
							EEV_fast = 1;
						} else if (T_EEV_dt > T_EEV_setpoint + EEV_HYSTERESIS) {			//too
							PrintS_and_D("EEV: opening");//!!!
							EEV_apulses =  +1;
							EEV_adonotcare = 0;
							EEV_fast = 0;
						} else if (T_EEV_dt  > T_EEV_setpoint) {					//ok
							PrintS_and_D("EEV: OK");//!!!
							//
						}
					}
					off_EEV();
				} 
				
			}
			*/
			//v1.1 algo
			if ( errorcode == 0 && async_wattage > c_workingOK_wattage_min && EEV_cur_pos > 0 )	{
				T_EEV_dt = Tae.T - Tbe.T;
				#ifdef EEV_DEBUG
					PrintS("EEV Td: " + String(T_EEV_dt));
				#endif
				if ( EEV_apulses >= 0 && EEV_cur_pos >= EEV_MINWORKPOS)	{
					if (T_EEV_dt  < (T_EEV_setpoint - EEV_EMERG_DIFF) ) {				//emerg!
						#ifdef EEV_DEBUG
							PrintS(F("EEV: 1 emergency closing!"));
						#endif
						EEV_apulses = -1;
						EEV_adonotcare = 0;
						EEV_fast = 1;
					} else if (T_EEV_dt  < T_EEV_setpoint) {					//too
						#ifdef EEV_DEBUG
							PrintS(F("EEV: 2 closing"));
						#endif
						//EEV_apulses = -EEV_NONPRECISE_STEPS;
						EEV_apulses = -1;
						EEV_adonotcare = 0;
						EEV_fast = 0;
					}
					//faster open when needed, condition copypasted (see EEV_apulses <= 0)
					if (T_EEV_dt  > T_EEV_setpoint + EEV_HYSTERESIS + EEV_PRECISE_START) {		//very
						#ifdef EEV_DEBUG
							PrintS(F("EEV: 3 enforce faster opening"));
						#endif
						//EEV_apulses =  +EEV_NONPRECISE_STEPS;
						//EEV_apulses =  +1;
						EEV_adonotcare = 0;
						EEV_fast = 1;
					}
				}
				if ( EEV_apulses <= 0 )	{
					if (T_EEV_dt  > T_EEV_setpoint + EEV_HYSTERESIS + EEV_PRECISE_START) {		//very
						#ifdef EEV_DEBUG
							PrintS(F("EEV: 4 fast opening"));
						#endif
						//EEV_apulses =  +EEV_NONPRECISE_STEPS;
						EEV_apulses =  +1;
						EEV_adonotcare = 0;
						EEV_fast = 1;
					} else if (T_EEV_dt > T_EEV_setpoint + EEV_HYSTERESIS) {			//too
						#ifdef EEV_DEBUG
							PrintS(F("EEV: 5 opening"));
						#endif
						EEV_apulses =  +1;
						EEV_adonotcare = 0;
						EEV_fast = 0;
					} else if (T_EEV_dt  > T_EEV_setpoint) {					//ok
						#ifdef EEV_DEBUG
							PrintS(F("EEV: 6 OK"));
						#endif
						//
					}
					//faster closing when needed, condition copypasted (see EEV_apulses >= 0)
					if (T_EEV_dt  < (T_EEV_setpoint - EEV_EMERG_DIFF) ) {				//emerg!
						#ifdef EEV_DEBUG
							PrintS(F("EEV: 7 enforce faster closing!"));
						#endif
						//EEV_apulses = -EEV_EMERG_STEPS;
						EEV_adonotcare = 0;
						EEV_fast = 1;
					}
				}
				off_EEV();
			}
			if ( EEV_apulses == 0 )	{
				if ( 	((async_wattage < c_workingOK_wattage_min) && ((unsigned long)(millis_now - millis_eev_last_close) > EEV_CLOSEEVERY))		||  millis_eev_last_close == 0  ){	//close every 24h by default
					#ifdef EEV_DEBUG
						PrintS(F("EEV: 10 FULL closing"));
					#endif
					if ( millis_eev_last_close != 0 ) {
						EEV_apulses =  -(EEV_cur_pos + EEV_CLOSE_ADD_PULSES);
					} else {
						EEV_apulses =  -(EEV_MAXPULSES + EEV_CLOSE_ADD_PULSES);
					}
					EEV_adonotcare = 1;
					EEV_fast = 1;
					//delay(EEV_STOP_HOLD);
					millis_eev_last_close = millis_now;
				} else if (errorcode != 0 || async_wattage < c_workingOK_wattage_min) {		//err or sleep
					if (EEV_cur_pos > 0  && EEV_cur_pos > EEV_OPEN_AFTER_CLOSE) {	//waiting pos. set
						#ifdef EEV_DEBUG
							PrintS(F("EEV: 11 close before open"));
						#endif
						EEV_apulses =  -(EEV_cur_pos + EEV_CLOSE_ADD_PULSES);
						EEV_adonotcare = 1;
						EEV_fast = 1;
					}
				}
				off_EEV();
			}
			if ( EEV_apulses == 0 && async_wattage < c_workingOK_wattage_min && EEV_cur_pos < EEV_OPEN_AFTER_CLOSE) {
				#ifdef EEV_DEBUG
					PrintS(F("EEV: 12 full close protection"));
				#endif
				if (EEV_OPEN_AFTER_CLOSE != 0) {				//full close protection
					EEV_apulses = EEV_OPEN_AFTER_CLOSE - EEV_cur_pos;
					EEV_adonotcare = 0;
					EEV_fast = 1;
				}
				off_EEV();
			}
			if ( EEV_apulses == 0 && async_wattage >= c_workingOK_wattage_min && EEV_cur_pos < EEV_MINWORKPOS) {
				#ifdef EEV_DEBUG
					PrintS(F("EEV: 13 open to work"));	
				#endif
				if (EEV_MINWORKPOS != 0) {					//full close protection
					EEV_apulses = EEV_MINWORKPOS - EEV_cur_pos;
					EEV_adonotcare = 0;
					EEV_fast = 1;
				}
				off_EEV();
			}
			if (	((unsigned long)(millis_now - millis_eev_last_on) > 10000)  ||  millis_eev_last_on == 0 ) {
				//PrintS_and_D("EEV: ON/OFF");
				on_EEV();
				//delay(30);
				//off_EEV();	//off_EEV called everywhere takes care of it
				millis_eev_last_on  =  millis_now;
			}
		#endif
		//-------------- EEV cycle END

		#ifndef EEV_ONLY
			//process heatpump sump heater
			if (Tsump.e == 1) {
				if ( Tsump.T < cT_sump_heat_threshold   &&   sump_heater_state == 0   &&   Tsump.T != -127) {
					sump_heater_state = 1;
				} else if (Tsump.T >= cT_sump_heat_threshold  && sump_heater_state == 1) {
					sump_heater_state = 0;
				} else if (Tsump.T == -127) {
					sump_heater_state = 0;
				}
				halifise();
			}
	
	
	
			//main logic
			if (_1st_start_sleeped == 0) {
				//PrintS_and_D("!!!!sleep disabled!!!!");
				//_1st_start_sleeped = 1;
				if ( (millis_now < poweron_pause) && (_1st_start_sleeped == 0) ) {
					PrintS_and_D("Wait: " + String(((poweron_pause-millis_now))/1000) + " s.");
					return;
				} else {
					_1st_start_sleeped = 1;
				}
			}
			
			//process_heatpump:
			//start if
			//    (last_on > N or not_started_yet)
			//    and (no errors)
			//    and (t hot out < t target + heat_delta_min)
			//    and (sump t > min'C)
			//    and (sump t < max'C)
			//    and (t watertank < target)
			//    and (t after evaporator > after evaporator min)
			//    and (t cold in > cold min)
			//    and (t cold out > cold min)
			if ( 	heatpump_state == 0     		&&
				(((unsigned long)(millis_now - millis_last_heatpump_on) > mincycle_poweroff)   ||   (millis_last_heatpump_on == 0)  )  &&
				//( tr_hot_out < (tr_sens_1 + cT_hotcircle_delta_min)  )    &&
				errorcode == 0         							&&
				( (Tsump.e == 1 	&& Tsump.T > cT_sump_min)  	|| (Tsump.e^1))	&&
				( (Tsump.e == 1 	&& Tsump.T < cT_sump_max)  	|| (Tsump.e^1))	&&
				//t1_sump > t2_cold_in   && ???
				Ttarget.T < T_setpoint  						&&    //was room here, change to advanced algo with room temperature
				( (Tae.e == 1 	&& Tae.T > cT_after_evaporator_min)	|| (Tae.e^1))	&&
				( (Tbc.e == 1 	&& Tbc.T < cT_before_condenser_max) 	|| (Tbc.e^1))	&&
				( (Tci.e == 1 	&& Tci.T > cT_cold_min)  		|| (Tci.e^1))	&&
				( (Tco.e == 1 	&& Tco.T > cT_cold_min) 		|| (Tco.e^1))	) {
					#ifdef RS485_HUMAN
						PrintS(F("Start"));
					#endif
					millis_last_heatpump_off = millis_now;
					heatpump_state = 1;
			}
			
			//stop if
			//    ( (last_off > N) and (t watertank > target) )
			if ( heatpump_state == 1     &&     ((unsigned long)(millis_now - millis_last_heatpump_off) > mincycle_poweron)    &&    (Ttarget.T > T_setpoint)) {
				#ifdef RS485_HUMAN 
					PrintS(F("Normal stop"));
				#endif
				millis_last_heatpump_on = millis_now;
				heatpump_state = 0;
			}
		
			//process_hot_side_pump:
			//start if (heatpump_enabled)
			//stop if (heatpump_disabled and (t hot out or in < t target + heat delta min) )
			if (  (heatpump_state == 1)   &&  (hotside_circle_state  == 0)  ) {    
				#ifdef RS485_HUMAN 
					PrintS(F("Hot WP ON"));
				#endif
				hotside_circle_state  = 1;
			}
			
			if (  (heatpump_state == 0)        &&    (hotside_circle_state  == 1) ) {
				if (  (deffered_stop_hotcircle != 0 	&& 	((unsigned long)(millis_now - millis_last_heatpump_on) > deffered_stop_hotcircle)   )	) {
					if ( 	(Tho.e == 1 && Tho.T < (Ttarget.T + cT_hotcircle_delta_min))	||
						(Thi.e == 1 && Thi.T < (Ttarget.T + cT_hotcircle_delta_min))	) {
						#ifdef RS485_HUMAN 
							PrintS(F("Hot WP OFF 1"));
						#endif
						hotside_circle_state  = 0;
					} else {
						#ifdef RS485_HUMAN 
							PrintS(F("Hot WP OFF 2"));
						#endif
						hotside_circle_state  = 0;
					}
				}
			}
			
			//heat if we can, just in case, ex. if lost power
			if ( (hotside_circle_state  == 0) && 
				( Tho.e == 1 && Tho.T > (Ttarget.T + cT_hotcircle_delta_min)  )  	||
				( Thi.e == 1 && Thi.T > (Ttarget.T + cT_hotcircle_delta_min)  )  ) {
					#ifdef RS485_HUMAN 
						PrintS(F("Hot WP ON"));
					#endif
					hotside_circle_state  = 1;
			}
			
			//process_cold_side_pump:
			//start if (heatpump_enabled)
			//stop if (heatpump_disbled)
			if (  (heatpump_state == 1)   &&  (coldside_circle_state  == 0)  ) {
				#ifdef RS485_HUMAN 
					PrintS(F("Cold WP ON"));
				#endif
				coldside_circle_state  = 1;
			}
			
			if (  (heatpump_state == 0)   &&  (coldside_circle_state  == 1)  ) {
				#ifdef RS485_HUMAN 
					PrintS(F("Cold WP OFF"));
				#endif
				coldside_circle_state  = 0;
			}
			
			
			//protective_cycle:
			//stop if
			//      (error)
			//      (t hot out > hot out max)
			//      (sump t > max'C)
			//      or (t after evaporator < after evaporator min)
			//      or (t cold in < cold min)
			//      or (t cold out < cold min)
			//          
			if (  heatpump_state == 1   &&  
				(	errorcode != 0                             		||
					(Tho.e 	== 1 	&&	Tho.T 	> cT_hotout_max)      	||
					(Tsump.e == 1 	&&	Tsump.T > cT_sump_max)   	||
					(Tae.e 	== 1 	&& 	Tae.T 	< cT_after_evaporator_min) ||
					(Tbc.e 	== 1 	&& 	Tbc.T 	> cT_before_condenser_max) ||
					(Tci.e 	== 1 	&& 	Tci.T 	< cT_cold_min )       	||
					(Tco.e 	== 1 	&& 	Tco.T 	< cT_cold_min) )     ) {
						#ifdef RS485_HUMAN 
							PrintS(F("Protective stop"));
						#endif
						millis_last_heatpump_on = millis_now;
						heatpump_state = 0;
						digitalWrite(RELAY_HEATPUMP, heatpump_state);
			}
			
			//alive_check_cycle_after_5_mins:
			//error if
			//v1.3: not error, just poweroff all
			//      or (t cold in - t cold out < t workingok min)
			//      or (t hot out - t hot in < t workingok min)
			//      or (sump t < 25'C)
			//      or wattage too low
			
			if (  heatpump_state == 1   &&  ((unsigned long)(millis_now - millis_last_heatpump_off) > 300000)  ) {
				//cold side processing simetimes works incorrectly, after long period of inactivity, due to T inertia on cold tube sensor, commented out
				//if ( ( errorcode == ERR_OK )     &&   (  tr_cold_in - tr_cold_out < cT_workingOK_cold_delta_min ) ) {
				//    errorcode = ERR_COLD_PUMP;
				//}
				//if ( ( errorcode == ERR_OK )     &&   (  Tho.e == 1 && Thi.e == 1 && (Tho.T - Thi.T < cT_workingOK_hot_delta_min )) ) {
				//	errorcode = ERR_HOT_PUMP;
				//}
				if ( ( errorcode == ERR_OK )     &&   (  Tsump.e == 1 && Tsump.T < cT_workingOK_sump_min )  ) {
					//errorcode = ERR_HEATPUMP;
					millis_last_heatpump_on = millis_now;
					heatpump_state = 0;
				}
				if ( ( errorcode == ERR_OK )     &&   ( async_wattage < c_workingOK_wattage_min )  ) {
					//errorcode = ERR_WATTAGE;
					millis_last_heatpump_on = millis_now;
					heatpump_state = 0;
				}
				digitalWrite(RELAY_HEATPUMP, heatpump_state);
			}
				
			//disable pump by error
			if ( errorcode != ERR_OK ) {
				millis_last_heatpump_on = millis_now;
				heatpump_state = 0;
				digitalWrite(RELAY_HEATPUMP, heatpump_state);
				#ifdef RS485_HUMAN 
					PrintS("Error stop: " + String(errorcode, HEX));
				#endif
			}
			
			//!!! self-test
			///heatpump_state = 1;
			
			//write states to relays
			digitalWrite	(RELAY_HEATPUMP, 	heatpump_state);
			digitalWrite	(RELAY_COLDSIDE_CIRCLE,	coldside_circle_state);
			halifise();
		#endif
	}
	
	if (RS485Serial.available() > 0) {
		//RS485Serial.println("some on serial..");	//!!!debug
		#ifdef RS485_HUMAN
			if (RS485Serial.available()) {
				inChar = RS485Serial.read();
				//RS485Serial.print(inChar);	//!!!debug
				if ( inChar == 0x1B ) {
					skipchars += 3;
					inChar = 0x00;
					millis_escinput = millis();
				}
				if ( skipchars != 0 ) {
					millis_charinput = millis();
					//if (millis_escinput + 2 > millis_charinput)
					if ((unsigned long)(millis_charinput - millis_escinput) < 16*2 ) {	//2 chars for 2400
						if (inChar != 0x7e) {
							skipchars -= 1;
						}
						if (inChar == 0x7e) {
							skipchars = 0;
						}
						if (inChar >= 0x30 && inChar <= 0x35) {
							skipchars += 1;
						}
						inChar = 0x00;
					} else {
						skipchars = 0;
					}
				}
			
				//- RS485_HUMAN: remote commands +,-,G,0x20/?/Enter
				switch (inChar) {
					case 0x00:
						break;
					case 0x20:
						_PrintHelp();
						break;
					case 0x3F:
						_PrintHelp();
						break;
					case 0x0D:
						_PrintHelp();
						break;
					case 0x2B:
						Inc_T();
						break;
					case 0x2D:
						Dec_T();
						break;
					case 0x3C:
						Dec_E();
						break;
					case 0x3E:
						Inc_E();
						break;
					case 0x47:
						PrintStats_Serial();
						break;
					case 0x67:
						PrintStats_Serial();
						break;
					}
			}
		#endif
        
		#ifdef RS485_PYTHON
			index = 0;
			while (RS485Serial.available() > 0) { // Don't read unless you know there is data
				if(index < 49) {   //  size of the array minus 1
					inChar = RS485Serial.read(); 	// Read a character
					inData[index] = inChar;      	// Store it
					index++;                     	// Increment where to write next
					inData[index] = '\0';        	// clear next symbol, null terminate the string
					delayMicroseconds(80);       	//80 microseconds - the best choice at 9600, "no answer"disappeared
									//40(20??) microseconds seems to be good, 9600, 49 symbols
									//
				} else {            //too long message! read it to nowhere
					inChar = RS485Serial.read();
					delayMicroseconds(80);
					//break;    //do not break if symbols!!
				}
			}
		
			//!!!debug, be carefull, can cause strange results
			/*
			if (inData[0] != 0x00) {
			RS485Serial.println("-");
			RS485Serial.println(inData);
			RS485Serial.println("-");
			}*/
			//or this debug
			/*
			digitalWrite(SerialTxControl, RS485Transmit);
			delay(10);
			RS485Serial.println(inData);
			RS485Serial.flush();
			RS485Serial.println(index);
			*/
			
			//ALL lines must be terminated with \n!
			if ( (inData[0] == hostID) && (inData[1] == devID) ) {             
				//  COMMANDS:
				// G (0x47): (G)et main data
				// TNN.NN (0x54): set aim (T)emperature
				digitalWrite(SerialTxControl, RS485Transmit);
				delay(1);
				//PrintS_and_D(freeMemory());
				outString = "";
				outString += devID;
				outString += hostID;
				outString +=  "A ";  //where A is Answer, space after header
			
				if ( (inData[2] == 0x47 ) ) {
					//PrintS_and_D("G");
					//WARNING: this procedure can cause "NO answer" effect if no or few T sensors connected
					outString += "{";
					outString += "\"E1\":" + String(errorcode);  
					if (Ts1.e == 1) {
						outString += ",\"TS1\":" + String(Ts1.T);
					}
					if (Tsump.e == 1) {
						outString += ",\"TS\":" + String(Tsump.T);
					}
					if (Tho.e == 1) {
						outString += ",\"THO\":" + String(Tho.T);
					}
					if (Tae.e == 1) {
						outString += ",\"TAE\":" + String(Tae.T);
					}
					char *outChar=&outString[0];
					RS485Serial.write(outChar);                    	//dirty hack to transfer long string
					RS485Serial.flush();
					delay (1);                                      //lot of errors without delay
					outString = "";
					if (Tbe.e == 1) {
						outString += ",\"TBE\":" + String(Tbe.T);                
					}
					if (Touter.e == 1) {
						outString += ",\"TO\":" + String(Touter.T);
					}
					if (Tco.e == 1) {
						outString += ",\"TCO\":" + String(Tco.T);
					}
					outString += ",\"W1\":" + String(async_wattage);
					#ifndef EEV_ONLY
						outString += ",\"A1\":" + String(T_setpoint);  //(A)im (target)
						outString += ",\"RP\":" + String(heatpump_state*RELAY_HEATPUMP);  
					#endif
					if (Tci.e == 1) {
						outString += ",\"TCI\":" + String(Tci.T);
					}
					RS485Serial.write(outChar);                       //dirty hack to transfer long string
					RS485Serial.flush();
					delay (1);                                        //lot of errors without delay
					outString = "";
					if (Thi.e == 1) {
						outString += ",\"THI\":" + String(Thi.T);
					}
					#ifndef EEV_ONLY
						outString += ",\"RSH\":" + String(sump_heater_state*3);                  
						outString += ",\"RH\":" + String(hotside_circle_state*2);                  
						outString += ",\"RC\":" + String(coldside_circle_state*1);  
					#endif
					if (Tbc.e == 1) {
						outString += ",\"TBC\":" + String(Tbc.T);
					}
					RS485Serial.write(outChar);                        //dirty hack to transfer long string
					RS485Serial.flush();
					delay (1);                                        //lot of errors without delay
					outString = "";
					if (Ts2.e == 1) {
						outString += ",\"TS2\":" + String(Ts2.T);
					}
					if (Tac.e == 1) {
						outString += ",\"TAC\":" + String(Tac.T);
					}
					if (Ttarget.e == 1) {
						outString += ",\"TT\":" + String(Ttarget.T);                                
					}
					#ifdef EEV_SUPPORT
						outString += ",\"EEVP\":" + String(EEV_cur_pos);
						outString += ",\"EEVA\":" + String(T_EEV_setpoint);
					#endif
					outString += "}";
				} else if ( (inData[2] == 0x54 ) || (inData[2] == 0x45 )) {  //(T)arget or (E)EV target format NN.NN, text
					if ( isDigit(inData[ 3 ]) && isDigit(inData[ 4 ]) && (inData[ 5 ] == 0x2e)  && isDigit(inData[ 6 ]) && isDigit(inData[ 7 ]) && ( ! isDigit(inData[ 8 ])) ) {
						
						tone(speakerOut, 2250);
						delay (100); // like ups power on
						noTone(speakerOut);
						
						char * carray = &inData[ 3 ];
						tempdouble = atof(carray);                
						if (inData[2] == 0x54 ){
							if (tempdouble > cT_setpoint_max) {
								outString += "{\"err\":\"too hot!\"}";
							} else if (tempdouble < 1.0) {
								outString += "{\"err\":\"too cold!\"}";
							} else {
								T_setpoint = tempdouble;
								outString += "{\"result\":\"ok, new value is: ";
								outString += String(T_setpoint);
								outString += "\"}";
							}
						}
						if (inData[2] == 0x45 ) {
							if (tempdouble > 10.0) {		//!!!!!!! hardcode !!!
								outString += "{\"err\":\"too hot!\"}";
							} else if (tempdouble < 0.1) {		//!!!!!!! hardcode !!!
								outString += "{\"err\":\"too cold!\"}";
							} else {
								T_EEV_setpoint = tempdouble;
								outString += "{\"result\":\"ok, new EEV value is: ";
								outString += String(T_EEV_setpoint);
								outString += "\"}";
							}
						}
					} else {
						outString += "{\"err\":\"NaN, format: NN.NN\"}";
					}
				} else {
					//default, just for example
					outString += "{\"err\":\"no_command\"}";
				}
				//crc.integer = CRC16.xmodem((uint8_t& *) outString, outString.length());
				//outString += (crc, HEX);
				outString += "\n";
				char *outChar=&outString[0];
				RS485Serial.write(outChar);
			}
			
			index = 0;
			for (i=0;i<49;i++) {  //clear buffer
				inData[i]=0;
			}
			RS485Serial.flush();
			digitalWrite(SerialTxControl, RS485Receive);
			delay(1);
		#endif
	}
    
}