Centralized control Solar-Biomass mixed system with Arduino and TFT Shield

In this post I will share with you the improvements I've made to our biomass/Solar mixed system , which is basically to change the obsolete control system for thermostats with a centralized system based on Arduino fully customizable, flexible and expandable; we will see the assembly, components and source code.

Applied materials:

   1 - Arduino MEGA 2560 (specifically I used a Funduino clone ), because the TFT shield does not leave me enough inputs / outputs Free UNO R3.

   2 - Touch Screen TFT 2.4 "  McuFriend , which will give us great freedom when it comes to display information on screen libraries that have worked best for me. Are the BUHOSOFT ; here you can download the version I used.

   3 - relays to activate solenoid valves, with a fed to 5V that can handle 230V and 10A worth us to spare.Not to stress regulator Arduino board, the food independently with other L7805 regulator (handles between 7-30V and 1.5A max). Being so low consumption, nor need a heatsink:

   - A speaker-buzzer for alarm warning in case of problems, which operates between 7 and 12V 100dB, enough.

   - A relay SSR DC-DC to activate the buzzer ; only consumes between 3 and 25mA so we can turn directly to the Arduino pin. I used one of solid state more than anything because I had left the other, butsince it is an element that is to be activated soon, you better go to a mechanical more economical and compact:

- Another solid state relay AC-DC to activate the motor . Of at least 10A, will be the element that suffer the continuous activations, so that the durability and reliability of solid state relay will ensure a long maintenance free I've added a heatsink for if heated , although I have exceeded its size as I then checked, but better to err;).

   - 4 sensors NTC 6K8 (at 25 ohm resistance is 6K8) plus 4 resistors 6K8 necessary, obtained from some old batteries, which measures temperatures between -25 and 125 ° C, ideal for the temperatures to be managed:

Such sensors are easy to get and set taking temperatures and resistance at two points (as I explained in the previous post ), these can be obtained from lithium batteries and large NI-MH ; the carry to regulate its temperature within safe margins, glued thereto. We also have them in batches very economical. Be sure that is the type that you have referred to in the schedule; in my case NTC (Negative Temperature Coefficient..); indicating rising temp. by lowering its resistance.

I preferred to use such sensors for price and convenience more than anything , instead of the usual transistors DS18B20, very common as well. 
Note that not suitable for very humid environments; water is conductive and would raise the temperature indicated incorrectly. To avoid possible problems with rain, water leakage, etc. can be isolated with "liquid silicone" a hotmelt or silicone standard l, as I have done.

Mounting elements and debugged the program

With a prototype card I connect the resistors and sensors, and I tested the data on screen and the feedback we debugged by series errors.

(For those who need it, when I can prepare the scheme with Fritzing to clarify the connections).

After a couple of days working properly, I connect the elements definitively:

For simplicity I have soldered directly 6K8 resistance of each sensor (analog pins 11 to 14) behind the plate:

In the following video I try running surface ; when we launched last settings:

Replacing the old system

The first is to identify each cable ; the previous configuration they were not, and I would have saved time; between sensors, power, and engine elecroválvulas are a few wires and there can be errors:

We take the same box, leaving the screen in the center window slightly enlarging the alarm at the top:

I distributed all over the box, which had ample depth for all elements:

In the next picture it can not be seen, but there is a USB cable plate hanging out for possible updates and final program debugging :

Replace the temperature sensors

Those who had placed could have served, but since thermostats are compatible with a limited range of sensors, I preferred to reserve them to remove them.

To replace the tank, insert the new one in its place ; the tank has a housing 6 mm. x 50 cm long where the sensor is inserted until the middle of the tank; the new sensor was introduced without difficulty, finer than the old one you see in the image:

Also change the sensor.  I could verify that after 7 years of use, is maintained in good condition, hardly have whitened polycarbonate, and thanks to the high temperatures fends off any moss or plant that wants to develop:

I used to change the board of the trap, which was already badly corroded.

In the image below we have placed the sensor on top of the hot water outlet of the solar collector(more details on its construction inputs), with white tape and more flanges. After white silicone will place above to isolate it better from the outside and does not distort the temperatures in winter, keeping the temperature as close to the actual water pipe.

The program is as follows (available in github) :

/*
 * ARCHIVO: Control sistema térmico mixto biomasa-solar
 *   AUTOR: David Losada
 *   FECHA: 8/08/2016
 *     URL: http://miqueridopinwino.blogspot.com.es/2016/08/control-centralizado-del-sistema-mixto-biomasa-solar-con-Arduino.html
 *   Versión 1.65 (7/01/17)
 *   - Se ha corregido el código de desconexión en caso de biomasa encendida, para evitar apagar el motor demasiado pronto con brasas
 *   - Se añade aviso de excesiva diferencia entre sondas, indicando en rojo la temperatura y activando alarma
 *   - Mejorada la alarma; se hace intermitente.
 *   - Añadido un 5º termistor en el serpentin biomasa (parte baja) por seguridad; Biomasa2, a veces se calienta antes en la parte inferior
 *   - Corregida la contabilización de horas funcionamiento
 *   - Cambiado el orden en pantalla
 *   - Se indican los KWh ahorrados por energía renovable :) (aproximado)
 *   - Cambiada la forma en que se comprueban temperaturas, dando prioridad real a biomasa (o estamos jodidos)
 *   - Ahora se activa cada 15 días la válvula de enfriado para evitar su agarrotamiento
 *   - Corregidos varios errores
 *   - 10/12/16 Mejorados varios puntos; no contabilizaba horas de motor, y la comprobación de temperaturas no era óptima con depósito
 *   - 12/12/16 Mejorado el código: añadido código para dormir el procesador, reducir los refrescos a lo mínimo necesario y sensor de pellets futuro
 *   - 15/12/16 Corregida la evaluación del tiempo
 *   - 07/01/16 Corregido error en la condición de apagado del motor en caso de activación por el captador solar
 *
 * OBJETIVO: Prototipo control de sistema casero mixto biomasa-solar térmica
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 */

// Uses TFTLCD sketch that has been Refurbished by BUHOSOFT
// If using an Arduino Mega make sure to use its hardware SPI pins, OR make
// sure the SD library is configured for 'soft' SPI in the file Sd2Card.h.

// Original code provided by Smoke And Wires
// http://www.smokeandwires.co.nz
// This code has been taken from the Adafruit TFT Library and modified
//  by us for use with our TFT Shields / Modules
// For original code / licensing please refer to
// https://github.com/adafruit/TFTLCD-Library

// adapted sketch by niq_ro from http://arduinotehniq.blogspot.com/
// ver. 1m5 - 13.11.2014, Craiova - Romania

//Librerías para dormir al procesador y ahorrar energía cuando no hace nada
#include 
#include 
#include 

//Librerías para la pantalla gráfica
#include 
#include 
#include 
#include 
#include 
#include 

#if defined(__SAM3X8E__)
    #undef __FlashStringHelper::F(string_literal)
    #define F(string_literal) string_literal
#endif

// The control pins for the LCD can be assigned to any digital or
// analog pins...but we'll use the analog pins as this allows us to
// double up the pins with the touch screen (see the TFT paint example).
// #define LCD_CS A3 // Chip Select goes to Analog 3
// #define LCD_CD A2 // Command/Data goes to Analog 2
// #define LCD_WR A1 // LCD Write goes to Analog 1
// #define LCD_RD A0 // LCD Read goes to Analog 0

// #define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin

// When using the BREAKOUT BOARD only, use these 8 data lines to the LCD:
// For the Arduino Uno, Duemilanove, Diecimila, etc.:
//   D0 connects to digital pin 8  (Notice these are
//   D1 connects to digital pin 9   NOT in order!)
//   D2 connects to digital pin 2
//   D3 connects to digital pin 3
//   D4 connects to digital pin 4
//   D5 connects to digital pin 5
//   D6 connects to digital pin 6
//   D7 connects to digital pin 7
// For the Arduino Mega, use digital pins 22 through 29
// (on the 2-row header at the end of the board).

//#define DEBUG
#include 
#include  //Para usar la memoria EEPROM
//Arduino con Tiny RTC I2C http://zygzax.com
//#include 
//#include 
#include  //Manejo reloj interno Arduino

#define LCD_CS A3
#define LCD_CD A2
#define LCD_WR A1
#define LCD_RD A0
// optional
#define LCD_RESET A4


#define YP A1 // Y+ is on Analog1
#define XM A2 // X- is on Analog2
#define YM 7 // Y- is on Digital7
#define XP 6 // X+ is on Digital6

#define TS_MINX 150
#define TS_MINY 120
#define TS_MAXX 920
#define TS_MAXY 940

// For better pressure precision, we need to know the resistance
// between X+ and X- Use any multimeter to read it
// For the one we're using, its 326 ohms across the X plate
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 326);

// Assign human-readable names to some common 16-bit color values:
#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF
//#define ROZ     0xFD20
#define ROZ     0xFBE0
#define GRI     0xBDF7
// http://stackoverflow.com/questions/13720937/c-defined-16bit-high-color
// http://wiibrew.org/wiki/U16_colors

Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);;
// If using the shield, all control and data lines are fixed, and
// a simpler declaration can optionally be used:
//Adafruit_TFTLCD tft;



////***************** COMIENZO DE PARÁMETROS CONFIGURABLES ***********************
//Control temperatura
//Para ahorrar cálculos, lo vamos a calcular antes del programa
//const float TPto1 = -6; //Temperatura en ºC punto 1 (A descomentar las siguientes cuatro líneas  si desconocemos el varor de B para el termistor utilizado)
//const float RPto1 = 40000; // Ohms en punto 1
//const float TPto2 = 96; // Temp. punto 2
//const float RPto2 = 970; // Ohms en punto 2
const long B = 3850; //Valor Beta del Datasheet; comentar esta línea si se meten los datos de los dos puntos
const int resistor = 6800; //El valor en ohmnios de la resistencia del termistor a 25ºC
const float voltage = 5.01; // El voltaje real en el punto 5Vcc de tu placa Arduino

//Deltas de temperatura
const byte DtFsolar = 6; //Delta temp ºC conexión de motor circuito panel solar
const byte Dtosolar = 1; //Delta temp. desconexión motor

const byte DtFbiomasa = 12; //Delta temp ºC conexión de motor y válvula circuito biomasa
const byte Dtobiomasa = 2; //Delta temp ºC desconexión de motor y válvula circuito biomasa

const byte DtFEnfriar = 65; //Temp. ºC conexión electroválvula circuito desvío exceso temp a calefacción
const byte DtoEnfriar = 60; //Temp. desconexión electroválvula desvío agua caliente a calefacción

const int frecseg = 1; //Tiempo en segundos X2 entre cada ejecución del programa (recomendado poner entre 1 y 3 para mantener la velocidad de respuesta)
const byte difTemp = 25; //Diferencia de temperatura máxima entre sondas considerada normal, a partir de la cual salta la alarma
const double ltsdeposito = 250; //para el cálculo de Kwh ahorrados; indicar aquí la capacidad del depósito de inercia

//Definición pines digitales para activar relés
#define ledPIN 13 //Led placa arduino
#define motorPIN 25 //Pin digital activar relé motor
#define valvbioPIN 27 //Pin digital activar relé electroválvula circuito biomasa
#define valvenfriaPIN 29 //Pin digital activar relé electroválvula circuito calefacción radiante
#define zumbadorPIN 31 //Conexión al Mosfet del zumbador electrónico de aviso
//En mi caso lo sensores están puestos en este orden desde el 11: Captador,Deposito,Biomasa1,Retorno,Biomasa2
#define primerSensor 11 //Pines analógicos para termistores; van correlativos desde este
#define numeroSensores 5 //Cantidad de sensores

float calibTemps[numeroSensores] = {0,0,0,0,0}; //Matriz de ajustes calibración sensores en ºC; se sumará a la temp. obtenida

int horasValvEnfria=120; //Cada este número de horas/3 se activará una vez la válvula de enfriado para evitar que se quede agarrotada

//***************** FIN DE PARÁMETROS CONFIGURABLES ***********************

//Variables 
double Msensores[numeroSensores] = {0,0,0,0,0}; //Matriz temperaturas obtenidas de sensores en orden de PIN
double Mtempsens[numeroSensores] = {0,0,0,0,0}; //Matriz temperaturas ordenadas a nuestro gusto
double MtempAnt[numeroSensores] = {0,0,0,0,0}; //Matriz temperaturas anteriores para borrado pantalla
const char* Mnombres[]={"Captador:","Biomasa1:","Biomasa2:","Retorno: ","Deposito:"}; //Matriz de arrays (*=pointers) de los nombres de los sensores
String TextoAnt;

#define captador 0 //Definimos la posición en la matriz de cada texto 
#define biomasa1 1
#define biomasa2 2
#define retorno  3
#define deposito 4
#define pellets  5

boolean motorON=false; //Para comprobar si está en marcha
boolean valvula=false; //control electroválvula 3 vías biomasa
//datos estadísticos y otras
long Mdatos[6] = {0,0,0,0,0,0}; //Matriz estadístias uso
//Matriz de arrays (*=pointers) de los nombres de los datos; No deberían tener más de 13 caracteres cada una (sumar 
const char* MnomDatos[]={"Hrs motor ON","Hrs Arduino","CTR RELE Motor","CTR VALVULA Fuego","CTR VALVULA Enfriar","KWh RENOVABLES"}; 
#define hrsMotorOn 0 //Para hacer referencia en código directamente
#define hrsArduino 1
#define ctrReleMotor 2
#define ctrValvulaFuego 3
#define ctrValvulaEnfriar 4
#define ctrKWh 5
double tempPrevia=0; //Temperatura cuando se activa el motor para el cálculo de Kwh ahorrados
double kwhAhorro=0; //Para cálculos
const double kwhGrado =  250 * (double(23)/double(859)); //Hacemos el cálculo de los kwh que suponen cada ºC que subimos la temp.; 1kWh son 859 kcal; 1 lt cuesta 23 Kcal

int activarValvEnfria=0; //Contador para activar la válvula de enfriado cada "horasValvEnfria" horas.

//Para ahorrar cálculos lo definimos como constante en esta parte del programa
const float K= 273.15; //Para pasar a grados Kelvin
const float e = 2.718281828459045; //Constante matemática 
//const float B = log(RPto2/RPto1)/(1/(TPto2+K)-(1/(TPto1+K))); //Valor Beta de tu termistor calculado de dos puntos
const float unodivr = 1/(resistor * pow(e,(-B/298.15))); //Con pow elevamos e al resultado

double T = 0; //Declaramos la variable Temperatura
int grados, decimas; //Para ponerle coma al resultado (en español)

float segundos=0; //Guardamos segundos funcionamiento (en sleepmode millis se para)
unsigned long millisAnterior=0; //Guardamos millis anterior
unsigned long segundosArduino=0; //Guardar horas funiconamiento Arduino
unsigned long segundosRefresca=0; //para refrescar pantalla
unsigned long segundosInicioMotor=0; //Guardar tiempo activado motor
unsigned long restoSegundosMotor=0; //Guardamos resto tiempo activación motor
unsigned long timeLED=0; //Tiempo funcionamiento LED placa
unsigned long segundosValvula=0; //Guardar momento activación válvula para desactivar después de 15 min.
byte error=0; //En caso de error será <> 0

int direccionInicial; //Dirección memoria EEPROM a partir de la cual se guardan los datos, asignado por la librería EEPROMex

void setup() {
  Serial.begin(9600);

//Descomentar las líneas siguientes para sincronizar tiempo por el Serial
//  if(Serial.available()) 
//  {
//     time_t t = processSyncMessage();
//     if(t >0)
//     {
//        RTC.set(t);   // set the RTC and the system time to the received value
//        setTime(t);          
//     }
//  }
//   digitalClockDisplay();  
//   delay(1000);
//}

  //sync internal time to the RTC
//  setSyncProvider(RTC.get);   // the function to get the time from the RTC
//  Serial.println();
//  if(timeStatus()!= timeSet) 
//     Serial.println("Unable to sync with the RTC");
//  else
//     Serial.println("RTC has set the system time");
//Wire.begin();
//RTC.begin();
//Si quitamos el comentario de la linea siguiente, se ajusta la hora y la fecha con la del ordenador
//RTC.adjust(DateTime(__DATE__, __TIME__));
  Serial.println("Arduino Working OK");

//Líneas de configuración del WatchDog Timer
/*** Setup the WDT ***/
  
  /* Clear the reset flag. */
  MCUSR &= ~(1<90) {
      error++; //Si se acumula algún error, haremos saltar la alarma en forma de zumbido
     }
 }  

//Guardamos valores anteriores
for(int i=0; i= DtFbiomasa or (Mtempsens[biomasa2]-Mtempsens[retorno])>= DtFbiomasa or (Mtempsens[biomasa1]-Mtempsens[deposito])>= DtFbiomasa) {
    valvula=true;
    motorON=true;
  }
else { //Si lo anterior no se cumple, comprobar si ya no está caliente y si temperatura captador también está frío, apagar
  if ((Mtempsens[biomasa1]-Mtempsens[retorno])<= Dtobiomasa and (Mtempsens[biomasa2]-Mtempsens[retorno])<= Dtobiomasa) {
    motorON=false;
  }
  //Si se activó por el captador, pero ya está frío, apagar motor
  if ((Mtempsens[captador]-Mtempsens[retorno])< Dtosolar and valvula==false) {
    motorON=false;
  }
  //Si captador solar está caliente activamos motor
  if ((Mtempsens[captador]-Mtempsens[deposito])>= DtFsolar) { //Si diferencia temp. captador y depósito mayor que el delta, activar motor
    motorON=true;
    }
 }

//Serial.print("Temp deposito: ");
//Serial.println(Mtempsens[deposito]);
//Serial.print("Temp previa: ");
//Serial.println(tempPrevia);

//Dependiendo del resultado de las anteriores comprobaciones, actuamos sobre el motor y electroválvula
if (motorON==true) {
    if (digitalRead(motorPIN)==LOW) { //Se activa relé; contamos el número de activaciones
    Mdatos[ctrReleMotor]++;
    tempPrevia=Mtempsens[deposito]; //Guardamos temperatura actual deposito
    segundosInicioMotor=segundos; //Y activamos el contador de tiempo uso motor
  }
  digitalWrite(motorPIN,HIGH);
  }
else  {
    //Cada vez que paramos el motor, comprobamos diferencia temp. depósito y añadimos kwh ahorrados
    if (Mtempsens[deposito]>tempPrevia and digitalRead(motorPIN)==HIGH) {
      Serial.print("Valor kwh");
      Serial.println(kwhGrado);
      kwhAhorro=(Mtempsens[deposito]-tempPrevia)*kwhGrado;
      Serial.print("Ahorro");
      Serial.println(kwhAhorro);
      Mdatos[ctrKWh]=Mdatos[ctrKWh]+int(kwhAhorro); //Guardamos el dato
      segundosValvula=segundos; //Iniciamos cuenta atrás
    }
    digitalWrite(motorPIN,LOW);
  }

if (motorON==false and (segundos-segundosValvula)>=600) { //Si el motor sigue apagado 10 minutos, apagamos válvula tres vías.
      valvula=false;  //Para evitar accionamientos innecesarios en las bajadas de temp por recargas de leña
}

if (valvula==true) {
    if (digitalRead(valvbioPIN)==LOW) { //Se activa relé; contamos el número de activaciones
      Mdatos[ctrValvulaFuego]++;
        }
    digitalWrite(valvbioPIN, HIGH);
}
else  {
    digitalWrite(valvbioPIN,LOW);
  }

//Si la temperatura del depósito es excesiva, o éste no absorve suficiente calor del serpentín, activar el relé de enfriamiento (desvío a calefacción)
if (((Mtempsens[deposito]> DtFEnfriar) and motorON==true) or (motorON==true and Mtempsens[biomasa1]>80)) {
    if (digitalRead(valvenfriaPIN)==LOW) { //Se activa relé; contamos el número de activaciones
    MnomDatos[ctrValvulaEnfriar]++;
  }
  Serial.println("Activar válvula desvío circuito enfriado");
  digitalWrite(valvenfriaPIN,HIGH);
}
else { //Desactivar la válvula enfriado si la temp depósito ha bajado suficiente o el motor se ha parado (ya no hay más aporte de calor)
    if ((Mtempsens[biomasa1]<70 a="" actualizamos="" ada="" and="" deposito="" digitalwrite="" dtoenfriar="" en="" estad="" hora="" if="" la="" lcd="" lo="" los="" mandamos="" motoron="=false" mtempsens="" or="" ostramos="" pantalla="" por="" primeros="" segundos-segundosrefresca="" segundos="" serial.println="" sticas="" texto="" ultimo="" valvenfriapin="" y="">=3600 or millis()<10000 abs="" actualizamos="" ada="" ahorro="" anal="" anterior="" atos="" c="" cimas="" co2:="" co2="" ctrkwh="" cuenta="" d="" datos="" de="" decimas="" else="" en="" estad="" evitado="" for="" gicos="" grado="" grados="" i="" if="" int="" kg="" kwh="" lento="" lo="" muy="" ndicamos="" nombres="" nomdatos="" numerosensores="" orramos="" pocos="" rados="" s="" scribimos="" seg.="" segundosrefresca="segundos;" sticas="" tempsens="" tenerlo="" termistores="" tft.fillscreen="" tft.print="" tft.println="" tft.setcursor="" tft.settextcolor="" tft.settextsize="" y="">-270) {
      if ((i==captador) || (i==biomasa1) || (i==biomasa2)) { //Si sonda captador o biomasa tienen mucha diferencia con respecto de depósito y retorno
        if ((Mtempsens[i]-Mtempsens[i+1])>difTemp) {
          tft.setTextColor(RED); //Ponemos la temperatura en rojo
          error++; //Activamos alarma
        }
      }
      grados=int(Mtempsens[i]);
      if (grados<10 _______________________________="" _______________________________________="" a="" abs="" acaba="" activada="" activado="" ahorro="" al="" and="" apagarse="" aviso="" biomasa="" cimas="" contador="" d="" de="" decimas="" del="" digitalread="" el="" else="" encendido="" enfria="" enfriado="" erial.print="" erial.println="" error="" es="" est="" estado="" extoant="" grado="" grados="" guardamos="" ha="" horas="" if="" illis:="" illismotor:="" incorrecta="" kwh="" la="" lectrov="" lo="" lvula="" millisiniciomotor="" motor="" motoron="=false" ndicamos="" nuevo="" off="" on="" onemos="" rados="" renovables="" reseteamos="" segundos="" segundosiniciomotor="" si="" stuvo="" sumamos="" temp="" textoant="String(TextoAnt" tft.print="" tft.println="" tft.setcursor="" tft.settextcolor="" tft.settextsize="" tiempo="" tiempos="" v="" valvbiopin="" valvenfriapin="" y="">0) { 
    Mdatos[hrsMotorOn]= Mdatos[hrsMotorOn] + ((segundos+restoSegundosMotor-segundosInicioMotor)/3600);
    restoSegundosMotor=(segundos+restoSegundosMotor-segundosInicioMotor)-(int((segundos+restoSegundosMotor-segundosInicioMotor)/3600)*3600);
    segundosInicioMotor=0;
}
//DEBUG ***********
//Serial.print("HrsMotorOn: ");
//Serial.println(Mdatos[hrsMotorOn]);
//Serial.print("restoHrsMotor: ");
//Serial.println(restoSegundosMotor);

//*** Cada 3 horas salvamos a la EEPROM los datos que han cambiado (no hacerlo mas frecuente para prevenir el envejecimiento prematuro de la FLASH)
if ((segundos-segundosArduino)>=(3600*3)) { //Si ha pasado tres horas
      Serial.println("Guardamos horas Arduino y resto de datos en EEPROM");
      Mdatos[hrsArduino]=Mdatos[hrsArduino]+3; //hrs Arduino
      segundosArduino=segundos; //Actualizamos
      //Comprobamos si el contador de activado de válvula de desvío enfriamiento ha llegado a cero para activarla 5 segundos
      //Evitamos posibles agarrotamientos por falta de uso.
      activarValvEnfria++;
      if (activarValvEnfria>=horasValvEnfria) {
        activarValvEnfria=0;
        digitalWrite(valvenfriaPIN,HIGH);
        delay(5000);
        digitalWrite(valvenfriaPIN,LOW);
      }
     //Salvamos los datos cambiados
     for(int i=0; i<6 acemos="" activaci="" al="" comprobando="" datos="" desde="" direccioninicial="" eeprom.writelong="" el="" hacemos="" i="" if="" la="" led="" ltima="" n="" parpadear="" segundos-timeled="" serial.println="" tiempo="">2) {
      digitalWrite(ledPIN,HIGH); //enciende LED indicando funcioanmiento
      timeLED=segundos;
  }
  else {
     digitalWrite(ledPIN,LOW); //apaga led
     }

if (error>0) { //Si hay algún problema, hacemos sonar la alarma intermitentemente
  for(int i=0; i=segundos) { //Tenemos en cuenta si se ha desbordado segundos
   segundosInicioMotor=segundos; 
   segundosArduino=segundos;
   segundosValvula=segundos;
   segundosRefresca=0;
   millisAnterior=millis();
    } 


//código para depuración
//    Serial.print(F("Valor kwh"));
//    Serial.println(kwhGrado);
//    kwhAhorro=(Mtempsens[deposito]-Mtempsens[retorno])*kwhGrado; //para depurar
//    Serial.print(F("Ahorro"));
//    Serial.println(kwhAhorro);

//THE END
}


//RUTINAS
//Code from http://donalmorrissey.blogspot.com.es/2010/04/sleeping-arduino-part-5-wake-up-via.html
/***************************************************
 *  Name:        ISR(WDT_vect)
 *
 *  Returns:     Nothing.
 *
 *  Parameters:  None.
 *
 *  Description: Watchdog Interrupt Service. This
 *               is executed when watchdog timed out.
 *
 ***************************************************/
ISR(WDT_vect)
{
 //Aquí el código que queremos se ejecute cuando el watchdog "despierta" al procesador

}



/***************************************************
 *  Name:        enterSleep
 *
 *  Returns:     Nothing.
 *
 *  Parameters:  None.
 *
 *  Description: Enters the arduino into sleep mode.
 *
 ***************************************************/
void enterSleep(void)
{
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);   /* EDIT: could also use SLEEP_MODE_PWR_SAVE for less power consumption. */
  sleep_enable();
  
  /* Now enter sleep mode. */
  sleep_mode();
  
  /* The program will continue from here after the WDT timeout*/
  sleep_disable(); /* First thing to do is disable sleep. */
  
  /* Re-enable the peripherals. */
  power_all_enable();
}

Isolating better tank

And finally, I improved isolation tank 150 lts with an old blanket and remains of an insulating sheet with aluminum layer (here recycles all) to protect it from the sun 's UV. This is essential if the deposit is in outside , it means lower losses, which in winter can be very high. to "hold" blankets have used pieces of old bike tire pressure tucked against the wall; to be elastic, it remains in place.

At the bottom I have also placed, but leaving easy access for maintenance of the deposit.

And finally I have secured with duct tape:

Maintenance of the expansion vessel

Every three years there to check the expansion vessel as it loses any tire pressure and stops properly perform its function of maintaining the pressure to 1.5 bar.

Below is a valve and vacuum we must fill air at a pressure of between 0.5 and 1 bar (takes more pressure to get water, so we must find a way that half full of water has 1.5 bar ). I spent a bit and did not come to get water, so it Regulate connected and letting out some pressure until it reached 10 kg approx (is 24 liters) and maintained between 1.5 and 2 bars .

The glass of my installation whole bottom was oxidized to splashed rain over the years, so I sanded with brushes sheets and drill and you've applied paint "forging" anti-oxide(carrying metal particles that severely limit the passage moisture), her anti - rust no need fora previous hand, it is very durable .

More info: Practical Guide to installing a solar thermal system Technical Manual installation Solar thermal energy