Orto Botanico

In questo post parleremo di come si costruisce un irrigazione automatica per il nostro orto e per le nostre fioriere.

Il progetto si basa su Arduino.

Per il progetto useremo i seguenti materiali:
- Arduino Uno
- Arduino Yun
- Shield  V2 Solar Charger 
- 2 moduli Bluetooth HC-05
- 2 Mini Breadboard 
- Sensore di umidità e temepratura DHT11
- Relé
- Pannello solare 5W 7500-SOLPAN1W
- Batteria da 9V
- Batteria polimeri di litio 3,7V 500MA

Tutti i prodotti sono acquistabili sul sito www.futurashop.it

Per la realizzazione del sistema di irrigazione abbiamo utilizzato materiale della Claber per l'irrigazione a goccia reperibile facilmente in qualsiasi negozio di giardinaggio quali:
- Elettrovalvola 9V
- Tubo collettore
- Rubinetti
- Tappi di chiusura
- Presa a due vie 

Per quanto riguarda la parte di stampa 3D abbiamo realizzato una scatola che contenesse le parte elettroniche http://www.thingiverse.com/thing:734474 e l'Arduino e una casetta in cui alloggiate la scatola di Arduino così da tenerla lontana dalla pioggia http://www.thingiverse.com/thing:734480. 
Inoltre abbiamo realizzato dei supporti da muro per l'elettrovalvola.

Per cominciare abbiamo costruito il sistema di irrigazione con il materiale Claber creando 3 circuiti differenti di irrigazione tramite l'utilizzo di rubinetti uno per l'orto vaso e due per due fioriere, infine li abbiamo collegati tutti al circuito primario. 
Ciascun circuito è collegato al circuito primario e all'elettrovalvola che permetterà l'uscita di acqua solo quando l'Arduino la aprirà.

Nelle foto qui sotto trovate il circuito costruito con il materiale Claber:

Nella foto qui a lato potete vedere il circuito numero 2 
che serve per irrigare l'orto.

In questa foto vedere il gocciolatore e il tappo di chiusura del circuito numero 2 .

In queste foto potete vedere i rubinetti di apertura del circuito che permettono di irrigare l'orto o il vaso anche in momenti differenti.

Nella foto a lato si vede l'elettrovalvola collegata a un circuito
per vederne il funzionamento.

Dopo aver realizzato il sistema di irrigazione, si può procedere al circuito elettronico.

La scheda Arduino Uno ci permetterà di rilevare la temperatura atmosferica, l'umidità dell'aria e riceverà i comandi dalla scheda Arduino Yun, installata in casa, su quando attivare l'elettrovalvola per irrigare i vasi.

Abbiamo collegato l'Arduino Uno e lo Shield Solar Charger. Per motivi di spazio abbiamo collocato la mini breadboard sulla shield Solar Charger così da mantenere le dimensioni della scatola 3D ridotte.

Sulla mini breadboard abbiamo messo il sensore di umidità e temperatura, il modulo HC-05 e le resistenze per abbassare la tensione da 5V a 3.3V, tensione a cui lavora il modulo bluetooth.  Infine abbiamo collegato il Relè che controllerà l'elettrovalvola alla scheda Arduino.

Vediamo ora la scheda Yun che, oltre a inviare il comando di apertura dell'elettrovalvola, raccoglierà i dati di temperatura e umidità per inviarli alla piattaforma Emon CMS dove sarà possibile osservare l'andamento di questi valori nell'arco della giornata.

Di seguito gli sketch da caricare su Arduino. 

Arduino Uno (Esterno)

#include <SoftwareSerial.h>

#include <dht.h>

dht DHT;

#define DHT11_PIN 5

const int sensorPowerLed = 12;

const int gLedPin = 13;

const int gRxPin = 10;

const int gTxPin = 11;

const int analogInPin = A0;  // Analog input pin that the VBAT pin is attached to

const int powPin = 6;  // power relè water

const int owPin = 7;  // control relè to open water

const int gIsMaster = 1;

int BatteryValue = 0;        // value read from the VBAT pin

float outputValue = 0;        // variable for voltage calculation

SoftwareSerial BTSerial(gRxPin, gTxPin);

String inData;

unsigned long start;

void setup()

{

  BTSerial.begin(9600);

  pinMode(gLedPin, OUTPUT);

  pinMode(powPin, OUTPUT);

  pinMode(owPin, OUTPUT);

  pinMode(sensorPowerLed, OUTPUT);

  Serial.begin(9600);

  Serial.println("bt2bt HC module - version a");

}

void loop()

{

  if (1 == gIsMaster) {

    if (millis() > start + 10000) {

      start = millis();

      digitalWrite(sensorPowerLed, HIGH);

      int chk = DHT.read11(DHT11_PIN);

      Serial.print(DHT.humidity, 1);

      Serial.print(",");

      Serial.println(DHT.temperature, 1);

      char tempString[10];  //  Hold The Convert Data

      dtostrf(DHT.temperature, 2, 2, tempString);

      // dtostrf( [doubleVar] , [sizeBeforePoint] , [sizeAfterPoint] , [WhereToStoreIt] )

      char tempHumidity[10];  //  Hold The Convert Data

      dtostrf(DHT.humidity, 2, 2, tempHumidity);

      // read the analog in value:

      BatteryValue = analogRead(analogInPin);

      // Calculate the battery voltage value

      outputValue = (float(BatteryValue) * 5) / 1023 * 2;

      // print the results to the serial monitor:

      Serial.print("Analog value = " );

      Serial.print(BatteryValue);

      Serial.print("\t voltage = ");

      Serial.print(outputValue);

      Serial.println("V \n");

      BTSerial.print("temp:" + String(tempString) + ",hum:" + String(tempHumidity) + ",battery:" + outputValue + "\n");

    }

    // Receive commands

    if (BTSerial.available()) {

      char received = BTSerial.read();

      //Serial.println(received);

      if (received != '\n')

      {

        inData += received;

      }

      // Process message when new line character is recieved

      else

      {

        Serial.println();

        Serial.print("Arduino Received: ");

        Serial.println(inData);

        Serial.println();

        if (inData == "ow") {

          digitalWrite(powPin, HIGH);

          digitalWrite(owPin, HIGH);

        } else if (inData == "cw") {

          digitalWrite(owPin, LOW);

          digitalWrite(powPin, LOW);

        }

        inData = ""; // Clear recieved buffer

      }

    }

  }

}

Arduino Yun  

#include "Bridge.h"

#include "HttpClient.h"

#include "SoftwareSerial.h"

int gLedPin = 13;

int gRxPin = 10;

int gTxPin = 11;

int gIsMaster = 0;

bool openWater = 0;

SoftwareSerial BTSerial(gRxPin, gTxPin);

String inData;

String apikey = "0f7377ae6704ddefd0d58cf77efb2ecc";

unsigned long start;

void setup()

{

  BTSerial.begin(9600);

  pinMode(gLedPin, OUTPUT);

  Bridge.begin();

  Serial.begin(9600);

  Serial.println("Home Controller");

}

void loop()

{

  if (BTSerial.available()) {

    char received = BTSerial.read();

    //Serial.println(received);

    if (received != '\n')

    {

      inData += received;

    }

    // Process message when new line character is recieved

    else

    {

      Serial.println();

      Serial.print("Arduino Received: ");

      Serial.println(inData);

      Serial.println();

      HttpClient client;

      String updateURL =  "http://emoncms.org/input/post.json?json={" + inData + "}&apikey=" + apikey;

      Serial.println(updateURL);

      Serial.println();

      Serial.flush();

      // Make a HTTP GET request to the API:

      client.get(updateURL);

      while (client.available()) {

        char c = client.read();

        Serial.print(c);

      }

      Serial.println();

      Serial.flush();

      inData = ""; // Clear recieved buffer

    }

  }

  // Send request to open water

  if (millis() > start + 30000) {

    start = millis();

    if (openWater) {

      openWater = 0;

      Serial.println("Close water");

      BTSerial.print("cw\n");

    } else {

      openWater = 1;

      Serial.println("Open water");

      BTSerial.print("ow\n");

    }

  }

}

Sensore di distanza HC-SR04

Con un sensore HC-SR04 e un buzzer, che troviamo nello starter kit di Arduino, possiamo simulare un sensore di parcheggio.
Per prima cosa dobbiamo effettuare i collegamenti fra arduino, il sensore HC-SR04 e il buzzer. Mettiamo, quindi, su una breadboard il sensore HC-SR04 facendo attenzione a rivolgerlo verso l'esterno e non verso Arduino e accanto il buzzer.
Nello schema qui sotto potete vedere i colegamenti:

Una volta effettuati i collegamenti possiamo procedere a caricare il seguente sketch su Arduino:

int triggerPort = 7;
int echoPort = 8;
int buzzer = 9;
unsigned long time;
unsigned long lampeggio_time;
unsigned long pausa_time;
void setup() {
pinMode( triggerPort, OUTPUT );
pinMode( echoPort, INPUT );
pinMode( buzzer, OUTPUT );
Serial.begin( 9600 );
Serial.println( "Sensore ultrasuoni: ");
}
void loop() {

digitalWrite( triggerPort, LOW );

digitalWrite( triggerPort, HIGH );
delayMicroseconds( 10 );
digitalWrite( triggerPort, LOW );
long duration = pulseIn( echoPort, HIGH );
long r = 0.034 * duration / 2;
Serial.print( "durata: " );
Serial.print( duration );
Serial.print( " , " );
Serial.print( "distanza: " );
if( duration > 38000 ) Serial.println( "fuori portata");
else { Serial.print( r ); Serial.println( "cm" );}
if( r > 3 && r <= 200){
delay(r*10);
digitalWrite(buzzer, HIGH);
delay(r*10); }
if( r <= 3){
digitalWrite(buzzer, HIGH);
delay(1000);}
digitalWrite(buzzer, LOW);
delay(10);

}

Di seguito alcune foto del progetto:

Moduli Bluetooth HC-05

Moduli Bluetooth HC-05

Se vogliamo far comunicare 2 schede Arduino con moduli Bluetooth è necessario configurare i moduli in modo che possano trasmettere dati tra loro.

In particolare è necessario configurare uno di questi come MASTER e l'altro come SLAVE e per farlo possiamo utilizzare i comandi AT.

Vediamo innanzitutto come collegare il modulo bluetooth ad Arduino per metterlo nella modalità programmazione. Li collegheremo uno alla volta e li imposteremo uno come modulo MASTER e l’altro SLAVE.

Come si vede dall'immagine abbiamo connesso i PIN RX e TX ai pin 11 e 10 di Arduino in modo da lasciare liberi i PIN RX e TX di Arduino per utilizzare la connessione seriale con il PC. Per fare ciò abbiamo utilizzato la libreria SoftwareSerial che ci permette di utilizzare i pin 10 e 11 per la comunicazione con il modulo bluetooth.

Abbiamo quindi collegato il pin KEY del modulo bluetooth al pin 9 di Arduino.

Colleghiamo il PIN GND del modulo bluetooth con il PIN GND di Arduino, mentre lasciamo per un attimo scollegato il PIN Vcc.

Carichiamo quindi lo sketch seguente sul nostro Arduino.

#include <SoftwareSerial.h>

SoftwareSerial BTSerial(10, 11); // RX | TX

void setup()

{

 pinMode(9, OUTPUT);  // this pin will pull the HC-05 pin 34 (key pin) HIGH to switch module to AT mode

 digitalWrite(9, HIGH);

 Serial.begin(9600);

 Serial.println("Enter AT commands:");

 BTSerial.begin(38400);  // HC-05 default speed in AT command more

}

void loop()

{

 // Keep reading from HC-05 and send to Arduino Serial Monitor

 if (BTSerial.available())

Serial.write(BTSerial.read());

 // Keep reading from Arduino Serial Monitor and send to HC-05

 if (Serial.available())

BTSerial.write(Serial.read());

}

Questo sketch ci permette di eseguire dei comandi AT sul modulo bluetooth e leggere le risposte.

Una volta caricato lo sketch su Arduino eseguiamo dei comandi AT per impostare il primo dei 2 moduli bluetooth come SLAVE:

• apriamo il monitor seriale del programma Arduino
• assicuriamoci che sia impostato il valore “Both NL & CR” e la velocità di connessione a 9600
• quando resettiamo Arduino (aprendo il monitr seriale Arduino si resetta), dovremmo vedere apparire sul monitor seriale la scritta: “Enter AT commands:”
• connettiamo il PIN Vcc del modulo bluetooth al PIN 5Vdi Arduino, dovremmo vedere il led di Arduino lampeggiare lentamente (ogni circa 2 secondi)
• scriviamo nel monitor seriale il comando AT e premiamo INVIO (bottone Send del monitor seriale)
• scriviamo quindi il comando AT+ROLE=0; questo configurerà il modulo bluetooth come SLAVE. Per verificare il comando appena eseguito digitiamo AT+ROLE? e dovremmo vedere restituito: +ROLE:0
• ora eseguiamo il comando AT+BIND= e premiamo INVIO. In questo modo rimuoviamo qualunque binding esistente. Per verificare eseguiamo il comando AT+BIND? e dovremmo ottenere: +BIND:0:0:0
• eseguiamo quindi il comando AT+ADDR? per ottenere l’indirizzo MAC del nostro modulo (avrà la forma 2837:3:92); segnamoci questo indirizzo perchè ci servirà nella programmazione del modulo master

Scolleghiamo il primo modulo bluetooth senza togliere tutti i collegamenti su Arduino in quanto ci serviranno per programmare il secondo modulo.

Per impostare il secondo modulo bluetooth eseguiamo invece i seguenti comandi:

• apriamo il monitor seriale del programma Arduino
• assicuriamoci che sia impostato il valore “Both NL & CR” e la velocità di connessione a 9600
• quando resettiamo Arduino (aprendo il monitr seriale Arduino si resetta), dovremmo vedere apparire sul monitor seriale la scritta: “Enter AT commands:”
• connettiamo il PIN Vcc del modulo bluetooth al PIN 5Vdi Arduino, dovremmo vedere il led di Arduino lampeggiare lentamente (ogni circa 2 secondi)
• scriviamo nel monitor seriale il comando AT e premiamo INVIO (bottone Send del monitor seriale)
• scriviamo quindi il comando AT+ROLE=1; questo configurerà il modulo bluetooth come MASTER. Per verificare il comando appena eseguito digitiamo AT+ROLE? e dovremmo vedere restituito: +ROLE:1
• ora eseguiamo il comando AT+BIND=2837,3,92 sostituendo l’indirizzo MAC che abbiamo segnato precedentemente e premiamo INVIO. Questo forzerà il nostro modulo master a connettersi automaticamente all’altro nostro modulo. Eseguendo il comando AT+BIND? dovremmo vedere restituito 2837:3:92.

A questo punto quando accenderemo i 2 moduli questi si connetteranno tra di loro indipendentemente da quale accendiamo per primo. Tutto quello che ti servirà per utilizzarli è aprire una connessione seriale e comunicare attraverso di essa.