Sensor Level Air Arduino: Kalibrasi, Alarm Luapan, dan Pompa

Sensor level air adalah cara termurah dan termudah untuk mendeteksi seberapa tinggi air di dalam gelas, akuarium, tatakan pot tanaman, atau tangki kecil dengan Arduino. Ketika jalur konduktif terbuka di board-nya terendam air, tegangan di output analognya naik; Arduino membaca tegangan itu dengan analogRead() lalu memutuskan apakah airnya “kosong”, “setengah”, atau “penuh”. Sensor ini dihubungkan dengan tiga kabel, bekerja dengan beberapa baris kode, dan menjadi titik awal banyak proyek, mulai dari alarm luapan sampai kendali pompa otomatis.

Di panduan ini kamu akan mempelajari apa isi modul ini, kenapa pembacaannya tidak pernah mencapai 1023, cara melakukan kalibrasi kosong/setengah/penuh, dan cara mencegah korosi yang menggerogoti sensor dalam beberapa minggu. Setelah itu kamu akan membuat alarm luapan dengan buzzer dan kendali pompa yang mengisi ulang tangki dengan sendirinya, membandingkan sensor ini secara singkat dengan saklar pelampung dan XKC-Y25 yang tanpa kontak, lalu melihat cara melakukan hal yang sama dengan ESP32 dan Raspberry Pi Pico.

Apa itu sensor level air dan bagaimana cara kerjanya?

Bagian bawah modul memiliki sepuluh jalur konduktif yang tidak saling bersentuhan dan saling menyisip seperti gigi dua sisir. Lima di antaranya adalah jalur daya yang terhubung ke catu +; lima lainnya adalah jalur sensor yang menuju basis transistor NPN S8050 di bagian atas board. Ketika board kering, di antara jalur hanya ada udara, transistor mati, dan pin S berada di dekat 0 V. Begitu board masuk ke air, air menjembatani jalur daya dan jalur sensor; arus kecil mengalir ke basis transistor, transistor mulai menghantar, dan tegangan di output S, yang diambil dari emitor, naik. Makin tinggi airnya, makin panjang bagian jalur yang basah, makin kecil hambatan di antara jalur, dan makin tinggi tegangan output-nya.

Cara kerja seperti ini punya tiga konsekuensi penting. Pertama, sensor ini sebenarnya tidak mengukur air, melainkan konduktivitas air: mineral terlarut di air keran menaikkan pembacaan, sedangkan air murni (air suling) hampir tidak memberi nilai apa pun. Kedua, karena output-nya berasal dari transistor yang bekerja sebagai emitter follower, tegangannya tidak pernah mencapai tegangan catu; sensor yang basah sepenuhnya dan diberi daya 5 V biasanya terbaca sekitar 500–650 di Arduino Uno dan tidak pernah mendekati 1023. Ketiga, hubungannya tidak linear: nilainya naik cepat di beberapa milimeter pertama, lalu makin lama makin lambat. Jadi sensor ini bukan penggaris dengan akurasi milimeter, melainkan indikator praktis yang andal membedakan beberapa level.

Pengkabelan sensor level air: Arduino Uno, ESP32, dan Pico

Cara termudah mencegah korosi adalah memberi daya sensor dari pin digital, seperti di tabel: kode membuat pin HIGH tepat sebelum pengukuran, menunggu 10 ms, membaca nilainya, lalu membuat pin LOW lagi. Pada sistem yang mengukur sekali per detik, jalur hanya teraliri listrik 1% dari seluruh waktu, sehingga keausan melambat kira-kira seratus kali. Ketika basah sepenuhnya, modul ini menarik arus paling banyak sekitar 20 mA. Batas yang dianjurkan untuk pin Arduino Uno adalah 20 mA dan batas mutlaknya 40 mA, dan pin hanya menyala selama beberapa milidetik, jadi sambungan ini aman; pin ESP32 juga dengan mudah memberikan arus sebesar ini. Namun, pin Pico bekerja dengan pengaturan drive strength bawaan yang lebih rendah, sehingga ketika sensor basah sepenuhnya, tegangan pin sedikit turun dan pembacaannya mengecil. Selama kamu mengkalibrasi dengan pengkabelan yang sama, hal ini bukan masalah; jika ingin nilai yang lebih stabil, kamu bisa menyambung-putuskan + sensor lewat transistor PNP kecil seperti BC557: emitor ke pin 3V3 board, kolektor ke + sensor, dan basis ke pin GPIO lewat resistor 1 kΩ, lalu sensor menyala ketika pin LOW. Untuk memilih transistor yang cocok, lihat alat pinout transistor.

Langkah demi langkah: pembacaan pertamamu dengan Arduino

1. Hubungkan pin S sensor ke A0, pin + ke D7, dan pin − ke GND. Pegang board dalam posisi tegak dengan jalur menghadap ke bawah.
2. Buka kode di bawah di Arduino IDE, pilih Arduino Uno sebagai board, pilih port yang benar, lalu upload.
3. Buka Serial Monitor dan atur ke 9600 baud. Pastikan nilainya mendekati 0 ketika sensor kering.
4. Turunkan sensor perlahan ke dalam segelas air: mula-mula ujungnya saja, lalu setengahnya, lalu sampai garis tempat jalurnya berakhir. Di setiap langkah, tunggu beberapa detik dan catat nilainya.

1const int SENSOR_PIN = A0;   // S → A0
2const int POWER_PIN = 7;     // + → D7 (yalnızca ölçerken besle / power only while measuring)
3
4int readSensor() {
5  digitalWrite(POWER_PIN, HIGH);        // sensörü aç / power the sensor
6  delay(10);                            // değerin oturmasını bekle / let the reading settle
7  long sum = 0;
8  for (int i = 0; i < 8; i++) {         // 8 ölçümün ortalaması / average of 8 readings
9    sum += analogRead(SENSOR_PIN);
10  }
11  digitalWrite(POWER_PIN, LOW);         // sensörü kapat / power off
12  return sum / 8;
13}
14
15void setup() {
16  pinMode(POWER_PIN, OUTPUT);
17  digitalWrite(POWER_PIN, LOW);         // kapalı başla / start powered off
18  Serial.begin(9600);
19}
20
21void loop() {
22  int raw = readSensor();
23  Serial.print("Ham deger / Raw value: ");
24  Serial.println(raw);
25  delay(1000);                          // saniyede bir ölç / measure once a second
26}

Fungsi readSensor() menyalakan sensor hanya sekitar 11 ms per pengukuran. Jeda 10 ms memberi waktu bagi transistor dan air di antara jalur untuk mencapai nilai yang stabil; lalu rata-rata dari 8 pembacaan menghaluskan fluktuasi kecil pada sampel tunggal. Di Uno, setiap analogRead() memakan waktu sekitar 0,1 ms, jadi 8 pembacaan selesai dalam kurang dari 1 ms. Ketika kamu mengaduk air atau menggoyang gelas, kamu akan melihat nilainya melompat-lompat di Serial Monitor; itu normal, karena permukaan air yang bergerak terus mengubah panjang jalur yang basah.

Kosong, setengah, penuh: cara mengkalibrasi

Jangan memakai ambang dari kode yang kamu temukan di internet begitu saja; setiap sensor, setiap jenis air, dan setiap tegangan catu memberi nilai yang berbeda. Kalibrasikan di wadah tempat sensor benar-benar akan dipakai dan dengan air yang sama: air akuarium untuk akuarium, air berpupuk untuk tangki irigasi berpupuk. Buat garis di 0, 10, 20, 30, dan 40 mm pada sensor dengan spidol, celupkan board sampai setiap garis, tunggu 3–4 detik sampai nilainya stabil, lalu catat angka di Serial Monitor. Tabel di bawah menunjukkan rentang khas untuk air keran dan catu 5 V; catat nilaimu sendiri di sebelahnya.

Yang menonjol di tabel adalah betapa cepat nilainya naik di sentimeter pertama lalu merapat: antara 0 dan 10 mm bisa ada selisih beberapa ratus unit, tetapi antara 20 dan 40 mm hanya beberapa puluh. Karena itu, alih-alih menarik satu garis lurus dengan map(), interpolasi linear sepotong-sepotong (piecewise linear interpolation), yang memakai rasio terpisah di antara setiap pasangan titik ukur, memberi hasil yang jauh lebih akurat. Kode di bawah menyimpan lima titik yang kamu ukur dalam dua array, mengubah nilai mentah menjadi milimeter, dan mencetak nama level-nya. Kamu cukup menuliskan hasil pengukuranmu sendiri ke array RAW, dari yang terkecil ke yang terbesar.

1const int SENSOR_PIN = A0;
2const int POWER_PIN = 7;
3
4// Kendi kalibrasyon ölçümlerin / your own calibration readings
5const int N = 5;
6const int RAW[N] = {0, 330, 440, 490, 520};   // ham değer, küçükten büyüğe / raw value, ascending
7const int MM[N]  = {0, 10, 20, 30, 40};       // batma derinliği (mm) / immersion depth (mm)
8
9int readSensor() {
10  digitalWrite(POWER_PIN, HIGH);
11  delay(10);
12  long sum = 0;
13  for (int i = 0; i < 8; i++) sum += analogRead(SENSOR_PIN);
14  digitalWrite(POWER_PIN, LOW);
15  return sum / 8;
16}
17
18int rawToMm(int raw) {
19  if (raw <= RAW[0]) return MM[0];
20  for (int i = 1; i < N; i++) {
21    if (raw <= RAW[i]) {                      // iki nokta arasında oran kur / interpolate between two points
22      return map(raw, RAW[i - 1], RAW[i], MM[i - 1], MM[i]);
23    }
24  }
25  return MM[N - 1];                           // en üst noktanın üstü / above the top point
26}
27
28const char* levelName(int mm) {
29  if (mm < 3)  return "Bos / Empty";
30  if (mm < 15) return "Az / Low";
31  if (mm < 30) return "Yarim / Half";
32  return "Dolu / Full";
33}
34
35void setup() {
36  pinMode(POWER_PIN, OUTPUT);
37  digitalWrite(POWER_PIN, LOW);
38  Serial.begin(9600);
39}
40
41void loop() {
42  int raw = readSensor();
43  int mm = rawToMm(raw);
44  Serial.print(raw);
45  Serial.print(" -> ");
46  Serial.print(mm);
47  Serial.print(" mm, ");
48  Serial.println(levelName(mm));
49  delay(1000);
50}

Alarm luapan dengan buzzer

Salah satu tugas paling berguna sensor level air adalah memperingatkanmu tentang luapan: ditaruh di bawah mesin cuci atau pemanas air, di tatakan pot tanaman, di wadah pembuangan AC, atau di bibir ember yang sedang terisi, sensor menyalakan alarm begitu air menyentuh ujungnya. Level “rendah” dari tabel kalibrasi pun sudah cukup untuk ini. Kode di bawah memakai buzzer aktif dan LED bawaan Uno; ketika nilainya melewati ALARM_ON, buzzer berbunyi setiap seperempat detik, dan ketika nilainya turun di bawah ALARM_OFF, buzzer diam. Karena pengaturan waktunya memakai millis() alih-alih delay(), pengukuran dan buzzer tidak saling memblokir. Untuk jenis-jenis buzzer, lihat Apa Itu Buzzer?, dan untuk ide millis(), lihat millis() dan delay().

1const int SENSOR_PIN = A0;   // S → A0
2const int POWER_PIN = 7;     // + → D7
3const int BUZZER_PIN = 8;    // aktif buzzer + ucu / active buzzer +
4const int LED_PIN = 13;      // Uno'nun dahili LED'i / Uno's built-in LED
5
6const int ALARM_ON = 200;    // bu değer ve üstü taşma / at or above: overflow (kendin ölç / measure yours)
7const int ALARM_OFF = 100;   // bunun altına inince alarm biter / alarm clears below this
8
9bool alarmActive = false;
10bool buzzerOn = false;
11unsigned long lastRead = 0;
12unsigned long lastBeep = 0;
13
14int readSensor() {
15  digitalWrite(POWER_PIN, HIGH);
16  delay(10);
17  long sum = 0;
18  for (int i = 0; i < 8; i++) sum += analogRead(SENSOR_PIN);
19  digitalWrite(POWER_PIN, LOW);
20  return sum / 8;
21}
22
23void setup() {
24  pinMode(POWER_PIN, OUTPUT);
25  pinMode(BUZZER_PIN, OUTPUT);
26  pinMode(LED_PIN, OUTPUT);
27  digitalWrite(POWER_PIN, LOW);
28  Serial.begin(9600);
29}
30
31void loop() {
32  unsigned long now = millis();
33
34  if (now - lastRead >= 1000) {                       // saniyede bir ölç / measure once a second
35    lastRead = now;
36    int level = readSensor();
37    if (!alarmActive && level >= ALARM_ON) alarmActive = true;    // taşma başladı / overflow started
38    if (alarmActive && level < ALARM_OFF) alarmActive = false;    // su çekildi / water receded
39    Serial.print("Seviye / Level: ");
40    Serial.println(level);
41  }
42
43  if (alarmActive) {
44    if (now - lastBeep >= 250) {                      // 250 ms öt, 250 ms sus / 250 ms on, 250 ms off
45      lastBeep = now;
46      buzzerOn = !buzzerOn;
47      digitalWrite(BUZZER_PIN, buzzerOn ? HIGH : LOW);
48    }
49  } else if (buzzerOn) {
50    buzzerOn = false;
51    digitalWrite(BUZZER_PIN, LOW);
52  }
53  digitalWrite(LED_PIN, alarmActive ? HIGH : LOW);
54}

Kendali pompa: mengisi ulang tangki dengan sendirinya

Aplikasi klasik kedua adalah pengisian ulang otomatis yang menjaga level tetap di dalam satu rentang. Mungkin kamu ingin menambah air akuarium yang menguap dari ember cadangan, menjaga mangkuk minum hewan peliharaanmu tetap penuh, atau mengisi tangki rumah kaca. Logikanya sederhana: ketika level turun di bawah START_BELOW, pompa menyala, dan ketika mencapai STOP_ABOVE, pompa berhenti. Selisih di antara kedua ambang ini adalah histeresis yang mencegah pompa terus-menerus menyala dan mati. Ingat, area sensor ini hanya sekitar 4 cm; pasang board di ketinggian yang membuat rentang air yang ingin kamu jaga berada di dalam 4 cm itu.

Pompa menarik arus jauh lebih besar daripada yang bisa diberikan pin Arduino, jadi kendalikan dengan modul relay atau dengan MOSFET logic-level dan dioda flyback, beri daya pompa dari catu terpisah, dan sambungkan GND kedua catu. Untuk detailnya, lihat Apa Itu Modul Relay?, memakai MOSFET, dan pompa air mini. Bagian terpenting dari kode ini adalah sebuah pengaman: jika pompa menyala selama seluruh periode MAX_RUN_MS dan level masih belum mencapai target, sistem mengunci pompa dan memperingatkanmu dengan bunyi bip pendek. Mungkin selangnya terlepas, ember cadangannya kosong, atau sensornya bergeser; tanpa penguncian ini, pompa bisa berjalan kering berjam-jam atau membanjiri seluruh tempat.

1const int SENSOR_PIN = A0;
2const int POWER_PIN = 7;
3const int PUMP_PIN = 8;                 // röle IN / relay IN
4const int BUZZER_PIN = 9;               // aktif buzzer / active buzzer
5const bool RELAY_ACTIVE_LOW = true;     // çoğu röle modülü LOW ile çeker / most relay modules switch on LOW
6
7const int START_BELOW = 300;            // bunun altında doldur / start filling below this (kendin ölç / measure yours)
8const int STOP_ABOVE = 480;             // bu değerde dur / stop at this value
9const unsigned long MAX_RUN_MS = 30000; // en uzun çalışma 30 sn / max run time 30 s
10
11bool pumpOn = false;
12bool fault = false;
13unsigned long pumpStart = 0;
14
15int readSensor() {
16  digitalWrite(POWER_PIN, HIGH);
17  delay(10);
18  long sum = 0;
19  for (int i = 0; i < 8; i++) sum += analogRead(SENSOR_PIN);
20  digitalWrite(POWER_PIN, LOW);
21  return sum / 8;
22}
23
24void setPump(bool on) {
25  pumpOn = on;
26  bool pinHigh = RELAY_ACTIVE_LOW ? !on : on;
27  digitalWrite(PUMP_PIN, pinHigh ? HIGH : LOW);
28}
29
30void setup() {
31  setPump(false);              // pin çıkış olmadan önce kapalı konuma al / set off before the pin becomes an output
32  pinMode(PUMP_PIN, OUTPUT);
33  pinMode(POWER_PIN, OUTPUT);
34  pinMode(BUZZER_PIN, OUTPUT);
35  digitalWrite(POWER_PIN, LOW);
36  Serial.begin(9600);
37}
38
39void loop() {
40  if (fault) {                 // arıza: pompa kilitli, kesik kesik öt / fault: pump locked out, beep
41    digitalWrite(BUZZER_PIN, HIGH);
42    delay(200);
43    digitalWrite(BUZZER_PIN, LOW);
44    delay(1800);
45    return;                    // yeniden başlatmak için reset / press reset to restart
46  }
47
48  int level = readSensor();
49
50  if (!pumpOn && level < START_BELOW) {
51    setPump(true);             // seviye düştü, doldur / level low, start filling
52    pumpStart = millis();
53  } else if (pumpOn && level >= STOP_ABOVE) {
54    setPump(false);            // istenen seviyeye ulaşıldı / target level reached
55  } else if (pumpOn && millis() - pumpStart > MAX_RUN_MS) {
56    setPump(false);            // süre doldu, seviye yükselmedi / timed out, level did not rise
57    fault = true;
58  }
59
60  Serial.print("Seviye / Level: ");
61  Serial.print(level);
62  Serial.println(pumpOn ? "  pompa / pump ON" : "  pompa / pump OFF");
63  delay(500);
64}

Sensor level air vs saklar pelampung vs XKC-Y25

Saklar pelampung terdiri dari batang berisi kontak reed dan pelampung bermagnet yang meluncur di sepanjang batang itu. Ketika air naik, pelampung terangkat, magnet sejajar dengan kontak reed, lalu kontaknya menutup atau membuka. Dengan memasang pelampung terbalik pada batangnya, kamu bisa menukar perilaku normally open (NO) dan normally closed (NC). Untuk menghubungkannya ke Arduino, sambungkan satu kabel ke pin digital dan kabel lainnya ke GND, lalu atur pin sebagai INPUT_PULLUP; karena tidak ada keausan akibat elektrolisis, saklar ini jauh lebih awet di instalasi permanen. Kontak model kecil biasanya dibatasi sekitar 0,5 A dan 10 W, jadi kendalikan pompa lewat relay, jangan langsung. Untuk cara kerja kontak reed, lihat artikel reed switch.

1const int FLOAT_PIN = 2;    // bir kablo D2'ye, diğeri GND'ye / one wire to D2, the other to GND
2
3void setup() {
4  pinMode(FLOAT_PIN, INPUT_PULLUP);   // dahili pull-up direnci / internal pull-up resistor
5  Serial.begin(9600);
6}
7
8void loop() {
9  // Kontak kapalıyken pin LOW okunur / the pin reads LOW when the contact is closed
10  if (digitalRead(FLOAT_PIN) == LOW) {
11    Serial.println("Kontak kapali / Contact closed");
12  } else {
13    Serial.println("Kontak acik / Contact open");
14  }
15  delay(500);
16}

Sementara itu, XKC-Y25 adalah sensor kapasitif yang tidak pernah menyentuh air: kamu menempelkannya di sisi luar tangki plastik atau kaca, dan sensor ini mendeteksi apakah ada cairan di balik dindingnya. Menurut produsennya, sensor ini bekerja pada 5–24 V, menarik sekitar 5 mA, bisa mendeteksi menembus dinding nonlogam setebal hingga 13 mm, dan merespons dalam sekitar 500 ms. Level tinggi output-nya sama dengan tegangan catu, jadi ketika kamu menghubungkan XKC-Y25 yang diberi daya 5 V ke ESP32 atau Pico, kamu perlu memakai pembagi tegangan (kalkulator pembagi tegangan menghitung resistor yang tepat). Penyetelan sensitivitas dan model dengan output yang berbeda kami bahas secara rinci di artikel sensor level tanpa kontak XKC-Y25.

Memantau level air dari ponselmu dengan ESP32

Dengan ESP32, kamu bisa membawa hasil pengukuran ke ponselmu lewat Wi-Fi. Selalu hubungkan pin S sensor ke pin ADC1 (GPIO 32–39); pin ADC2 tidak bisa dibaca selama Wi-Fi aktif. ADC ESP32 adalah 12-bit, jadi nilainya berkisar dari 0 sampai 4095, dan karena sensor diberi daya 3,3 V, angkanya tidak bisa dibandingkan dengan angka di Uno; kamu perlu mengkalibrasi ulang. ADC ESP32 tidak sepenuhnya linear di dekat 0 V dan di dekat batas atas rentangnya, tetapi karena yang penting di sini adalah perbedaan antar-level, bukan tegangan absolutnya, hal itu bukan masalah. Kode di bawah melakukan pembacaan setiap dua detik dan menyajikan halaman web kecil yang menyegarkan dirinya sendiri setiap lima detik, yang bisa kamu buka dari ponselmu di jaringan yang sama.

1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "WIFI_ADIN";      // ağ adın / your network name
5const char* WIFI_PASS = "WIFI_SIFREN";    // ağ şifren / your network password
6
7const int SENSOR_PIN = 34;   // S → GPIO 34 (ADC1, Wi-Fi ile çalışır / works with Wi-Fi)
8const int POWER_PIN = 25;    // + → GPIO 25
9const int HALF = 1500;       // yarım eşiği / half threshold (kendin ölç / measure yours)
10const int FULL = 2000;       // dolu eşiği / full threshold (kendin ölç / measure yours)
11
12WebServer server(80);
13int lastRaw = 0;
14unsigned long lastRead = 0;
15
16int readSensor() {
17  digitalWrite(POWER_PIN, HIGH);
18  delay(10);
19  long sum = 0;
20  for (int i = 0; i < 16; i++) sum += analogRead(SENSOR_PIN);   // 0–4095
21  digitalWrite(POWER_PIN, LOW);
22  return sum / 16;
23}
24
25const char* levelName(int raw) {
26  if (raw < 100) return "Bos / Empty";
27  if (raw < HALF) return "Az / Low";
28  if (raw < FULL) return "Yarim / Half";
29  return "Dolu / Full";
30}
31
32void handleRoot() {
33  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
34                "<meta name='viewport' content='width=device-width'>"
35                "<meta http-equiv='refresh' content='5'></head><body>"
36                "<h1>Su seviyesi / Water level</h1><h2>";
37  html += levelName(lastRaw);
38  html += "</h2><p>Ham deger / Raw: ";
39  html += lastRaw;
40  html += "</p></body></html>";
41  server.send(200, "text/html", html);
42}
43
44void setup() {
45  Serial.begin(115200);
46  pinMode(POWER_PIN, OUTPUT);
47  digitalWrite(POWER_PIN, LOW);
48  WiFi.begin(WIFI_SSID, WIFI_PASS);
49  while (WiFi.status() != WL_CONNECTED) {   // bağlanana kadar bekle / wait until connected
50    delay(500);
51    Serial.print(".");
52  }
53  Serial.println();
54  Serial.print("Adres / Address: http://");
55  Serial.println(WiFi.localIP());
56  server.on("/", handleRoot);
57  server.begin();
58}
59
60void loop() {
61  server.handleClient();
62  if (millis() - lastRead >= 2000) {        // 2 sn'de bir ölç / measure every 2 s
63    lastRead = millis();
64    lastRaw = readSensor();
65  }
66}

Sebelum meng-upload, ganti WIFI_SSID dan WIFI_PASS dengan detail jaringanmu sendiri; ESP32 hanya terhubung ke jaringan 2,4 GHz. Ketika kamu membuka Serial Monitor di 115200 baud, cukup ketik alamat yang ditampilkannya di browser ponselmu. Jika kamu ingin notifikasi di ponsel ketika level “penuh”, kamu bisa mengubah pembacaan yang sama menjadi pesan dengan metode dari artikel bot Telegram ESP32.

Alarm luapan dengan Raspberry Pi Pico dan MicroPython

Di Raspberry Pi Pico, pin GP26, GP27, dan GP28 dipakai untuk pembacaan analog. Fungsi read_u16() di MicroPython menskalakan pengukuran 12-bit Pico ke rentang 0–65535, jadi ambangmu akan berupa angka yang jauh lebih besar daripada di Uno. Kode di bawah memberi daya sensor dari GP15, membaca output S di GP26, dan memberi peringatan luapan dengan tiga bunyi bip pendek dari buzzer aktif di GP14. Sama seperti sketch pertama, tentukan ambang dari pengukuranmu sendiri.

1from machine import ADC, Pin
2import time
3
4sensor = ADC(26)                    # GP26 (ADC0) → S
5power = Pin(15, Pin.OUT, value=0)   # GP15 → sensör + / sensor +
6buzzer = Pin(14, Pin.OUT, value=0)  # GP14 → aktif buzzer / active buzzer
7
8ALARM_ON = 20000    # bu değer ve üstü taşma / at or above: overflow (kendin ölç / measure yours)
9ALARM_OFF = 10000   # bunun altında alarm biter / alarm clears below this
10
11def read_level(samples=8):
12    power.value(1)
13    time.sleep_ms(10)               # değerin oturmasını bekle / let the reading settle
14    total = 0
15    for _ in range(samples):
16        total += sensor.read_u16()  # 0–65535
17    power.value(0)
18    return total // samples
19
20alarm = False
21while True:
22    level = read_level()
23    if not alarm and level >= ALARM_ON:
24        alarm = True
25    elif alarm and level < ALARM_OFF:
26        alarm = False
27    print("Seviye / Level:", level, "ALARM" if alarm else "")
28    if alarm:
29        for _ in range(3):          # üç kısa bip / three short beeps
30            buzzer.value(1)
31            time.sleep_ms(150)
32            buzzer.value(0)
33            time.sleep_ms(150)
34    else:
35        time.sleep(1)

Ide proyek dengan sensor level air

• Peringatan luapan tatakan pot: Buzzer yang berbunyi ketika air menggenang di tatakan setelah penyiraman; gabungkan dengan sensor kelembapan tanah dan kamu punya sistem penyiraman yang lengkap.
• Pengisi ulang akuarium otomatis: Sistem pengisian berbatas waktu yang mengganti air yang menguap dari ember cadangan dengan pompa mini.
• Mangkuk minum hewan peliharaan: Pengingat yang menyalakan LED atau mengirim notifikasi ke ponselmu lewat ESP32 ketika airnya tinggal sedikit.
• Detektor kebocoran air: Alarm kebocoran dengan sensor yang diletakkan mendatar di lantai di bawah mesin cuci atau pemanas air, atau di ruang bawah tanah.
• Tangki rumah kaca pintar: Proteksi yang memantau level tangki irigasi dan mengunci pompa ketika tangki kosong; mudah ditambahkan ke Proyek Rumah Kaca Pintar.
• Pengukur tong air hujan: Panel yang menampilkan level sebagai kosong, setengah, atau penuh di layar LCD I2C; kamu juga bisa menambahkan sensor hujan untuk menangkap momen hujan mulai turun.

Kesalahan umum dan cara mengatasinya

Sensor level air mengajarkan pembacaan analog, kalibrasi, histeresis, dan masalah dunia nyata seperti korosi hanya dengan satu modul murah. Jika kamu perlu mengukur level tangki besar sentimeter demi sentimeter, kamu bisa beralih ke solusi ultrasonik seperti sensor jarak HC-SR04. Di aplikasi BlueGrays, kamu akan menemukan proyek Stasiun Penyiraman Pintar dan proyek alarm dengan buzzer, lengkap dengan skema rangkaian dan kode langkah demi langkah, dan kamu bisa dengan mudah menambahkan sensor level air ke proyek-proyek itu.