Valden_HeatPumpController.ino

/*
	
	Valden Heat Pump.
	
	Heat Pump Controller firmware.
	
	https://github.com/OpenHP/
	
	Copyright (C) 2018-2021 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/>.
*/


//-----------------------USER OPTIONS-----------------------
//#define SELFTEST_RELAYS_LEDS_SPEAKER		//speaker and relays QA test, uncomment to enable
//#define SELFTEST_EEV				//EEV QA test, uncomment to enable
//#define SELFTEST_T_SENSORS			//temperature sensors QA test, uncomment to enable

//communication protocol with external world
//#define RS485_JSON		1  		//json, external systems integration
//#define RS485_HUMAN   	2		//RS485 is used in the same way as the local console, warning: Use only if 2 devices (server and this controller) connected to the same RS485 line
#define RS485_MODBUS 		3 		//default, MODBUS via RS485, connection to the display (both sensor or 1602, see https://GitHub.com/OpenHP/Display/) or connection to any other MODBUS application or device 

//system type, comment both if HP with EEV
//#define	EEV_ONLY			//Valden controller as EEV controller: NO target T sensor. No relays. Oly EEV. Sensors required: Tae, Tbe, current sensor. Additional T sensors can be used but not required.
//#define	NO_EEV				//capillary tube or TXV, EEV not used

//which sensor is used to check setpoint, uncomment one of options
#define SETPOINT_THI				//"warm floor" scheme: "hot in" (Thi) temperature used as setpoint
//#define SETPOINT_TS1				//"swimming pool" or "water tank heater" scheme: "sensor 1" (Ts1) is used as setpoint and located somewhere in a water tank

#define HUMAN_AUTOINFO	30000			//print stats to console, every milliseconds

#define WATCHDOG          			//disable for older bootloaders
//-----------------------USER OPTIONS END-----------------------



//-----------------------Fine Tuning OPTIONS-----------------------
//next sections: advanced options



//-----------------------T Sensors -----------------------
//temperature sensors used in a system, comment to disable 
#define T_cold_in;			//cold side (heat source) inlet sensor
#define T_cold_out;			//cold side outlet sensor
#define T_before_evaporator;		//"before" and "after evaporator" sensors required to control EEV, both "EEV_ONLY" and "full" schemes  
#define T_after_evaporator;		//"before" and "after evaporator" sensors required to control EEV, both "EEV_ONLY" and "full" schemes 
//#define T_separator_gas;		//no longer used (PCB 1.3 MI +) artifact from experimental scheme with separator 
//#define T_separator_liquid;		//no longer used (PCB 1.3 MI +) artifact from experimental scheme with separator 
//#define T_before_valve;		//no longer used (PCB 1.3 MI +) artifact from experimental scheme with separator 
//#define T_suction;			//no longer used (PCB 1.3 MI +) artifact from experimental scheme with separator 
#ifdef SETPOINT_TS1
	#define T_sensor_1;		//T values from the additional sensor S1 used as a "setpoint" in "pool" or "water tank heater" schemes  
#endif
//!!!
#define T_sensor_2;			//additional sensor, any source; for example, outdoor temperature, in-case temperature, and so on
#define T_crc;				//if defined, enables the crankcase T sensor and crankcase heater on the relay "Crankcase heater"
//#define T_regenerator;		//an additional sensor, the regenerator temperature sensor (inlet or outlet or housing); used only to obtain a temperature data if necessary 
#define T_afrer_condenser;		//after condenser (and before valve)
//!!!#define T_before_condenser;	//before condenser (discharge)
#define T_hot_out;			//hot side outlet
//In full scheme Hot IN required! Optional in "EEV_ONLY" scheme (see "EEV_ONLY" option), 
#define T_hot_in;			//hot side inlet

//-----------------------TEMPERATURES-----------------------
#define MAGIC     		0x66;  		//change this value if you want to rewrite the T setpoint in EEPROM 
#define	T_SETPOINT		26.0;		//This is a predefined target temperature value (start temperature). EEPROM-saved. Ways to change this value: 1. Console command 2. Change the "setpoint" on a display 3. Change value here AND change "magic number" 4. JSON command
#define T_SETPOINT_MAX 		48.0;  		//maximum "setpoint" temperature that an ordinary user can set
#define T_SETPOINT_MIN		10.0;		//min. "setpoint" temperature that an ordinary user can set, lower values not recommended until antifreeze fluids at hot side used.
#define T_CRANKCASE_MIN 		8.0;	//compressor (crankcase) min. temperature, HP will not start if T lower
#define T_CRANKCASE_MAX 		110.0;	//compressor (crankcase) max. temperature, overheating protection, HP will stop if T higher
#define T_CRANKCASE_HEAT_THRESHOLD 	16.0;	//crankcase heater threshold, the compressor heater will be powered on if T lower
#define T_WORKINGOK_CRANKCASE_MIN 	25.0;	//compressor temperature: additional check. HP will stop if T is lower than this value after 5 minutes of work. Do not set the value too high to ensure normal operation after long pauses. 
#define T_BEFORE_CONDENSER_MAX 	108.0;      	//discharge MAX, system stops if discharge higher
#define T_COLDREF_MIN 		-14.0;		//suction min., HP stops if T lower, cold side (glycol) loop freeze protection and compressor protection against liquid 
#define T_BEFORE_EVAP_WORK_MIN 	-25.5;		//!!!before evaporator (after valve) min. T; can be very low for a few minutes after a startup, ex: capillary tube in some conditions; and for all systems: after long shut-off, lack of refrigerant, 1st starts, and many others
#define T_COLD_MIN 		-15.5;		//cold side (glycol) loop freeze protection: HP stops if inlet or outlet temperature lower
#define T_HOT_MAX 		50.0;		//hot loop: HP stops if hot side inlet or outlet temperature higher than this threshold

//#define T_REG_HEAT_THRESHOLD	17.0;		//no longer used (PCB 1.3 MI +) artifact from experimental scheme with separator 
//#define T_HOTCIRCLE_DELTA_MIN 	2.0;	//not used since ~FW v1.6, "water heater with intermediate heat exchanger" scheme, where Ts1 == "sensor in water"; hot side CP will be switched on if "Ts1 - hot_out > T_HOTCIRCLE_DELTA_MIN"

//-----------------------WATTS AND CYCLES TIMES-----------------------
//time: milliseconds, power: watts
#define MAX_WATTS	1000.0 + 70.0 + 80.0	//power limit, watt, HP stops if exceeded, examples: 	//	installation1: compressor 165: 920 Watts, + 35 watts 25/4 circ. pump at 1st speed + 53 watts 25/4 circ. pump at 2nd speed
													//	installation2: compressor unk: ~1000 + hot CP 70 + cold CP 80 = 1150 watts
													//	installation3: and so on
#define POWERON_PAUSE     	300000    	//after power on: 			wait 5 minutes before starting HP (power faults protection) 
#define MINCYCLE_POWEROFF 	600000    	//after a normal compressor stop: 	10 minutes pause (max 99999 seconds) 
#define MINCYCLE_POWERON  	3600000  	//after compressor start: 		minimum compressor operation time, i.e. work time is not less than this value (or more, depending on the setpoint temperature) 60 minutes = 3.6 KK 120mins = 5.4 kK.
#define POWERON_HIGHTIME	7000		//after compressor start: 		defines time when power consumption can be 3 times greater than normal, 7 sec. by default
#define COLDCIRCLE_PREPARE	90000		//before compressor start:		power on cold CP and wait 90 sec.; if false start: CP will off twice this time; and (hotcircle_stop_after - this_value) must be > hotcircle_check_prepare or HP will go sleep cycle instead of start
#define DEFFERED_STOP_HOTCIRCLE	1200000		//after compressor stop:		wait 20 minutes, if no need to start compressor: stop hot WP; value must be > 0
#define HOTCIRCLE_START_EVERY	2400000		//while pauses:				pump on "hot side"  starts every 40 minutes (by default) (max 9999 seconds) to circulate water and get exact temperature reading, option used if "warm floor" installation (Thi as setpoint)...
#define HOTCIRCLE_CHECK_PREPARE	150000		//while pauses:				...and wait for temperature stabilization 2.5 minutes (by default), after that do setpoint checks...
#define HOTCIRCLE_STOP_AFTER	(HOTCIRCLE_CHECK_PREPARE + COLDCIRCLE_PREPARE + 30000)		//...and then stop after few minutes of circulating, if temperature is high and no need to start compressor; value must be check_prepare + coldcircle_prepare + 30 seconds (or more)


//-----------------------EEV-----------------------
//If you are using a capillary tube or TXV: simply skip next section.
//Depending on how many milliseconds allocated per step, the speed of automatic tuning will change.
//Remember that your refrigeration system reaction on every step is not immediate. The system reacts after a few minutes, sometimes after tens of minutes.

#define EEV_MAXPULSES		250		//max steps, 250 is tested for sanhua 1.3

//steps tuning: milliseconds per fast and slow (precise) steps
#define EEV_PULSE_FCLOSE_MILLIS	20		//(20 tube evaporator)		fast closing, closing on danger			(milliseconds per step)
#define EEV_PULSE_CLOSE_MILLIS	45000		//(50000 tube evaporator)	accurate closing while the compressor works 	(milliseconds per step)
#define EEV_PULSE_WOPEN_MILLIS	20		//(20 tube evaporator)		standby (waiting) pos. set			(milliseconds per step)
#define EEV_PULSE_FOPEN_MILLIS	1400		//(1300 tube evaporator)	fast opening, fast search 			(milliseconds per step)
#define EEV_PULSE_OPEN_MILLIS	30000		//(60000 tube evaporator)	accurate opening while the compressor works	(milliseconds per step)
#define EEV_STOP_HOLD		500		//0.1..1sec for Sanhua		hold time					(milliseconds per step)
#define EEV_CLOSEEVERY		86400000	//86400000: EEV full close (zero calibration) every 24 hours, executed while HP is NOT working	(milliseconds per cycle)

//positions
#define EEV_CLOSE_ADD_PULSES	8		//read below, additional steps after zero position while full closing 
#define EEV_OPEN_AFTER_CLOSE	45		//0 - set the zero position, then add EEV_CLOSE_ADD_PULSES (zero insurance, read EEV guides for this value) and stop, EEV will be in zero position. 
						//N - set the zero position, then add EEV_CLOSE_ADD_PULSES, than open EEV on EEV_OPEN_AFTER_CLOSE pulses
						//i.e. it's a "waiting position" while HP isn't working, value must be <= MINWORKPOS
#define EEV_MINWORKPOS		50		//position will be not less during normal work, open EEV to this position after compressor start

//temperatures
#define EEV_PRECISE_START	8.6		//(8.6 tube evaporator) 	precise tuning threshold: 		make slower pulses if (real_diff-target_diff) less than this value. Used for fine auto-tuning
#define EEV_EMERG_DIFF		1.7		//(2.5 tube evaporator) 	liquid at suction threshold:		if dangerous condition occurred, real_diff =< (target_diff - EEV_EMERG_DIFF)  then EEV will be closed to min. work position //Ex: EEV_EMERG_DIFF = 2.0, target diff 5.0, if real_diff =< (5.0 - 2.0) then EEV will be closed to EEV_MINWORKPOS
#define EEV_HYSTERESIS		0.45		//(0.6 tube evaporator) 	hysteresis, to stop fine tuning:	must be less than EEV_PRECISE_START, ex: target difference = 4.0, hysteresis = 0.3, no EEV pulses will be done while real difference in range 4.0..4.3 
#define EEV_TARGET_TEMP_DIFF	3.6		//(3.6 tube evaporator) 	target difference between Before Evaporator and After Evaporator, the head of the whole algorithm

//additional options
#define EEV_REOPENLAST		1		///1 = reopen to last position on compressor start, useful for ordinary schemes with everyday working cycles, 0 = not
#define EEV_REOPENMINTIME	40000		//after system start: min. delay between "min. work pos." (must be > 0 in this case and > waiting position) set and reopening start
//#define EEV_MANUAL				//comment to disable, manual set of EEV position via a console; warning: this option will stop all EEV auto-activities, including zero position find procedure; so this option not recommended: switch auto/manual mode from a console

//do not use next option if you're not sure what are you doing
//#define EEV_DEBUG				//debug, useful during system fine-tuning, works both with local serial and RS485_HUMAN
//-----------------------ADDRESSES-----------------------
const char devID  = 0x45;	//used only if JSON communication, does not matter for MODBUS and Valden display https://github.com/OpenHP/Display/
const char hostID = 0x30;	//used only if JSON communication, not used for MODBUS

//-----------------------OTHER-----------------------
#define MAX_SEQUENTIAL_ERRORS 	15 		//max cycles to wait auto-clean error, ex: T sensor appears, stop compressor after counter exceeded (millis_cycle * MAX_SEQUENTIAL_ERRORS)
//-----------------------Fine Tuning OPTIONS END -----------------------

//-----------------------changelog-----------------------
/*
v1.0, 01 Sep 2019:
+ initial version, hardware and software branch ready

v1.1: 21 Sep 2019:
+ Dev and Host ID to header

v1.2: 20 Dec 2019:
+- ?seems to be fixed minor bug while HP stopped: wattage is 0, if tCrc < T_CRANKCASE_HEAT_THRESHOLD and may be few sensors absence
+ min_user_t/max_user_t to header

v1.3: 05 Jan 2020:
+ manual EEV mode (high priority, ex: new system 1st starts and charge) 
+ rs485_modbus
+ reopen to last EEV value at startup

v1.4: 22 Jan 2020
+ crankcase naming

v1.5: 05 Jun 2020
+ minor modbus updates

v1.6: 09 Dec 2020
+ NO_EEV option
+ some variables renames
+ Tho instead of Thi (stop conditions) bugfix
+ Last Start Message added

v1.7: 03 Feb 2021
+ 1.3 PCB revision support, previous revisions also supported
+ enable cold circle if tci < col_min (circulate ground loop, if outdoor installation and very cold and deep freeze)
+ inputs support
+ add option "Thi" and "Ts1" to header, enable Ts1 by this option
+ temperature check after start of hot side circle + 5 mins for Thi target

v1.8: 06 Feb 2021
+ very rare case: 0.0 readings, 2-3 attempts then pass 0.0
+ countdown for compressor relay after cold CP start (stab. cold loop T)
+ self-test options to header

v1.9-1.11: 25-27 Feb 2021:
+ lot of small workflow logic and user terminal changes

v1.12: 21 Mar 2021:
+ TS1/THO #define way fix
+ CWP and HWP prepare optimisation

v1.13: 26 Mar 2021:
+ rounding error via Modbus found and fixed

//TODO:
? lower bit resolution for all sensors, except Tbe, Tae, Ts1 ?
? poss. DoS: infinite read to nowhere, fix it, set finite counter (ex: 200)
? add "heater start" and "cold circle start" and "not start HP" if t_crc < t_coldin/coldout(?)/tae/tbe(?) + 2.0
? ref. migration protection for summer season with long waiting periods: start cold circle and crankcase heater if tCrc =< tci+1, add option to header
? EEV manual mode and position by RS485 python or modbus command ?
? add speaker and err code for ""ERR: no Tae or Tbe for EEV!""
? deffered HWP stop: check HP stop cause, stop HWP if protective/error stop
? wclose and fclose to EEV
? valve_4way
? rewite re-init proc from MAGIC to another way
? EEV: target to EEPROM (?? no need ?)
? EEV: define maximum working position
*/
//-----------------------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   
//

//Speaker
//
// 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


/*
relay 1: heat pump
relay 2: hot side circulator pump
relay 3: cold side circulator pump
relay 4: crankcase heater
relay 5: (1.3+: not used anymore)

relay 6: reserved
relay 7: reserved

T sensors: 

0 cold_in;
1 cold_out;
2 before_evaporator;
3 after_evaporator;
4 separator_gas;	//if flooded evaporator: separator out
5 separator_liquid;	//if flooded evaporator: separator out
6 before_valve;		//before expansion valve, if regenerator used
7 suction;		//compressor suction, if regenerator
8 sensor_1;		//additional sensor 1
9 sensor_2;		//additional sensor 2
A crankcase;		//compressor case
B regenerator;
C afrer_condenser;
D before_condenser;
E hot_out;
F hot_in;
*/

String fw_version = "1.13";

//hardware resources
#define RELAY_HEATPUMP        	A2
#define RELAY_HOTSIDE_CIRCLE  	A1

#define PR_LOW		A6
#define PR_HIGH		A7

#define OW_BUS_ALLTSENSORS    9
#define speakerOut            6
#define em_pin1               A3


String hw_version = "v1.1+";

#define LATCH_595 		3
#define CLK_595 		2
#define DATA_595 		7
#define OE_595 			4

//---------------------------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>

#define SEED 	0xFFFF
#define POLY	0xA001
unsigned int 	crc16;
int 		cf;
#define MODBUS_MR 50	//50 ok now

#include <SoftwareSerial.h>
#define SerialRX        12	//RX connected to RO - Receiver Output  
#define SerialTX        11	//TX connected to DI - Driver Output Pin
#define SerialTxControl 13	//RS485 Direction control DE and RE to this pin
#define RS485Transmit    HIGH
#define RS485Receive     LOW

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);

DeviceAddress dev_addr;		//temp


//short names used to prevent unreadeable source
#ifdef T_cold_in
	bool TciE = 1;
#else
	bool TciE = 0;
#endif
double Tci = -127.0;

#ifdef T_cold_out
	bool TcoE = 1;
#else
	bool TcoE = 0;
#endif
double Tco = -127.0;

#ifdef T_before_evaporator
	bool TbeE = 1;
#else
	bool TbeE = 0;
#endif
double Tbe = -127.0;


#ifdef T_after_evaporator
	bool TaeE = 1;
#else
	bool TaeE = 0;
#endif
double Tae = -127.0;


/*
#ifdef T_separator_gas
	bool TsgE = 1;
#else
	bool TsgE = 0;
#endif
double Tsg = -127.0;


#ifdef T_separator_liquid
	bool TslE = 1;
#else
	bool TslE = 0;
#endif
double Tsl = -127.0;


#ifdef T_before_valve
	bool TbvE = 1;
#else
	bool TbvE = 0;
#endif
double Tbv = -127.0;


#ifdef T_suction
	bool TsucE = 1;
#else
	bool TsucE = 0;
#endif
double Tsuc = -127.0;
*/

#ifdef T_sensor_1
	bool Ts1E = 1;
#else
	bool Ts1E = 0;
#endif
double Ts1 = -127.0;


#ifdef T_sensor_2
	bool Ts2E = 1;
#else
	bool Ts2E = 0;
#endif
double Ts2 = -127.0;	


#ifdef T_crc
	bool TcrcE = 1;
#else
	bool TcrcE = 0;
#endif
double Tcrc = -127.0;

#ifdef T_regenerator
	bool TregE = 1;
#else
	bool TregE = 0;
#endif
double Treg = -127.0;


#ifdef T_afrer_condenser
	bool TacE = 1;
#else
	bool TacE = 0;
#endif
double Tac = -127.0;

#ifdef T_before_condenser
	bool TbcE = 1;
#else
	bool TbcE = 0;
#endif
double Tbc = -127.0;

#ifdef T_hot_out
	bool ThoE = 1;
#else
	bool ThoE = 0;
#endif
double Tho = -127.0;

#ifdef T_hot_in
	bool ThiE = 1;
#else
	bool ThiE = 0;
#endif
double Thi = -127.0;

double T_setpoint 			= T_SETPOINT;
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 		= T_SETPOINT_MAX;
const double cT_setpoint_min 		= T_SETPOINT_MIN;
//const double cT_hotcircle_delta_min 	= T_HOTCIRCLE_DELTA_MIN;
const double cT_crc_min 		= T_CRANKCASE_MIN;
const double cT_crc_max 		= T_CRANKCASE_MAX;
const double cT_crc_heat_threshold 	= T_CRANKCASE_HEAT_THRESHOLD;
//const double cT_reg_heat_threshold 	= T_REG_HEAT_THRESHOLD;
const double cT_before_condenser_max 	= T_BEFORE_CONDENSER_MAX;
const double cT_coldref_min 		= T_COLDREF_MIN;
const double cT_before_evap_work_min 	= T_BEFORE_EVAP_WORK_MIN;
const double cT_cold_min 		= T_COLD_MIN;
const double cT_hot_max 		= T_HOT_MAX;
//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_crc_min 	= T_WORKINGOK_CRANKCASE_MIN;        	//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/5;     //

unsigned int pr_low_state_anal  	= 0;	//sensors are NC for spec. conditions, so 1 == ok, 0 == error
unsigned int pr_high_state_anal    	= 0;	//

bool pr_low_state_bool  	= 1;	//sensors are NC for spec. conditions, so 1 == ok, 0 == error
bool pr_high_state_bool    	= 1;	//

bool heatpump_state    		= 0;
bool hotside_circle_state  	= 0;
bool coldside_circle_state 	= 0;
bool crc_heater_state    	= 0;
//bool reg_heater_state		= 0;

//bool relay6_state		= 0;
//bool relay7_state		= 0;

bool LED_OK_state		= 0;
bool LED_ERR_state		= 0;

bool S0_state			= 0;
bool S1_state			= 0;
bool S2_state			= 0;
bool S3_state			= 0;

bool EEV1_state			= 0;
bool EEV2_state			= 0;
bool EEV3_state			= 0;
bool EEV4_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_reopen_pos	= 0;
bool EEV_must_reopen_flag	= 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;		
#ifdef EEV_MANUAL
	bool EEV_manual		= 1;
#else
	bool EEV_manual		= 0;
#endif
const bool c_EEV_reopenlast	= EEV_REOPENLAST;

//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_last_hotWP_on  = 0;
unsigned long millis_last_hotWP_off = 0;

unsigned long millis_last_coldWP_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_485	=  0;  
unsigned long millis_charinput_485 	=  0;  
unsigned long millis_escinput_local	=  0;  
unsigned long millis_charinput_local 	=  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;
unsigned long millis_eev_minworkpos_time =  0;
unsigned long millis_eev_last_work 	=  0;

unsigned long tmic1    =  0;
unsigned long tmic2    =  0;

int skipchars_485 = 0;
int skipchars_local = 0;

#define BUFSIZE          150   

unsigned char dataBuf[BUFSIZE+1];	// 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 u	= 0;
int z	= 0;
int x	= 0;
int y	= 0;
double tempdouble	= 0.0;
double tempdouble_intpart	= 0.0;

int tempint       	= 0;
bool tempbool 		= 0;

char 		fp_integer	= 0;
char		fp_fraction	= 0;

String outString;
String lastStopCauseTxt;		//20 reserved, but use 12 chars of text max
bool fl_printSS_lastStopCauseTxt = 0;	//flag to call printSS
#define LSCint_normal		0
#define LSCint_protective	1
#define LSCint_error		2
int 	LSCint	=	LSCint_normal;	//0 = normal, 1 = protective, 2 = error
String lastStartMsgTxt;			//same as LSC
bool fl_printSS_lastStartMsgTxt = 0;	//flag to call printSS
String t_sensorErrString;

char convBuf[13];

//-------------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_P_HI	2
#define ERR_P_LO	3

int errorcode 			= 0;
unsigned char sequential_errors = 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, 2960 = 28, 4440 = 42
//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

const char str1[] PROGMEM = "Valden Heat Pump Controller, https://github.com/OpenHP/\n\r\n\rCommands: \n\r(?) help\n\r(-) decrease setpoint T\n\r\n\r(+) increase setpoint T";
const char str2[] PROGMEM = "(<) decrease EEV T diff \n\r(>) increase EEV T diff\n\r\n\r(M) manual EEV mode\n\r(A) auto EEV mode\n\r\n\r(z) -1 EEV\t(Z) -10 EEV\n\r(x) +1 EEV\t(X) +10 EEV\n\r(G) get stats";
const char str3[] PROGMEM = "EEV:auto";
const char str4[] PROGMEM = "EEV:manual";
const char str5[] PROGMEM = "N/A,auto";
const char str6[] PROGMEM = "+10 ok";
const char str7[] PROGMEM = "-10 ok";
const char str8[] PROGMEM = "+1 ok";
const char str9[] PROGMEM = "-1 ok";
const char str10[] PROGMEM = "Max!";
const char str11[] PROGMEM = "Min!";
const char str12[] PROGMEM = "HWP ON by Setp. update";
const char str13[] PROGMEM = "EE->mem";
const char str14[] PROGMEM = "mem->EE";
const char str15[] PROGMEM = "OK:E.T.Sens.";
const char str16[] PROGMEM = "OK:Pr.Cold";
const char str17[] PROGMEM = "OK:Pr.Hot";
const char str18[] PROGMEM = "HWP_ON";
const char str19[] PROGMEM = "unkn_F";

PGM_P const const_strs[] PROGMEM = {
	str1,	str2,	str3,	str4,	str5,	str6,	str7,	str8,	str9,	str10,
	str11,	str12,	str13,	str14,	str15,	str16,	str17,	str18,	str19
};

#define IDX_HELP1 	0
#define IDX_HELP2 	1
#define IDX_EEVAUTO 	2
#define IDX_EEVMANUAL	3
#define IDX_NAAUTO	4
#define IDX_PLUS10_OK	5
#define IDX_MINUS10_OK	6
#define IDX_PLUS1_OK	7
#define IDX_MINUS1_OK	8
#define IDX_MAX		9
#define IDX_MIN		10
#define IDX_HWP_ONBYUPD	11
#define IDX_EEtoMEM	12
#define IDX_MEMtoEE	13
#define IDX_OK_ETSENS	14
#define IDX_OK_PRCOLD	15
#define IDX_OK_PRHOT	16
#define IDX_HWPON	17
#define IDX_UNKNF	18


//--------------------------- 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
}

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

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

void PrintSSch(char idx) {
	strcpy_P(dataBuf, (PGM_P)pgm_read_word(&const_strs[idx]));
	Serial.println((const char *) dataBuf);
	#ifdef RS485_HUMAN
		digitalWrite(SerialTxControl, RS485Transmit);
		halifise();
		delay(1);    
		RS485Serial.print((const char *) dataBuf);
		RS485Serial.println();
		RS485Serial.flush();
		digitalWrite(SerialTxControl, RS485Receive);  
	#endif
}
void PrintSS_SaD (double num) {	//global string + double
	#ifdef RS485_HUMAN
		digitalWrite(SerialTxControl, RS485Transmit);
		halifise();
		delay(1);
		RS485Serial.print(outString);
		RS485Serial.println(num);
		RS485Serial.flush();
		digitalWrite(SerialTxControl, RS485Receive);  
	#endif
	Serial.print(outString);
	Serial.println(num);
	Serial.flush();
}

void PrintSS_SaBl (bool num) {	
	#ifdef RS485_HUMAN
		digitalWrite(SerialTxControl, RS485Transmit);
		halifise();
		delay(1);
		RS485Serial.print(outString);
		RS485Serial.println(num);
		RS485Serial.flush();
		digitalWrite(SerialTxControl, RS485Receive);  
	#endif
	Serial.print(outString);
	Serial.println(num);
	Serial.flush();
}

void ApToOut_D (double num) {
	outString += String(num);
}

void PrintSS_SaI (int num) {	
	#ifdef RS485_HUMAN
		digitalWrite(SerialTxControl, RS485Transmit);
		halifise();
		delay(1);
		RS485Serial.print(outString);
		RS485Serial.println(num);
		RS485Serial.flush();
		digitalWrite(SerialTxControl, RS485Receive);  
	#endif
	Serial.print(outString);
	Serial.println(num);
	Serial.flush();
}


/*void PrintSS_SaI (int num) {	//global string + double
	#ifdef RS485_HUMAN
		digitalWrite(SerialTxControl, RS485Transmit);
		halifise();
		delay(1);
		RS485Serial.print(outString);
		RS485Serial.println(num);
		RS485Serial.flush();
		digitalWrite(SerialTxControl, RS485Receive);  
	#endif
	Serial.print(outString);
	Serial.println(num);
	Serial.flush();
}*/

void _PrintHelp(void) {   
	PrintSS("fw: "	+ fw_version  + " board: "+ hw_version);
	PrintSSch(IDX_HELP1);
	#ifndef NO_EEV
		PrintSSch(IDX_HELP2);
	#endif
}

void PrintSS_double (double double_to_print) {
	dtostrf(double_to_print,1,2,temp);
	PrintSS(temp);
}

void Add_Double_To_Buf_IntFract (double float_to_convert) {	//uses tempdouble tempdouble_intpart fp_integer fp_fraction
	if (float_to_convert > 255.0 || float_to_convert < -127.0) {
		fp_integer	= -127;
		fp_fraction	= 0;
	} else {
		tempdouble = modf (float_to_convert , &tempdouble_intpart);
		fp_integer = trunc(tempdouble_intpart);
		tempdouble  = tempdouble * 100;
		fp_fraction = round(tempdouble);
	}
	dataBuf[i]  =  fp_integer;
	i++;
	dataBuf[i]  =  fp_fraction;
	i++;
	/*
	Serial.println(float_to_convert);
	Serial.println(fp_integer, DEC);
	Serial.println(fp_fraction, DEC);*/
}


void IntFract_to_tempdouble (char _int_to_convert, char _fract_to_convert) {	//fract is also signed now!
	tempdouble = (double) _fract_to_convert / 100;
	tempdouble += _int_to_convert;
	/*Serial.println(_int_to_convert);
	Serial.println(_fract_to_convert);
	Serial.println(tempdouble);*/
}


void _ProcessInChar(void){
	//remote commands +,-,G,0x20/?/Enter/A/M/x/X/z/Z
	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;
		#ifndef NO_EEV
			case 0x3C:
				Dec_E();
				break;
			case 0x3E:
				Inc_E();
				break;
			case 0x41:
				EEV_manual = 0;
				PrintSSch(IDX_EEVAUTO);
				break;
		#endif
		case 0x47:
			PrintStats_SS();
			millis_last_printstats = millis_now;
			break;
		#ifndef NO_EEV
			case 0x4D:
				EEV_manual = 1;
				PrintSSch(IDX_EEVMANUAL);
				break;
			case 0x58:	//+10
				if (EEV_manual != 1){
					PrintSSch(IDX_NAAUTO);
					break;
				}
				EEV_apulses += 10;
				EEV_fast = 1;
				PrintSSch(IDX_PLUS10_OK);
				break;
			case 0x5A:	//-10
				if (EEV_manual != 1){
					PrintSSch(IDX_NAAUTO);
					break;
				}
				EEV_apulses -= 10;
				EEV_fast = 1;
				PrintSSch(IDX_MINUS10_OK);
				break;
			case 0x78:	//+1
				if (EEV_manual != 1){
					PrintSSch(IDX_NAAUTO);
					break;
				}
				EEV_apulses += 1;
				EEV_fast = 1;
				PrintSSch(IDX_PLUS1_OK);
				break;
			case 0x7A:	//-1
				if (EEV_manual != 1){
					PrintSSch(IDX_NAAUTO);
					break;
				}
				EEV_apulses += 10;
				EEV_fast = 1;
				PrintSSch(IDX_MINUS1_OK);
				break;
		#endif
	}

}

int Inc_T (void) {
	if (T_setpoint + 0.5 > cT_setpoint_max) {
		PrintSSch(IDX_MAX);
		delay (200);
		return 0;
	}
	T_setpoint += 0.5;
	PrintSS_double(T_setpoint);	
	return 1;	
}

int Dec_T (void) {
	if (T_setpoint - 0.5 < cT_setpoint_min) {
		PrintSSch(IDX_MIN);
		delay (200);
		return 0;
	}
	T_setpoint -= 0.5;
	PrintSS_double(T_setpoint);	
	return 1;
}

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

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





void _HotWPon_by_Setpoint_update(void){	//if setpoint updated: start hot circle to check temperature
	if (  (heatpump_state == 0)   &&  (hotside_circle_state  == 0)  && ((unsigned long)(millis_now - millis_last_hotWP_on) < HOTCIRCLE_START_EVERY)	) {    //process START_EVERY for hot side
		millis_last_hotWP_off = millis_now;
		hotside_circle_state  = 1;
		PrintSSch(IDX_HWP_ONBYUPD);
	}
}

void PrintStats_SS (void) {
		
		if (TciE)	{ 	outString = F("\n\r---\n\r\tTbe:\t")	;	PrintSS_SaD(Tbe);	}
	        if (TaeE)	{	outString = F("\tTae:\t")	;	PrintSS_SaD(Tae);	}
		if (TcoE)	{	outString = F("\tTci:\t");		PrintSS_SaD(Tci);	}
		if (TcoE)	{	outString = F("\tTco:\t")	;	PrintSS_SaD(Tco);	}
	        
	        //if (TsgE)	{	outString = F("\tTsg: ")	;	PrintSS_SaD(Tsg);	}
	        //if (TslE)	{	outString = F("\tTsl: ")	;	PrintSS_SaD(Tsl);	}
	        //if (TbvE)	{	outString = F("\tTbv: ")	;	PrintSS_SaD(Tbv);	}
	        //if (TsucE)	{	outString = F("\tTsuc: ")	;	PrintSS_SaD(Tsuc);	}
	        if (Ts1E)	{	outString = F("\tTs1:\t")	;	PrintSS_SaD(Ts1);	}
	        if (Ts2E)	{	outString = F("\tTs2:\t")	;	PrintSS_SaD(Ts2);	}
	        //Tcrc misorder due to large string
	        if (TregE)	{	outString = F("\tTreg:\t")	;	PrintSS_SaD(Treg);	}
	        if (TbcE)	{	outString = F("\tTbc:\t")	;	PrintSS_SaD(Tbc);	}
		if (TacE)	{	outString = F("\tTac:\t")	;	PrintSS_SaD(Tac);	}
	        if (ThiE)	{	outString = F("\tThi:\t")	;	PrintSS_SaD(Thi);	}
		if (ThoE)	{	outString = F("\tTho:\t")	;	PrintSS_SaD(Tho);	}
		if (TcrcE)	{	outString = F("\tTcrankcase:\t");	PrintSS_SaD(Tcrc);	}//misorder due to large string
		outString = F("\tSetpoint:\t");	
		PrintSS_SaD(T_setpoint); 
		
		outString = F("\n\r\tHP:\t");
		PrintSS_SaBl(heatpump_state);
		outString = F("\tHWP:\t");
		PrintSS_SaBl(hotside_circle_state);
		outString = F("\tCWP:\t");
		PrintSS_SaBl(coldside_circle_state);
		outString = F("\tCRCheat:");
		PrintSS_SaBl(crc_heater_state);
		outString = F("\tWatts:\t")	;	
		PrintSS_SaD(async_wattage);
		
		#ifndef NO_EEV
			outString = F("\n\r\tT_EEV_setpoint: ");
			PrintSS_SaD(T_EEV_setpoint);
			outString = "\tEEV_pos:\t";
			PrintSS_SaI(EEV_cur_pos);
		#endif 
		
		outString = "\n\r\tErr:\t";
		PrintSS_SaI(errorcode);
		outString = F("\tPr.Cold:")	;	
		if (pr_low_state_bool == 1) {
			outString += F("OK");
		} else {
			outString += F("ERR");
		}
		outString += F("\n\r\tPr.Hot:\t")	;	
		if (pr_high_state_bool == 1) {
			outString += F("OK");
		} else {
			outString += F("ERR");
		}
		
		outString += F("\n\r\n\r\tLast Stop Cause:\t");
		outString += lastStopCauseTxt;
		outString += F("\n\r\tLast Start Message:\t");
		outString += lastStartMsgTxt;
		outString += F("\n\r---\n\r");
		PrintSS(outString);
		
	#ifdef RS485_HUMAN
		digitalWrite(SerialTxControl, RS485Transmit);
		halifise();
		delay(1);    
		RS485Serial.print(outString);
		RS485Serial.println();
		RS485Serial.flush();
		digitalWrite(SerialTxControl, RS485Receive);  
	#endif
}

void Calc_CRC(unsigned char b) {	//uses/changes y
	crc16 ^= b & 0xFF;
	for (y=0; y<8; y++) {
		cf = crc16 & 0x0001;
		crc16>>=1;
		if (cf) { crc16 ^= POLY; }
	}
}

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

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;
		}
}

double GetT (int channel) {
	S0_state = bitRead(channel,0);
	S1_state = bitRead(channel,1);
	S2_state = bitRead(channel,2);
	S3_state = bitRead(channel,3);
	halifise();
	
	tempdouble = -127.0;
	for ( i = 0; i < 8; i++) {
		#ifdef WATCHDOG
			wdt_reset();
		#endif
		eevise();
		tempdouble = s_allTsensors.getTempCByIndex(0);
		if ( (tempdouble == 85.0) || (tempdouble < -55.0) || (tempdouble == 0.0) || (tempdouble > 125.0) ) {	//0.0 added to test
			//outString =  F("Warn:T_SensReRead!");
			//PrintSS_SaD(tempdouble);
			if ( tempdouble == 85.0 || tempdouble == 0.0 ) {    //initial value in dallas register after poweron
				s_allTsensors.requestTemperatures();	//!!!added to test, seems to work ok
				delay (375);              //375 actual for 11 bits resolution, 2-3 retries OK for 12-bits resolution
			} else {
				delay (37);
			}
		} else {
			break;
		}
	}
	s_allTsensors.requestTemperatures();
	if ( (tempdouble > 125.0) || (tempdouble < -55.0)) {	//incorrect readings protection, rare
		tempdouble = -127.0;
	}
	return tempdouble;
}

//older version of GetT
/*double GetT (int channel) {
	S0_state = bitRead(channel,0);
	S1_state = bitRead(channel,1);
	S2_state = bitRead(channel,2);
	S3_state = bitRead(channel,3);
	halifise();
	
	tempdouble = -127.0;
	for ( i = 0; i < 8; i++) {
		#ifdef WATCHDOG
			wdt_reset();
		#endif
		eevise();
		tempdouble = s_allTsensors.getTempCByIndex(0);
		if ( (tempdouble == 85.0) || (tempdouble == -127.0) ) {
			if ( tempdouble == 85.0 ) {    //initial value in dallas register after poweron
				s_allTsensors.requestTemperatures();//!!! added to test
				delay (375);              //375 actual for 11 bits resolution, 2-3 retries OK for 12-bits resolution
			} else {
				delay (37);
			}
		} else {
			break;
		}
	}
	s_allTsensors.requestTemperatures();
	return tempdouble;
}*/

void GetTemperatures(void){
	if (TciE)	{ 	Tci	= GetT(0);}
	if (TcoE)	{	Tco	= GetT(1);}
	if (TbeE)	{	Tbe	= GetT(2);}
	if (TaeE)	{	Tae	= GetT(3);}
	//if (TsgE)	{	Tsg	= GetT(4);}
	//if (TslE)	{	Tsl	= GetT(5);}
	//if (TbvE)	{	Tbv	= GetT(6);}
	//if (TsucE)	{	Tsuc	= GetT(7);}
	if (Ts1E)	{	Ts1	= GetT(8);}
	if (Ts2E)	{	Ts2	= GetT(9);}
	if (TcrcE)	{	Tcrc	= GetT(10);}
	if (TregE)	{	Treg	= GetT(11);}
	if (TacE)	{	Tac	= GetT(12);}
	if (TbcE)	{	Tbc	= GetT(13);}
	if (ThoE)	{	Tho	= GetT(14);}
	if (ThiE)	{	Thi	= GetT(15);}	
}

void on_EEV(){	
	x = EEV_steps[EEV_cur_step];
	EEV1_state	=	bitRead(x, 0);
	EEV2_state	=	bitRead(x, 1);
	EEV3_state	=	bitRead(x, 2);
	EEV4_state	=	bitRead(x, 3);
	halifise();
}

void off_EEV(){	
	EEV1_state	=	0;
	EEV2_state	=	0;
	EEV3_state	=	0;
	EEV4_state	=	0;
	//PrintSS("off_EEV");
	halifise();
}

void halifise(void){
	/*
	relay 1: heat pump
	relay 2: hot side circulator pump
	relay 3: cold side circulator pump
	relay 4: crankcase heater
	(no more v1.3mi) relay 5:
	
	#define RELAY_HEATPUMP        	A2
	#define RELAY_HOTSIDE_CIRCLE  	A1
	
	Reg 1:
	595.0: 4067 S3
	595.1: 4067 S0
	595.2: 4067 S1
	595.3: 4067 S2
	595.4: EEV_1
	595.5: EEV_2
	595.6: EEV_3
	595.7: EEV_4
	
	Reg 2:
	595.8: !! free
	595.9: ok/err LED 2
	595.A: Relay 6 
	595.B: Relay 7 
	595.C: Relay 5 
	595.D: Relay 4
	595.E: Relay 3
	595.F: ok/err LED 1
	
	Reg 3:
	595.10: LED "EEV opening"
	595.11: LED "EEV closing"
	595.12: LED "EEV Fast"
	595.13: LED "485 RX"
	595.14: LED "485 TX"
	595.15: LED "Manual mode"
	595.16: LED "LSC: error"
	595.17: LED "LSC: protection"
	*/

	digitalWrite(LATCH_595, 0);
	//17
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	if (LSCint == LSCint_protective) {
		digitalWrite(DATA_595, 1);
	} else {
		digitalWrite(DATA_595, 0);
	}
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//16
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	if (LSCint == LSCint_error) {
		digitalWrite(DATA_595, 1);
	} else {
		digitalWrite(DATA_595, 0);
	}
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//15
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, EEV_manual);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//14
	tempbool = digitalRead (13);
	
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, tempbool);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//13
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, !tempbool);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//12
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, EEV_fast);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//11
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	if ( EEV_apulses < 0 ) {
		digitalWrite(DATA_595, 1);
	} else {
		digitalWrite(DATA_595, 0);
	}
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//10
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	if ( EEV_apulses > 0 ) {
		digitalWrite(DATA_595, 1);
	} else {
		digitalWrite(DATA_595, 0);
	}
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//F
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, LED_ERR_state);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//E
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, coldside_circle_state);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//D
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, crc_heater_state);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//C
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	//digitalWrite(DATA_595, reg_heater_state);
	digitalWrite(DATA_595, 0);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//B
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	//digitalWrite(DATA_595, relay7_state);
	digitalWrite(DATA_595, 0);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//A
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	//digitalWrite(DATA_595, relay6_state);
	digitalWrite(DATA_595, 0);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//9
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, LED_OK_state);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//8
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, 0);	//FREE
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//7
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, EEV4_state);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//6
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, EEV3_state);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//5
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, EEV2_state);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//4
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, EEV1_state);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//3
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, S2_state);	
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//2
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, S1_state); 
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//1
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, S0_state);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	//0
	digitalWrite(CLK_595, 0);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(DATA_595, S3_state);
	digitalWrite(CLK_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(CLK_595, 0);
	//
	digitalWrite(LATCH_595, 1);
	__asm__ __volatile__ ("nop\n\t");
	digitalWrite(LATCH_595, 0);
	digitalWrite	(RELAY_HEATPUMP,	heatpump_state);
	digitalWrite	(RELAY_HOTSIDE_CIRCLE, 	hotside_circle_state);
}

void eevise(void) {
	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;
						//PrintSS("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;
						//PrintSS("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];
				EEV1_state	=	bitRead(x, 0);
				EEV2_state	=	bitRead(x, 2);		//!!!here pins are swapped fot sanhua
				EEV3_state	=	bitRead(x, 1);		//!!!here pins are swapped fot sanhua
				EEV4_state	=	bitRead(x, 3);
			}
			if (EEV_cur_pos < 0) { 
				EEV_cur_pos = 0;	
			}
			millis_eev_last_step = millis_now;
			#ifdef EEV_DEBUG 
				PrintSS(String(EEV_cur_pos));	
			#endif
			halifise();
	}
}

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

void setup(void) {
	pinMode		(LATCH_595, 		OUTPUT);
	pinMode		(CLK_595, 		OUTPUT);
	pinMode		(DATA_595, 		OUTPUT);
	pinMode		(OE_595, 		OUTPUT);
	pinMode		(RELAY_HEATPUMP,	OUTPUT);
	pinMode		(RELAY_HOTSIDE_CIRCLE, 	OUTPUT);
	pinMode		(PR_LOW, 		INPUT);
	pinMode		(PR_HIGH, 		INPUT);
	
	
	digitalWrite	(LATCH_595, 		LOW);
	digitalWrite	(CLK_595, 		LOW);
	digitalWrite	(DATA_595, 		LOW);
	digitalWrite	(OE_595, 		LOW);
	digitalWrite	(RELAY_HEATPUMP,	LOW);
	digitalWrite	(RELAY_HOTSIDE_CIRCLE, 	LOW);
	halifise();
	
	#ifdef WATCHDOG
		wdt_disable();
		delay(2000);
	#endif
	
	// start serial port
	Serial.begin(9600);
	//Serial.print("Starting, dev_id:");
	//Serial.println(devID);

	RS485Serial.begin(9600);
	pinMode(SerialTxControl, OUTPUT); 
	pinMode(SerialTX, OUTPUT);   	
	pinMode(SerialRX, INPUT);   
	digitalWrite(SerialTxControl, RS485Receive);
	delay(100);
	PrintSS("ID: 0x" + String(devID, HEX));

	delay(200);
	off_EEV();
	
	pinMode	(em_pin1, INPUT);
	
	//PrintSS("setpoint (C):");
	//PrintSS(setpoint);
	
	//PrintSS(String(freeMemory()));
	
	s_allTsensors.begin();
	s_allTsensors.setWaitForConversion(false);  //ASYNC mode, request before get, see Dallas library for details
	
	//----------------------------- self-tests ----------------------------- ----------------------------- ----------------------------- 
	/*
	index = 0;
	outChar[index] = 0xFF;
	index++;
	outChar[index] = 0xAA;
	index++;
	outChar[index] = 0xBB;
	index++;
	outChar[index] = 0xCC;
	index++;
	
	crc16 = SEED;
	for (z = 0; z < index; z++) {   
		Calc_CRC(outChar[z]); 
        }
        outChar[index]=crc16 & 0xFF;
        index++;
	outChar[index]=crc16 >> 8;
	index++;
	outChar[index]=0x00;
	index++;
	
	Serial.println(crc16, HEX);
	for (z = 0; z < index; z++) {   
		Serial.print(" ");
		Serial.print(outChar[z], HEX); 
        }
	Serial.println(" ");
	*/
	
	//Relays self-test
	#if (defined SELFTEST_RELAYS_LEDS_SPEAKER || defined SELFTEST_EEV || defined SELFTEST_T_SENSORS)
		while ( 1 == 1) {
			#if defined SELFTEST_RELAYS_LEDS_SPEAKER 
				PrintSS(F("Relays and LEDS self-test"));
				
				analogWrite(speakerOut, 10);
				delay (1500);
				analogWrite(speakerOut, 0);
			
				heatpump_state    	= 1;	halifise();	delay(1000);
				hotside_circle_state  	= 1;	halifise();	delay(1000);
				coldside_circle_state 	= 1;	halifise();	delay(1000);
				crc_heater_state    	= 1;	halifise();	delay(1000);
				//reg_heater_state 	= 1;	halifise();	delay(1000);
				
				//relay6_state		= 1;	halifise();	delay(1000);
				//relay7_state		= 1;	halifise();	delay(1000);
			
				EEV_apulses		= 10;	halifise();	delay(1000);
				EEV_apulses		= -10;	halifise();	delay(1000);
				EEV_fast		= 1;	halifise();	delay(1000);
				digitalWrite(SerialTxControl, RS485Transmit);	halifise();	delay(1000);
				EEV_manual		= 1;		halifise();	delay(1000);
				LSCint 		= LSCint_error;		halifise();	delay(1000);
				LSCint 		= LSCint_protective;	halifise();	delay(1000);	
				
				LED_OK_state		= 1;	halifise();	delay(1000);
				LED_ERR_state		= 1;	halifise();	delay(1000);
			
				analogWrite(speakerOut, 10);
				delay (1500);
				analogWrite(speakerOut, 0);
				
				heatpump_state    	= 0;	halifise();	delay(1000);
				hotside_circle_state  	= 0;	halifise();	delay(1000);
				coldside_circle_state 	= 0;	halifise();	delay(1000);
				crc_heater_state    	= 0;	halifise();	delay(1000);
				//reg_heater_state 	= 0;	halifise();	delay(1000);
				
				//relay6_state		= 0;	halifise();	delay(1000);
				//relay7_state		= 0;	halifise();	delay(1000);
				
				EEV_apulses		= 10;	halifise();	delay(1000);
				EEV_apulses		= -10;	halifise();	delay(1000);
				EEV_fast		= 0;	halifise();	delay(1000);
				digitalWrite(SerialTxControl, RS485Receive);	halifise();	delay(1000);
				digitalWrite(SerialTxControl, RS485Transmit);	halifise();	delay(1000);
				EEV_manual		= 0;		halifise();	delay(1000);		
				LSCint 		= LSCint_error;		halifise();	delay(1000);
				LSCint 		= LSCint_protective;	halifise();	delay(1000);
				
				LED_OK_state		= 0;	halifise();	delay(1000);
				LED_ERR_state		= 0;	halifise();	delay(1000);
		
				analogWrite(speakerOut, 10);
				delay (1500);
				analogWrite(speakerOut, 0);
			#endif
			#if defined SELFTEST_EEV
				EEV_apulses		= 0;
				EEV_fast		= 0;
				halifise();	
				delay(1000);
				//EEV self-test, also can be used for compressor test
				//vacuuming/charge via low pressure side: leave EEV opened
				//PrintSS("EEV self-test");
				EEV_apulses =  -(EEV_MAXPULSES + EEV_CLOSE_ADD_PULSES);
				EEV_adonotcare = 1;
				EEV_fast = 1;
				while (EEV_apulses < 0){
					millis_now = millis();
					eevise();
				}
				analogWrite(speakerOut, 10);
				delay (1500);
				analogWrite(speakerOut, 0);
				delay(1000);
				//EEV_apulses =  EEV_MAXPULSES;
				EEV_apulses =  50;
				EEV_fast = 1;
				while (EEV_apulses > 0){
					millis_now = millis();
					eevise();
				}
				analogWrite(speakerOut, 10);
				delay (1500);
				analogWrite(speakerOut, 0);
				delay(1000);
			#endif
			#if defined SELFTEST_T_SENSORS
				GetTemperatures();
				
				outString=F("Tbe: ");		PrintSS_SaD(Tbe);
				outString=F("Tae: ");		PrintSS_SaD(Tae);
				outString=F("Tci: ");		PrintSS_SaD(Tci);
				outString=F("Tco: ");		PrintSS_SaD(Tco);
				outString=F("Tbc: ");		PrintSS_SaD(Tbc);
				outString=F("Tac: ");		PrintSS_SaD(Tac);
				outString=F("Thi: ");		PrintSS_SaD(Thi);
				outString=F("Tho: ");		PrintSS_SaD(Tho);
				outString=F("Ts1: ");		PrintSS_SaD(Ts1);
				outString=F("Tcrc: ");		PrintSS_SaD(Tcrc);
				outString=F("Ts2: ");		PrintSS_SaD(Ts2);
				outString=F("Treg: ");		PrintSS_SaD(Treg);
				analogWrite(speakerOut, 10);
				delay (1500);
				analogWrite(speakerOut, 0);
				delay(1000);
			#endif

	//---------DEBUG END--------  

		}
	#endif
	
	//----------------------------- self-test END----------------------------- ----------------------------- ----------------------------- 
	
	
	eeprom_magic_read = EEPROM.read(eeprom_addr);
	eeprom_addr += 1;
	//EEPROM content: 0x00 - magic,   0x01..0x04 target value
	if (eeprom_magic_read == eeprom_magic){
		PrintSSch(IDX_EEtoMEM);
	} else {
		PrintSSch(IDX_MEMtoEE);
		WriteFloatEEPROM(eeprom_addr, T_setpoint);
		EEPROM.write(0x00, eeprom_magic);
	}
	T_setpoint = ReadFloatEEPROM(eeprom_addr);
	PrintSS_double(T_setpoint);
	//eeprom_addr += 4;
	
	T_setpoint_lastsaved = T_setpoint;

	#ifdef WATCHDOG
		wdt_enable (WDTO_8S);
	#endif
	
	GetTemperatures();
	
	outString.reserve(80);
	lastStopCauseTxt.reserve(20);
	lastStartMsgTxt.reserve(20);
	t_sensorErrString.reserve(12);
	//PrintSS(String(freeMemory()));
	
	LED_OK_state		= 1;
	
	_PrintHelp();
	
	analogWrite(speakerOut, 10);
	delay (1500); 
	analogWrite(speakerOut, 0);
	lastStopCauseTxt = F("Start Pause");
	lastStartMsgTxt = "";
}

 
void loop(void) {  
	
	digitalWrite(SerialTxControl, RS485Receive);
	millis_now = millis();
	halifise();
	eevise();
	
	if (((unsigned long)(millis_now - millis_last_printstats) > HUMAN_AUTOINFO)   ||   (millis_last_printstats == 0)  ) {
		PrintStats_SS();
		millis_last_printstats = millis_now;
	}
	//--------------------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 !!!
		/*
		PrintSS("Async impl. results 1:  ");
		PrintSS(String(async_wattage));	           // Apparent power
		PrintSS(String(async_Irms_1));	           // Irms
		PrintSS(" voltage: ");
		PrintSS(String(supply_voltage));
		*/
		//----------------------------- self-test END
		
	}
	eevise();

	//--------------------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*3)) {
			millis_last_heatpump_on = millis_now;
			heatpump_state = 0;
			LSCint = LSCint_protective;
			halifise();
			lastStopCauseTxt = ("P.WtMax:") + String(async_wattage);
			PrintSS(lastStopCauseTxt);
		}
	}
		
	//-------------------check cycle
	if(  ((unsigned long)(millis_now - millis_prev) > millis_cycle )  ||  (millis_prev == 0) ) {
		millis_prev = millis_now;
		GetTemperatures();  //      wdt_reset here due to 85.0'C filtration
		SaveSetpointEE();
		pr_low_state_anal  	= analogRead(PR_LOW);	//
		pr_high_state_anal  	= analogRead(PR_HIGH);	//shotrcut test shows 993-994 for analogRead (10.4ma)
		if (pr_low_state_anal > 200) {
			pr_low_state_bool = 1;
		} else {
			pr_low_state_bool = 0;
		}
		if (pr_high_state_anal > 200) {
			pr_high_state_bool = 1;
		} else {
			pr_high_state_bool = 0;
		}	
		//--------------------important logic
		//check T sensors
		if ( errorcode == ERR_OK ) {
			if (TbeE == 1 	&& Tbe == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tbe");}
			if (TaeE == 1 	&& Tae == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tae");}
			if (TciE == 1 	&& Tci == -127 )	{errorcode = ERR_T_SENSOR; outString = F("E.Tci");}
			if (TcoE == 1 	&& Tco == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tco");} 
			if (TbcE == 1 	&& Tbc == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tbc");}
			if (TacE == 1 	&& Tac == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tac");}
			if (ThiE == 1 	&& Thi == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Thi");}
			if (ThoE == 1 	&& Tho == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tho");}
			//if (TsgE == 1 	&& Tsg == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tsg");}
			//if (TslE == 1 	&& Tsl == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tsl");}
			//if (TbvE == 1 	&& Tbv == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tbv");}
			//if (TsucE == 1 	&& Tsuc == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tsuc");}
			if (Ts1E == 1 	&& Ts1 == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Ts1");}
			if (Ts2E == 1	&& Ts2 == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Ts2");}
			if (TcrcE == 1 	&& Tcrc == -127 )  	{errorcode = ERR_T_SENSOR; outString = F("E.Tcrc");}
			if (TregE == 1 	&& Treg == -127 ) 	{errorcode = ERR_T_SENSOR; outString = F("E.Treg");}
			
			if (errorcode == ERR_T_SENSOR){
				//PrintSS(String(outString));
				t_sensorErrString = String(outString);	
				//printed to console below
			}
		}
		
		//auto-clean sensor error on sensor appears
		// add 1xor enable here!
		if ( ( errorcode == ERR_T_SENSOR )     && (   	((TciE == 1 	&& Tci != -127 )  	||	(TciE	^1)) 	&&	
								((TcoE == 1 	&& Tco != -127 )  	||	(TcoE	^1)) 	&&	
								((TbeE == 1 	&& Tbe != -127 )  	||	(TbeE	^1)) 	&&	
								((TaeE == 1 	&& Tae != -127 )  	||	(TaeE	^1)) 	&&	
								//((TsgE == 1 	&& Tsg != -127 )  	||	(TsgE	^1)) 	&&	
								//((TslE == 1 	&& Tsl != -127 )  	||	(TslE	^1)) 	&&	
								//((TbvE == 1 	&& Tbv != -127 )  	||	(TbvE	^1)) 	&&	
								//((TsucE == 1 	&& Tsuc != -127 )  	||	(TsucE	^1)) 	&&	
								((Ts1E == 1 	&& Ts1 != -127 )  	||	(Ts1E	^1)) 	&&	
								((Ts2E == 1	&& Ts2 != -127 )  	||	(Ts2E ^1)) 	&&	
								((TcrcE == 1 	&& Tcrc != -127 )  	||	(TcrcE	^1)) 	&&	
								((TregE == 1 	&& Treg != -127 )  	||	(TregE	^1)) 	&&	
								((TacE == 1 	&& Tac != -127 )  	||	(TacE	^1)) 	&&	
								((TbcE == 1 	&& Tbc != -127 )  	||	(TbcE	^1)) 	&&	
								((ThoE == 1 	&& Tho != -127 )  	||	(ThoE	^1)) 	&&	
								((ThiE == 1 	&& Thi != -127 )  	||	(ThiE	^1)) 	)) {
											errorcode = ERR_OK;
											PrintSSch(IDX_OK_ETSENS);
											sequential_errors = 0;
											t_sensorErrString = "";
		}
		
		//check pressure sensors
		//auto-clean prev. errors first
		if ( errorcode == ERR_P_LO ) {
			if (pr_low_state_bool == 1) 	{
				errorcode = ERR_OK; 
				PrintSSch(IDX_OK_PRCOLD);
			}
		}
		if ( errorcode == ERR_P_HI ) {
			if (pr_high_state_bool == 1) 	{
				errorcode = ERR_OK; 
				PrintSSch(IDX_OK_PRHOT);
			}
		}

		
		//recheck, if another sensor
		if ( errorcode == ERR_OK ) {
			if (pr_low_state_bool == 0) 	{errorcode = ERR_P_LO;}	//for PrintSS scroll down
			if (pr_high_state_bool == 0)	{errorcode = ERR_P_HI;} //for PrintSS scroll down
		}
			
		//-------------- EEV cycle
		/*
		//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  ){
				PrintSS("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
				PrintSS("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
					PrintSS("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;
				PrintSS("EEV: driving " + String(T_EEV_dt));
				if (EEV_cur_pos <= 0){
					PrintSS("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!
						PrintSS("EEV: emergency closing!");
						EEV_apulses = -EEV_EMERG_STEPS;
						EEV_adonotcare = 0;
						EEV_fast = 1;
					} else if (T_EEV_dt  < T_EEV_setpoint) {					//too
						PrintSS("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
						PrintSS("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
						PrintSS("EEV: opening");
						EEV_apulses =  +1;
						EEV_adonotcare = 0;
						EEV_fast = 0;
					} else if (T_EEV_dt  > T_EEV_setpoint) {					//ok
						PrintSS("EEV: OK");
						//
					}
				}
				off_EEV();
			} 
			
		}
		*/
		//v1.2 algo: reopen added
		#ifndef NO_EEV
			if ( EEV_manual == 0 && errorcode == 0 && async_wattage >= c_workingOK_wattage_min && EEV_cur_pos > 0 )	{
				T_EEV_dt = Tae - Tbe;
				#ifdef EEV_DEBUG
					PrintSS("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
							PrintSS(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
							PrintSS(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
							PrintSS(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 ( EEV_must_reopen_flag == 1 && (T_EEV_dt > T_EEV_setpoint + EEV_HYSTERESIS)  && ((unsigned long)(millis_now - millis_eev_minworkpos_time) > EEV_REOPENMINTIME)   &&  (millis_eev_last_work <	millis_eev_minworkpos_time)  ) {	//reopen
						EEV_must_reopen_flag = 0;
						EEV_apulses = EEV_reopen_pos - EEV_cur_pos;
						EEV_adonotcare = 0;
						EEV_fast = 1;
						#ifdef EEV_DEBUG
							PrintSS(F("EEV: 14 reopening last"));
							PrintSS(String(EEV_apulses));
							PrintSS(String(millis_now));
							PrintSS(String(millis_eev_minworkpos_time));
							PrintSS(String(millis_eev_last_work));
						#endif
					} else if (T_EEV_dt  > T_EEV_setpoint + EEV_HYSTERESIS + EEV_PRECISE_START) {	//very
						#ifdef EEV_DEBUG
							PrintSS(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
							PrintSS(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
							PrintSS(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
							PrintSS(F("EEV: 7 enforce faster closing!"));
						#endif
						//EEV_apulses = -EEV_EMERG_STEPS;
						EEV_adonotcare = 0;
						EEV_fast = 1;
					}
				}
				off_EEV();
			}
			
			if ( EEV_manual == 0 && 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
						PrintSS(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
						EEV_reopen_pos		= EEV_cur_pos;				//reopen pos. set
						EEV_must_reopen_flag	= 1;
						millis_eev_last_work	= millis_now;
						#ifdef EEV_DEBUG
							PrintSS(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_manual == 0 && EEV_apulses == 0 && async_wattage < c_workingOK_wattage_min && EEV_cur_pos < EEV_OPEN_AFTER_CLOSE) {
				#ifdef EEV_DEBUG
					PrintSS(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_manual == 0 && EEV_apulses == 0 && async_wattage >= c_workingOK_wattage_min && EEV_cur_pos < EEV_MINWORKPOS) {
				#ifdef EEV_DEBUG
					PrintSS(F("EEV: 13 open to work"));	
				#endif
				if (EEV_MINWORKPOS != 0) {			
					EEV_apulses = EEV_MINWORKPOS - EEV_cur_pos;
					EEV_adonotcare = 0;
					EEV_fast = 1;
					//millis_eev_minworkpos_time = millis_now;
				}
				off_EEV();
			}
			if (EEV_cur_pos < EEV_MINWORKPOS) {	//for reopen
				millis_eev_minworkpos_time = millis_now;
			}
			if ( EEV_manual == 0 && EEV_apulses == 0 && EEV_fast == 1 ) {//just for LED
				EEV_fast = 0;
			}
			if (	((unsigned long)(millis_now - millis_eev_last_on) > 10000)  ||  millis_eev_last_on == 0 ) {
				//PrintSS("EEV: ON/OFF");
				on_EEV();
				//delay(30);
				//off_EEV();	//off_EEV called somewhere else takes care of it
				millis_eev_last_on  =  millis_now;
			}
			//-------------- EEV cycle END
		#endif
		#ifndef EEV_ONLY
			//process heatpump crankcase heater
			if (TcrcE == 1) {
				if ( Tcrc < cT_crc_heat_threshold   &&   crc_heater_state == 0   &&   Tcrc != -127) {
					crc_heater_state = 1;
				} else if (Tcrc >= cT_crc_heat_threshold  && crc_heater_state == 1) {
					crc_heater_state = 0;
				} else if (Tcrc == -127) {
					crc_heater_state = 0;
				}
				halifise();
			}
							
			//main logic
			if (_1st_start_sleeped == 0) {
				//enable hot WP immidiately
				if (hotside_circle_state  == 0){
					millis_last_hotWP_off = millis_now;
					hotside_circle_state  = 1;
				}
				//_1st_start_sleeped = 1;
				if ( (millis_now < poweron_pause) && (_1st_start_sleeped == 0) ) {
					outString = String(((poweron_pause-millis_now))/1000);
					//PrintSS("Wait: " + outString + " s.");
					lastStartMsgTxt = "StCntd:" + outString; //start countdown, max 5 numerical places
					fl_printSS_lastStartMsgTxt = 1;
					//PrintSS(lastStartMsgTxt);
					//return;
				} else {
					_1st_start_sleeped = 1;
					lastStopCauseTxt="";
					lastStartMsgTxt="";
				}
			}
			
			//process_heatpump:
			//start if
			//    (last_on > N or not_started_yet)
			//    and (no errors)
			//    and (t hot out < t target)
			//    and (t hot out < t hot max)
			//    and (t hot in < t hot max)
			//    and (crc t > min'C)
			//    and (crc 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 &&	errorcode == ERR_T_SENSOR) {
				lastStartMsgTxt = t_sensorErrString;
				//fl_printSS_lastStartMsgTxt = 1;
			}
			
			if (heatpump_state == 0 && errorcode == ERR_P_LO ) {
				lastStartMsgTxt = F("E.PresCold");
			}
			
			if (heatpump_state == 0 && errorcode == ERR_P_HI ) {
				lastStartMsgTxt = F("E.PresHot");
			}

			if (heatpump_state == 0 &&	errorcode == ERR_OK 	&& 	_1st_start_sleeped == 1) {
				i = 0;
				#ifdef SETPOINT_THI
				if ( Thi < T_setpoint )  								{i+=1;} else { lastStartMsgTxt = F("#Thi>Setp."); }	//or1	//Thi = warm floor heat pump
				#endif
				#ifdef SETPOINT_TS1
					if ( Ts1 < T_setpoint )  								{i+=1;} else { lastStartMsgTxt = F("#Ts1>Setp."); }	//or1	//Ts1 = tank heater
				#endif
				//2	wait cold circe if needed
				if ( coldside_circle_state  == 1 && ((unsigned long)(millis_now - millis_last_coldWP_off) > COLDCIRCLE_PREPARE) ){
					i+= 1;
				//only if hot runned and T < setpoint
				} else if ((coldside_circle_state  == 0) && (hotside_circle_state  == 1) && ((unsigned long)(millis_now - millis_last_hotWP_off) > HOTCIRCLE_CHECK_PREPARE) ) {
					#ifdef SETPOINT_THI
					if ( Thi < T_setpoint ) 	{
					#endif
					#ifdef SETPOINT_TS1
					if ( Ts1 < T_setpoint )  	{
					#endif
						lastStartMsgTxt = F("#CPpStart");
						millis_last_coldWP_off = millis_now;
						coldside_circle_state  = 1;
						fl_printSS_lastStartMsgTxt = 1;
						//PrintSS(lastStartMsgTxt);
					}
				} else if (coldside_circle_state  == 1) {
					lastStartMsgTxt = "#CPp:" + String( (COLDCIRCLE_PREPARE -(unsigned long)(millis_now - millis_last_coldWP_off))/1000 );
				}
				//3	wait hot circe if needed
				#ifdef SETPOINT_THI
					if ((hotside_circle_state  == 1) && ((unsigned long)(millis_now - millis_last_hotWP_off) > HOTCIRCLE_CHECK_PREPARE)	)	{	
						i+=1;
					} else if (hotside_circle_state  == 1) {	//waiting for T stabilisation
						lastStartMsgTxt = "#HotPrp:" + String( (HOTCIRCLE_CHECK_PREPARE -(unsigned long)(millis_now - millis_last_hotWP_off))/1000 );
					} else if (hotside_circle_state  == 0) {	//sleeping, hot CP off, waiting for next check cycle
						lastStartMsgTxt = "#HotSlp:" + String( (HOTCIRCLE_START_EVERY -(unsigned long)(millis_now - millis_last_hotWP_on))/1000 );
					}
				#else ifdef SETPOINT_TS1
					i+=1;
				#endif
				//4	countdown, compressor min. cycle
				if (((unsigned long)(millis_now - millis_last_heatpump_on) > mincycle_poweroff)   ||   (millis_last_heatpump_on == 0)  )  	{	
					i+=1;
				} else {
					if (millis_last_heatpump_on != 0){
						lastStartMsgTxt = "#HPSlp:" + String( (mincycle_poweroff -(unsigned long)(millis_now - millis_last_heatpump_on))/1000 );
					}
				}
				
				if ( (TcrcE == 1 	&& Tcrc > cT_crc_min)  			||	(TcrcE^1))	{i+=1;} else { lastStartMsgTxt = F("#CaseCold"); }	//5
				if ( (TaeE == 1 	&& Tae > cT_coldref_min)		||	(TaeE^1))	{i+=1;} else { lastStartMsgTxt = F("#Tae<RefMin"); }	//6
				if ( (TbeE == 1 	&& Tbe > cT_coldref_min)		||	(TbeE^1))	{i+=1;} else { lastStartMsgTxt = F("#Tbe<RefMin"); }	//7
				if ( (TciE == 1 	&& Tci > cT_cold_min)  			||	(TciE^1))	{i+=1;} else { lastStartMsgTxt = F("#Tci<ColdMin"); }	//8
				if ( (TcoE == 1 	&& Tco > cT_cold_min) 			||	(TcoE^1))	{i+=1;} else { lastStartMsgTxt = F("#Tco<ColdMin"); }	//9
				if ( (ThoE == 1 	&& Tho 	< cT_hot_max)			||	(ThoE^1))	{i+=1;} else { lastStartMsgTxt = F("#Tho>Max"); }	//10
				if ( (ThiE == 1 	&& Thi 	< cT_hot_max)			||	(ThiE^1))	{i+=1;} else { lastStartMsgTxt = F("#Thi>Max"); }	//11
				//t1_crc > t2_cold_in   && ???
				if ( (TcrcE == 1 	&& Tcrc < cT_crc_max)  			||	(TcrcE^1))	{i+=1;} else { lastStartMsgTxt = F("#CaseHot"); }	//12
				if ( (TbcE == 1 	&& Tbc < cT_before_condenser_max) 	||	(TbcE^1))	{i+=1;} else { lastStartMsgTxt = F("#Tbc>Max"); }	//13
				//if ( (TregE == 1 	&& Treg > cT_crc_min)  			||	(TregE^1))	{i+=1;} else { lastStartMsgTxt = F("RegCold"); }	//14
				//if ( (TsucE == 1 	&& Tsuc > cT_coldref_min)		||	(TsucE^1))	{i+=1;} else { lastStartMsgTxt = F("Suc<CRMin"); }	//15
				if (i == 13) {
							//PrintSS(F("HP Started"));
							lastStartMsgTxt = F("HP_Started");
							fl_printSS_lastStartMsgTxt = 1;
							millis_last_heatpump_off = millis_now;
							heatpump_state = 1;
							lastStopCauseTxt = "";
							//lastStartMsgTxt = "";
				} else if (i < 13){
					//"waiting for something" state, do nothing here
				} else {
					//lastStartMsgTxt = F("UErr:1897");
					//PrintSS(lastStartMsgTxt);
				}
			}
			
			//
			
			//stop if
			//    ( (last_off > N) and (t watertank > target) )
			#ifdef SETPOINT_THI
			if ( heatpump_state == 1     &&     ((unsigned long)(millis_now - millis_last_heatpump_off) > mincycle_poweron)    &&    (Thi > T_setpoint) &&  errorcode == ERR_OK) {//or Ts1, if tank heater
			#endif
			#ifdef SETPOINT_TS1
			if ( heatpump_state == 1     &&     ((unsigned long)(millis_now - millis_last_heatpump_off) > mincycle_poweron)    &&    (Ts1 > T_setpoint) &&  errorcode == ERR_OK) {//or Thi, if default warm floor heat pump
			#endif
				millis_last_heatpump_on = millis_now;
				heatpump_state = 0;
				LSCint = LSCint_normal;
				lastStopCauseTxt=F("Normal_stop");
				fl_printSS_lastStopCauseTxt = 1;
				//PrintSS(lastStopCauseTxt);
			}

			//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) ) 	|| 	((_1st_start_sleeped == 0 ) && (hotside_circle_state  == 0))	){
				PrintSSch(IDX_HWPON);
				millis_last_hotWP_off = millis_now;
				hotside_circle_state  = 1;
			}
			#ifdef SETPOINT_THI
				if (  (heatpump_state == 0)   &&  (hotside_circle_state  == 0)  && ((unsigned long)(millis_now - millis_last_hotWP_on) > HOTCIRCLE_START_EVERY)	) {    //process START_EVERY for hot side
					millis_last_hotWP_off = millis_now;
					hotside_circle_state  = 1;
					//PrintSS(F("HWP ON by startevery"));
					lastStartMsgTxt = F("HWP_ON_by_ev");
					fl_printSS_lastStartMsgTxt = 1;
				}
			#endif
			
			if (  (heatpump_state == 0)        &&    (hotside_circle_state  == 1) ) {
				if (	( (unsigned long)(millis_now - millis_last_heatpump_on) > deffered_stop_hotcircle) 	|| 	millis_last_heatpump_on == 0) 	{ //deffered stop aftret heat pump stop and correct processing of 1st start, 1st_start sleeped flag not used - there's another logic
					/*
					//useful for tank heater with Ts1 as setpont control and large intermediate water reservoir
					if ( 	(ThoE == 1 && Tho < (Ts1 + cT_hotcircle_delta_min))	||
						(ThiE == 1 && Thi < (Ts1 + cT_hotcircle_delta_min))	) {
						PrintSS(F("Hot CP OFF 1"));
						millis_last_hotWP_on = millis_now;
						hotside_circle_state  = 0;
					} else {
						PrintSS(F("Hot CP OFF 2"));
						millis_last_hotWP_on = millis_now;
						hotside_circle_state  = 0;
					}
					*/
					if ( (unsigned long)(millis_now - millis_last_hotWP_off) > HOTCIRCLE_STOP_AFTER) {	//and START_EVERY processing
						#ifdef SETPOINT_THI
						if ( Thi > T_setpoint ) 	{
						#endif
						#ifdef SETPOINT_TS1
						if ( Ts1 > T_setpoint )  	{
						#endif
							//PrintSS(F("HWP OFF"));
							lastStartMsgTxt = F("HWP_OFF");
							fl_printSS_lastStartMsgTxt = 1;
							millis_last_hotWP_on = millis_now;
							hotside_circle_state  = 0;
						}
					}
				}
			}
			
			//heat if we can, just in case, ex. if lost power, usefull for tank heater with large intermediate water reservoir
			/*
			if ( (hotside_circle_state  == 0) && 
				( ThoE == 1 && Tho > (Ts1 + cT_hotcircle_delta_min)  )  	||
				( ThiE == 1 && Thi > (Ts1 + cT_hotcircle_delta_min)  )  ) 	{
					PrintSS(F("Hot WP ON"));
					hotside_circle_state  = 1;
			}
			*/
			
			//process_cold_side_pump:
			//start if (heatpump_enabled)
			//stop if (heatpump_disbled)
			//start if tci < cold_min
			if (  (heatpump_state == 1)   &&  (coldside_circle_state  == 0)  ) {
				//PrintSS(F("CWP_ON"));
				millis_last_coldWP_off = millis_now;
				coldside_circle_state  = 1;
			}
			
			if (	(heatpump_state == 0)   	&&	(TciE == 1) 	&& 	(Tci > -127.0) 	&& 	(Tci < cT_cold_min) 	&& 	(coldside_circle_state  == 0)	) {
				//PrintSS(F("CWP ON by ColdMin"));
				lastStartMsgTxt = F("CWP_ON_CoMin");
				fl_printSS_lastStartMsgTxt = 1;
				millis_last_coldWP_off = millis_now;
				coldside_circle_state  = 1;
			}
			
			if (  	(heatpump_state == 0)   	&&  	(coldside_circle_state  == 1)	)	{	//is on
				if ( (TciE == 1 	&& Tci > cT_cold_min)  		||	(TciE^1))	{ 	//does not overfrozen
					//next: deal with unstable env. to prevent false starts (water tank with dynamic flows, maybe air heating): stop CWP while waiting period if false start
					//stop if T>S OR if not needed by prepare
					#ifdef SETPOINT_THI
					if (    ( Thi > T_setpoint )  || ((unsigned long)(millis_now - millis_last_coldWP_off) > (COLDCIRCLE_PREPARE*2)) 	) {
					#endif
					#ifdef SETPOINT_TS1
					if (	( Ts1 > T_setpoint )  || ((unsigned long)(millis_now - millis_last_coldWP_off) > (COLDCIRCLE_PREPARE*2))	) {
					#endif
						//PrintSS(F("CWP_OFF"));
						coldside_circle_state  = 0;
					}
				}
			}

			//protective_cycle:
			//stop if
			//      (error)
			//      (t hot out > hot max)
			//      (t hot in  > hot max)
			//      (crc 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 == ERR_OK ){
				if (ThoE 	== 1 	&&	Tho 	> cT_hot_max)			{heatpump_state = 0; 	lastStopCauseTxt = F("P.Tho");		}
				if (ThiE 	== 1 	&&	Thi 	> cT_hot_max)			{heatpump_state = 0; 	lastStopCauseTxt = F("P.Thi");		}
				if (TcrcE 	== 1 	&&	Tcrc	> cT_crc_max)   		{heatpump_state = 0; 	lastStopCauseTxt = F("P.Tcrc"); 	}
				if (TaeE 	== 1 	&& 	Tae 	< cT_coldref_min)		{heatpump_state = 0; 	lastStopCauseTxt = F("P.Tae"); 		}
				if (TbeE 	== 1 	&& 	Tbe 	< cT_before_evap_work_min) 	{heatpump_state = 0; 	lastStopCauseTxt = F("P.Tbe");		}
				//if (TsucE 	== 1 	&& 	Tsuc 	< cT_coldref_min)		{heatpump_state = 0; 	lastStopCauseTxt = F("P.Tsuc");		}
				if (TbcE 	== 1 	&& 	Tbc 	> cT_before_condenser_max)	{heatpump_state = 0; 	lastStopCauseTxt = F("P.Tbc");		}
				if (TciE 	== 1 	&& 	Tci 	< cT_cold_min)       		{heatpump_state = 0; 	lastStopCauseTxt = F("P.Tci");		}
				if (TcoE 	== 1 	&& 	Tco 	< cT_cold_min)			{heatpump_state = 0; 	lastStopCauseTxt = F("P.Tco");		}
				if (heatpump_state == 0){
					LSCint = LSCint_protective;
					fl_printSS_lastStopCauseTxt = 1;
					//PrintSS(lastStopCauseTxt);
					millis_last_heatpump_on = millis_now;
				}
			}
			
			//5 minutes workout checks
			//alive_check_cycle_after_5_mins:
			//(old)error if
			//(new)not error, just poweroff all
			//next disabled: issues after a deep freeze, long time needed for stabilisation
			//DISABLED//      or (t cold in - t cold out < t workingok min diff) 
			//DISABLED//      or (t hot out - t hot in < t workingok min diff)
			//      or (crc 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 )     &&   (  TcrcE == 1 && Tcrc < cT_workingOK_crc_min )  ) {
					//errorcode = ERR_HEATPUMP;
					millis_last_heatpump_on = millis_now;
					heatpump_state = 0;
					LSCint = LSCint_protective;
					lastStopCauseTxt = F("P.W.TcrcMIN");
					fl_printSS_lastStopCauseTxt = 1;
					//PrintSS(lastStopCauseTxt);
				}
				if ( ( errorcode == ERR_OK )     &&   ( async_wattage < c_workingOK_wattage_min )  ) {
					//errorcode = ERR_WATTAGE;
					millis_last_heatpump_on = millis_now;
					heatpump_state = 0;
					LSCint = LSCint_protective;
					lastStopCauseTxt = F("P.W.wattMIN");
					fl_printSS_lastStopCauseTxt = 1;
					//PrintSS(lastStopCauseTxt);
				}
				//digitalWrite(RELAY_HEATPUMP, heatpump_state);	////!!! old, now halifised
			}

				
			//disable pump by t.sensor error, sequentially
			if ( heatpump_state == 1   &&  errorcode == ERR_T_SENSOR ) {
				sequential_errors += 1;
				if (sequential_errors > MAX_SEQUENTIAL_ERRORS) {
					millis_last_heatpump_on = millis_now;
					heatpump_state = 0;
					LSCint = LSCint_error;
					lastStopCauseTxt = t_sensorErrString;
					fl_printSS_lastStopCauseTxt = 1;
				}
				//PrintSS(t_sensorErrString);
			}
			
			if ( errorcode == ERR_OK ) {	//auto-clean counter just in case
				sequential_errors = 0;
			}
			
			//disable pump by pressure error, immediately
			if ( heatpump_state == 1   &&  ( errorcode == ERR_P_HI || errorcode == ERR_P_LO ) ) {
				millis_last_heatpump_on = millis_now;
				heatpump_state = 0;
				if (errorcode == ERR_P_HI) {
					lastStopCauseTxt = F("E.PressHot");				
				} else if (errorcode == ERR_P_LO) {
					lastStopCauseTxt = F("E.PressCold");
				}
				LSCint = LSCint_error;
				fl_printSS_lastStopCauseTxt = 1;
				//PrintSS(lastStopCauseTxt);
			}

			//!!! self-test
			///heatpump_state = 1;
			
			halifise();
			
			if (errorcode == ERR_T_SENSOR) {
				PrintSS(t_sensorErrString);
			}
			
			if (fl_printSS_lastStartMsgTxt == 1){
				PrintSS(lastStartMsgTxt);
				fl_printSS_lastStartMsgTxt = 0;
			}
			
			if (fl_printSS_lastStopCauseTxt == 1){
				PrintSS(lastStopCauseTxt);
				fl_printSS_lastStopCauseTxt = 0;
			}
		#endif
		
		//process errors
		//beep N times error
		if ( errorcode != ERR_OK ) {
			LED_OK_state		= 0;
			LED_ERR_state		= 1;
			if (  ((unsigned long)(millis_now - millis_notification) > millis_notification_interval)  ||  millis_notification == 0 ) {
				millis_notification = millis_now;
				outString = F("Err: ");
				PrintSS_SaI(errorcode);
				for ( i = 0; i < errorcode; i++) {
					LED_ERR_state		= 0;
					halifise();
					analogWrite(speakerOut, 10);  	delay (500);      
					LED_ERR_state		= 1;
					halifise();
					analogWrite(speakerOut, 0);	delay (500);
				}
			}
		} else {
			LED_OK_state		= 1;
			LED_ERR_state		= 0;
			halifise();
		}
	}
	
	if (Serial.available() > 0) {
		inChar = Serial.read();
		if ( inChar == 0x1B ) {
			skipchars_local += 3;
			inChar = 0x00;
			millis_escinput_local = millis();
		}
		if ( skipchars_local != 0 ) {
			millis_charinput_local = millis();
			if ((unsigned long)(millis_charinput_local - millis_escinput_local) < 16*2 ) {	//2 chars for 2400
				if (inChar != 0x7e) {
					skipchars_local -= 1;
				}
				if (inChar == 0x7e) {
					skipchars_local = 0;
				}
				if (inChar >= 0x30 && inChar <= 0x35) {
					skipchars_local += 1;
				}
				inChar = 0x00;
			} else {
				skipchars_local = 0;
			}
		}
		_ProcessInChar();
	}
	
	if (RS485Serial.available() > 0) {
		//PrintSS("some on 485..");	//!!!debug
		#ifdef RS485_HUMAN
			if (RS485Serial.available()) {
				inChar = RS485Serial.read();
				//RS485Serial.print(inChar);	//!!!debug
				if ( inChar == 0x1B ) {
					skipchars_485 += 3;
					inChar = 0x00;
					millis_escinput_485 = millis();
				}
				if ( skipchars_485 != 0 ) {
					millis_charinput_485 = millis();
					//if (millis_escinput_485 + 2 > millis_charinput_485)
					if ((unsigned long)(millis_charinput_485 - millis_escinput_485) < 16*2 ) {	//2 chars for 2400
						if (inChar != 0x7e) {
							skipchars_485 -= 1;
						}
						if (inChar == 0x7e) {
							skipchars_485 = 0;
						}
						if (inChar >= 0x30 && inChar <= 0x35) {
							skipchars_485 += 1;
						}
						inChar = 0x00;
					} else {
						skipchars_485 = 0;
					}
				}
				_ProcessInChar();
			}
		#endif
        
		#ifdef RS485_JSON
			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
					dataBuf[index] = inChar;      	// Store it
					index++;                     	// Increment where to write next
					dataBuf[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 (dataBuf[0] != 0x00) {
			PrintSS("-");
			PrintSS(dataBuf);
			PrintSS("-");
			}
			*/
			//or this debug
			/*
			digitalWrite(SerialTxControl, RS485Transmit);
			halifise();
			delay(10);
			RS485Serial.println(dataBuf);
			RS485Serial.flush();
			RS485Serial.println(index);
			*/
			
			//ALL lines must be terminated with \n!
			if ( (dataBuf[0] == hostID) && (dataBuf[1] == devID) ) {             
				//  COMMANDS:
				// G (0x47): (G)et main data
				// TNN.NN (0x54): set aim (T)emperature
				// ENN.NN (0x45): set (E)EV difference aim
				digitalWrite(SerialTxControl, RS485Transmit);
				halifise();
				delay(1);
				//PrintSS(freeMemory());
				outString = "";
				outString = devID;
				outString += hostID;
				outString +=  "A ";  //where A is Answer, space after header
				char *outChar=&outString[0];
				if ( (dataBuf[2] == 0x47 ) ) {
					//PrintSS("G");
					//WARNING: this procedure can cause "NO answer" effect if no or few T sensors connected
					
					//outString = "";
					//if (TsgE)	{	outString += ",\"TSG\":" + String(Tsg);	}
					//if (TslE)	{	outString += ",\"TSL\":" + String(Tsl);	}
					//if (TbvE)	{	outString += ",\"TBV\":" + String(Tbv);	}
					//if (TsucE)	{	outString += ",\"TSUC\":" + String(Tsuc);}
					//RS485Serial.write(outChar);                    	//dirty hack to transfer long string
					//RS485Serial.flush();
					//delay (1);                                      //lot of errors without delay
					outString += "{";
					outString += "\"E1\":" + String(errorcode);  
					if (TciE)	{ 	outString += ",\"TCI\":"; 	ApToOut_D(Tci);	}
					if (TcoE)	{	outString += ",\"TCO\":"; 	ApToOut_D(Tco);	}
					if (TbeE)	{	outString += ",\"TBE\":"; 	ApToOut_D(Tbe);	}
					if (TaeE)	{	outString += ",\"TAE\":"; 	ApToOut_D(Tae);	}
					if (Ts1E)	{	outString += ",\"TS1\":"; 	ApToOut_D(Ts1);	}
					if (Ts2E)	{	outString += ",\"TS2\":"; 	ApToOut_D(Ts2);	}
					if (TcrcE)	{	outString += ",\"TCRC\":"; 	ApToOut_D(Tcrc);}
					if (TregE)	{	outString += ",\"TR\":"; 	ApToOut_D(Treg);}
					RS485Serial.write(outChar);                    	//dirty hack to transfer long string
					RS485Serial.flush();
					delay (1);                                      //lot of errors without delay
					
					outString = "";
					if (TacE)	{	outString += ",\"TAC\":"; 	ApToOut_D(Tac);	}
					if (TbcE)	{	outString += ",\"TBC\":"; 	ApToOut_D(Tbc);	}
					if (ThoE)	{	outString += ",\"THO\":"; 	ApToOut_D(Tho);	}
					if (ThiE)	{	outString += ",\"THI\":"; 	ApToOut_D(Thi);}
					outString += ",\"W1\":";	ApToOut_D(async_wattage);
					outString += ",\"EEVP\":" 	+ String(EEV_cur_pos);
					outString += ",\"EEVA\":"; 	ApToOut_D(T_EEV_setpoint);
					
					#ifndef EEV_ONLY
						outString += ",\"A1\":"; 	ApToOut_D(T_setpoint);  //(A)im (target)
						outString += ",\"RP\":" 	+ String(heatpump_state*RELAY_HEATPUMP);  
						outString += ",\"RH\":" 	+ String(hotside_circle_state*RELAY_HOTSIDE_CIRCLE);                  
						outString += ",\"RC\":" 	+ String(coldside_circle_state*1);  
						outString += ",\"RCRCH\":" 	+ String(crc_heater_state*3);                 
						//if (TregE)	{	outString += ",\"RRH\":" + String(reg_heater_state*4);}                 
						//RS485Serial.write(outChar);                    	//dirty hack to transfer long string
						//RS485Serial.flush();
						//delay (1);                                      //lot of errors without delay
					#endif
					RS485Serial.write(outChar);                    	//dirty hack to transfer long string
					RS485Serial.flush();
					delay (1);                                      //lot of errors without delay
					
					outString = "";
					outString = ",\"LSC\":\"";
					outString += lastStopCauseTxt;
					outString += ("\"");
					//RS485Serial.write(outChar);                    	//dirty hack to transfer long string
					//RS485Serial.flush();
					//delay (1);                                      //lot of errors without delay
					outString += ",\"LSM\":\"";
					outString += lastStartMsgTxt;
					outString += ("\"");
					outString += "}";
					
				} else if ( (dataBuf[2] == 0x54 ) || (dataBuf[2] == 0x45 )) {  //(T)arget or (E)EV target format NN.NN, text
					if ( isDigit(dataBuf[ 3 ]) && isDigit(dataBuf[ 4 ]) && (dataBuf[ 5 ] == 0x2e)  && isDigit(dataBuf[ 6 ]) && isDigit(dataBuf[ 7 ]) && ( ! isDigit(dataBuf[ 8 ])) ) {
						
						analogWrite(speakerOut, 10);
						delay (100); 
						analogWrite(speakerOut, 0);
						
						char * carray = &dataBuf[ 3 ];
						tempdouble = atof(carray);                
						if (dataBuf[2] == 0x54 ){
							if (tempdouble > cT_setpoint_max) {
								outString += "{\"r\":\"too hot!\"}";
							} else if (tempdouble < cT_setpoint_min) {
								outString += "{\"r\":\"too cold!\"}";
							} else {
								T_setpoint = tempdouble;
								_HotWPon_by_Setpoint_update();
								outString += "{\"r\":\"ok, new value: "; 
								ApToOut_D(T_setpoint);
								outString += "\"}";
							}
						}
						if (dataBuf[2] == 0x45 ) {
							if (tempdouble > 10.0) {		//!!!!!!! hardcode !!!
								outString += "{\"r\":\"too hot!\"}";
							} else if (tempdouble < 0.1) {		//!!!!!!! hardcode !!!
								outString += "{\"r\":\"too cold!\"}";
							} else {
								T_EEV_setpoint = tempdouble;
								outString += "{\"r\":\"ok, new EEV value: ";
								ApToOut_D(T_EEV_setpoint);
								outString += "\"}";
							}
						}
					} else {
						outString += "{\"r\":\"NaN, format: NN.NN\"}";
					}
				} else {
					//default, just for example
					outString += "{\"r\":\"no_command\"}";
				}
				//crc.integer = CRC16.xmodem((uint8_t& *) outString, outString.length());
				//outString += (crc, HEX);
				outString += "\n";
				RS485Serial.write(outChar);
			}
			
			index = 0;
			for (i=0;i < (BUFSIZE);i++) {  //clear buffer
				dataBuf[i]=0;
			}
			RS485Serial.flush();
			digitalWrite(SerialTxControl, RS485Receive);
			delay(1);
		#endif
		
		#ifdef RS485_MODBUS
			index = 0;
			z = 0;  //error flag
			while ( 1 == 1 ) {//9600
				//read
				//!!!!!!!
				//Serial.println("-");
				if (RS485Serial.available()) {
					if(index < BUFSIZE) {
						inChar = RS485Serial.read();	 
						//Serial.print(inChar, HEX);
						//Serial.print(" ");
						dataBuf[index] = inChar;      	
						index++;                   	
						dataBuf[index] = '\0';        	
						delayMicroseconds(80);       	//yep, 80, HERE
					} else {
						z = 1;
						while (RS485Serial.available()) {
							inChar = RS485Serial.read();
							delayMicroseconds(1800);
						}
						break;
					}
				} else {
					//Serial.print(".");
					tmic1 = micros();
					for (i = 0; i < 10; i++) {    
						delayMicroseconds(180);
						if (RS485Serial.available()){
							//Serial.print("babaika");
							//Serial.println(i);
							tmic2 = micros();
							break;
						}
						tmic2 = micros();
						if ( (unsigned long)(tmic2 - tmic1) > 1800 ){
							i = 10;
							break;
						}
					}
					if (i == 10 && RS485Serial.available()) {
						z = 2;
						i = 0;
						while (RS485Serial.available()) {
							if (i > 200){ 
								break; 
							}
							inChar = RS485Serial.read();
							delayMicroseconds(1800);
							i++;
						}
						break;
					} else if (!RS485Serial.available()) {
						break;
					} else if (RS485Serial.available()) {
						continue;
					} else {
						//PrintSS(F("e2245"));
					}
				}
			}
			
			
			//check CRC
			if (index < 3) { 
				z+= 10;
			}
			if ( dataBuf[1] == 0x03 && ( (index % 8 ) == 0) && index > 8 ) { //automatic "duplicated message" detector, can be found if lot of T sensors absent and requests are too fast
				index = 8;
			}
				
			crc16 = SEED;
			for (x = 0; x < (index-2); x++) {   
				Calc_CRC(dataBuf[x]); 
			}
			x = dataBuf[index - 2];
			y = dataBuf[index - 1];
			if (( x !=  (crc16 & 0xFF )) || ( y != (crc16 >> 8))) {
				z += 100;
			}
			//PrintSS(F("-----"));
			if ( z != 0 ) {
				//probably another proto
				//PrintSS(F("MmsgERR: "));
				/*Serial.println(z);
				for (x =0; x<index; x++){
					Serial.print(dataBuf[x], HEX);
					Serial.print(" ");
				}
				Serial.println();*/
			}  else {		
				/*PrintSS(F("ModbusMSG: "));
				Serial.println(z);
				for (x =0; x<index; x++){
					Serial.print(dataBuf[x], HEX);
					Serial.print(" ");
				}
				Serial.println();*/
				
				digitalWrite(SerialTxControl, RS485Transmit);
				halifise();
				z = 0;
				if (dataBuf[0] != 0x00 && dataBuf[0] != devID ) {	//will reply to 0x00
					z = 0xFF;
				}
				if (dataBuf[1] != 0x03 && dataBuf[1] != 0x06) { //0x01
					z = 1;
				}
				if (dataBuf[1] == 0x03 && dataBuf[2] != 0x00 && dataBuf[4] != 0x00) { //0x02
					z = 2;
				}
				if (dataBuf[1] == 0x06 && dataBuf[2] != 0x00) { 	//0x02
					z = 2;
				}
				if (dataBuf[1] == 0x06 && dataBuf[3] > MODBUS_MR)  {	//0x03
					z = 3;
				}
				if (dataBuf[1] == 0x03 && dataBuf[5] > MODBUS_MR)  {	//0x05 
					z = 5;
				}
				
				i = 0;
				//dataBuf[i]  =  devID;
				//unchanged! can be devID or 0x00
				i++;
				if (z == 0) {
					//PrintSS(F("ModParse"));
					x = dataBuf[3]; 	//addr	
					y = dataBuf[5];		//num
					if (dataBuf[1]  ==  0x03) {
						//PrintSS(F("F03"));
						dataBuf[i]  = 0x03;
						i++;	
						//the most significant byte is sent first
						dataBuf[i]  =  y*2;
						i++;  // data
						for (u = x; u < (x+y); u++) {
							if (u > MODBUS_MR){
								z = 2;
								break;
							}
							switch (u) {								
								case 0x00:
									Add_Double_To_Buf_IntFract(Tci); //uses dataBuf, i
									break;
								case 0x01:
									Add_Double_To_Buf_IntFract(Tco); //uses dataBuf, i
									break;
								case 0x02:
									Add_Double_To_Buf_IntFract(Tbe); //uses dataBuf, i
									break;
								case 0x03:
									Add_Double_To_Buf_IntFract(Tae); //uses dataBuf, i
									break;
								case 0x04:
									//Add_Double_To_Buf_IntFract(Tsg); //uses dataBuf, i
									dataBuf[i]  = 0;
									i++;
									dataBuf[i]  = 0;
									i++;
									break;
								case 0x05:
									//Add_Double_To_Buf_IntFract(Tsl); //uses dataBuf, i
									dataBuf[i]  = 0;
									i++;
									dataBuf[i]  = 0;
									i++;
									break;
								case 0x06:
									//Add_Double_To_Buf_IntFract(Tbv); //uses dataBuf, i
									dataBuf[i]  = 0;
									i++;
									dataBuf[i]  = 0;
									i++;
									break;
								case 0x07:
									//Add_Double_To_Buf_IntFract(Tsuc); //uses dataBuf, i
									dataBuf[i]  = 0;
									i++;
									dataBuf[i]  = 0;
									i++;
									break;
								case 0x08:
									Add_Double_To_Buf_IntFract(Ts1); //uses dataBuf, i
									break;
								case 0x09:
									Add_Double_To_Buf_IntFract(Ts2); //uses dataBuf, i
									break;
								case 0x0A:
									Add_Double_To_Buf_IntFract(Tcrc); //uses dataBuf, i
									break;
								case 0x0B:
									Add_Double_To_Buf_IntFract(Treg); //uses dataBuf, i
									break;
								case 0x0C:
									Add_Double_To_Buf_IntFract(Tac); //uses dataBuf, i
									break;
								case 0x0D:
									Add_Double_To_Buf_IntFract(Tbc); //uses dataBuf, i
									break;
								case 0x0E:
									Add_Double_To_Buf_IntFract(Tho); //uses dataBuf, i
									break;
								case 0x0F:
									Add_Double_To_Buf_IntFract(Thi); //uses dataBuf, i
									break;
								case 0x10:
									dataBuf[i]  = 0;
									i++;
									dataBuf[i]  = errorcode;
									i++;
									break;
								case 0x11:
									dataBuf[i]  = (int)async_wattage >> 8;
									i++;
									dataBuf[i]  = (int)async_wattage & 0xFF;
									i++;
									break;
								case 0x12:
									dataBuf[i]  = 0;
									i++;
									dataBuf[i]  = 0;
									bitWrite(dataBuf[i], 0, heatpump_state);
									bitWrite(dataBuf[i], 1, hotside_circle_state);
									bitWrite(dataBuf[i], 2, coldside_circle_state);
									bitWrite(dataBuf[i], 3, crc_heater_state);
									//bitWrite(dataBuf[i], 4, reg_heater_state);
									i++;
									break;
								case 0x13:
									Add_Double_To_Buf_IntFract(T_EEV_setpoint); //uses dataBuf, i
									break;
								case 0x14:
									Add_Double_To_Buf_IntFract(T_setpoint); //uses dataBuf, i
									break;
								case 0x15:
									dataBuf[i]  = (int)EEV_cur_pos >> 8;
									i++;
									dataBuf[i]  = (int)EEV_cur_pos & 0xFF;
									i++;
									break;
								case 0x16:
									dataBuf[i]  = lastStopCauseTxt.charAt(0);
									i++;
									dataBuf[i]  = lastStopCauseTxt.charAt(1);
									i++;
									break;
								case 0x17:
									dataBuf[i]  = lastStopCauseTxt.charAt(2);
									i++;
									dataBuf[i]  = lastStopCauseTxt.charAt(3);
									i++;
									break;
								case 0x18:
									dataBuf[i]  = lastStopCauseTxt.charAt(4);
									i++;
									dataBuf[i]  = lastStopCauseTxt.charAt(5);
									i++;
									break;
								case 0x19:
									dataBuf[i]  = lastStopCauseTxt.charAt(6);
									i++;
									dataBuf[i]  = lastStopCauseTxt.charAt(7);
									i++;
									break;
								case 0x1A:
									dataBuf[i]  = lastStopCauseTxt.charAt(8);
									i++;
									dataBuf[i]  = lastStopCauseTxt.charAt(9);
									i++;
									break;
								case 0x1B:
									dataBuf[i]  = lastStopCauseTxt.charAt(10);
									i++;
									dataBuf[i]  = lastStopCauseTxt.charAt(11);
									i++;
									break;
								case 0x1C:
									dataBuf[i]  = lastStartMsgTxt.charAt(0);
									i++;
									dataBuf[i]  = lastStartMsgTxt.charAt(1);
									i++;
									break;
								case 0x1D:
									dataBuf[i]  = lastStartMsgTxt.charAt(2);
									i++;
									dataBuf[i]  = lastStartMsgTxt.charAt(3);
									i++;
									break;
								case 0x1E:
									dataBuf[i]  = lastStartMsgTxt.charAt(4);
									i++;
									dataBuf[i]  = lastStartMsgTxt.charAt(5);
									i++;
									break;
								case 0x1F:
									dataBuf[i]  = lastStartMsgTxt.charAt(6);
									i++;
									dataBuf[i]  = lastStartMsgTxt.charAt(7);
									i++;
									break;
								case 0x20:
									dataBuf[i]  = lastStartMsgTxt.charAt(8);
									i++;
									dataBuf[i]  = lastStartMsgTxt.charAt(9);
									i++;
									break;
								case 0x21:
									dataBuf[i]  = lastStartMsgTxt.charAt(10);
									i++;
									dataBuf[i]  = lastStartMsgTxt.charAt(11);
									i++;
									break;
								default:
									dataBuf[i]  = 0x00;
									i++;
									dataBuf[i]  = 0x00;
									i++;
									break;
							}
						}
					} else if (dataBuf[1]  ==  0x06) {	//de-facto echo
						//PrintSS(F("F06"));
						dataBuf[i]  = 0x06;
						i++;
						dataBuf[i]  = 0x00;
						i++;
						dataBuf[i]  = x;
						i++;

						switch (x) {
							case 0x13:
								//PrintSS(F("06F_EEV_setpoint"));
								IntFract_to_tempdouble(dataBuf[4], dataBuf[5]);
								//Serial.println(tempdouble);
								if (tempdouble > 15.0 || tempdouble < -15.0) {		//incorrectest values filter
									z = 3;
									break;
								}
								T_EEV_setpoint = tempdouble;
								//Serial.println(T_EEV_setpoint);
								Add_Double_To_Buf_IntFract(T_EEV_setpoint); //uses dataBuf, i
								break;
							case 0x14:
								//PrintSS(F("06F_T_setpoint"));
								IntFract_to_tempdouble(dataBuf[4], dataBuf[5]);
								//Serial.println(tempdouble);
								if (tempdouble > cT_setpoint_max || tempdouble < cT_setpoint_min) {	//incorrectest values filter
									z = 3;
									break;
								}
								T_setpoint = tempdouble;
								_HotWPon_by_Setpoint_update();
								//Serial.println(T_setpoint);
								Add_Double_To_Buf_IntFract(T_setpoint); //uses dataBuf, i
								break;
							//case 0x15:
							//	//EEV_cur_pos
							//	break;
							default:
								z = 3;
								break;
						}
					} else {
						PrintSSch(IDX_UNKNF);
						z = 1;
					}
					if (z != 0) {
						i = 1;
						bitWrite(dataBuf[i], 7, 1);
						i++;
						dataBuf[i] = z;
						i++;
					}
					
					crc16 = SEED;
					for (x = 0; x < (i); x++) {   
						Calc_CRC(dataBuf[x]); 
					}
					dataBuf[i] = crc16 & 0xFF;
					i++;
					dataBuf[i] = crc16 >> 8;
					i++;
					
					RS485Serial.write(dataBuf, i);
					RS485Serial.flush();	
					delay (1);              

					//!!! debug
					/*
					for (x = 0; x<i; x++){
						Serial.print(dataBuf[x], HEX);
						Serial.print(" ");
					}
					*/
					/*Serial.println("ModResp");
					for (z = 0; z < i; z++){
						Serial.print(dataBuf[z], HEX);  
						Serial.print(" ");  
						if ( z%50 == 0) Serial.println();
					}
					Serial.println();*/
					
					digitalWrite(SerialTxControl, RS485Receive);
				}
			}
		#endif
	}
}