INTERNET OF THINGS

2021

2021

ARDUCAMP
Oleh Tim arducamp
Daftar Isi
PENDAHULUAN ............................................................................................................................................... 4
IOT ? ............................................................................................................................................................ 4
DEVELOPMENT BOARD YANG DIGUNAKAN ................................................................................................ 5
Wemos D1 MINI PRO (KELUARGA ESP8266) ........................................................................................... 5
WEMOS LOLIN32 (KELUARGA ESP32) ..................................................................................................... 6
MATERI 1 : INSTALASI WEMOS D1 MINI ......................................................................................................... 8
MATERI 2 : INPUT & OUTPUT ........................................................................................................................ 11
MATERI 2.1 : INPUT ................................................................................................................................... 11
Materi 2.1.1 : Push Button .................................................................................................................... 11
Materi 2.1.2 : DHT11 ............................................................................................................................. 14
Materi 2.1.3 : LDR ................................................................................................................................. 16
MATERI 2.2 : OUTPUT ............................................................................................................................... 18
Materi 2.2.1 : LED .................................................................................................................................. 18
MATERI 3 : DASAR KONEKSI WIFI .................................................................................................................. 21
MATERI 3.1 : WEMOS SEBAGAI STA .......................................................................................................... 21
Materi 3.1.1 : Memindai WiFi sekitar .................................................................................................... 22
Materi 3.1.2 : Koneksi WEMOS dengan jaringan WiFi ........................................................................... 25
Materi 3.1.3 : Koneksi Wemos ke website ............................................................................................ 28
MATERI 3.2 : WEMOS SEBAGAI ACCESS POINT ......................................................................................... 33
MATERI 4 : KOMUNIKASI ANTARA PERANGKAT WEMOS .............................................................................. 38
MATERI 4.1 : KOMUNIKASI TCP ................................................................................................................. 39
MATERI 4.2 : KOMUNIKASI UDP ................................................................................................................ 45
MATERI 5 : WEBSERVER ................................................................................................................................ 51
MATERI 5.1 : DASAR-DASAR WEBSERVER PADA ESP8266 ......................................................................... 52
MATERI 5.3 : HTTP REQUEST ..................................................................................................................... 56
MATERI 5.4 : AUTO REFRESH SCRIPT............................................................. Error! Bookmark not defined.
MATERI 6 : ADAFRUIT & IFTTT ...................................................................................................................... 62
MATERI 6.1 : ADAFRUIT DASHBOARD WEBSITE ........................................................................................ 64
MATERI 6.2 : ADAFRUIT MQTT DASHBOARD pada ANDROID SMARTPHONE ........................................... 80
MATERI 6.2 : ADAFRUIT X IFTTT ................................................................................................................ 87
MATERI 7 : WEBHOOK IFTTT ......................................................................................................................... 98
MATERI 7.1 : TRIGGER SMS DAN EMAIL.................................................................................................... 98
MATERI 8 : WEB HOSTING (FINAL PROJECT) ............................................................................................... 116
MATERI 8.1 : IOT WEATHER STATION WEBSITE ...................................................................................... 116

2
3
PENDAHULUAN
IOT ?
Internet of Things (IoT) telah menjadi topik yang hangat untuk dibicarakan akhir-akhir ini. IoT tidak
hanya menjadi suatu konsep yang mempengaruhi hidup manusia tetapi bagaimana IoT bisa membantu
memudahkan kehidupan manusia. Namun sebenarnya, apa sih yang dimaksud IoT itu? dan apa saja
dampaknya? Mari kita mulai dengan memahami beberapa hal. Fakta menyatakan ketersediaan broadband
Intenet semakin meningkat, biaya koneksi semakin murah, begitu juga harga alat pengembangan teknologi.
Fakta ini menjadikan IoT sebagai sesuatu yang sempurna untuk digunakan.
Sederhananya, Internet of Things adalah konsep dasar yang menghubungkan perangkat apapun satu
sama lain. Termasuk kulkas, TV, mesin cuci, lampu, smartphone, mobil dan masih banyak lagi. Selain
peralatan sehari-hari, IoT juga bisa menghubungkan berbagai komponen mesin seperti mesin jet pesawat
terbang, bor pertambangan minyak dan lain-lain. Pada dasarnya, jika kita memiliki peralatan yang
mempunyai saklar on dan off, peralatan tersebut mempunyai kesempatan yang besar untuk digunakan
dalam ranah IoT.
IoT akan mempunyai dampak yang menyebabkan aturan baru dimana aturan masa depan akan
menjadi, 'apapun yang dapat dihubungkan, akan terhubung'. Namun, pertanyaannya kenapa kita
memerlukan banyak perangkat yang saling terhubung satu sama lain? Misal, jika anda sedang di jalan untuk
meeting, dan mobil anda bisa mengakses rute terbaik yang diambil, namun lalu lintas berat menyebabkan
mobil mengirimkan pesan teks ke rekan meeting bahwa anda akan terlambat? Contoh lain, bagaimana jika
anda telat bangun, dan jam alarm yang sudah diatur jam 6 berdering dan memberitahukan mesin pembuat
kopi untuk menyeduh kopi anda?
Untuk skala yang lebih luas, IoT dapat diterapkan untuk jaringan transportasi untuk kepetingan Smart
City yang dapat membantu kita mengurangi limbah dan meningkatkan penggunaan energi seefisien
mungkin. Hal ini akan membantu kita dalam memahami dan meningkatkan kesejahteraan hidup.
Topik IoT selama beberapa tahun menjadikan kita berusaha untuk memahami bagaimana IoT
mempengaruhi kehidupan. Kita juga harus berusaha untuk memahami peluang dan tantangan apa saja yang
bisa kita ambil dan selesaikan. Karena semakin banyak perangkat mulai bergabung dengan IoT. Untuk saat
ini hal terbaik yang bisa kita lakukan adalah mendidik diri sendiri tentang apa yang dimaksud IoT dan mencari
tahu dampak potensial yang dapat dilihat agar pekerjaan dan hidup kita semakin nyaman.

4
DEVELOPMENT BOARD YANG DIGUNAKAN
Wemos D1 MINI PRO (KELUARGA ESP8266)
WeMos D1 mini merupakan module development board yang berbasis WiFi dari keluarga ESP8266.
WeMos D1 dapat diprogram menggunakan software IDE Arduino seperti halnya dengan NodeMCU. Salah
satu kelebihan dari WeMos D1 mini dibandingkan dengan module development board berbasis ESP8266
lainnya yaitu adanya module shield untuk pendukung hardware plug and play. Module shield development
yang dimaksud antaralain Modul Display, Sensor, dan Aktuator. Ada beberapa turunan dari keluarga WeMos
D1 di tahun 2018, antaralain D1, D1 Mini, D1 mini Lite, dan D1 mini Pro. Pada pembahasan kali ini, kita akan
berfokus pada WeMos D1 Mini yang paling populer di Indonesia.
Spesifikasi dari Wemos D1 Mini:
1. Beroperasi pada tegangan operasional 3,3 V
2. Memiliki 11 pin digital I/O termasuk pin I2C, one-wire, PWM, SPI, dan interrupt
3. Memiliki 1 pin analog input (ADC)
4. Berbasis micro USB untuk fungsi pemrogramannya
5. Memory flash: 4Mbyte
6. Dimensi module: 34,2 mm x 25,6 mm
7. Clock speed: 80MHz
8. Menggunakan IC CH340G untuk komunikasinya

Pin Map GPIO WeMos D1 Mini:

Gambar 1 Pemetaan pin Wemos D1 Mini 2.

5
Tabel berikut memberikan informasi, mana saja pin GPIO yang dapat dijadikan refrensi dalam pembuatan
proyek IOT, untuk mengurangi tingkat kegagalan.
Tabel 1 Detail Pin Wemos D1 Mini.

Ada pin tertentu yang menghasilkan sinyal 3.3V saat ESP8266 proses booting. Ada kemungkinan
permasalahan yang timbul jika menghubungkan device lain seperti relay ke GPIO tersebut. GPIO6 ke GPIO11
biasanya terhubung ke chip flash di papan ESP8266. Jadi, pin ini tidak disarankan untuk digunakan. Berikut
ini GPIO menghasilkan sinyal HIGH saat boot: GPIO16, GPIO3, GPIO1, GPIO10, GPIO9.
GPIO4 dan GPIO5 merupakan GPIO yang paling aman digunakan jika ingin koneksikan dengan device
relay.

WEMOS LOLIN32 (KELUARGA ESP32)

ESP32 merupakan salah satu varian development kit selain ESP8266 yang dikembangkan oleh
Espressif System. ESP32 adalah sebuah sistem mikrokontroler IOT yang berbiaya rendah, berdaya rendah
pada seri chip dengan kemampuan WiFi dan bluetooth dalam dua mode. Adapun keluarga ESP32 adalah chip
ESP32-D0WDQ6, ESP32-D2WD, ESP32-S0WD, dan sistem dalam paket ESPRE-PICO-D4. Pada intinya, jenis
mikroprosesor Tensilica Xtensa LX6 dengan inti dual core atau single core mempunyai kecepatan hingga
240Mhz. ESP32 sudah terpasang antena, RF balun, power amplifier, low-noise receive amplifier, filter, dan
power management module. Perangkat ini didesain untuk semua jenis perangkat dari seluler, embedded
system, dll.
Adapun pemetaan pinout dari ESP32 dapat dilihat pada Gambar 2. Yang kita gunakan dalam
praktikum ini. Perbedaan antara ESP32 versi biasa dengan ESP32 versi wemos adalah versi wemos dapat

6
mengeluarkan tegangan 5V dan versi wemos juga dapat menerima langsung masukkan daya dari baterai
lipo.

Gambar 2 ESP32 Pinout.

Gambar 3 Wemos Lolin32 Pinout.

7
MATERI 1 : INSTALASI WEMOS D1
MINI
Tujuan :
1. Peserta memahami instalasi perangkat wemos D1 Mini
2. Peserta dapat menjalankan coding led blink pertama di wemos D1 Mini

Bahan yang diperlukan:

1. WeMos D1 Mini
2. Kabel Micro USB
3. Laptop
4. Arduino IDE

Langkah-Langkah Persiapan Integrasi Library ESP8266 NodeMCU:

1. Download dan install software Arduino IDE (sesuai dengan Operation System), kemudian buka
software tersebut.
2. Pilih dan klik menu file → preferences
3. Pada bagian “Additional Boards Manager URLs” masukan link dibawah berikut ini:
http://arduino.esp8266.com/stable/package_esp8266com_index.json klik OK

8
 Gambar 4 Windows Preferences

4. Setelah itu, pilih menu tools -> board -> boards manager
5. Ketikan pada “filter your search” -> esp8266 by ESP8266 community
6. Kemudian klik install, dan tunggu beberapa detik sampai proses selesai

9
 Gambar 5 Boards Manager.

Langkah-Langkah Persiapan Pemrograman:

1. Pada software Arduino IDE klik menu tools -> boards -> Wemos D1 Mini
2. Masuk ke menu Port dan pilih port mana yang digunakan (COMxx)
3. Setelah itu ke menu File -> Examples ->Basic -> Blink
4. klik tombol “upload“. Tunggu beberapa detik, program akan mulai diunggah ke module dengan
ditandai adanya “blinking” pada LED

10
MATERI 2 : INPUT & OUTPUT
Di bab ini, kita akan mempelajari mengenai masukan dan keluaran yang ada pada wemos D1
mini, adapun masukan yang akan kita gunakan ada tiga macam, yaitu push button, DHT11 (sensor
kelembapan udara dan suhu), dan LDR. Sedangkan untuk keluaran wemos, kita menggunakan lampu LED
dua buah.

MATERI 2.1 : INPUT

Pada subbab ini, kita akan melaksanakan pelatihan tentang bagaimana cara kera dari masukan
yang nantinya dapat dibaca oleh wemos baik itu masukan digital atau masukan analog. Adapun rangkaian
secara umum untuk praktikum ini dapat dilihat pada

Gambar 6 Rangkaian Penuh Wemos D1 Mini.

Materi 2.1.1 : Push Button

Kita akan mencoba memproses masukan digital berupa push button. Push button yang kita
gunakan ini, memiliki dua kaki yang kalau ditekan akan menghubungkan antara kaki-kaki tersebut. Pada push
button, terdapat dua jenis rangkaian, yaitu rangkaian active high dan active low. Rangkaian active high
adalah rangkaian yang jika terhubung maka akan memberikan tegangan +5V/+3,3V kepada pin masukan
wemos. Sedangkan active low adalah rangkaian yang jika terhubung maka akan memberikan ground kepada

11
pin masukan wemos. Rangakaian active low sering digunakan oleh para pengguna arduino dikarenakan lebih
sederhana merangkainya dan tidak perlu menggunakan resistor tambahan pada kaki ground-nya. Pada
percobaan ini, kita menggunakan rangkaian active low.
Tujuan
1. Peserta dapat memahami konsep masukan pada wemos D1 Mini.
2. Peserta dapat memahami rangkaian aktif low pada push button.
3. Peserta dapat memahami prinsip kerja rangkaian aktif low pada push button.

Bahan-bahan yang digunakan

1. Kabel secukupnya
2. 1 buah push button
3. Wemos D1 Mini
4. Project board
5. Kabel USB

Langkah-langkah secara Umum

1. Rangkaialah rangkaian sesuai pada Gambar 6.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.

Koding
#define BUTTON_PIN D2

int current = 0;

void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
}

void loop() {
current = digitalRead(BUTTON_PIN);
Serial.println(current);
Delay(1000);
}

Penjelasan Koding

12
#define BUTTON_PIN D2
int current = 0;
Pada awal baris, kita membuat satu konstanta dan dua variabel. konstanta BUTTON_PIN digunakan
untuk menyimpan pin tombolnya. Variabel current berguna untuk menyimpan hasil masukan dari push
button dan memiliki nilai awal 0.
void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
}
Void setup () adalah prosedur yang dijalankan oleh wemos ketika dinyalakan dan hanya sekali
dijalankan. Didalam void setup() terdapat koding pinMode yang dimana berguna untuk mengatur jenis pin
yang dipakai. Dalam hal ini, BUTTON_PIN kita jadikan sebagai INPUT_PULLUP, yang artinya masukan active
low. Serial.begin(115200) akan menyetel baud rate sebesar 115200.
void loop() {
current = digitalRead(BUTTON_PIN);
Serial.println(current);
}
Void loop() merupakan prosedur utama yang akan dijalankan oleh wemos secara terus-menerus
hingga terputusnya aliran listrik yang menghidupinya. Ketika wemos telah membaca syntax paling terakhir,
maka langka selanjutnya wemos akan mengulang pebacaan koding void loop() dari awal lagi. Fungsi
digitalRead() adalah membaca masukan dari pin digital. Dalam konteks ini, digitalRead () akan membaca
masukan dari BUTTON_PIN, kemudian menyimpannya kedalam variabel current. Serial.println(current)
berguna untuk menampilkan apa yang ada di dalam variabel current pada saat itu di serial monitor.

Hasil Penerapan Koding

13
 Gambar 7 Penekanan tombol push button

Ketika push button ditekan, maka akan menghasilkan nilai low yang ditampilkan di serial monitor.
Sedangkan, ketika push button tidak ditekan, maka akan menghasilkan nilai high yang ditampilkan pada
serial monitor.

Materi 2.1.2 : DHT11

Pada materi kali ini, kita akan membahas salah satu sensor yang banyak digunakan dalam proyek
arduino maupun IOT. Sensor ini bernama DHT yang dimana terdapat dua macam jenis DHT11 dan DHT22.
Meskipun memiliki tujuan yang sama, DHT11 memiliki galat pengukuran suhu dan kelembapan yang lebhi
lebar dibandingkan dengan DHT22. Namun, DHT11 dari sisi harga jauh lebih terjangkau dibandingkan dengan
DHT22. Sehingga DHT11 untuk kalangan penghobi, lebih banyak digunakan dibandingkan dengan DHT22.
Pada pelatihan materi ini, kita akan membaca nilai suhu dan kelembapan yang dihasilkan oleh sensor DHT11.
Hasil dari sensor tersebut nantinya akan menjadi objek pelatihan kita sampai akhir dari kelas IOT ini.
Tujuan
1. Peserta dapat memahami cara kerja dari DHT11 dalam menghasilkan nilai suhu dan kelembapan.
2. Peserta dapat memahami rangkaian dari DHT11 dan wemos.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. Kabel Micro USB.

Langkah-Langkah Secara Umum

1. Rangkaialah rangkaian sesuai pada Gambar 6.
2. Pasang library pada arduino dengan nama library DHTesp.
3. Ketik koding yang tersedia pada sketch arduino.
4. Setelah selesai di ketik kodingnya, diunggah kodingnya.
5. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.

Koding
#include "DHTesp.h"

DHTesp dht;

void setup()
{

14
 Serial.begin(115200);
dht.setup(D4, DHTesp::DHT11);
}

void loop()
{
delay(dht.getMinimumSamplingPeriod());

float humidity = dht.getHumidity();

float temperature = dht.getTemperature();

Serial.print(“Humidity :”);
Serial.println(humidity);
Serial.print(“temperature :”);
Serial.println(temperature);
}

Penjelasan Koding
#include "DHTesp.h"
DHTesp dht;
#include “DHTesp.h” berguna untuk memasukkan library pemrograman dari DHT11 & DHT22 untuk
esp8266 dan esp32. Sedangkan syntax DHTesp dht adalah kelas yang dibuat untuk mengoperasikan sensor
DHT tersebut.
void setup()
{
Serial.begin(115200);
dht.setup(D4, DHTesp::DHT11);
}
Untuk syntax Serial.begin(115200) berguna untuk mengatur baud rate antara perangkat sebesar
115200. Sedangkan, dht.setup(D4, DHTesp::DHT11) adalah syntax yang berfungsi untuk menyatakan bahwa
pin sensor DHT11 dihubungkan ke pin wemos D4 dan DHTesp:DHT11 menyatakan bahwa sensor yang kita
gunakan adalah DHT11.
void loop()
{
delay(dht.getMinimumSamplingPeriod());

float humidity = dht.getHumidity();

float temperature = dht.getTemperature();

Serial.print(“Humidity :”);
Serial.println(humidity);
Serial.print(“temperature :”);
Serial.println(temperature);
}
15
 delay(dht.getMinimumSamplingPeriod()); berguna untuk memberikan nilai delay kepada wemos
agar ada jeda waktu pembacaan sensor. Syntax float humidity = dht.getHumidity(); & float temperature =
dht.getTemperature(); berguna untuk membentuk variabel bilangan pecahan untuk menampung nilai sensor
humidity dan temperature. Sedangkan beberapa syntax terakhir berguna untuk mencetak nilai yang
disimpan oleh variabel humidity dan temperature.

Hasil Penerapan Koding

Gambar 8 Hasil Output DHT11

Gambbar 5 di atas adalah hasil pembacaan dari sensor DHT11, yang kemudian dicetak oleh wemos
ke dalam serial monitor.

Materi 2.1.3 : LDR

Pada dasarnya, ada berbagai macam jenis sensor yang sensitif terhadap perubahan intensitas
cahaya, dimulai dari foto dioda, LDR, dll. Di pelatihan ini, kita menggunakan LDR untuk membaca intensitas
cahaya di sekeliling kita. Cahaya yang masuk ke dalam sensor nantinya akan dikonversi kedalam data digital.
Sensor LDR ini menggunakan pin masukan analog, berbeda dari perangkat-perangat sebelumnya yang
menggunakan pin masukan digital.

Tujuan
1. Peserta dapat memahami cara kerja dari LDR.
2. Peserta dapat memahami rangkaian LDR dengan wemos D1 Mini.

16
Bahan-Bahan yang Digunakan
1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. Kabel Micro USB.

Langkah-Langkah Secara Umum

1. Rangkaialah rangkaian sesuai pada Gambar 6.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.

Koding
#define LDR_PIN A0

float sensorValue = 0;

void setup() {
Serial.begin(115200);
}

void loop() {
sensorValue = analogRead(LDR_PIN);
sensorValue = (sensorValue / 1023) * 5000;
Serial.print("Sensor value LDR : ");
Serial.println(sensorValue);
delay(1000);
}

Penjelasan Koding
#define LDR_PIN A0

float sensorValue = 0;
Pada syntax koding di atas, kita membuat konstanta A0 bernama LDR_PIN dan membuat variabel
sensorValue yang berupa jenis bilangan pecahan dan memiliki nilai awal 0.
sensorValue = analogRead(LDR_PIN);
sensorValue = (sensorValue / 1023) * 5000;
Serial.print("Sensor value LDR : ");
Serial.println(sensorValue);

17
 analogRead(LDR_PIN); berguna untuk membaca masukan analog dari pin LDR_PIN, yang kemudian
disimpan ke dalam sensorValue. (sensorValue / 1023) * 5000; adalah sebuah rumus untuk mengonversi nilai
mentah sensorValue untuk menjadi satuan mikrovolt (tegangan). Setelah dikonversi, nilai sensorValue
ditampilkan kedalam serial monitor.

Hasil Penerapan Koding

Gambar 9 Hasil Keluaran LDR

Gambar di atas adalah hasil keluaran dari LDR, yang dimana nilai mentah dari sensornya diubah
secara matematis ke dalam satuan mikro volt.

MATERI 2.2 : OUTPUT

Pada subbab ini, kita akan mempelajari bagaimana output bekerja dalam Wemos D1 Mini. Ada
berbagai macam jenis keluaran yang dapat kita gunakan seperti motor DC, buzzer, servo, dll. Adapaun
perangkat keluaran yang kita gunakan dalam pelatihan ini adalah LED. Kenapa hanya menggunakan LED ?
karena LED adalah perangkat sederhana dalam rangkaian dan penggunaan serta pada intinya pin keluaran
digital hanya menghasilkan nilai tinggi atau rendah sehingga lebih mudah dipresentasikan dalam bentuk
cahaya.

Materi 2.2.1 : LED

LED (Light Emitting Diode) adalah sebuah dioda yang dapat memendarkan cahaya jika diberikan arus.
LED terdapat berbagai macam jenis, yaitu white LED, RGB LED, infrared LED, dll. Pada pelatihan ini, kita
menggunakan dua buah LED sebagai keluaran dari wemos D1 Mini. LED yang kita gunakan pun berjenis RGB
LED.

18
Tujuan
1. Peserta dapat memahami cara kerja dari LDR.
2. Peserta dapat memahami rangkaian LDR dengan wemos D1 Mini.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. Kabel Micro USB.

Langkah-Langkah Secara Umum

1. Rangkaialah rangkaian sesuai pada Gambar 6.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.

Koding
#define LED_PIN1 D3
#define LED_PIN2 D1

void setup() {
pinMode(LED_PIN1, OUTPUT);
pinMode(LED_PIN2, OUTPUT);
}

void loop() {
digitalWrite(LED_PIN1, HIGH);
digitalWrite(LED_PIN2, HIGH);
delay(1000);
digitalWrite(LED_PIN1, LOW);
digitalWrite(LED_PIN2, LOW);
delay(1000);
}

Penjelasan Koding
#define LED_PIN1 D3
#define LED_PIN2 D1
Pada syntax koding di atas, kita memberi nama kepada pin yang digunakan sebagai keluaran LED.
pinMode(LED_PIN1, OUTPUT);

19
 pinMode(LED_PIN2, OUTPUT);
pinMode berguna untuk menyetel jenis pin yang akan digunakan. Pada kasus ini, pin yang digunakan
akan disetel menjadi pin OUTPUT.
digitalWrite(LED_PIN1, HIGH);
digitalWrite(LED_PIN2, HIGH);
delay(1000);
digitalWrite(LED_PIN1, LOW);
digitalWrite(LED_PIN2, LOW);
delay(1000);
digitalWrite () merupakan sebuah prosedur untuk mengirimkan perintah kepada pin yang dituju.
Perintah yang diberikan merupakan data digital yang hanya memiliki dua nilai, yaitu HIGH dan LOW. HIGH
berarti akan memberikan tegangan 3.3V sedangkan LOW akan memberikan ground kepada pin tersebut.
sehingga kalau diterjemahkan ke dalam perangkat LED. HIGH berarti menyala sedangkan LOW berarti mati.
Dimana setiap rentang mati dan hidupnya LED diberikan jeda waktu 1000 ms atau 1 detik.

Hasil Penerapan Koding

Kedua lampu led yang dirangkaian dan dihubungkan ke dalam wemos, akan menyala bersama-sama
dengan rentang waktu satu detik, kemudian mati bersama-sama dengan rentang waktu satu detik dan
begitupun seterusnya, hingga aliran daya ke wemos diputuskan.

20
MATERI 3 : DASAR KONEKSI WIFI
Pada bab kali ini, kita akan membahas mengenai dasar koneksi WiFi ke dalam jaringan. Baik jaringan
lokal maupun jaringan internet. Ada dua skenario yang akan kita bahas kedepannya. Skenario pertama, kita
menjadikan wemos sebagai STA atau station, yang dimana wemos akan dihubungkan ke router atau access
point. Sedangkan skenario kedua, kita menjadikan wemos sebagai access point, yang dimana wemos akan
bekerja selayaknya router, bertindak sebagai pengatur jaringan yang terhubung dengannya.

MATERI 3.1 : WEMOS SEBAGAI STA

Gambar 10 Wemos Sebagai Station.

Wemos sebagai STA memiliki beberapa fitur yang unik untuk memfasilitasi pengaturan koneksi ke
router. Fitur unik tersebut antara lain :
1. Ketika jaringan WiFi wemos terputus dari routernya, wemos akan berusaha menghubungkan
kembali secara otomatis ke router yang terakhir kali terkoneksi dengannya. Ini disebabkan
wemos dapat menyimpan ssid dan password yang telah digunakan terakhir kali sehingga
menjaga wemos dapat menjaga koneksi jaringan agar tetap stabil.
2. Di suatu area yang memiliki beberapa koneksi WiFi, kita dapat menyimpan beberapa ssid
dan password ke dalam wemos dan memberikan pilihan kepada wemos untuk mengatur
sendiri ke router mana yang akan ia hubungkan dengan mempertimbangkan kekuatan sinyal
dari WiFi router tersebut.

21
 Pada subbab ini, kita akan mencoba mengoperasikan wemos sebagai STA dengan beberapa skenario,
yakni : pemindaian WiFI sekitar dan menampilkan berapa kekuatan sinyalnya, memberikan pilihan kepada
wemos untuk memilih koneksi terbaik, dan menghubungkan wemos ke internet dan mengakses website.

Materi 3.1.1 : Memindai WiFi sekitar

Pada pelatihan ini, kita akan mengoperasikan wemos sebagai STA agar dapat memindai WiFi sekitar
dan menampilkan WiFi yang terdeteksi sembari menghitung berapa kekuatan sinyal untuk setiap WiFI yang
diterima oleh wemos tersebut.

Tujuan
1. Peserta dapat memahami cara kerja wemos dalam pemindaian WiFi.
2. Peserta dapat memahami rincian detail WiFi yang ditampilkan oleh wemos dalam serial monitor.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.

Langkah-Langkah Secara Umum

1. Rangkaialah sesuai gambar rangkaian materi 2.1 INPUT.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.
5. Buka serial monitor untuk melihat hasilnya.

Koding
#include "ESP8266WiFi.h"

void setup() {
Serial.begin(115200);

WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
22
 Serial.println("Setup done");
}

void loop() {
Serial.println("scan start");
int n = WiFi.scanNetworks();
Serial.println("scan done");
if (n == 0) {
Serial.println("no networks found");
} else {
Serial.print(n);
Serial.println(" networks found");
for (int i = 0; i < n; ++i) {
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));
Serial.print(")");
Serial.println((WiFi.encryptionType(i) == ENC_TYPE_NONE) ? " " : "*");
delay(10);
}
}
Serial.println("");
delay(5000);
}

Penjelasan Koding
#include "ESP8266WiFi.h"
Library di atas kita masukkan ke dalam sketch karena memang perangkat yang kita gunakan dasarnya
adalah ESP8266 hanya saja diproduksi oleh wemos. Sejatinya kita bisa menggunakan library dasar untuk
modul ESP8266, yakni #include <WiFi.h>. Namun, dibeberapa perangkat, penerapan library dasar ke dalam
perangkat wemos atau dev kit esp8266 dapat menyebabkan dev kit tersebut me-reboot terus menerus.
Sehingga dibutuhkan library khusus untuk menangani dev kit yang akan kita gunakan.
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
Serial.println("Setup done");
}
Pada syntax koding di atas, kita menyetel wemos untuk menjadi station yang nantinya akan
dihubungkan ke router. Sedangkan WiFi.disconnect() berguna untuk memutuskan hubungan dari router

23
yang terhubung sebelumnya. Lalu diberikan jeda selama 100 ms untuk memastikan wemos benar-benar
terputus dengan jaringan yang ada.
Serial.println("scan start");
// WiFi.scanNetworks will return the number of networks found
int n = WiFi.scanNetworks();
Serial.println("scan done");
if (n == 0) {
Serial.println("no networks found");
}
Kita mulai masuk untuk melakukan pemindaian jaringan WiFi disekitar wemos. Nantinya jumlah hasil
pemindaian jaringan WiFi akan dimasukkan ke dalam variabel n. Jika tidak ada jaringan disekitaran wemos
maka wemos akan mencetak pernyataan di serial monitor “no networks found”.
else {
Serial.print(n);
Serial.println(" networks found");
for (int i = 0; i < n; ++i) {
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));
Serial.print(")");
Serial.println((WiFi.encryptionType(i) == ENC_TYPE_NONE) ? " " : "*");
delay(10);
}
Pada koding ini, jika ditemukan satu atau lebih jaringan WiFi di sekitaran wemos. Maka wemos akan
mencetak nama jaringan tersebut dan kekuatan sinyal yang diterima oleh wemos untuk masing-masing
jaringan WiFi. Perulangan for digunakan untuk melakukan perulangan cetak identitas WiFi, yang dimana
jumlah pencetakan dipengaruhi oleh variabel n. WiFi.SSID(i) merupakan syntax koding yang berguna untuk
menampilkan nama jaringannya, kemudian karena berbentuk array sehingga didalam kurungnya diberikan
indicator i untuk mencetak nama jaringan pada indeks yang ditunjuk.
Sedangkan WiFi.RSSI(i) menunjukkan kekuatan sinyal yang dipancarkan oleh jaringan WiFi dan
diterima oleh wemos. Kemudian pada syntax koding WiFi.encryptionType(i) == ENC_TYPE_NONE) ? " " : "*",
ini merupakan syntax koding ternary, yang dimana bentuk sederhana dari if else. Ketika jaringan WiFi yang
terdeteksi memiliki enkripsi, maka nanti akan dicetak tanda “*” setelah mencetak kekuatan dari WiFi
tersebut. Lalu diberikan delay 10ms untuk jeda pemindaian.

Hasil Penerapan Koding

24
 Gambar 11 Hasil Penerapan Koding Pemindai WiFi

Pada gambar di atas, setelah diterapkan koding pemindaian WiFi. Wemos akan memindai area
seklilingnya untuk mencari WiFi. Pemindaian dilakukan untuk mengidentifikasi nama SSID dan kekuatan
sinyal dari jaringan WiFi tersebut. ketika sudah dilakukan pemindaian, wemos akan mencetak hasilnya ke
dalam serial monitor.

Materi 3.1.2 : Koneksi WEMOS dengan jaringan WiFi

Pada materi kali ini, kita akan membahas bagaimana cara membuat wemos agar dapat terkoneksi
ke dalam jaringan WiFi. Skenario yang kita gunakan adalah multiWiFi, yang dimana nanti kita akan
menyimpan beberapa nama jaringan dan password dari WiFi tersebut. Lalu, wemos akan memilih dari detail
jaringan yang kita berikan, mana dari jaringan tersebut yang memiliki sinyal terkuat. Ketika ditemukan sinyal
tersebut, maka wemos akan menghubungkan ke jaringan WiFi tersebut.

Tujuan
1. Peserta memahami konsep koneksi antara jaringan WiFi dan wemos.
2. Peserta memahami cara mengoneksikan Wifi dan jaringan wemos.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.

25
 6. Dua buah LED.
7. Kabel Micro USB.

Langkah-Langkah secara Umum

1. Rangkaialah sesuai gambar rangkaian materi 2.1 INPUT.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.
5. Buka serial monitor untuk melihat hasilnya.

Koding
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>

ESP8266WiFiMulti wifiMulti;

void setup() {
Serial.begin(115200);

WiFi.mode(WIFI_STA);
wifiMulti.addAP("BGPLaptop", "bagusgilang");
//wifiMulti.addAP("ssid_from_AP_2", "your_password_for_AP_2");
//wifiMulti.addAP("ssid_from_AP_3", "your_password_for_AP_3");

Serial.println("Connecting Wifi...");
}

void loop() {
if (wifiMulti.run() == WL_CONNECTED) {
Serial.println("WiFi connected");
Serial.print("SSID: ");
Serial.println(WiFi.SSID());
Serial.print("IP Address: ");
Serial.println(WiFi.localIP());
Serial.println();
}
delay(5000);
}

26
Penjelasan Koding
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
ESP8266WiFiMulti wifiMulti;
Kita menggunakan dua jenis library, baris pertama untuk koneksi WiFi wemos ke jaringan.
Sedangkan baris kedua untuk scenario koneksi pemilihan jaringan terbaik dari beberapa detail WiFi yang
diberikan. Untuk dapat memilih jaringan WiFi terbaik, kita membuat kelas yang bernama wifiMulti, yang
nantinya digunakan untuk menyimpan beberapa jaringan yang ada.
Serial.begin(115200);

WiFi.mode(WIFI_STA);
wifiMulti.addAP("ssid_from_AP_1", "your_password_for_AP_1");
wifiMulti.addAP("ssid_from_AP_2", "your_password_for_AP_2");
wifiMulti.addAP("ssid_from_AP_3", "your_password_for_AP_3");
kita menjadikan wemos untuk bekerja dalam mode station. Kemudian kita menambahkan detail
jaringan dari nama WiFi hingga password WiFi tersebut.
if (wifiMulti.run() == WL_CONNECTED) {
Serial.println("WiFi connected");
Serial.print("SSID: ");
Serial.println(WiFi.SSID);
Serial.print("IP Address: ");
Serial.println(WiFi.localIP());
}
Dalam syntax ini, kita mengoneksikan wemos ke dalam jaringan WiFi. Wemos akan memilih salah
satu jaringan dengan kekuatan WiFi terbaik dari beberapa jaringan yang kita masukkan sebelumnya. Setelah
terkoneksi dengan salah satu jaringan WiFi terbaik, maka kita memberikan perintah ke wemos untuk
mencetak IP Address dan SSID yang diterima oleh wemos dari router yang terhubung.

27
Hasil Penerapan Koding

Gambar 12 Hasil Koneksi dengan Access Point

Pada gambar di atas, ditunjukkan hasil koneksi wemos ke jaringan WiFi yang ditentukan. Ketika telah
terhubung, wemos akan mencetak alamat IP yang diberikan oleh router ke wemos tersebut.

Materi 3.1.3 : Koneksi Wemos ke website

Pada materi kali ini, setelah kita mengoneksikan wemos ke dalam jaringan router, kita akan mencoba
menghubungkan wemos ke website. Wemos akan kita perintahkan untuk berkomunikasi dengan website
tersebut, dengan mengirimkan perintah ke server dan menunggu balasan dari server tersebut. Lalu, wemos
akan mencetak balasan dari website yang kita hubungkan dan kirimkan perintah.

Tujuan
1. Peseta dapat memahami cara kerja wemos mengakses website internet.

28
 2. Peserta dapat memahami langkah-langkah wemos dalam mengakses website.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.

Langkah-Langkah secara Umum

1. Rangkaialah sesuai gambar rangkaian Materi 2.1 INPUT.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.
5. Buka serial monitor untuk melihat hasilnya.

Koding
#include <ESP8266WiFi.h>

#ifndef STASSID
#define STASSID "BGPLaptop"
#define STAPSK "bagusgilang"
#endif

const char* ssid = STASSID;

const char* password = STAPSK;

const char* host = "djxmmx.net";

const uint16_t port = 17;

void setup() {
Serial.begin(115200);
Serial.print("Connecting to ");
Serial.println(ssid);

WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);

29
 while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}

Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}

void loop() {
Serial.print("connecting to ");
Serial.print(host);
Serial.print(':');
Serial.println(port);

WiFiClient client;
if (!client.connect(host, port)) {
Serial.println("connection failed");
delay(5000);
return;
}

Serial.println("sending data to server");

if (client.connected()) {
client.println("hello from ESP8266");
}

unsigned long timeout = millis();

while (client.available() == 0) {
if (millis() - timeout > 5000) {
Serial.println(">>> Client Timeout !");
client.stop();
delay(10000);
return;
}
}

Serial.println("receiving from remote server");

while (client.available()) {
char ch = static_cast<char>(client.read());
Serial.print(ch);
}

Serial.println();
Serial.println("closing connection");
client.stop();

30
 delay(10000);
}

Penjelasan Koding
#include <ESP8266WiFi.h>

#ifndef STASSID
#define STASSID "BGPLaptop"
#define STAPSK "bagusgilang"
#endif

const char* ssid = STASSID;

const char* password = STAPSK;

const char* host = "djxmmx.net";

const uint16_t port = 17;
Pada koding di atas, kita akan mengoneksikan wemos ke jaringan WiFi yang telah ditentukan.
Dengan mengisi ssid dan password pada salah satu jaringan WiFi yang tersedia. Sedangkan untuk website
yang kita akan akses pun diisikan dan disimpan dalam variabel khusus. Begitupun port yang akan digunakan
untuk komunikasi antara client dan server, sudah kita tentukan di awal.
Serial.begin(115200);
Serial.print("Connecting to ");
Serial.println(ssid);

WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());

Setelah kita menentukan website dan WiFi yang akan dikoneksikan, kita akan menghubungkan
wemos ke WiFi yang tersedia. Dalam kasus ini, kita hanya memberikan satu detail jaringan WiFi, sehingga
tidak memberikan pilihan kepada wemos diantara sekian banyak jaringan WiFi yang tersedia. Sembari
menunggu wemos terkoneksi dengan jaringan WiFi, maka wemos akan mencetak “.” Dengan jeda per 500
ms. Jika wemos telah terkoneksi dengan WiFi yang ditentukan, maka wemos akan mencetak alamat IP yang
diberikan oleh router.

31
 Serial.print("connecting to ");
Serial.print(host);
Serial.print(':');
Serial.println(port);

WiFiClient client;
if (!client.connect(host, port)) {
Serial.println("connection failed");
delay(5000);
return;
}
Koding di atas berfungsi untuk memerintah wemos untuk mencetak pernyataan koneksi ke server
yang dituju dan ditampilkan di serial monitor. Kemudian, wemos akan menghubungkan ke server. Jika tidak
terhubung, maka wemos akan mencetak pernyataan “connection failed” pada serial monitor dan syntax
return berguna untuk kembali ke awal lagi untuk mencoba menghubungkan ulang ke website yang telah
ditentukan.
Serial.println("sending data to server");
if (client.connected()) {
client.println("hello from ESP8266");
}

unsigned long timeout = millis();

while (client.available() == 0) {
if (millis() - timeout > 5000) {
Serial.println(">>> Client Timeout !");
client.stop();
delay(10000);
return;
}
}
Pada koding ini, ketika wemos sudah terhubung dengan host. Wemos akan mengirimkan pernyataan
“hello from esp8266” ke server. Kemudian menunggu balasan dari server yang dituju selama lima menit. Jika
tidak ada balasan dari server, maka wemos akan memutuskan hubungan ke server dan menjalankan delay
selama 10 detik, kemudian menjalankan return untuk kembali ke awal koding.
Serial.println("receiving from remote server");
while (client.available()) {
char ch = static_cast<char>(client.read());
Serial.print(ch);
}

Serial.println();
Serial.println("closing connection");
client.stop();

32
 delay(10000);
ketika terdapat balasan dari server, maka wemos akan menerima balasan tersebut, kemudian
mencetak apa yang diberikan oleh server ke dalam serial monitor. Setelah mencetak semua apa yang
diberikan oleh server. Wemos akan mengakhiri koneksi dengan server yang dituju dan menjalankan delay
selama 10 detik.

Hasil Penerapan Koding

Gambar 13 Hasil Koneksi ke Website

Pada gambar 11, wemos dikoneksikan ke WiFi yang memiliki jaringan internet. Kemudian wemos
dikoneksikan ke alamat website djxmmx.net. Hasil dari koneksi alamat website tersebut, server akan
mengirimkan quote kepada wemos. Kemudian wemos akan menampilkan quotenya ke dalam serial monitor.

MATERI 3.2 : WEMOS SEBAGAI ACCESS POINT

Pada subbab kali ini, kita akan membahas skenario mengenai wemos sebagai soft access point.
Sebelumnya, kita harus memahami dulu apa itu Acces point. Access point adalah sebuah perangkat yang
memberikan akses jaringan WiFi kepada perangkat lainnya dan menghubungkan mereka antara satu sama
lain. Keluarga esp8266 dapat menyediakan fungsi yang sama dengan access point, namun dalam ranah
mereka hal itu disebut soft access point. Adapun maksimal jumlah perangkat yang dapat terhubung dengan
access point wemos adalah lima perangkat.

33
 Gambar 14 Wemos sebagai Access Point.

Tujuan
1. Peserta memahami cara kerja dari soft access point.
2. Peserta dapat menyetel wemos menjadi soft access point.
3. Peserta dapat menghubungkan perangkat ke access point dan mengakses alamat IP nya.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.

Langkah-Langkah secara Umum

1. Rangkaialah sesuai gambar rangkaian Materi 2.1 INPUT.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.
5. Buka serial monitor untuk melihat hasilnya.

34
Koding
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

#ifndef APSSID
#define APSSID "BagusIoT"
#define APPSK "bagusgilang"
#endif

const char *ssid = APSSID;

const char *password = APPSK;

ESP8266WebServer server(80);

void handleRoot() {
server.send(200, "text/html", "<h1>You are connected\nBy Bagus</h1>");
}

void setup() {
delay(1000);
Serial.begin(115200);
Serial.println();
Serial.print("Configuring access point...");

WiFi.softAP(ssid, password);

IPAddress myIP = WiFi.softAPIP();

Serial.print("AP IP address: ");
Serial.println(myIP);
server.on("/", handleRoot);
server.begin();
Serial.println("HTTP server started");
}

void loop() {
server.handleClient();
}

Penjelasan Koding
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

#ifndef APSSID
35
#define APSSID "BagusIoT"
#define APPSK "bagusgilang"
#endif

const char *ssid = APSSID;

const char *password = APPSK;

ESP8266WebServer server(80);
Ada beberapa library yang kita tambahkan dalam koding ini, seperti #include
<ESP8266WebServer.h> yang berfungsi untuk menjalankan webserver pada wemos. #include <WiFiClient.h>
berfungsi untuk komunikasi wemos sebagai client dan menangani client. Karena skenario sekarang kita
menjadikan wemos sebagai access point, maka kita mempersiapkan nama WiFi dan password untuk menjaga
jaringan WiFi yang kita buat. Lalu, webserver yang akan kita buat, nantinya akan diakses melalui port ke 80.
void handleRoot() {
server.send(200, "text/html", "<h1>You are connected\nBy Bagus</h1>");
}
Prosedur ini berfungsi ketika terdapat client yang terkoneksi ke webserver. Kemudian, client
melakukan HTTP request ke alamat server. Server wemos akan mengirimkan html ke client sesuai dengan
yang kita perintahkan.
WiFi.softAP(ssid, password);

IPAddress myIP = WiFi.softAPIP();

Serial.print("AP IP address: ");
Serial.println(myIP);
server.on("/", handleRoot);
server.begin();
Serial.println("HTTP server started");
Pada syntax pertama, kita menyetel nama dan password jaringan yang akan kita buat. Lalu, setelah
disetel, kita menampilkan alamat IP dari routernya. Pada syntax server.on(“/”, handleRoot) akan menangani
client yang terhubung dan menjalankan prosedur handleRoot. Lalu syntax selanjutnya akan menjalankan
server agar dapat diakses.
void loop() {
server.handleClient();
}
Pada prosedur void loop() akan dijalankan prosedur handleClient pada server untuk membaca
apakah ada client yang terhubung ke server.
Hasil Penerapan Koding

36
 Gambar 15 HTTP Server Dijalankan

Gambar 16 Mengakses Alamat Wemos

Pada gambar 12 dan gambar 13, kita menyetel wemos agar menjadi access point dan menunjukkan
alamat IP-nya. Kemudian membuat webserver sederhana yang nantinya ketika di akses oleh client di browser
mereka, maka akan menampilkan text “You are connected By Bagus”.

37
MATERI 4 : KOMUNIKASI ANTARA
PERANGKAT WEMOS
Pada bab ini, kita akan membahas mengenai komunikasi antara perangkat wemos dengan
menggunakan dua macam protokol, yaitu TCP dan UDP. Sebelum kita masuk lebih dalam ke arah komunikasi
dua perangkat ini. Kita harus memahami dulu apa yang dimaksud oleh komunikasi TCP dan UDP agar kita
dapat memahami prinsip kerja dari keduanya. Hal ini dikarenakan komunikasi TCP dan UDP antara perangkat
wemos tidak jauh berbeda dari segi teknis dan protokol dengan komunikasi antara perangkat komputer.
TCP (Tranmission Control Protocol) adalah sebuah protokol yang berorientasi dengan koneksi. TCP
akan melakukan pengecekan galat dari setiap komunikasi yang terhubung dan menjamin data yang terkirim
akan sesuai dengan data aslinya. Sedangkan UDP (User Datagram Protocol) adalah protokol komunikasi yang
hampir mirip dengan TCP. Hanya saja di dalam UDP tidak ada pengecekan error dan prosedur perbaikan data
ketika data yang diterima tidak sesuai dengan data aslinya.
TCP sangat handal dalam pengiriman data, namun jika dibandingkan dengan UDP, kecepatan
transfer data TCP lebih lambat dari UDP, dikarenakan dalam TCP banyak protokol yang harus dijalankan
untuk menjamin data yang sampai sesuai dengan data aslinya. Sebelum melakukan pengiriman data ke
perangkat lain, TCP akan membangun terlebih dahulu komunikasi antara server dan client. Ketika sudah
terbangun jembatan komunikasi, maka perangkat dapat mengirimkan data satu sama lain. Lain hal dengan
UDP, yang tidak perlu membangun jembatan koneksi, dan langsung mengirimkan data tanpa memperdulikan
data yang sampai sesuai dengan data aslinya atau tidak.
TCP lebih banyak digunakan pada world wide web, secure shell, file transfer protocol, email.
Sedangkan UDP lebih banyak digunakan pada VPN, streaming video, online game, live broadcast, domain
name system, voice over internet protocol, trivial file transfer protocol.

Gambar 17 Komunikasi antara ESP8266.

38
MATERI 4.1 : KOMUNIKASI TCP
Pada subbab ini, kita akan menjalankan skenario komunikasi TCP antara dua perangkat wemos, yang
dimana salah satu perangkat wemos akan menjadi server dan satunya akan menjadi client. Komunikasi yang
dilakukan nantinya tidak terkait dengan bahasa pemrograman PHP dan HTML. Jadi yang kita bahas kali ini
hanyalah protokol komunikasi TCP/IP antara perangkat wemos. Antara wemos tersebut nantinya akan
bertukar data antara satu sama lain. Client akan mengirimkan perintah dan server akan membalas perintah
tersebut.

Tujuan
1. Peserta dapat memahami konsep kerja dari TCP IP.
2. Peserta dapat memahami komunikasi antara wemos dengan menggunakan protokol TCP IP.

Bahan-Bahan yang Digunakan

1. Satu buah Wemos D1 Mini.
2. Satu buah wemos lolin32.
3. Kabel secukupnya.
4. DHT11.
5. LDR.
6. Satu buah push button.
7. Dua buah LED.
8. Kabel Micro USB.

Langkah-Langkah secara Umum

1. Rangkaialah sesuai Gambar 18.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.
5. Buka serial monitor untuk melihat hasilnya.

Gambar Rangkaian

39
 Gambar 18 Komunikasi Antara Perangkat Wemos dengan TCP IP

Koding
A. Koding Server Wemos D1 Mini
#include <ESP8266WiFi.h>
#include <WiFiClient.h>

char ssid[] = "BGPLaptop";

char pass[] = "bagusgilang";
WiFiServer server(80);

IPAddress ip(192, 168, 137, 80);

IPAddress gateway(192, 168, 137, 1);
IPAddress subnet(255, 255, 255, 0);

void setup() {
Serial.begin(115200);
WiFi.config(ip, gateway, subnet);
WiFi.begin(ssid, pass);
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}
server.begin();
Serial.print("IP : ");
Serial.println(WiFi.localIP());
Serial.println();
}

void loop () {
WiFiClient client = server.available();
if (client) {
if (client.connected()) {

40
 Serial.println(".");
String request = client.readStringUntil('\r');
Serial.print("From client: ");
Serial.println(request);
Serial.print("IP : ");
Serial.println(client.remoteIP());
client.flush();
client.println("Hi client! No, I am listening.\r");
}
client.stop();
}
}

B. Koding Client Wemos Lolin32

#include <ESP8266WiFi.h
#include <WiFiClient.h>

char ssid[] = "BGPLaptop";

char pass[] = "bagusgilang";

IPAddress server(192,168,0,80);
WiFiClient client;

void setup() {
Serial.begin(115200);
WiFi.begin(ssid, pass);
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}
Serial.print("IP : ");
Serial.println(WiFi.localIP());
Serial.println();
}

void loop () {
client.connect(server, 80);
Serial.println(".");
client.println("Hello server! Are you sleeping?\r");
String answer = client.readStringUntil('\r');
Serial.println("from server: " + answer);
client.stop();
delay(2000);
}

Penjelasan Koding

41
 A. Koding Server Wemos D1 mini
#include <ESP8266WiFi.h>
#include <WiFiClient.h>

char ssid[] = "BGPLaptop";

char pass[] = "bagusgilang";
WiFiServer server(80);

IPAddress ip(192, 168, 137, 80);

IPAddress gateway(192, 168, 137, 1);
IPAddress subnet(255, 255, 255, 0);
Pada koding di atas, kita akan menyetel wemos yang akan dijadikan sebagai server untuk bekerja di
port 80 (WiFiServer server(80)). Untuk memudahkan akses terhadap server, maka kita akan menyetel dari
awal alamat IP, gateway, dan subnet mask-nya.
void setup() {
Serial.begin(115200);
WiFi.config(ip, gateway, subnet);
WiFi.begin(ssid, pass);
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}
Kemudian, kita menghubungkan wemos ke server yang ada. Dalam skenario ini, kita menjalankan
wemos sebagai station. Wemos juga kita konfigurasi agar ip, gateway, dan subnet-nya sesuai dengan yang
kita tentukan di bagian koding sebelumnya (WiFi.config(ip, gateway, subnet);).
server.begin();
Serial.print("IP : ");
Serial.println(WiFi.localIP());
}
Setelah kita menghubungkan wemos dengan WiFi, maka langkah selanjutnya adalah menyalakan
server-nya dan mencetak di serial monitor alamat IP-nya.
void loop () {
WiFiClient client = server.available();
if (client) {
if (client.connected()) {
Serial.println(".");
String request = client.readStringUntil('\r');
Serial.print("From client: "); Serial.println(request);
Serial.print("IP : "); Serial.println(client.remoteIP());
client.flush();
client.println("Hi client! No, I am listening.\r");
}
client.stop();
}

42
}
Syntax koding di atas, akan membaca apakah ada client yang terhubung dengan server wemos. jika
terhubung, maka server akan membaca masukkan dari client. Jika client memberikan masukan, maka akan
dibalas oleh server sesuai dengan yang kita perintahkan dan juga server akan mencetak alamat IP dari client
yang terhubung. Di akhir koding, setiap koneksi yang tersambung, akan diputuskan sehingga jika terdapat
koneksi dari perangkat lain, perangkat yang lain tidak terblokir dengan sendirinya.
B. Koding Client Wemos Lolin32
#include <WiFi.h>
#include <WiFiClient.h>

char ssid[] = "BGPLaptop";

char pass[] = "bagusgilang";

IPAddress server(192,168,137,80);
WiFiClient client;
Pada koding di atas, kita memberikan informasi mengenai jaringan WiFi yang akan kita koneksikan
dengan wemos. kemudian, kita membuat kelas dengan tipe IPAddress bernama server, yang berguna untuk
akses menuju server. Dalam kelas server, kita memasukkan IP address server yang kita tuju. Lalu, kita juga
membuat kelas bernama client dengan tipe WiFiClient yang berguna untuk mengatur komunikasi antara
server dan client.
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, pass);
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}
Serial.print("IP : ");
Serial.println(WiFi.localIP());
}
Pada koding ini, kita mengoneksikan wemos client dengan jaringan WiFi. Setelah terkoneksi, kita
mencetak alamat IP yang diberikan ke dalam serial monitor.
void loop () {
client.connect(server, 80);
Serial.println(".");
client.println("Hello server! Are you sleeping?\r");
String answer = client.readStringUntil('\r');
Serial.println("from server: " + answer);
client.stop();
delay(2000);
}

43
 Pada koding client.connect(server, 80);, kita mengoneksikan wemos client ke wemos server. Setelah
terkoneksi, kita akan mengirimkan perintah berupa kalimat “Hello Server! Are you sleeping?\r”. Setelah
mengirimkan perintah tersebut, kita akan membaca apakah ada balasan dari server atau tidak. Balasan yang
diterima nantinya akan di cetak ke dalam serial monitor. Setelah terjadi komunikasi antar client dan server,
maka client akan memutuskan hubungan dengan server yang bersangkutan. Kemudian menjalankan tunda
kerja selama dua detik.

Hasil Penerapan Koding

A. Koding Server

Gambar 19 Hasil komunikasi dari sudut pandang server.

Gambar 15 merupakan hasil komunikasi antara server dan client yang dimana pihak server mencetak
apa yang dikirimkan oleh client.
B. Koding Client

44
 Gambar 20 Hasil komunikasi antara server dan client dari sudut pandang client.

Gambar 16 merupakan hasil komunikasi antara client dan server. Pihak client akan menerima
jawaban dari server setelah mengirimkan perintah kepadanya.

MATERI 4.2 : KOMUNIKASI UDP

Pada subbab kali ini, kita akan menjalankan skenario komunikasi antara perangkat wemos dengan
protokol UDP. Sama seperti protokol TCP sebelumnya, kita tidak terikat dengan PHP dan HTML. Dalam
skenario komunikasi UDP, tidak ada peran server dan client. Ini dikarenakan dalam UDP tidak diperlukan
jembatan koneksi. Salah satu perangkat wemos hanya menyiarkan apa yang akan dikirimkan ke alamat IP
yang dituju. Perangkat dengan alamat IP yang dituju akan mendengar apa yang dikrimkan oleh pengirimnya.
Konsekuensi yang harus dipahami dalam komunikasi UDP adalah karena tidak adanya pengecekan galat,
maka bisa saja pesan yang sampai tidak sesuai dengan yang dikirimkan oleh pihak wemos pengirim.

Tujuan
1. Peserta dapat memahami komunikasi UDP antara perangkat.
2. Peserta dapat menjalankan skenario UDP antara perangkat wemos.

Bahan-Bahan yang Digunakan

1. Satu buah Wemos D1 Mini.
2. Satu buah wemos lolin32.
3. DHT11.

45
 4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.

Langkah-Langkah secara Umum

1. Rangkaialah sesuai Gambar 18.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.
5. Buka serial monitor untuk melihat hasilnya.

Gambar Rangkaian

Gambar 21 Rangkaian komunikasi antara perangkat dengan protokol UDP

Koding
Terapkan koding di bawah ini, untuk semua wemos.
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

char *ssid = "TP-LINK_C65FAC";

const char *pass = "0987654321";

unsigned int localPort = 2000;

IPAddress SendIP(192, 168, 137, 255);
WiFiUDP udp;

char packetBuffer[9];

46
void setup(){
Serial.begin(115200);
Serial.println();

WiFi.begin(ssid, pass);
Serial.println();

while (WiFi.status() != WL_CONNECTED){

delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Connected to ");
Serial.println(ssid);
Serial.print("IP Address: ");
Serial.println(WiFi.localIP());

Serial.println("Starting UDP");
udp.begin(localPort);
Serial.print("Local Port: ");
Serial.println(localPort);
}

void loop(){
int cb = udp.parsePacket();
if (!cb){
if (Serial.available() > 0){
udp.beginPacket(SendIP, 2000);

char a[1];
a[0] = char(Serial.read());
udp.write(a, 1);
udp.endPacket();
}
}
else{
udp.read(packetBuffer, 1);
Serial.print(packetBuffer);
delay(20);
}
}

Penjelasan Koding
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

47
char *ssid = "TP-LINK_C65FAC";
const char *pass = "0987654321";

unsigned int localPort = 2000;

IPAddress SendIP(192, 168, 137, 255);
WiFiUDP udp;

char packetBuffer[9];
koding di atas berguna untuk memberikan detail jaringan WiFi yang akan dihubungkan. unsigned int
localPort = 2000; adalah syntax untuk mensetel komunikasi UDP berjalan di port 2000. Kemudian di baris
selanjutnya, kita menyatakan bahwa pesan yang kita kirimkan akan disiarkan ke seluruh alamat IP dari
192.168.137.0 sampai dengan 192.168.137.254. Sedangkan, packetBuffer[9] adalah variabel penyimpanan
ketika kita menerima pesan dari wemos lain.
void setup()
{
Serial.begin(115200);
Serial.println();

WiFi.begin(ssid, pass);
Serial.println("");

while (WiFi.status() != WL_CONNECTED) {

delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Connected to ");
Serial.println(ssid);
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
Serial.println("Starting UDP");
udp.begin(localPort);
Serial.print("Local port: ");
Serial.println(localPort);
}
Syntax koding di atas akan menghubungkan wemos ke jaringan WiFi dan mencetak alamat IP yang
diberikan oleh router. Lalu, wemos akan menjalankan fungsi komunikasi UDP dengan port yang telah
ditentukan.
void loop()
{
int cb = udp.parsePacket();
if (!cb){
if (Serial.available() > 0){
udp.beginPacket(SendIP, 2000);
char a[1];
48
 a[0] = char(Serial.read());
udp.write(a, 1);
udp.endPacket();
}
}
Udp.parserPacket() merupakan sebuah fungsi untuk membaca apakah ada paket data yang diterima
oleh wemos atau tidak. Ketika tidak ada data yang diterima, maka wemos akan mengirimkan paket data yang
telah ditentukan. udp.beginPacket(SendIP, 2000) adalah syntax yang berguna untuk tujuan pengiriman paket
data dan port yang digunakan. Dalam skenario ini, kita akan mencoba mengirimkan data melalui serial
monitor selayaknya applikasi percakapan yang sering kita gunakan. Maka dari itu, kita menjadikan serial
monitor untuk membaca masukkan dari pesan yang akan dikirimkan. Dalam koding, hal tersebut
diterjemahkan ke dalam a[0] = char(Serial.read()).
Setelah data dikirimkan melalui serial monitor, kita akan mengirimkan data melalui UDP per satu
byte. Pengiriman tersebut akan dilakukan hingga jumlah paket data yang kita masukkan melalui serial
monitor selesai. Sebagai contoh : jika kita mengirimkan “Hello”, maka wemos akan mengirimkan per satu
huruf hingga huruf terakhir “o” dikirimkan. Setelah dikirimkan, maka nanti kita tutup paket data UDP-nya
dengan syntax udp.endPacket() untuk memberitahukan ke pihak penerima bahwa itu adalah akhir dari paket
datanya.
else {
udp.read(packetBuffer, 1);
Serial.print(packetBuffer);
delay(20);
}
}
ketika wemos menerima paket data dari wemos lain, maka kita akan membaca paket data tersebut
per satu byte dan mencetak data tersebut ke dalam serial monitor.

49
Hasil Penerapan Koding

Gambar 22 Komunikasi antara perangkat wemos melalui UDP skenario kesatu.

Gambar 23 Komunikasi antara perangkat wemos melalui UDP skenario kedua.

Gambar 22 dan Gambar 23 menunjukkan bahwa komunikasi antara dua perangkat wemos yang
menggunakan UDP sangat tidak bisa diandalkan. Data yang dikirimkan antara keduanya tidak terkirim secara
sempurna. Ada beberapa bagian data yang terhapus dan terkirim secara acak.

50
MATERI 5 : WEBSERVER
Pada bab kali ini, kita akan membahas mengenai penerapan webserver pada esp8266. Sebelum kita
masuk lebih lanjut, kita harus memahami dulu apa yang dimaksud dengan webserver. Webserver adalah
sebuah perangkat yang menyimpan, memproses dan mengirimkan halaman-halaman website kepada web
client. Sedangkan web client hanyalah web browser saja yang bisa kita gunakan di smartphone ataupun
laptop. Adapun komunikasi antara server dan client menggunakan protokol khusus, yakni HTTP (Hypertext
Transfer Protocol). Pada protokol ini, client akan memulai komunikasi dengan meminta halaman website
khusus atau jika yang diminta tidak ada, maka client akan menerima pesan error 404. Halaman-halaman
website yang dikirimkan oleh server sebagian besar adalah dokumen HTML. Tabel di bawah ini merupakan
daftar jenis respon yang diberikan oleh server untuk client dalam menjawab permintaan client.
Tabel 2 Kode Status Respon Server Kepada Client

Kode
Pengertian
Status

200 OK: Permintaan client berhasil dijalankan

Lihat yang lain : biasa digunakan untuk mengalihkan ke alamat web yang lain, setelah
303
melakukan permintaan POST sebagai contoh.

Permintaan buruk : server tidak mengerti apa yang diminta karena syntax-nya ada yang
400
salah.

401 Tidak diizinkan: dibutuhkan izin pengguna untuk mengaksesnya.

403 Terlarang: server menolak permintaan meskipun ada izin pengguna.

404 Tidak ditemukan: permintaan alamant dari pengguna tidak ditemukan.

Terjadi galat internal pada server: server mengalami kondisi yang tidak diharapkan dan
500
tidak dapat memenuhi permintaan client.

Skenario webserver yang kita gunakan adalah bertipe jaringan lokal dan untuk esp8266 akan
dijadikan ke dalam mode station. Ada beberapa skenario yang akan kita bahas dari mulai dasar-dasar
webster, kemudian client melakukan request, dan yang terakhir adalah auto-refresh web page.

51
MATERI 5.1 : DASAR-DASAR WEBSERVER PADA ESP8266
Pada subbab kali ini, kita akan membahas tentang dasar-dasar penerapan webserver pada ESP8266.
Pada umumnya, penerapan webserver pada ESP8266 tidak jauh berbeda dari penerapan ESP8266 pada
server desktop. Hanya saja dalam ESP8266, kita tidak menggunakan php sebagai pemrograman backend,
tetapi menggunakan bahasa C++ itu sendiri sebagai pemrograman backend yang berguna untuk mengatur
jalannya webserver. Sedangkan untuk frontend, kita tetap menggunakan HTML beserta tambahannya
seperti javascript. Pelatihan subbab ini, kita akan menjalankan webserver yang nantinya berguna untuk
menampilkan nilai sensor LDR. Wemos akan membaca nilai sensor LDR dan kemudian mempublikasikannya
di halaman website secara lokal.

Tujuan
1. Peserta memahami dasar-dasar dari webserver pada ESP8266.
2. Peserta dapat membangun website menggunakan ESP8266

Bahan-Bahan yang Digunakan

1. NodeMCU ESP8266.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.

Langkah-Langkah secara Umum

1. Rangkaialah sesuai gambar pada materi 2.1 INPUT.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.
5. Buka serial monitor untuk melihat hasilnya.

Koding C++
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266WiFiMulti.h>
52
const char *ssid = "POCO X3 NFC";
const char *pass = "11223344";

ESP8266WebServer server(80);

void handleRoot();
void handleNotFound();
const int inputLDR = A0;

ESP8266WiFiMulti WiFiMulti;

void setup(){
Serial.begin(115200);

Serial.println("Connecting to WiFi..");
WiFi.mode(WIFI_STA);
WiFiMulti.addAP(ssid, pass);
Serial.println("\n\n");
Serial.println("Wait for WiFi..");
while (WiFiMulti.run() != WL_CONNECTED){
Serial.print(".");
delay(100);
}

IPAddress IP = WiFi.localIP();
Serial.println("WiFi Connected.\n IP Address: ");
Serial.println(IP);

server.on("/", handleRoot);
server.onNotFound(handleNotFound);
server.begin();
Serial.println("HTTP Server Started.");
}

void loop(void){
server.handleClient();
}

void handleRoot(){
float LDRSensorValue = analogRead(inputLDR);
String LDRSensorValueStr = String((LDRSensorValue/ 1023) * 5000);
const String HTML_Str = "<!DOCTYPE html><html>\
<body>\
<h1>ESP32 Web Server</h1>\
<p>LDR Sensor Value ="\
+ LDRSensorValueStr +\
"</p></body></html>";

53
 server.send(200, "text/html", HTML_Str);
}

void handleNotFound(){
server.send(404, "text/plain", "404: Not Found!");
}

Koding HTML
<html>
<body>
<h1>ESP32 Web Server</h1>
<p>LDR Sensor Value = $LDRSensorValue</p>
</body>
</html>

Penjelasan Koding C++

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266WiFiMulti.h>

const char* ssid = "BGPLaptop";

const char* pass = "bagusgilang";

ESP8266WebServer server(80);

void handleRoot();
void handleNotFound();
const int inputLDR = A0;

ESP8266WiFiMulti WiFiMulti;
Pada syntax koding di atas, kita menggunakan library tambahan, yaitu ESP8266WebServer yang
berguna sebagai alat untuk membangun webserver pada wemos yang akan kita gunakan. Setelah
dideklarasikan library-nya, kita membuat class ESP8266WebServer bernama server dan port yang digunakan
adalah port 80. Kita membuat dua buah prosedur untuk mengakomodir webserver, yaitu handleRoot dan
handleNotFound. handleRoot berguna ketika client melakukan Request pertama kali pada server dan server
akan menjalankan prosedur handleRoot. Sedangkan handleNotFound berguna ketika client melakukan
Request namun server tidak memiliki apa yang diminta client, maka server akan menjalankan prosedur ini.
server.on("/", handleRoot);
server.onNotFound(handleNotFound);
server.on("/LED", handleLED);
server.begin();
Serial.println("HTTP server started");

54
 Pada koding ini, server.on("/", handleRoot) berguna untuk memasangkan server dengan prosedur
handleRoot, dan ketika client mengakses alamat IP di browser-nya dengan ekstensi “/”, maka server akan
mengirimkan apa yang ada di handleRoot. Server.onNotFound(handleNotFound) berguna untuk
memasangkan server dengan prosedur handleNotFound, yang dimana ketika permintaan client tidak ada di
database server, maka server akan menjalankan fungsi handleNotFound. Setelah dilakukan penyetelah,
maka kita akan menjalankan server.begin untuk menyalakan servernya.
void loop(void){
server.handleClient();
}

void handleRoot(){
float LDRSensorValue = analogRead(inputLDR);
String LDRSensorValueStr = String((LDRSensorValue/ 1023) * 5000);
const String HTML_Str = "<!DOCTYPE html><html>\
<body>\
<h1>ESP32 Web Server</h1>\
<p>LDR Sensor Value ="\
+ LDRSensorValueStr +\
"</p></body></html>";
server.send(200, "text/html", HTML_Str);
}

void handleNotFound(){
server.send(404, "text/plain", "404: Not Found!");
}
Koding yang ada di void loop hanya akan menjalankan satu syntax, yaitu server.handleClient() yang
artinya akan dilaksanakan ketika terhubung dengan client. Pada prosedur void handleRoot(), wemos akan
diperintahkan untuk membaca sensor LDR yang nantinya akan ditampilkan di halaman web. Pada konstanta
HTML_Str, di dalamnya terdapat isi koding HTML yang akan ditampilkan ketika client meminta halaman awal.
Server.send(200, “text/html”, HTML_Str) adalah syntax yang berfungsi untuk mengirimkan konstanta
HTML_Str kepada client, nilai 200 adalah konfirmasi yang menyatakan bahwa permintaan client telah
dijalankan dengan sukses, sedangkang text/html adalah perintah kepada browser untuk menerjemahkan
HTML_Str ke dalam ranah HTML. Untuk void handleNotFound(), berisi tentang bagaimana server menangani
permintaan yang tidak ada pada server itu sendiri, server akan mengirimkan kode 404 yang berarti tidak
ditemukan, text/plain yang berarti string “404: Not found” akan diproses sebagai teks biasa.

Penjelasan Koding HTML

<html>
<body>
<h1>ESP32 Web Server</h1>
<p>LDR Sensor Value = $LDRSensorValue</p>
</body>

55
</html>
Pada koding di atas, kita akan membuat halaman awal yang akan diberikan kepada client ketika client
meminta akses awal dari server. Bagian meta merupakan penyetelan untuk layout dari halaman website
yang kita buat. Style berguna untuk mendesign seperti apa tampilan dari halaman web yang kita buat. Di
bagian body, terdapat heading <h> untuk menampilkan teks ESP32 Web Server. Dan paragraf <p> untuk
menampilkan nilai dari nilai sensor LDR.

Hasil Penerapan Koding

Gambar 24 Tampilan akses website lokal wemos.

Tampilan halaman web di atas akan muncul ketika kita mengakses alamat IP dari server wemos baik
dari browser komputer maupun smartphone. Kita akan mendapati nilai LDR, namun untuk memperbaharui
nilai LDR yang ada di website, kita harus menekan tombol F5 secara manual untuk menyegarkan kembali
halaman yang ada.

MATERI 5.2 : HTTP REQUEST

Terdapat dua macam jenis Request, yaitu POST dan GET. GET Request digunakan untuk mengambil
data yang ada pada server seperti halaman website. GET Request pada dasarnya tidak mengubah apapun
yang ada di dalam server, hanya mengambil data yang ada pada server tanpa ada efek yang lain. Ketika kita
membuka halaman website di browser kita, browser tersebut akan membaca URL yang kita tuliskan dan
menaruhnya pada HTTP GET Request. Kemudian, GET akan mengirimkannya kepada server yang dituju
menggunakan protokol TCP. Server akan membaca permintaan Get tersebut, kemudian mengecek URL-nya
sesuai dengan syntax yang berlaku, lalu mengirimkan HTTP response kepada browser pengirim ditambah
data yang ia minta. GET tidak memiliki struktur HTTP, hanya saja ia menggunakan url untuk melakukan
permintaan data.
Sedangkan POST Request berguna untuk mengirimkan data yang ada pada server, sebagai contoh,
kita mengirimkan username dan password ke server ketika ingin masuk ke dalam server tersebut, atau ketika
kita ingin mengupload foto. Tidak seperti GET, POST dapat mengubah data yang ada pada server atau

56
keadaan dari server tersebut. POST memiliki struktur yang dapat menyimpan data yang akan dikirimkan ke
server.

Tujuan
1. Peserta memahami pengertian dan perbedaan antara GET dan POST Request.
2. Peserta dapat menggunakan POST dan GET dalam melakukan Request yang ditujukan kepada
webserver ESP8266.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.

Langkah-Langkah secara Umum

1. Rangkaialah sesuai gambar rangkaian Materi 2.1 INPUT.
2. Ketik koding yang tersedia pada sketch arduino.
3. Setelah selesai di ketik kodingnya, diunggah kodingnya.
4. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.
5. Buka serial monitor untuk melihat hasilnya.

Koding C++
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266WiFiMulti.h>

const char* ssid = "BGPLaptop";

const char* pass = "bagusgilang";

ESP8266WebServer server(80);

void handleRoot();
void handleNotFound();
void handleLED();

57
const int inputLDR = A0;
const int outputD1 = D1;
String ledStatus = "OFF";

ESP8266WiFiMulti WiFiMulti;

void setup() {
Serial.begin(115200);
pinMode(outputD1, OUTPUT);
digitalWrite(outputD1, LOW);

Serial.println("Connecting to WiFI...");
WiFi.mode(WIFI_STA);
WiFiMulti.addAP(ssid, pass);
Serial.println("\n\n");
Serial.println("wait for WiFi...");
while (WiFiMulti.run() != WL_CONNECTED) {
Serial.print(".");
delay(100);
}

IPAddress IP = WiFi.localIP();
Serial.println("WiFi Connected.\n IP address: ");
Serial.println(IP);

server.on("/", handleRoot);
server.onNotFound(handleNotFound);
server.on("/LED", handleLED);
server.begin();
Serial.println("HTTP server started");
}

void loop(void) {
server.handleClient();
}

void handleRoot() {
float LDRSensorValue = analogRead(inputLDR);
String LDRSensorValueStr = String((LDRSensorValue / 1023) * 5000);
const String HTML_Str = "<!DOCTYPE html><html>\
<body>\
<h1>ESP32 Web Server</h1>\
<form action=\"/LED\" method=\"POST\">\
<input type=\"submit\" value=\"Toggle LED :" + ledStatus + "\">\
</form>\
<p>LDR Sensor Value ="\
+ LDRSensorValueStr +\

58
 "</p></body></html>";
server.send(200, "text/html", HTML_Str);
}

void handleNotFound() {
server.send(404, "text/plain", "404: Not found");
}

void handleLED() {
digitalWrite(outputD1, !digitalRead(outputD1));
if (digitalRead(outputD1)) {
ledStatus = "ON";
}
else {
ledStatus = "OFF";
}
server.sendHeader("Location", "/");
server.send(303);
}

Koding HTML
<html>
<body>
<h1>ESP32 Web Server</h1>
<form action="/LED" method="POST">
<input type="submit" value="Toggle LED :" + ledStatus + "\">
</form>
<p>LDR Sensor Value = $LDRSensorValue </p>
</body>
</html>

Penjelasan Koding C++

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266WiFiMulti.h>

const char* ssid = "BGPLaptop";

const char* pass = "bagusgilang";

ESP8266WebServer server(80);

void handleRoot();
void handleNotFound();
void handleLED();

const int inputLDR = A0;

const int outputD1 = D1;
59
String ledStatus = "OFF";

ESP8266WiFiMulti WiFiMulti;
Syntax koding pada skenario ini pada dasarnya hampir sama dengan skenario sebelumnya, hanya
saja ada beberapa tambahan untuk mengakomodir skenario HTTP request. Untuk mensimulasikan HTTP
Request, kita memakain LED yang nantinya dapat dinyalakan dan dihidupkan oleh client. LED yang kita
gunakan akan terhubung dengan pin D1. Kita juga membuat prosedur handleLED untuk mengatur nyala dan
mati dari led tersebut yang diatur oleh client. Adapun variabel string yang kita buat berupa ledStatus berguna
untuk menyimpan status nyala dari LED tersebut. ia bersifat string karena nantinya status tersebut akan
ditampilkan di alamat website ketika di akses oleh client pada browsernya.
server.on("/", handleRoot);
server.onNotFound(handleNotFound);
server.on("/LED", handleLED);
server.begin();
Prosedur handleLED pun dipasangkan dengan kelas server yang telah kita buat sebelumnya sebagai
media pengatur nyala dan mati lampu LED pada wemos.
void loop(void) {
server.handleClient();
}

void handleRoot() {
float LDRSensorValue = analogRead(inputLDR);
String LDRSensorValueStr = String((LDRSensorValue / 1023) * 5000);
const String HTML_Str = "<!DOCTYPE html><html>\
<body>\
<h1>ESP32 Web Server</h1>\
<form action=\"/LED\" method=\"POST\">\
<input type=\"submit\" value=\"Toggle LED :" + ledStatus + "\">\
</form>\
<p>LDR Sensor Value ="\
+ LDRSensorValueStr +\
"</p></body></html>";
server.send(200, "text/html", HTML_Str);
}

void handleNotFound() {
server.send(404, "text/plain", "404: Not found");
}
Kemudian pada prosedur void handleRoot(), kita menambahkan beberapa baris koding untuk
mengakomodir tombol LED pada halaman website. Lalu, kita menambahkan variabel string ledStatus untuk
menunjukkan status nyala LED sebagai informasi kepada client ketika mengakses web yang diminta.
void handleLED() {
digitalWrite(outputD1, !digitalRead(outputD1));

60
 if (digitalRead(outputD1)) {
ledStatus = "ON";
}
else {
ledStatus = "OFF";
}
server.sendHeader("Location", "/");
server.send(303);
}
Pada prosedur handleLED(), kita membangun struktur syntax yang berfungsi untuk mengakomodir
permintaan dari client untuk mengatur nyala lampu LED pada server. Ketika lampu LED menyala, dan datang
perintah dari client untuk mengubah status nyala lampu, maka koding digitalWrite(outputD1,
!digitalRead(outputD1)) berguna untuk memerintahkan lampu LED agar yang menyala sebelumnya untuk
mati setelahnya, dan sebaliknya. Lalu, status dari nyala lampu tersebut akan merubah nilai dari variabel
string ledStatus sesuai dengan kondisi dari lampu LED-nya.
Adapun koding dari server.sendHeader(“Location”, “/”) berguna untuk mengirimkan perintah
kepada client untuk kembali ke halaman awal yang disimbolkan dengan “/”. Sedangkan server.send(303)
merupakan perintah server kepada cilent untuk segera berpindah kehalaman yang dituju.

Penjelasan Koding HTML

<html>
<body>
<h1>ESP32 Web Server</h1>
<form action="/LED" method="POST">
<input type="submit" value="Toggle LED :" + ledStatus + "\">
</form>
<p>LDR Sensor Value = $LDRSensorValue </p>
</body>
</html>
Pada koding di atas, pada dasarnya masih sama dengan skenario sebelumnya. Hanya saja ada
tambahan pada bagian <form> untuk membuat tombol yang ketika ditekan oleh client, ia akan mengirimkan
POST Request untuk mengubah status menyala LED pada wemos.

Hasil Penerapan Koding

Gambar 25 Hasil Akses Website ESP8266 Webserver.

61
 Pada gambar di atas, merupakan tampilan halaman website yang muncul ketika kita mengakses
alamat IP server wemos baik dari browser komputer maupun smartphone.

MATERI 6 : ADAFRUIT & IFTTT

Pada materi kali ini, kita akan membahas salah satu protokol yang sangat penting dalam dunia
internet of things (IOT), yaitu MQTT. Protokol MQTT (Message Queuing Telemetry Transport) adalah sebuah
protokol yang berjalan di atas stack TCP/IP dan mempunyai ukuran paket data yang sangat kecil minimum 2
bytes sehingga memberikan keuntungan pada konsumsi daya dan bandwidth yang rendah.
Protokol jenis ini adalah jenis protokol data-agnostic yang artinya kita bisa mengirimkan data
kemanapun, dimanapun, dan dalam bentuk apapun seperti data binary, text, XML, JSON, bahkan gambar.
Protokol ini memakai model publish/subscribe dibandingkan dengan protokol TCP/IP yang berupa client-
server.

Gambar 26 Sistem komunikasi MQTT.

Secara umum, sistem MQTT terdiri dari dua macam perangkat, sebagai berikut:
1. MQTT Client yang akan dipasangkan pada perangkat yang diinginkan, seperti laptop,
mikrokontroller, komputer, smartphone, raspberry pi dll. MQTT client berfungsi sebagai user
pengiriman dan penerimaan data komunikasi.
2. MQTT Broker yang berfungsi untuk menangani publish dan subscribe data yang diterima dari
client.

62
 Keuntungan penggunaan dari sistem publish dan subscribe adalah antara sumber pengirim data dan
penerima data tidak saling mengetahui karena ada broker diantaranya. Broker bertindak seperti orang
tengah yang mengantarkan data hanya ketika diminta oleh client atau menerima data ketika ada client yang
mengirimkan. Sistem ini bisa dianalogikan seperti penyuplai – distribusi – pengguna, dimana pengguna tidak
perlu tahu siapa yang menyuplai, penyuplai tidak perlu tahu siapa yang menggunakan datanya, dan
distributor menyalurkan dan menerima data sesuai permintaan yang ada. Tidak seperti protokol TCP/IP yang
mengharuskan antara client dan server untuk saling terhubung agar dapat berkomunikasi data. Pada
protokol MQTT tidak diperlukan hubungan antara keduanya, sehingga membuat sistem ini lebih mudah
dalam menangani banyaknya jumlah pengguna.
Pada MQTT dikenal dengan istilah topic. Topic dalam konteks ini berguna sebagai sarana broker
untuk menyaring data yang masuk dan keluar, sebagai contoh :
Mqtt/rumah/suhu
Arti dari syntax di atas adalah kita membuat sebuah topic pada MQTT. Kemudian penyuplai
(publisher) dan pengguna (subscriber) data dapat bertukar informasi mengenai suhu sebuah rumah dengan
menggunakan topik di atas.
Salah satu fitur unggulan pada MQTT adalah Quality of Service (QoS). Kita dapat mengatur level
menyiarkan (publish) data dalam tiga kelas, yang dijelaskan sebagai berikut:
1. Level 0
Pesan hanya disiarkan sekali. Pesan yang terkirim tergantung dari kehandalan jaringan dan
ketersediaan dari bandwidth tersebut. Jika terjadi kegagalan maka sistem tidak akan mengirimkan kembali.
2. Level 1
Pesan disiarkan setidaknya satu kali. Jadi client setidaknya akan menerima pesan tersebut sekali. Jika
subscriber tidak mengakui (acknowledge) maka broker akan mengirimkan pesan sampai publisher menerima
status pengakuuan pesan dari client.
3. Level 2
Pesan pasti diterima satu kali. Protokol dengan level ini memastikan bahwa pesan pasti
tersampaikan dan tidak terjadi duplikasi pesan yang terkirim.
IFTTT (If This Then That) adalah pelayanan gratis berbasis internet yang membuat rantai pernyataan
kondisional, yang disebut applets. Sebuah applet dipicu oleh perubahan yang terjadi pada pelayanan internet
lainnya, seperti gmail, facebook, telegra, mikrokontroller ioT, dll. Sebagai contoh, sebuah applet akan
mengirimkan email jika pengguna twitter menggunakan hastag atau menyalin foto di facebook untuk
diarsipkan jika seseorang menandai si pengguna pada foto tersebut. Sebagai tambahan, IFTTT juga berjalan
di IOS dan android.

63
MATERI 6.1 : ADAFRUIT DASHBOARD WEBSITE
Adafruit.io adalah sebuah layanan yang menyediakan MQTT untuk IoT berbasis cloud yang dimana
pertukaran data pengguna dan penyedia jasa dilakukan seluruhnya melalui jaringan internet. Adafruit.io
memberikan beberapa jenis pelayanan antara lain:
1. Menampilkan data yang dikirimkan pengguna secara real time.
2. Membuat perangkat terkoneksi dengan jaringan internet.
3. Membuat perangkat agar dapat terhubung dengan beberapa pelayanan jaringan website,
seperti twitter, RSS feeds, dll.
Dalam pelatihan ini, kita akan membuat skenario komunikasi antara wemos dan adafruit.io yang
dimana wemos bertindak sebagai MQTT client dan adafruit.io bertindak sebagai MQTT broker. Kita akan
membuat wemos menyiarkan data berupa nilai LDR dan Push button ke broker adafruit.io. Lalu, adafruit.io
akan menampilkan data tersebut sesuai dengan kehendak dari kita sebagai pengguna, apakah dengan
menggunakan gauge, switch, ataupun grafik.

Tujuan
1. Peserta dapat memahami fungsi dari Adafruit IO sebagai broker dalam MQTT.
2. Peserta dapat menghubungkan antara wemos dengan adafruit IO.
3. Peserta dapat membangun komunikasi data antara wemos dan adafruit IO kemudian
mempresentasikan hasilnya sesuai dengan widget-nya.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.

Langkah-Langkah
1. Buatlah akun di alamat io.adafruit.com. Untuk mempermudah pembuatan akun, cukup koneksikan
akun email gmail ke io.adafruit.com.

64
 Gambar 27 Tampilan Halaman Awal io.adafruit.com.

2. Pada halaman awal adafruit, silakan tekan label adafruit IO key (posisi pojok kanan atas) untuk
mendapatkan kode khusus untuk terkoneksi dengan wemos.

Gambar 28 Tampilan adafruit IO key.

3. Simpan key yang telah dihasilkan oleh io.adafruit. key tersebut nantinya menjadi identitas kita
sebagai pengguna untuk berkomunikasi dengan io adafruit.
4. Karena pada skenario ini kita akan menghubungkan push button dan sensor LDR dengan io adafruit,
maka kita akan membuat feeds sebagai jalan komunikasi keduanya. Silahkan tekan menu feeds
bagian atas dan klik viewall.

65
 Gambar 29 Tampilan Feeds pada IO Adafruit.

5. Untuk membangun komunikasi antara IO Adafruit dan wemos, maka kita klik actions (posisi pojok
sebelah kiri), kemudian create new feeds. Isikan nama feed sesuai dengan yang anda inginkan tapi
alangkah baiknya, sesuaikan dengan fungsi pada wemos, sebagai contoh : “pushButtonFeed” dan
“LDRFeed”. Yang perlu diingat lagi adalah besar kecilnya huruf sangat diperhitungkan dalam kasus
ini. Setelah diisikan nama feed-nya, kita bisa mengisikan deskripsi untuk menjelaskan fungsi dari feed
tersebut namun tidak wajib, kemudian klik create. Kita buat dua buah untuk mengakomodir push
button dan LDR.

66
 Gambar 30 Tampilan Create Feeds.

6. Maka nanti akan muncul feed yang kita buat di tabel feeds. Pada tabel feeds, ada berbagai macam
detail, antara lain: key berfungsi sebagai token dari feed yang kita buat, last value merupakan nilai
terakir yang terekam dari komunikasi dengan perangkat wemos, dan recorded adalah waktu
perekaman dari last value.
7. Setelah kita selesai membuat feed, maka kita akan membuat dashboard io adafruit untuk
merepresentasikan hasil komunikasi antara perangkat wemos dan adafruit. Klik menu dashboards
dan klik view all setelahnya (posisi dashboard disebelah feeds). Setelah muncul, klik action kemudian
create a new dashboard. Lalu isikan nama dashboard sesuai dengan yang kalian inginkan dan setelah
itu klik create. Setelah dashboard yang kita buat muncul, maka klik dashboard yang kita buat.

67
 Gambar 31 Tampilan Dashboard Adafruit IO.

Gambar 32 Tampilan Create Dashboard.

8. Untuk menampilkan widget yang berguna untuk merepresentasikan push button dan LDR, maka kita
klik tombol Dashboard Setting di sebelah kanan. Kemudian, kita akan masuk pada Create New Block,
untuk menambahkan widget kita klik pada widget yang diperlukan.

68
Gambar 33 Tampilan Dashboard Setting.

69
 Gambar 34 Tampilan Create a New Block.

9. Karena kita akan membuat untuk push button, maka kita bisa memilih pada panel pertama (sebelah
kiri atas), yang berbentuk switch. Sedangkan, untuk LDR kita pilih pada panel keempat yang
merepresentasikan alat pengukur (sebelah kanan atas).

70
 Gambar 35 Tampilan untuk Memilih Feed yang Akan Dihubungkan.

10. Untuk menghubungkan widget switch dengan feed push button, maka kita check list sesuai dengan
feed-nya. Lalu klik next step jika sudah selesai.

71
Gambar 36 Tampilan Penyetelan untuk Widget Switch.

72
 Gambar 3732 Tampilan Penyetelan Widget LDR.

11. Isikan ketentuan untuk widget switch sesuai dengan Gambar dan widget LDR sesuai dengan Gambar
3732. Setelah diisikan, klik tombol create block.
12. Setelah selesai membuat dashboard, maka selanjutnya kita klik tombol hijau bertuliskan save (posisi
di sebelah tombol ‘+’).

73
 Gambar 38 Adafruit Dashboard dengan Dua Widget.

13. Langkah selanjutnya adalah kita akan memasang library untuk adafruit sebagai sarana komunikasi
antara wemos dan IO adafruit. Ada tiga library yang akan kita pasang pada arduino IDE, yaitu
ArduinoHttpClient, Adafruit IO Arduino, dan Adafruit MQTT.
14. Langkah selanjutnya adalah, kita mengkoding wemos agar bisa berkomunikasi dengan io adafruit.
15. Koding yang telah diketikkan di sketch arduino bisa kita upload setelahnya.
16. Untuk rangkaian, masih tetap menggunakan rangkaian pada materi 2.1 INPUT.

Koding
#define IO_USERNAME "van_a_p"
#define IO_KEY "********************"

#define WIFI_SSID "TP-LINK_C65FAC"

#define WIFI_PASS "0987654321"

#include "AdafruitIO_WiFi.h"
AdafruitIO_WiFi io(IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS);

#include <ESP8266WiFi.h>
#include <AdafruitIO.h>
#include <Adafruit_MQTT.h>
#include <ArduinoHttpClient.h>

#define BUTTON_PIN D2
#define LED_PIN D1
#define LDR_PIN A0

74
int current = 0;
int last = 0;

float sensorValue = 0;
unsigned long previousMillis = 0;
const long interval = 5000;

AdafruitIO_Feed *commandPushButton = io.feed("PushButtonFeed");

AdafruitIO_Feed *commandLDR = io.feed("LDRFeed");

void setup() {
pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(LED_PIN, OUTPUT);

Serial.begin(115200);
Serial.print("Connecting to Adafruit IO");

io.connect();
commandPushButton->onMessage(handleMessagePushButton);
commandLDR->onMessage(handleMessageLDR);

while(io.status() < AIO_CONNECTED) {

Serial.print(".");
delay(500);
}

Serial.println();
Serial.println(io.statusText());
}

void loop() {
io.run();
unsigned long currentMillis = millis();

if (currentMillis - previousMillis >= interval) {

previousMillis = currentMillis;

sensorValue = analogRead(LDR_PIN);
sensorValue = (sensorValue / 1023) * 5000;

Serial.print("sending sensor value -> ");

Serial.println(sensorValue);
commandLDR->save(sensorValue);
}

if (digitalRead(BUTTON_PIN) == LOW)
current = 1;
else

75
 current = 0;

if (current == last)
return;

Serial.print("sending button -> ");

Serial.println(current);

commandPushButton->save(current);
last = current;
}

void handleMessagePushButton(AdafruitIO_Data *data) {

int command = data->toInt();
if (command == 1) {
Serial.print("received <- ");
Serial.println(command);
digitalWrite(LED_PIN, HIGH);
}
else {
Serial.print("received <- ");
Serial.println(command);
digitalWrite(LED_PIN, LOW);
}
}

void handleMessageLDR(AdafruitIO_Data *data) {

int command = data->toInt();
Serial.print("Received sensor value <- ");
Serial.println(command);
}

Penjelasan Koding
#define IO_USERNAME "van_a_p"
#define IO_KEY "********************"

#define WIFI_SSID "TP-LINK_C65FAC"

#define WIFI_PASS "0987654321"

#include "AdafruitIO_WiFi.h"
AdafruitIO_WiFi io(IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS);
Pada koding di atas, kita mendefinisikan beberapa konstanta sebagai penunjang koneksi antara
wemos dan adafruit IO. Dua baris pertama kita mendefinisikan username dan key adafruit yang sudah kita
simpan sebelumnya. Token tersebut sebagai indentitas wemos dalam mengakses feeds yang ada pada
adafruit IO. Dua baris selanjutnya merupakan detail informasi untuk menghubungkan perangkat wemos

76
dengan jaringan WiFi yang kita tentukan. Dua baris terakhir kita mendefinisikan library yang kita gunakan
dalam hal ini adalah AdafruitIO_WiFi.h. Library tersebut nantinya akan kita gunakan untuk menggunakan
fitur utama adafruit dan juga agar bisa menghubungkan wemos dengan adafruit IO. Baris terakhir kita
membentuk sebuah kelas bernama IO yang dimana kita isikan parameter yang telah kita definiskan
sebelumnya.
#include <ESP8266WiFi.h>
#include <AdafruitIO.h>
#include <Adafruit_MQTT.h>
#include <ArduinoHttpClient.h>

#define BUTTON_PIN D2
#define LED_PIN D1
#define LDR_PIN A0
Kemudian, kita menambahkan beberapa library pendukung untuk jalannya komunikasi antara
broker adafruit IO dan wemos. Tiga baris terakhir kita memberikan nama kepada pin yang kita gunakan
sebagai ujicoba dalam praktikum ini.
int current = 0;
int last = 0;

float sensorValue = 0;
unsigned long previousMillis = 0;
const long interval = 5000;
kita juga membuat beberapa variabel untuk mengatur jalannya program. Dua variabel pertama,
current dan last, berguna untuk menyimpan kondisi saat ini dan terakhir dari push button. Variabel
sensorValue berguna untuk menyimpan nilai dari LDR. Dan dua variabel terakhir, previousMillis dan interval,
berguna untuk pengaturan jalannya fungsi millis().
AdafruitIO_Feed *commandPushButton = io.feed("PushButtonFeed");
AdafruitIO_Feed *commandLDR = io.feed("LDRFeed");
Pada koding di atas, kita membuat dua buah kelas dengan jenis yang sama. Kelas tersebut berguna
untuk melakukan komunikasi dengan feed yang ada pada broker adafruit. Satu kelas hanya untuk satu feed.
Sehingga jika kita menggunakan tiga feeds, maka kita harus membuat juga tiga kelas AdafruitIO_Feed.
io.connect();

commandPushButton->onMessage(handleMessagePushButton);
commandLDR->onMessage(handleMessageLDR);

while(io.status() < AIO_CONNECTED) {

Serial.print(".");
delay(500);
}

Serial.println();
77
 Serial.println(io.statusText());
Kemudian kita mengoneksikan wemos dengan jaringan WiFi serta adafruit IO seperti pada baris
pertama. Pada baris kedua dan ketiga, kita akan memasangkan prosedur kepada setiap kelas
adafruitIO_feed. Prosedur ini nantinya akan dieksekusi ketika ada informasi yang datang dari adafruit IO ke
wemos. Baris selanjutnya, kita menunggu koneksi antara wemos, WiFi, dan Adafruit IO. Baik terkoneksi
ataupun tidak, maka status koneksi tersebut akan tercetak di serial monitor.
io.run();

unsigned long currentMillis = millis();

if (currentMillis - previousMillis >= interval)
{
previousMillis = currentMillis;
sensorValue = analogRead(LDR_PIN);
sensorValue = (sensorValue / 1023) * 5000;
Serial.print("sending sensor value -> ");
Serial.println(sensorValue);
commandLDR->save(sensorValue);
}
Pada baris pertama, kita menjalankan kelas io untuk tetap terkoneksi dengan adafruit IO dan saling
bertukar informasi antara keduanya. Kemudian, kita mendefinisikan bahwa untuk pembacaan LDR akan
dilakukan setiap lima menit sekali, maka dari itu kita menggunakan fungsi millis. Di dalam fungsi millis
tersebut, kita melakukan pembacaan LDR. Setelah dibaca nilai LDR, kita mengubah satuan unit nilai tersebut
untuk menjadi microvolt. Setelah didapatkan nilainya, kita menggunakan prosedur save untuk mengirimkan
data nilai LDR ke adafruit IO untuk ditampilkan ke dalam bentuk gauge.
if (digitalRead(BUTTON_PIN) == LOW)
current = 1;
else
current = 0;

if (current == last)
return;

Serial.print("sending button -> ");

Serial.println(current);
commandPushButton->save(current);

last = current;
Lalu, kita mendefinisikan langkah untuk menyalakan LED dengan push button melalui konfirmasi dari
Adafruit IO. Karena kita menggunakan rangkaian aktif LOW, maka ketika push button ditekan akan
menghasilkan nilai low. Nilai tersebut akan disimpan ke dalam variabel current. Jika nilai variabel current
masih sama dengan nilai sebelumnya yang tersimpan dalam last, maka akan dikembalikan ke awal lagi

78
perlaksanaan kodingngya. Jika berbeda dari nilai sebelumnya, maka kita mengirim nilai yang baru ke adafruit
IO. Kemudian, menyimpan nilai yang saat ini pada variabel last.
void handleMessagePushButton(AdafruitIO_Data *data) {
int command = data->toInt();
if (command == 1) {
Serial.print("received <- ");
Serial.println(command);
digitalWrite(LED_PIN, HIGH);
} else {
Serial.print("received <- ");
Serial.println(command);
digitalWrite(LED_PIN, LOW);
}
}
Prosedur yang sebelumnya kita pasangkan dengan feed dimana akan terpicu ketika wemos
mengirimkan data ke adafruit. Data yang dikirimkan ke adafruit kemudian akan dikirimkan kepada semua
perangkat yang berlangganan dengan feed tersebut, dalam hal ini feed yang digunakan untuk menyalakan
dan mematikan LED. Ketika ada informasi yang datang dari adafruit berkaitan dengan feed LED, maka
informasi tersebut akan disimpan pada variabel command. Kemudian, LED akan menyesuaikan status
hidupnya sesuai dengan yang tersimpan dalam variabel command.
void handleMessageLDR(AdafruitIO_Data *data) {
int command = data->toInt();
Serial.print("Received sensor value <- ");
Serial.println(command);
}
Pada koding di atas, kita membuat prosedur untuk membaca informasi yang masuk mengenai feed
untuk LDR. Nilai feed tersebut disimpan dalam variabel command. Kemudian hasilnya akan dicetak di serial
monitor.

Hasil Penerapan Koding

Gambar 39 Hasil Akhir Dashboard Adafruit IO.

79
 Pada Gambar , kita melihat dua buah widget yang telah kita buat. Widget pertama berbentuk toggle
akan mengatur jalannya dari LED yang ada pada wemos tersebut dan widget kedua berbentuk gauge akan
menunjukkan nilai dari LDR dan memberikan peringatan ketika nilai melebihi 4500. Gambar menunjukkan
jalur komunikasi antara wemos dan adafruit IO, setiap pengiriman dan penerimaan data yang dilakukan oleh
wemos dan adafruit akan tercatat pada serial monitor yang kita buka sebelumnya.

Gambar 40 Hasil Komunikasi Serial Adafruit IO dan Wemos.

MATERI 6.2 : ADAFRUIT MQTT DASHBOARD pada ANDROID

SMARTPHONE
Pada skenario kali ini, kita akan menjadikan smartphone kita sebagai MQTT client sehingga jalur
komunikasi yang kita gunakan persis seperti Gambar 26. Dimana wemos akan menjadi sebagai penyuplai
data, adafruit.io sebagai distributor, dan smartphone sebagai penggunanya. Adapun sensor yang kita
gunakan dalam pelatihan ini adalah LDR yang nantinya akan menyiarkan nilai intensitas dari cahaya sekitar,
Input digital yang kita gunakan adalah push button yang akan menyiarkan ketika tombol ditekan atau tidak,
sedangkan output yang kita gunakan adalah LED yang akan berlangganan topik push button dimana akan
menyala atau mati ketika push button menyiarkan statusnya.

Tujuan
1. Peserta dapat memahami cara kerja komunikasi antara wemos, Adafruit IO, dan Aplikasi MQTT pada
smartphone android.
2. Peserta dapat memantau sensor dan mengendalikan nyala lampu LED pada wemos melalui
smartphone yang terhubung dengan adafruit IO.

Bahan-Bahan yang Digunakan

80
 1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.
8. Smartphone yang terinstal MQTT Dashboard.

Langkah-Langkah secara Umum

1. Unduh aplikasi MQTT Dashboard di playstore masing-masing peserta.
2. Setelah terpasang, silakan buka applikasi MQTT Dashboard dan akan muncul seperti pada Gambar
33.

Gambar 33 Halaman Awal MQTT Dashboard.

3. Tekan menu yang ada di pojok kanan bawah hingga muncul seperti pada Gambar 34. Setelah itu, klik
tombol Manage Brokers, maka akan muncul tampilan seperti pada Gambar 35.

Gambar 34 Tampilan Penyetelan Awal Brokers.

81
 Gambar 35 Tampilan Awal Manage Brokers

4. Untuk menambah broker, tekan tombol bulat bertanda “+” di tengah bawah. Lalu akan muncul layar
seperti pada Gambar 36. Isikan sesuai dengan yang ada di gambar tersebut. pada bagian broker
protection, silakan ditekan untuk mengaktifkannya. Maka akan muncul kotak teks username dan
password. Untuk username, silakan isikan username persis seperti username di akun adafruit kita.
Kemudian untuk password, masukkan AIO Key yang sebelumnya kita gunakan sebagai token
identitas. Kalau sudah diisikan, maka kita simpan dan jika sudah akan muncul tampilan seperti pada
Gambar 37.

Gambar 36 Tampilan Edit Broker.

82
 Gambar 37 Tampilan Setelah Penyetelan Disimpan.

5. Tekan tombol kembali untuk menuju halaman awal MQTT Dashboard jika tidak ada kendala
(terkoneksi dengan internet smartphone-nya), maka akan muncul seperti pada Gambar 38.

Gambar 38 Tampilan MQTT Dashboard telah terkoneksi dengan Adafruit IO.

6. Untuk menambahkan widget agar bisa berkomunikasi dengan Adafruit, kita tekan tombol bulat
bertanda “+”. Lalu akan muncul windows seperti pada Gambar 39. Kita pilih label standard dan nanti
akan muncul beberapa macam widget pilihan seperti pada Gambar 40. Karena pada tahap awal kita
membuat widget push button, maka kita pilih widget switch.

Gambar 39 Tampilan Pilihan Kategori Widget.

83
 Gambar 40 Tampilan Pilihan Widget pada MQTT.

7. Setelah kita memilih widget switch, kita masuk ke layar untuk menyetel widget switch tersebut
seperti pada Gambar 41. Kita isikan nama dari widget push button sesuai dengan yang kita inginkan.
Kemudian ada dua buah kotak teks, bagian pertama berlabel unduh berfungsi sebagai subscribe yang
berguna untuk meminta data dari broker, bagian kedua berlabel unggah berfungsi sebagai publish
yang berguna untuk mengirimkan data ke broker. Untuk subscribe dan publish kepada broker, kita
isikan keduanya dengan alamat dari feeds pada IO adafruit, sebagai contoh :
bagusgilangp/feeds/firstiotcommand. Jadi pada widget switch, kita dapat mengontrol LED pada
wemos dari smartphone dan smartphone juga dapat memantau kondisi dari LED tersebut jika
dimatikan dari wemos atau dari brokernya. Lalu, pada Gambar 42, kita bisa mengubah status gambar
ketika mati dan hidup. Nilai yang kita masukkan nantinya harus disesuaikan dengan nilai yang ada di
broker. Kita menggunakan nilai 1 yang menyatakan bahwa LED hidup dan nilai 0 yang menyatakan
bahwa LED mati. Jika sudah diisikan parameternya, maka langkah selanjutnya adalah kita
menyimpannya.

84
 Gambar 41 Tampilan Edit Widget untuk Push Button (1).

Gambar 42 Tampilan Edit Widget untuk Push Button (2).

8. Setelah kita menyimpannya kita akan kembali ke halaman awal. Pada halaman awal tersebut, akan
muncul widget lampu LED yang telah kita buat tadi. Silakan diujicoba apakah ketika ditekan dengan
status 1 akan menyala atau tidak LED pada wemosnya. Jika tidak bisa, maka bisa dicek kembali
parameter-parameter yang sebelumnya dimasukkan ke penyetelan widget.

85
 Gambar 43 Tampilan Adafruit IO Setelah Ditambahkan Push Button.

9. Jika sudah berhasil, kita bisa melanjutkan langkah selanjutnya. Agar dapat merepresentasikan nilai
LDR, kita menggunakan widget progress. Setelah kita masuk ke layar widget progress LDR, kita isikan
parameternya sesuai dengan feed pada IO adafruit. Pada layar ini, kita akan menemui kotak teks
untuk nilai minimun dan maksimum. Untuk nilai minimun nilainya adalah 0 dan untuk nilai
maksimum nilaina adalah 5000. Bisa dilihat pada Gambar 44 dan Gambar 45.

Gambar 44 Tampilan Edit Widget untuk LDR (1).

86
 Gambar 45 Tampilan Edit Widget untuk LDR (2).

10. Jika sudah diisikan parameternya, maka kita simpan. Pada halaman awal, akan muncul widget
progress LDR, akan terupdate ketika wemos mengirimkan nilai LDR ke broker dan broker menyiarkan
nilai tersebut kepada client-nya.

Gambar 46 Tampilan MQTT Dashboard.

MATERI 6.2 : ADAFRUIT X IFTTT

Pada sub materi kali ini, kita akan memadukan antara IFTTT dan adafruit. Skenario yang kita gunakan
adalah kita akan membuat widget tombol pada smartphone menggunakan salah satu fitur dari IFTTT. Tombol

87
tersebut akan mengirimkan perintah untuk menghidupkan dan mematikan LED yang ada di wemos. Jalur
komunikasi yang kita gunakan adalah smartphone melalui aplikasi IFTTT akan mengirimkan data melalui
module button widget, setelah itu IFTTT akan meneruskan data tersebut ke adafruit, dan dari adafruit, ia
akan meneruskan ke wemos, kemdian wemos akan mengeksekusi data yang dikirimkan.

Tujuan
1. Peserta memahami manfaat dari penggunaan IFTTT.
2. Peserta memahami cara mengoneksikan antara IFTTT dan adafruit IO.
3. Peserta memahami jalur komunikasi antara wemos, IFTTT, dan adafruit dalam pertukaran informasi.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.

Langkah-Langkah secara Umum

1. Buat akun IFTTT.com dengan mengoneksikannya dengan akun gmail agar lebih mudah. Kita juga
dapat mendownload aplikasi IFTTT di smartphone android dan mengoneksikannya dengan alamat
gmail kita.
2. Langkah yang awal adalah kita koneksikan Adafruit dengan IFTTT. Buka halaman awal IFTTT yang
sudah dimasukkan akun yang kita buat seperti pada Gambar 47 Tampilan Awal Halaman
IFTTT.Gambar 47.

88
 Gambar 47 Tampilan Awal Halaman IFTTT.

3. Silakan cari kata kunci “adafruit” (Posisi textbox search ada di menu atas). Setelah pencarian, pilih
tabulasi services, maka nanti akan muncul panel adafruit seperti pada Gambar 48.

Gambar 48 Tampilan Awal Halaman Adafruit.

4. Kita klik panel adafruit tersebut. Kemudian nanti akan muncul halaman awal adafruit pada IFTTT
seperti pada Gambar 49. Kita tekan tombol connect kemudian akan muncul permohonan izin IFTTT
untuk membaca beberapa data dari adafruit sesuai dengan akun yang kita miliki. Selanjutnya, kita
tekan tombol authorize seperti pada Gambar 50. Setelah kita tekan, maka nanti akan muncul
informasi bahwa antara adafruit dan IFTTT sudah terhubung.

89
 Gambar 49 Halaman Permintaan Koneksi Adafruit.

Gambar 50 Tampilan Permintaan Izin IFTTT.

5. Selanjutnya, kita akan membuat applets yang dimana skenarionya adalah kita membuat tombol yang
dapat mengatur nyala LED wemos. Untuk itu, kita klik avatar kita (pojok kanan atas) kemudian pilih
create seperti pada Gambar 51.

Gambar 51 Tampilan Pilihan Menu.

90
6. Setelah ditekan, akan muncul halaman create IFTTT (gambar dapat dilihat pada Gambar 52). Langkah
pertama kita tekan tanda tambah untuk membuat pemicu pada IFTTT.

Gambar 52 Tampilan Halaman if THIS.

7. Kemudian kita diminta untuk memilih servis yang akan kita gunakan. Dalam hal ini, kita
menggunakan servis button. Cari dengan kata kunci button setelah itu akan mucul panel seperti pada
Gambar 53. Lalu, kita klik panel tersebut.

Gambar 53 Pemilihan Layanan untuk This.

8. Setelah menekan panel tersebut, kita akan diarahkan menuju pemilihan trigger untuk button widget
(dapat dilihat pada Gambar 54). Kita pilih panel button press dengan cara menekannya.

91
 Gambar 54 Tampilan Halaman Pemilihan Trigger.

9. Pemicu yang telah kita pilih akan tampil gambarnya seperti pada Gambar 55. Selanjutnya, kita akan
memilih reaksi dari pemicu tersebut dengan menekan tanda tambah yang berada di sebelah then.

Gambar 55 Tampilan Pemilihan Aksi Selanjutnya.

10. Pada bagian ini, kita akan memilih servis yang menjadi reaksi. Servis yang kita gunakan adalah
adafruit yang telah kita hubungkan sebelumnya. Silakan dicari dengan kata kunci adafruit pada
textbox. Setelah dicari, maka nanti akan muncul panel adafruit seperti pada Gambar 56.

Gambar 56 Tampilan Pemilihan Layanan Aksi

92
11. Kemudian, kita akan diminta untuk memilih aksi yang dilakukan. Kita pilih panel “send data to
adafruit IO”.

Gambar 57 Tampilan Pemilihan Kategori Aksi.

12. Kita isi parameter yang ada pada Gambar 58. Karena tombol yang kita buat bertujuan untuk
menyalakan LED pada wemos, maka kita pilih feed yang terhubung dengan LED kita, kemudian kita
isikan data yang akan dikirim ke adafruit. Setelah pengisian parameter, kita klik create action.

Gambar 58 Tampilan Pengisian Parameter Adafruit.

13. Langkah terakhir, kita akan diminta untuk meninjau ulang atas apa yang kita buat. Jika parameter
sudah benar maka kita tekan finish. Selanjutnya, kita akan mendapati applets yang kita buat sudah
bisa dijalankan seperti pada Gambar 60.

93
 Gambar 59 Tampilan Meninjau Ulang IFTTT yang Dibuat.

Gambar 60 Tampilan IFTTT yang Telah Terkoneksi.

14. Tahapan untuk pembuatan applets IFTTT sudah selesai, saatnya kita membuat tombol untuk
mengaktifkan applets yang telah kita buat. Tombol yang kita buat sebelumnya hanya bekerja pada
smartphone. Maka dari itu, aplikasi IFTTT yang telah kita pasang dan masukkan akunnya kita
jalankan. Tampilan awal IFTTT pada smartphone ditunjukkan pada Gambar 61. Applets yang kita
buat akan muncul pada panel aplikasi IFTTT.

94
 Gambar 61 Tampilan Awal IFTTT Smartphone.

15. Untuk pembuatan widget tombol IFTTT, silakan kembali ke pengaturan masing-masing smartphone
peserta. Dalam modul ini, kami menggunakan smartphone xiomi 3x. Pembuatan widget-nya
ditunjukan seperti pada Gambar 62. Kita pilih widget IFTTT small 1x1.

95
 Gambar 62 Pembuatan Widget Button pada Smartphone.

16. Setelah pemilihan jenis widgetnya, kita akan diarahkan ke screen pemilihan applets yang kita buat
sebelumnya. Kita pilih panel button adafruit yang ita buat seperti pada Gambar 63.

Gambar 63 Pemilihan Applets yang akan Digunakan.

17. Jika sudah dilakukan, maka button widget siap digunakan untuk menyalakan LED yang ada pada
wemos.

96
 Gambar 64 Widget Button IFTTT.

18. Koding yang kita gunakan, masih sama seperti pada materi 2.1 INPUT.
19. Setelah selesai di ketik kodingnya, diunggah kodingnya.
20. Tunggu hingga selesai unggahannya, setelah selesai pengunggahannya, rangkaian dapat dijalankan.
21. Buka serial monitor untuk melihat hasilnya.

97
MATERI 7 : WEBHOOK IFTTT
Webhooks adalah salah satu dari sekian banyak modul yang ada pada IFTTT. Yang membuat
webhooks berbeda dan terkenal dari modul lainnya adalah kemampuan dia menghubungkan dengan semua
jenis perangkat yang kita gunakan. Webhooks sangat berguna dan ringan untuk digunakan. Webhooks
menggunakan protokol post request untuk melakukan komunikasi dengan modul yang lainnya sesuai dengan
yang kita tentukan secara real time. Ini membuat webhooks lebih efisien untuk pengguna dalam komunikasi
data.

MATERI 7.1 : TRIGGER SMS DAN EMAIL

Pada materi kali ini, kita akan menjalankan skenario yang dimana wemos akan mengirimkan post
request melalui webhooks. Kemudian webhooks akan menghubungkan permintaan tersebut dengan modul
sms dan email. Setiap pengiriman post request menggunakan wemos, webhooks akan mengirimkan sms dan
email sesuai dengan tujuan pengiriman yang kita tentukan.

Tujuan
1. Peserta memahami cara kerja dari webhooks.
2. Peserta memahami hubungan antara wemos dan webhooks dalam komunikasi data menggunakan
trigger yang tersedia di modul IFTTT.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.

Langkah-Langkah secara Umum

1. Buka halaman IFTTT yang sudah masuk ke dalam akun yang telah dibuat seperti pada Gambar 65.

98
 Gambar 65 Tampilan Awal IFTTT.

2. Cari webhooks pada kolom textbox search, kemudian pilih tabulasi service. Panel webhooks akan
muncul dengan ciri-ciri gambar seperti fidget spinner dan berwarna biru seperti pada Gambar 66.

Gambar 66 Tampilan Hasil Pencarian Webhooks.

3. Koneksikan IFTTT dengan webhooks dengan menekan tombol connect. Setelah ditekan, maka nanti
dibagian atas akan muncul informasi bahwa koneksi antara keduanya telah berhasil.

99
 Gambar 67 Tampilan Koneksi Webhooks.

4. Langkah selanjutnya adalah kita membuat applets seperti pada materi pelatihan sebelumnya. Kita
membuat penyebab trigger dengan memilih webhooks (lihat Gambar 70) sebagai sarana komunikasi
antara wemos dan modul sms serta modul email.

Gambar 68 Tampilan Create Applets.

100
 Gambar 69 Tampilan Pembuatan Aksi.

Gambar 70 Tampilan Pencarian Pelayanan Webhooks.

5. Setelah masuk ke halaman pemilihan pemicu webhooks, kita pilih panel yang pertama (lihat Gambar
71), yakni akan menerima permintaan web request yang dikirimkan oleh wemos. Adapun metode
pengiriman data kita menggunakan POST untuk melakukan REQUEST HTTP.

101
 Gambar 71 Tampilan Pemilihan Trigger untuk Webhooks.

6. Kemudian kita akan diarahkan menuju pengisian awal parameter untuk pemberian nama event yang
akan dilakukan jika terjadi permintaan dari wemos. kita isikan parameternya sesuai dengan Gambar
72. Setelah diisikan, kita klik tombol create trigger.

Gambar 72 Tampilan Pengisian Parameter Penamaan Event.

7. Setelah itu, kita akan kembali ke tampilan pembuatan aksi-reaksi yang dimana tombol tambah
sebelumnya dibagian this akan menjadi gambar dari webhooks (dapat dilihat pada Gambar 73).
Langkah selajutnya, kita menekan tanda tambah untuk reaksinya, kemudian mencari service sms.
Pencarian tersebut menghasilkan dua buah panel (lihat pada Gambar 74). Panel pertama android
sms yang akan menjadikan smartphone kita yang sudah terpasang aplikasi IFTTT untuk mengirimkan
pesan sesuai yang kita perintahkan. Sedangkan untuk panel kedua clickSend SMS, merupakan

102
 sebuah layanan penyedia jasa SMS, MMS, email, dll kemanapun, kapanpun, dan untuk siapapun.
Untuk pelatihan ini, kita akan menggunakan android SMS dan pastikan smartphone yang kita
gunakan memiliki pulsa agar dapat mengirimkan sms yang datang dari perintah IFTTT ke tujuan yang
kita tentukan.

Gambar 73 Tampilan Pembuatan Reaksi.

Gambar 74 Tampilan Pemilihan Service SMS.

8. Pada bagian ini, kita akan memilih aksi yang akan dilakukan ketika datang perintah dari wemos. kita
pilih panel yang pertama bertuliskan send an SMS (Gambar 75). Kemudian, pada halaman
selanjutnya kita akan diminta untuk mengisi parameter tentang nomor tujuan pengiriman dan pesan
yang akan disampaikan. Kita dapat memasukkan beberapa parameter tambahan, seperti nama
event, waktu terjadinya event, dan beberapa variabel dengan menekan tombol add ingredient
(Gambar 76).

103
 Gambar 75 Tampilan Pemilihan Aksi Trigger SMS.

Gambar 76 Tampilan Pengisian Parameter Pengiriman SMS.

9. Setelah menekan tombol create action, kita akan diminta untuk meninjau ulang dan memberikan
nama applets-nya. Jika sudah dirasa pantas, maka kita tekan tombol finish. Setelah menekan tombol
tersebut, maka applets yang kita buat telah terkoneksi untuk melakukan pengiriman perintah SMS
(Gambar 78).

104
 Gambar 77 Tampilan Peninjauan Kembali Hasil Pembuatan Event Push Button.

Gambar 78 Tampilan Webhooks yang Sudah Terpasang Event Push Button.

10. Untuk langkah selanjutnya, kita akan membuat applets yang menghubungkan webhooks dengan
email. Silakan kembali lakukan seperti pada langkah nomor 4 dan 5. Kemudian kita cari di kotak
pencarian dengan kata kunci email. Kita pilih panel pertama yang bertuliskan email (Gambar 79).
Lalu, pilih aksi pada panel pertama yang akan mengirimkan email ketika diperintahkan oleh wemos
(Gambar 80).

105
 Gambar 79 Tampilan Pemilhan Servis Email.

Gambar 80 Tampilan Pemilhan Aksi Pengiriman Email.

11. Yang perlu diingat pada pemilihan pelayanan email ini adalah email yang dituju untuk dikirimkan
berita merupakan email pengguna dari akun yang didaftarkan pada IFTTT. Kita tidak bisa
mengirimkan email selain dari email tersebut. Pada Gambar 81, kita akan diminta untuk mengisikan
beberapa parameter, seperti subject yang merupakan topik pengiriman email dan body yang
merupakan isi utama dari email yang kita kirimkan.

106
 Gambar 81 Tampilan Pengisian Parameter Email.

12. Setelah menekan tombol create action, kita akan diminta kembali untuk meninjau ulang yang kita
buat dan memberikan nama pada applets yang kita buat (Gambar 82). Jika sudah dirasa benar, kita
tekan finish dan nanti akan muncul halaman koneksi antara webhooks dan email (Gambar 83).

107
 Gambar 82 Tampilan Peninjauan Ulang Pembuatan Trigger Email.

Gambar 83 Tampilan Webhooks Sudah Terkoneksi Dengan Email.

13. Jika kita menekan gambar webhooks, maka kita akan diarahkan ke halaman utama dari webhooks
itu sendiri. Jika sudah terpasang dengan baik applets sms dan email, maka nanti akan muncul dua
panel dengan applets yang kita buat sebelumnya (Gambar 84).

108
 Gambar 84 Tampilan Halaman Awal Webhooks yang Sudah Terkoneksi SMS dan Email.

14. Langkah selanjutnya adalah kita akan melihat pengaturan untuk mendapatkan token sebagai sarana
komunikasi antara wemos dan webhooks. Kita tekan settings yang berada di pojok kanan atas. Jika
sudah ditekan, maka kita akan diarahkan ke halaman seperti pada Gambar 85. Pada gambar tersebut
kita akan mendapati alamat URL. Silakan disalin dan ditempel di browser yang kita gunakan agar kita
bisa masuk ke alamat URL tersebut.

Gambar 85 Tampilan Setting Webhooks.

109
 15. Pada bagian your key is, kita salin token yang kita dapatkan. Token tersebut kita ibaratkan seperti
kunci untuk masuk kedalam webhooks. Jadi perlakukan token yang kita dapat seperti password
karena jika kita sebarluaskan key tersebut akan menjadi celah pihak luar untuk mengeksploitasi
perangkat kita (Gambar 86).

Gambar 86 Tampilan Info Akun Webhooks.

Koding
#include <ESP8266WiFi.h>

const char* ssid = "bagus";

const char* password = "bagusgilang";
const char* host = "maker.ifttt.com";
const char* apiKey = "****";

const byte buttonPin = D2;

volatile int flag = false;

const char* PINState = "not pressed";

void setup() {
Serial.begin(115200);
Serial.println("Button pressed integration with IFTTT");
delay(100);
pinMode(buttonPin, INPUT_PULLUP);

Serial.println("Connecting To");
Serial.println(ssid);
WiFi.begin(ssid, password);

110
 while (WiFi.status() != WL_CONNECTED) {
delay(250);
Serial.print(".");
}

Serial.println("");
Serial.print("IP Address : ");
Serial.println(WiFi.localIP());
}

void loop() {
// put your main code here, to run repeatedly:
byte inputButton = digitalRead(buttonPin);
if (!inputButton) {
Serial.print("connecting to ");
Serial.println(host);

WiFiClient client;
const int httpPort = 80;
if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}

String urlSMS = "/trigger/buttonPressedSMS/with/key/";

String urlEmail = "/trigger/buttonPressedEmail/with/key/";
urlSMS += apiKey;
urlEmail += apiKey;
PINState = "Button Pressed, sending email and SMS";
flag = true;
Serial.print("Requesting URLSMS: ");
Serial.println(urlSMS);
Serial.print("Requesting URLEmail: ");
Serial.println(urlEmail);
client.print(String("POST ") + urlSMS + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Content-Type: application/x-www-form-urlencoded\r\n" +
"Content-Length: 13\r\n\r\n" +
"value1=" + PINState + "\r\n");
client.print(String("POST ") + urlEmail + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Content-Type: application/x-www-form-urlencoded\r\n" +
"Content-Length: 13\r\n\r\n" +
"value1=" + PINState + "\r\n");
Serial.println("receiving from remote server");
String line = client.readStringUntil('\r');
Serial.println(line);

111
 while (client.available()) {
char c = client.read();
Serial.write(c);
}

Serial.println("closing connection");
client.stop();
flag = false;

}
delay(100);
}

Penjelasan Koding
#include <ESP8266WiFi.h>

const char* ssid = "bagus";

const char* password = "bagusgilang";
const char* host = "maker.ifttt.com";
const char* apiKey = "****";

const byte buttonPin = D2;

volatile int flag = false;

const char* PINState = "not pressed";
Di bagian header, kita menggunakan library ESP8266WiFi untuk komunikasi dengan jaringan yang
ada. Kita memasukkan detail ssid dan password wifi yang kita tuju. Kemudian, kita memasukkan alamat
website untuk melakukan HTTP request. Untuk apikey, kita tuliskan sesuai dengan token yang kita dapat
sebelumnya. Karena kita menggunakan pemicu push button, kita berikan nama pin D2 sesuai dengan yang
tertera di atas. Kemudian kita membuat variabel PINState untuk menyimpan status keadaan dari pin push
button tersebut.
Serial.begin(115200);
Serial.println("Button pressed integration with IFTTT");
delay(100);
pinMode(buttonPin, INPUT_PULLUP);

Serial.println("Connecting To");
Serial.println(ssid);
WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(250);
Serial.print(".");
}
112
 Serial.println("");
Serial.print("IP Address : ");
Serial.println(WiFi.localIP());
Pada koding di atas, kita mengoneksikan wemos dengan jaringan WiFi yang telah kita tentukan dan
mencetak alamat IP yang didapatkan ketika sudah terhubung dengan jaringan WiFi tersebut.
byte inputButton = digitalRead(buttonPin);
if (!inputButton) {
Serial.print("connecting to ");
Serial.println(host);

WiFiClient client;
const int httpPort = 80;
if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}
Pada bagian ini, kita memerintahkan wemos untuk membaca masukan pada pin push button. Jika
ditekan, maka akan memerintahkan wemos untuk mengoneksikan dengan host yang sudah kita tentukan
sebelumnya pada port 80.
String urlSMS = "/trigger/<event-name>/with/key/";
String urlEmail = "/trigger/<event-name>/with/key/";
urlSMS += apiKey;
urlEmail += apiKey;
PINState = "Button Pressed, sending email and SMS";
flag = true;
Serial.print("Requesting URLSMS: ");
Serial.println(urlSMS);
Serial.print("Requesting URLEmail: ");
Serial.println(urlEmail);
Setelah terhubung dengan alamat host tersebut. Kita mempersiapkan alamat URL untuk mengakses
pemicu SMS dan email. Pada bagian urlSMS, kita mengisikan event name-nya sesuai dengan event yang kita
buat pada IFTTT sebelumnya, yaitu buttonPressedSMS dan untuk email buttonPressedEmail. Kedua variabel
URL tersebut kemudian kita tambahkan string apikey yang berisikan token yang kita masukkan sebelumnya.
client.print(String("POST ") + urlSMS + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Content-Type: application/x-www-form-urlencoded\r\n" +
"Content-Length: 13\r\n\r\n" +
"value1=" + PINState + "\r\n");
client.print(String("POST ") + urlEmail + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Content-Type: application/x-www-form-urlencoded\r\n" +
"Content-Length: 13\r\n\r\n" +
"value1=" + PINState + "\r\n");

113
 Serial.println("receiving from remote server");
String line = client.readStringUntil('\r');
Serial.println(line);

while (client.available()) {
char c = client.read();
Serial.write(c);
}

Serial.println("closing connection");
client.stop();
flag = false;
Syntax di atas berfungsi untuk melakukan HTTP REQUEST menggunakan metode POST, kita
mengisikan beberapa parameter pendukung seperti URL yang kita buat sebelumnya dan variabel yang akan
kita kirim kita masukkan dalam body dari HTTP REQUEST tersebut. Kemudain, setelah melakukan POST
REQUEST, kita menunggu jawaban dari server dan mencetak jawaban tersebut. Setelah jawaban tercetak,
maka kita akan memutus komunikasi dengan host-nya.

Hasil Penerapan Koding

Hasil dari penerapan koding di atas dapat kita lihat pada serial monitor (Gambar 87). Ketika kita
menekan tombolnya, maka wemos akan mengirimkan permintaan kepada host bersangkutan untuk
mengirimkan sms dan email sesuai dengan tujuannya. Jika berhasil, maka kita akan menerima balasan
HTTP/1.1 200 OK dan beberapa info yang menyatakan bahwa kita telah berhasil memicu event
bersangkutan. Hasil dari SMS dan email dapat dilihat pada Gambar 88 dan Gambar 89.

Gambar 87 Tampilan Serial Monitor Hasil Komunikasi Antara Wemos dan Webhooks.

114
Gambar 88 SMS yang Dikirim oleh Webhooks Ketika Tombol Ditekan.

Gambar 89 Email yang Dikirim Webhooks Ketika Tombol Ditekan.

115
MATERI 8 : WEB HOSTING (FINAL
PROJECT)
Pada materi kali ini, kita akan mencoba untuk memperbaharui dua buah variabel yang ada pada
website di internet, yaitu temperature dan humidity. Protokol yang kita gunakan untuk memperbaharui dua
buah variabel tersebut post request. Berbeda dengan get request, post request akan menyimpan variabel
yang akan dikirimkan di dalam body dari template HTTP REQUEST sedangkan get request menaruh variabel
yang akan dikirim di url-nya. Dengan memilih metode post request, data kita jauh lebih aman dari sisi
kerahasian.

MATERI 8.1 : IOT WEATHER STATION WEBSITE

Pada skenario kali ini, kita akan menjadikan wemos sebagai client untuk mengirimkan data berupa
temperature dan humidity kepada website yang akan kita buat nantinya. Wemos akan memperbaharui
website tersebut setiap tiga detik sekali agar tidak membebankan website kita nantinya.

Tujuan
1. Peserta dapat memahami cara kerja dari webhosting.
2. Peserta dapat memahami post request dari wemos ke host.
3. Peserta dapat memahami komunikasi antara wemos dan host.

Bahan-Bahan yang Digunakan

1. Wemos D1 Mini.
2. Kabel secukupnya.
3. DHT11.
4. LDR.
5. Satu buah push button.
6. Dua buah LED.
7. Kabel Micro USB.
8. Filezilla.
9. Webhosting.
10. Notepad++.

Langkah-Langkah secara Umum

1. Pada skenario kali ini, kita menggunakan salah satu webhosting yang cukup terkenal, yaitu
000webhost. Langkah awal adalah mendaftarkan diri kita untuk mendapatkan akun 000webhost
116
 agar bisa membuat website sesuai dengan yang kita inginkan. Jika sudah mendaftar maka halaman
awal website tersebut dapat dilihat pada Gambar 90.

Gambar 90 Tampilan Halaman Awal Akun 000webhost.

2. Untuk membuat website baru, silakan klik tombol “+ create new site”. Kemudian akan muncul
seperti pada Gambar 91. Kita isikan nama dan password websitenya sesuai dengan yang kita
inginkan. Setelah kita isikan parameter tersebut, kita klik tombol create dan akan muncul tampilan
website seperti pada Gambar 92

Gambar 91 Tampilan Pembuatan Website Baru.

117
 Gambar 92 Tampilan Website yang Telah DIbuat.

3. Untuk melihat informasi dari halaman website yang telah kita buat, kita tekan di tabulasi sebelah
kiri menu website settings -> general. Setelah diklik, maka akan muncul tampilan seperti pada
Gambar 93. Pada panel FTP Detailed Information, kita mendapati beberapa informasi seperti toggle
untuk FTP transfer, host name yang akan dijadikan sebagai tujuan pengiriman file, port komunikasi
yang digunakan, dan username serta password yang kita buat sebelumnya.

Gambar 93 Tampilan Informasi FTP Website.

4. Setelah kita mengetahui informasi untuk FTP website tersebut, langkah selanjutnya adalah kita
membuka aplikasi filezilla untuk mengirimkan file php-nya. Kita masukkan detail host, username,
password, dan port sesuai dengan informasi yang kita dapatkan pada langkah nomor tiga lalu klik
quickconnect. Filezilla akan menghubungi host untuk mengambil beberapa data yang diminta dan
menampilkan seperti pada Gambar 94. Jika sudah terkoneksi dengan baik pada panel sebelah kanan
bawah yang bernama filename, akan muncul dua buah folder, yaitu public_html dan tmp. Kemudian,
kita klik folder public_html untuk memasukan file php yang kita buat nantinya. Di dalam folder
tersebut nantinya akan berisi file yang bernama .htaccess (lihat Gambar 95).

118
 Gambar 94 Tampilan Awal Filezilla Terkoneksi dengan Host.

Gambar 95 Tampilan Isi Folder Public_html.

5. Sebelum kita melangkah lebih lanjut, sekarang kita buat file php dengan menggunakan notepad++.
Buka notepad++, kemudian tuliskan koding PHP yang ada di bagian materi ini (letaknya di bawah
koding C++). Setelah diketikkan, maka kita simpan file tersebut sebagai file dengan tipe php bernama
esppost2 (nama boleh diubah, namun tipe file tidak boleh diubah).
6. Setelah file tersebut dibuat, langkah selanjutnya adalah kita akan mengunggah file tersebut ke
halaman website kita menggunakan filezilla. Klik dan tekan file esppost2.php kemudian seret file
tersebut ke arah panel filename. Filezilla akan mengunggah file yang kita taruh di panel filename.
Jika sudah selesai mengunggah file tersebut, maka file tersebut akan muncul di panel filename dan
pada bagian atas, akan bertuliskan status file transfer successsful (Gambar 96).
7. Langkah selanjutnya adalah kita mengetikkan koding yang ada pada bagian koding C++.
8. Setelah diketikkan, diunggah ke wemos yang kita gunakan dan setelah selesai diunggah kita buka
serial monitor untuk memantau kerja dari wemos tersebut.

119
 Gambar 96 Tampilan Filezilla Setelah Pengunggahan File PHP.

Koding C++
#include <ESP8266WiFi.h>
#include <DHTesp.h>
#include <ESP8266HTTPClient.h>
#define DHTPin D4
#define STASSID "bagus"
#define STAPASS "bagusgilang"

const String host = "bgilangp.000webhostapp.com";

const String urlPost = "/esppost.php";
const byte port = 80;

float temperature, humidity;

DHTesp dht;

String readDHT ()
{
String temp, hum;
temp = String(dht.getTemperature());
hum = String(dht.getHumidity());
return ("temperature=" + temp + "&humidity=" + hum);
}

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
dht.setup(DHTPin, DHTesp::DHT11);

120
 Serial.print("Connecting to :");
Serial.println(STASSID);

WiFi.mode(WIFI_STA);
WiFi.begin(STASSID, STAPASS);

while (WiFi.status() != WL_CONNECTED) {

delay(100);
Serial.print(".");
}

if (WiFi.status() == WL_CONNECTED) {
Serial.println("WiFi connected");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}
else return;
}

void loop() {
// put your main code here, to run repeatedly:
Serial.print("connecting to ");
Serial.print(host);
Serial.print(":");
Serial.println(port);

WiFiClient client;
if (!client.connect(host, port)) {
Serial.println("connection failed");
delay(1000);
return;
}
if (client.connected()) {
String dataDHT = readDHT();
String postRequest =
"POST " + urlPost + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Accept: *" + "/" + "*\r\n" +
"Content-Length: " + dataDHT.length() + "\r\n" +
"Content-Type: application/x-www-form-urlencoded\r\n" +
"\r\n" + dataDHT;
client.println(postRequest);
}

unsigned long timeout = millis();

while (client.available() == 0) {
if (millis() - timeout > 5000) {
Serial.println(">>> Client Timeout !");

121
 client.stop();
delay(5000);
return;
}
}

Serial.println("receiving from host");

while (client.available())
{
char ch = static_cast<char>(client.read());
Serial.print(ch);
}

Serial.println();
Serial.println("closing connection");
client.stop();
delay(3000);
}

Koding PHP
<?php
if (isset($_POST["temperature"]) && isset($_POST["humidity"]))
{
//create variable that will receive the temperature
$Temp = $_POST["temperature"];
//create variable that will receive the humidity
$Humidity = $_POST["humidity"];
//create an HTML file to display the data within
$Write= "<!DOCTYPE html>" .
"<html>" .
"<head>" .
"<meta name=\"viewport\" content=\"width=device-width, initial-
scale=1\">" .
"<link rel=\"icon\" href=\"data:,\">" .
"<style>html { font-family: Helvetica; display: inline-block;
margin: 0px auto; text-align: center;}</style>" .
"</head>" .
"<body>" .
"<p>IOT By Bagus Gilang Pratama</p>" .
"<p>temperature : " . $Temp . " Celcius </p>" .
"<p>humidity : " . $Humidity . " % </p>" .
"</body>";
file_put_contents('index.html',$Write);
}
?>

Penjelasan Koding C++

#include <ESP8266WiFi.h>
#include <DHTesp.h>
#include <ESP8266HTTPClient.h>
#define DHTPin D4
#define STASSID "bagus"
122
#define STAPASS "bagusgilang"

const String host = "bgilangp.000webhostapp.com";

const String urlPost = "/esppost.php";
const byte port = 80;

float temperature, humidity;

DHTesp dht;
Pada syntax di atas, kita memasukkan beberapa library yang dibutuhkan sebagai sarana komunikasi
antara wemos dan host serta untuk mengaktifkan DHT dan membaca tempratur darinya. Kita memasukkan
detail untuk koneksi dengan WiFi dan menandakan pin mana yang digunakan sebagai masukkan data dari
DHT11. Kemudian, kita membuat variabel host yang berisi alamat dari website yang kita buat, url yang berisi
tujuan khusus dari alamat tersebut, port yang bermaksud jalur komunikasi wemos, temprature dan humidity
yang akan diisi nilai dari sensor DHT11, dan dht yang merupakan kelas untuk mengakses sensor DHT11.
String readDHT ()
{
String temp, hum;
temp = String(dht.getTemperature());
hum = String(dht.getHumidity());
return ("temperature=" + temp + "&humidity=" + hum);
}
Fungsi yang kita buat di atas berguna untuk membentuk salah satu bagian dari HTTP REQUEST. Kita
membaca sensor dari DHT11 kemudian menggabungkannya ke dalam satu string yang nantinya akan
digabungkan dengan bagian dari HTTP REQUEST. HTTP REQUEST tersebut akan dikirim ke host untuk
memperbaharui nilai temperature dan humidity di website-nya.
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
dht.setup(DHTPin, DHTesp::DHT11);
Serial.print("Connecting to :");
Serial.println(STASSID);

WiFi.mode(WIFI_STA);
WiFi.begin(STASSID, STAPASS);

while (WiFi.status() != WL_CONNECTED) {

delay(100);
Serial.print(".");
}

if (WiFi.status() == WL_CONNECTED) {
Serial.println("WiFi connected");
Serial.print("IP address: ");

123
 Serial.println(WiFi.localIP());
}
else return;
}
Syntax di atas berguna untuk menghubungkan wemos dengan jaringan wifi yang ditentukan dan
menentukan jenis DHT yang digunakan dalam pembacaan nilai temperature dan humidity. Jika sudah
terhubung, wemos akan mencetak IP address yang diberikan oleh router dan jika gagal wemos akan
mencoba menghubungkan ulang dengan router yang ditentukan.
void loop() {
Serial.print("connecting to ");
Serial.print(host);
Serial.print(":");
Serial.println(port);

WiFiClient client;
if (!client.connect(host, port)) {
Serial.println("connection failed");
delay(1000);
return;
}
if (client.connected()) {
String dataDHT = readDHT();
String postRequest =
"POST " + urlPost + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Accept: *" + "/" + "*\r\n" +
"Content-Length: " + dataDHT.length() + "\r\n" +
"Content-Type: application/x-www-form-urlencoded\r\n" +
"\r\n" + dataDHT;
client.println(postRequest);
}
Di dalam void loop, kita mencoba menghubungkan wemos dengan host menggunakan port yang kita
tentukan sebelumnya. Jika terjadi kegagalan koneksi maka wemos akan mengulangi koneksi dengan host
yang bersangkutan. Jika telah terkoneksi, kita memerintahkan wemos untuk menjalankan fungsi readDHT().
Setelah itu, kita membuat bagian untuk melakukan post request sesuai dengan template yang telah
ditentukan. Nilai temperature dan humidity yang akan dikirimkan ke website kita taruh di bagian bawah
setelah “content-Type”.
unsigned long timeout = millis();
while (client.available() == 0) {
if (millis() - timeout > 5000) {
Serial.println(">>> Client Timeout !");
client.stop();
delay(5000);
return;

124
 }
}

Serial.println("receiving from host");

while (client.available())
{
char ch = static_cast<char>(client.read());
Serial.print(ch);
}

Serial.println();
Serial.println("closing connection");
client.stop();
delay(3000);
}
Pada koding di atas, setelah kita melakukan post request, kita menunggu jawaban dari server. Waktu
tunggu untuk menerima jawaban tersebut adalah lima detik. Jika gagal, maka wemos akan kita perintahkan
untuk kembali ke awal dan mengirimkan ulang post request. Jika terdapat jawaban dari server, kita mencetak
jawaban tersebut di serial monitor hingga pesan terakhir. Setelah mencetak, kita memutuskan hubungan
dengan server menggunakan prosedur client.stop() dan menunggu selama tiga detik sebelum melakukan
pengiriman ulang ke website yang bersangkutan.

Penjelasan Koding Notepad++

<?php
if (isset($_POST["temperature"]) && isset($_POST["humidity"]))
{
//create variable that will receive the temperature
$Temp = $_POST["temperature"];
//create variable that will receive the humidity
$Humidity = $_POST["humidity"];
//create an HTML file to display the data within
$Write= "<!DOCTYPE html>" ……………
file_put_contents('index.html',$Write);
}
?>

Pada baris pertama, kita menyatakan bagian ini merupakan domain dari php. Baris kedua berisi
tentang pernyataan tentang pembentukan variabel post yang bernama temperature dan humidity. Kedua
variabel ini nantinya, akan menerima nilai dari post request yang dilakukan oleh client. Pada baris kelima,
variabel post akan dimasukkan ke dalam variabel php yang bernama temp, begitu juga dengan variabel post
humidity dimasukkan ke dalam variabel humidity. Langkah selanjutnya adalah kita membentuk variabel
bernama Write yang berisi syntax dari html. Di dalam syntax tersebut, nanti akan terdapat nilai yang kita
dapat dari post request client.

Hasil Penerapan Koding

125
 Pada Gambar 97, kita melihat komunikasi antara wemos dan host. Setelah wemos mengoneksikan
dengan wifi dan mencetak ip address yang didapat, wemos mengirimkan permintaan untuk memperbaharui
parameter variabel temperature dan humidity di host. Wemos akan menerima jawaban dari server yang
berupa 200 OK. Jawaban tersebut berarti server telah mengakui dan memperbaharui data yang ada pada
host. Hasil dari perbaharuan tersebut ditampilkan pada website dan dapat kita akses pada browser kita
(Gambar 98).

Gambar 97 Tampilan Serial Monitor Saat Komunikasi dengan Host.

Gambar 98 Tampilan Website yang Menampilkan Variabel yang Kita Buat.

126