Smart Garden System with Android (IoT)

Inspiration

Bagi petani atau pecinta tanaman mungkin tidak asing dengan istilah SMART GARDEN. Ya itu pasti, karena banyak sekali dilingkungan pertanian saat ini mengaplikasikan sistem ini. Pembuatan alat ini terinspirasi dari analisa lapangan yang memungkinkan petani melakukan perawatan kebun secara efisien serta memberikan hasil kebun tetap efektif. Jadi, saya membuat sebuah alat yang yang dapat mengatasi persoalan itu dengan memanfaatkan Mikrokontroller dan rangkaian sensor untuk membantu tugas ini.

How it Work?

Smart Garden adalah sistem pemantauan lingkungan pertanian. Pemantauan meliputi kelembapan tanah, kelembapan udara, suhu tanah, suhu udara dan itensitas cahaya. Selain itu, sistem ini dilengakpi dengan sistem penyiraman secara otomatis berdasarkan data yang diterima dari sensor.

Monitoring

Sistem pemantauan pada alat ini menggunakan aplikasi ThingSpeak pada android dengan library App Inventor dan Arduino Uno untuk menampilkan hasil dari proses sensor kelembaban tanah. Sehingga pengguna bisa lebih mudah dan cepat untuk mengetahui kualitas tanah dengan menggunakan teknologi ThingSpeak dengan aplikasi berbasis IoT (Internet of Thing) layaknya smarthome.

Kelebihan dari dari aplikasi ini memakai library App Inventor voice command berbahasa Indonesia, membuat language model sesuai keinginan pengguna, mudah diakses menggunakan jaringan lokal maupun internet.

Software 

Perangkat lunak yang dibutuhkan adalah sebagai berikut:

1. Android, untuk mengembangkan perangkat lunak dan dapat dijalankan di semua platform dan juga dapat di jalankan pada android.
2. App Inventor, yang menyediakan library pengenalan suara berbasis teknologi Speech Recognition (pengenalan kalimat atau kata) pada perangkat lunak.
3. IDE Arduino (Integrated Developtment Enviroenment), Software processing yang digunakan untuk menulis program kedalam perangkat keras yaitu Arduino. Prosessing sendiri merupakan penggabungan antara bahasa C++ dan Java.
4. Fritzing, adalah software yang digunakan untuk mendeseain pin out pada rangkaian elektronika.
5. EAGLE (Easily Applicable Graphical Layout Editor), merupakan sebuah aplikasi untuk mendesain skematik elektronika maupun PCB (Printed Circuit Board).

Hardware

Adapun perangkat keras yang dibutuhkan dalam pembuatan alat ini diantaranya adalah:

1. Arduino Uno R3
2. Modul Wifi ESP-8266,
3. Sensor YL69,
4. Sensor udara DHT22,
5. Sensor suhu DS18B20,
6. Smarphone,
7. Relay.

Block Diagram

Berikut adalah tahapan-tahapan perancangan alat yang akan dijelaskan pada Diagram berikut ini:

Diagram Block Smart Garden

Berdasarkan blok diagram diatas, dijelaskan bahwa Input dari alat ini adalah:

1. Kelembaban tanah menggunakan sensor YL-69, 
2. Kelembapan udara menggunakan DHT22, 
3. Kelembapan suhu menggunakan DS18B20, dan 
4. Kensor cahaya menggunakan LDR. 
5. Sementara Local Unit pemrosesan datanya menggunakan Arduino uno yang mendapat supply dari AC Adapter. 
6. Dari serangkaian sensor akan mendapatkan output berupa LED, relay, pompa air dan lampu 12 VDC. 
7. Writing Data dan Reading Data pada database ThingSpeak adalah dengan menggunakan modul wifi ESP8266.

Schematic Design

Sebelum membuat rangkaian keseluruhan, akan menjelaskan beberapa rangkaian komponen sensor seperti berikut:

Download: Test_Sensor.fzz

Rangkaian Sensor

Sebelum membuat desain layout PCB menggunakan Software Eagle perlu menganalisa satu persatu dari komponen yang akan digunakan. Dengan rangkaian diatas dapat dilihat perbandingan dari temperature suhu, kelembaban, cahaya dan juga udara. Sehingga dapat menentukan setpoint yang harus digunakan dalam pengaplikasiannya nanti.

Baca:

Cara Mengukur Kelembapan Tanah dengan Arduino

Cara Menggunakan Sensor Suhu DS18B20

Cara Mengakses Sensor Suhu dan Kelembaban Menggunakan DHT11 & DHT22 dengan Arduino  

Sebelum melakukan pengujian sensor yang digunakan, terlebih dahulu harus memiliki library yang harus diinstal pada software arduino IDE.

Library Soil Moisture Sensor
Library DS18B20
Library DHT22

Setelah mendownload dan memasukan ke Arduino IDE, kemudian upload program dibawah ini: 

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
int soilTemp = 0;
//DHT22
#include "DHT.h"
#include 
int pinoDHT = 11;
int tipoDHT =  DHT22;
DHT dht(pinoDHT, tipoDHT); 
int airTemp = 0;
int airHum = 0;
// LDR (Cahaya)
#define ldrPIN 1
int light = 0;
// Kelembapan Tanah
#define soilHumPIN 0
int soilHum = 0;

void setup()
{
  Serial.begin(9600); 
  DS18B20.begin();
  dht.begin();
}
void loop()
{
  readSensors();
  displaySensors();
  delay (10000);
}

void readSensors(void)
{
  airTemp = dht.readTemperature();
  airHum = dht.readHumidity();
  DS18B20.requestTemperatures(); 
  soilTemp = DS18B20.getTempCByIndex(0);
  soilHum = map(analogRead(soilHumPIN),1023,0,0,100);             
  light = map(analogRead(ldrPIN), 1023, 0, 0, 100); 
}
void displaySensors(void)
{
  Serial.print ("airTemp  (oC): ");
  Serial.println (airTemp);
  Serial.print ("airHum    (%): ");
  Serial.println (airHum);
  Serial.print ("soilTemp (oC): ");
  Serial.println (soilTemp);
  Serial.print ("soilHum   (%): ");
  Serial.println (soilHum);
  Serial.print ("light     (%): ");
  Serial.println (light);
  Serial.println ("");
}

Setelah berhasil diupload, buka serial monitor. Maka, akan tampil pada serial monitor seperti gambar berikut ini:

Tampilan Hasil Pengujian Sensor

Setelah merangkai komponen diatas dan mengujinya, selajutnya membuat rangkaian modul wifi ESP-8266, seperti tampak pada gambar berikut ini:

Download: Rangkaian-esp8266.fzz

Rangkaian Esp8266

ESP-01 akan digunakan sebagai Serial Bridge, yang berarti bahwa ESP-01 akan diprogram dengan menggunakan "perintah AT". Yang pertama adalah memastikan bahwa ESP-01 berada pada kecepatan komunikasi Baud Rate yang benar. Biasanya, ESP-01 diprogram dari pabrik dengan 115.200 baud dan pada program harus mengubahnya menjadi 9.600 baudrate.

Untuk menguji apakah ESP-8266 berfungsi adalah dengan memasukkan program berikut: 

#include    
SoftwareSerial esp8266(6,7);
#define speed8266 9600 
void setup() 
{
  esp8266.begin (speed8266); 
  Serial.begin(speed8266);
  Serial.println("ESP8266 Setup test - use AT coomands");
}
void loop() 
{
  while(esp8266.available())
  {
    Serial.write(esp8266.read());
  }
  while(Serial.available())
  {
    esp8266.write(Serial.read());
  }
}

Selanjutnya buka serial monitor dan ketik perintah satu persatu dibawah ini:

*    AT         ==> ESP8266 OK
*    AT+RST     ==> ESP8266 restart OK
*    AT+GMR     ==> ESP8266 SDK version
*    AT+CWMODE? ==> ESP8266 Type
*    AT+CWLAP   ==> ESP8266 access points
*    AT+CIFSR   ==> ESP8266 IP

Dari hasil perintah yang diketikkan diatas akan mendapatkan tampilan serial monitor seperti berikut:

Pengujian ESP pada Serial Monitor

Berikut ini adalah rangkaian keseluruhan system yang telah dirangkai menjadi satu kesatuan:

Download: Rangkaian_keseluruhan.fzz

Rangkaian Keseluruhan

Reading dan Writing sensor yang digunakan dalam pembuatan alat ini menggunakan layanan cloud dari chanel ThingSpeak.com. Oleh karena itu, kode program secara keseluruhan akan dijelaskan diakhir tutorial pada bagian Source Code.

Optional

Setelah selesai merancang dan menganalisa dari masing-masing rangkaian, kamu bisa membuat layout PCB menggunakan software desain PCB seperti Eagle dan protel seperti contoh dibawah ini.

Download Schematic PCB

PCB Print

Software Design

Agar perangkat keras (hardware) yang dirancang bekerja sesuai dengan yang diinginkan dibuatlah suatu kombinasi perintah-perintah dalam bahasa pemrograman sesuai dengan syntax program pada alat yang dirancang.

Berikut akan dijelaskan beberapa langkah pemrograman, diantaranya adalah sebagai berikut: 

A. Account Thingspeak

ThingSpeak memiliki hubungan erat dengan MathWorks.Inc, semua data ThingSpeak dimasukkan ke situs dokumentasi Matlab yang mengharuskan pengguna mendaftar terlebih dahulu disitus ThingSpeak. Pendaftaran login account menggunaan account google. Sebelum memahami perancangan dan analisa, berikut ini adalah tampilan cara kerja dari ThingSpeak

Cara Kerja Thingspeak

Berikut adalah langkah pembuatan account ThingSpeak, langkah pertama yaitu melakukan konfigurasi di situs Thingspeak https://thingspeak.com

Konfigurasi Account

Setelah mendaftar dengan menggunakan account google, selanjutnya adalah mengkonfigurasi email masuk di account gmail, seperti pada gambar berikut:

Verifikasi Account

Selanjutnya adalah membuat channel baru, setiap masing channel berisi field dengan fungsi yang dapat diatur sesuai kebutuhan. Langkahnya adalah: Klik New Channel untuk membuat Channel Data. Isikan field yang diperlukan (satu channel maksimal 8 filed). Isikan nama channel (‘Name’) dan ‘field1’.

Membuat Chanel Baru

Kemudian mengisi field, field ini nantinya akan berisi data sensor yang dikirimkan dari Arduino maupun ESP8266. Setelah selesai mengisi data tekan Save Channel:

Membuat Field Baru

Masing-masing Field digunakan untuk menempatkan data sensor. Berikut ini adalah tampilan dari channel thingspeak yang telah dibuat:

ID Chanel Thingspeak

Untuk mendapatkan Key akses Write data melalui menu API Keys yang ditunjuk di nomor 2 pada gambar diatas kemudian copy key pada bagian Write API Key. Sedangkan Key Read API Keys digunakan untuk membaca data. Channel ID akan digunakan untuk menampilkan data melalui aplikasi android.

B. Aplikasi Android

Perancangan algoritma pemrograman Android ini tidak perlu berhadapan dengan bahasa pemrograman yang rumit. Dengan memanfaatkan App Inventor akan memudahkan untuk merancang sebuah aplikasi android yang nantinya akan digunakan untuk mengakses sistem dari jarak jauh. MIT App Inventor sebenarnya bisa dijalankan secara online maupun offline. Namun, ada perbedaan mendalam antara keduanya, khususnya dalam hal instalasi dan konfigurasi.

Laman MIT App Inventor

Saat pertama kali mengakses MIT App Inventor, pengguna akan diminta untuk login dengan akun Google. Masukkan username dan password akun Google, kemudian akan diarahkan ke halaman permission request yang berisi permintaan izin untuk mengakses beberapa informasi akun Google. Dengan klik Allow, terms of service yang muncul setelahnya dan aplikasi MIT App Inventor akan terbuka.

Setelah berhasil login, user akan langsung dibawa kehalaman persetujuan penggunaan layanan MIT. Kemudian klik “I accept the term of service!”.

Halaman Pernyataan MIT Inventor

Setelah menyetujui perjanjian diatas akan muncul take survey bagi pengguna baru, untuk melewatkan take survey ini bisa langsung klik “take survey latter”  bertujuan untuk mengikuti survey nanti.

Halaman Survei bagi Pengguna Baru

Berikut adalah tampilan awal pembuatan project baru pada app inventor, klik  “Start New Projct” untuk langsung membuatnya. Seperti pada gambar dibawah ini:

Membuat Project Baru

Setelah melakukan langkah diata, kini halaman utama aplikasi MIT App Inventor telah terbuka. Dari sini bisa mulai membuat aplikasi baru dengan meng-klik tombol Start New Project atau melalui menu Projects-Start New Project. Selanjutnya tinggal beri beri nama project yang diinginkan.

Untuk menambahkan komponen bisa mengakses jendela Palette pada sub menu Drawing and Animation. Drag and drop fungsi komponen ke layar smartphone sehingga pada jendela Components muncul satu lagi komponen baru.

Menembah Komponen Baru

Label yang sudah diletakkan pada layer screen kemudian di atur sesuai dengan tampilan gambar diatas. Agar mendapatkan pengaturan rata tengah pada screen dapat datur pada properties Width dengan pilihan fill parent yang ditunjukkan pada nomor 5 seperti gambar diatas. Begitu juga dengan merubah text label bisa dirubah pada properties text yang ditunjukkan pada nomor 6.

Kemudian menambah dan mengatur arrangement dibawah label sebagai tampilan form space status sensor seperti gambar dibawah ini:

Menambah Komponen Arrangement

Arrangement  digunakan untuk tata letak tampilan sensor yang digunakan dalam pembuatan alat ini.

Jendela Komponen

Desain tampilan utama aplikasi telah selesai dibuat, kemudian masuk ke halaman Blocks untuk mulai menyusun program aplikasi yang akan dibuat. Untuk melakukannya, klik tombol Blocks yang ada pada bagian kanan atas interface MIT App Inventor. 

Pendefinisian Status

Komponen blok diatas berfungsi sebagai inisial status pada saat awal app diaktifkan adalah bernilai low/nol. Kemudian menyusun komponen yang tampak seperti pada gambar dibawah ini:

Chanel dan Key Apy ThingSpeak

Kode Chanel diatas didapat dari Account ThngSpeak yang sudah dijelaskan pada pembahasan sebelumnya, Chanel dan Key diatas berfungsi untuk menulis dan membaca sesuai URL Status app inventor dan webserver ThingSpeak.com.

Setelah aplikasi android diatas selesai, download dan instal di Android. Menginstal aplikasi yang telah dibuat pada android dilakukan seperti menginstal aplikasi pada umumnya. Dengan cara klik Build pada dekstop MIT App Inventor, kemudian menyimpan file berekstensi .apk ke dalam komputer. Setelah itu, kirimkan file .apk ke android dan kemudian menginstalnya.

Download: Smart_Garden.aia

Download: Smart_Garden.apk

C. Flowchart

Adapun diagram alir atau flowchart dari perancangan perangkat lunak yang akan dibuat ditunjukkan pada Gambar dibawah ini:

Flowchart Pemrograman

Pada Gambar diatas menunjukkan cara kerja sistem melalui diagram alir. Pertama, program akan melakukan koneksi ke ke jaringan internet, apabila ditemukan, sistem akan langsung melakukan pengumpulan data oleh sensor. Data yang dibaca oleh sensor kemudian akan diproses oleh Arduino Uno untuk dikrimkan ke webserver ThigSpeak. ESP8266 berfungsi sebagai pengirim data input dari sensor untuk ditampilkan pada ThigSpeak dan juga bertanggung jawab untuk sistem dari protokol MQTT (aplikasi android) yang dibuat pada program ini. Kemudian data yang dibaca oleh sensor akan ditampilkan dalam bentuk nilai kondisi real time.

Selanjutnya adalah Flowchart dari rancangan ESP-8266:

Flowchart Pemrograman Esp8266

Sistem kerja dari ESP8266 yaitu pertama akan melakukan konfigurasi serial kemudian proses reset modul dari ESP8266 sebelum setting Chanel tujuan. Setelah terhubung, sistem akan Mencocokkan Apy Key Write pada Webserver yang telah disediakan pada account ThingSpeak. Kemudian, app android yang telah disetting dan dicocokkan akan terhubung menampilkan data sensor melalui jaringan internet.

Perancangan perangkat lunak sensor juga memiliki serangkaian alur pemrograman yang berbeda dengan flowchart diatas. Namun, serangkaian flowchart dari masing masing perangkat lnak ini saling berkaitan satu sama lain sehingga membentuk sebuah system monitoring berbasis webserver ThigSpeak. Berikut ini adalah tampilan flowchart dari perancangan perangkat lunak Sensor:

Flowchart Sensor

Sistem ini menggunakan empat sensor yaitu: sensor YL-69, sensor DHT-11, sensor DS18B20 dan sensor LDR. Sensor soil moisture berfungsi untuk membaca nilai kelembaban tanah, sensor DHT-11 berfungsi membaca nilai dari kelembaban udara dan juga suhu. Sensor DS18B20 digunakan untuk mengukur suhu dan sensor LDR digunakan untuk mengukur intensitas cahaya.

Source Code

Setelah merangkai komponen dan memahami penjelasan diatas, kemudian saatnya memprogram satu persatu rangkaian.

Reading command from ThingSpeak.com

Berikut ini adalah kode program untuk membaca perintah dari chanel thingspeak.

/***************************************************** 
* Reading Status to ThingSpeak.com
*****************************************************/

// Thingspeak  
String statusChWriteKey = "J9SOSNX1ZGD2O74K";  // Status Channel id: 999999

#include <SoftwareSerial.h>
SoftwareSerial EspSerial(6, 7); // Rx,  Tx
#define HARDWARE_RESET 8

// DS18B20
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 5 // DS18B20 on pin D5 
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
int soilTemp = 0;

//DHT
#include "DHT.h"
#include <stdlib.h>
int pinoDHT = 11;
int tipoDHT =  DHT22;
DHT dht(pinoDHT, tipoDHT); 
int airTemp = 0;
int airHum = 0;

// LDR (Light)
#define ldrPIN 1
int light = 0;

// Soil humidity
#define soilHumPIN 0
int soilHum = 0;

// Variables to be used with timers
long writeTimingSeconds = 17; // ==> Define Sample time in seconds to send data
long startWriteTiming = 0;
long elapsedWriteTime = 0;

// Variables to be used with Actuators
boolean pump = 0; 
boolean lamp = 0; 

int spare = 0;
boolean error;

void setup()
{
  Serial.begin(9600);
  
  pinMode(HARDWARE_RESET,OUTPUT);
  
  digitalWrite(HARDWARE_RESET, HIGH);
  
  DS18B20.begin();
  dht.begin();

  EspSerial.begin(115200); // Comunicacao com Modulo WiFi
  EspHardwareReset(); //Reset do Modulo WiFi
  startWriteTiming = millis(); // starting the "program clock"
}

void loop()
{
  start: //label 
  error=0;
  
  elapsedWriteTime = millis()-startWriteTiming; 
  
  if (elapsedWriteTime > (writeTimingSeconds*1000)) 
  {
    readSensors();
    writeThingSpeak();
    startWriteTiming = millis();   
  }
  
  if (error==1) //Resend if transmission is not completed 
  {       
    Serial.println(" <<<< ERROR >>>>");
    delay (2000);  
    goto start; //go to label "start"
  }
}

/********* Read Sensors value *************/
void readSensors(void)
{
  airTemp = dht.readTemperature();
  airHum = dht.readHumidity();

  DS18B20.requestTemperatures(); 
  soilTemp = DS18B20.getTempCByIndex(0); // Sensor 0 will capture Soil Temp in Celcius
             
  light = map(analogRead(ldrPIN), 1023, 0, 0, 100); //LDRDark:0  ==> light 100%  
  soilHum = map(analogRead(soilHumPIN), 1023, 0, 0, 100); 

}

/********* Conexao com TCP com Thingspeak *******/
void writeThingSpeak(void)
{

  startThingSpeakCmd();

  // preparacao da string GET
  String getStr = "GET https://api.thingspeak.com/update?api_key=J9SOSNX1ZGD2O74K&field1=0";
  getStr += statusChWriteKey;
  getStr +="&field1=";
  getStr += String(pump);
  getStr +="&field2=";
  getStr += String(lamp);
  getStr +="&field3=";
  getStr += String(airTemp);
  getStr +="&field4=";
  getStr += String(airHum);
  getStr +="&field5=";
  getStr += String(soilTemp);
  getStr +="&field6=";
  getStr += String(soilHum);
  getStr +="&field7=";
  getStr += String(light);
  getStr +="&field8=";
  getStr += String(spare);
  getStr += "\r\n\r\n";

  sendThingSpeakGetCmd(getStr); 
}

/********* Reset ESP *************/
void EspHardwareReset(void)
{
  Serial.println("Reseting......."); 
  digitalWrite(HARDWARE_RESET, LOW); 
  delay(500);
  digitalWrite(HARDWARE_RESET, HIGH);
  delay(8000);//Tempo necessário para começar a ler 
  Serial.println("RESET"); 
}

/********* Start communication with ThingSpeak*************/
void startThingSpeakCmd(void)
{
  EspSerial.flush();//limpa o buffer antes de começar a gravar
  
  String cmd = "AT+CIPSTART=\"TCP\",\"";
  cmd += "184.106.153.149"; // Endereco IP de api.thingspeak.com
  cmd += "\",80";
  EspSerial.println(cmd);
  Serial.print("enviado ==> Start cmd: ");
  Serial.println(cmd);

  if(EspSerial.find("Error"))
  {
    Serial.println("AT+CIPSTART error");
    return;
  }
}

/********* send a GET cmd to ThingSpeak *************/
String sendThingSpeakGetCmd(String getStr)
{
  String cmd = "AT+CIPSEND=";
  cmd += String(getStr.length());
  EspSerial.println(cmd);
  Serial.print("enviado ==> lenght cmd: ");
  Serial.println(cmd);

  if(EspSerial.find((char *)">"))
  {
    EspSerial.print(getStr);
    Serial.print("enviado ==> getStr: ");
    Serial.println(getStr);
    delay(500);//tempo para processar o GET, sem este delay apresenta busy no próximo comando

    String messageBody = "";
    while (EspSerial.available()) 
    {
      String line = EspSerial.readStringUntil('\n');
      if (line.length() == 1) 
      { //actual content starts after empty line (that has length 1)
        messageBody = EspSerial.readStringUntil('\n');
      }
    }
    Serial.print("MessageBody received: ");
    Serial.println(messageBody);
    return messageBody;
  }
  else
  {
    EspSerial.println("AT+CIPCLOSE");     // alert user
    Serial.println("ESP8266 CIPSEND ERROR: RESENDING"); //Resend...
    spare = spare + 1;
    error=1;
    return "error";
  } 
}

Didalam proses pengiriman status string GET menggunakan tiga bagian string yang dikirimkan ke chanel ThingSpeak, yaitu:

1. Start CMD, digunakan untuk menuliskan alamat IP ThingSpeak.com
AT+CIPSTART="TCP","184.106.153.149",80
2. Length, digunakan untuk mengirimkan pesan ke database ThingSpeak
AT+CIPSEND=116
3. String GET Api Key, digunakan untuk mengirimkan status ThingSpeaks

GET/update?api_key=J9SOSNX1ZGD2O74K_HERE&field1=pump&fieldlamp=0&field3=airTemp&field4=airHum&field5=soilTemp&field6=soilHum&field7=light&field8=spare

Kode J9SOSNX1ZGD2O74K diatas adalah API key dari chanel ThingSpeak. API key inilah yang dapat mengirimkan data status sensor yang diproses oleh arduino ke cloud chanel thingspeak.com. jika koneksi internet yang menghubungkan esp dengan cloud thingspeak stabil, maka proses pengirimannya cepat. Begitu juga sebaliknya, jika konekesi internetnya tidak stabil, maka proses pengirimannya akan lambat dan bahkan tidak berhasil terkirim.

Mengirim Data Sensor ke ThingSpeak

Program Utama

Setelah memahami kode program diatas, sekarang saatnya memasukan program keseluruhan dibawah ini:

Download: Smart-garden.ino

/***************************************************** 
* Smart_Garden - Remote controling a plantation
* 
* ThingSpeak ID Channels: 
*   Status (Actuators and Sensors): 999999
*   Actuator1: 999999 (Pump)
*   Actuator2: 999999 (Lamp)
* 
* Sensors:
*   DHT (2-wire Air Temperature/Humidity digital sensor)  ==> Pin D11
*   DS18B20 (1-Wire Temperature digital Sensor)           ==> Pin D05
*   LDR (Light Dependent Resistor - Analog Sensor)        ==> Pin A1
*   LM394/YL70 (Soil Humidity Analog Sensor)  
* 
* Actuators:
*   Actuator1         ==> Pin 10 (RED LED   ==> pump)
*   Actuator2         ==> Pin 12 (GREEN LED ==> lamp)
* 
* FREEZE_LED:       ==> Pin 13 (ESP-01 Freezing and Comm errors)
* HW RESET          ==> Pin 08
*     
* Version 1.1: Connection to WiFi using local credentials
*   Enter with your network credentials: "YOUR USERNAME\" and "YOUR PASSWORD\" directly 
*   on function connectWiFi()
* 
* https:///www.hestech.id/ 
*****************************************************/

// Thingspeak  
String statusChWriteKey = "J9SOSNX1ZGD2O74K";  // Status Channel id: 385184

String canalID1 = "715441"; // Enter your Actuator1 Channel ID here
String canalID2 = "715441"; // Enter your Actuator1 Channel ID here

#include <SoftwareSerial.h>
SoftwareSerial EspSerial(6, 7); // Rx,  Tx

// HW Pins
#define FREEZE_LED 13
#define HARDWARE_RESET 8

// DS18B20
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 5 // DS18B20 on pin D5 
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
int soilTemp = 0;

//DHT
#include "DHT.h"
#include <stdlib.h>
int pinoDHT = 11;
int tipoDHT =  DHT22;
DHT dht(pinoDHT, tipoDHT); 
int airTemp = 0;
int airHum = 0;

// LDR (Light)
#define ldrPIN 1
int light = 0;

// Soil humidity
#define soilHumPIN 0
int soilHum = 0;

// Variables to be used with timers
long writeTimingSeconds = 17; // ==> Define Sample time in seconds to send data
long readTimingSeconds = 10; // ==> Define Sample time in seconds to receive data
long startReadTiming = 0;
long elapsedReadTime = 0;
long startWriteTiming = 0;
long elapsedWriteTime = 0;

//Relays
#define ACTUATOR1 10 // RED LED   ==> Pump
#define ACTUATOR2 12 // GREEN LED ==> Lamp
boolean pump = 0; 
boolean lamp = 0; 

int spare = 0;
boolean error;

void setup()
{
  Serial.begin(9600);
  
  pinMode(ACTUATOR1,OUTPUT);
  pinMode(ACTUATOR2,OUTPUT);
  pinMode(FREEZE_LED,OUTPUT);
  pinMode(HARDWARE_RESET,OUTPUT);

  digitalWrite(ACTUATOR1, HIGH); //o módulo relé é ativo em LOW
  digitalWrite(ACTUATOR2, HIGH); //o módulo relé é ativo em LOW
  digitalWrite(FREEZE_LED, LOW);
  digitalWrite(HARDWARE_RESET, HIGH);
  
  DS18B20.begin();
  dht.begin();

  EspSerial.begin(115200); // Comunicacao com Modulo WiFi
  EspHardwareReset(); //Reset do Modulo WiFi
  startReadTiming = millis(); // starting the "program clock"
  startWriteTiming = millis(); // starting the "program clock"

  connectWiFi();
}

void loop()
{
  start: //label 
  error=0;
  
  
  elapsedWriteTime = millis()-startWriteTiming; 
  elapsedReadTime = millis()-startReadTiming; 

  if (elapsedReadTime > (readTimingSeconds*1000)) 
  {
    ESPcheck();//executar antes de qualquer leitura ou gravação
    int command = readThingSpeak(canalID1); 
    if (command != 9) pump = command; 
    delay (5000);
    command = readThingSpeak(canalID2); 
    if (command != 9) lamp = command; 

    takeActions();
    startReadTiming = millis();   
  }
  
  if (elapsedWriteTime > (writeTimingSeconds*1000)) 
  {
    ESPcheck();//executar antes de qualquer leitura ou gravação
    readSensors();
    writeThingSpeak();
    startWriteTiming = millis();   
  }
  
  if (error==1) //Resend if transmission is not completed 
  {       
    Serial.println(" <<<< ERROR >>>>");
    digitalWrite(FREEZE_LED, HIGH);
    delay (2000);  
    goto start; //go to label "start"
  }
}

/********* Read Sensors value *************/
void readSensors(void)
{
  airTemp = dht.readTemperature();
  airHum = dht.readHumidity();

  DS18B20.requestTemperatures(); 
  soilTemp = DS18B20.getTempCByIndex(0); // Sensor 0 will capture Soil Temp in Celcius
             
  light = map(analogRead(ldrPIN), 1023, 0, 0, 100); //LDRDark:0  ==> light 100%  
  soilHum = map(analogRead(soilHumPIN), 1023, 0, 0, 100); 

}

/********* Take actions based on ThingSpeak Commands *************/
void takeActions(void)
{
  Serial.print("Pump: ");
  Serial.println(pump);
  Serial.print("Lamp: ");
  Serial.println(lamp);
  if (pump == 1) digitalWrite(ACTUATOR1, LOW);
  else digitalWrite(ACTUATOR1, HIGH);
  if (lamp == 1) digitalWrite(ACTUATOR2, LOW);
  else digitalWrite(ACTUATOR2, HIGH);
}

/********* Read Actuators command from ThingSpeak *************/
int readThingSpeak(String channelID)
{
  startThingSpeakCmd();
  int command;
  // preparacao da string GET
  String getStr = "GET /channels/";
  getStr += channelID;
  getStr +="/fields/1/last";
  getStr += "\r\n";

  String messageDown = sendThingSpeakGetCmd(getStr);
  if (messageDown[5] == 49)
  {
    command = messageDown[7]-48; 
    Serial.print("Command received: ");
    Serial.println(command);
  }
  else command = 9;
  return command;
}

/********* Conexao com TCP com Thingspeak *******/
void writeThingSpeak(void)
{

  startThingSpeakCmd();

  // preparacao da string GET
  String getStr = "https://api.thingspeak.com/channels/715441/fields/1.json?results=2";
  getStr += statusChWriteKey;
  getStr +="&field1=";
  getStr += String(pump);
  getStr +="&field2=";
  getStr += String(lamp);
  getStr +="&field3=";
  getStr += String(airTemp);
  getStr +="&field4=";
  getStr += String(airHum);
  getStr +="&field5=";
  getStr += String(soilTemp);
  getStr +="&field6=";
  getStr += String(soilHum);
  getStr +="&field7=";
  getStr += String(light);
  getStr +="&field8=";
  getStr += String(spare);
  getStr += "\r\n\r\n";

  sendThingSpeakGetCmd(getStr); 
}

/********* Echo Command *************/
boolean echoFind(String keyword)
{
 byte current_char = 0;
 byte keyword_length = keyword.length();
 long deadline = millis() + 5000; // Tempo de espera 5000ms
 while(millis() < deadline){
  if (EspSerial.available()){
    char ch = EspSerial.read();
    Serial.write(ch);
    if (ch == keyword[current_char])
      if (++current_char == keyword_length){
       Serial.println();
       return true;
    }
   }
  }
 return false; // Tempo de espera esgotado
}

/********* Reset ESP *************/
void EspHardwareReset(void)
{
  Serial.println("Reseting......."); 
  digitalWrite(HARDWARE_RESET, LOW); 
  delay(500);
  digitalWrite(HARDWARE_RESET, HIGH);
  delay(8000);//Tempo necessário para começar a ler 
  Serial.println("RESET"); 
}

/********* Check ESP *************/
boolean ESPcheck(void)
{
  EspSerial.println("AT"); // Send "AT+" command to module
   
  if (echoFind("OK")) 
  {
    //Serial.println("ESP ok");
    digitalWrite(FREEZE_LED, LOW);
    return true; 
  }
  else //Freeze ou Busy
  {
    Serial.println("ESP Freeze ******************************************************");
    digitalWrite(FREEZE_LED, HIGH);
    EspHardwareReset();
    return false;  
  }
}

/********* Start communication with ThingSpeak*************/
void startThingSpeakCmd(void)
{
  EspSerial.flush();//limpa o buffer antes de começar a gravar
  
  String cmd = "AT+CIPSTART=\"TCP\",\"";
  cmd += "184.106.153.149"; // Endereco IP de api.thingspeak.com
  cmd += "\",80";
  EspSerial.println(cmd);
  Serial.print("enviado ==> Start cmd: ");
  Serial.println(cmd);

  if(EspSerial.find("Error"))
  {
    Serial.println("AT+CIPSTART error");
    return;
  }
}

/********* send a GET cmd to ThingSpeak *************/
String sendThingSpeakGetCmd(String getStr)
{
  String cmd = "AT+CIPSEND=";
  cmd += String(getStr.length());
  EspSerial.println(cmd);
  Serial.print("enviado ==> lenght cmd: ");
  Serial.println(cmd);

  if(EspSerial.find((char *)">"))
  {
    EspSerial.print(getStr);
    Serial.print("enviado ==> getStr: ");
    Serial.println(getStr);
    delay(500);//tempo para processar o GET, sem este delay apresenta busy no próximo comando

    String messageBody = "";
    while (EspSerial.available()) 
    {
      String line = EspSerial.readStringUntil('\n');
      if (line.length() == 1) 
      { //actual content starts after empty line (that has length 1)
        messageBody = EspSerial.readStringUntil('\n');
      }
    }
    Serial.print("MessageBody received: ");
    Serial.println(messageBody);
    return messageBody;
  }
  else
  {
    EspSerial.println("AT+CIPCLOSE");     // alert user
    Serial.println("ESP8266 CIPSEND ERROR: RESENDING"); //Resend...
    spare = spare + 1;
    error=1;
    return "error";
  } 
}

/***************************************************
* Connect WiFi
****************************************************/
void connectWiFi(void)
{
  sendData("AT+RST\r\n", 2000, 0); // reset
  sendData("AT+CWJAP=\"ThingPad i7 Predator\",\"pppppppp\"\r\n", 2000, 0); //Connect network
  delay(3000);
  sendData("AT+CWMODE=1\r\n", 1000, 0);
  sendData("AT+CIFSR\r\n", 1000, 0); // Show IP Adress
  Serial.println("8266 Connected");
}

/***************************************************
* Send AT commands to module
****************************************************/

String sendData(String command, const int timeout, boolean debug)
{
  String response = "";
  EspSerial.print(command);
  long int time = millis();
  while ( (time + timeout) > millis())
  {
    while (EspSerial.available())
    {
      // The esp has data so display its output to the serial window
      char c = EspSerial.read(); // read the next character.
      response += c;
    }
  }
  if (debug)
  {
    Serial.print(response);
  }
  return response;
}

Result
Untuk melakukan pengoperasian secara umum dapat dilihat pada gambar  berikut ini:

Pengoperasian Awal

Setelah pengaktifan alat dilakukan, langkah selanjutnya adalah memastikan alat bekerja dengan maksimal, caranya adalah sebagai berikut:

• Power supply yang digunakan adalah 5 vdc, oleh karena itu bisa menggunakan power supply dari USB laptop,
• Setelah dicolokan dengan menggunakan kabel USB port, selanjutnya buka serial monitor pada Arduino IDE, untuk lebih jelasnya dapat dilihat pada gambar berikut:

Tampilan Serial Monitor

• Jika modul esp8266 berhasil terhubung dengan internet seperti gambar diatas, berarti alat sudah bisa digunakan.
• Kemudian langkah selanjutnya adalah menguji sensor kelembapan tanah. Dengan cara menancapkan kedalam tanah.

  

  Menguji Sensor Kelembapan dan Sensor DS18B20

• Selanjutnya buka serial monitor dan akan menampilkan data seperti gambar berikut:

Pesan Terkirim ke ThingSpeak

Pesan diatas dikirimkan sesuai dengan code api key yang didapat dari chanel ThingSpeak

ID Chanel Thingspeak

• Kode kode diatas dituliskan pada program arduino IDE dan aplikasi android. Penulisan code program dilakukan sebelum aplikasi belum menjadi .apk yang dilakukan pada saat perancangan. Jika salah satu dari code yang dimasukkan salah, maka data sensor tidak dapat dikirimkan:

Pesan Tidak Terkirim

• Kemudian cek data sensor pada private view yang masuk di chanel thingspeak yang sudah dibuat:

Hasil Data yang Terkirim di Chanel Thingspeak

• Data yang masuk ke database thingspeak dapat dilihat dengan menggunakan aplikasi yag sudah dirancang sebelumnya. Sebelum membuka aplikasi, pastikan koneksi jaringan internet pada android terhubung dengan android.

Tampilan data Thingspeak di android

Gambar diatas menunjukkan nilai status sensor diantaranya adalah suhu udara dalam satuan ºCelcius, kelembapan udara dalam %, status cahaya dalam satuan %, begitu juga dengan suhu tanah yang digunakan adalah dalam satuan ºCelcius, kelembapan tanah dalam satuan %, dan spare digunakan untuk nilai ambang batas status masing-masing sensor.

• Selanjutnya, jika status kelembapan tanah adalah kurang dari (<=)  40 ºC maka aplikasi akan menampilkan data seperti berikut: 

Status Peringatan pada Aplikasi

• Pengguna aplikasi juga dapat mengontrol kelembapan tanah jika kelembapan terlalu rendah / tanah terlalu kering dengan cara menghidupkan pompa air melalui aplikasi android. Caranya adalah dengan mengklik tombol Pump On untuk menghidupkan pompa air, begitu juga dengan sebaliknya.

Status Kontrol pada Aplikasi

• Perubahan data pada kelembapan tanah dapat dilihat melalui chanel thingspeak seperti pada gambar berikut:

Status Perubahan Field pada Chanel Thingspeak

Status kelembapan tanah terakhir pada field 6 chart yang merupakan field status kelembapan tanah menunjukkan nilai 71%, status terakhir ini akan dikirimkan ke aplikasi android seperti pada gambar berikut:

Status Nilai pada Aplikasi Android

Data yang dikirimkan dari chanel thingspeak ke aplikasi android memerlukan delay 30 s/d 60 detik sesuai jaringan yang digunakan untuk mengakses database. Jika jaringan internetnya lemah, sudah dipastikan update data sensor memerlukan waktu yang lebih lama.

Hasil Alat yang sudah di Uji Coba di Persidangan 

Selesai
Selamat Mencoba, silahkan bertanya dikolom komentar jika ada yang belum jelas.

tag:
#tugas-akhir
#arduino-projects
#thingspeak
#app-inventor
#android-app
#sensor