gestione pannelli solari termici e termostati

buongiorno a tutti

mi chiamo Luca e sono totalmente a digiuno in merito ad ARDUINO.

Ho deciso di buttarmi dentro ad un progetto per tentare di sfruttare al massimo i miei pannelli solari termici (non ho il fotovoltaico).

mi spiego:

ho un impianto cosi' composto

riscaldamento a pavimento
un accumulatore (boiler/puffer/serbatoio che dir si voglia) da circa 800 l
5 pannelli solari termici
una caldaia a metano
un termostato netatmo controllabile con ifttt via email

come molti, sono via tutto il giorno da casa e torno la sera con una temperatura desiderata di circa 22,5 °C

il netatmo mi fa risparmiare tantissimo in quanto accende in anticipo solo per il tempo necessario a raggiungere la temperatura desiderata esattamente all'ora del mio rientro a casa.

In questo modo ho tagliato di molto gli sprechi per accensioni troppo anticipate e contemporaneamente non rientro mai con temperature basse (ha un ottimo algoritmo per anticipare/ritardare l'accensione in base alla temperatura esterna e alla "dispersione termica della casa")

MA VENIAMO AL DUNQUE

in inverno, pur accumulando nel puffer acqua calda generata dal solare di giorno, questa termina prima che la casa sia riscaldata. Conseguentemente si accende la caldaia e si consuma gas.

ho notato che sicuramente se accendo il netatmo a distanza quando vedo una giornata di sole risparmio... (uovo di Colombo...) .. ma mi devo ricordare di farlo e a volte sono in posti dove ho meteo diverso da casa (nuvolo contro sole o viceversa)

L'idraulico ti dice di mantenere sempre la stessa temperatura tutto il giorno... ma comunque si spreca gas nelle giornate non di sole rispetto ad accendere solo per avere la temperatura desiderata alla sera

IDEA:

apparato che esegua le seguenti operazioni:

leggere la temperatura del puffer con una sonda (dovrebbe essere a filo sottile e non con il barilottino in cima in quanto nel puffer quella presente occupa quasi tutto il vano sonda)

se la temperatura supera i 55° C (valore simbolico) mandi una mail e attivi il termostato con IFTTT (ciclo di controllo ogni 20-30 minuti circa)

se la temperatura si abbassa a 47 °C (o valore di x gradi sopra quello a cui si attiverebbe la caldaia) mandi una mail e disattivi il termostato a prescindere che la temperatura definita sia stata raggiunta o no

se mando una mail all'apparato con "disattivati" non deve attivare l'algoritmo sopra riportato (salvare in una posizione della eeprom la variabile?)

se gli mando una mail con "attivati" deve attivare l'algoritmo sopra riportato (il tutto ovviamente per quando non penso di rientrare alla sera e quindi è inutile che lui mi scaldi casa facendo girare inutilmente le pompe che comunque consumano TANTA corrente)

in questo modo dovrei automatizzare al massimo lo sfruttamento del calore generato dal sole impedendo contemporaneamente l'accensione della caldaia e un'inutile spreco di gas

qualcuno potrebbe trovare obiezioni in merito al fatto di non usare sensori di temperatura in casa collegati ad arduino e/o comandare direttamente la caldaia/pompe

punto primo: il fatto è che con il netatmo mi sono trovato bene perchè dispongo il sensore di temperatura dove voglio in wireless, è facilmente gestibile con un'app da moglie e figli, e.... la pappa era pronta con poca spesa e senza passare sonde o a apparecchi autocostruiti.

punto secondo: non voglio per ovvi motivi di certificazioni di impianto, sicurezza e funzionalità disattivare o toccare l'impianto base (con questo sistema NON INVASIVO parallelizzo il controllo senza complicare la vita a moglie, figli, ecc... con apparecchi artigianali o poco gestibili e comunque disattivabili sfilando un sensoree staccando una spina)

DOMANDA FINALE

a vostro parere potrei fare il tutto con un ARDUINO ETHERNET (non mi serve il wifi, la lan è accanto al puffer)? dovrei andare su YUN?

mi è sembrato di capire che Yun (a parte il wifi) sarebbe conveniente rispetto a ARDUINO ETHERNET in quanto ha già all'interno il lettore SD, ad esempio per memorizzare i log di temperatura (comodo ma non indispensabile)

Ho cercato sonde in lungo e in largo, ho letto di tutto, ma ci ho capito poco...
Mi è sembrato che forse (a parte la dimensione della testa della sonda) questa sia la più simile a quello che dovrebbe servirmi http://www.robot-italy.com/it/ds18b20-waterproof-digital-temperature-sensor.html
In passato avevo studiato l'uso di termocoppie, ma sembra che i costi per le interfacce di quelle tipo le k siano decisamente alti (per avere un risparmio non devo spendere di hardware più di 100 - 150 euro in tutto... forse.... e potrebbero essere già troppi a detta di qualcuno)

premesso che se siete arrivati a leggere fino a qui dovrei già offrirVi una cena di ringraziamento....

sono un visionario o è fattibile?

Grazie a tutti in anticipo

Lascia stare.
Ciao Uwe

a vostro parere potrei fare il tutto con un ARDUINO ETHERNET (non mi serve il wifi, la lan è accanto al puffer)? dovrei andare su YUN?

Se vuoi spendere poco il WiFi è la soluzione più economica, un ESP8266, una sonda di temperatura come quella che hai menzionato DS18B20 , aggiungi un alimentatore e con meno di 10 Euro lo fai.
In rete trovi molti esempi di come si gestisce l'ESP8266 con l'IDE di Arduino e IFTTT

Brunello:
Se vuoi spendere poco il WiFi è la soluzione più economica, un ESP8266 ....

>willytrilly: guarda ad esempio QUESTO oggetto ... lo programmi direttamente con l'IDE di Arduino, hai tutti i pin che ti servono e spendi una miseria per ogni singolo punto.

Per saperne di più sul modulo ESP8266 ... in Megatopic c'è un completissimo thread di oltre 150 pagine dove trovi di tutto e di più.

Guglielmo

Cominciamo con.... grazie a tutti per le risposte...

a parte il "lascia stare" che non è parte della mia indole... direi grazie per avermi fatto scoprire una variante sul tema di cui sono totalmente digiuno...

A) se andrò avanti potrò postare sketch e quant'altro o é un progetto troppo banale?

B) che vi risulti, sulle sonde digitali i cavi sono allungabili nell'arco di un paio di metri o l'alimentazione ( non avrei problemi a usare tutti e tre i fili) ne patirebbe? Ho trovato che ci sono problemi su 20-50 m ma non ho trovato info su distanze minori.

Buona serata a tutti

A) nessun problema per il codice, purché, in conformità al regolamento, punto 7, sia racchiuso tra i tag CODE che, in fase di edit, ti inserisce il bottone </> ... primo a sinistra :wink:

B) "sonde digitali" è un po' generico :wink: ...
... vediamo le sigle di tutte le sonde che vuoi usare, i datasheet e ... rispondiamo :smiley:

Guglielmo

Se intendi il sensore di temperatura DS18B20, un paio di metri non danno problemi.
Comunque quel sensore ha una testa di 6mm, controlla prima se ci entra nella sede

Al moderatore:

grazie... avevo più paura di postare un progetto inutile veramente....

La sonda digitale a cui mi riferivo era quella del link del primo post... ma mi hanno battuto sul tempo e mi hanno anche dato una dritta sulle dimensioni che adesso dovrò verificare nel puffer.. grazie BRUNELLO

... sto cercando info sui prodotti... caratteristiche tecniche e poi procederò all'ordine

Mi sto orientando su una scheda leonardo, non per non accettare il consiglio datomi, ma per poter eventualmente imparare qualcosina di più su arduino. Ho visto che ha la sd e la ethernet integrata. In questo modo non comincio a incasinarmi con shield supplementari... e dovrei riuscire anche ad ottenere un log delle misurazioni...

Notte a tutti

Mi sto orientando su una scheda leonardo, ....................... Ho visto che ha la sd e la ethernet integrata

La Leonardo ha la Ethernet integrata ??????

Brunello:
La Leonardo ha la Ethernet integrata ??????

NO, di sicuro NO :smiley: :smiley: :smiley:

Guglielmo

Ops, scusate, sono stato poco preciso

"Leonardo Ethernet senza Poe"

Non mi ero accorto che esiste la versione base e davo per scontato che fosse eth con sd

Ok, parliamo di un prodotto fatto solo da Arduino.org e questo è il forum di Arduino.cc ... ::slight_smile:

Non mi sembra che Arduino.cc l'abbia mai prodotta quindi ... noi qui possiamo dare un supporto limitato dato che non la conosciamo ...

Guglielmo

Abbiate pazienza per l'errore...... Non è che mi sono fatto una tampa del tipo cena a base di bistecche al sangue per la fidanzata vegana?

ri-salve a tutti e BUON NATALE

ho lavorato e prodotto...

posto il risultato sperando sia utile

... e se qualcuno fosse in grado di fornire ulteriori consigli saranno assolutamente ben accetti

l'idea sarebbe di convertire il tutto in pyton per ovviare ai problemi di memoria di arduino

hardware:

  • arduino YUN
  • sonda dallas ds18b20 "immergibile" con cavo integrato
  • resistenza da 10kOhm in parallelo alla sonda (su internet ho trovato che per yun è consigliata al posto di altri valori)
  • termostato netatmo comandato tramite IFTTT

requisiti di funzionamento del sistema:

  • mandare una mail "accendi" quando la temperatura supera il valore tmax
  • mandare una mail "spegni" quando la temperatura scende sotto il valore tmin (tmin deve avere un gap da tmax per evitare troppi accendi-spegni consecutivi)
  • log delle temperature rilevate e stato del comando di accensione
  • log delle sole accensioni e spegnimenti
  • paginetta web con ultima temperatura, data e stato accensione
  • tempo tra un intervallo di lettura e l'altro di 5 minuti
  • parametri tmax, tmin, e stato comando accensione su file salvati su sd in modo da garantire riprese corrette di funzionamento in caso di mancanza e ritorno di corrente. Per Tmax e Tmin, il file serve per cambiare velocemente i valori senza ricaricare lo sketch
#include <DallasTemperature.h>
#include <OneWire.h>
#include <Ethernet.h>
#include <EthernetClient.h>
#include <EthernetServer.h>
#include <Bridge.h>
#include <BridgeClient.h>
#include <BridgeServer.h>
#include <BridgeSSLClient.h>
#include <Console.h>
#include <FileIO.h>
#include <HttpClient.h>
#include <Mailbox.h>
#include <Process.h>
#include <FileIO.h>
#include <YunServer.h>
#include <YunClient.h>

byte mac[] = { 0x, 0x, 0x, 0x, 0x, 0x }; // setta la rete per yun
byte ip[] = { 192, 168, 100, 101 };
byte gateway[] = { 192, 168, 100, 250 };
byte subnet[] = { 255, 255, 255, 0 };
byte ddns[] = { 8, 8, 8, 8};
EthernetClient client;
YunServer server;

float temperature; // valore temperatura letto
#define ONE_WIRE_BUS 2
OneWire ourWire(ONE_WIRE_BUS);
DallasTemperature sensors(&ourWire);

String  semaforo; // stato accensione
float tmin; // tmin 
String tmins; // tmin letto da file txt
float tmax; // tmax
String tmaxs; // tmax letto da file txt

void setup() {
  // put your setup code here, to run once:

  blinkled(2, 200); // notifica accensione arduino con lampeggio veloce

  server.listenOnLocalhost(); 
  server.begin();
  Bridge.begin();
  Ethernet.begin(mac, ip, ddns, gateway, subnet);
  FileSystem.begin();
  delay(10000); //  attende 10 secondi che arduino si assesti in rete

  pinMode(LED_BUILTIN, OUTPUT);

  Process p;
  p.runShellCommand("cat /root/test.txt | ssmtp indirizzo@fornitoreemail.com"); //  manda una mail che notifica avvio del sistema
  blinkled(2, 1000); // notifica invio mail con lampeggio lungo
}

void loop() {
  Bridge.begin();
  Process p;
  semaforo = leggifile("semaforo.txt"); //  legge da disco lo stato del comando di accensione 
  tmins = leggifile("tmin.txt"); // legge da file tmin.txt il valore 
  tmaxs = leggifile("tmax.txt"); // legge da file tmax.txt il valore 
  tmin = tmins.toFloat(); // converte il valore letto dal file da stringa a float
  tmax = tmaxs.toFloat(); // converte il valore letto dal file da stringa a float
  
  // put your main code here, to run repeatedly:

  YunClient client = server.accept();
  temperature = getTemp(); // legge la temperatura dalla sonda

  if ( temperature < 70)  { // la sonda dallas sembra dare una falsa lettura di 85 gradi alla prima accensione, si esclude cosi tale lettura
    // il valore massimo teorico del bollitore non dovrebbe superare in inverno i 65 gradi, quindi 70 gradi vanno bene come soglia per non eseguire il ciclo
    if (temperature >= tmax) { 
      if (String(semaforo[0]) == "S" )  { // se la temperatura è oltre a tmax e non è stato ancora inviato il comando di accensione  
        p.runShellCommand("cat /mnt/sda1/arduino/www/accendi.txt | ssmtp indirizzo@fornitoreemail.com"); //  invia mail "accendi"
        semaforo = "A;"; // setta lo stato di accensione in "acceso" ovvero A
        scrivifile("semaforo.txt", semaforo, 2); // scrive lo stato "A" su file semaforo.txt sulla sd cancellando lo stato precedente
        delay(2000); 
        scrivifile("accensioni.csv", percsv(String(semaforo[0])), 1); // annota su un file l'orario di accensione
      }
    }
    if (temperature <= tmin) { one

      if ( String(semaforo[0]) == "A") { // se la temperatura è sotto a tmin e non è stato ancora inviato il comando di spegnimento
        p.runShellCommand("cat /mnt/sda1/arduino/www/spegni.txt | ssmtp indirizzo@fornitoreemail.com"); //  invia mail "spegni"
        semaforo = "S;"; // setta lo stato di accensione in "spento" ovvero S
        scrivifile("semaforo.txt", String(semaforo[0]), 2); // scrive lo stato "S" su file semaforo.txt sulla sd cancellando lo stato precedente
        delay(2000);
        scrivifile("accensioni.csv", percsv(String(semaforo[0])), 1); // annota su un file l'orario di spegnimento
      }
    }
  }
        Bridge.put("statosemaforo",String(semaforo)); // invia al bridge verso linino lo stato dell'accensione corrente
        Bridge.put("dataeora",getTime()); // invia al bridge verso linino l'ora dell'ultima lettura
        Bridge.put("valtemperatura",String(temperature)); // invia al bridge verso linino l'ultima temperatura rilevata
  scrivifile("temperature.csv", percsv(String(semaforo[0])), 1); // scrive su file di log la temperatura, ad ogni ciclo, e il relativo stato di accensione
  delay(300000); // attende 5 minuti
}

float getTemp() {  // legge la temperatura dalla sonda in gradi centigradi
  //returns the temperature from one DS18B20 in DEG Celsius
sensors.begin();
sensors.requestTemperatures(); 
return sensors.getTempCByIndex(0);
}

String getTime() {  // restituisce una stringa con data e ora correnti
  String result;
  Process time;
  time.begin("date");
  time.addParameter("+%D;%T;");
  time.run();
  while (time.available() > 0) {
    char c = time.read();
    if (c != '\n')
      result += c;
  }
  return result;
}

void blinkled(int cicle, int temp ) { // fa lampeggiare il led n volte per il tempo settato
  for ( int x = 1; x <= cicle; x++) {
    digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on
    delay(temp);                       // wait for a temp
    digitalWrite(LED_BUILTIN, LOW);    // turn the LED off
    delay(temp);                       // wait for a temp
  }
}

void scrivifile  ( String nome, String testo, int modo) { // scrive sul file NOME, la stringa TESTO. se MODO è 1 aggiunge al file, se MODO è 2 cancella il file e scrive il valore in uno nuovo
  FileSystem.begin();
  Bridge.begin();
  String percorso;
  percorso = "/mnt/sda1/arduino/www/" + nome;
  if (modo == 1) {  //modo 1 aggiunta a file esistente
    File dataFile = FileSystem.open(percorso.c_str() , FILE_APPEND);
    if (dataFile) {
      dataFile.println(testo);
      dataFile.close();
    }
  }
  else
  { //modo 2 variazione file (cancella e riscrive)
   FileSystem.remove(percorso.c_str());
    File dataFile1 = FileSystem.open(percorso.c_str() , FILE_APPEND);  //FILE_WRITE);
    if (dataFile1) {
      dataFile1.println(testo);
      dataFile1.close();
    }
  }
}

String percsv(String semaforo) { // prepara una stringa con data, temperatura letta e stato accensione
  String dataString;
  dataString += getTime();
  dataString += temperature;
  dataString += ";";
  dataString += semaforo;
  return dataString;
}

String leggifile(String nome) { // legge da file di testo una stringa
  FileSystem.begin();
  Bridge.begin();
  String percorso;
  percorso = "/mnt/sda1/arduino/www/" + nome;
  File dataFile2 = FileSystem.open(percorso.c_str(), FILE_READ);
  String received;
  char ch;
  while (dataFile2.available()) {
    ch = dataFile2.read();
    if (ch == '\n') {
      return String(received);
    } else {
      received += ch;
    }
  }
  //return "";
}

Grazie a tutti

ecco il file html per leggere i dati "passati" da arduino a linino

è salvato sulla sd e richiamabile con http://indirizzoip/sd/sensori.html
utilizza il file zepto.min.js (da scaricare da internet e salvare nella sd)

<!DOCTYPE html>
<html>
<head>
<script type="text/javascript" src="zepto.min.js"></script>
<script type="text/javascript">
function refresh()
{
  $.getJSON("/data/get/valtemperatura", function(json) { document.getElementById('mytemp').innerHTML=json.value; });
  $.getJSON("/data/get/dataeora", function(json) { document.getElementById('dataeora').innerHTML=json.value; });
  $.getJSON("/data/get/statosemaforo", function(json) { document.getElementById('semaforo').innerHTML=json.value; });
}
</script>

</head>
<body onload="setInterval(refresh, 2000);">

Temperatura: <span id='mytemp'>---.--</span> °C 

Data e Ora: <span id='dataeora'>---.--</span> 

Comando termostato: <span id='semaforo'>---.--</span> 

</body>
</html>