arduinoi + Xively = blocco dopo pochi gg di funzionamento

Ciao a tutti,
sono nuovamente qui a cercare aiuto in quanto ho questo sketch che ho scritto per due motivi:

  • accensione e spegnimento della caldaia in relazione alla temperatura dell'acqua contenuta nella cisterna dell'impianto termosolare
  • monitoraggio su xively dell'impianto termosolare e di quello fotovoltaico

Problema:

  • ogni 3/4 gg arduino si blocca e non invia più i dati a xively. Per risolvere il problema devo spegnere sia Arduino che lo switck della rete su cui è collegato.

Ho impostato un ritardo all'avvio dello scketch in modo tale che se manca la corrente in casa, arduino "parta" dopo che il router TIM si è avviato altrimenti arduino rimane in blocco.

Qualcuno riesce ad aiutarmi per far si che arduino non di blocchi così spesso?

Vi ringrazio.

Parte 1:

/*************************************************************************************************************
*
* Title    : 
* Version    : v14
* Last updated            : 04.08.15
* Target    : Arduino UNO
* Web                       : http://www.gaffer.it/Arduino.html
* Installato il             : 08 SETTEMBRE 2015
* NOTE                      : ACCENSIONE RITARDATA DI 90 SEC AL VOID SETUP
**************************************************************************************************************/


//  INIZIO 
#include <SPI.h>
#include <Ethernet.h>
#include <HttpClient.h>
#include <Xively.h>
#include "EmonLib.h"  // Include Emon Library


// MAC address for your Ethernet shield
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// Your Xively key to let you upload data
char xivelyKey[] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";


/*
D1= ING Controlo Stato caldaia da D6
D2= OUT sempre hight per visualizzazione stato resistenza su xively
D3= ING DHT11
D6= OUT uscita in parallelo a D8 per visualizzazione stato caldaia su xively
D7= OUT relay ventola
D8= OUT relay caldaia
D9= ING Controllo Stato resistenza 2Kw interna al bollitore
*/


// Analog pin which we're monitoring (0 and 1 are used by the Ethernet shield)

// A0 Libero per Ethernet shield
// A1 Libero per Ethernet shield
int sensorPin_A2 = 2; //H2O_IN
float mediaA2;        // media valori di A2
//A3 Amperometro Produzione Fotovoltaico FV
//A4 Amperometro Consumi in Casa
int sensorPin_A5 = 5; //H20_OUT
float mediaA5;        // media valori di A5
int sensorPin_D1 = digitalRead(1); //STATO CALDAIA
int sensorPin_D3 = digitalRead(3); //DHT11
int sensorPin_D9 = digitalRead(9); //STATO RESISTENZA


const float AnaRef = 5.0;            // valore tensione pin di riferimento tensione AREF(5V)
const unsigned int Risoluzione = 1024;    // risoluzione (10 bit) 
const float RangeMin = 2.0; // temperatura minima °C sensore LM35DZ (alim. 5V, out con res. 2k in serie)
const float RangeMax = 100.0;  // temperatura massima °C sensore LM35DZ (alim. 5V, out con res. 2k in serie)
const float Incremento = 0.01;  // incremento (10 mV/°C)
float Volt = 0;       // valore sensori analogici in volt
const float Isteresi = 1.0; // isteresi (1 °C)
float TA = 0.0;   // TA = temperatura aria
float TAM = 2.0;  // soglia inferiore temperatura aria (min 2 °C = RangeMin) TAM=TempAriaMin
float TAMAX = 30.0; // soglia superiore temperatura aria (max 100 °C = RangeMax) TAMAX=TempAriaMax
float ToutW = 0.0;   // temperatura acqua "TempAcquaOUTtermosolare" = ToutW
float TWMIN = 2.0;   // soglia inferiore temperatura acqua (min 2 °C) TWMIN=TempAcquaMin
float TWMAX = 43.0;   // soglia superiore temperatura acqua (max 100 °C) TWMAX=TempAcquaMax
float TinW = 0.0; // temperatura acqua in ingresso al termosolare "TempAcquaINGtermosolare" = TinW
EnergyMonitor emon1;  // Create an instance CORRENTE GENERATA DAL FOTOVOLTAICO
float media_emon1;
EnergyMonitor emon2;  // Create an instance CORRENTE CONSUMATA IN CASA
float media_emon2;
extern unsigned long timer0_millis;
float ConteggioMillis;

// Define the strings for our datastream IDs
char sensorId[] = "2-Temperatura_esterna";
char sensorId1[] = "3-Umidita_esterna";
char sensorId2[] = "6-H2O_Out";
char sensorId3[] = "5-H2O_In";
char sensorId4[] = "4-Ambiente";
char sensorId5[] = "0-Energia_Produzione";
char sensorId6[] = "1-Energia_Consumo";
char sensorId7[] = "7-Caldaia";
char sensorId8[] = "8-R2KW";

XivelyDatastream datastreams[] = {
    XivelyDatastream(sensorId, strlen(sensorId), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId1, strlen(sensorId1), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId2, strlen(sensorId2), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId3, strlen(sensorId3), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId4, strlen(sensorId4), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId5, strlen(sensorId5), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId6, strlen(sensorId6), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId7, strlen(sensorId7), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId8, strlen(sensorId8), DATASTREAM_FLOAT),
    //XivelyDatastream(sensorId10, strlen(sensorId10), DATASTREAM_FLOAT),

};
// Finally, wrap the datastreams into a feed
XivelyFeed feed(xxxxxxxxx, datastreams, 9 /* number of datastreams */);

EthernetClient client;
XivelyClient xivelyclient(client);

/////////////////////////////////FINE INIZIALIZZAZIONE XIVELY 
// 
// FILE:  dht11_test1.pde
// PURPOSE: DHT11 library test sketch for Arduino
// DHT11 connesso a pin DIGITALE 3
//

//Celsius to Fahrenheit conversion
double Fahrenheit(double celsius)
{
 return 1.8 * celsius + 32;
}

//Celsius to Kelvin conversion
double Kelvin(double celsius)
{
 return celsius + 273.15;
}

// dewPoint function NOAA
// reference: http://wahiduddin.net/calc/density_algorithms.htm 
double dewPoint(double celsius, double humidity)
{
 double C= 373.15/(273.15 + celsius);
 double SUM = -7.90298 * (C-1);
 SUM += 5.02808 * log10(C);
 SUM += -1.3816e-7 * (pow(10, (11.344*(1-1/C)))-1) ;
 SUM += 8.1328e-3 * (pow(10,(-3.49149*(C-1)))-1) ;
 SUM += log10(1013.246);
 double VP = pow(10, SUM-3) * humidity;
 double T = log(VP/0.61078);   // temp var
 return (241.88 * T) / (17.558-T);
}

// delta max = 0.6544 wrt dewPoint()
// 5x faster than dewPoint()
// reference: http://en.wikipedia.org/wiki/Dew_point
double dewPointFast(double celsius, double humidity)
{
 double a = 17.271;
 double b = 237.7;
 double temp = (a * celsius) / (b + celsius) + log(humidity/100);
 double Td = (b * temp) / (a - temp);
 return Td;
}

#include <dht11.h>
dht11 DHT11;
#define DHT11PIN 3   // PIN DIGITALE 3


void setup() ////////  SETUP   SETUP   SETUP   SETUP   SETUP   SETUP   SETUP   SETUP  
{
  delay (90000);    //RITARDO ACCENSIONE ARDUINO PER PERMETTERE AL MODEM TIM DI ALLINEARSI
  Serial.begin(9600);
  Serial.println(F("DHT11 TEST PROGRAM "));
  Serial.print(F("LIBRARY VERSION: "));
  Serial.println(F(DHT11LIB_VERSION));
  Serial.println();
  Serial.println("Starting single datastream upload to Xively...");
  Serial.println();

  while (Ethernet.begin(mac) != 1)
  {
    Serial.println("Error getting IP address via DHCP, trying again...");
    delay(15000);
  }
  
  /////////////////////////////////////////////////////////
  ConteggioMillis=1;
  analogReference(DEFAULT);        // DEFAULT (5V), INTERNAL (1,1V), EXTERNAL (0÷5V)
  //////////////////////////////////////////////////////////

  pinMode(A2, INPUT);    // sensore A2 di temp. acqua ING termosolare (TinW)
  pinMode(A3, INPUT);    // TA Fotovoltaico (Produzione_Energia)
  pinMode(A4, INPUT);    // TA Casa (Consumo_Energia)
  pinMode(A5, INPUT);    // sensore A1 di temp. acqua OUT termosolare (ToutW)
  
  pinMode(1, INPUT);     //*D1 ingresso controllo stato caldaia da D6
  pinMode(2, OUTPUT);    // D2 uscita per relè in parallelo alla resistenza 2Kw installata sul bollitore 
  pinMode(3, INPUT);     //*D3 ingresso controllo stato ventola da D5?????????????
  pinMode(4, OUTPUT);    // TENTATIVO DI NON FAR BLOCCARE LA SCHEDA ETHERNET http://forum.arduino.cc//index.php?topic=186039.15
  pinMode(6, OUTPUT);    //*USCITA IN PARALLELO AL RELE ACQUA PER VISUALIZZAZIONE WEB STATO CALDAIA  
  pinMode(7, OUTPUT);     // relay ventola ON/OFF
  pinMode(8, OUTPUT);     // relay caldaia ON/OFF
  pinMode(9, INPUT);      // D9 ingresso per relè in parallelo alla resistenza da 2Kw installata sul bollitore
  pinMode(10, OUTPUT);    // TENTATIVO DI NON FAR BLOCCARE LA SCHEDA ETHERNET http://forum.arduino.cc//index.php?topic=186039.15

 //////////////// AMPEROMETRI
   emon1.current(3, 500);  // Current: A3 -CORRENTE GENERATA DAL FOTOVOLTAICO-  input pin, calibration (118 valore di calibrazione da gtrovare manualmente)
   emon2.current(4, 500);  // Current: A4 -CORRENTE CONSUMATA IN CASA-  input pin, calibration (118 valore di calibrazione da gtrovare manualmente)
///////////////////////////
  
}

Parte 2:

void loop() //////// LOOP  LOOP   LOOP  LOOP  LOOP  LOOP  LOOP  LOOP  LOOP  LOOP  LOOP  LOOP 
{
  digitalWrite(2, HIGH);   // attivazione uscita D2 sempre high per controllo stato resistenza  
  

  mediaA2=0;        // media valori di A2
  mediaA5=0;        // media valori di A5
  media_emon1=0;    // media valori di emon1 A3
  media_emon2=0;    // media valori di emon2 A4

Serial.println(F("\n"));

  int chk = DHT11.read(DHT11PIN);

  Serial.print(F("Read sensor: "));
  switch (chk)
       {
        case 0: Serial.println("OK");
     
 
      // DHT11 TEMPERATURA
      Serial.print(F("Temperature Esterna Casa(oC): "));
      Serial.println((float)DHT11.temperature, 2);
      datastreams[0].setFloat(DHT11.temperature);
      //Serial.print(F("Read sensor value "));
      //Serial.println(datastreams[0].getFloat());
      
     /* //DHT11 UMIDITA'   *******NON PRECISO********
      Serial.print(F("Humidity (%): "));
      Serial.println((float)DHT11.humidity, 2);
      datastreams[1].setFloat(DHT11.humidity);
      Serial.print(F("Read sensor value "));
      Serial.println(datastreams[1].getFloat());
  */
      //Serial.println(F("Uploading it to Xively"));
      /*int ret = xivelyclient.put(feed, xivelyKey);
      Serial.print(F("xivelyclient.put returned "));
      Serial.println(ret);

      Serial.println();
  
      delay(2000); 
      */
      
  break;
  
    case -1: Serial.println("Checksum error"); break;
    case -2: Serial.println("Time out error"); break;
    default: Serial.println("Unknown error"); break;
     }
    Serial.println(F("xivelyclient.put returned "));


  delay(10);

 
 /*       ********DISCONNESSO*******
 // MONITORAGGIO A0 sensore di temperatura aria (TA)   
 // sensorId4[] = "4-Ambiente";
  int sensorValue_A0 = ((5.0 * analogRead(sensorPin_A0) * 100.0) / 1024)+0;  // sensore di temperatura aria (TA)
  for (int i=0; i<100; i++){
     mediaA0+=(5.0 * analogRead(sensorPin_A0) * 100.0) / 1024;
     }
 mediaA0=mediaA0/100;
  datastreams[4].setFloat(mediaA0); 
  delay(10);
  Serial.print("A0= ");
  Serial.print(datastreams[4].getFloat());
  
   if (mediaA0 >= (TAMAX + Isteresi)) {
    digitalWrite(7, HIGH);                                 // relay ventola ON
    Serial.println(F("   Aria >30°C - Ventola ON"));
  }
  else if (mediaA0 < (TAMAX - Isteresi)) {
    digitalWrite(7, LOW);                                   // relay ventola OFF
    Serial.println(F("   Aria <30°C - Ventola OFF")); 
  }
  */
  
 // MONITORAGGIO sensore A5 di temp. acqua OUT termosolare(ToutW)
 // sensorId2[] = "6-H2O_Out";
  int sensorValue_A5 = ((5.0 * analogRead(sensorPin_A5) * 100.0) / 1024)+4;  // sensore di temp. acqua OUT termosolare(ToutW)
  for (int i=0; i<100; i++){
     mediaA5+=(5.0 * analogRead(sensorPin_A5) * 100.0) / 1024;
     }
 mediaA5=((mediaA5/100)+1);
  datastreams[2].setFloat(mediaA5);
  delay(10);
  Serial.print("H2O_Out= ");
  Serial.println(datastreams[2].getFloat());
  
  if ((sensorPin_A5 > (TWMAX + Isteresi)) && ConteggioMillis==1) (timer0_millis = 0, ConteggioMillis = 0 );
  if ( sensorPin_A5 > (TWMAX + Isteresi) && (millis()>30000)) {
  delayMicroseconds(120);   // 120 µs (min time reading = 100 µs x channel) 

    digitalWrite(8, LOW);   // relay caldaia OFF
    digitalWrite(6, LOW);   //*USCITA IN PARALLELO AL SEGNALE CALDAIA PER TELECONTROLLO
    Serial.println(F("   Temp. Acqua Bollitore >43°C - Caldaia OFF"));
   }
     else if (mediaA5 < (TWMAX - Isteresi)) {
     digitalWrite(8, HIGH);  // relay caldaia ON
     digitalWrite(6, HIGH);  //*USCITA IN PARALLELO AL SEGNALE CALDAIA PER TELECONTROLLO
     ConteggioMillis=1;
     Serial.println(F("   Temp. Acqua Bollitore <43°C - Caldaia ON")); 
  }
  
  
  // MONITORAGGIO sensore A2 di temperatura acqua ingresso termosolare (TinW)
  // sensorId3[] = "5-H2O_In";
  int sensorValue_A2 = ((5.0 * analogRead(sensorPin_A2) * 100.0) / 1024)+0;  // sensore di temperatura acqua ingresso termosolare (TinW)
  for (int i=0; i<100; i++){
     mediaA2+=(5.0 * analogRead(sensorPin_A2) * 100.0) / 1024;
     }
 mediaA2=((mediaA2/100)+1);
  datastreams[3].setFloat(mediaA2);
  delay(10);
  Serial.print("H20_IN= ");
  Serial.println(datastreams[3].getFloat());
  
   // **************INIZIO MONITORAGGIO FOTOVOLTAICO***************
  
  // sensorId5[] = "0-Energia_Produzione";
   double Produzione_Energia = (emon1.calcIrms(1480)-0);  // Calculate Irms only
   for (int i=0; i<100; i++){
     media_emon1+=Produzione_Energia;  // Amperer misurati da TA connesso ad A3
     }
 media_emon1=media_emon1/100;
 media_emon1=(media_emon1*220);
 
 if (media_emon1<140)
 {
   media_emon1=0;          // da valore 0 in cui la misura sia monima, ciò per evitare false misure soprattutto in assenza di sole
   }
   
   datastreams[5].setFloat(media_emon1);
   delay(10);
   
   Serial.print("FV= ");
   Serial.println(datastreams[5].getFloat());
  
  
  // sensorId6[] = "1-Energia_Consumo";
    double Consumo_Energia = emon2.calcIrms(1480);  // Calculate Irms only
    for (int i=0; i<100; i++){
     media_emon2+=Consumo_Energia;    // Amperer misurati da TA connesso ad A4
     }
     media_emon2=media_emon2/100;
     media_emon2=(media_emon2*220);
     datastreams[6].setFloat(media_emon2);
     delay(10);
    
    Serial.print("Casa= ");
    Serial.println(datastreams[6].getFloat());
  
//   ************FINE MONITORAGGIO FOTOVOLTAICO***************
    
    

// sensorId7[] = "7-Caldaia";   
  int sensorValue_D1 = digitalRead(1);
  datastreams[7].setFloat(sensorValue_D1);
  Serial.print("Caldaia= ");
  Serial.println(datastreams[7].getFloat());
  

// sensorId8[] = "8-R2KW"; 
  int sensorValue_D9 = digitalRead(9);
  datastreams[8].setFloat(sensorValue_D9);
  Serial.print("Resistenza= ");
  Serial.println(datastreams[8].getFloat());
  
  Serial.println("Uploading it to Xively");
  int ret = xivelyclient.put(feed, xivelyKey);
  Serial.print("xivelyclient.put returned: ");
  Serial.println(ret);

  Serial.println();
  delay(1000);
  /////////////////////////////////////////////
  
}

Ci sono due motivi per il blocco dopo alcuni giorni:
1 - software, esaurimento memoria RAM;
2 - hardware, disturbo elettrico.

Ho esaminato lo sketch sul tuo sito (ho apprezzato i ringraziamenti) e mi sembra che non hai usato elementi che possono provocare la saturazione progressiva della memoria RAM, in particolare l'oggetto String.

Poiché per i vari Serial.print di costanti testo non hai usato la funzione F(), prova ad inserirla e vedere se il numero di giorni prima del blocco aumenta o meno: è la controprova che il software funziona.

Quindi rimane il disturbo elettrico: se non ho capito male, piloti con relè la resistenza elettrica del boiler, una ventola e la caldaia, tutti a 230Vac.

Se non hai messo qualcosa per limitare le extratensioni dei carichi induttivi (sospetto la ventola), questi potrebbero generare disturbi.

Consiglio dei diodi VTS in parallelo ai carichi.

Ciao ciberhs,
oggi mi metto all'opera per fare le modifiche che mi hai consigliato.
A proposito dei diodi VTS, dei quali non sapevo neanche l'esistenza, li devo montare in parallelo alla bobine dei relè o in parallelo ai carichi, che sono a 220v?
Ci sono vari modelli di diodi VTS? Cosa dovrei acquistare?

Ti ringrazio.

Puoi usare il TVS VISHAY mod. BZW04-342B bidirezionale da 342V di tensione di stand off che interviene a partire da 380V.

Tieni presente che la tensione di rete 230Vac (secondo la normativa europea che ha portato la tensione di rete da 220V a 230V) ha dei picchi di circa 325Vp.

Deve essere montato in parallelo al carico.

Ottimo, Grazie.

Lo sketch l'ho gia modificato come da te consigliato.

Appena trovo i diodi li installo e ti dico come va.

Grazie ancora.

Ciao Cyberhs,
già solo aggiungendo F() noto un bel miglioramento, ad oggi non si è ancora bloccato.

Ho difficoltà a trovare i diodi ma, mal che vada, li ordino da rs-components.

Grazie

Allora è probabile che si bloccherà più avanti: il problema è software.

Ho controllato meglio e tu usi la String in una routine: meglio sostituirla con un vettore char.

Porta pazienza ma non ho capito ne quello che dovrei fare ne perchè...

:frowning:

Prima di addentrami in una spiegazione piuttosto complicata, guarda se lo sketch entra ancora in blocco.

ok

Grazie

Ciao Cyberhs,
come avevi previsto, Arduino se è bloccato…
:frowning:

Lo sketch pubblicato sul tuo sito sembra diverso da quello che hai postato.

Fammi vedere quello che effettivamente usi.

Lo sketch che hai visto sul sito è vecchio, in funzione c'è quello che hai visto all'inizio di questa discussione.
Ho dovuto dividerlo in due blocchi perchè superava i caratreri consentiti...

Sì, ma hai apportato delle modifiche (la funzione F).

Ti dispiace mostrarmele?

Ecco ciò che ho fatto:

/*************************************************************************************************************
*
* Title			    : 
* Version		    : v16
* Last updated	            : 14.09.15
* Target		    : Arduino UNO
* IDE                       : 1.0.6
* Author                    : Elvis Pasqual
* Web                       : http://www.gaffer.it/Arduino.html
* Installato il             : 14 SETTEMBRE 2015
* NOTE                      : ACCENSIONE RITARDATA DI 300 SEC AL VOID SETUP
**************************************************************************************************************/


//  INIZIO 
#include <SPI.h>
#include <Ethernet.h>
#include <HttpClient.h>
#include <Xively.h>
#include "EmonLib.h"  // Include Emon Library


// MAC address for your Ethernet shield
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// Your Xively key to let you upload data
char xivelyKey[] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";


/*
D1= ING Controlo Stato caldaia da D6
D2= OUT sempre hight per visualizzazione stato resistenza su xively
D3= ING DHT11
D6= OUT uscita in parallelo a D8 per visualizzazione stato caldaia su xively
D7= OUT relay ventola
D8= OUT relay caldaia
D9= ING Controllo Stato resistenza 2Kw interna al bollitore
*/


// Analog pin which we're monitoring (0 and 1 are used by the Ethernet shield)

// A0 Libero per Ethernet shield
// A1 Libero per Ethernet shield
int sensorPin_A2 = 2; //H2O_IN
float mediaA2;        // media valori di A2
//A3 Amperometro Produzione Fotovoltaico FV
//A4 Amperometro Consumi in Casa
int sensorPin_A5 = 5; //H20_OUT
float mediaA5;        // media valori di A5
int sensorPin_D1 = digitalRead(1); //STATO CALDAIA
int sensorPin_D3 = digitalRead(3); //DHT11
int sensorPin_D9 = digitalRead(9); //STATO RESISTENZA


const float AnaRef = 5.0;            // valore tensione pin di riferimento tensione AREF(5V)
const unsigned int Risoluzione = 1024;    // risoluzione (10 bit) 
const float RangeMin = 2.0; // temperatura minima °C sensore LM35DZ (alim. 5V, out con res. 2k in serie)
const float RangeMax = 100.0;  // temperatura massima °C sensore LM35DZ (alim. 5V, out con res. 2k in serie)
const float Incremento = 0.01;  // incremento (10 mV/°C)
float Volt = 0;       // valore sensori analogici in volt
const float Isteresi = 1.0; // isteresi (1 °C)
float TA = 0.0;   // TA = temperatura aria
float TAM = 2.0;  // soglia inferiore temperatura aria (min 2 °C = RangeMin) TAM=TempAriaMin
float TAMAX = 30.0; // soglia superiore temperatura aria (max 100 °C = RangeMax) TAMAX=TempAriaMax
float ToutW = 0.0;   // temperatura acqua "TempAcquaOUTtermosolare" = ToutW
float TWMIN = 2.0;   // soglia inferiore temperatura acqua (min 2 °C) TWMIN=TempAcquaMin
float TWMAX = 43.0;   // soglia superiore temperatura acqua (max 100 °C) TWMAX=TempAcquaMax
float TinW = 0.0; // temperatura acqua in ingresso al termosolare "TempAcquaINGtermosolare" = TinW
EnergyMonitor emon1;  // Create an instance CORRENTE GENERATA DAL FOTOVOLTAICO
float media_emon1;
EnergyMonitor emon2;  // Create an instance CORRENTE CONSUMATA IN CASA
float media_emon2;
extern unsigned long timer0_millis;
float ConteggioMillis;

// Define the strings for our datastream IDs
char sensorId[] = "2-Temperatura_esterna";
char sensorId1[] = "3-Umidita_esterna";
char sensorId2[] = "6-H2O_Out";
char sensorId3[] = "5-H2O_In";
char sensorId4[] = "4-Ambiente";
char sensorId5[] = "0-Energia_Produzione";
char sensorId6[] = "1-Energia_Consumo";
char sensorId7[] = "7-Caldaia";
char sensorId8[] = "8-R2KW";

XivelyDatastream datastreams[] = {
    XivelyDatastream(sensorId, strlen(sensorId), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId1, strlen(sensorId1), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId2, strlen(sensorId2), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId3, strlen(sensorId3), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId4, strlen(sensorId4), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId5, strlen(sensorId5), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId6, strlen(sensorId6), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId7, strlen(sensorId7), DATASTREAM_FLOAT),
    XivelyDatastream(sensorId8, strlen(sensorId8), DATASTREAM_FLOAT),
    //XivelyDatastream(sensorId10, strlen(sensorId10), DATASTREAM_FLOAT),

};
// Finally, wrap the datastreams into a feed
XivelyFeed feed(xxxxxxxxxx, datastreams, 9 /* number of datastreams */);

EthernetClient client;
XivelyClient xivelyclient(client);

/////////////////////////////////FINE INIZIALIZZAZIONE XIVELY 
// 
// FILE:  dht11_test1.pde
// PURPOSE: DHT11 library test sketch for Arduino
// DHT11 connesso a pin DIGITALE 3
//

//Celsius to Fahrenheit conversion
double Fahrenheit(double celsius)
{
	return 1.8 * celsius + 32;
}

//Celsius to Kelvin conversion
double Kelvin(double celsius)
{
	return celsius + 273.15;
}

// dewPoint function NOAA
// reference: http://wahiduddin.net/calc/density_algorithms.htm 
double dewPoint(double celsius, double humidity)
{
	double C= 373.15/(273.15 + celsius);
	double SUM = -7.90298 * (C-1);
	SUM += 5.02808 * log10(C);
	SUM += -1.3816e-7 * (pow(10, (11.344*(1-1/C)))-1) ;
	SUM += 8.1328e-3 * (pow(10,(-3.49149*(C-1)))-1) ;
	SUM += log10(1013.246);
	double VP = pow(10, SUM-3) * humidity;
	double T = log(VP/0.61078);   // temp var
	return (241.88 * T) / (17.558-T);
}

// delta max = 0.6544 wrt dewPoint()
// 5x faster than dewPoint()
// reference: http://en.wikipedia.org/wiki/Dew_point
double dewPointFast(double celsius, double humidity)
{
	double a = 17.271;
	double b = 237.7;
	double temp = (a * celsius) / (b + celsius) + log(humidity/100);
	double Td = (b * temp) / (a - temp);
	return Td;
}

#include <dht11.h>
dht11 DHT11;
#define DHT11PIN 3   // PIN DIGITALE 3


void setup() ////////  SETUP   SETUP   SETUP   SETUP   SETUP   SETUP   SETUP   SETUP  
{
  delay (300000);    //RITARDO ACCENSIONE ARDUINO PER PERMETTERE AL MODEM TIM DI ALLINEARSI
  Serial.begin(9600);
  Serial.println(F("DHT11 TEST PROGRAM "));
  Serial.print(F("LIBRARY VERSION: "));
  Serial.println(F(DHT11LIB_VERSION));
  Serial.println();
  Serial.println(F("Starting single datastream upload to Xively..."));
  Serial.println();

  while (Ethernet.begin(mac) != 1)
  {
    Serial.println(F("Error getting IP address via DHCP, trying again..."));
    delay(15000);
  }
  
  /////////////////////////////////////////////////////////
  ConteggioMillis=1;
  analogReference(DEFAULT);        // DEFAULT (5V), INTERNAL (1,1V), EXTERNAL (0÷5V)
  //////////////////////////////////////////////////////////

  pinMode(A2, INPUT);    // sensore A2 di temp. acqua ING termosolare (TinW)
  pinMode(A3, INPUT);    // TA Fotovoltaico (Produzione_Energia)
  pinMode(A4, INPUT);    // TA Casa (Consumo_Energia)
  pinMode(A5, INPUT);    // sensore A1 di temp. acqua OUT termosolare (ToutW)
  
  pinMode(1, INPUT);     //*D1 ingresso controllo stato caldaia da D6
  pinMode(2, OUTPUT);    // D2 uscita per relè in parallelo alla resistenza 2Kw installata sul bollitore 
  pinMode(3, INPUT);     //*D3 ingresso controllo stato ventola da D5?????????????
  pinMode(4, OUTPUT);    // TENTATIVO DI NON FAR BLOCCARE LA SCHEDA ETHERNET http://forum.arduino.cc//index.php?topic=186039.15
  pinMode(6, OUTPUT);    //*USCITA IN PARALLELO AL RELE ACQUA PER VISUALIZZAZIONE WEB STATO CALDAIA  
  pinMode(7, OUTPUT);     // relay ventola ON/OFF
  pinMode(8, OUTPUT);     // relay caldaia ON/OFF
  pinMode(9, INPUT);      // D9 ingresso per relè in parallelo alla resistenza da 2Kw installata sul bollitore
  pinMode(10, OUTPUT);    // TENTATIVO DI NON FAR BLOCCARE LA SCHEDA ETHERNET http://forum.arduino.cc//index.php?topic=186039.15

 //////////////// AMPEROMETRI
   emon1.current(3, 500);  // Current: A3 -CORRENTE GENERATA DAL FOTOVOLTAICO-  input pin, calibration (118 valore di calibrazione da gtrovare manualmente)
   emon2.current(4, 500);  // Current: A4 -CORRENTE CONSUMATA IN CASA-  input pin, calibration (118 valore di calibrazione da gtrovare manualmente)
///////////////////////////
  
}
void loop() //////// LOOP  LOOP   LOOP  LOOP  LOOP  LOOP  LOOP  LOOP  LOOP  LOOP  LOOP  LOOP 
{
  digitalWrite(2, HIGH);   // attivazione uscita D2 sempre high per controllo stato resistenza  
  

  mediaA2=0;        // media valori di A2
  mediaA5=0;        // media valori di A5
  media_emon1=0;    // media valori di emon1 A3
  media_emon2=0;    // media valori di emon2 A4

Serial.println(F("\n"));

  int chk = DHT11.read(DHT11PIN);

  Serial.print(F("Read sensor: "));
  switch (chk)
       {
        case 0: Serial.println("OK");
     
 
      // DHT11 TEMPERATURA
      Serial.print(F("Temperature Esterna Casa(oC): "));
      Serial.println((float)DHT11.temperature, 2);
      datastreams[0].setFloat(DHT11.temperature);
      //Serial.print(F("Read sensor value "));
      //Serial.println(datastreams[0].getFloat());
      
     /* //DHT11 UMIDITA'   *******NON PRECISO********
      Serial.print(F("Humidity (%): "));
      Serial.println((float)DHT11.humidity, 2);
      datastreams[1].setFloat(DHT11.humidity);
      Serial.print(F("Read sensor value "));
      Serial.println(datastreams[1].getFloat());
  */
      //Serial.println(F("Uploading it to Xively"));
      /*int ret = xivelyclient.put(feed, xivelyKey);
      Serial.print(F("xivelyclient.put returned "));
      Serial.println(ret);

      Serial.println();
  
      delay(2000); 
      */
      
  break;
  
    case -1: Serial.println(F("Checksum error")); break;
    case -2: Serial.println(F("Time out error")); break;
    default: Serial.println(F("Unknown error")); break;
     }
    Serial.println(F("xivelyclient.put returned "));


  delay(10);

 
 /*       ********DISCONNESSO*******
 // MONITORAGGIO A0 sensore di temperatura aria (TA)   
 // sensorId4[] = "4-Ambiente";
  int sensorValue_A0 = ((5.0 * analogRead(sensorPin_A0) * 100.0) / 1024)+0;  // sensore di temperatura aria (TA)
  for (int i=0; i<100; i++){
     mediaA0+=(5.0 * analogRead(sensorPin_A0) * 100.0) / 1024;
     }
 mediaA0=mediaA0/100;
  datastreams[4].setFloat(mediaA0); 
  delay(10);
  Serial.print("A0= ");
  Serial.print(datastreams[4].getFloat());
  
   if (mediaA0 >= (TAMAX + Isteresi)) {
    digitalWrite(7, HIGH);                                 // relay ventola ON
    Serial.println(F("   Aria >30°C - Ventola ON"));
  }
  else if (mediaA0 < (TAMAX - Isteresi)) {
    digitalWrite(7, LOW);                                   // relay ventola OFF
    Serial.println(F("   Aria <30°C - Ventola OFF")); 
  }
  */
  
 // MONITORAGGIO sensore A5 di temp. acqua OUT termosolare(ToutW)
 // sensorId2[] = "6-H2O_Out";
  int sensorValue_A5 = ((5.0 * analogRead(sensorPin_A5) * 100.0) / 1024)+4;  // sensore di temp. acqua OUT termosolare(ToutW)
  for (int i=0; i<100; i++){
     mediaA5+=(5.0 * analogRead(sensorPin_A5) * 100.0) / 1024;
     }
 mediaA5=((mediaA5/100)+1);
  datastreams[2].setFloat(mediaA5);
  delay(10);
  Serial.print(F("H2O_Out= "));
  Serial.println(datastreams[2].getFloat());
  
  if ((sensorPin_A5 > (TWMAX + Isteresi)) && ConteggioMillis==1) (timer0_millis = 0, ConteggioMillis = 0 );
  if ( sensorPin_A5 > (TWMAX + Isteresi) && (millis()>30000)) {
  delayMicroseconds(120);   // 120 µs (min time reading = 100 µs x channel) 

    digitalWrite(8, LOW);   // relay caldaia OFF
    digitalWrite(6, LOW);   //*USCITA IN PARALLELO AL SEGNALE CALDAIA PER TELECONTROLLO
    Serial.println(F("   Temp. Acqua Bollitore >43°C - Caldaia OFF"));
   }
     else if (mediaA5 < (TWMAX - Isteresi)) {
     digitalWrite(8, HIGH);  // relay caldaia ON
     digitalWrite(6, HIGH);  //*USCITA IN PARALLELO AL SEGNALE CALDAIA PER TELECONTROLLO
     ConteggioMillis=1;
     Serial.println(F("   Temp. Acqua Bollitore <43°C - Caldaia ON")); 
  }
  
  
  // MONITORAGGIO sensore A2 di temperatura acqua ingresso termosolare (TinW)
  // sensorId3[] = "5-H2O_In";
  int sensorValue_A2 = ((5.0 * analogRead(sensorPin_A2) * 100.0) / 1024)+0;  // sensore di temperatura acqua ingresso termosolare (TinW)
  for (int i=0; i<100; i++){
     mediaA2+=(5.0 * analogRead(sensorPin_A2) * 100.0) / 1024;
     }
 mediaA2=((mediaA2/100)+1);
  datastreams[3].setFloat(mediaA2);
  delay(10);
  Serial.print(F("H20_IN= "));
  Serial.println(datastreams[3].getFloat());
  
  
  
  // **************INIZIO MONITORAGGIO FOTOVOLTAICO***************
  
  // sensorId5[] = "0-Energia_Produzione";
   double Produzione_Energia = (emon1.calcIrms(1480)-0);  // Calculate Irms only
   for (int i=0; i<100; i++){
     media_emon1+=Produzione_Energia;  // Amperer misurati da TA connesso ad A3
     }
 media_emon1=media_emon1/100;
 media_emon1=(media_emon1*220);
 
 if (media_emon1<140)
 {
   media_emon1=0;          // da valore 0 in cui la misura sia monima, ciò per evitare false misure soprattutto in assenza di sole
   }
   
   datastreams[5].setFloat(media_emon1);
   delay(10);
   
   Serial.print(F("FV= "));
   Serial.println(datastreams[5].getFloat());
  
  
  // sensorId6[] = "1-Energia_Consumo";
    double Consumo_Energia = emon2.calcIrms(1480);  // Calculate Irms only
    for (int i=0; i<100; i++){
     media_emon2+=Consumo_Energia;    // Amperer misurati da TA connesso ad A4
     }
     media_emon2=media_emon2/100;
     media_emon2=(media_emon2*220);
     datastreams[6].setFloat(media_emon2);
     delay(10);
    
    Serial.print(F("Casa= "));
    Serial.println(datastreams[6].getFloat());
  
//   ************FINE MONITORAGGIO FOTOVOLTAICO***************
    
    

// sensorId7[] = "7-Caldaia";   
  int sensorValue_D1 = digitalRead(1);
  datastreams[7].setFloat(sensorValue_D1);
  Serial.print(F("Caldaia= "));
  Serial.println(datastreams[7].getFloat());
  

// sensorId8[] = "8-R2KW"; 
  int sensorValue_D9 = digitalRead(9);
  datastreams[8].setFloat(sensorValue_D9);
  Serial.print(F("Resistenza= "));
  Serial.println(datastreams[8].getFloat());
  
  Serial.println(F("Uploading it to Xively"));
  int ret = xivelyclient.put(feed, xivelyKey);
  Serial.print(F("xivelyclient.put returned: "));
  Serial.println(ret);

  Serial.println();
  delay(1000);
  /////////////////////////////////////////////
  
}

Ho dovuto cancellare gli F() da alcuni Serial.print tipo: “Serial.println(datastreams.getFloat());” in quanto creava un errore.

A proposito, io ho lasciato libere A0 ed A1 perchè ho trovato scritto da qualche parte che servono per la ethernet shield, è vero?
In origine avevo pensato di usarle per delle sonde di temperatura LM35...
Potrei usarle o devo lasciarle libere?
Grazie

Ci sono alcuni errori.

La misura del sensore al pin A5 è letta 100 volte: non è necessario bastano 10 volte.

Inoltre, sarebbe meglio sommare il valore ADC int ed alla fine calcolare il valore medio:
int Somma = 0;
for (int i = 0; i < 10; i ++) {
Somma += analogRead(sensorPin_A5);
}
mediaA5 = 5.0 * Somma / 10 / 1024;

L’istruzione:

if ((sensorPin_A5 > (TWMAX + Isteresi))…

non ha alcun senso.

Era meglio se sensorPin_A5 lo avessi chiamato H2O_OUTpin o qualcosa che faccia capire la sua funzione.

Insomma, devi rivedere ed ordinare il tuo sketch.