MODUL 4

[KEMBALI KE MENU SEBELUMNYA]

DAFTAR ISI

1. Judul

2. Tujuan

3. Alat dan Bahan

4. Dasar Teori

5. Percobaan

Percobaan ...

1. a) Rangkaian Simulasi dan Prinsip Kerja
2. b) Flowchart dan Listing Program
3. c) Video Demo
4. d) Kesimpulan dan Saran
5. e) Download File

MODUL 4

1. Judul[Kembali]

Prototipe Sistem Peringatan Dini Banjir untuk Antisipasi Luapan Drainase dengan STM32 Blue Pill sebagai Sarana Edukasi di Lingkungan Irigasi Limau Manis, Kota Padang

Sistem monitoring drainase berbasis STM32 Blue Pill merupakan proyek yang dirancang untuk memantau kondisi saluran drainase secara otomatis. Sistem ini bekerja dengan membaca kondisi hujan, ketinggian air, dan debit aliran air pada saluran drainase. Dengan adanya sistem ini, kondisi drainase dapat diketahui lebih cepat sehingga potensi genangan atau luapan air dapat diantisipasi.

Pada sistem ini digunakan sensor hujan FC-37 untuk mendeteksi adanya air hujan, sensor jarak laser VL53L0X V2 untuk mengukur level air, serta sensor water flow YF-S201 untuk membaca debit aliran air. Sensor VL53L0X V2 dipasang pada bagian atas pipa ukur dan diarahkan ke pelampung styrofoam yang berada di dalam pipa. Penggunaan styrofoam bertujuan agar pantulan cahaya dari sensor lebih stabil dibandingkan jika sensor langsung diarahkan ke permukaan air.

Data dari sensor akan diproses oleh STM32 Blue Pill. Hasil pembacaan ditampilkan melalui LCD 16x2 I2C, sedangkan kondisi drainase ditunjukkan melalui LED indikator dan buzzer. LED hijau menunjukkan kondisi aman, LED kuning menunjukkan kondisi waspada, dan LED merah menunjukkan kondisi bahaya atau potensi luapan. Buzzer aktif 12 V digunakan sebagai peringatan suara ketika kondisi drainase berada pada status bahaya.

Dengan adanya proyek ini, sistem monitoring drainase dapat disimulasikan dalam bentuk prototipe sederhana menggunakan pipa, air, sensor, dan mikrokontroler. Sistem ini diharapkan dapat menjadi contoh penerapan mikrokontroler pada bidang pemantauan lingkungan, khususnya untuk mendeteksi kondisi drainase secara real-time.

2. Tujuan[Kembali]

1. Untuk merancang dan membangun sistem monitoring drainase berbasis STM32 Blue Pill.
2. Untuk mendeteksi kondisi hujan menggunakan sensor hujan FC-37.
3. Untuk mengukur level air pada saluran drainase menggunakan sensor jarak laser VL53L0X V2 dengan bantuan pelampung styrofoam sebagai bidang pantul.
4. Untuk mengukur debit aliran air pada saluran drainase menggunakan sensor water flow YF-S201.
5. Untuk menampilkan data sensor dan status drainase melalui LCD 16x2 I2C.
6. Untuk memberikan indikator kondisi drainase menggunakan LED hijau, kuning, merah, dan buzzer aktif 12 V.
7. Untuk membuat skenario simulasi kondisi drainase normal, waspada, bahaya, dan potensi luapan.

3. Alat dan Bahan[Kembali]

ALAT

1. Laptop/PC

2. STM32CubeIDE
3. Proteus
4. Multimeter/Voltmeter

5. Breadboard

6. Kabel jumper

7. Adaptor 12 V

8. Pipa PVC atau pipa akrilik

BAHAN

1. STM32 Blue Pill STM32F103C8T6

2. Sensor hujan FC-37

3. Sensor jarak laser VL53L0X V2

4. Sensor water flow YF-S201

5. LCD 16x2 I2C

6. LED

7. Buzzer aktif 3,3 V

8. Transistor NPN 2N2222

11. Resistor

12. Pelampung Styrofoam

4. Dasar Teori[Kembali]

Sistem monitoring drainase merupakan sistem yang dirancang untuk memantau kondisi saluran air berdasarkan beberapa parameter, yaitu kondisi hujan, ketinggian air, dan debit aliran air. Drainase berfungsi untuk mengalirkan air hujan atau air limpasan agar tidak terjadi genangan. Apabila hujan terjadi dalam intensitas tinggi dan aliran drainase tidak lancar, maka ketinggian air pada saluran dapat meningkat dan menyebabkan luapan.

Pada proyek ini, sistem monitoring drainase dibuat menggunakan STM32 Blue Pill sebagai pusat pengendali. Sistem membaca data dari sensor hujan FC-37, sensor jarak laser VL53L0X V2, dan sensor water flow YF-S201. Data dari sensor tersebut diproses untuk menentukan status drainase, yaitu aman, waspada, bahaya, atau potensi luapan. Hasil pemantauan ditampilkan melalui LCD 16x2 I2C, sedangkan indikator status ditunjukkan menggunakan LED dan buzzer.

4.1 STM32 Blue Pill STM32F103C8T6

STM32 Blue Pill merupakan papan mikrokontroler yang menggunakan IC STM32F103C8T6. Mikrokontroler ini digunakan sebagai pusat pemrosesan data pada sistem. STM32 membaca masukan dari sensor, mengolah data, kemudian mengendalikan keluaran berupa LCD, LED, dan buzzer.

Pada sistem monitoring drainase ini, STM32 berfungsi untuk membaca sensor hujan, sensor level air, dan sensor debit air. Sensor hujan dapat dibaca melalui pin analog atau digital, sensor VL53L0X dibaca menggunakan komunikasi I2C, sedangkan sensor YF-S201 dibaca melalui pin digital yang menghitung pulsa. Setelah data sensor diproses, STM32 menentukan status drainase dan mengaktifkan indikator sesuai kondisi.

STM32 memiliki fitur ADC yang dapat digunakan untuk membaca sinyal analog. ADC pada STM32F103C8T6 memiliki resolusi 12-bit, sehingga nilai digital yang dihasilkan berada pada rentang 0 sampai 4095. Hubungan antara tegangan masukan dan nilai ADC dapat ditulis sebagai berikut:

4.2 Sensor Hujan FC-37

Sensor hujan FC-37 digunakan untuk mendeteksi ada atau tidaknya air hujan pada lingkungan sekitar drainase. Sensor ini memiliki papan pendeteksi berupa jalur konduktif. Ketika permukaan sensor kering, hambatan antarjalur relatif besar. Ketika air mengenai permukaan sensor, air akan menghubungkan jalur konduktif sehingga nilai keluaran sensor berubah.

Pada sistem ini, sensor hujan diletakkan di bagian luar prototipe drainase agar dapat terkena air secara langsung. Sensor hujan berfungsi sebagai indikator awal bahwa kondisi lingkungan sedang hujan. Data dari sensor hujan tidak langsung menentukan bahaya, tetapi digabungkan dengan data level air dan debit air untuk menentukan status sistem.

Secara umum, semakin basah permukaan sensor, maka nilai analog yang terbaca akan semakin kecil. Hubungan respons sensor hujan dapat dilihat pada Tabel 1.

Tabel 1. Data respons sensor hujan FC-37

Kondisi Sensor	Intensitas Air (%)	Nilai ADC
Kering	0	4095
Sedikit basah	25	3000
Basah	50	2200
Sangat basah	75	1400
Hujan deras	100	800

Berdasarkan Tabel 1, grafik respons sensor hujan berbentuk menurun. Semakin tinggi intensitas air pada permukaan sensor, maka nilai ADC yang terbaca semakin kecil.

Gambar 1. Grafik Respon Sensor Hujan FC-37

4.3 Sensor Jarak Laser VL53L0X V2

Sensor VL53L0X V2 merupakan sensor jarak berbasis teknologi Time-of-Flight atau ToF. Sensor ini bekerja dengan memancarkan cahaya laser inframerah ke objek, kemudian menghitung waktu pantulan cahaya tersebut kembali ke sensor. Berdasarkan waktu pantulan tersebut, sensor dapat menentukan jarak antara sensor dan objek.

Pada sistem monitoring drainase ini, sensor VL53L0X V2 digunakan untuk mengukur level air. Sensor dipasang pada bagian atas pipa ukur dan diarahkan ke bawah. Di dalam pipa ukur diletakkan pelampung styrofoam sebagai bidang pantul. Penggunaan styrofoam bertujuan agar pantulan cahaya dari sensor lebih stabil dibandingkan jika sensor diarahkan langsung ke permukaan air.

Ketika level air naik, pelampung styrofoam ikut naik. Akibatnya, jarak antara sensor dan styrofoam semakin kecil. Sebaliknya, ketika level air turun, pelampung ikut turun sehingga jarak sensor terhadap styrofoam semakin besar.

Pada prototipe ini, rentang jarak kerja yang digunakan adalah 3 cm sampai 18 cm. Jarak 18 cm dianggap sebagai kondisi air rendah, sedangkan jarak mendekati 3 cm menunjukkan bahwa air berada pada kondisi sangat tinggi. Hubungan antara jarak sensor dan level air dapat dihitung dengan persamaan:

dengan,

h: level air

H: jarak acuan saat air rendah

d: jarak sensor ke styrofoam

Grafik respons sensor VL53L0X V2 terhadap level air berbentuk menurun. Semakin tinggi level air, maka jarak sensor terhadap pelampung semakin kecil.

4.4 Sensor Water Flow YF-S201

Sensor water flow YF-S201 digunakan untuk mengukur debit aliran air pada sistem drainase. Sensor ini memiliki rotor yang akan berputar ketika air mengalir melewati sensor. Putaran rotor tersebut dideteksi oleh sensor Hall dan diubah menjadi sinyal pulsa digital.

Semakin besar debit air yang mengalir, maka semakin cepat rotor berputar. Akibatnya, jumlah pulsa yang dihasilkan dalam satu detik juga semakin besar. STM32 menghitung jumlah pulsa tersebut untuk memperoleh nilai frekuensi, kemudian frekuensi dikonversi menjadi debit air.

Frekuensi pulsa dan debut air dapat dihitung dengan persamaan:

Keterangan:

f           = frekuensi pulsa dalam Hz

N         = jumlah pulsa yang terbaca

t           = waktu pengukuran dalam detik

Keterangan:

Q         = debit air dalam liter/menit

f           = frekuensi pulsa dalam Hz

7,5       = faktor kalibrasi sensor YF-S201

Grafik respons sensor YF-S201 berbentuk naik atau berbanding lurus. Semakin besar debit air, maka semakin besar frekuensi pulsa yang dihasilkan sensor.

Selain debit air, sensor YF-S201 juga dapat digunakan untuk menghitung volume air yang telah melewati sensor. Secara umum, sensor menghasilkan sekitar 450 pulsa untuk setiap 1 liter air. Volume air dapat dihitung dengan persamaan:

Keterangan:

V         = volume air dalam liter

Ntotal  = total pulsa yang terbaca

450      = jumlah pulsa untuk setiap 1 liter air

4.5 LCD 16x2 I2C

LCD 16x2 I2C digunakan untuk menampilkan informasi hasil pembacaan sensor dan status sistem. LCD ini dapat menampilkan dua baris karakter, sehingga sesuai untuk menampilkan data sederhana seperti status hujan, level air, debit air, dan kondisi drainase.

Penggunaan modul I2C pada LCD bertujuan untuk mengurangi jumlah pin yang digunakan pada mikrokontroler. Dengan komunikasi I2C, LCD hanya membutuhkan dua jalur komunikasi utama, yaitu SDA dan SCL. Pada sistem ini, LCD digunakan untuk menampilkan informasi seperti:

Level Air         = ... cm

Debit               = ... L/menit

Status              = Aman/Waspada/Bahaya

4.6 LED Indikator

LED digunakan sebagai indikator visual untuk menunjukkan kondisi drainase. Sistem menggunakan tiga warna LED, yaitu hijau, kuning, dan merah. LED hijau menunjukkan kondisi aman, LED kuning menunjukkan kondisi waspada, dan LED merah menunjukkan kondisi bahaya atau potensi luapan.

Penggunaan LED bertujuan agar status sistem dapat diketahui secara cepat tanpa harus membaca nilai sensor secara detail pada LCD. Pembagian status LED dapat dilihat pada Tabel 2.

Tabel 2. Indikator LED pada sistem

Warna LED	Status	Keterangan
Hijau	Aman	Tidak hujan, level air rendah, dan aliran normal
Kuning	Waspada	Hujan mulai terdeteksi atau level air mulai naik
Merah	Bahaya	Level air tinggi
Merah berkedip	Potensi luapan	Level air sangat tinggi dan debit rendah

4.7 Buzzer Aktif 12 V dan Driver Transistor

Buzzer aktif 12 V digunakan sebagai alarm suara ketika sistem mendeteksi kondisi bahaya. Karena buzzer bekerja pada tegangan 12 V, buzzer tidak dapat dihubungkan langsung ke pin STM32. Pin STM32 hanya menghasilkan tegangan logika 3,3 V dan memiliki batas arus kecil, sehingga diperlukan rangkaian driver.

Driver buzzer dapat dibuat menggunakan transistor NPN seperti 2N2222. Transistor berfungsi sebagai saklar elektronik. Ketika pin STM32 bernilai HIGH, arus kecil mengalir ke basis transistor melalui resistor. Arus tersebut membuat transistor aktif, sehingga arus dari buzzer dapat mengalir menuju ground.

Konfigurasi driver buzzer dapat dituliskan sebagai berikut:

+12V → Buzzer → Collector transistor → Emitter transistor → GND

Sementara itu, pin STM32 dihubungkan ke basis transistor melalui resistor pembatas arus. Dengan rangkaian ini, buzzer tetap mendapatkan tegangan 12 V, sedangkan STM32 hanya digunakan sebagai sinyal kontrol.

4.8 Regulator Tegangan

Regulator tegangan digunakan untuk menyesuaikan tegangan sumber dengan kebutuhan rangkaian. Pada sistem ini, adaptor 12 V digunakan sebagai sumber utama. Tegangan 12 V digunakan untuk buzzer, sedangkan STM32 dan sensor membutuhkan tegangan yang lebih rendah.

Oleh karena itu, digunakan regulator atau buck converter untuk menurunkan tegangan 12 V menjadi 5 V dan 3,3 V. Tegangan 5 V dapat digunakan untuk modul sensor tertentu dan LCD, sedangkan tegangan 3,3 V digunakan untuk STM32 dan komunikasi logika sensor.

5. Percobaan[Kembali]

 

Laporan Akhir

[KEMBALI KE MENU SEBELUMNYA]

DAFTAR ISI

a. Rangkaian Simulasi dan Prinsip Kerja

b. Flowchart dan Listing Program

c. Video Demo

d. Kesimpulan dan Saran

e. Download file

 LAPORAN AKHIR

a. Rangkaian Simulasi dan Prinsip Kerja [kembali]

Pada sistem monitoring drainase berbasis STM32 Blue Pill, prinsip kerja rangkaian didasarkan pada pembacaan tiga parameter utama, yaitu kondisi hujan, level air, dan debit aliran air. Ketiga parameter tersebut digunakan untuk menentukan status saluran drainase, apakah berada dalam kondisi aman, waspada, bahaya, atau potensi luapan.

Sensor hujan FC-37 dipasang pada bagian luar saluran drainase. Sensor ini berfungsi untuk mendeteksi adanya air hujan. Ketika permukaan sensor dalam keadaan kering, sistem membaca kondisi tidak hujan. Ketika sensor terkena air, nilai keluaran sensor berubah dan sistem mendeteksi bahwa hujan sedang terjadi. Data dari sensor hujan digunakan sebagai tanda awal bahwa volume air pada drainase berpotensi meningkat.

Sensor VL53L0X V2 digunakan untuk membaca level air pada saluran drainase. Sensor ini dipasang di bagian atas pipa ukur transparan dan diarahkan ke bawah. Di dalam pipa ukur terdapat pelampung styrofoam yang bergerak naik dan turun mengikuti permukaan air. Ketika level air rendah, posisi styrofoam berada jauh dari sensor sehingga jarak yang terbaca besar. Ketika level air naik, styrofoam ikut naik mendekati sensor sehingga jarak yang terbaca semakin kecil. Data jarak tersebut kemudian diolah oleh STM32 untuk menentukan level air.

Sensor water flow YF-S201 dipasang pada jalur pipa drainase. Sensor ini bekerja dengan menghasilkan pulsa ketika air mengalir melewati bagian dalam sensor. Semakin besar debit air yang mengalir, semakin banyak pulsa yang dihasilkan. Pulsa dari sensor dibaca oleh STM32 melalui pin input digital atau interrupt, kemudian dihitung untuk memperoleh nilai debit air dalam liter per menit.

Setelah data dari ketiga sensor terbaca, STM32 Blue Pill akan memproses data tersebut untuk menentukan status sistem. Apabila tidak hujan, level air rendah, dan debit air normal, maka sistem berada pada kondisi aman. Pada kondisi ini LED hijau menyala, buzzer mati, dan LCD menampilkan status aman.

Apabila sensor hujan mendeteksi adanya hujan atau level air mulai naik, maka sistem masuk ke kondisi waspada. Pada kondisi ini LED kuning menyala dan buzzer dapat berbunyi lambat sebagai peringatan awal. LCD menampilkan informasi bahwa sistem berada pada status waspada.

Apabila level air sudah tinggi, maka sistem masuk ke kondisi bahaya. Pada kondisi ini LED merah menyala dan buzzer berbunyi lebih cepat. Status bahaya menunjukkan bahwa air pada saluran drainase sudah meningkat dan perlu diperhatikan.

Kondisi paling berbahaya terjadi ketika level air sangat tinggi, tetapi debit air rendah. Kondisi ini menunjukkan bahwa air pada saluran meningkat, tetapi aliran air tidak lancar. Hal tersebut dapat menandakan adanya penyumbatan atau potensi luapan pada saluran drainase. Pada kondisi ini LED merah berkedip dan buzzer menyala sebagai alarm peringatan.

Secara umum, alur kerja sistem dimulai dari pembacaan sensor hujan, sensor level air, dan sensor debit air. Data sensor kemudian diproses oleh STM32 untuk menentukan status drainase. Hasil pemrosesan ditampilkan pada LCD, sedangkan LED dan buzzer digunakan sebagai indikator visual dan suara.

b. Flowchart dan Listing Program [kembali]

Flowchart

Listing Program

/* USER CODE BEGIN Header */

/**

  ******************************************************************************

  * @file           : main.c

  * @brief          : Main program body for Smart Drainage Prototype (30cm)

  ******************************************************************************

  */

/* USER CODE END Header */

 

/* Includes ------------------------------------------------------------------*/

#include "main.h"

 

/* Private includes ----------------------------------------------------------*/

/* USER CODE BEGIN Includes */

#include <stdio.h>

#include <string.h>

#include "i2c_lcd.h"

#include "VL53L0X.h"

/* USER CODE END Includes */

 

/* Private typedef -----------------------------------------------------------*/

/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

 

/* Private define ------------------------------------------------------------*/

/* USER CODE BEGIN PD */

/* USER CODE END PD */

 

/* Private macro -------------------------------------------------------------*/

/* USER CODE BEGIN PM */

/* USER CODE END PM */

 

/* Private variables ---------------------------------------------------------*/

ADC_HandleTypeDef hadc1;

 

I2C_HandleTypeDef hi2c1;

I2C_HandleTypeDef hi2c2;

 

/* USER CODE BEGIN PV */

volatile uint32_t flowPulse = 0;

uint32_t flowHz = 0;

float debitLpm = 0.0;

 

uint16_t rainValue = 0;

uint16_t jarakAir = 0;

uint8_t jarakCm = 0;

char statusDrainase[20] = "AMAN";

 

uint32_t previousMillis = 0;

uint32_t lcdMillis = 0;

/* USER CODE END PV */

 

/* Private function prototypes -----------------------------------------------*/

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_ADC1_Init(void);

static void MX_I2C1_Init(void);

static void MX_I2C2_Init(void);

 

/* USER CODE BEGIN PFP */

uint16_t Read_ADC(uint32_t channel);

void CheckDrainageStatus(void);

void UpdateOutputs(void);

/* USER CODE END PFP */

 

/* Private user code ---------------------------------------------------------*/

/* USER CODE BEGIN 0 */

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)

{

    if (GPIO_Pin == GPIO_PIN_2) // PA2 untuk Flow Sensor

    {

        flowPulse++;

    }

}

 

uint16_t Read_ADC(uint32_t channel)

{

    ADC_ChannelConfTypeDef sConfig = {0};

 

    sConfig.Channel = channel;

    sConfig.Rank = ADC_REGULAR_RANK_1;

    sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;

 

    HAL_ADC_ConfigChannel(&hadc1, &sConfig);

    HAL_ADC_Start(&hadc1);

    HAL_ADC_PollForConversion(&hadc1, 100);

 

    uint16_t value = HAL_ADC_GetValue(&hadc1);

 

    HAL_ADC_Stop(&hadc1);

 

    return value;

}

/* USER CODE END 0 */

 

/**

  * @brief  The application entry point.

  * @retval int

  */

int main(void)

{

    /* USER CODE BEGIN 1 */

    /* USER CODE END 1 */

 

    /* MCU Configuration--------------------------------------------------------*/

 

    /* Reset of all peripherals, Initializes the Flash interface and the Systick. */

    HAL_Init();

 

    /* USER CODE BEGIN Init */

    /* USER CODE END Init */

 

    /* Configure the system clock */

    SystemClock_Config();

 

    /* USER CODE BEGIN SysInit */

    /* USER CODE END SysInit */

 

    /* Initialize all configured peripherals */

    MX_GPIO_Init();

    MX_ADC1_Init();

    MX_I2C1_Init();

    MX_I2C2_Init();

 

    /* USER CODE BEGIN 2 */

    lcd_init();

    lcd_clear();

    lcd_put_cur(0, 0);

    lcd_send_string("Sistem Drainase");

    lcd_put_cur(1, 0);

    lcd_send_string("Inisialisasi...");

    HAL_Delay(1000);

 

    if (!initVL53L0X(true, &hi2c2))

    {

        lcd_clear();

        lcd_put_cur(0, 0);

        lcd_send_string("Error: Laser!");

        HAL_Delay(2000);

    }

    else

    {

        setSignalRateLimit(0.1);

        setVcselPulsePeriod(VcselPeriodPreRange, 18);

        setVcselPulsePeriod(VcselPeriodFinalRange, 14);

 

        lcd_clear();

        lcd_put_cur(0, 0);

        lcd_send_string("Laser Ready");

        HAL_Delay(1000);

    }

 

    lcd_clear();

    previousMillis = HAL_GetTick();

    lcdMillis = HAL_GetTick();

    /* USER CODE END 2 */

 

    /* Infinite loop */

    /* USER CODE BEGIN WHILE */

    while (1)

    {

        /* USER CODE END WHILE */

 

        /* USER CODE BEGIN 3 */

        uint32_t currentMillis = HAL_GetTick();

 

        rainValue = Read_ADC(ADC_CHANNEL_0);

        jarakAir = readRangeSingleMillimeters(0);

 

        jarakCm = jarakAir / 10;

 

        if (currentMillis - previousMillis >= 1000)

        {

            previousMillis = currentMillis;

 

            flowHz = flowPulse;

            flowPulse = 0;

 

            debitLpm = (float)flowHz / 7.5;

 

            CheckDrainageStatus();

        }

 

        UpdateOutputs();

 

        if (currentMillis - lcdMillis >= 500)

        {

            lcdMillis = currentMillis;

 

            char line1[21];

            char line2[21];

 

            sprintf(line1, "Air:%2dcm D:%3.1fL", jarakCm, debitLpm);

            lcd_put_cur(0, 0);

            lcd_send_string(line1);

 

            sprintf(line2, "%-16s", statusDrainase);

            lcd_put_cur(1, 0);

            lcd_send_string(line2);

        }

        /* USER CODE END 3 */

    }

}

 

/**

  * @brief System Clock Configuration

  * @retval None

  */

void SystemClock_Config(void)

{

    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

 

    /** Initializes the RCC Oscillators according to the specified parameters

    * in the RCC_OscInitTypeDef structure.

    */

    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;

    RCC_OscInitStruct.HSEState = RCC_HSE_ON;

    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;

 

    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)

    {

        Error_Handler();

    }

 

    /** Initializes the CPU, AHB and APB buses clocks

    */

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK |

                                  RCC_CLOCKTYPE_SYSCLK |

                                  RCC_CLOCKTYPE_PCLK1 |

                                  RCC_CLOCKTYPE_PCLK2;

 

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;

    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

 

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)

    {

        Error_Handler();

    }

 

    PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;

    PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV2;

 

    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)

    {

        Error_Handler();

    }

}

 

/**

  * @brief ADC1 Initialization Function

  * @param None

  * @retval None

  */

static void MX_ADC1_Init(void)

{

    /* USER CODE BEGIN ADC1_Init 0 */

    /* USER CODE END ADC1_Init 0 */

 

    ADC_ChannelConfTypeDef sConfig = {0};

 

    /* USER CODE BEGIN ADC1_Init 1 */

    /* USER CODE END ADC1_Init 1 */

 

    /** Common config

    */

    hadc1.Instance = ADC1;

    hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;

    hadc1.Init.ContinuousConvMode = DISABLE;

    hadc1.Init.DiscontinuousConvMode = DISABLE;

    hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;

    hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;

    hadc1.Init.NbrOfConversion = 1;

 

    if (HAL_ADC_Init(&hadc1) != HAL_OK)

    {

        Error_Handler();

    }

 

    /** Configure Regular Channel

    */

    sConfig.Channel = ADC_CHANNEL_0;

    sConfig.Rank = ADC_REGULAR_RANK_1;

    sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;

 

    if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)

    {

        Error_Handler();

    }

 

    /* USER CODE BEGIN ADC1_Init 2 */

    /* USER CODE END ADC1_Init 2 */

}

 

/**

  * @brief I2C1 Initialization Function

  * @param None

  * @retval None

  */

static void MX_I2C1_Init(void)

{

    /* USER CODE BEGIN I2C1_Init 0 */

    /* USER CODE END I2C1_Init 0 */

 

    /* USER CODE BEGIN I2C1_Init 1 */

    /* USER CODE END I2C1_Init 1 */

 

    hi2c1.Instance = I2C1;

    hi2c1.Init.ClockSpeed = 100000;

    hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;

    hi2c1.Init.OwnAddress1 = 0;

    hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;

    hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;

    hi2c1.Init.OwnAddress2 = 0;

    hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;

    hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;

 

    if (HAL_I2C_Init(&hi2c1) != HAL_OK)

    {

        Error_Handler();

    }

 

    /* USER CODE BEGIN I2C1_Init 2 */

    /* USER CODE END I2C1_Init 2 */

}

 

/**

  * @brief I2C2 Initialization Function

  * @param None

  * @retval None

  */

static void MX_I2C2_Init(void)

{

    /* USER CODE BEGIN I2C2_Init 0 */

    /* USER CODE END I2C2_Init 0 */

 

    /* USER CODE BEGIN I2C2_Init 1 */

    /* USER CODE END I2C2_Init 1 */

 

    hi2c2.Instance = I2C2;

    hi2c2.Init.ClockSpeed = 100000;

    hi2c2.Init.DutyCycle = I2C_DUTYCYCLE_2;

    hi2c2.Init.OwnAddress1 = 0;

    hi2c2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;

    hi2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;

    hi2c2.Init.OwnAddress2 = 0;

    hi2c2.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;

    hi2c2.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;

 

    if (HAL_I2C_Init(&hi2c2) != HAL_OK)

    {

        Error_Handler();

    }

 

    /* USER CODE BEGIN I2C2_Init 2 */

    /* USER CODE END I2C2_Init 2 */

}

 

/**

  * @brief GPIO Initialization Function

  * @param None

  * @retval None

  */

static void MX_GPIO_Init(void)

{

    GPIO_InitTypeDef GPIO_InitStruct = {0};

 

    /* USER CODE BEGIN MX_GPIO_Init_1 */

    /* USER CODE END MX_GPIO_Init_1 */

 

    /* GPIO Ports Clock Enable */

    __HAL_RCC_GPIOD_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();

    __HAL_RCC_GPIOB_CLK_ENABLE();

 

    /* Configure GPIO pin Output Level */

    HAL_GPIO_WritePin(GPIOB, LED_Kuning_Pin | LED_Merah_Pin | Buzzer_Pin, GPIO_PIN_RESET);

 

    /* Configure GPIO pin : sensor_flow_Pin */

    GPIO_InitStruct.Pin = sensor_flow_Pin;

    GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    HAL_GPIO_Init(sensor_flow_GPIO_Port, &GPIO_InitStruct);

 

    /* Configure GPIO pin : LED_Hijau_Pin */

    GPIO_InitStruct.Pin = LED_Hijau_Pin;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    HAL_GPIO_Init(LED_Hijau_GPIO_Port, &GPIO_InitStruct);

 

    /* Configure GPIO pins : LED_Kuning_Pin LED_Merah_Pin Buzzer_Pin */

    GPIO_InitStruct.Pin = LED_Kuning_Pin | LED_Merah_Pin | Buzzer_Pin;

    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

 

    /* Configures the port and pin on which the EVENTOUT Cortex signal will be connected */

    HAL_GPIOEx_ConfigEventout(AFIO_EVENTOUT_PORT_B, AFIO_EVENTOUT_PIN_12);

 

    /* Enables the Event Output */

    HAL_GPIOEx_EnableEventout();

 

    /* EXTI interrupt init */

    HAL_NVIC_SetPriority(EXTI2_IRQn, 0, 0);

    HAL_NVIC_EnableIRQ(EXTI2_IRQn);

 

    /* USER CODE BEGIN MX_GPIO_Init_2 */

    /* USER CODE END MX_GPIO_Init_2 */

}

 

/* USER CODE BEGIN 4 */

void CheckDrainageStatus(void)

{

    if (jarakCm < 10)

    {

        if (rainValue <= 1500 && debitLpm > 2.0)

        {

            strcpy(statusDrainase, "LUAPAN");

        }

        else

        {

            strcpy(statusDrainase, "BAHAYA");

        }

    }

    else if (jarakCm >= 10 && jarakCm <= 20)

    {

        if (rainValue <= 3000)

        {

            strcpy(statusDrainase, "WASPADA");

        }

        else

        {

            strcpy(statusDrainase, "AMAN");

        }

    }

    else

    {

        strcpy(statusDrainase, "AMAN");

    }

}

 

void UpdateOutputs(void)

{

    static uint32_t beepMillis = 0;

    static uint32_t blinkMillis = 0;

    uint32_t currentMillis = HAL_GetTick();

 

    if (strcmp(statusDrainase, "AMAN") == 0)

    {

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_SET);   // Hijau aktif

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, GPIO_PIN_RESET);

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, GPIO_PIN_RESET); // Buzzer mati

    }

    else if (strcmp(statusDrainase, "WASPADA") == 0)

    {

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET);

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, GPIO_PIN_SET);   // Kuning aktif

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);

 

        if (currentMillis - beepMillis >= 600)

        {

            beepMillis = currentMillis;

            HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_15);

        }

    }

    else if (strcmp(statusDrainase, "BAHAYA") == 0)

    {

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET);

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, GPIO_PIN_RESET);

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);   // Merah aktif

 

        if (currentMillis - beepMillis >= 150)

        {

            beepMillis = currentMillis;

            HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_15);

        }

    }

    else if (strcmp(statusDrainase, "LUAPAN") == 0)

    {

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET);

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, GPIO_PIN_RESET);

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, GPIO_PIN_SET);   // Buzzer aktif terus

 

        if (currentMillis - blinkMillis >= 150)

        {

            blinkMillis = currentMillis;

            HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_14); // Merah berkedip

        }

    }

}

/* USER CODE END 4 */

 

/**

  * @brief  This function is executed in case of error occurrence.

  * @retval None

  */

void Error_Handler(void)

{

    /* USER CODE BEGIN Error_Handler_Debug */

    /* User can add his own implementation to report the HAL error return state */

    __disable_irq();

 

    while (1)

    {

    }

    /* USER CODE END Error_Handler_Debug */

}

 

#ifdef USE_FULL_ASSERT

/**

  * @brief  Reports the name of the source file and the source line number

  *         where the assert_param error has occurred.

  * @param  file: pointer to the source file name

  * @param  line: assert_param error line source number

  * @retval None

  */

void assert_failed(uint8_t *file, uint32_t line)

{

    /* USER CODE BEGIN 6 */

    /* User can add his own implementation to report the file name and line number,

       ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

    /* USER CODE END 6 */

}

#endif /* USE_FULL_ASSERT */

c. Video Demo [kembali]

d. Kesimpulan dan Saran [kembali]

Kesimpulan

Berdasarkan perancangan dan simulasi sistem monitoring drainase berbasis STM32 Blue Pill, dapat disimpulkan bahwa:

1. Sistem monitoring drainase berhasil dirancang menggunakan STM32 Blue Pill sebagai mikrokontroler utama untuk membaca sensor, mengolah data, dan mengendalikan output.
2. Sensor hujan FC-37 digunakan untuk mendeteksi kondisi hujan pada lingkungan sekitar saluran drainase. Sensor ini berfungsi sebagai indikator awal adanya potensi peningkatan volume air pada drainase.
3. Sensor jarak laser VL53L0X V2 digunakan untuk mengukur level air pada saluran drainase. Sensor ini membaca jarak terhadap pelampung styrofoam yang diletakkan di dalam pipa ukur. Semakin tinggi level air, maka jarak antara sensor dan pelampung semakin kecil.
4. Sensor water flow YF-S201 digunakan untuk membaca debit aliran air pada saluran drainase. Sensor ini menghasilkan pulsa digital yang kemudian dihitung oleh STM32 untuk memperoleh nilai debit air dalam liter per menit.
5. Output sistem berupa LCD 16x2 I2C, LED indikator, dan buzzer dapat digunakan untuk menampilkan kondisi drainase. LCD menampilkan data sensor dan status sistem, LED menunjukkan kondisi aman, waspada, atau bahaya, sedangkan buzzer memberikan peringatan suara ketika kondisi drainase berbahaya.
6. Sistem mampu membedakan beberapa kondisi drainase, yaitu aman, waspada, bahaya, dan potensi luapan. Kondisi paling berbahaya terjadi ketika level air sangat tinggi tetapi debit air rendah, karena kondisi tersebut menunjukkan kemungkinan adanya penyumbatan pada saluran drainase.
7. Prototipe ini dapat digunakan sebagai simulasi awal sistem pemantauan drainase sederhana yang bekerja secara otomatis berdasarkan pembacaan sensor hujan, level air, dan debit air.

Saran

Adapun saran untuk pengembangan sistem ini adalah sebagai berikut:

1. Pada pengembangan selanjutnya, sistem dapat ditambahkan modul komunikasi seperti Wi-Fi, LoRa, atau GSM agar data kondisi drainase dapat dikirim ke pengguna secara jarak jauh.
2. Sensor VL53L0X V2 sebaiknya dikalibrasi terlebih dahulu sesuai tinggi pipa ukur yang digunakan agar hasil pembacaan level air lebih akurat.
3. Pelampung styrofoam perlu dibuat dengan ukuran yang sesuai dengan diameter pipa ukur agar dapat bergerak naik dan turun dengan stabil tanpa tersangkut.
4. Sensor hujan FC-37 dan rangkaian elektronik sebaiknya diberi pelindung agar tidak terkena percikan air secara langsung, kecuali bagian permukaan sensor yang memang digunakan untuk mendeteksi hujan.
5. Sensor YF-S201 sebaiknya dipasang pada jalur pipa yang alirannya stabil agar pembacaan debit air lebih baik dan tidak terlalu banyak gangguan.
6. Untuk penerapan nyata, sistem dapat dikembangkan dengan menambahkan sumber daya cadangan seperti baterai agar tetap dapat bekerja ketika listrik padam.
7. Sistem dapat ditingkatkan dengan menambahkan penyimpanan data atau database agar riwayat level air, debit air, dan kondisi hujan dapat dianalisis lebih lanjut.

e. Download file [kembali]

Rangkaian Proteus klik disini

Rain Sensor Library klik disini

Water Sensor Library klik disini

Flow Sensor Library klik disini

Datasheet Rain Sensor klik disini

Datasheet LCD I2C klik disini

Datasheet Transistor 2N222

 klik disini

Datasheet Rain Sensor klik disini

Datasheet STM32F103C8T6 Blue Pill klik disini

Datasheet Sensor Jarak klik disini

Datasheet Water Flow Sensor klik disini