Modul 4
Platform Edukasi dan Peringatan Dini Kualitas Air Pascabencana Berbasis STM32 dengan Indikator RGB bagi Masyarakat Batu Busuak
1. Tujuan Rancangan [kembali]
Rancangan Platform Edukasi dan Peringatan Dini Kualitas Air Pascabencana Berbasis STM32 dengan Indikator RGB bagi Masyarakat Batu Busuak bertujuan untuk membantu masyarakat dalam memantau kualitas air secara sederhana dan real-time setelah terjadinya bencana. Sistem ini dirancang untuk mengukur tingkat keasaman (pH) dan suhu air sebagai parameter utama dalam menentukan kualitas air. Selain itu, sistem juga dilengkapi dengan sensor Float Switch untuk mendeteksi kondisi air penuh pada wadah penyimpanan. Informasi yang diperoleh dari sensor akan diproses oleh mikrokontroler STM32 dan ditampilkan melalui LCD, RGB LED, serta buzzer sehingga pengguna dapat mengetahui kondisi air dengan cepat dan mudah dipahami.
2. Daftar Alat dan Komponen [kembali]
- STM32F103C8T6
- Sensor pH
- Sensor Suhu DS18B20
- Float Switch
- LCD 16×2 I2C
- RGB LED
- Buzzer
- Resistor 220 Ω
- Resistor 4,7 kΩ
- Kabel jumper
- Breadboard
- Akrilik prototype
- Adaptor 5V
3. Landasan Teori dan Grafik Sensor [kembali]
Landasan Teori
3.1 Mikrokontroler STM32F103C8T6
STM32F103C8T6 merupakan mikrokontroler 32-bit berbasis ARM Cortex-M3 yang diproduksi oleh STMicroelectronics. Mikrokontroler ini banyak digunakan dalam berbagai aplikasi sistem tertanam karena memiliki kemampuan pemrosesan yang tinggi, konsumsi daya yang rendah, serta dilengkapi berbagai periferal internal yang mendukung pengembangan sistem monitoring dan kontrol. STM32F103C8T6 memiliki kecepatan clock hingga 72 MHz, memori Flash sebesar 64 KB hingga 128 KB, serta RAM sebesar 20 KB yang cukup untuk menjalankan berbagai aplikasi berbasis sensor.
Dalam sistem Platform Edukasi dan Peringatan Dini Kualitas Air Pascabencana, STM32F103C8T6 berfungsi sebagai pusat pengendali utama. Mikrokontroler ini bertugas membaca data dari sensor pH, sensor suhu DS18B20, dan sensor Float Switch, kemudian mengolah data tersebut untuk menentukan kondisi kualitas air. Setelah data diproses, STM32 akan mengendalikan LCD, RGB LED, dan buzzer sebagai media penyampaian informasi kepada pengguna.
Penggunaan STM32 dipilih karena memiliki ADC (Analog to Digital Converter) 12-bit yang mampu mengubah sinyal analog dari sensor pH menjadi data digital dengan resolusi tinggi. Selain itu, STM32 juga mendukung komunikasi digital yang digunakan untuk membaca data dari sensor DS18B20 dan menampilkan informasi pada LCD berbasis I2C.
3.2 Sensor pH
Sensor pH merupakan sensor yang digunakan untuk mengukur tingkat keasaman atau kebasaan suatu larutan. Nilai pH berkisar antara 0 hingga 14. Larutan dengan pH kurang dari 7 bersifat asam, pH sama dengan 7 bersifat netral, sedangkan pH lebih dari 7 bersifat basa. Tingkat pH merupakan salah satu parameter penting dalam menentukan kualitas air karena berpengaruh terhadap kesehatan manusia maupun organisme yang hidup di dalam air.
Prinsip kerja sensor pH didasarkan pada pengukuran konsentrasi ion hidrogen (H⁺) dalam suatu larutan. Sensor akan menghasilkan tegangan yang berubah sesuai dengan perubahan nilai pH. Tegangan tersebut kemudian dibaca oleh ADC pada mikrokontroler dan diolah menjadi nilai pH yang dapat ditampilkan kepada pengguna.
Pada sistem ini, sensor pH digunakan sebagai parameter utama dalam menentukan kualitas air pascabencana. Air dianggap layak digunakan apabila memiliki nilai pH pada rentang 6,5 hingga 8,5 sesuai standar kualitas air bersih. Apabila nilai pH berada di bawah atau di atas rentang tersebut, maka sistem akan memberikan peringatan kepada pengguna.
Kategori kualitas air berdasarkan pH yang digunakan pada sistem adalah:
- pH 6,5 – 8,5 : Normal
- pH < 6,5 : Waspada/Bahaya
- pH > 8,5 : Waspada/Bahaya
Data hasil pengukuran sensor pH ditampilkan pada LCD dan digunakan sebagai dasar pengambilan keputusan untuk mengaktifkan indikator RGB LED serta buzzer.
3.3 Sensor Suhu DS18B20
DS18B20 merupakan sensor suhu digital yang menggunakan protokol komunikasi One-Wire. Sensor ini hanya memerlukan satu jalur data untuk berkomunikasi dengan mikrokontroler sehingga penggunaan pin menjadi lebih efisien. DS18B20 memiliki rentang pengukuran suhu dari -55°C hingga 125°C dengan tingkat akurasi yang cukup tinggi.
Dalam sistem monitoring kualitas air, suhu merupakan salah satu parameter yang sangat penting karena dapat memengaruhi karakteristik fisik, kimia, dan biologis air. Suhu yang terlalu tinggi dapat mempercepat pertumbuhan mikroorganisme tertentu, mengurangi kadar oksigen terlarut, serta mempercepat terjadinya reaksi kimia di dalam air.
Sensor DS18B20 bekerja dengan mengubah perubahan suhu menjadi data digital yang dikirim langsung ke mikrokontroler. Data suhu yang diperoleh kemudian ditampilkan pada LCD dan digunakan sebagai parameter penentu kondisi kualitas air.
Pada sistem ini digunakan parameter:
- 25°C – 30°C : Normal
- <25°C : Waspada/Bahaya
- 30°C : Waspada/Bahaya
Apabila suhu berada di luar rentang normal, sistem akan mengaktifkan indikator peringatan sebagai tanda bahwa kondisi air memerlukan perhatian lebih lanjut.
3.4 Sensor Float Switch
Float Switch merupakan sensor level air yang bekerja menggunakan mekanisme pelampung. Sensor ini terdiri dari pelampung yang akan bergerak mengikuti perubahan permukaan air. Ketika permukaan air mencapai titik tertentu, pelampung akan mengaktifkan kontak saklar di dalam sensor sehingga menghasilkan perubahan logika digital yang dapat dibaca oleh mikrokontroler.
Berbeda dengan sensor pH dan sensor suhu yang digunakan untuk menentukan kualitas air, Float Switch pada sistem ini digunakan sebagai indikator kondisi air penuh pada wadah penyimpanan atau toren. Sensor ini berfungsi untuk memberikan informasi kepada pengguna bahwa kapasitas penyimpanan air telah mencapai batas maksimum.
Keunggulan Float Switch adalah konstruksinya yang sederhana, mudah dipasang, memiliki keandalan yang baik, serta tidak memerlukan proses kalibrasi yang rumit. Karena menghasilkan keluaran digital, sensor ini juga mudah diintegrasikan dengan mikrokontroler STM32.
Parameter yang digunakan dalam sistem adalah:
- Float Switch OFF : Air belum penuh
- Float Switch ON : Air penuh
Ketika kondisi air penuh terdeteksi, sistem akan menampilkan informasi "AIR PENUH" pada LCD dan dapat mengaktifkan buzzer sebagai peringatan tambahan kepada pengguna.
3.5 LCD 16×2 I2C
LCD 16×2 merupakan perangkat output yang digunakan untuk menampilkan informasi dalam bentuk karakter dan angka. LCD ini mampu menampilkan dua baris teks dengan kapasitas masing-masing 16 karakter. Dalam sistem ini digunakan modul I2C sehingga komunikasi dengan mikrokontroler hanya memerlukan dua jalur yaitu SDA dan SCL.
LCD berfungsi sebagai media informasi utama yang menampilkan nilai pH, suhu air, status air penuh, dan kondisi kualitas air secara real-time. Dengan adanya LCD, pengguna dapat memantau seluruh kondisi sistem tanpa memerlukan perangkat tambahan.
Penggunaan LCD memberikan kemudahan bagi masyarakat karena informasi yang ditampilkan dapat dibaca secara langsung dan mudah dipahami.
3.6 RGB LED
RGB LED merupakan Light Emitting Diode yang terdiri dari tiga warna dasar yaitu merah (Red), hijau (Green), dan biru (Blue). Dengan mengatur kombinasi ketiga warna tersebut, RGB LED dapat menghasilkan berbagai warna yang berbeda.
Pada sistem ini RGB LED digunakan sebagai indikator visual kondisi kualitas air. Penggunaan indikator warna mempermudah pengguna dalam memahami kondisi air tanpa harus membaca nilai sensor secara detail.
Indikator yang digunakan adalah:
- Hijau : Kualitas air normal
- Merah : Kualitas air waspada/bahaya
Apabila nilai pH dan suhu berada dalam rentang normal, maka LED hijau akan menyala. Sebaliknya, apabila salah satu parameter berada di luar rentang normal, LED merah akan menyala sebagai tanda peringatan.
3.7 Buzzer
Buzzer merupakan komponen elektronika yang mampu menghasilkan suara ketika diberikan tegangan listrik. Pada sistem peringatan dini, buzzer digunakan sebagai media alarm untuk menarik perhatian pengguna ketika terjadi kondisi tertentu.
Dalam sistem ini buzzer akan aktif apabila kualitas air berada pada kondisi waspada/bahaya atau ketika sensor Float Switch mendeteksi bahwa wadah penyimpanan air telah penuh. Penggunaan buzzer bertujuan agar pengguna dapat mengetahui kondisi sistem meskipun tidak sedang memperhatikan LCD maupun indikator LED.
Keberadaan buzzer meningkatkan efektivitas sistem peringatan dini karena informasi tidak hanya disampaikan secara visual, tetapi juga secara audio.
3.8 Sistem Peringatan Dini Kualitas Air Pascabencana
Sistem peringatan dini kualitas air pascabencana merupakan sistem yang dirancang untuk membantu masyarakat dalam memantau kondisi air setelah terjadinya bencana alam. Setelah bencana, kualitas air sering mengalami perubahan akibat pencemaran, masuknya material asing, maupun perubahan kondisi lingkungan sehingga diperlukan sistem yang mampu memberikan informasi secara cepat dan mudah dipahami.
Sistem ini bekerja dengan membaca data dari sensor pH dan sensor suhu sebagai parameter utama kualitas air. Data yang diperoleh kemudian diproses oleh STM32 untuk menentukan apakah kondisi air berada dalam kategori normal atau waspada/bahaya. Selain itu, sistem juga memantau kondisi air penuh menggunakan sensor Float Switch.
Apabila nilai pH dan suhu berada pada rentang normal, sistem akan menyalakan LED hijau dan menampilkan status kualitas air normal pada LCD. Sebaliknya, apabila salah satu parameter berada di luar rentang normal, sistem akan mengaktifkan LED merah dan buzzer sebagai tanda peringatan. Ketika Float Switch mendeteksi air penuh, sistem akan menampilkan informasi tambahan pada LCD sehingga pengguna dapat mengetahui kondisi wadah penyimpanan air.
Dengan adanya sistem ini, masyarakat Batu Busuak diharapkan dapat memperoleh informasi kualitas air secara cepat, mudah, dan akurat sehingga dapat mengurangi risiko penggunaan air yang tidak layak setelah terjadinya bencana.
4. Flowchart Sistem [kembali]
5. Listing Program [kembali]
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body (HYDRO-CARE V2 - REAL HARDWARE I2C LCD)
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
// Alamat I2C LCD. Jika layar tidak nyala, ganti 0x4E menjadi 0x7E (Tergantung versi PCF8574)
#define SLAVE_ADDRESS_LCD 0x4E
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
I2C_HandleTypeDef hi2c1;
UART_HandleTypeDef huart1;
/* USER CODE BEGIN PV */
char lcd_buffer[32];
float nilai_pH = 0.0;
float nilai_suhu = 0.0;
uint8_t status_toren_penuh = 0; // 1 = Penuh, 0 = Mengisi
uint32_t nilai_adc_pH = 0;
// Variabel untuk delay non-blocking sensor suhu
uint32_t last_temp_req = 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_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */
// Prototipe Fungsi I2C LCD
void lcd_init(void);
void lcd_send_cmd(char cmd);
void lcd_send_data(char data);
void lcd_send_string(char *str);
void lcd_put_cur(int row, int col);
void lcd_clear(void);
// Prototipe Fungsi DS18B20
void delay_us(uint32_t us);
uint8_t DS18B20_Start(void);
void DS18B20_Write(uint8_t data);
uint8_t DS18B20_Read(void);
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// ========================================================
// FUNGSI LIBRARY CUSTOM: I2C LCD 16x2
// ========================================================
void lcd_send_cmd (char cmd) {
char data_u, data_l;
uint8_t data_t[4];
data_u = (cmd&0xf0);
data_l = ((cmd<<4)&0xf0);
data_t[0] = data_u|0x0C; //en=1, rs=0
data_t[1] = data_u|0x08; //en=0, rs=0
data_t[2] = data_l|0x0C; //en=1, rs=0
data_t[3] = data_l|0x08; //en=0, rs=0
HAL_I2C_Master_Transmit (&hi2c1, SLAVE_ADDRESS_LCD,(uint8_t *) data_t, 4, 100);
}
void lcd_send_data (char data) {
char data_u, data_l;
uint8_t data_t[4];
data_u = (data&0xf0);
data_l = ((data<<4)&0xf0);
data_t[0] = data_u|0x0D; //en=1, rs=1
data_t[1] = data_u|0x09; //en=0, rs=1
data_t[2] = data_l|0x0D; //en=1, rs=1
data_t[3] = data_l|0x09; //en=0, rs=1
HAL_I2C_Master_Transmit (&hi2c1, SLAVE_ADDRESS_LCD,(uint8_t *) data_t, 4, 100);
}
void lcd_clear (void) {
lcd_send_cmd (0x01);
HAL_Delay(2);
}
void lcd_put_cur(int row, int col) {
switch (row) {
case 0: col |= 0x80; break;
case 1: col |= 0xC0; break;
}
lcd_send_cmd (col);
}
void lcd_init (void) {
HAL_Delay(50);
lcd_send_cmd (0x30); HAL_Delay(5);
lcd_send_cmd (0x30); HAL_Delay(1);
lcd_send_cmd (0x30); HAL_Delay(10);
lcd_send_cmd (0x20); HAL_Delay(10);
lcd_send_cmd (0x28); HAL_Delay(1);
lcd_send_cmd (0x08); HAL_Delay(1);
lcd_send_cmd (0x01); HAL_Delay(2);
lcd_send_cmd (0x06); HAL_Delay(1);
lcd_send_cmd (0x0C); HAL_Delay(1);
}
void lcd_send_string (char *str) {
while (*str) lcd_send_data (*str++);
}
/* 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_USART1_UART_Init();
/* USER CODE BEGIN 2 */
// 1. Matikan semua aktuator (LED & Buzzer) saat alat baru menyala
HAL_GPIO_WritePin(GPIOA, LED_MERAH_Pin|LED_HIJAU_Pin|BUZZER_Pin, GPIO_PIN_RESET);
// 2. Inisialisasi Layar I2C LCD
lcd_init();
lcd_clear();
lcd_put_cur(0, 0);
lcd_send_string("HYDRO-CARE HW");
lcd_put_cur(1, 0);
lcd_send_string("SYSTEM READY...");
HAL_Delay(2000);
lcd_clear();
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
// =========================================================
// BLOK 1: AKUISISI DATA SENSOR (INPUT)
// =========================================================
// A. Baca Sensor pH
HAL_ADC_Start(&hadc1);
if (HAL_ADC_PollForConversion(&hadc1, 100) == HAL_OK) {
nilai_adc_pH = HAL_ADC_GetValue(&hadc1);
}
HAL_ADC_Stop(&hadc1);
// Rumus kalibrasi presisi berbasis ADC Mentah (pH 4 & pH 7)
nilai_pH = (-0.0934f * (float)nilai_adc_pH) + 67.71f;
// Batasi nilai agar tetap relevan dengan skala kimia
if (nilai_pH < 0.0f) nilai_pH = 0.0f;
if (nilai_pH > 14.0f) nilai_pH = 14.0f;
// B. Baca Sensor Suhu DS18B20 (Metode Non-Blocking 800ms)
if (HAL_GetTick() - last_temp_req > 800 || last_temp_req == 0) {
if (last_temp_req != 0) {
DS18B20_Start();
DS18B20_Write(0xCC);
DS18B20_Write(0xBE);
uint8_t temp_byte1 = DS18B20_Read();
uint8_t temp_byte2 = DS18B20_Read();
uint16_t temp_raw = (temp_byte2 << 8) | temp_byte1;
nilai_suhu = (float)temp_raw / 16.0;
}
DS18B20_Start();
DS18B20_Write(0xCC);
DS18B20_Write(0x44);
last_temp_req = HAL_GetTick();
}
// C. Baca Sensor Float Switch (Active Low)
if (HAL_GPIO_ReadPin(GPIOA, FLOAT_SWITCH_Pin) == GPIO_PIN_RESET) {
status_toren_penuh = 1; // Logika 0 = Penuh
} else {
status_toren_penuh = 0; // Logika 1 = Mengisi
}
// Manipulasi variabel untuk cetak desimal ke LCD
int ph_int = (int)nilai_pH;
int ph_dec = (int)(nilai_pH * 10) % 10;
int suhu_int = (int)nilai_suhu;
int suhu_dec = (int)(nilai_suhu * 10) % 10;
// =========================================================
// BLOK 2: LOGIKA PENGKONDISIAN & AKTUATOR (OUTPUT)
// =========================================================
if (nilai_pH < 6.5 || nilai_pH > 8.5 || nilai_suhu > 30.0)
{
// --- KONDISI 1: AIR TERCEMAR (BAHAYA) ---
HAL_GPIO_WritePin(GPIOA, LED_HIJAU_Pin, GPIO_PIN_RESET); // Matikan Hijau
// LED Merah NYALA konstan & Buzzer NYALA konstan (Sesuai Tabel)
HAL_GPIO_WritePin(GPIOA, LED_MERAH_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, BUZZER_Pin, GPIO_PIN_SET);
sprintf(lcd_buffer, "pH:%d.%d T:%d.%dC ", ph_int, ph_dec, suhu_int, suhu_dec);
lcd_put_cur(0, 0); lcd_send_string(lcd_buffer);
lcd_put_cur(1, 0); lcd_send_string("BAHAYA! TERCEMAR");
HAL_Delay(500); // Jeda stabilisasi pembacaan
}
else
{
// --- KUALITAS AIR AMAN ---
HAL_GPIO_WritePin(GPIOA, LED_MERAH_Pin, GPIO_PIN_RESET); // Matikan Merah
HAL_GPIO_WritePin(GPIOA, LED_HIJAU_Pin, GPIO_PIN_SET); // LED Hijau NYALA konstan
if (status_toren_penuh == 1)
{
// --- KONDISI 2: AMAN (TOREN PENUH) ---
sprintf(lcd_buffer, "pH:%d.%d T:%d.%dC ", ph_int, ph_dec, suhu_int, suhu_dec);
lcd_put_cur(0, 0); lcd_send_string(lcd_buffer);
lcd_put_cur(1, 0); lcd_send_string("AMAN | TR:PENUH ");
// Buzzer BERKEDIP putus-putus (Sesuai Tabel)
HAL_GPIO_WritePin(GPIOA, BUZZER_Pin, GPIO_PIN_SET);
HAL_Delay(150);
HAL_GPIO_WritePin(GPIOA, BUZZER_Pin, GPIO_PIN_RESET);
HAL_Delay(350);
}
else
{
// --- KONDISI 3: AMAN (TOREN MENGISI) ---
sprintf(lcd_buffer, "pH:%d.%d T:%d.%dC ", ph_int, ph_dec, suhu_int, suhu_dec);
lcd_put_cur(0, 0); lcd_send_string(lcd_buffer);
lcd_put_cur(1, 0); lcd_send_string("AMAN | TR:MENGISI");
// Buzzer MATI (Sesuai Tabel)
HAL_GPIO_WritePin(GPIOA, BUZZER_Pin, GPIO_PIN_RESET);
HAL_Delay(500);
}
}
}
/* 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_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
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_HSI;
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 USART1 Initialization Function
* @param None
* @retval None
*/
static void MX_USART1_UART_Init(void)
{
/* USER CODE BEGIN USART1_Init 0 */
/* USER CODE END USART1_Init 0 */
/* USER CODE BEGIN USART1_Init 1 */
/* USER CODE END USART1_Init 1 */
huart1.Instance = USART1;
huart1.Init.BaudRate = 9600;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART1_Init 2 */
/* USER CODE END USART1_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(GPIOA, DS18B20_Pin|BUZZER_Pin|LED_MERAH_Pin|LED_HIJAU_Pin, GPIO_PIN_RESET);
/*Configure GPIO pins : DS18B20_Pin BUZZER_Pin LED_MERAH_Pin LED_HIJAU_Pin */
GPIO_InitStruct.Pin = DS18B20_Pin|BUZZER_Pin|LED_MERAH_Pin|LED_HIJAU_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pin : FLOAT_SWITCH_Pin */
GPIO_InitStruct.Pin = FLOAT_SWITCH_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(FLOAT_SWITCH_GPIO_Port, &GPIO_InitStruct);
/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}
/* USER CODE BEGIN 4 */
// ========================================================
// FUNGSI SENSOR DS18B20 - DIRECT REGISTER ACCESS (8 MHz)
// ========================================================
void delay_us(uint32_t us) {
// Pada HSI 8MHz, pengali 1 hingga 2 adalah nilai optimal
// untuk mengompensasi siklus loop biner assembly
volatile uint32_t loops = us * 1;
while (loops--) {
__asm("NOP");
}
}
uint8_t DS18B20_Start(void) {
uint8_t response = 0;
GPIOA->BRR = DS18B20_Pin; // HAL_GPIO_WritePin LOW (Instan)
delay_us(480);
GPIOA->BSRR = DS18B20_Pin; // HAL_GPIO_WritePin HIGH (Instan)
delay_us(80);
if (!(GPIOA->IDR & DS18B20_Pin)) response = 1; // HAL_GPIO_ReadPin (Instan)
delay_us(400);
return response;
}
void DS18B20_Write(uint8_t data) {
for (int i = 0; i < 8; i++) {
if ((data & (1<<i)) != 0) {
GPIOA->BRR = DS18B20_Pin; // Tulis 1: Tarik LOW sebentar
delay_us(2);
GPIOA->BSRR = DS18B20_Pin; // Lepas kembali ke HIGH
delay_us(60);
} else {
GPIOA->BRR = DS18B20_Pin; // Tulis 0: Tarik LOW lama
delay_us(60);
GPIOA->BSRR = DS18B20_Pin; // Lepas kembali ke HIGH
delay_us(2);
}
}
}
uint8_t DS18B20_Read(void) {
uint8_t value = 0;
for (int i = 0; i < 8; i++) {
GPIOA->BRR = DS18B20_Pin; // Mulai slot baca: Tarik LOW
delay_us(2); // Tahan low selama 2 us
GPIOA->BSRR = DS18B20_Pin; // Lepas pin (Open Drain letting pull-up take over)
delay_us(8); // Tunggu 8 us (Total 10 us, sangat aman di bawah batas 15 us)
if (GPIOA->IDR & DS18B20_Pin) { // Ambil sampel data bit sekarang
value |= (1<<i);
}
delay_us(50); // Selesaikan sisa slot waktu 60 us
}
return value;
}
/* 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 */
6. Rangkaian Simulasi dan Prototype [kembali]
7. Video Penjelasan [kembali]
8. Kesimpulan dan Saran [kembali]
Kesimpulan
Berdasarkan hasil perancangan dan implementasi Platform Edukasi dan Peringatan Dini Kualitas Air Pascabencana Berbasis STM32 dengan Indikator RGB bagi Masyarakat Batu Busuak, dapat disimpulkan bahwa sistem telah berhasil dirancang untuk melakukan pemantauan kualitas air secara real-time menggunakan sensor pH dan sensor suhu DS18B20 sebagai parameter utama. Sistem mampu mengukur nilai pH dan suhu air, kemudian mengolah data tersebut menggunakan mikrokontroler STM32F103C8T6 untuk menentukan kondisi kualitas air.
Kondisi air dikategorikan sebagai normal apabila nilai pH dan suhu berada dalam rentang yang telah ditentukan, yaitu pH 6,5–8,5 dan suhu 25°C–30°C. Apabila salah satu parameter berada di luar rentang tersebut, sistem akan mengategorikan kondisi air sebagai waspada/bahaya dan memberikan peringatan melalui RGB LED serta buzzer. Selain itu, sensor Float Switch berhasil digunakan sebagai indikator kondisi air penuh pada wadah penyimpanan sehingga pengguna dapat mengetahui kapasitas air yang tersedia.
Informasi hasil pemantauan ditampilkan melalui LCD 16×2 I2C sehingga pengguna dapat memantau kondisi sistem secara langsung. Dengan adanya sistem ini, masyarakat dapat memperoleh informasi kualitas air secara cepat, sederhana, dan mudah dipahami sehingga dapat membantu mengurangi risiko penggunaan air yang tidak layak pascabencana.
Saran
- Sistem yang telah dirancang dapat dikembangkan lebih lanjut dengan menambahkan fitur dan fungsi yang lebih lengkap sesuai kebutuhan pengguna.
- Pengujian sistem dapat dilakukan pada kondisi dan lingkungan yang berbeda untuk memperoleh hasil yang lebih beragam.
- Perawatan dan pengecekan komponen secara berkala perlu dilakukan agar sistem dapat bekerja dengan baik dan stabil.
- Penggunaan komponen dengan spesifikasi yang lebih baik dapat dipertimbangkan untuk meningkatkan kinerja sistem.
- Diharapkan rancangan ini dapat menjadi referensi untuk pengembangan sistem monitoring kualitas air pada penelitian atau proyek berikutnya.
9. Download File [kembali]
- Download Rangkaian Simulasi disini
- Download Datasheet STM32F103C8T6 disini
- Download Datasheet Sensor Suhu DS18B20 disini
- Download Datasheet LCD I2C 16X2 disini
- Download Datasheet Sensor pH disini
- Download Datasheet Sensor Float Switch disini
- Download Datasheet LED RGB disini
- Download Datasheet Buzzer disini
Komentar
Posting Komentar