[Working In Progress] Progetto GrowStation - Arduino

[Edhorin]

Stiamo facendo più o meno un progetto analogo complimenti dacci dentro

 

[..db..]

Quello sopra non è frutto del mio lavoro.... io vorrei scrivere uno sketch per automatizzare 3 zone di coltivazione

. fioritura
. pianta madre
. radicazione

ecco l abbozzo di schema

////////////////////////////////////////////////////////////////
// qui si definiscono le temperature e vari settaggi ///
//////////////////////////////////////////////////////////////
///
////// fioritura ///
int tMAXf = 25; ///
int tMINf = 20; ///
int hMINf = 60; ///
///
///// madre ///
int tMAXm = 20; ///
int tMINm = 18; ///
int hMINm = 470; ///
///
///// radicamento ///
int tMAXr = 25; ///
int tMINr = 24; ///
int hMINr = 90; ///
///
/////////////////////////////////////////////
////////////////////////////////////////////


// ************************************************
// librerie
// ************************************************
#include <Wire.h>
#include "DHT.h"

#include <OneWire.h>
#include <DallasTemperature.h>

// ************************************************
// Variabili sensori dht11
// ************************************************
#define DHT1PIN 27
#define DHT2PIN 28
#define DHT3PIN 29
#define DHT4PIN 30

#define DHTTYPE DHT11

DHT dht1(DHT1PIN, DHTTYPE); // fioritura
DHT dht2(DHT2PIN, DHTTYPE); // fioritura
DHT dht3(DHT3PIN, DHTTYPE); // madre
DHT dht4(DHT4PIN, DHTTYPE); // radicamento

// ************************************************
// Variabili sensori ds18b20
// ************************************************
OneWire ds_1(11);
OneWire ds_2(12);
OneWire ds_3(13);

DallasTemperature sensor_1(&ds_1); // fioritura
DallasTemperature sensor_2(&ds_2); // madre
DallasTemperature sensor_3(&ds_3); // radicamento

float th2of;
float th2om;
float th2or;

void temp_check() {

sensor_1.requestTemperatures();
sensor_2.requestTemperatures();
sensor_3.requestTemperatures();

th2of = sensor_1.getTempCByIndex(0);
th2om = sensor_2.getTempCByIndex(0);
th2or = sensor_3.getTempCByIndex(0);
}

// ************************************************
// Pins relays
// ************************************************
int relay1 = 22; // -- aspiratore fioritura
int relay2 = 23; // risacaldamento fioritura
int relay3 = 24; // umidificatore fioritura
int relay4 = 25; // riscaldamento acqua fioritura RF con ds18b20
int relay5 = 26; // pompa h2o fioritura
int relay6 = 27; // -- aspiratore peperoncino
int relay7 = 28; // riscaldamento peperoncino
int relay8 = 29; // umidificatore peperoncino
int relay9 = 30; // pompa h2o peperoncino
int relay10 = 31; // -- aspiratore radicamento
int relay11 = 32; // riscaldamento radicamento
int relay12 = 33; // umidificatore radicamento
int relay13 = 34; // riscaldamento acqua radicamento con ds18b20
int relay14 = 35; // --riscaldamento acqua madre con ds18b20
int relay15 = 36; // ------------
int relay16 = 37; // ------

// ************************************************************************************************
// Sensori Umidità Terreno fioritura --- in questo momento ne uso solo 2
// ************************************************************************************************
int analogPin1 = A0; // Sensore 1 umidità Suolo fioritura
float SoilH1 = 0; // variabile per memorizzare il valore proveniente dal sensore
int analogPin2 = A1; // Sensore 2 umidità Suolo fioritura
float SoilH2 = 0; // variabile per memorizzare il valore proveniente dal sensore
int analogPin3 = A2; // Sensore 3 umidità Suolo fioritura
float SoilH3 = 0; // variabile per memorizzare il valore proveniente dal sensore
int analogPin4 = A3; // Sensore 4 umidità Suolo fioritura
float SoilH4 = 0; // variabile per memorizzare il valore proveniente dal sensore
int analogPin5 = A4; // Sensore 5 umidità Suolo fioritura
float SoilH5 = 0; // variabile per memorizzare il valore proveniente dal sensore
int analogPin6 = A5; // Sensore 6 umidità Suolo fioritura
float SoilH6 = 0; // variabile per memorizzare il valore proveniente dal sensore
int analogPin7 = A6; // Sensore 7 umidità Suolo fioritura
float SoilH7 = 0; // variabile per memorizzare il valore proveniente dal sensore
int analogPin8 = A7; // Sensore 8 umidità Suolo fioritura
float SoilH8 = 0; // variabile per memorizzare il valore proveniente dal sensore

float SoilHf = 0; // da memorizzare x irrigazione

// ************************************************************************************************
// Sensori Umidità Terreno madre
// ************************************************************************************************
int analogPin9 = A8; // Sensore 9 umidità Suolo madre
float SoilH9 = 0; // variabile per memorizzare il valore proveniente dal sensore
int analogPin10 = A9; // Sensore 10 umidità Suolo madre
float SoilH10 = 0; // variabile per memorizzare il valore proveniente dal sensore
int analogPin11 = A10; // Sensore 11 umidità Suolo madre
float SoilH11 = 0; // variabile per memorizzare il valore proveniente dal sensore
int analogPin12 = A11; // Sensore 12 umidità Suolo madre
float SoilH12 = 0; // variabile per memorizzare il valore proveniente dal sensore

float SoilHm = 0; // da memorizzare x irrigazione

// ************************************************************************************************
// ************************************************************************************************
// inizio VOID SETUP
// ************************************************************************************************
// ************************************************************************************************

void setup() {

// dHt
dht1.begin(); // avvio DHT fioritura
dht2.begin(); // avvio DHT fioritura
dht3.begin(); // avvio DHT madre
dht4.begin(); // avvio DHT radicamento

// ds18b20
sensor_1.begin(); // avvio ds18b20 fioritura
sensor_2.begin(); // avvio ds18b20 madre
sensor_3.begin(); // avvio ds18b20 radicamento

//relays
pinMode(relay1, OUTPUT);
pinMode(relay2, OUTPUT);
pinMode(relay3, OUTPUT);
pinMode(relay4, OUTPUT);
pinMode(relay5, OUTPUT);
pinMode(relay6, OUTPUT);
pinMode(relay7, OUTPUT);
pinMode(relay8, OUTPUT);
pinMode(relay9, OUTPUT);
pinMode(relay10, OUTPUT);
pinMode(relay11, OUTPUT);
pinMode(relay12, OUTPUT);
pinMode(relay13, OUTPUT);
pinMode(relay14, OUTPUT);
pinMode(relay15, OUTPUT);
pinMode(relay16, OUTPUT);

Serial.begin(9600); //
Wire.begin(); //
}


// ************************************************************************************************
// ************************************************************************************************
// inizio VOID LOOP
// ************************************************************************************************
// ************************************************************************************************

void loop() {

// ************************************************************************************************
// Umidità Suolo fioritura
// ************************************************************************************************

if (analogRead(analogPin1) > 224) {
SoilH1 = 100-(((analogRead(analogPin1))-224)*0.125);
} else {
SoilH1 = 100;
}
if (analogRead(analogPin2) > 224) {
SoilH2 = 100-(((analogRead(analogPin2))-224)*0.125);
} else {
SoilH2 = 100;
}

// uso solo 2 sensori
// if (analogRead(analogPin3) > 224) {
// SoilH3 = 100-(((analogRead(analogPin3))-224)*0.125);
// } else {
// SoilH3 = 100;
// }
// if (analogRead(analogPin4) > 224) {
// SoilH4 = 100-(((analogRead(analogPin4))-224)*0.125);
// } else {
// SoilH4 = 100;
// }
// if (analogRead(analogPin5) > 224) {
// SoilH5 = 100-(((analogRead(analogPin5))-224)*0.125);
// } else {
// SoilH5 = 100;
// }
// if (analogRead(analogPin6) > 224) {
// SoilH6 = 100-(((analogRead(analogPin6))-224)*0.125);
// } else {
// SoilH6 = 100;
// }
// if (analogRead(analogPin7) > 224) {
// SoilH7 = 100-(((analogRead(analogPin7))-224)*0.125);
// } else {
// SoilH7 = 100;
// }
// if (analogRead(analogPin8) > 224) {
// SoilH8 = 100-(((analogRead(analogPin8))-224)*0.125);
// } else {
// SoilH8 = 100;
// }
// copiare i sensori mancanti con quelli presenti
SoilH3 = (SoilH1);
SoilH4 = (SoilH2);
SoilH5 = (SoilH1);
SoilH6 = (SoilH2);
SoilH7 = (SoilH1);
SoilH8 = (SoilH2);

SoilHf = ((SoilH1+SoilH2+SoilH3+SoilH4+SoilH5+SoilH6+SoilH7+SoilH8)/8);


// ************************************************************************************************
// Umidità Suolo madre
// ************************************************************************************************

if (analogRead(analogPin9) > 224) {
SoilH9 = 100-(((analogRead(analogPin9))-224)*0.125);
} else {
SoilH9 = 100;
}
if (analogRead(analogPin10) > 224) {
SoilH10 = 100-(((analogRead(analogPin10))-224)*0.125);
} else {
SoilH10 = 100;
}
if (analogRead(analogPin11) > 224) {
SoilH11 = 100-(((analogRead(analogPin11))-224)*0.125);
} else {
SoilH11 = 100;
}
if (analogRead(analogPin12) > 224) {
SoilH12 = 100-(((analogRead(analogPin12))-224)*0.125);
} else {
SoilH12 = 100;
}

SoilHm = ((SoilH9+SoilH10+SoilH11+SoilH12)/4);


// ************************************************************************************************
// associazione temperatura dht11
// ************************************************************************************************

float h1 = dht1.readHumidity();
float t1 = dht1.readTemperature();
float h2 = dht2.readHumidity();
float t2 = dht2.readTemperature();
float h3 = dht3.readHumidity();
float t3 = dht3.readTemperature();
float h4 = dht4.readHumidity();
float t4 = dht4.readTemperature();
if (isnan(t1) || isnan(h1)) {
Serial.println("dHt fioritura non va!!");}
if (isnan(t2) || isnan(h2)) {
Serial.println("dHt fioritura non va!!");}
if (isnan(t3) || isnan(h3)) {
Serial.println("dHt delle madre non va!!");}
if (isnan(t4) || isnan(h4)) {
Serial.println("dHt delle radici non va!!");}


// ************************************************************************************************
// Operazioni dei Relè
// ************************************************************************************************

//////////////////////////// Temperature Aria + Umidità
//////// fioritura
if (((t1+t2)/2) >= tMAXf) {
digitalWrite(relay1, HIGH); // accensione aspiratore
if (((t1+t2)/2) <= tMAXf) {
digitalWrite(relay1, LOW);} // spegnimento aspiratore

if (((t1+t2)/2) <= tMINf) {
digitalWrite(relay2, HIGH); // accensione stufa
if (((t1+t2)/2) >= tMINf) {
digitalWrite(relay2, LOW);} // spegnimento stufa

if (((h1+h2)/2) <= hMINf) {
digitalWrite(relay3, HIGH); // accensione umidificatore
if (((h1+h2)/2) >= hMINf) {
digitalWrite(relay3, LOW);} // spegmiento umidificatore

//////// madre
if (t3 >= tMAXm) {
digitalWrite(relay6, HIGH); // accensione aspiratore
if (t3 <= tMAXm) {
digitalWrite(relay6, LOW);} // spegnimento aspiratore

if (t3 <= tMINm) {
digitalWrite(relay7, HIGH); // accensione stufa
if (t3 >= tMINm) {
digitalWrite(relay7, LOW);} // spegnimento stufa

if (h3 <= hMINm) {
digitalWrite(relay8, HIGH); // accensione umidificatore
if (h3 >= hMINm) {
digitalWrite(relay8, LOW);} // spegmiento umidificatore

//////// radicamento
if (t4 >= tMAXr) {
digitalWrite(relay7, HIGH); // accensione aspiratore
if (t4 <= tMAXr) {
digitalWrite(relay7, LOW);} // spegnimento aspiratore

if (t4 <= tMINr) {
digitalWrite(relay8, HIGH); // accensione stufa
if (t4 >= tMINr) {
digitalWrite(relay8, LOW);} // spegnimento stufa

if (h4 <= hMINr) {
digitalWrite(relay9, HIGH); // accensione umidificatore
if (h4 >= hMINr) {
digitalWrite(relay9, LOW);} // spegmiento umidificatore

////////////////////////////// Irrigazione

if (SoilHf < 0) { // imposto variabile sensore umidita terreno fioritura
digitalWrite(relay5, HIGH); // accensione pompa h2o fioritura
delay(8000); // imposto tempo irrigazione dopo il quale la pompa si spegne..... esempio => pompa da 1000 l/h ... pianta bisogno 2l h2o ... 1 minuto pompa = 0,25 l ... apertura 8 minuti = 2l
digitalWrite(relay5, LOW);} // spegnimento pompa h2o fioritura

if (SoilHm < 0) { // imposto variabile sensore umidita terreno madre
digitalWrite(relay9, HIGH); // accensione pompa h2o madre
delay(10000);
digitalWrite(relay9, LOW);} // spegnimento pompa h2o madre

////////////////////////////// Riscaldamento h2o

if (th2of < 18) { ///imposto la temperatura minima h2o fioritura
digitalWrite(relay4, HIGH); // accensione serpentina h2o fioritura
if (th2of > 20) { ///imposto la temperatura massima h2o fioritura
digitalWrite(relay4, LOW);} // spegnimento serpentina h2o fioritura

if (th2om < 20) { ///imposto la temperatura minima h2o madre
digitalWrite(relay13, HIGH); // accensione serpentina h2o madre
if (th2om > 22) { ///imposto la temperatura massima h2o madre
digitalWrite(relay13, LOW);} // spegnimento serpentina h2o madre

if (th2or < 20) { ///imposto la temperatura minima h2o radicamento
digitalWrite(relay14, HIGH); // accensione serpentina h2o radicamento
if (th2or > 22) { ///imposto la temperatura massima h2o radicamento
digitalWrite(relay14, LOW);} // spegmiento serpentina h2o radicamento


}

se volete ho iniziato una discussione qui... chiaramente

fioritura => pomodori
madre => peperoncino
radicamento => semenzaio

sai come ahahahahahah

voi avete qualcosa da mostrare... tanto per darci una mano....

 

[Guidus93]

ho quasi completato un progetto simile, ti ho scritto nel forum di arduino comuque!

 

[messicano]

mi invitate per la visualizzazione del blog? grazie.

 

[messicano]

Buongiorno a tutti, vi presento il primo video di test visuali sulla schermata home e relativi sottomenù di impostazioni della nuova centrale di controllo per serre e grow room in fase di progettazione finale.
La centrale (per la quale ancora non decido il nome) è in grado di controllare tutti i fattori di una grow room.
Alcuni dettagli:
La centrale è composta da un sensore di umidità e temperatura grazie alla quale possiamo inpostare un range di funzionamento di temperatura minima e temperatura massima sia per il giorno che per la notte, Infatti tramite un sensore apposito riesce a capire se le luci sono accese o spente e portare i valori di temperatura e umidità in base a quelli che abbiamo impostato per i due periodi differenti. Stessa cosa per l'umidità. In base ai valori letti e quelli impostati dall'utente essa è in grado di azionare una termoventola per alzare la temperatura oppure un climatizzatore per abbassarla(in realtà al posto del climatizzatore è possibile collegare qualunque altro apparecchio in grado di abbassare la temperatura, anche una ventola o estrattore secondario) In riferimento ai valori di umidità impostati essa attiva un umidificatore e un deumidificatore. Inoltre è anche possibile collegare direttamente l'impianto luci per gestirlo tramite gli orari che impostiamo nel menù dedicato alle luci. Sono state aggiunte altre uscite dove impostare fino ad un massimo di 15 periodi di accensione e spegnimento indipendenti per l'estrazione, l'immissione dell'aria, per la ventilazione all'interno della grow. Altra chicca è il sensore di PH collegato direttamente alla centrale dove grazie al menù dedicato possiamo correggere il valore letto per calibrarlo senza dover andare ad agire sui trimmer di settaggio sulle schede. Inoltre la centrale ha la possibilità, tramite una sonda di controllare l'umidità del terreno ed azionare una elettrovalvola per innaffiare in base all'umidità di terreno che abbiamo impostato nel menù (SECCO-UMIDO-BAGNATO) ed è anche possibile decidere per quanto tempo azionare l'elettrovalvola. Non finisce qui perchè possiamo azionale anche l'irrigazione manuale e accendere e spegnere l'irrigazione a nostro piacimento ad esempio per il flush finale. Inoltre la centrale visualizza anche il tempo passato dal momento dell'inizio della vegetativa e al momento dello switch alla fioritura possiamo far partire il tempo visualizzando a video in HOME i giorni di vegetativa e quelli di fioritura. allego un primo video del prototipo che è molto più eloquente di tutto quello che ho appena illustrato.
La forza di questa centrale sarà il prezzo estremamente basso rispetto alle centrali attualmente in commercio che hanno costi che superano le migliaia di euro e non hanno tutte queste funzioni.
https://www.youtube.com/watch?v=Dt5HyirJvGY

 

[growbastard]

Avevo scritto da nubbio anche io uno sketch per usare la DHT11 come sonda per controllare Temp e Umidità ma, non ho mai approfondito se funzionava In Teoria dovrebbe anche salvare i dati su eprom

Lo condivido volentieri se può servire come base a qualcuno che si prende le bega di provarlo e correggerlo se presentasse errori

tutto vostro

#include <LiquidCrystal.h>
#include <EEPROM.h>
#include "DHT.h"
#define DHTPIN 8
// 8 è il pin di Arduino per il sensore di temperatura
#define DHTTYPE DHT11
// dht11 è il tipo di sensore che uso, se usate il DTH22 modificare sketch
DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
// connessione display (pin)
const int tsu = 6;
const int tgiu = 7;
const int hsu = 9;
const int hgiu = 10;
const int tout = 14;
const int hout = 15;
const int reset = 16;
//dichiaro i pulsanti
byte MIN;
byte MAX;
// dichiaro le variabili
int statoreset = 0;
int statotsu = 0;
int statotgiu = 0;
int statohsu = 0;
int statohgiu = 0;
int tempimpostata = 0;
int umidimpostata = 0;
void setup() {
lcd.begin(20, 4);
//set display (colonne, righe)
lcd.print("TEMP");
lcd.setCursor(10,0);
lcd.print("SET");
lcd.setCursor(0,1);
lcd.print("UMID");
lcd.setCursor(10,1);
lcd.print("SET");
lcd.setCursor(0,2)
lcd.print("TEMP ATTUALE");
lcd.setCursor(0,3);
lcd.print("MIN");
lcd.setCursor(9,3);
lcd.print("MAX");
//scrivo sul display i caratteri fissi
pinMode(tout, OUTPUT);
pinMode(hout, OUTPUT);
pinMode(reset, INPUT);
digitalWrite(10, HIGH);
MIN = EEPROM.read(1);
MAX = EEPROM.read(2);
}
void loop() {
statotsu = digitalRead (tsu);
if( statotsu == HIGH)
{tempimpostata++;}
statotgiu = digitalRead (tgiu);
if( statotgiu == HIGH)
{tempimpostata--;}
statohsu = digitalRead (hsu);
if( statohsu == HIGH)
{umidimpostata++;}
statohgiu = digitalRead (hgiu);
if( statohgiu == HIGH)
{umidimpostata--;}
int t = dht.readTemperature();
int h = dht.readHumidity();
// posiziono il cursore alla colonna 12 e riga 0
lcd.setCursor(5, 0);
lcd.print(t);
lcd.setCursor(14, 0);
lcd.print(tempimpostata);
lcd.setCursor(5, 1);
lcd.print(h);
lcd.setCursor(14, 1);
lcd.print(umidimpostata);
if (tempimpostata > -1 && tempimpostata < 10)
{ lcd.setCursor (15, 0);
lcd.print (" ");}
if (umidimpostata > -1 && umidimpostata < 10)
{ lcd.setCursor (15, 1);
lcd.print (" ");}
if ( t < tempimpostata )
{digitalWrite ( tout, HIGH );}
else {digitalWrite (tout, LOW);}
if ( h < umidimpostata )
{digitalWrite ( hout, HIGH );}
else {digitalWrite (hout, LOW);}
if (t > MAX)
{MAX = t;
EEPROM.write(2, t);}
// se la temperatura supera il valore MAX modifico il valore MAX
// scrivo questo dato nella eeprom
if (t < MIN)
{MIN = t;
EEPROM.write(1, t);}
// se la temperatura è minore del Valore MIN allora modifico il valore MIN
// scrivo questo dato nella eeprom
statoreset = digitalRead (reset);
if( statoreset == LOW)
{MIN = t;
MAX = t;}
// tasto reset cancella Eprom
lcd.setCursor(14, 2);
lcd.print(t);
lcd.setCursor(5, 3);
lcd.print(MIN);
lcd.setCursor(14, 3);
lcd.print(MAX);
// scrittura dati sul display
delay(100);
}

 

[growbastard]

C'era un commento errato

#include <LiquidCrystal.h>
#include <EEPROM.h>
#include "DHT.h"
#define DHTPIN 8
// 8 è il pin di Arduino per il sensore di temperatura
#define DHTTYPE DHT11
// dht11 è il tipo di sensore che uso, se usate il DTH22 modificare sketch
DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
// connessione display (pin)
const int tsu = 6;
const int tgiu = 7;
const int hsu = 9;
const int hgiu = 10;
const int tout = 14;
const int hout = 15;
const int reset = 16;
//dichiaro i pulsanti
byte MIN;
byte MAX;
// dichiaro le variabili
int statoreset = 0;
int statotsu = 0;
int statotgiu = 0;
int statohsu = 0;
int statohgiu = 0;
int tempimpostata = 0;
int umidimpostata = 0;
void setup() {
lcd.begin(20, 4);
//set display (colonne, righe)
lcd.print("TEMP");
lcd.setCursor(10,0);
lcd.print("SET");
lcd.setCursor(0,1);
lcd.print("UMID");
lcd.setCursor(10,1);
lcd.print("SET");
lcd.setCursor(0,2)
lcd.print("TEMP ATTUALE");
lcd.setCursor(0,3);
lcd.print("MIN");
lcd.setCursor(9,3);
lcd.print("MAX");
//scrivo sul display i caratteri fissi
pinMode(tout, OUTPUT);
pinMode(hout, OUTPUT);
pinMode(reset, INPUT);
digitalWrite(10, HIGH);
MIN = EEPROM.read(1);
MAX = EEPROM.read(2);
}
void loop() {
statotsu = digitalRead (tsu);
if( statotsu == HIGH)
{tempimpostata++;}
statotgiu = digitalRead (tgiu);
if( statotgiu == HIGH)
{tempimpostata--;}
statohsu = digitalRead (hsu);
if( statohsu == HIGH)
{umidimpostata++;}
statohgiu = digitalRead (hgiu);
if( statohgiu == HIGH)
{umidimpostata--;}
int t = dht.readTemperature();
int h = dht.readHumidity();
lcd.setCursor(5, 0);
lcd.print(t);
lcd.setCursor(14, 0);
lcd.print(tempimpostata);
lcd.setCursor(5, 1);
lcd.print(h);
lcd.setCursor(14, 1);
lcd.print(umidimpostata);
if (tempimpostata > -1 && tempimpostata < 10)
{ lcd.setCursor (15, 0);
lcd.print (" ");}
if (umidimpostata > -1 && umidimpostata < 10)
{ lcd.setCursor (15, 1);
lcd.print (" ");}
if ( t < tempimpostata )
{digitalWrite ( tout, HIGH );}
else {digitalWrite (tout, LOW);}
if ( h < umidimpostata )
{digitalWrite ( hout, HIGH );}
else {digitalWrite (hout, LOW);}
if (t > MAX)
{MAX = t;
EEPROM.write(2, t);}
// se la temperatura supera il valore MAX modifico il valore MAX
// scrivo questo dato nella eeprom
if (t < MIN)
{MIN = t;
EEPROM.write(1, t);}
// se la temperatura è minore del Valore MIN allora modifico il valore MIN
// scrivo questo dato nella eeprom
statoreset = digitalRead (reset);
if( statoreset == LOW)
{MIN = t;
MAX = t;}
// tasto reset cancella Eprom
lcd.setCursor(14, 2);
lcd.print(t);
lcd.setCursor(5, 3);
lcd.print(MIN);
lcd.setCursor(14, 3);
lcd.print(MAX);
// scrittura dati sul display
delay(100);
}

 

[FaX!]

Complimenti blue è bello leggere le tue spiegazioni tecniche!!
Da quello che ho capito una volta che hai il cervello centrale programmato che elabora i parametri e apre e chiude i relè, la qualità del sistema sta tutto nella validità delle sonde che vai ad applicare giusto?
Quindi la valutazione precisa delle sonde sta alla base di tutto! (Ovviamente dopo aver programmato il cervello centrale)

Ciao e scusa l'intrusione

 

[messicano]

questo è il link del mio progetto sempre basato su arduino leggermente più avanzato perchè gestisce qualcosina in più, ormai completo...manca solo la stampa del case esterno: https://www.icmag.com/ic/showthread.php?p=7016129#post7016129

bel progetto anche il tuo, ti consiglierei però di rivedere un attimino alcune parti del codice, memorizzare i dati inseriti nella eeprom in caso di riavvio e soprattutto alla fine un bel watch dog per il riavvio automatico nel caso si blocchi qualcosa nel loop dei cicli.
P.S. per quanto riguarda il sensore di umidità del terreno ti consiglierei di inserire un transistor ed utilizzare anche l'uscita digitale del sensore per dargli l'input di lettura altrimenti max due settimane e ti sei giocato la sonda. (leggi le regole dell'elettrolisi per capire meglio) appena ho due minuti in più leggo tutto il post per capire se hai qualcosaltro da sistemare. cmq lo vedo molto limitato non poter inserire i valori direttamente da tasti fisici sulla centrale.io ho implementato anche i range di temperatura e umidità per la notte oltre a quelli del giorno, il sistema riconosce se è giorno o notte con una semplice fotoresistenza

 

[Bluedeep85]

memorizzare i dati nella eeprom è useless in quanto conto di inizializzare il tutto da una basedati sql.

Watch dog invece hai perfettamente ragione è da implementare.

Non conto di inserire un sensore di umidità del terreno sono troppo poco affidabili purtroppo l'effetto galvanico c'è e non si può nulla contro alla fisica.

 

[Bluedeep85]

Avevo pensato di applicare un variatore di tensione per variare la velocità delle ventole, ma il variatore è troppo complicato da realizzare, quindi mi sa che lascio perdere

 

[Edhorin]

Avevo pensato di applicare un variatore di tensione per variare la velocità delle ventole, ma il variatore è troppo complicato da realizzare, quindi mi sa che lascio perdere

basta usare un circuito di comando pwm con ne555 e un resistore digitale

 

[Bluedeep85]

basta usare un circuito di comando pwm con ne555 e un resistore digitale

ok, ma quali estrattori hanno il pwm?

 

[Bluedeep85]

Okay ho in mente una modifica abbastanza figa. Invece di definire i parametri di:
GERMINAZIONE
VEGETAZIONE
FIORITURA

come constanti, ho deciso di importarli direttamente nel programma, in questo modo lato webserver posso cambiare i parametri come voglio, quando voglio senza dover ogni volta caricare lo sketch sull'arduino. Conto di sfruttare questa libreria: https://github.com/bblanchon/ArduinoJson

 

[Bluedeep85]

Ho visto che sul sito della Vents consigliano (anche se non la prima scelta) di usare un triac.

Ho visto che tutte le centraline GSE che ci sono usano sempre un triac, quindi ho deciso di costruirmi questo:
http://www.instructables.com/id/Arduino-controlled-light-dimmer-The-circuit/

In pratica tramite il circuito si rileva il zero-cross point e tramite un interrupt di arduino si imposta un ritardo dell'apertura del triac.

 

[Amaccabanane]

magari offe qualche spunto:
http://techcrunch.com/2015/09/22/leaf-is-a-plug-n-plant-box-to-automatically-grow-pot-in-your-home/

 

[messicano]

Green House tetraidro ver.1.0

Green House tetraidro ver.1.0

[FONT=Arial, Helvetica, sans-serif]Finalmente il progetto è completo è lavora alla perfezione. Attualmente è la centrale più completa esistente per la gestione di serre e grow box grazie al controllo di ben 9 apparati. (aria calda, aria fredda, umidificatore, deumidificatore, luci, immissione, estrazione, ventilazione, irrigazione automatica in base al grado di umidità del terreno) oppure in modalità manuale utile per il flushing finale. Il sistema è impostabile per un range di temperatura minima e massima per il giorno e minima e massima per la notte. stessa cosa per il grado di umidità relativa. Il sistema rileva se è giorno o notte tramite un fotoresistore. Implementata anche la sonda del ph per le sostanze nutritive più tante altre funzioni. Il case è interamente realizzato tramite fresatura di lastre di forex da 1 cm di spessore che è un materiale plastico ignifugo. I relè di controllo degli apparati sono tutti optoisolati per evitare un ritorno di tensione ed è stato eliminato il classico problema di corrosione della sonda del terreno per effetto dell'elettrolisi.


[/FONT]