arduinoi + Xively = blocco dopo pochi gg di funzionamento

International Italiano Software
#1

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.

#2

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)
///////////////////////////
  
}
#3

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);
  /////////////////////////////////////////////
  
}
#4

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.

#5

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.

#6

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.

#7

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.

#8

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

#9

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.

#10

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

:frowning:

#11

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

#12

ok

Grazie

#13

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

#14

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

Fammi vedere quello che effettivamente usi.

#15

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

#16

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

Ti dispiace mostrarmele?

#17

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)
///////////////////////////
  
}
#18 
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.

#19

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

#20

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.