Laporan Modul 4 Kelompok 22

    [KEMBALI KE MENU SEBELUMNYA]



Smart Electrical and Fire Hazard Early Warning System Berbasis STM32 

untuk Keselamatan Rumah Tinggal di Kawasan Huntara 


1. Pendahuluan [kembali]

Kebakaran rumah tinggal masih menjadi salah satu permasalahan yang sering terjadi di Indonesia, termasuk di Sumatra Barat. Berdasarkan data Dinas Pemadam Kebakaran Kota Padang tahun 2026, tercatat lebih dari 100 kasus kebakaran terjadi dalam beberapa bulan pertama tahun 2026 dan sebagian besar disebabkan oleh korsleting listrik. Hal ini menunjukkan bahwa bahaya overload listrik dan keterlambatan deteksi kebakaran masih menjadi masalah serius di lingkungan masyarakat. 

Penggunaan stop kontak bertumpuk, instalasi listrik yang kurang baik, serta kurangnya sistem monitoring dini menjadi faktor utama yang meningkatkan risiko kebakaran rumah. Selain itu, masyarakat sering terlambat menyadari adanya asap atau sumber api sehingga penanganan menjadi lebih sulit dilakukan. 

Berdasarkan permasalahan tersebut, diperlukan sebuah sistem Early Warning System (EWS) sederhana yang mampu mendeteksi potensi bahaya kebakaran sejak dini. Oleh karena itu, pada project ini akan dirancang sebuah sistem peringatan dini berbasis mikrokontroler STM32 yang mampu mendeteksi overload listrik, asap, dan api menggunakan beberapa sensor. Sistem akan memberikan peringatan secara otomatis melalui alarm buzzer, pemutusan aliran listrik menggunakan relay, dan tampilan informasi pada LCD.

2. Tujuan Rancangan [kembali]

  1. Membuat prototype Smart Early Warning System berbasis STM32. 
  2. Mendeteksi overload listrik menggunakan sensor arus.
  3.  Mendeteksi asap dan api sebagai indikasi awal kebakaran.
  4. Memberikan peringatan dini secara otomatis melalui buzzer, relay, dan LCD. 
  5. Memberikan edukasi kepada masyarakat mengenai keselamatan listrik rumah tangga.

3. Alat dan Komponen  [kembali]

  1. Input (Sensor)
  • Sensor Arus ACS712


  • Sensor Asap MQ-2 


  • Flame Sensor
    2. Output (Aktuator) 
  • Buzzer

  • Relay Module

  • LCD I2C 16x2

  • STM32 BluePill


4. Landasan Teori serta Grafik Respon Sensor [kembali]

  1. Input (Sensor)
  • Sensor Arus ACS712
Sensor ACS712 merupakan sensor arus berbasis efek Hall yang diproduksi oleh Allegro MicroSystems. Sensor ini digunakan untuk mengukur arus AC maupun DC secara linier dengan memanfaatkan medan magnet yang dihasilkan oleh arus listrik yang mengalir pada konduktor internal sensor. Sensor ACS712 memiliki isolasi listrik antara jalur pengukuran arus dan jalur sinyal keluaran sehingga meningkatkan keamanan sistem monitoring listrik.

Prinsip kerja ACS712 didasarkan pada fenomena efek Hall. Arus yang mengalir melalui konduktor tembaga internal akan menghasilkan medan magnet. Medan magnet tersebut dideteksi oleh elemen Hall yang berada sangat dekat dengan konduktor sehingga menghasilkan tegangan yang proporsional terhadap besar arus yang mengalir. Tegangan Hall yang dihasilkan kemudian diperkuat dan dikondisikan menjadi sinyal analog yang dapat dibaca oleh ADC mikrokontroler.

Sensor ACS712 bekerja menggunakan catu daya tunggal 5 V dan menghasilkan tegangan keluaran analog yang berbanding lurus terhadap arus yang diukur. Pada kondisi tanpa arus (0 A), tegangan keluaran berada pada sekitar setengah tegangan suplai atau sebesar 2,5 V. Ketika arus bertambah pada arah positif, tegangan keluaran meningkat, sedangkan untuk arah negatif tegangan keluaran menurun.

ACS712 tersedia dalam beberapa varian pengukuran, yaitu ±5 A, ±20 A, dan ±30 A dengan sensitivitas masing-masing sebesar 185 mV/A, 100 mV/A, dan 66 mV/A. Sensor memiliki bandwidth hingga 80 kHz, waktu respons sekitar 5 μs, resistansi konduktor internal sebesar 1,2 mΩ, serta kesalahan pengukuran tipikal sebesar ±1,5% pada suhu 25°C.

Dalam sistem Smart Electrical and Fire Hazard Early Warning System, sensor ACS712 digunakan untuk memantau besarnya arus yang digunakan oleh beban listrik rumah. Apabila arus melebihi nilai ambang batas yang telah ditentukan, STM32 akan mengidentifikasi kondisi overload sebagai potensi bahaya kebakaran akibat pemanasan berlebih pada instalasi listrik dan selanjutnya mengaktifkan mekanisme peringatan dini.


Gambar Grafik Respon Sensor ACS712

 

  • Flame Sensor

Flame Sensor merupakan sensor yang digunakan untuk mendeteksi keberadaan api melalui radiasi cahaya inframerah (Infrared/IR) yang dipancarkan oleh nyala api. Sensor ini memiliki sensitivitas tinggi terhadap spektrum cahaya inframerah pada rentang panjang gelombang 760 nm hingga 1100 nm, sehingga mampu mendeteksi sumber api seperti lilin, korek api, maupun kebakaran pada jarak tertentu. Dibandingkan sensor suhu, flame sensor dapat memberikan respons yang lebih cepat karena mendeteksi keberadaan api secara langsung melalui pancaran radiasi inframerah yang dihasilkan oleh proses pembakaran.
Modul Flame Sensor yang digunakan pada penelitian ini terdiri dari sensor inframerah, rangkaian pengondisi sinyal, potensiometer pengatur sensitivitas, serta IC komparator LM393. Ketika cahaya inframerah dari api mengenai sensor, nilai tegangan keluaran sensor akan berubah. Perubahan tegangan tersebut kemudian dibandingkan oleh LM393 dengan nilai ambang yang telah ditentukan. Jika intensitas inframerah melebihi nilai ambang, maka keluaran digital sensor akan berubah sehingga dapat dikenali oleh mikrokontroler STM32 sebagai kondisi adanya api. Sensor dapat bekerja pada tegangan 3,3 V hingga 5 V dan memiliki sudut deteksi sekitar 60°.

Pada sistem Smart Electrical and Fire Hazard Early Warning System Berbasis STM32 untuk Keselamatan Rumah Tinggal, flame sensor berfungsi sebagai pendeteksi dini kebakaran. Sensor ditempatkan pada area pemantauan dan akan terus melakukan pendeteksian terhadap radiasi inframerah yang berasal dari nyala api. Ketika api terdeteksi, sensor mengirimkan sinyal ke STM32 melalui pin input digital. Selanjutnya STM32 akan mengaktifkan buzzer sebagai alarm peringatan, memutus aliran listrik melalui relay untuk mengurangi risiko penyebaran kebakaran akibat korsleting, serta menampilkan pesan “KEBAKARAN TERDETEKSI” pada LCD 16×2. Dengan adanya flame sensor, sistem mampu memberikan peringatan lebih cepat sehingga potensi kerugian akibat kebakaran dapat diminimalkan. 

 

 

      

Gambar Grafik Respon Sensor Flame




  •  Sensor Asap dan Gas MQ-2

Sensor MQ-2 merupakan sensor gas semikonduktor yang digunakan untuk mendeteksi keberadaan asap dan berbagai gas mudah terbakar seperti LPG, propana, butana, metana, hidrogen, alkohol, serta asap hasil pembakaran. Sensor ini banyak digunakan pada sistem keselamatan dan sistem deteksi kebakaran karena memiliki sensitivitas yang baik terhadap gas-gas yang berpotensi menyebabkan kebakaran.
Prinsip kerja MQ-2 didasarkan pada perubahan resistansi material semikonduktor timah dioksida (SnO₂) ketika terpapar gas tertentu. Di dalam sensor terdapat elemen pemanas yang menjaga material sensitif pada temperatur kerja optimal. Saat konsentrasi gas mudah terbakar atau asap meningkat, resistansi sensor akan berubah sehingga menghasilkan perubahan tegangan keluaran yang dapat diukur oleh mikrokontroler.
Hubungan antara konsentrasi gas dan tegangan keluaran bersifat sebanding. Semakin tinggi konsentrasi gas atau asap yang terdeteksi, maka tegangan keluaran sensor akan semakin besar. Sebaliknya, ketika konsentrasi gas rendah, tegangan keluaran sensor juga akan rendah. Oleh karena itu, nilai tegangan keluaran dapat digunakan sebagai indikator tingkat keberadaan asap atau gas berbahaya di lingkungan.
Modul MQ-2 bekerja dengan tegangan suplai 5 VDC dan menyediakan dua jenis keluaran, yaitu keluaran analog (A0) dan keluaran digital (D0). Keluaran analog digunakan untuk membaca tingkat konsentrasi gas secara kontinu melalui ADC mikrokontroler, sedangkan keluaran digital digunakan untuk mendeteksi apakah konsentrasi gas telah melewati nilai ambang batas yang dapat diatur menggunakan potensiometer pada modul. Sensor memerlukan waktu pemanasan (warm-up) sebelum menghasilkan pembacaan yang stabil.

Dalam sistem Smart Electrical and Fire Hazard Early Warning System, sensor MQ-2 digunakan sebagai pendeteksi awal kebocoran gas dan kemunculan asap akibat proses pembakaran. Ketika konsentrasi asap atau gas meningkat hingga melewati batas yang ditentukan, STM32 akan mengaktifkan buzzer, menampilkan pesan peringatan pada LCD, dan menjalankan prosedur keselamatan yang telah diprogram.





Gambar Grafik Renspon Sensor MQ -2


2. Output (Aktuator) 
  • Buzzer

Buzzer merupakan komponen elektronika yang berfungsi mengubah energi listrik menjadi energi suara. Buzzer banyak digunakan sebagai perangkat indikator atau alarm pada sistem peringatan karena mampu menghasilkan bunyi yang mudah didengar oleh pengguna. Secara umum, buzzer terdiri dari dua jenis, yaitu buzzer aktif dan buzzer pasif. Buzzer aktif memiliki osilator internal sehingga dapat langsung menghasilkan bunyi ketika diberikan tegangan DC, sedangkan buzzer pasif memerlukan sinyal pulsa atau gelombang tertentu dari mikrokontroler untuk menghasilkan suara.

Prinsip kerja buzzer didasarkan pada efek piezoelektrik atau elektromagnetik. Pada buzzer piezoelektrik, material piezoelektrik akan mengalami deformasi mekanik ketika diberikan tegangan listrik. Getaran yang dihasilkan akan menggerakkan diafragma sehingga menghasilkan gelombang suara. Frekuensi bunyi yang dihasilkan bergantung pada frekuensi sinyal masukan yang diberikan.

Dalam sistem Smart Electrical and Fire Hazard Early Warning System, buzzer digunakan sebagai perangkat alarm utama untuk memberikan peringatan dini kepada penghuni rumah ketika terdeteksi kondisi berbahaya seperti overload listrik, kenaikan suhu berlebih, keberadaan asap, maupun indikasi kebakaran. Ketika STM32 menerima sinyal bahaya dari sensor, mikrokontroler akan mengaktifkan buzzer sehingga pengguna dapat segera mengetahui adanya potensi gangguan atau kebakaran.

  • Relay Module

Relay merupakan saklar elektromekanik yang bekerja berdasarkan prinsip elektromagnetik. Relay memungkinkan sinyal berdaya rendah dari mikrokontroler digunakan untuk mengendalikan beban listrik yang memiliki tegangan atau arus lebih besar tanpa adanya hubungan listrik langsung antara kedua rangkaian.

Sebuah relay terdiri atas kumparan (coil), inti besi, pegas, dan kontak saklar. Ketika kumparan dialiri arus listrik, medan magnet akan terbentuk dan menarik kontak bergerak menuju kontak tetap. Perubahan posisi kontak ini menyebabkan rangkaian listrik dapat terhubung atau terputus sesuai kondisi yang diinginkan. Ketika arus pada kumparan dihentikan, pegas akan mengembalikan kontak ke posisi semula.

Modul relay yang digunakan bersama mikrokontroler biasanya telah dilengkapi transistor driver, resistor pembatas arus, LED indikator, dan dioda flyback untuk melindungi rangkaian dari tegangan induksi balik yang dihasilkan oleh kumparan relay saat proses switching.

Pada sistem Smart Electrical and Fire Hazard Early Warning System, relay digunakan sebagai perangkat proteksi otomatis. Ketika STM32 mendeteksi kondisi overload listrik atau potensi kebakaran, relay akan memutus suplai daya menuju beban sehingga risiko terjadinya kerusakan instalasi maupun penyebaran kebakaran dapat diminimalkan.

  • LCD I2C 16x2

LCD (Liquid Crystal Display) 16×2 merupakan perangkat tampilan yang mampu menampilkan 16 karakter pada setiap baris dan terdiri dari dua baris tampilan. LCD ini banyak digunakan pada sistem embedded untuk menampilkan informasi sensor, status sistem, maupun pesan peringatan kepada pengguna.

Pada sistem ini LCD dihubungkan menggunakan modul I2C yang umumnya menggunakan IC ekspander I/O PCF8574. Penggunaan modul I2C memungkinkan komunikasi antara STM32 dan LCD hanya melalui dua jalur komunikasi, yaitu SDA (Serial Data) dan SCL (Serial Clock). IC PCF8574 bertugas mengubah data serial dari jalur I2C menjadi data paralel yang dibutuhkan oleh pengontrol LCD.

Prinsip kerja LCD didasarkan pada perubahan orientasi molekul kristal cair ketika diberikan medan listrik. Perubahan orientasi tersebut akan mengatur intensitas cahaya yang melewati lapisan LCD sehingga karakter dapat ditampilkan pada layar. Pengendalian karakter dilakukan oleh kontroler LCD yang kompatibel dengan standar HD44780.

Pada sistem peringatan dini yang dirancang, LCD 16×2 berfungsi sebagai media antarmuka pengguna untuk menampilkan kondisi sistem secara real-time. Informasi yang ditampilkan antara lain kondisi normal ("SISTEM AMAN"), kondisi overload listrik, deteksi asap, kenaikan suhu, maupun indikasi kebakaran sehingga pengguna dapat mengetahui jenis bahaya yang sedang terjadi.

  • STM32 BluePill

STM32F103C8T6 merupakan mikrokontroler berbasis arsitektur ARM Cortex-M3 32-bit yang diproduksi oleh STMicroelectronics. Mikrokontroler ini dikenal memiliki performa tinggi, konsumsi daya rendah, serta dilengkapi berbagai periferal yang mendukung pengembangan sistem embedded dan Internet of Things (IoT).

STM32F103C8T6 bekerja pada frekuensi maksimum 72 MHz, memiliki memori Flash sebesar 64 KB, SRAM sebesar 20 KB, serta berbagai antarmuka komunikasi seperti UART, SPI, dan I2C. Selain itu, mikrokontroler ini juga dilengkapi ADC 12-bit yang memungkinkan pembacaan data sensor analog dengan resolusi yang cukup tinggi.

Board pengembangan yang umum digunakan adalah Blue Pill, yaitu papan minimum system yang memuat mikrokontroler STM32F103C8T6 beserta rangkaian pendukung seperti regulator tegangan, kristal osilator, dan header GPIO. Board ini banyak digunakan dalam penelitian dan pengembangan sistem kontrol karena memiliki ukuran yang ringkas serta harga yang relatif ekonomis.

Pada sistem Smart Electrical and Fire Hazard Early Warning System, STM32F103C8T6 berfungsi sebagai pusat pengendali seluruh sistem. Mikrokontroler membaca data dari sensor ACS712, MQ-2, LM35, dan flame sensor, kemudian mengolah data tersebut untuk menentukan kondisi sistem. Berdasarkan hasil pengolahan data, STM32 akan mengendalikan buzzer, relay, dan LCD untuk memberikan peringatan serta melakukan tindakan proteksi secara otomatis apabila terdeteksi kondisi berbahaya.


5. Flowchart dan Listing Program [kembali]

  1. Flowchart Sistem






2. Listing Program

  • main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2026 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "lcd.h"
#include <stdio.h>
#include <string.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;

/* USER CODE BEGIN PV */
/* Threshold */
#define ACS_THRESHOLD     2048    // sesuaikan hasil kalibrasi
#define MQ2_DETECTED      GPIO_PIN_SET
#define BUZZER_PORT GPIOA
#define BUZZER_PIN  GPIO_PIN_6

#define RELAY_PORT  GPIOB
#define RELAY_PIN   GPIO_PIN_3

#define MQ2_PORT    GPIOB
#define MQ2_PIN     GPIO_PIN_1

#define FLAME_PORT  GPIOB
#define FLAME_PIN   GPIO_PIN_2
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);

uint16_t Read_ADC(void);
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{

  /* USER CODE BEGIN 1 */
uint16_t acs_value;
  /* 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();
  LCD_Init();
  LCD_Clear();

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {

  /* Membaca sensor */
         acs_value = Read_ADC();

         uint8_t smoke_detected =
                 HAL_GPIO_ReadPin(MQ2_PORT, MQ2_PIN);

         uint8_t flame_detected =
                 HAL_GPIO_ReadPin(FLAME_PORT, FLAME_PIN);

         /* =========================
            PRIORITAS 1 : API
            ========================= */
         if(flame_detected == GPIO_PIN_SET)
         {
             HAL_GPIO_WritePin(BUZZER_PORT, BUZZER_PIN, GPIO_PIN_SET);
             HAL_GPIO_WritePin(RELAY_PORT, RELAY_PIN, GPIO_PIN_RESET);

             LCD_Clear();
             LCD_SetCursor(0,0);
             LCD_Print("KEBAKARAN");
             LCD_SetCursor(1,0);
             LCD_Print("TERDETEKSI");

             HAL_Delay(500);
         }

         /* =========================
            PRIORITAS 2 : OVERLOAD
            ========================= */
         else if(acs_value > ACS_THRESHOLD)
         {
             HAL_GPIO_WritePin(BUZZER_PORT,
                               BUZZER_PIN,
                               GPIO_PIN_SET);

             HAL_GPIO_WritePin(RELAY_PORT,
                               RELAY_PIN,
                               GPIO_PIN_RESET);

             LCD_Clear();
             LCD_SetCursor(0,0);
             LCD_Print("OVERLOAD");
             LCD_SetCursor(1,0);
             LCD_Print("LISTRIK");

             HAL_Delay(500);
         }

         /* =========================
            PRIORITAS 3 : ASAP
            ========================= */
         else if(smoke_detected == GPIO_PIN_SET)
         {
             HAL_GPIO_WritePin(BUZZER_PORT,
                               BUZZER_PIN,
                               GPIO_PIN_SET);

             HAL_GPIO_WritePin(RELAY_PORT,
                               RELAY_PIN,
                               GPIO_PIN_SET);

             LCD_Clear();
             LCD_SetCursor(0,0);
             LCD_Print("ASAP");
             LCD_SetCursor(1,0);
             LCD_Print("TERDETEKSI");

             HAL_Delay(500);
         }

         /* =========================
            KONDISI NORMAL
            ========================= */
         else
         {
             HAL_GPIO_WritePin(BUZZER_PORT,
                               BUZZER_PIN,
                               GPIO_PIN_RESET);

             HAL_GPIO_WritePin(RELAY_PORT,
                               RELAY_PIN,
                               GPIO_PIN_SET);

             LCD_Clear();
             LCD_SetCursor(0,0);
             LCD_Print("SISTEM");
             LCD_SetCursor(1,0);
             LCD_Print("AMAN");

             HAL_Delay(500);

  }

  }   // tutup while

  }   // tutup main
/**
  * @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)
{
    ADC_ChannelConfTypeDef sConfig = {0};

    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();
    }

    sConfig.Channel = ADC_CHANNEL_8;     // PB0 ACS712
    sConfig.Rank = ADC_REGULAR_RANK_1;
    sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;

    if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
    {
        Error_Handler();
    }
}

/**
  * @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 */
  {
      __HAL_RCC_GPIOA_CLK_ENABLE();
      __HAL_RCC_GPIOB_CLK_ENABLE();

      /* Buzzer PA6 */
      GPIO_InitStruct.Pin = GPIO_PIN_6;
      GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
      GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
      HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

      /* Relay PB3 */
      GPIO_InitStruct.Pin   = GPIO_PIN_3;
      GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;
      GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
      HAL_GPIO_Init(GPIOB,&GPIO_InitStruct);

      /* MQ2 PB1 */
      GPIO_InitStruct.Pin  = GPIO_PIN_1;
      GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
      GPIO_InitStruct.Pull = GPIO_PULLUP;
      HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

      /* Flame PB2 */
      GPIO_InitStruct.Pin = GPIO_PIN_2;
      GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
      GPIO_InitStruct.Pull = GPIO_NOPULL;
      HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

      HAL_GPIO_WritePin(GPIOA,
                        GPIO_PIN_6,
                        GPIO_PIN_RESET);

      HAL_GPIO_WritePin(GPIOB,
                        GPIO_PIN_3,
                        GPIO_PIN_SET);
  }
  /* 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, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3
                          |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2|GPIO_PIN_3, GPIO_PIN_RESET);

  /*Configure GPIO pins : PA0 PA1 PA2 PA3
                           PA4 PA5 PA6 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3
                          |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6;
  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 pins : PB2 PB3 */
  GPIO_InitStruct.Pin = GPIO_PIN_3;
  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);
  /* USER CODE BEGIN MX_GPIO_Init_2 */

  /* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */
uint16_t Read_ADC(void)
{
    HAL_ADC_Start(&hadc1);

    HAL_ADC_PollForConversion(&hadc1,100);

    return HAL_ADC_GetValue(&hadc1);
}
/* 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 */

  • lcd.h

#ifndef LCD_H_
#define LCD_H_

#include "stm32f1xx_hal.h"

void LCD_Init(void);
void LCD_Clear(void);
void LCD_SetCursor(uint8_t row, uint8_t col);
void LCD_Print(char *str);
void LCD_PrintXY(uint8_t row,
                 uint8_t col,
                 char *str);

#endif

  • lcd.c

#include "lcd.h"

#include "main.h"

#include <string.h>


/* LCD PIN */

#define LCD_RS_PORT GPIOA

#define LCD_RS_PIN  GPIO_PIN_0


#define LCD_EN_PORT GPIOA

#define LCD_EN_PIN  GPIO_PIN_1


#define LCD_D4_PORT GPIOA

#define LCD_D4_PIN  GPIO_PIN_2


#define LCD_D5_PORT GPIOA

#define LCD_D5_PIN  GPIO_PIN_3


#define LCD_D6_PORT GPIOA

#define LCD_D6_PIN  GPIO_PIN_4


#define LCD_D7_PORT GPIOA

#define LCD_D7_PIN  GPIO_PIN_5


/* =================================== */


static void LCD_EnablePulse(void);

static void LCD_Send4Bit(uint8_t data);

static void LCD_SendCommand(uint8_t cmd);

static void LCD_SendData(uint8_t data);


/* =================================== */


static void LCD_EnablePulse(void)

{

    HAL_GPIO_WritePin(LCD_EN_PORT,

                      LCD_EN_PIN,

                      GPIO_PIN_SET);


    HAL_Delay(1);


    HAL_GPIO_WritePin(LCD_EN_PORT,

                      LCD_EN_PIN,

                      GPIO_PIN_RESET);


    HAL_Delay(1);

}


/* =================================== */


static void LCD_Send4Bit(uint8_t data)

{

    HAL_GPIO_WritePin(LCD_D4_PORT,

                      LCD_D4_PIN,

                      (data & 0x01) ? GPIO_PIN_SET : GPIO_PIN_RESET);


    HAL_GPIO_WritePin(LCD_D5_PORT,

                      LCD_D5_PIN,

                      (data & 0x02) ? GPIO_PIN_SET : GPIO_PIN_RESET);


    HAL_GPIO_WritePin(LCD_D6_PORT,

                      LCD_D6_PIN,

                      (data & 0x04) ? GPIO_PIN_SET : GPIO_PIN_RESET);


    HAL_GPIO_WritePin(LCD_D7_PORT,

                      LCD_D7_PIN,

                      (data & 0x08) ? GPIO_PIN_SET : GPIO_PIN_RESET);


    LCD_EnablePulse();

}


/* =================================== */


static void LCD_SendCommand(uint8_t cmd)

{

    HAL_GPIO_WritePin(LCD_RS_PORT,

                      LCD_RS_PIN,

                      GPIO_PIN_RESET);


    LCD_Send4Bit(cmd >> 4);

    LCD_Send4Bit(cmd & 0x0F);


    HAL_Delay(2);

}


/* =================================== */


static void LCD_SendData(uint8_t data)

{

    HAL_GPIO_WritePin(LCD_RS_PORT,

                      LCD_RS_PIN,

                      GPIO_PIN_SET);


    LCD_Send4Bit(data >> 4);

    LCD_Send4Bit(data & 0x0F);


    HAL_Delay(1);

}


/* =================================== */


void LCD_Init(void)

{

    HAL_Delay(50);


    HAL_GPIO_WritePin(LCD_RS_PORT,

                      LCD_RS_PIN,

                      GPIO_PIN_RESET);


    LCD_Send4Bit(0x03);

    HAL_Delay(5);


    LCD_Send4Bit(0x03);

    HAL_Delay(5);


    LCD_Send4Bit(0x03);

    HAL_Delay(5);


    LCD_Send4Bit(0x02);


    LCD_SendCommand(0x28);

    LCD_SendCommand(0x0C);

    LCD_SendCommand(0x06);

    LCD_SendCommand(0x01);


    HAL_Delay(5);

}


/* =================================== */


void LCD_Clear(void)

{

    LCD_SendCommand(0x01);

    HAL_Delay(2);

}


/* =================================== */


void LCD_SetCursor(uint8_t row, uint8_t col)

{

    uint8_t address;


    if(row == 0)

        address = 0x80 + col;

    else

        address = 0xC0 + col;


    LCD_SendCommand(address);

}


/* =================================== */


void LCD_Print(char *str)

{

    while(*str)

    {

        LCD_SendData(*str++);

    }

}


/* =================================== */


void LCD_PrintXY(uint8_t row,

                 uint8_t col,

                 char *str)

{

    LCD_SetCursor(row,col);

    LCD_Print(str);

}



6. Rangkaian Simulasi dan Prinsip Kerja[kembali]


Prinsip kerja sistem ini, antara lain :

Berdasarkan rancangan pada dokumen "Kelompok 22 - Smart Electrical and Fire Hazard Early Warning System Berbasis STM32 untuk Keselamatan Rumah Tinggal.pdf" dan skema Proteus, prinsip kerja sistem ini diawali saat STM32 aktif mendapat suplai tegangan dan langsung memantau data dari ketiga sensor secara terus-menerus. Pada kondisi normal, sensor arus ACS712, sensor asap MQ-2, dan flame sensor mendeteksi parameter yang aman, sehingga STM32 memerintahkan LCD menampilkan tulisan "SISTEM AMAN", buzzer tetap mati, dan pin PA15 memicu Transistor Q1 agar koil relay tetap aktif menjaga aliran listrik rumah berjalan normal.

Namun, alur kerja akan berubah drastis menjadi mode pengamanan darurat ketika sensor mendeteksi adanya bahaya. Jika ACS712 membaca arus berlebih (overload) atau flame sensor mendeteksi percikan api, STM32 akan langsung mengirim data ke LCD untuk mengubah status bahaya ("OVERLOAD LISTRIK" atau "KEBAKARAN TERDETEKSI"), menyalakan alarm buzzer melalui pin PA8, serta memutus bias pada Transistor Q1 yang otomatis membuat sakelar relay terbuka untuk memadamkan total aliran listrik utama rumah demi mencegah kebakaran. Sementara jika sensor MQ-2 mendeteksi adanya asap, sistem akan memicu alarm suara dan mengubah tampilan LCD menjadi "ASAP TERDETEKSI" sebagai peringatan dini bagi penghuni.


7. Video Simulasi [kembali]


8. Kesimpulan dan Saran [kembali]

a. Kesimpulan

Berdasarkan rancangan sistem yang telah dibuat, dapat disimpulkan beberapa hal sebagai berikut:
  • Keberhasilan Perancangan Sistem: Proyek ini telah berhasil merancang sebuah prototype Smart Electrical and Fire Hazard Early Warning System menggunakan mikrokontroler STM32 Blue Pill sebagai pusat kendali utamanya. Sistem ini mampu mengintegrasikan sensor arus ACS712, sensor asap MQ-2, dan flame sensor untuk memantau kondisi rumah dari potensi bahaya secara terus-menerus.
  • Mekanisme Respon Otomatis: Sistem terbukti dapat memberikan respons pengamanan dini yang efektif. Ketika kondisi bahaya terdeteksi (seperti overload listrik, asap, atau api), sistem akan mengaktifkan buzzer sebagai alarm, memutus aliran listrik secara otomatis via relay untuk mencegah kerusakan lebih lanjut, serta menampilkan status valid pada LCD 16x2.
  • Dampak Bagi Masyarakat: Implementasi sistem EWS ini memberikan dampak positif yang signifikan bagi keselamatan masyarakat di lingkungan tempat tinggal. Dengan adanya deteksi dini yang bersifat preventif ini, keterlambatan penanganan kebakaran akibat korsleting listrik dapat diminimalisir. Selain itu, proyek ini berkontribusi dalam meningkatkan kesadaran (awareness) dan memberikan edukasi praktis kepada masyarakat mengenai pentingnya manajemen keselamatan instalasi listrik rumah tangga.

b. Saran

Sebagai langkah pengembangan lebih lanjut agar sistem ini menjadi lebih sempurna dan memiliki daya guna yang lebih tinggi, disarankan beberapa hal berikut:
  • Peningkatan Fitur Komparatif Terhadap MCB Konvensional: Mengingat subsistem pemutus arus menggunakan sensor ACS712 dan relay memiliki prinsip kerja yang serupa dengan MCB mekanis rumah tangga , pengembangan ke depan sebaiknya memaksimalkan keunggulan digital dari STM32. Disarankan untuk menambahkan fitur pengaturan batas arus (threshold) yang dapat diubah secara dinamis melalui software (bukan nilai kaku), serta pencatatan data log (data logging) konsumsi arus harian.
  • Integrasi Teknologi IoT (Internet of Things): Peringatan bahaya saat ini masih terbatas pada buzzer dan LCD di tempat kejadian. Agar sistem perlindungan lebih optimal ketika rumah sedang kosong, disarankan untuk mengintegrasikan modul komunikasi seperti ESP8266 atau modul Wi-Fi sejenis. Dengan begitu, notifikasi bahaya (seperti "KEBAKARAN TERDETEKSI" atau "OVERLOAD") dapat dikirimkan langsung ke smartphone pemilik rumah atau dinas pemadam kebakaran setempat secara real-time.
  • Pengembangan Proteksi Fail-Safe pada Relay: Perlu dilakukan analisis lebih mendalam mengenai kapasitas pemutusan arus pada relay module yang digunakan. Untuk implementasi pada beban rumah tangga yang sebenarnya (bukan sekadar prototype), disarankan menggunakan relay berkapasitas tinggi atau kontaktor magnetik yang memiliki ketahanan arc-extinguishing (peredam percikan api) yang baik agar tidak menjadi titik lemah baru yang memicu bahaya listrik.


9. Download File [kembali]








Comments

Post a Comment

Popular posts from this blog

Mikroprosesor dan Mikrokontroler

Image
  [KEMBALI KE MENU SEBELUMNYA] DAFTAR ISI 1. Pendahuluan 2. Tujuan 3 . Dasar Teori    CHAPTER 11 BASIC I/O INTERFACE 1. Pendahuluan   [kembali]      Sebuah mikroprosesor sangat hebat dalam memecahkan masalah, tetapi jika tidak dapat berkomunikasi dengan dunia luar, maka nilainya akan sangat terbatas. Bab ini menjelaskan beberapa metode dasar komunikasi, baik secara serial maupun paralel , antara manusia atau mesin dengan mikroprosesor. Dalam bab ini, pertama-tama kita akan memperkenalkan antarmuka I/O dasar dan membahas decoding untuk perangkat I/O. Selanjutnya, kita akan membahas secara rinci tentang interfacing paralel dan serial , yang keduanya memiliki beragam aplikasi. Untuk mempelajari aplikasinya, kita akan menghubungkan konverter analog-ke-digital (ADC) dan digital-ke-analog (DAC) , serta motor DC dan stepper ke mikroprosesor.   2. Tujuan   [kembali] Menjelaskan cara kerja antarmuka masukan dan keluaran dasar.  Mendekode ...
Read more
Image
BAHAN PRESENTASI UNTUK MATA KULIAH  ELEKTRONIKA 2023     Nama :Widati Talitha Rifiana NIM : 2310953027 -  Februari 25, 2023   Tidak ada komentar: 
Read more

UTS

[KEMBALI KE MENU SEBELUMNYA] DAFTAR ISI 1. Soal No.1 2. Soal No.2 3. Soal No.3 4. Download File   1. Soal No.1   kembali Rancanglah suatu rangkaian aplikasi sederhana (revisi Tugas Besar kelompok anda – dengan sensor berbeda >=2 sensor dari teman sekelompok anda) yang terdiri dari ≥ 5 input sensor dan output (seperti motor, heater, Fan, lampu dll) dikendalikan oleh >= 1 sensor, dengan melibatkan kontrol yang memakai penguat transistor dan op-amp Jawab : Rangkaian Kontrol Lift    2. Soal No.2   kembali Rancanglah suatu rangkaian pembangkit sinyal gigi gergaji dengan Vp-p = ±2,5 Volt dengan frekuensi 15 kHz Jawab : Rangkaian Pembangkit Sinyal Gigi Gergaji  download   3. Soal No.3   kembali Rancanglah suatu rangkaian HPF +60 dB/dec Jawab : Rangkaian HPF +60 dB/dec  download   4. Download File  kembali Rangkaian Gambar 3  download
Read more