Eccoci giunti alla parte più interessante dell’impianto di microirrigazione proposto negli articoli precedenti. Per il primo prototipo ho deciso di utilizzare il Netduino per eseguire velocemente tutti i test  dell’impianto e per poter adattare il software alle mie esigenze di irrigazione.

Lo schema elettrico del circuito è il seguente

Il circuito sembra complesso ma molti componenti sono stati utilizzati negli articoli precedenti.
Questo circuito sfrutta maggiormente gli ingressi analogici del Netduino. Sul pin A0 è collegata la fotoresistenza mentre sul pin A1 è collegato il sensore di temperatura. Sia la fotoresistenza che il sensore di temperatura sono alimentati con la 3.3V.
Gli altri ingressi analogici vengono utilizzati per le tre sonde che verificano l’umidità del terreno. Ho visto alcuni schemi elettrici che, per misurare la conducibilità del terreno, utilizzando una tensione continua. Questo approccio è molto semplice ma può dare problemi di elettrolisi, e conseguente ossidazione delle sonde poste nel terreno, con conseguente imprecisione della misura.
Per evitare questo problema, possiamo utilizzarne una tensione alternata, in questo caso però dobbiamo successivamente trasformarla in una tensione continua per poterla inviare agli ingressi analogici del Netduino.

Vediamo nel dettaglio il funzionamento della centralina, alcuni argomenti sono stati già esposti e quindi vi rimando alla lettura tramite questi link:

Per il sensore di temperature potete leggere questo articolo.
Per il sensore di luminosità tramite fotoresistenza potete fare riferimento a questo articolo.

La parte nuova da descrivere riguarda il sensore di umidità. Come ho detto prima, preferisco alimentare le sonde con un segnale alternato; la soluzione migliore è quella di utilizzare la funzione PWM del Netduino disponibile sul pin5.
Il segnale PWM viene inviato a tre ingressi dell’integrato 74HC244 (Line Driver) per avere un po più di corrente e disaccoppiare il Netduino delle sonde. Il duty cycle del pwm è del 50% e la sua frequenza è di 10Khz, naturalmente questi parametri possono essere variati in base alle esigenze e alla tipologia del terreno.

Quindi, il segnale si propaga nel terreno relativamente alla quantità di acqua presente. L’altro polo della sonda riceve questo segnale e lo invia al raddrizzatore che provvederà a fornire una tensione continua proporzionale al livello di umidità del terreno.
Il raddrizzatore è composto semplicemente da un diodo e da un condensatore. I diodi contrassegnati con il nome DP servono a limitare eventuali extra-tensioni captate dalla sonda.
Il partitore resistivo composto dalle resistenze R (da 27Kohm) serve a limitare la tensione sui pin analogici, dato che, il valore massimo applicabile non deve essere superiore a 3.3Vdc.

La parte che pilota il solenoide è composta da due relè, questa scelta può sembrare confusa ma penso che sia quella più economica e per capirla, è necessario conoscere  il funzionamento di una elettrovalvola (vedi riquadro)

Principalmente esistono due tipi di elettrovalvola, quella monostabile e quella bistabile. L’elettrovalvola monostabile è alimentata con una tensione alternata mentre quella bistabile con una continua.

Quelle monostabili possiedono un posizione stabile che è quella di chiusura della valvola, per aprirla dobbiamo alimentarla costantemente, se l’alimentazione viene a mancare la valvola ritorna nella sua posizione stabile. Il vantaggio è che se dovesse mancare l’alimentazione al circuito, mentre l’irrigazione è in atto, la valvola si chiude e quindi non ci sono problemi di allagamento.
Lo svantaggio è un maggior consumo elettrico poiché le valvole devono essere alimentate per tutto il tempo dell’irrigazione.

Quelle bistabili possiedono due stati stabili, uno per la valvola chiusa e uno per la valvola aperta. Alimentando il solenoide la valvola si apre e rimane aperta anche togliendo l’alimentazione. Per chiuderla dobbiamo alimentare il solenoide invertendo le polarità, anche in questo caso togliendo l’alimentazione la valvola rimane chiusa.
Il vantaggio principale e un consumo minimo in termini elettrici, dato che per aprire e chiudere la valvola basta alimentarla per qualche secondo, questo permette di creare automatismi a batteria .
Lo svantaggio è che se succede qualche problema al circuito o all’alimentazione, mentre la valvola è aperta, questa rimarrà in questo stato creando problemi di allagamento.

Nel mio caso, per la realizzazione del circuito, ho utilizzato una piccola basetta mille-fori dove ho alloggiato tutti i componenti del circuito. Per scopi prototipali, potete montare il circuito, anche su una breadboard.

La costruzione delle sonde richiede del comune filo elettrico e due elementi metallici da inserire nel terreno.

Una volta assemblato il circuito e le sonde, possiamo passare allo sviluppo del software. Avendo a disposizione vari input possiamo gestire il nostro impianto di microirrigazione adattando diversi algoritmi.

Per una irrigazione efficace dovremmo attivare l’elettrovalvola nel tardo pomeriggio, quando il sole inizia a tramontare. L’irrigazione deve avvenire se le sonde indicano una scarsa umidità del terreno. Il sensore di temperature serve per eseguire, ad esempio, una irrigazione aggiuntiva o prolungata, quando le giornate sono più calde.

Comunque sia, l’algoritmo può variare a seconda delle proprie esigenze, dal tipo di coltura e dalla posizione geografica dell’orto. Quello che mi interessa ora non è creare un algoritmo perfetto ma spiegare come utilizzare la centralina. Ognuno potrà poi, creare e personalizzare il proprio algoritmo.

La prima cosa da fare è assicurarsi che tutti i sensori del circuito funzionino a dovere. Il codice seguente acquisisce i segnali dagli ingressi analogici.

Nota: gli ingressi analogici potrebbero non rispettare la sequenza dello schema elettrico in quanto il prototipo è stato realizzato precedentemente allo schema elettrico

PWM pwmSondeUmidita = new PWM(Pins.GPIO_PIN_D5); //uscita pwm su pin5

AnalogInput SondaTerreno1 = new AnalogInput(Pins.GPIO_PIN_A0);
AnalogInput SondaTerreno2 = new AnalogInput(Pins.GPIO_PIN_A1);
AnalogInput SondaTerreno3 = new AnalogInput(Pins.GPIO_PIN_A2);
AnalogInput FotoSensor = new AnalogInput(Pins.GPIO_PIN_A3);
AnalogInput TempSensor = new AnalogInput(Pins.GPIO_PIN_A4);

//10Khz 50% duty cycle
pwmSondeUmidita.SetPulse(100, 50);

while (true)
{
Debug.Print("SondaTerreno1= " + SondaTerreno1.Read().ToString());
Debug.Print("SondaTerreno2= " + SondaTerreno2.Read().ToString());
Debug.Print("SondaTerreno3= " + SondaTerreno3.Read().ToString());
Debug.Print("SensoreLuce= " + FotoSensor.Read().ToString());
Debug.Print("SensoreTemperatura= " + TempSensor.Read().ToString());

Debug.Print("\n");

//attendo 1 secondo
Thread.Sleep(1000);
}

Le sonde S1, S2 ed S3 devono essere distanziate di qualche decina di centimetri cosi che il segnale di una sonda non interferisca con l’altra. Per verificarle ho immerso le sonde in 3 bicchieri di acqua diversi.
Nella finestra debug otterremo qualcosa di simile

Le sonde per il rilevamento dell’umidità hanno un valore di circa 650-700 quando sono in corto circuito, quando invece non conducono il valore tenderà a 0.
Il sensore di luminosità ha un valore elevato in presenza di forte luce mentre tenderà a 0 in presenza di poca luce.
Il sensore di temperatura ha un valore proporzionale alla temperatura misurata, per ottenere il valore in gradi centigradi vi rimando all’articolo dedicato al sensore.

Eccovi un semplice esempio che può darvi un’idea di come utilizzare la centralina

Int32 LumDato = 0;
Int32 TempDato = 0;
Int32 UmSens1Dato = 0;
Int32 UmSens2Dato = 0;
Int32 UmSens3Dato = 0;

Boolean AttivaIrrigazione = false;
Int32 Ciclo = 0;

//Configurazione PWM
PWM pwmSondeUmidita = new PWM(Pins.GPIO_PIN_D5); //uscita pwm su pin5
//Configurazione attuatori (relè)
OutputPort AlimentazioneValvola = new OutputPort(Pins.GPIO_PIN_D7, false);
OutputPort PolarizzazioneValvola = new OutputPort(Pins.GPIO_PIN_D6, false);
//Configuraziobe Ingressi analogici
AnalogInput SondaTerreno1 = new AnalogInput(Pins.GPIO_PIN_A0);
AnalogInput SondaTerreno2 = new AnalogInput(Pins.GPIO_PIN_A1);
AnalogInput SondaTerreno3 = new AnalogInput(Pins.GPIO_PIN_A2);
AnalogInput FotoSensor = new AnalogInput(Pins.GPIO_PIN_A3);
AnalogInput TempSensor = new AnalogInput(Pins.GPIO_PIN_A4);

//10Khz 50% duty cycle
pwmSondeUmidita.SetPulse(100, 50);

while (true)
{
//leggo dal sensore fotosensibile
LumDato = FotoSensor.Read();
//leggo dal sensore 9700a
TempDato = TempSensor.Read();
//leggo dalle sonde
UmSens1Dato = SondaTerreno1.Read();
UmSens2Dato = SondaTerreno2.Read();
UmSens3Dato = SondaTerreno3.Read();

//attendi il tramonto
if (LumDato < 200 && AttivaIrrigazione == true)
{
//Questa variabile serve per attivare l'irrigazione
//una sola volta dopo che la luminosità scende sotto 200
AttivaIrrigazione = false;

//controllo l'umidità nelle tre sonde
 //Avvia l'irrigazione solo se necessaria (terreno secco)
 if (UmSens1Dato < 300 && UmSens2Dato < 300 && UmSens3Dato < 300)
{
//se la temperatura ha un valore elevato irriga
//per un tempo superiore
if (TempDato > 350)
{
//Irrigazione prolungata per alta temperatura

//attivo l'elettrovalvola per un secondo
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);

//l'elettrovalvola è attiva
//attendo 40 minuti prima di disattivarla
for (Ciclo = 0; Ciclo <= 2400; Ciclo++)
{
Thread.Sleep(100);
}

//Inverto le polarità del solenoide
//e poi l'alimento per 1 secondo
PolarizzazioneValvola.Write(true);
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);
PolarizzazioneValvola.Write(false);
}
else
 {
//Irrigazione Normale
//attivo l'elettrovalvola per un secondo
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);

//l'elettrovalvola è attiva
//attendo 15 minuti prima di disattivarla
for (Ciclo = 0; Ciclo <= 900; Ciclo++)
{
Thread.Sleep(1000);
}

//Inverto le polarità del solenoide
//e l'alimento per 1 secondo
PolarizzazioneValvola.Write(true);
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);
PolarizzazioneValvola.Write(false);
}
}
}
else if (LumDato > 200)
{
//Rispristina la variabile quando la luminosità
//risale sopra i 200
AttivaIrrigazione = true;
}

Thread.Sleep(500);
}

Appena alimentiamo il circuito, Netduino esegue il codice creando gli oggetti per l’acquisizione dagli ingressi analogici, per generare il segnale pwm e per comandare i due relè, successivamente esegue un ciclo infinito acquisendo i dati dai sensori ogni 500 millisecondi.

Durante il giorno, in presenza di una buona luminosità, il sistema rimane nella fase di acquisizione; appena la luminosità inizia a diminuire, presumibilmente per il calar del sole, il valore acquisito dal pin analogico A0, collegato alla fotoresistenza, diminuisce.
Quando questo valore scende sotto la soglia di 200 (variabile in funzione del vostro sistema),  Netduino entra nel primo blocco if, dato che, AttivaIrrigazione è uguale a True.
Se le tre sonde indicano una bassa umidità del terreno (dato inferiore a 300), Netduino entra nel secondo blocco if. A questo punto troviamo un’altra istruzione if che permette di eseguire il codice per attivare l’elettrovalvola a seconda della temperatura misurata dal sensore 9700a.
Quindi se la temperatura è elevata verrà eseguito il primo blocco if, altrimenti verrà eseguito il codice del blocco else.
Il codice di questi blocchi è identico, tranne per il ciclo for che, per una temperatura elevata, dura maggiormente.

Analizziamo meglio il codice che pilota l’elettrovalvola

//Irrigazione Normale
//attivo l'elettrovalvola per un secondo
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);

//l'elettrovalvola è attiva
//attendo 15 minuti prima di disattivarla
for (Ciclo = 0; Ciclo <= 900; Ciclo++)
{
Thread.Sleep(1000);
}

//Inverto le polarità del solenoide
//e l'alimento per 1 secondo
PolarizzazioneValvola.Write(true);
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);
PolarizzazioneValvola.Write(false);

Le istruzioni comandano direttamente i due relè. In condizioni iniziali il relè2 permette di alimentare il solenoide per aprire l’elettrovalvola. Le prime istruzioni attivano il relè1, per alimentare per un secondo il solenoide.
Il ciclo for serve per creare un ritardo software di diversi minuti (tempo di irrigazione).
Una volta che il ciclo for termina, dobbiamo attivare il relè2 per invertire le polarità di alimentazione del solenoide. Una volta invertite viene attivato il relè1 per fornire nuovamente tensione al solenoide per circa 1 secondo il quale chiude la valvola, interrompendo l’irrigazione.
Le ultime istruzioni diseccitano il relè1 e il relè2.

Le illustrazioni seguenti mostrano come avviene la sequenza di azionamento dei relè.

Infine la variabile AttivaIrrigazioneviene utilizzata per irrigare una sola volta, altrimenti il ciclo di irrigazione dura finché le sonde S1, S2 ed S3 rilevano una elevata umidità del terreno.

Il codice è molto esemplificativo, serve per dare una linea guida su come utilizzare la centralina. Nulla vieta di utilizzare un algoritmo differente, o di utilizzare codice più efficiente.

Non ci resta che montare il circuito ed andarlo a sperimentare sul campo.

The post Netduino, centralina per impianto di microirrigazione appeared first on Esperimenti con logiche programmabili.