Microirrigazione autonoma sul balcone con comandi e routine Alexa
Realizzare un impianto di microirrigazione per caduta con un'elettrovalvola bistabile, modulo ESP8266 e Alexa.
Immagino vi sarà già capitato di pensare ai metodi per innaffiare i
vasi sul balcone durante i periodi di assenza dalla
vostra abitazione.
In commercio esistono soluzioni professionali per risolvere questo tipo di problematica con programmatori e kit di irrigazione ad hoc.
In questo articolo, per gli amanti del fai da te, vedremo come realizzare un semplice impianto automatizzato, sfruttando la rete wifi
di casa e l'acqua contenuta in una cisterna. Chiederemo un aiuto ad Alexa per innaffiare ad intervalli programmati o a fronte di comandi vocali seduti comodamente sul divano.
L'ambito di applicazione è un classico balcone da appartamento di città. Il progetto è quindi facilmente replicabile per situazioni simili, ma è anche adattabile ad altri contesti in funzione delle diverse necessità.
I principi saranno sempre validi.
Ci tengo a sottolineare che non serve essere esperti in materia di giardinaggio, come non lo ero io nel momento in cui ho iniziato a documentarmi su tubi e raccordi...
Spero che questa esperienza e i risultati ottenuti possano essere utili a qualcuno che voglia cimentarsi anche solo per le prime esperienze di elettronica e domotica, per divertirsi in progetti del genere.
Prerequisiti
Sono pochi:
- Interesse per il fai da te
- conoscenze basiche di elettronica e informatica
A tal proposito segnalo il kit base di Arduino per principianti. Il progetto spiegato in questo post non è basato sulla scheda Arduino, però utilizza lo stesso linguaggio di programmazione e lo stesso framework di sviluppo (IDE) installato sul PC.
Ho trovato utile questo kit acquistato circa un anno fa per acquisire un po' di dimestichezza sull'utilizzo dei microcontrollori:
- Alexa già funzionante a casa
Come è strutturato l'articolo
1. Componenti necessari- scheda di sviluppo WeMos D1 Mini o compatibile basato su ESP8266. Costo indicativo: 5-8 €
- Scheda con Motor driver TB6612FNG della Toshiba. Costo indicativo: 5-8 €
- elettrovalvola bistabile RPE 9V 1" attacco Femmina a bassa pressione. Costo indicativo: 40 €
Si può acquistare online presso Acquapiù o Caser Irrigazione
- cisterna in plastica da 30 L predisposta per rubinetto. Costo indicativo: 20 €
- tubi e raccordi. Costo indicativo: 30 €
- costo indicativo totale: 100 €
- Effettuare i collegamenti idraulici
- Effettuare i collegamenti elettrici
- Programmare la scheda di sviluppo D1 Mini
- Collaudo e test finali
1 Componenti necessari
Possiamo dividerli in tre macro sezioni:
- scelta dell'elettrovalvola
- scelta della parte idraulica (cisterna, tubi, raccordi, ecc.)
- scelta del microcontrollore e del driver per il comando dell'elettrovalvola
Scelta dell'elettrovalvola
Primo aspetto: funzionamento a riposo
Innanzitutto occorre scegliere tra elettrovalvole monostabili o bistabili (dette anche latching o bistable solenoid valves).
Il vantaggio è che se per qualche motivo si esaurisse o si interrompesse la fonte di alimentazione elettrica esterna, l'elettrovalvola (se di tipo Normalmente Chiusa) interromperebbe il flusso dell'acqua e quindi eviterebbe nel nostro caso di allagare il balcone :-)
Nelle elettrovalvole bistabili non c'è un funzionamento a riposo, l'elettrovalvola resta aperta o chiusa in funzione dell'ultimo comando che ha ricevuto.
Tenendo conto che una delle linee guida principali che avevo per questo progetto era il basso assorbimento di energia dell'impianto, la scelta è ricaduta su un'elettrovalvola bistabile, perchè questa non ha la necessità di essere alimentata durante l'irrigazione, e quindi i consumi elettrici sono molto bassi, sebbene la relativa programmazione sia leggermente più complessa.
Vedremo in un post successivo l'importanza della limitazione dei consumi elettrici per il funzionamento a batteria.
Secondo aspetto: la pressione di funzionamento.
La maggior parte delle elettrovalvole in commercio sono progettate per essere collegate ad impianti esistenti di distribuzione dell'acqua (es.: collegati ad acquedotto), per cui hanno la membrana interna progettata per attivarsi con pressioni > 1 bar.
Per questo progetto, volendo usare l'acqua di una tanica, la pressione dell'acqua su cui possiamo contare è solo quella che si genera per caduta dalla cisterna, quindi una pressione molto bassa e vicina allo zero.Pertanto sceglieremo un'elettrovalvola a bassa pressione. Tipicamente l'applicazione di queste elettrovalvole è per il riutilizzo delle acque piovane e irrigazione da cisterna come è visibile sul sito del produttore RPE.
Terzo aspetto: la tensione di funzionamento.
L'alimentazione dell'elettrovalvola è fornita da una batteria esterna. Ho optato per un'elettrovalvola a 9V (l'alternativa era a 24V) in modo da poter semplicemente usare le classiche batterie transistor da 9V.
Come già detto, l'elettrovalvola si può acquistare online presso Acquapiù o Caser Irrigazione insieme ai raccordi che vedremo dopo.
Scelta della parte idraulica
Il primo componente è una tanica / cisterna o fusto in cui sia già presente un foro filettato da 3/4" a cui applicheremo in seguito un rubinetto o valvola principale, in sostituzione del piccolo rubinetto di cui la tanica probabilmente è già fornita.
Sembrerà strano ma è il componente che ho avuto più difficoltà a individuare, visto lo svariato numero di cisterne in commercio. Il punto importante è che avesse già la filettatura adatta ai comuni raccordi.
Di seguito le parole chiave utili per la ricerca:
FUSTO BOCCA LARGA IN PLASTICA 30 LT PER ALIMENTI PREDISPOSTO PER RUBINETTO
Facendo la ricerca come indicato, si può acquistare la tanica con foro filettato internamente da 3/4", ovvero la dimensione di partenza usata in questo progetto e a cui è stato applicato il primo raccordo. Nel caso non sia indicato espressamente, potete richiedere conferma del diametro della predisposizione del rubinetto al venditore prima dell'acquisto.
Il volume del fusto (es.: 30 , 50 L) può essere scelto in funzione delle esigenze di autonomia dell'impianto.
Servirà progettare l'insieme di tubi e raccordi che partono dalla cisterna
posizionata ad un'altezza di almeno 50 cm (*) per generare la pressione minima
di 0,05 bar necessaria all'elettrovalvola, come indicato sul sito del produttore.
(*) Se volessimo calcolare l'altezza minima direttamente, di seguito qualche calcolo in base alla legge di Stevino (?).
-------------------------------------------------------------------------------------------
(?)
legge di Stevino: la pressione esercitata da un liquido in un recipiente si ottiene come prodotto della costante di gravità g per la densità del liquido per l’altezza che esso raggiunge all’interno del recipiente:
p = g ⋅ d ⋅ h
--> h = p / (g ⋅ d) = 5.000 / (9,81 ⋅ 1.000) = 0,5 m
dove:
p = 0,05 (bar) ⋅ 100.000 = 5.000 Pa <--- E' la pressione minima di funzionamento della elettrovalvola dichiarata dal produttore espressa in Pascal)
g = 9,81 <--- E' la costante di gravità
d= 1.000 Kg/m3 <--- E' la densità dell'acqua
-------------------------------------------------------------------------------------------
Dalla cisterna il sistema dei tubi può essere schematizzato secondo questa figura, in cui sono rappresentate le varie diramazioni dal tubo principale che arriveranno ai vari vasi e porteranno l'acqua tramite i gocciolatori o i fori ricavati sui microtubi.
- (A) 1 tubo in polietilene (PE) bassa densità da 20 mm (di diametro)
che si svilupperà in altezza e porterà l'acqua all'ingresso dell'elettrovalvola. Lunghezza (> 50 cm) = 80 cm
- (B) 1 tubo PE da 16 mm
che servirà da linea principale per il nostro impianto di irrigazione. Lunghezza = quella necessaria ad attraversare il balcone o la zona interessata dai vasi.
- (C) Dei tubi capillari da 4-6 mm
che avranno il compito di linee di derivazione per portare l'acqua vicino alle radici delle piante. Si possono acquistare in rotoli di diverse metrature (15 metri sono più che sufficienti per avere un po' di scorta).
In base a questa tabellina (ulteriori approfondimenti sul blog di mondoirrigazione e sul sito claber) ho verificato indicativamente che le tubazioni scelte fossero corrette:
| Pollici | Diametro tubo | Portata (litri / minuto) |
| 1/4" | (4-6 mm) | 1,65 |
| 1/2" | 16 | 15 |
| 5/8" | 20 | 25 |
| 3/4" | 25 | 45 |
| 1" | 32 | 75 |
| n.linee | 4 | |
| lunghezza linea (m) | 1 | |
| portata gocciolatori (l/h) | 6 | |
| distanza gocciolatori (cm) | 20 | |
| n. gocciolatori / metro | 5 | |
| consumo / metro | 30 | |
| consumo linea (l/h) | 30 | |
| consumo linea (l/min) | 0,50 | <1,65 |
| consumo totale linee (l/min) | 2,00 | <15 |
| capacità cisterna (l) | 30 | |
| n. giorni autonomia (innaffiatura 1 min / giorno) | 15 |
I calcoli mostrati sopra sono empirici e basati su tabelline di riferimento. I calcoli esatti richiederebbero formule complesse in funzione di altri parametri (pressione di funzionamento, ecc.) che esulerebbero dagli obiettivi di realizzare un semplice impianto di irrigazione per un balcone...
Sono necessari anche i seguenti raccordi filettati e a compressione:
Questi comodi rubinettini Claber li ho inseriti per innestare i tubi capillari al tubo principale:
Seppur non indispensabile, è consigliabile usare la fustella per fare i fori che vedremo di seguito, in modo da averli tutti della sezione corretta e senza sbavature, così da evitare il più possibile perdite d'acqua durante il funzionamento normale.
Fustella Claber per effettuare i fori per l'innesto dei piccoli rubinetti:
Io l'ho acquistato da Leroy Merlin insieme ai tubi PE da 16 e 20 mm che è possibile acquistare al metro.
Scelta del microcontrollore e del driver per l'alimentazione dell'elettrovalvola
Sebbene lo studio iniziale sia stato fatto con scheda Arduino, la scelta del microcontrollore è ricaduta su una scheda compatibile WeMos D1 Mini (che di seguito chiameremo semplicemente D1 Mini) della Az-Delivery acquistabile su Amazon.
La scheda è basata su microcontrollore (MCU) ESP8266-12E, è programmabile e alimentabile con micro-USB, è dotata di WiFi integrato e più orientata a progetti IoT.
Queste schede sono programmabili come dicevo con la stessa IDE di Arduino.
Servirà inoltre poi un "ponte ad H" (o H-Bridge) in modo da poter variare la direzione della tensione ai capi del solenoide dell'elettrovalvola per permetterne la chiusura/apertura.
Come ponte ad H ho scelto uno basato sull'integrato TB6612FNG, prodotto dalla Toshiba, normalmente usato per il controllo di motori in DC per impostare il verso di rotazione e velocità.
E' acquistabile su Amazon:
L'alternativa era usare il ponte ad H L293D di cui già disponevo, presente ad esempio nello starter Kit di Arduino, basato su BJT, invece che MOSFET, che però ha una più elevata caduta di tensione interna ed è meno adatto a comandare solenoidi da 9V (sperimentato).
Di seguito, quando parleremo di programmazione, approfondiremo il tema dell'utilizzo del motor driver nel nostro progetto.
N.B.: normalmente i kit contenenti queste schede (motor driver, D1 Mini, ecc.) vengono fornite con i PIN non saldati in modo da permettere un posizionamento più flessibile sulle breadboard o eventualmente su schede millefori o PCB. La saldatura è semplice, ma se non disponete a casa del saldatore, potete optare in fase di acquisto su kit in cui i PIN siano già saldati.
Infine occorre procurarsi:
- un led e una resistenza da 200 / 220 ohm in modo da verificare visivamente l'attivazione dell'irrigazione da parte della scheda e il comando ricevuto da Alexa,
- una breadboard per effettuare più comodamente i collegamenti elettrici e il pozionamento dei componenti elettronici.
- cavetti jumper per effettuare i collegamenti
2. Assemblaggio dell'impianto
Anche in questo caso, occorre agire su più livelli:
- Effettuare i collegameni idraulici
- Effettuare i collegamenti elettrici
- Programmare il modulo ESP8266
- Collaudo e test finali
Effettuare i collegamenti idraulici
In generale è consigliabile avvolgere con nastro in teflon gli elementi
filettati in modo da evitare perdite d'acqua. Ci sono già diversi tutorial in internet che spiegano come applicare il nastro di teflon per cui non mi dilungo su questo tema.
Partendo dalla cisterna si segue il seguente schema
Infine si usano i tubi più sottili tagliati alla lunghezza necessaria
per raggiungere e attraversare i vasi. Nel mio caso ho creato 4 sezioni da
1,5 metri di tubo capillare così da avere un po' di margine per raggiungere le parti più alte della fioriera.
Si effettuano dei fori sul tubo da 16 con la fustella in corrispondenza alle distanze tra i vasi e si applica ad ognuno di essi un'estremità del piccolo rubinetto.
All'altra estremità del rubinetto si inserisce il tubo capillare.
Ho trovato utile l'utilizzo di questi rubinettini in quanto così è
possibile eventualmente isolare una linea di irrigazione dal resto
dell'impianto semplicemente agendo sulla valvolina arancione.
Si fa salire il tubicino fino a raggiungere a mo' di serpentina tutte le piante di
ciascuna fila da annaffiare.
Si chiude con un tappo da 4-6 mm ciascuna sezione di filo creato.
Infine occorre effettuare dei buchi, utilizzando sempre la fustella, alle distanze desiderate sul tubicino che passa tra le
piante.
In alternativa si può pensare di applicare dei gocciolatori o
microirrigatori in modo da limitare ancor di più il consumo d'acqua e avere
un flusso più diretto e omogeneo.
Io non ho ancora applicato dei veri e propri gocciolatori perchè ho ancora
dubbi su quali modelli sarebbero adatti allo scopo, visto che leggendo i
dati tecnici dei gocciolatori in commercio è richiesta una pressione di 0,5
bar che non è disponibile in un impianto in cui la pressione è indotta dalla
gravità. Si accettano suggerimenti... Probabilmente farò delle prove in futuro.
In ogni caso effettuando dei forellini, l'obiettivo di bagnare è
raggiunto.
Effettuare i collegamenti elettrici
Innanzitutto occorre effettuare i collegamenti come nello schema
descritto sotto tra il D1 Mini e il Driver del solenoide (Motor
Driver in figura). Solo al termine collegare la batteria da 9V. Nello schema è anche
presente un LED collegato tramite una resistenza da 220 ohm di cui
parleremo nel punto successivo.
Significato dei vari PIN del Motor Driver:
- A01 e A02 fanno parte del circuito di potenza e sono le connessioni che vanno al solenoide dell'elettrovalvola. A seconda di chi riceverà la tensione, la tensione applicata sarà positiva o negativa (+/- 9V).
- AIN1 e AIN2 fanno parte del circuito logico e determinano la direzione su cui si muoverà il nucleo del solenoide (apertura/chiusura dell'elettrovalvola) a seconda dei valori Alto/Basso (3,3 V / 0 V) dei PIN D1 e D2 in uscita dal modulo ESP8266 e che chiameremo Control PIN.
- STBY è il PIN Stand-By. Fa parte sempre del circuito logico ed è pilotato dalla scheda D1 Mini con il PIN D5. Il PIN STBY deve essere portato a livello ALTO affinche il driver si attivi.
- PWMA, che chiameremo Enable PIN lato D1 Mini, nel controllo di un motore servirebbe per variarne la velocità con tecnica Pulse-Width Modulation. A noi interessa velocità 0 o massima, per cui può essere istruito con un output PIN analogico al valore 0 o 3,3 V (corrispondente al valore massimo PWM 1023) impostato sul D6.
Enable PIN deve essere portato ad uno stato basso una volta completato l'operazione di apertura o chiusura dell'elettrovalvola: va visto come la modalità per fornire l'impulso di attivazione al solenoide (in apertura o chiusura). Il solenoide non è un motore che deve continuare a ruotare, ma deve solo spostare un nucleo di ferro, e quindi lo spostamento è infinitesimo: nel mio programma ho impostato un impulso di 20 ms (millisecondi).
- VCC è la tensione di alimentazione del circuito logico del driver. Può variare da 2,7 a 5,5 V, per cui per alimentarlo basta collegare l'uscita 3,3 V del D1 Mini al PIN VCC del driver.
- VM è la tensione di alimentazione del solenoide dell'elettrovalvola. Va collegata al polo positivo di una batteria da 9V, mentre il polo negativo va collegato a Ground (GND), così come il PIN GND del driver e del microcontrollore.
Programmare il modulo ESP8266
Come dicevo all'inizio, ho scelto un microcontrollore programmabile come
Arduino ma con Wifi integrato in modo da renderlo comandabile dall'esterno e
in particolare con Alexa.
Punto di partenza è che l'IDE di Arduino sia in grado di interfacciarsi con
il modulo ESP8266, in rete ci sono già tante informazioni in merito per fare questo step preliminare, per
esempio qui.
Dividiamo in due macroparti il programma:
- Logica di comando dell'elettrovalvola. Vedremo come il modulo sia in grado di accendere l'elettrovalvola, attendere il periodo dell'innaffiatura e quindi spegnerla nuovamente (ricordiamo che l'elettrovalvola è bistabile e quindi va spenta).
- Integrazione comandi vocali e implementazione routine Alexa. Vedremo come accendere e spegnere l'impianto con comandi vocali o con app Alexa e come implementare routine Alexa in modo ad esempio da programmare l'innaffiatura ad un certo orario ogni giorno.
Logica di comando dell'elettrovalvola
In questa tabellina sono quindi ricapitolati i valori di uscita del
microcontrollore necessari per provocare l'effetto desiderato
sull'elettrovalvola:
Integrazione comandi vocali e implementazione routine Alexa
In rete ci sono già esempi di integrazione Alexa con ESP8266 ad esempio per comandare un relè collegato a delle lampadine.
Ho trovato molto utile questo articolo di Rui Santos che vi invito a leggere per approfondimenti e che ho utilizzato come base di partenza e poi modificato per rendere il codice adatto a comandare un'elettrovalvola. Nel contesto dell'irrigazione infatti ci sono alcune peculiarità che sono state implementate.
Chiameremo innanzitutto "INNAFFIATORE" il dispositivo D1 Mini riconosciuto da Alexa.
Abbiamo visto come il microcontrollore WeMos D1 Mini basato su ESP8266
sia in grado di pilotare l'elettrovalvola bistabile grazie sostanzialmente
a due gruppi univoci di stati delle uscite digitali del
microcontrollore (Output PIN).
Essendo due i gruppi di stati, impostiamo tutta la logica di integrazione con
Alexa in maniera tale che il pilota sia un ulteriore PIN il cui stato alto o basso
sia comandato da Alexa.
A questo PIN comandato da Alexa associeremo un LED che sarà quindi acceso e spento quando riceverà dei comandi vocali per il dispositivo "INNAFFIATORE" .
E' lo stesso principio del relè con le lampadine descritto nel tutorial originale, solo che al suo posto
abbiamo un LED da "accendere" per un tempo
limitato...
Inoltre al posto dei GPIO PIN del ESP8266 nativo, abbiamo i PIN del
modulo D1 Mini. Per approfondire le corrispondenze tra i relativi PIN
potete far riferimento al documento allegato.
Ho modificato il codice in questo modo:
- Viene comandato sostanzialmente il LED sulla breadboard e gestito il relativo stato (Acceso/Spento) sulla base del
comando ricevuto da Alexa
- Nel loop principale, grazie al controllo dello stato di questo LED
vengono eseguite le routine di avvio e interruzione dell'innaffiatura
- I due stati del LED sono dunque tradotti nella coppia di quattro stati
di cui sopra del driver a fronte del quale l'elettrovalvola si accende/spegne
- Impostazione di un time-out, ovvero un periodo di fine irrigazione che varrà a prescindere dal fatto
che qualcuno dica "Alexa, spegni INNAFFIATORE!", giusto per evitare di svuotare la tanica se ce ne si
dimentica... :-)
E' stata usata la libreria
FauxmoESP che contiene il protocollo necessario a comandare schede basate su ESP8266 / ESP32 da dispositivi Alexa come Amazon Echo Dot come se fossero luci Philips Hue.
Richiede come prerequisito l'installazione di ESPAsyncTCP per la corretta gestione delle connessioni TCP (Async HTTP e
WebSocket Server).
- Download FauxmoESP
- Rinomina la cartella estratta lasciando solo la prima parte del nome
(prima del codice numerico): xoseperez-fauxmoesp
- Sposta la cartella all'interno della cartella libraries nella
directory di installazione della IDE di Arduino
- Download ESPAsyncTCP
- Come prima otterrai un file zip ESPAsyncTCP-master.zip di cui va fatto l'unzip.
- Rinomina la cartella estratta lasciando solo la prima parte del nome: ESPAsyncTCP
- Analogamente a prima, sposta la cartella all'interno della cartella libraries nella directory di installazione della IDE di Arduino
Ora potrai aprire la IDE di Arduino e procedere alla programmazione
usando il codice fornito di seguito.
Prima di fare l'upload sulla scheda, effettuare le personalizzazioni descritte in seguito.
/*
Rui Santos
Original Project from http://randomnerdtutorials.com
Danilo Vaccarella
Modified in order to control a Latching Solenoid Valve from Alexa - May 2020
*/
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include "fauxmoESP.h"
#define LED_PIN D7
#define SERIAL_BAUDRATE 115200
#define WIFI_SSID "OWN WIFI SSID"
#define WIFI_PASS "OWN WIFI PASSWORD"
#define INNAFFIATORE "INNAFFIATORE"
fauxmoESP fauxmo;
// Wi-Fi Connection
const int controlPin1 = D1; // connected to pin AIN1 on the H-bridge to drive opening of the solenoid
const int controlPin2 = D2; // connected to pin AIN2 on the H-bridge to drive closing of the solenoid
const int standbyPin = D5; // connected to pin STBY on the H-bridge to deactivate stand-by
const int enablePin = D6; //connected to PWMA on the H-bridge to control the speed (PWM) (0: stop, 1023 enabled completely)
const int impulseTimeActiv = 20; //durata dell'impulso di attivazione del solenoide bistabile (20 default)
const int impulseTimeDeact = 20; //durata dell'impulso di disattivazione del solenoide bistabile (20 default)
const int irrigationTime = 30000; //periodo tra attivazione e disattivazione del solenoide --> durante questo tempo l'irrigatore bagna
int LED_status = 0;
int stoirrigando = 0;
int t = 0;
void wifiSetup() {
// Set WIFI module to STA mode
WiFi.mode(WIFI_STA);
// Connect
Serial.printf("[WIFI] Connecting to %s ", WIFI_SSID);
WiFi.begin(WIFI_SSID, WIFI_PASS);
// Wait
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(100);
}
Serial.println();
// Connected!
Serial.printf("[WIFI] STATION Mode, SSID: %s, IP address: %s\n", WiFi.SSID().c_str(), WiFi.localIP().toString().c_str());
}
void Irriga() {
stoirrigando = 1;
t = 0;
Serial.print("[Irriga] Sto irrigando (0=NO; 1=SI) ");
Serial.println(stoirrigando);
//impulso di attivazione
digitalWrite(standbyPin, HIGH);
digitalWrite(controlPin1, HIGH);
digitalWrite(controlPin2, LOW);
analogWrite(enablePin, 1023);
delay(impulseTimeActiv);
analogWrite(enablePin, 0);
digitalWrite(standbyPin, LOW);
while (t <= irrigationTime) {
Serial.print(".");
Serial.print(t);
if (digitalRead(LED_PIN) == 0) { //se lo stato del LED cambia l'innaffiatore si spegne
t = irrigationTime;
}
delay(1000);
t = t + 1000;
}
// impulso di disattivazione
digitalWrite(standbyPin, HIGH);
digitalWrite(controlPin1, LOW);
digitalWrite(controlPin2, HIGH);
analogWrite(enablePin, 1023);
delay(impulseTimeDeact);
analogWrite(enablePin, 0);
digitalWrite(standbyPin, LOW);
digitalWrite(LED_PIN, LOW);
stoirrigando = 0;
t = 0;
Serial.print("[Irriga] Sto irrigando (0=NO; 1=SI) ");
Serial.println(stoirrigando);
}
void SpegniIrrigatore() {
if (stoirrigando == 1) {
Serial.print("[SpegniIrrigatore] Sto irrigando (0=NO; 1=SI) ");
Serial.println(stoirrigando);
digitalWrite(standbyPin, HIGH);
digitalWrite(controlPin1, LOW);
digitalWrite(controlPin2, HIGH);
analogWrite(enablePin, 1023);
delay(impulseTimeDeact);
analogWrite(enablePin, 0);
digitalWrite(standbyPin, LOW);
digitalWrite(LED_PIN, LOW);
stoirrigando = 0;
Serial.print("[SpegniIrrigatore] Sto irrigando (0=NO; 1=SI) ");
Serial.println(stoirrigando);
}
}
void setup() {
// Init serial port and clean garbage
Serial.begin(SERIAL_BAUDRATE);
Serial.println();
// Wi-Fi connection
wifiSetup();
// Solenoid valve
pinMode(controlPin1, OUTPUT);
pinMode(controlPin2, OUTPUT);
pinMode(enablePin, OUTPUT);
pinMode(standbyPin, OUTPUT);
digitalWrite(standbyPin, LOW);
analogWrite(enablePin, 0);
digitalWrite(controlPin1, LOW);
digitalWrite(controlPin2, LOW);
// LED
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
// By default, fauxmoESP creates it's own webserver on the defined port
// The TCP port must be 80 for gen3 devices (default is 1901)
// This has to be done before the call to enable()
fauxmo.createServer(true); // not needed, this is the default value
fauxmo.setPort(80); // This is required for gen3 devices
// You have to call enable(true) once you have a WiFi connection
// You can enable or disable the library at any moment
// Disabling it will prevent the devices from being discovered and switched
fauxmo.enable(true);
// You can use different ways to invoke alexa to modify the devices state:
// "Alexa, turn lamp two on"
// Add virtual devices
fauxmo.addDevice(INNAFFIATORE);
fauxmo.onSetState([](unsigned char device_id, const char * device_name, bool state, unsigned char value) {
// Callback when a command from Alexa is received.
// You can use device_id or device_name to choose the element to perform an action onto (relay, LED,...)
// State is a boolean (ON/OFF) and value a number from 0 to 255 (if you say "set kitchen light to 50%" you will receive a 128 here).
// Just remember not to delay too much here, this is a callback, exit as soon as possible.
// If you have to do something more involved here set a flag and process it in your main loop.
Serial.printf("[MAIN] Device #%d (%s) state: %s value: %d\n", device_id, device_name, state ? "ON" : "OFF", value);
if ( (strcmp(device_name, INNAFFIATORE) == 0) ) {
// this just sets a variable that the main loop() does something about
Serial.println("INNAFFIATORE switched by Alexa");
if (state) {
digitalWrite(LED_PIN, HIGH);
//Irriga();
} else {
digitalWrite(LED_PIN, LOW);
//SpegniIrrigatore();
}
}
});
}
void loop() {
// fauxmoESP uses an async TCP server but a sync UDP server
// Therefore, we have to manually poll for UDP packets
fauxmo.handle();
static unsigned long last = millis();
if (millis() - last > 5000) {
last = millis();
Serial.printf("[MAIN] Free heap: %d bytes\n", ESP.getFreeHeap());
Serial.print("[MAIN] Il LED_PIN è ");
Serial.println(digitalRead(LED_PIN));
LED_status = digitalRead(LED_PIN);
if (LED_status == 1) {
Irriga();
} else {
SpegniIrrigatore();
}
Serial.print("[MAIN] Sto irrigando (0=NO; 1=SI) ");
Serial.println(stoirrigando);
}
}
// If your device state is changed by any other means (MQTT, physical button,...)
// you can instruct the library to report the new state to Alexa on next request:
// fauxmo.setState(ID_YELLOW, true, 255);
Occorre quindi personalizzarlo con i
dati della propria rete WiFi
#define WIFI_SSID "INSERIRE IL SSID DELLA PROPRIA RETE WIFI"
#define WIFI_PASS "INSERIRE LA PASSWORD DELLA PROPRIA RETE WIFI"
e verificare che i PIN utilizzati sulla scheda siano gli stessi e
eventualmente modificarli.
Inoltre se l'elettrovalvola è diversa da quella
da me usata, potrebbe essere necessario testare il valore della durata
dell'impulso (nel mio caso 20 ms sono sufficienti).
Ovviamente il tempo di irrigazione dipende dalle vostre
esigenze, in questo caso ho impostato 30 sec.
Di seguito il riepilogo dei parametri da verificare:
Infine è possibile configurare il dispositivo "INNAFFIATORE" nell'app
alexa.
E' possibile configurare nell'app Alexa le routine di innaffiatura, in
modo che ad intervalli programmati parta il comando di accensione
innaffiatore.
E' possibile, oltre che comodo, impostare nella routine un messaggio audio
proveniente dall'echo dot di Alexa che ci ricordi "Innaffiatura in corso" nel momento in cui il programma parte all'orario stabilito.
Ecco quindi realizzato il nostro timer o
programmatore gestito da Alexa per la nostra innaffiatura
quotidiana :-)
Collaudo e test finali
A questo punto in questo breve video si vede all'opera l'impianto creato.
3. Conclusioni e prossimi passi
Mi piacerebbe capire se può esservi utile questa guida e quindi vi invito a
commentare con suggerimenti o casi pratici realizzati.
E' mia intenzione realizzare una seconda parte dell'articolo in cui al
posto di Alexa e dell'alimentazione da rete elettrica di casa, l'impianto
funzioni totalmente in maniera autonoma, ovvero a batteria.
Buon lavoro! ;-)
Commenti
Posta un commento