KUNJUNGI KAMI

KUNJUNGI KITA DI BUKALAPAK, TOKOPEDIA DAN SHOPEE
Tampilkan postingan dengan label 1. HOME. Tampilkan semua postingan
Tampilkan postingan dengan label 1. HOME. Tampilkan semua postingan

Antarmuka Sensor Kelembaban Tanah Kapasitif dengan Arduino



Menjaga tanaman hias tetap hidup bisa menjadi tugas yang sulit, bukan? Dan seringkali, ini hanya tentang mengingat untuk menyiraminya. Untungnya, sensor kelembaban tanah dapat membantu kita mengingat untuk menyiram tanaman kita dan membantu mereka hidup lebih lama.


Namun, sebagian besar sensor kelembaban tanah yang murah adalah tipe resistif, di mana terdapat dua ujung dan sensor mengukur kadar air dalam tanah berdasarkan konduktivitas di antara keduanya. Mereka bekerja dengan baik pada awalnya, tetapi seiring waktu, mereka mulai berkarat, bahkan jika mereka dilapisi emas! Karat ini mengganggu pembacaan, sehingga Anda harus terus menyesuaikan kode Anda untuk mendapatkannya dengan benar. Selain itu, mereka tidak berfungsi dengan baik dalam tanah yang longgar.


Untungnya, ada pilihan yang lebih baik: Sensor Kelembaban Tanah Kapasitif. Sensor-sensor ini beroperasi berdasarkan pengukuran kapasitif, yang menawarkan keunggulan signifikan dibandingkan pengukuran resistif. Sensor-sensor ini memiliki satu probe saja, tanpa logam terbuka yang berkarat, dan tidak merusak tanaman Anda dengan memasukkan listrik ke dalam tanah.


Dalam tutorial ini, Anda akan belajar bagaimana menggunakan sensor kelembaban tanah kapasitif secara efektif dengan Arduino. Pada akhir tutorial ini, Anda akan memiliki pengetahuan dan keterampilan untuk menjaga tanaman Anda tetap berkembang dengan baik, tanpa perlu khawatir tentang penyiraman berlebih atau kekurangan air. Mari kita mulai!


Gambaran Perangkat Keras

Sensor Kelembaban Tanah Kapasitif sangat menakjubkan. Cukup masukkan mereka ke dalam tanah dan mereka akan mengeluarkan sinyal analog yang sebanding dengan seberapa basah tanah tersebut.


Sensor-sensor ini menggunakan IC timer 555 dan beroperasi dengan mengukur seberapa cepat (atau lambat) sebuah kapasitor mengisi daya melalui sebuah resistor, tetapi pada sensor-sensor ini kapasitor bukanlah komponen fisik, melainkan terbentuk oleh dua jalur PCB yang saling berdekatan. Kapasitansinya, dan oleh karena itu laju pengisian dayanya, berubah sebagai respons terhadap seberapa banyak air di sekitarnya.



Sensor ini dilengkapi dengan regulator tegangan 3.3V di dalamnya, sehingga cocok digunakan untuk MCUs dengan tegangan 3.3V dan 5V. Selain itu, sensor ini mengonsumsi kurang dari 5mA arus listrik.


Perlu diperhatikan bahwa sensor ini hanya dapat memberikan pengukuran kualitatif terhadap kelembaban tanah. Saat tanah semakin basah, nilai keluaran menurun, dan saat tanah semakin kering, nilai keluaran meningkat. Saat ditenagakan dengan tegangan 5V, nilai keluarannya berkisar antara sekitar 1.5V (untuk tanah basah) hingga 3V (untuk tanah kering).



Namun, nilai keluaran akhir dipengaruhi oleh kedalaman penyisipan probe dan seberapa padat tanah yang mengelilinginya.


Spesifikasi Teknis

Berikut adalah spesifikasinya:

Parameter Nilai
Tegangan Operasi 3.3 hingga 5.5V
Arus Operasi < 5mA
Tegangan Keluaran pada 5V 1.5V hingga 3V (perkiraan)
Ukuran Probe Sensor P x L (PCB)  98 x 23mm
Panjang Kabel 20cm


Bagaimana Cara Kerja Sensor Kelembaban Tanah Kapasitif?

Untuk memahami bagaimana sensor kelembaban tanah kapasitif bekerja, Anda perlu memahami perilaku kapasitor dalam suatu rangkaian RC.



Dalam rangkaian RC sederhana seperti ini, saat tegangan positif diterapkan pada Input, kapasitor (C) mulai mengisi daya melalui resistor (R). Saat ini, tegangan di sepanjang kapasitor berubah. Seiring waktu, tegangan kapasitor naik hingga sama dengan tegangan masukan. Di sini, Anda dapat melihat grafik yang memplot tegangan terhadap waktu untuk kapasitor yang mengisi daya.



Waktu yang diperlukan untuk mengisi sepenuhnya kapasitor tergantung pada nilai resistor dan kapasitor tersebut. Jika Anda mempertahankan nilai R tetap dan mencoba dua nilai kapasitansi yang berbeda untuk C, Anda akan mengamati bahwa kapasitor dengan kapasitansi yang lebih besar memerlukan lebih banyak waktu untuk mengisi,



kurva pengisian kapasitor dengan nilai kapasitansi besar



sedangkan kapasitor dengan kapasitansi yang lebih kecil memerlukan waktu lebih sedikit untuk mengisi.


kurva pengisian kapasitor dengan nilai kapasitansi kecil

Sekarang kembali ke sensor kita, kapasitor C pada papan sensor bukanlah komponen sebenarnya, melainkan hanya dua jejak tembaga yang bertindak seperti kapasitor. Efek ini, dikenal sebagai Kapasitansi Parasitik, sering terjadi dalam rangkaian dan biasanya diabaikan. Namun, dengan sengaja membuat dua jejak tembaga ini lebih besar, kita dapat menggunakan efek ini untuk keuntungan kita.


Kapasitansi kapasitor parasitik ini ditentukan oleh bentuk jejak dan lingkungan di sekitarnya (secara teknis dikenal sebagai konstanta dielektrik). Saat sensor dimasukkan ke dalam tanah, lingkungan di sekitar kapasitor berubah tergantung pada apakah tanah menjadi lebih basah atau lebih kering. Ini mengubah kapasitansinya, dan akibatnya, memengaruhi waktu pengisiannya.


Ketika tanah kering, kapasitor memiliki kapasitansi yang lebih kecil dan karenanya mengisi dengan cepat. Sebaliknya, ketika tanah basah, kapasitor memiliki kapasitansi yang lebih besar dan karenanya mengisi dengan lebih lambat.


Untuk lebih memahami bagaimana ini diimplementasikan dalam sensor, mari kita periksa diagram rangkaian.



Sensor ini menggunakan rangkaian 555 yang dikonfigurasi sebagai osilator astabil. Gelombang persegi yang dihasilkan oleh rangkaian 555 diumpankan ke dalam integrator RC, di mana kapasitor terbentuk oleh probe tanah. Sinyal dari integrator lebih berupa gelombang segitiga, yang dimasukkan ke dalam penyearah dan kapasitor penyaring untuk menghasilkan keluaran DC.


Keluaran ini sebanding dengan kandungan kelembaban tanah. Jadi jika tanah kering, kapasitor mengisi dengan cepat, mengakibatkan amplitudo gelombang segitiga yang lebih besar dan selanjutnya menghasilkan tegangan keluaran yang lebih tinggi. Sebaliknya, saat tanah basah, kapasitor mengisi lebih lambat, mengakibatkan amplitudo gelombang segitiga yang lebih kecil, yang pada gilirannya menghasilkan tegangan keluaran yang lebih rendah.


Pinout Sensor Kelembaban Tanah Kapasitif

Sensor kelembaban tanah kapasitif dilengkapi dengan konektor tipe 3-pin JST PH2.0. Salah satu ujung kabel yang disediakan dicolokkan ke konektor ini, sementara ujung lainnya adalah konektor perempuan 3-pin gaya Dupont standar. Kabel ini memiliki kode warna sehingga Anda dapat dengan mudah mengidentifikasi setiap kabel: hitam mewakili ground, merah mewakili VCC, dan kuning mewakili AOUT.



Diagram pin sensor kelembaban tanah kapasitif

VCC adalah pin pasokan daya. Disarankan agar sensor diberi daya dari 3.3V hingga 5V. Harap diingat bahwa keluaran analog akan bervariasi tergantung pada tegangan yang diberikan ke sensor.


GND adalah pin ground.


Pin AOUT memberikan keluaran tegangan analog yang sebanding dengan jumlah kelembaban dalam tanah. Keluaran ini dapat dibaca menggunakan input analog pada mikrokontroler Anda. Ketika tingkat kelembaban meningkat, tegangan keluaran mengurang, dan sebaliknya.


Petunjuk Penggunaan

Ketika menggunakan sensor ini, perhatikan hal-hal berikut:


  • Disarankan agar probe tidak ditempatkan pada kedalaman yang melewati batas garis pada sensor.
  • Komponen-komponen pada papan ini TIDAK tahan air, jadi pastikan mereka tidak bersentuhan dengan air atau percikan air. Untuk perlindungan tambahan, pertimbangkan untuk menggunakan selongsong panas yang lebar di sekitar bagian atas papan.
  • Perhatikan bahwa tepi PCB dapat menyerap kelembaban seiring waktu, mempersingkat masa pakai sensor. Untuk meningkatkan daya tahan, pertimbangkan untuk mengaplikasikan lapisan pelindung, seperti epoxy bening, yang tidak akan memengaruhi kinerja sensor.


Menghubungkan Sensor Kelembaban Tanah Kapasitif ke Arduino adalah hal yang mudah. Anda hanya perlu menghubungkan tiga kabel.


Mulai dengan menghubungkan kabel merah (VCC) sensor ke pasokan daya, 3.3V-5V sudah cukup. Gunakan tegangan yang sama dengan logika mikrokontroler Anda. Untuk sebagian besar Arduino, itu adalah 5V. Untuk perangkat logika 3.3V, gunakan 3.3V. Selanjutnya, hubungkan kabel hitam (GND) ke ground.


Terakhir, sambungkan kabel kuning (AOUT) ke salah satu pin input analog pada Arduino Anda. Dalam kasus kami, kabel ini dihubungkan


Menghubungkan Sensor Kelembaban Tanah Kapasitif ke Arduino

Menghubungkan sensor kelembaban tanah kapasitif ke Arduino sangat mudah. Anda hanya perlu menghubungkan tiga kabel.


Mulailah dengan menghubungkan kabel merah sensor (VCC) ke pasokan daya, 3.3V-5V adalah baik. Gunakan tegangan yang sama dengan logika mikrokontroler Anda. Pada sebagian besar Arduino, itu adalah 5V. Untuk perangkat logika 3.3V, gunakan 3.3V. Sekarang sambungkan kabel hitam (GND) ke ground.


Akhirnya, hubungkan kabel kuning (AOUT) ke salah satu pin input analog pada Arduino Anda. Dalam kasus kami, itu terhubung ke pin A0.


Pengkabelan ditunjukkan pada gambar di bawah ini.



pengkabelan sensor kelembaban tanah kapasitif ke Arduino



Menentukan Nilai Ambang

Tidak mungkin menentukan persentase kelembaban sebenarnya dalam tanah secara langsung dari pengukuran yang diambil. Namun, relatif mudah untuk mendefinisikan rentang dasar untuk apa yang dianggap "terlalu kering," "terlalu basah," dan "cukup tepat."


Cukup jalankan sketsa di bawah ini dan catat keluaran sensor Anda dalam tiga kondisi dasar:


  • Saat tanah cukup kering sehingga tanaman membutuhkan penyiraman.
  • Saat tanah telah disiram hingga mencapai tingkat kelembaban ideal untuk tanaman.
  • Saat tanah telah disiram berlebihan dan terlalu basah, yang tidak ideal untuk tanaman.


Setelah menjalankan sketsa, Anda seharusnya mengharapkan pembacaan yang serupa dengan yang terdaftar di bawah ini:


  • Di udara terbuka: sekitar 590
  • Tanah kering yang perlu disiram: sekitar 380
  • Kelembaban tanah ideal: antara 277 dan 380
  • Tanah yang baru saja disiram: sekitar 277
  • Di dalam cangkir air: sekitar 273

Tes ini mungkin memerlukan sedikit uji coba. Setelah Anda memiliki pembacaannya, Anda dapat menggunakannya sebagai ambang batas untuk memicu tindakan.


Contoh Kode Arduino

Sketsa di bawah ini memperkirakan tingkat kelembaban tanah menggunakan nilai ambang berikut:


  • < 277 terlalu basah
  • 277 - 380 adalah rentang target
  • > 380 terlalu kering


Jika semuanya baik-baik saja, Anda seharusnya melihat keluaran yang serupa di monitor serial.


Berikut adalah tabel yang menunjukkan hubungan pin:



/* Change these values based on your observations */
#define wetSoil 277   // Define max value we consider soil 'wet'
#define drySoil 380   // Define min value we consider soil 'dry'

// Define analog input
#define sensorPin A0

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

void loop() {
  // Read the Analog Input and print it
  int moisture = analogRead(sensorPin);
  Serial.print("Analog output: ");
  Serial.println(moisture);
  
  // Determine status of our soil
  if (moisture < wetSoil) {
    Serial.println("Status: Soil is too wet");
  } else if (moisture >= wetSoil && moisture < drySoil) {
    Serial.println("Status: Soil moisture is perfect");
  } else {
    Serial.println("Status: Soil is too dry - time to water!");
  }
  Serial.println();
  
  // Take a reading every second
  delay(1000);
}

Memahami Cara Kerja Sensor Kelembaban Tanah Kapasitif
Menggunkan Sensor Kelembaban Tanak Kapasitif Dengan Arduino

Menyambungkan Sensor BME280 untuk Suhu, Kelembaban, dan Tekanan dengan Arduino

Sensor presisi BME280 dari Bosch digunakan dalam beragam aplikasi mulai dari pemantauan cuaca hingga pengendalian permainan dan pengukuran ketinggian di mana akurasi dalam hitungan kaki diperlukan."


Sensor ini mudah digunakan, sudah dikalibrasi sebelumnya, dan tidak memerlukan komponen tambahan, sehingga Anda dapat segera mulai mengukur kelembaban relatif, suhu, tekanan barometrik, dan ketinggian.


Jadi, mari kenali lebih dekat dengan BME280, yang sudah banyak kami dengar.


Kemampuan BME280


Pengukuran Suhu 

BME280 dapat mengukur suhu dalam rentang -40°C hingga 85°C. Dalam rentang suhu 0 hingga 65°C, akurasinya adalah ±1,0°C; di luar rentang tersebut, akurasi menurun menjadi ±1,5°C.


Perlu dicatat bahwa pengukuran suhu ini digunakan secara internal untuk mengkalibrasi sensor tekanan dan kelembaban. Karena sensor ini menghasilkan panas sendiri, suhu yang diukur biasanya sedikit lebih tinggi dari suhu sebenarnya. Jika hal ini kritikal untuk proyek Anda, bandingkan suhu yang diukur dengan suhu aktual dan terapkan pergeseran (offset) jika diperlukan.


Pengukuran Kelembaban 

BME280 dapat mengukur kelembaban relatif dalam rentang 0 hingga 100% dengan akurasi ±3%.


Menurut lembar data, sensor ini dapat mengukur hingga 100% kelembaban dalam rentang suhu 0 hingga 60°C. Namun, kemampuan pengukuran kelembaban maksimum menurun pada suhu yang sangat tinggi dan sangat rendah.


Pengukuran Tekanan 

BME280 dapat mengukur tekanan dalam rentang 300Pa hingga 1100 hPa dengan akurasi mutlak ±1 hPa.


Dalam rentang suhu 0 hingga 65°C, akurasi penuh dapat diperoleh, menghasilkan akurasi pengukuran ketinggian sekitar ±1 meter. Di luar rentang tersebut, akurasi menurun menjadi 1.7 hPa.


Menghitung Ketinggian

BME280 dapat mengukur tekanan dengan presisi yang tinggi (tingkat kebisingan ketinggian rendah sekitar 0,25 meter) sehingga juga dapat digunakan sebagai altimeter dengan akurasi ±1 meter.


Sebelum melanjutkan, penting untuk memahami perbedaan antara Ketinggian Mutlak dan Ketinggian Relatif. Istilah "ketinggian mutlak" mengacu pada ketinggian di atas permukaan laut (MSL), sedangkan "ketinggian relatif" mengacu pada ketinggian di atas permukaan tanah (AGL).


Perlu dicatat bahwa BME280 tidak dapat langsung mengukur ketinggian, tetapi dapat memperkirakannya menggunakan pembacaan tekanan. Karena BME280 sangat baik dalam mengukur tekanan, ia dapat menghitung ketinggian relatif dengan akurat. Sebagai contoh, jika Anda mengetahui ketinggian objek yang berada di atas meja dan Anda memindahkannya ke lantai, BME280 akan menunjukkan penurunan ketinggian sekitar 2 kaki.


Namun, jika Anda mencoba mengukur ketinggian mutlak, hal-hal menjadi sedikit lebih rumit karena BME280 perlu mengetahui tekanan permukaan laut saat ini.


Oleh karena itu, untuk mendapatkan pengukuran ketinggian mutlak yang akurat, konstanta SEA_LEVEL_PRESSURE disediakan dalam contoh kode di bawah ini, yang harus Anda perbarui dengan tekanan permukaan laut saat ini di lokasi Anda.


Gambaran Perangkat Keras

BME280 IC

Di inti modul ini terdapat sensor suhu, kelembaban, dan tekanan digital generasi berikutnya dari Bosch - BME280. Ini adalah penerus dari sensor-sensor seperti BMP180, BMP085, dan BMP183.



Daya

Modul ini dilengkapi dengan regulator LM6206 3,3V dan Penerjemah Tegangan I2C on-board, sehingga Anda dapat menggunakannya dengan mikrokontroler logika 3,3V atau 5V seperti Arduino tanpa khawatir.



BME280 mengonsumsi kurang dari 1mA selama pengukuran dan hanya 5μA saat dalam keadaan diam. Karena konsumsi daya yang rendah ini, sensor ini dapat digunakan dalam perangkat bertenaga baterai seperti handset, modul GPS, dan jam tangan.


Antarmuka I2C

Modul BME280 berkomunikasi melalui I2C dan mendukung dua alamat I2C, yaitu 0x76 dan 0x77, memungkinkan hingga dua sensor digunakan pada bus yang sama.


Alamat I2C default modul ini adalah 0x76HEX, yang dapat dengan mudah diubah menjadi 0x77HEX menggunakan jembatan solder yang disediakan.



Untuk mengubah alamat i2c menjadi 0x77, potong jalur antara pad tembaga tengah dan pad tembaga kiri dengan menggunakan pisau tajam. Kemudian, tambahkan tetesan solder antara pad tembaga tengah dan pad tembaga kanan untuk menghubungkannya secara singkat.




Spesifikasi Teknis

Berikut adalah spesifikasi:

Device Specifications

Input Voltage 3.3V – 5V -
Current Consumption 1mA (typ.) and 5μA (idle) -
Temperature -40°C to 85°C ±1.0°C
Humidity 0 to 100% RH ±3%
Pressure 300Pa to 1100 hPa ±1 hPa
Altitude 0 to 30,000 ft. ±1 m


Untuk informasi lebih lanjut, silakan lihat lembar data di bawah ini.

BME 280 Datasheet.


Susunan Pin BME280 Sensor

Modul BME280 memiliki hanya 4 pin yang menghubungkannya dengan dunia luar. Koneksi-koneksi tersebut adalah sebagai berikut:




VIN memberikan pasokan daya ke modul. Hubungkan tegangan antara 3,3V hingga 5V ke pin ini.

GND adalah pin tanah.

SCL adalah pin clock serial untuk antarmuka I2C.

SDA adalah pin data serial untuk antarmuka I2C.


Menghubungkan Modul BME280 ke Arduino

Mari kita sambungkan modul BME280 ke Arduino.

Hubungan cukup sederhana. Mulailah dengan menghubungkan pin VCC ke output 5V Arduino dan pin GND ke ground.

Sekarang kita memiliki pin-pin yang digunakan untuk komunikasi I2C. Perhatikan bahwa setiap board Arduino memiliki pin I2C yang berbeda-beda yang harus dihubungkan dengan benar. Pada  board Arduino dengan layout R3, pin SDA (garis data) dan SCL (garis clock) terletak di header pin dekat pin AREF. Mereka juga disebut A5 (SCL) dan A4 (SDA).

Lihat tabel di bawah ini untuk referensi cepat.

Arduino Pin Configuration

Board Pins
SCL SDA
Arduino Uno A5 A4
Arduino Nano A5 A4
Arduino Mega 21 20
Leonardo/Micro 3 2



Diagram di bawah ini menunjukkan cara menghubungkan semuanya.




Menginstal Library yang Diperlukan

Untuk mulai membaca data sensor, Anda harus terlebih dahulu menginstal Pustaka Adafruit BME280. Pustaka ini tersedia melalui pengelola pustaka Arduino.

Untuk menginstal pustaka, buka Sketch > Include Library > Manage Libraries... Tunggu hingga Pengelola Pustaka mengunduh indeks pustaka dan memperbarui daftar pustaka yang terinstal.




Saring pencarian Anda dengan memasukkan 'bme280'. Cari Pustaka Adafruit BME280 oleh Adafruit. Klik pada entri tersebut, lalu pilih Instal.




Pustaka sensor BME280 menggunakan backend dukungan Sensor Adafruit. Jadi, cari Adafruit Unified Sensor dan instal  (Anda mungkin perlu menggulir sedikit).


Kode Contoh Arduino


Berikut adalah program sederhana yang membaca suhu, kelembaban relatif, tekanan, dan ketinggian perkiraan dari modul BME280 dan mencetaknya di monitor serial.

#include 
#include 
#include 

#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BME280 bme;

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

	if (!bme.begin(0x76)) {
		Serial.println("Could not find a valid BME280 sensor, check wiring!");
		while (1);
	}
}

void loop() {
	Serial.print("Temperature = ");
	Serial.print(bme.readTemperature());
	Serial.println("*C");

	Serial.print("Pressure = ");
	Serial.print(bme.readPressure() / 100.0F);
	Serial.println("hPa");

	Serial.print("Approx. Altitude = ");
	Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
	Serial.println("m");

	Serial.print("Humidity = ");
	Serial.print(bme.readHumidity());
	Serial.println("%");

	Serial.println();
	delay(1000);
}


Anda seharusnya melihat keluaran yang serupa di monitor serial.



Pembahasan Kode:

Sketsa ini dimulai dengan menyertakan tiga pustaka, yaitu Wire.h, Adafruit Sensor.h, dan Adafruit BME280.h.


#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
"Kemudian, variabel SEALEVELPRESSURE_HPA didefinisikan. Variabel ini menyimpan tekanan permukaan laut dalam milibar dan digunakan untuk menghitung ketinggian absolut untuk tekanan tertentu dengan membandingkannya dengan tekanan permukaan laut. Nilai default (1013,25) digunakan dalam sketsa ini, tetapi untuk hasil yang akurat, gantikan dengan tekanan permukaan laut saat ini di lokasi Anda.

Objek dari pustaka Adafruit BME280 juga dibuat sehingga kita dapat mengakses fungsinya."

#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BME280 bme;


Pada bagian pengaturan kode, kami menginisialisasi komunikasi serial dengan PC dan memanggil fungsi begin().

Fungsi begin(I2C_ADDR) mengambil alamat I2C modul sebagai parameter. Jika Anda mengubah alamat I2C modul Anda, Anda harus menentukannya dengan benar. Fungsi ini menginisialisasi antarmuka I2C dengan alamat I2C yang diberikan dan memvalidasi ID chip. Kemudian, chip diatur ulang secara lembut dan menunggu sensor untuk dikalibrasi setelah bangun."

Serial.begin(9600);

if (!bme.begin(0x76)) {
	Serial.println("Could not find a valid BME280 sensor, check wiring!");
	while (1);
}


Pada bagian loop kode, kami menggunakan fungsi-fungsi berikut untuk membaca suhu, kelembaban relatif, dan tekanan atmosfer dari modul BME280.

Fungsi readTemperature() mengembalikan suhu.

Fungsi readPressure() mengembalikan tekanan atmosfer.

Fungsi readAltitude(SEALEVELPRESSURE_HPA) menghitung ketinggian (dalam meter) dengan membandingkan tekanan atmosfer yang ditentukan (dalam hPa) dengan tekanan permukaan laut (dalam hPa).

Fungsi readHumidity() mengembalikan kelembaban relatif."


Serial.print("Temperature = ");
Serial.print(bme.readTemperature());
Serial.println("*C");

Serial.print("Pressure = ");
Serial.print(bme.readPressure() / 100.0F);
Serial.println("hPa");

Serial.print("Approx. Altitude = ");
Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
Serial.println("m");

Serial.print("Humidity = ");
Serial.print(bme.readHumidity());
Serial.println("%");

Mengenal Sensor BME280
Mengukur Suhu, Kelembaban dan Tekanan dengan Sensor BME280
Cara Kerja BME280
Cara Kerja Sensor BME280
Prinsip Kerja Sensor BME280

Arduino dengan Sensor Cahaya Lingkungan BH1750

BH1750 adalah sensor cahaya lingkungan 16-bit. Dalam panduan ini, Anda akan belajar bagaimana menggunakan sensor cahaya lingkungan BH1750 dengan Arduino board. Sensor ini berkomunikasi dengan mikrokontroler menggunakan protokol komunikasi I2C."



Anda akan belajar cara menghubungkan sensor ke board Arduino, menginstal library yang dibutuhkan, dan menggunakan sketsa sederhana untuk menampilkan pembacaan sensor di Monitor Serial.


Panduan ini mencakup topik-topik berikut:


Memperkenalkan Sensor Cahaya Lingkungan BH1750

BH170 Pinout 

Antarmuka I2C BH17500

Contoh: BH1750: Membaca Cahaya Lingkungan dengan Arduino


Memperkenalkan Sensor Cahaya Lingkungan BH1750

BH1750 adalah sensor cahaya lingkungan 16-bit yang berkomunikasi melalui protokol I2C. Sensor ini menghasilkan pengukuran kecerahan dalam satuan lux (satuan terderivasi SI untuk pencahayaan). Rentang pengukurannya mulai dari minimum 1 lux hingga maksimum 65535 lux.


Sensor ini mungkin tersedia dalam berbagai format breakout board. Lihat gambar di bawah ini. Kedua gambar tersebut merupakan representasi dari sensor BH1750.


Fitur-fitur BH1750

Berikut adalah daftar fitur-fitur dari sensor BH1750. Untuk informasi lebih lanjut, silakan lihat datasheet sensor BH1750.


- Antarmuka bus I2C

- Tanggung jawab spektral mendekati respons mata manusia

- Konverter pencahayaan menjadi data digital

- Rentang pengukuran: 1 - 65535 lux

- Konsumsi arus rendah melalui fungsi power down

- Fungsi penolakan gangguan cahaya 50Hz / 60Hz

- Dapat memilih 2 alamat I2C slave yang berbeda

- Variasi pengukuran kecil (+/- 20%)

- Pengaruh sinar inframerah sangat kecil

- Mendukung mode pengukuran berkelanjutan

- Mendukung mode pengukuran satu kali (one-time measurement mode)


Mode Pengukuran

Sensor ini mendukung dua mode pengukuran yang berbeda: mode pengukuran berkelanjutan (continuous measurement mode) dan mode pengukuran satu kali (one-time measurement mode). Setiap mode mendukung tiga mode resolusi yang berbeda.

Mode Resolusi Rendah Presisi 4 lux Waktu pengukuran 16 ms
Mode Resolusi Tinggi Presisi 1 lux Waktu pengukuran 120 ms
Mode Resolusi Tinggi 2 Presisi 0.5 lux Waktu pengukuran 120 ms

Pada mode pengukuran berkelanjutan, sensor terus-menerus mengukur nilai cahaya lingkungan. Pada mode pengukuran satu kali, sensor mengukur nilai cahaya lingkungan satu kali saja, dan kemudian beralih ke mode power down.

Aplikasi 

BH1750 adalah sensor cahaya lingkungan sehingga dapat digunakan dalam berbagai macam proyek. Contohnya:


untuk mendeteksi apakah sudah siang atau malam;

untuk mengatur atau menghidupkan/mematikan kecerahan LED sesuai dengan cahaya lingkungan;

untuk mengatur kecerahan LCD dan layar;

untuk mendeteksi apakah sebuah LED menyala;"


BH1750 Pinout

Berikut adalah pinout BH1750:

VCC Menyuplai daya ke sensor (3.3V atau 5V)
GND Koneksi GND (Tanah)
SCL Pin SCL untuk komunikasi I2C
SDA Pin SDA untuk komunikasi I2C
ADD Memilih alamat (opsional)

Pin ADD digunakan untuk mengatur alamat sensor I2C. Jika tegangan pada pin ini kurang dari 0.7VCC (pin dibiarkan mengambang atau terhubung ke GND), alamat I2C adalah 0x23. Namun, jika tegangan lebih tinggi dari 0.7xVCC (pin terhubung ke VCC), alamatnya adalah 0x5C. Ringkasnya:


  • Pin ADD mengambang atau terhubung ke GND → alamat: 0x23
  • Pin ADD terhubung ke VCC → alamat: 0x5C


Antarmuka I2C BH1750

Sensor cahaya lingkungan BH1750 mendukung antarmuka I2C.

Anda dapat menghubungkan sensor BH1750 ke Arduino menggunakan pin I2C default (ini adalah pin untuk Arduino UNO, jika Anda menggunakan model lain, periksa pin I2C-nya):

BH1750 Arduino
SCL A5
SDA A4
SDA Pin SDA untuk komunikasi I2C
ADD Memilih alamat (opsional)


BH1750: Membaca Cahaya Lingkungan dengan Arduino

Sekarang setelah Anda lebih familiar dengan sensor BH1750, mari kita coba mengujinya. Pada bagian ini, kami akan membangun proyek sederhana yang membaca cahaya lingkungan dan menampilkannya di Monitor Serial Arduino IDE.


Komponen yang Dibutuhkan

Untuk menyelesaikan panduan ini, Anda memerlukan komponen-komponen berikut:


Sensor cahaya lingkungan BH1750

Arduino (baca tentang Best Arduino starter kits)

Breadboard (opsional)

Kabel jumper (opsional)

Anda dapat menggunakan tautan sebelumnya atau langsung pergi ke tokopedia.com/cncstorebandung untuk menemukan semua komponen untuk proyek Anda dengan harga terbaik!


Skematik - Arduino dengan BH1750

Hubungkan sensor BH1750 ke pin I2C Arduino. Anda dapat mengikuti skematik diagram berikut.



Anda juga dapat mengikuti tabel berikut:

BH1750 Arduino
VCC 5V
GND GND
SCL A5
SDA (Data) A4
ADD* Don’t connect


Dengan tidak menghubungkan pin ADD, kita memilih alamat I2C 0x23. Hubungkan pin ADD ke 3.3V untuk memilih alamat 0x5C.


Menginstal  BH1750 Library

Terdapat beberapa library untuk membaca sensor BH1750. Kita akan menggunakan BH1750 Library buatan Christopher Laws. Library ini kompatibel dengan ESP32, ESP8266, dan Arduino.


Buka Arduino IDE Anda dan pergi ke Sketch > Include Library > Manage Libraries. Library Manager akan terbuka.


Cari "BH1750" pada kotak pencarian dan instal library BH1750 buatan Christopher Laws.



Kode - Membaca Sensor Cahaya Lingkungan BH1750


Salin kode berikut ke Arduino IDE Anda. Kode ini hanya membaca cahaya lingkungan dalam satuan lux dan menampilkan nilainya di Monitor Serial. Ini adalah contoh kode dari library bernama BH1750test (Anda dapat mengaksesnya di File > Examples > BH1750 > BH1750test).


/*
  Example of BH1750 library usage. This example initialises the BH1750 object using the default high resolution continuous mode and then makes a light level reading every second.
*/

#include <Wire.h>
#include <BH1750.h>

BH1750 lightMeter;

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

  // Initialize the I2C bus (BH1750 library doesn't do this automatically)
  Wire.begin();
  // On esp8266 you can select SCL and SDA pins using Wire.begin(D4, D3);
  // For Wemos / Lolin D1 Mini Pro and the Ambient Light shield use Wire.begin(D2, D1);

  lightMeter.begin();

  Serial.println(F("BH1750 Test begin"));
}

void loop() {
  float lux = lightMeter.readLightLevel();
  Serial.print("Light: ");
  Serial.print(lux);
  Serial.println(" lx");
  delay(1000);
}


Library ini juga menyediakan contoh-contoh lain yang layak untuk dieksplorasi.


Cara Kerja Kode Ini

Kita mulai dengan menyertakan library yang diperlukan. Library Wire.h digunakan untuk menggunakan protokol komunikasi I2C, dan library BH1750.h digunakan untuk membaca dari sensor.


#include <Wire.h>
#include <BH1750.h>


Kemudian, kita membuat objek BH1750 yang disebut lightMeter.


BH1750 lightMeter;


Dalam setup(), inisialisasi Monitor Serial dengan kecepatan baud 9600.

Contoh Kode C++ untuk BH1750


Serial.begin(9600);


Inisialisasi protokol komunikasi I2C. Ini akan memulai komunikasi I2C pada pin I2C default mikrokontroler. Jika Anda ingin menggunakan pin I2C yang berbeda, sertakan pin-pi tersebut dalam metode begin() seperti ini: Wire.begin(SDA, SCL).


Wire.begin();


Inisialisasi sensor menggunakan metode begin() pada objek BH1750 (lightMeter).


lightMeter.begin();


Dalam loop(), kita membuat variabel bernama lux, yang menyimpan nilai kecerahan. Untuk mendapatkan nilai tersebut, Anda cukup memanggil fungsi readLightLevel() pada objek BH1750 (lightMeter).


float lux = lightMeter.readLightLevel();


Akhirnya, tampilkan hasil pengukuran di Monitor Serial.


Serial.print("Light: ");
Serial.print(lux);
Serial.println(" lx");


Anda mendapatkan dan mencetak hasil bacaan baru setiap satu detik.


delay(1000);


Demonstrasi

Sekarang, Anda dapat mengunggah kode ke board Anda. Pertama, hubungkan board Anda ke komputer. Kemudian, pergi ke Tools > Board dan pilih Arduino board yang Anda gunakan. Pergi ke Tools > Port dan pilih port COM tempat board Anda terhubung. Terakhir, klik tombol unggah (upload).


Setelah berhasil mengunggah kode, buka Serial Monitor dengan kecepatan baud 9600.



Pembacaan kecerahan yang baru akan dicetak di Serial Monitor.


Fungsi Lain yang Berguna

Library yang kita gunakan dengan sensor BH1750 menyediakan contoh-contoh lain yang menggambarkan fungsi dan fitur lain yang berguna. Anda dapat memeriksa semua contoh library BH1750 di sini.


Mengatur Mode Pengukuran

Secara default, library menggunakan mode pengukuran berkelanjutan dengan resolusi tinggi, tetapi Anda dapat mengubahnya dengan melewatkan mode pengukuran yang diinginkan ke metode begin() saat menginisialisasi sensor. Contohnya:


Berikut adalah daftar semua mode yang tersedia:

  • BH1750_CONTINUOUS_LOW_RES_MODE
  • BH1750_CONTINUOUS_HIGH_RES_MODE (default)
  • BH1750_CONTINUOUS_HIGH_RES_MODE_2
  • BH1750_ONE_TIME_LOW_RES_MODE
  • BH1750_ONE_TIME_HIGH_RES_MODE
  • BH1750_ONE_TIME_HIGH_RES_MODE_2

Lihat properti dari setiap mode pada bagian sebelumnya

mode pada bagian sebelumnya.


Penutup

Dalam tutorial ini, Anda telah belajar bagaimana menggunakan sensor cahaya lingkungan BH1750 dengan Arduino Uno. Sensor ini sangat mudah digunakan. Ia menggunakan protokol komunikasi I2C, yang membuat pengawatan menjadi sederhana, dan library menyediakan metode untuk dengan mudah mendapatkan pembacaan.


Kami berharap Anda menemukan tutorial ini bermanfaat. Beri tahu kami dalam komentar di bawah ini, dalam proyek apa Anda akan menggunakan sensor BH1750.


Kami memiliki tutorial untuk sensor lain dengan board Arduino yang mungkin Anda suka: (tuliskan daftar tutorial lain di sini)

Ambient Light Sensor Adalah

Cara kerja Sensor Cahaya Lingkungan BH1750

Cara menggunakan Sensor Cahaya Lingkungan BH1750 

Mode Pengukuran Sensor Cahaya Lingkungan BH1750

Mode Pengukuran BH1750

Tutorial Menggunakan Sensor Cahaya Lingkungan BH1750 dengan Arduino

Mendeteksi Siang dan Malam dengan Sensor BH1750 dan Arduino 

ESP32 DS18B20 Sensor Suhu (Temperatur) dengan Arduino IDE (Tunggal, Ganda, Server Web)"

Ini adalah panduan mendalam untuk sensor suhu DS18B20 dengan ESP32 menggunakan Arduino IDE. Kami akan menunjukkan cara menghubungkan sensor, menginstal library yang diperlukan, dan menulis kode untuk mendapatkan pembacaan sensor dari satu dan beberapa sensor. Akhirnya, kami akan membangun sebuah server web sederhana untuk menampilkan pembacaan sensor.


Pengenalan Sensor Suhu DS18B20

Sensor suhu DS18B20 adalah sensor suhu digital satu kabel. Ini berarti hanya memerlukan satu jalur data (dan GND) untuk berkomunikasi dengan ESP32 Anda.


Sensor ini dapat diberi daya oleh sumber daya eksternal atau dapat memperoleh daya dari jalur data (disebut "mode parasit"), yang menghilangkan kebutuhan untuk sumber daya eksternal.



Setiap sensor suhu DS18B20 memiliki kode serial unik berukuran 64-bit. Hal ini memungkinkan Anda untuk menghubungkan beberapa sensor ke kabel data yang sama. Dengan demikian, Anda dapat mendapatkan data suhu dari beberapa sensor hanya menggunakan satu pin GPIO.


Selain itu, sensor suhu DS18B20 juga tersedia dalam versi tahan air (waterproof).



Berikut adalah ringkasan dari spesifikasi paling relevan dari sensor suhu DS18B20:


- Berkomunikasi melalui bus komunikasi satu kabel (one-wire bus).

- Rentang sumber daya: 3,0V hingga 5,5V.

- Rentang suhu operasi: -55ºC hingga +125ºC.

- Akurasi +/-0,5 ºC (antara rentang -10ºC hingga 85ºC).


Untuk informasi lebih lanjut, silakan lihat lembar data (datasheet) dari sensor DS18B20.


Bagian-bagian yang diperlukan

Untuk mengikuti panduan ini, Anda memerlukan bagian-bagian berikut:


1. ESP32 (baca: Papan pengembangan ESP32 terbaik)

2. Sensor suhu DS18B20 (satu atau beberapa sensor) - versi tahan air (waterproof)

3. Resistor 4.7k Ohm

4. Kabel jumper

5. Breadboard (papan percobaan)


Anda dapat menggunakan tautan sebelumnya atau langsung mengunjungi tokopedia.com/cncstorebandung untuk menemukan semua bagian yang Anda butuhkan untuk proyek Anda dengan harga terbaik!


Skema (Schematic) - ESP32

Seperti yang disebutkan sebelumnya, sensor suhu DS18B20 dapat diberi daya melalui pin VDD (mode normal), atau dapat memperoleh daya dari jalur data (mode parasit). Anda dapat memilih salah satu dari kedua mode tersebut.


Jika Anda menggunakan ESP32, ikuti salah satu dari dua diagram skema berikut.

Mode Parasit 



Mode Normal 



Menyiapkan Arduino IDE Anda

Kami akan memprogram ESP32 menggunakan Arduino IDE, pastikan Anda telah menginstal add-on ESP32 sebelum melanjutkan:


Instal Board ESP32 di Arduino IDE (ikuti instruksi untuk Windows, Mac OS X, dan Linux)

Instalasi (Libraries)


Menginstal Libraries

Untuk berinteraksi dengan sensor suhu DS18B20, Anda perlu menginstal library One Wire karya Paul Stoffregen dan library Dallas Temperature. Ikuti langkah-langkah berikut untuk menginstal kedua library tersebut.


1. Buka Arduino IDE Anda dan pergi ke Sketch > Include Library > Manage Libraries. Library Manager akan terbuka.


2. Ketikkan "onewire" pada kotak pencarian dan instal library OneWire karya Paul Stoffregen.



3. Selanjutnya, cari "Dallas" dan instal library DallasTemperature karya Miles Burton.



Setelah menginstal library, restart Arduino IDE Anda.



Kode (Single DS18B20)

Setelah menginstal library yang diperlukan, Anda dapat mengunggah kode ke ESP32. Berikut adalah contoh kode untuk membaca suhu dari sensor suhu DS18B20 dan menampilkan pembacaan tersebut di Serial Monitor Arduino IDE.


/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com  
*********/

#include <OneWire.h>
#include <DallasTemperature.h>

// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;     

// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(oneWireBus);

// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);

void setup() {
  // Start the Serial Monitor
  Serial.begin(115200);
  // Start the DS18B20 sensor
  sensors.begin();
}

void loop() {
  sensors.requestTemperatures(); 
  float temperatureC = sensors.getTempCByIndex(0);
  float temperatureF = sensors.getTempFByIndex(0);
  Serial.print(temperatureC);
  Serial.println("ºC");
  Serial.print(temperatureF);
  Serial.println("ºF");
  delay(5000);
}


"Terdapat banyak cara berbeda untuk mendapatkan suhu dari sensor suhu DS18B20. Namun, jika Anda hanya menggunakan satu sensor tunggal, cara ini merupakan salah satu cara yang paling mudah dan sederhana."



Bagaimana Kode Bekerja


#include <OneWire.h>
#include <DallasTemperature.h>

Mulailah dengan menyertakan library OneWire dan DallasTemperature.



Buatlah instance yang dibutuhkan untuk sensor suhu. Sensor suhu ini terhubung ke pin GPIO 4 (D4) pada ESP32.


// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;

// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(oneWireBus);

// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);


Pada fungsi setup(), inisialisasikan Serial Monitor dengan kecepatan baud rate 115200.


Serial.begin(115200);



Inisialisasikan sensor suhu DS18B20:


sensors.begin();



Sebelum benar-benar mendapatkan suhu, Anda perlu memanggil metode requestTemperatures().


sensors.requestTemperatures();


Kemudian, dapatkan suhu dalam derajat Celsius dengan menggunakan metode getTempCByIndex() seperti yang ditunjukkan di bawah ini:


float temperatureC = sensors.getTempCByIndex(0);



Atau gunakan getTempFByIndex() untuk mendapatkan suhu dalam Fahrenheit.


float temperatureF = sensors.getTempFByIndex(0);


Metode getTempCByIndex() dan getTempFByIndex() menerima indeks dari sensor suhu. Karena kita hanya menggunakan satu sensor, indeksnya adalah 0. Jika Anda ingin membaca lebih dari satu sensor, Anda dapat menggunakan indeks 0 untuk satu sensor, indeks 1 untuk sensor lainnya, dan seterusnya.


Terakhir, cetak hasilnya di Serial Monitor.


Serial.print(temperatureC);
Serial.println("ºC");
Serial.print(temperatureF);
Serial.println("ºF");


Pembacaan suhu baru diminta setiap 5 detik.


delay(5000);



Demonstrasi 

Setelah mengunggah kode, Anda akan melihat pembacaan suhu dari sensor ditampilkan di Serial Monitor:



Mendapatkan Suhu dari Beberapa Sensor Suhu DS18B20



Sensor suhu DS18B20 berkomunikasi menggunakan protokol satu kabel (one-wire) dan setiap sensor memiliki kode serial unik berukuran 64-bit, sehingga Anda dapat membaca suhu dari beberapa sensor hanya menggunakan satu pin GPIO. Anda hanya perlu menghubungkan semua jalur data bersama-sama seperti yang ditunjukkan dalam diagram skema berikut:



Kode (Multiple DS18B20s)


Kemudian, unggah kode berikut. Kode ini akan memindai semua perangkat yang terhubung pada GPIO 4 dan mencetak suhu dari setiap perangkat. (Sketch ini berdasarkan contoh yang disediakan oleh library DallasTemperature).


/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com  
*********/

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged TO GPIO 4
#define ONE_WIRE_BUS 4

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);

// Number of temperature devices found
int numberOfDevices;

// We'll use this variable to store a found device address
DeviceAddress tempDeviceAddress; 

void setup(){
  // start serial port
  Serial.begin(115200);
  
  // Start up the library
  sensors.begin();
  
  // Grab a count of devices on the wire
  numberOfDevices = sensors.getDeviceCount();
  
  // locate devices on the bus
  Serial.print("Locating devices...");
  Serial.print("Found ");
  Serial.print(numberOfDevices, DEC);
  Serial.println(" devices.");

  // Loop through each device, print out address
  for(int i=0;i



Demonstrasi


Pada contoh ini, kami menggunakan tiga sensor suhu DS18B20. Ini adalah hasil yang akan Anda lihat di Serial Monitor Arduino IDE:



Kami memiliki artikel khusus tentang cara menghubungkan beberapa sensor suhu DS18B20 dengan ESP32. Ikuti tutorial berikut:


"ESP32 dengan Beberapa Sensor Suhu DS18B20"



Menampilkan (Display) Pembacaan Suhu DS18B20 pada Web Server


Untuk membangun web server, kita akan menggunakan library ESPAsyncWebServer yang menyediakan cara mudah untuk membuat web server yang asinkron. Membangun web server asinkron memiliki beberapa keuntungan. Kami sarankan untuk melihat dokumentasi library tersebut di halaman GitHub-nya.


Menginstal Library ESPAsyncWebServer dan AsyncTCP


Anda perlu menginstal dua library berikut di Arduino IDE Anda untuk membangun web server untuk proyek ini.


"ESPAsyncWebServer (.zip folder)"

"AsyncTCP (.zip folder)"


Library ESPAsyncWebServer, AsyncTCP, dan ESPAsyncTCP tidak tersedia untuk diinstal melalui Arduino Library Manager, jadi Anda perlu menyalin file library ke folder Libraries di instalasi Arduino. Sebagai alternatif, di Arduino IDE Anda, Anda dapat pergi ke Sketch > Include Library > Add .zip Library dan pilih library yang baru saja Anda unduh.


Kode (DS18B20 Async Web Server)

Buka Arduino IDE Anda dan salin kode berikut."


/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com  
*********/

// Import required libraries
#ifdef ESP32
  #include <WiFi.h>
  #include <ESPAsyncWebServer.h>
#else
  #include <Arduino.h>
  #include <ESP8266WiFi.h>
  #include <Hash.h>
  #include <ESPAsyncTCP.h>
  #include <ESPAsyncWebServer.h>
#endif
#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is connected to GPIO 4
#define ONE_WIRE_BUS 4

// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);

// Variables to store temperature values
String temperatureF = "";
String temperatureC = "";

// Timer variables
unsigned long lastTime = 0;  
unsigned long timerDelay = 30000;

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Create AsyncWebServer object on port 80
AsyncWebServer server(80);

String readDSTemperatureC() {
  // Call sensors.requestTemperatures() to issue a global temperature and Requests to all devices on the bus
  sensors.requestTemperatures(); 
  float tempC = sensors.getTempCByIndex(0);

  if(tempC == -127.00) {
    Serial.println("Failed to read from DS18B20 sensor");
    return "--";
  } else {
    Serial.print("Temperature Celsius: ");
    Serial.println(tempC); 
  }
  return String(tempC);
}

String readDSTemperatureF() {
  // Call sensors.requestTemperatures() to issue a global temperature and Requests to all devices on the bus
  sensors.requestTemperatures(); 
  float tempF = sensors.getTempFByIndex(0);

  if(int(tempF) == -196){
    Serial.println("Failed to read from DS18B20 sensor");
    return "--";
  } else {
    Serial.print("Temperature Fahrenheit: ");
    Serial.println(tempF);
  }
  return String(tempF);
}

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css" integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLbHG9Sr" crossorigin="anonymous">
  <style>
    html {
     font-family: Arial;
     display: inline-block;
     margin: 0px auto;
     text-align: center;
    }
    h2 { font-size: 3.0rem; }
    p { font-size: 3.0rem; }
    .units { font-size: 1.2rem; }
    .ds-labels{
      font-size: 1.5rem;
      vertical-align:middle;
      padding-bottom: 15px;
    }
  </style>
</head>
<body>
  <h2>ESP DS18B20 Server</h2>
  <p>
    <i class="fas fa-thermometer-half" style="color:#059e8a;"></i> 
    <span class="ds-labels">Temperature Celsius</span> 
    <span id="temperaturec">%TEMPERATUREC%</span>
    <sup class="units">°C</sup>
  </p>
  <p>
    <i class="fas fa-thermometer-half" style="color:#059e8a;"></i> 
    <span class="ds-labels">Temperature Fahrenheit</span>
    <span id="temperaturef">%TEMPERATUREF%</span>
    <sup class="units">°F</sup>
  </p>
</body>
<script>
setInterval(function ( ) {
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
      document.getElementById("temperaturec").innerHTML = this.responseText;
    }
  };
  xhttp.open("GET", "/temperaturec", true);
  xhttp.send();
}, 10000) ;
setInterval(function ( ) {
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
      document.getElementById("temperaturef").innerHTML = this.responseText;
    }
  };
  xhttp.open("GET", "/temperaturef", true);
  xhttp.send();
}, 10000) ;
</script>
</html>)rawliteral";

// Replaces placeholder with DS18B20 values
String processor(const String& var){
  //Serial.println(var);
  if(var == "TEMPERATUREC"){
    return temperatureC;
  }
  else if(var == "TEMPERATUREF"){
    return temperatureF;
  }
  return String();
}

void setup(){
  // Serial port for debugging purposes
  Serial.begin(115200);
  Serial.println();
  
  // Start up the DS18B20 library
  sensors.begin();

  temperatureC = readDSTemperatureC();
  temperatureF = readDSTemperatureF();

  // Connect to Wi-Fi
  WiFi.begin(ssid, password);
  Serial.println("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  
  // Print ESP Local IP Address
  Serial.println(WiFi.localIP());

  // Route for root / web page
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/html", index_html, processor);
  });
  server.on("/temperaturec", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/plain", temperatureC.c_str());
  });
  server.on("/temperaturef", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/plain", temperatureF.c_str());
  });
  // Start server
  server.begin();
}
 
void loop(){
  if ((millis() - lastTime) > timerDelay) {
    temperatureC = readDSTemperatureC();
    temperatureF = readDSTemperatureF();
    lastTime = millis();
  }  
}



Masukkan kredensial jaringan Anda pada variabel berikut, dan kode akan langsung berfungsi.


Bagaimana Kode Berfungsi


const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";


Pada paragraf berikut, kami akan menjelaskan bagaimana kode berfungsi. Lanjutkan membaca jika Anda ingin belajar lebih lanjut atau langsung ke bagian "Demonstrasi" untuk melihat hasil akhir.


Impor Library

Pertama, impor library yang diperlukan untuk board ESP32:


Membuat Instance untuk Sensor DS18B20


Tentukan pin GPIO tempat data sensor DS18B20 dihubungkan. Dalam kasus ini, pin tersebut dihubungkan ke GPIO 4.


#define ONE_WIRE_BUS 4


Membuat Instance yang Diperlukan untuk Menginisialisasi Sensor:


// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);


Mengatur Kredensial Jaringan Anda

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";


Masukkan kredensial jaringan Anda pada variabel berikut, agar ESP8266 dapat terhubung ke jaringan lokal Anda.


Membuat objek AsyncWebServer pada port 80.


AsyncWebServer server(80);


Fungsi Membaca Suhu


Selanjutnya, kami membuat dua fungsi untuk membaca suhu.


Fungsi `readDSTemperatureC()` mengembalikan pembacaan suhu dalam derajat Celsius.


String readDSTemperatureC() {
  // Call sensors.requestTemperatures() to issue a global temperature and Requests to all devices on the bus
  sensors.requestTemperatures(); 
  float tempC = sensors.getTempCByIndex(0);

  if(tempC == -127.00){
    Serial.println("Failed to read from DS18B20 sensor");
    return "--";
  } else {
    Serial.print("Temperature Celsius: ");
    Serial.println(tempC); 
  }
  return String(tempC);
}


"Jika sensor tidak dapat mendapatkan pembacaan yang valid, maka fungsi ini mengembalikan nilai -127. Karena itu, kami menggunakan pernyataan if untuk mengganti nilai -127 dengan dua tanda hubung (–-) jika sensor gagal mendapatkan pembacaan yang valid."


if(tempC == -127.00){
  Serial.println("Failed to read from DS18B20 sensor");
  return "--";
}


Fungsi `readDSTemperatureF()` bekerja dengan cara yang serupa tetapi mengembalikan pembacaan suhu dalam derajat Fahrenheit.


Hasil pembacaan dikembalikan dalam tipe data string. Untuk mengonversi tipe data float menjadi string, gunakan fungsi String().


return String(tempC);


Membangun Halaman Web


Langkah berikutnya adalah membangun halaman web. Kode HTML dan CSS yang diperlukan untuk membangun halaman web disimpan dalam variabel index_html.


Dalam teks HTML, kami memiliki TEMPERATUREC dan TEMPERATUREF di antara tanda persen (%). Ini adalah tempat penampung untuk nilai suhu.


Ini berarti bahwa teks %TEMPERATUREC% berfungsi seperti variabel yang akan digantikan dengan nilai suhu aktual dari sensor. Penampung pada teks HTML harus berada di antara tanda persen (%).


Kami telah menjelaskan secara detail bagaimana HTML dan CSS yang digunakan dalam web server ini berfungsi dalam tutorial sebelumnya. Jika Anda ingin belajar lebih lanjut, silakan lihat proyek berikutnya:


"DHT11/DHT22 Temperature and Humidity Web Server with Arduino IDE"



Processor


Sekarang, kita perlu membuat fungsi processor() yang akan menggantikan penampung dalam teks HTML dengan nilai suhu aktual.


String processor(const String& var){
  //Serial.println(var);
  if(var == "TEMPERATUREC"){
    return readDSTemperatureC();
  }
  else if(var == "TEMPERATUREF"){
    return readDSTemperatureF();
  }
  return String();
}


Ketika halaman web diminta, kita memeriksa apakah ada penampung dalam HTML. Jika kita menemukan penampung %TEMPERATUREC%, kita akan mengembalikan nilai suhu dalam derajat Celsius dengan memanggil fungsi readDSTemperatureC() yang telah dibuat sebelumnya.


if(var == "TEMPERATUREC"){
  return readDSTemperatureC();
}


Jika penampungnya adalah %TEMPERATUREF%, kita akan mengembalikan nilai suhu dalam derajat Fahrenheit.


else if(var == "TEMPERATUREF"){
  return readDSTemperatureF();
}


Setup () 

Dalam fungsi setup(), kita inisialisasi Serial Monitor untuk tujuan debugging.


Serial.begin(115200);


Inisialisasi sensor suhu DS18B20.


sensors.begin();


Sambungkan ke jaringan lokal Anda dan cetak alamat IP ESP32.


WiFi.begin(ssid, password);
Serial.println("Connecting to WiFi");
while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print(".");
}
Serial.println();

// Print ESP8266 Local IP Address
Serial.println(WiFi.localIP());


Terakhir, tambahkan baris kode berikut untuk menangani web server.


server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/html", index_html, processor);
});
server.on("/temperaturec", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/plain", readDSTemperatureC().c_str());
});
server.on("/temperaturef", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/plain", readDSTemperatureF().c_str());
});


Ketika kita membuat permintaan pada URL root, kita mengirimkan teks HTML yang disimpan dalam variabel index_html. Kami juga perlu melewati fungsi processor, yang akan menggantikan semua penampung dengan nilai yang tepat.


server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/html", index_html, processor);
});


Kita perlu menambahkan dua penangan tambahan untuk memperbarui pembacaan suhu. Ketika kita menerima permintaan pada URL/temperaturec, kita hanya perlu mengirimkan nilai suhu yang diperbarui. Ini berupa teks biasa, dan harus dikirimkan sebagai char, sehingga kita menggunakan metode c_str().


server.on("/temperaturec", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/plain", readDSTemperatureC().c_str());
});


Proses yang sama diulangi untuk suhu dalam Fahrenheit.


server.on("/temperaturef", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/plain", readDSTemperatureF().c_str());
});


Terakhir, kita bisa memulai server.


server.begin();


Karena ini adalah web server yang bersifat asinkron, kita tidak perlu menulis apapun di dalam loop().


void loop(){

}


Itulah kurang lebih cara kerja kode ini.


Demonstrasi

Setelah mengunggah kode, buka Serial Monitor Arduino IDE dengan baud rate 115200. Tekan tombol reset pada ESP32 dan setelah beberapa detik, alamat IP ESP32 akan muncul.

Di jaringan lokal Anda, buka browser dan ketik alamat IP ESP32.

Sekarang Anda dapat melihat suhu dalam derajat Celsius dan Fahrenheit pada web server Anda. Pembacaan sensor akan diperbarui secara otomatis tanpa perlu me-refresh halaman web.





Penutup 

Kami berharap Anda telah menemukan tutorial ini bermanfaat.

Terima kasih telah membaca.


Sensor Suhu DS18B20
Sensor temperatur DS28B20 
Tutorial Mengintegrasisan Sensor Suhu DS18B20 dengan ESP32
Cara Membaca dan Menampilkan Suhu Data Suhu dengan DS18B20 dan ESP32

DS18B20 adalah 
Tutorial Memantau Suhu Via Web Server  dengan DS18B20 dan ESP32
Membuat Web Server Untuk Sensor Suhu DS18B20 dan ESP32
Panduan Membaca Suhu dengan DS18B20 dan ESP32 menggunakan Arduino
Mengukur Suhu dengan DS18B20 dan ESP32 
Cara Kerja Sensor Suhu DS18B20
Prinsip Kerja Sensor Suhu DS18B20