Laporan Akhir 2

DAFTAR ISI

Prosedur
Hardware dan Diagram Blok
Rangkaian Simulasi dan Prinsip Kerja
Flowchart dan Listing Program
Video Demo
Analisa
Download File

a. Prosedur

Siapkan semua alat dan bahan yang dibutuhkan seperti board STM32, flame sensor, float sensor, relay, buzzer, LED, resistor, serta kabel penghubung. Pastikan semua komponen dalam kondisi baik agar tidak terjadi kendala saat dirangkai.

Tentukan terlebih dahulu bagian input dan output pada rangkaian. Flame sensor dan float sensor digunakan sebagai input, sedangkan LED, buzzer, dan relay sebagai output yang akan dikendalikan oleh mikrokontroler.

Hubungkan flame sensor ke board STM32 dengan menyambungkan pin VCC ke sumber tegangan, GND ke ground, dan pin output ke salah satu pin input pada STM32.

Pasang float sensor dengan menghubungkan salah satu kakinya ke tegangan dan kaki lainnya ke pin input STM32. Tambahkan resistor sebagai penstabil agar pembacaan sensor lebih baik.

Lakukan pemasangan komponen output. LED dihubungkan ke pin output STM32 melalui resistor, buzzer dihubungkan langsung ke pin output dan ground, serta relay dihubungkan ke pin output untuk mengontrol pompa atau beban lainnya.

Periksa kembali setiap sambungan kabel untuk memastikan tidak ada kesalahan pemasangan atau hubungan yang terbalik.

Buat program pada STM32 sesuai dengan logika kerja yang diinginkan, yaitu mendeteksi api terlebih dahulu, kemudian mengontrol pompa berdasarkan kondisi tangki.

Upload program ke board STM32 menggunakan software yang sesuai, lalu jalankan sistem.

Lakukan pengujian pada rangkaian yang sudah dibuat

b. Hardware dan Diagram Blok

A. Hardware

a) Mikrokontroler STM32 NUCLEO-G474RE

2. Infrared Sensor

3. Buzzer

4. Power Supply

5. RGB LED

Jual LED RGB 4 PIN WARNA MERAH HIJAU BIRU 5mm ( ARDUINO ) - Common Cathode - Jakarta Barat - Ardushop-id | Tokopedia

6. Resistor 1k Ohm

7. Switch

8. Adaptor

9. Breadboard

B. Diagram Blok

c. Rangkaian Simulasi dan Prinsip Kerja

Prinsip kerja:

Rangkaian ini bekerja dengan memanfaatkan dua sensor yaitu flame sensor sebagai pendeteksi api dan float sensor sebagai pendeteksi ketinggian air, yang dikendalikan oleh mikrokontroler STM32 (board Nucleo C031C6). Kedua sensor tersebut memberikan sinyal input ke mikrokontroler untuk menentukan kondisi lingkungan dan mengambil tindakan yang sesuai.

Saat flame sensor mendeteksi adanya api, sensor akan mengirimkan sinyal (biasanya berupa logika HIGH atau LOW tergantung konfigurasi) ke mikrokontroler. Mikrokontroler kemudian memproses sinyal tersebut dan mengaktifkan indikator berupa LED sebagai tanda visual bahwa api terdeteksi. Selain itu, buzzer juga dapat diaktifkan untuk memberikan peringatan suara sebagai alarm bahaya.

Sementara itu, float sensor berfungsi untuk mendeteksi level cairan (misalnya air). Ketika ketinggian air mencapai batas tertentu, float sensor akan berubah kondisi (ON/OFF) dan mengirimkan sinyal ke mikrokontroler. Berdasarkan kondisi ini, mikrokontroler dapat mengontrol modul relay yang terhubung ke beban eksternal, seperti pompa air atau sistem lainnya. Misalnya, jika air terlalu tinggi, relay dapat mematikan pompa, atau sebaliknya menyalakan pompa saat air rendah.

Dalam kondisi tertentu, kedua sensor dapat bekerja secara bersamaan. Mikrokontroler akan memprioritaskan atau mengombinasikan logika dari kedua input tersebut. Contohnya, jika terdeteksi api, sistem bisa langsung mengaktifkan alarm tanpa memperhatikan kondisi level air. Sebaliknya, jika tidak ada api, sistem akan fokus pada pengendalian level air melalui relay.

d. Flowchart dan Listing Program

Listing program:

main.h:

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.h
  * @brief          : Header for main.c file.
  *                   This file contains the common defines of the application.
  ******************************************************************************
  * @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 */

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __MAIN_H
#define __MAIN_H

#ifdef __cplusplus
extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "stm32g4xx_hal.h"

#include "stm32g4xx_nucleo.h"
#include <stdio.h>

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Exported types ------------------------------------------------------------*/
/* USER CODE BEGIN ET */

/* USER CODE END ET */

/* Exported constants --------------------------------------------------------*/
/* USER CODE BEGIN EC */

/* USER CODE END EC */

/* Exported macro ------------------------------------------------------------*/
/* USER CODE BEGIN EM */

/* USER CODE END EM */

/* Exported functions prototypes ---------------------------------------------*/
void Error_Handler(void);

/* USER CODE BEGIN EFP */

/* USER CODE END EFP */

/* Private defines -----------------------------------------------------------*/

/* ====== INPUT ====== */
#define FLAME_PIN        GPIO_PIN_0
#define FLAME_PORT       GPIOA

#define FLOAT_PIN        GPIO_PIN_1
#define FLOAT_PORT       GPIOA

/* ====== OUTPUT ====== */
#define LED_PIN          GPIO_PIN_5
#define LED_PORT         GPIOA

#define BUZZER_PIN       GPIO_PIN_6
#define BUZZER_PORT      GPIOA

#define RELAY_PIN        GPIO_PIN_7
#define RELAY_PORT       GPIOA

/* USER CODE BEGIN Private defines */

/* USER CODE END Private defines */

#ifdef __cplusplus
}
#endif

#endif /* __MAIN_H */

main.c:
#include "main.h"
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
while (1)
{
  GPIO_PinState flame_state;
  GPIO_PinState float_state;

  flame_state = HAL_GPIO_ReadPin(FLAME_PORT, FLAME_PIN);
  float_state = HAL_GPIO_ReadPin(FLOAT_PORT, FLOAT_PIN);

  /* ===== FLAME SENSOR ===== */
  if (flame_state == GPIO_PIN_RESET)
  {
    /* Api terdeteksi */
    HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_SET);
    HAL_GPIO_WritePin(BUZZER_PORT, BUZZER_PIN, GPIO_PIN_SET);
  }
  else
  {
    HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(BUZZER_PORT, BUZZER_PIN, GPIO_PIN_RESET);
  }

  /* ===== RELAY / POMPA ===== */
  if ((flame_state == GPIO_PIN_SET) || (float_state == GPIO_PIN_SET))
  {
    /* Api ATAU tangki penuh → pompa MATI */
    HAL_GPIO_WritePin(RELAY_PORT, RELAY_PIN, GPIO_PIN_RESET);
  }
  else
  {
    /* Aman & tangki belum penuh → pompa HIDUP */
    HAL_GPIO_WritePin(RELAY_PORT, RELAY_PIN, GPIO_PIN_SET);
  }

  HAL_Delay(100);
}

}

static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  __HAL_RCC_GPIOA_CLK_ENABLE();

  /* INPUT */
  GPIO_InitStruct.Pin = FLAME_PIN | FLOAT_PIN;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* OUTPUT */
  GPIO_InitStruct.Pin = LED_PIN | BUZZER_PIN | RELAY_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);

  /* Relay default ON */
  HAL_GPIO_WritePin(RELAY_PORT, RELAY_PIN, GPIO_PIN_SET);
}

void SystemClock_Config(void)
{
  /* Clock default CubeIDE */
}

void Error_Handler(void)
{
  while (1) {}
}