Laporan Akhir II

DAFTAR ISI

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

a. Prosedur

- Siapkan seluruh komponen yang diperlukan, yaitu board STM32 Nucleo G474RE, LED, sensor LDR, sensor PIR, push button, breadboard, kabel jumper, resistor.

- Sambungkan pin keluaran dari sensor LDR ke pin PA0 pada STM32 yang dikonfigurasi sebagai input ADC, sehingga mikrokontroler dapat membaca perubahan intensitas cahaya di lingkungan sekitar.

- Hubungkan pin output sensor PIR ke pin PA1 yang difungsikan sebagai input digital untuk mendeteksi adanya pergerakan objek di area pemantauan.

- Pasang push button pada pin PB1 yang dikonfigurasi sebagai external interrupt untuk mengaktifkan mode darurat, serta tambahkan resistor pull-up agar sinyal tombol tetap stabil saat dibaca oleh sistem.

- Sambungkan LED ke pin PA6 yang terhubung dengan fitur PWM pada TIM3 Channel 1, sehingga tingkat kecerahan lampu dapat diatur secara bertahap sesuai kondisi yang terdeteksi.

- Lakukan pengaturan pada sistem mikrokontroler, meliputi konfigurasi ADC untuk pembacaan sensor LDR, konfigurasi PWM untuk mengontrol intensitas LED, konfigurasi input digital untuk sensor PIR, serta konfigurasi interrupt pada push button.

- Setelah konfigurasi selesai, unggah program ke board STM32 Nucleo G474RE menggunakan STM32CubeIDE, kemudian jalankan sistem sesuai program yang telah dibuat.

- Lakukan pengujian sistem dengan menutupi sensor LDR untuk mensimulasikan kondisi malam, memberikan cahaya pada sensor untuk mensimulasikan kondisi siang, menggerakkan tangan di depan sensor PIR untuk mensimulasikan keberadaan kendaraan atau pejalan kaki, serta menekan push button untuk memastikan mode darurat dapat bekerja dengan baik.

b. Hardware dan Diagram Blok

A. Hardware

1. STM32F103C8

2. Heartbeat Sensor

3. Breadboard

4. LED

5. Buzzer

6. Resistor

7. Push Button

B. Diagram Blok

A. Hardware

1. STM32 NUCLEO-G474RE

2. LDR Sensor

3. PIR Sensor

4. LED

5. Adaptor

6. Resistor

7. Push Button

B. Diagram Blok

c. Rangkaian Simulasi dan Prinsip Kerja

Rangkaian ini bekerja menggunakan mikrokontroler STMicroelectronics STM32 Nucleo sebagai pusat pengendali utama. Sistem memanfaatkan sensor LDR untuk mendeteksi kondisi terang atau gelap, sensor PIR untuk mendeteksi gerakan, LED sebagai simulasi lampu jalan, dan push button sebagai kontrol tambahan.

Saat rangkaian dinyalakan, STM32 akan membaca data dari sensor LDR untuk mengetahui kondisi cahaya di lingkungan sekitar. Jika kondisi masih terang atau siang hari, LED akan tetap mati karena cahaya matahari masih cukup untuk penerangan. Namun, ketika lingkungan mulai gelap atau malam hari, sensor LDR akan mengirimkan sinyal ke STM32 sehingga LED menyala redup menggunakan sinyal PWM sebagai mode hemat energi.

Selanjutnya, sensor PIR akan memantau adanya gerakan di sekitar area, seperti manusia atau kendaraan. Jika sensor PIR mendeteksi gerakan, STM32 akan meningkatkan intensitas cahaya LED sehingga lampu menjadi lebih terang agar area sekitar mendapatkan penerangan yang lebih baik. Setelah beberapa saat tidak ada gerakan yang terdeteksi, intensitas LED akan kembali redup seperti kondisi awal saat malam hari.

Dengan sistem ini, lampu jalan dapat bekerja secara otomatis sesuai kondisi lingkungan dan aktivitas di sekitar, sehingga penggunaan energi menjadi lebih efisien dan penerangan tetap optimal.

d. Flowchart dan Listing Program

Listing Program:

#include "main.h"
// HANDLE
ADC_HandleTypeDef hadc1;
TIM_HandleTypeDef htim3;
// VARIABLE
volatile uint8_t emergency_mode = 0;
uint32_t last_motion_time = 0;
// fallback tombol
uint8_t last_button_state = 1;
// PARAMETER
#define LDR_THRESHOLD 2000
#define MOTION_TIMEOUT 5000
#define LED_OFF 0
#define LED_DIM 100
#define LED_FULL 1000
// ================= CLOCK =================
void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
 RCC_OscInitStruct.HSIState = RCC_HSI_ON;
 HAL_RCC_OscConfig(&RCC_OscInitStruct);
 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK |
RCC_CLOCKTYPE_SYSCLK;
 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
 RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
 HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
}
// ================= GPIO =================
void MX_GPIO_Init(void)
{
 __HAL_RCC_GPIOA_CLK_ENABLE();
 __HAL_RCC_GPIOB_CLK_ENABLE();
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 // PIR → PA1
 GPIO_InitStruct.Pin = GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  // BUTTON → PB1 (PULL-UP + INTERRUPT)
  GPIO_InitStruct.Pin = GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  // LED PWM → PA6
  GPIO_InitStruct.Pin = GPIO_PIN_6;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF1_TIM3;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  // IRQ untuk PB1 (EXTI0_1)
  HAL_NVIC_SetPriority(EXTI0_1_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI0_1_IRQn);
 }
 // ================= ADC =================
 void MX_ADC1_Init(void)
 {
  __HAL_RCC_ADC_CLK_ENABLE();
  hadc1.Instance = ADC1;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  HAL_ADC_Init(&hadc1);
  ADC_ChannelConfTypeDef sConfig = {0};
  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  HAL_ADC_ConfigChannel(&hadc1, &sConfig);
 }
 // ================= PWM =================
 void MX_TIM3_Init(void)
 {
  __HAL_RCC_TIM3_CLK_ENABLE();
  htim3.Instance = TIM3;
   htim3.Init.Prescaler = 64;
   htim3.Init.Period = 1000;
   htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
   HAL_TIM_PWM_Init(&htim3);
   TIM_OC_InitTypeDef sConfigOC = {0};
   sConfigOC.OCMode = TIM_OCMODE_PWM1;
   sConfigOC.Pulse = 0;
   HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);
  }
  // ================= INTERRUPT =================
  void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  {
   if (GPIO_Pin == GPIO_PIN_1)
   {
   emergency_mode = !emergency_mode;
   }
  }
  // ================= HELPER =================
  uint16_t read_LDR(void)
  {
   HAL_ADC_Start(&hadc1);
   HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
   return HAL_ADC_GetValue(&hadc1);
  }
  void set_LED(uint16_t value)
  {
   __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, value);
  }
  // ================= MAIN =================
  int main(void)
  {
   HAL_Init();
   SystemClock_Config();
   MX_GPIO_Init();
   MX_ADC1_Init();
   MX_TIM3_Init();
   HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
   while (1)
    {
    // ===== FALLBACK BUTTON =====
    uint8_t current_button = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
    if (last_button_state == 1 && current_button == 0)
    {
    emergency_mode = !emergency_mode;
    HAL_Delay(50);
    }
    last_button_state = current_button;
    // ===== MODE DARURAT =====
    if (emergency_mode)
    {
    set_LED(LED_OFF);
    continue;
    }
    uint16_t ldr = read_LDR();
    uint8_t pir = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1);
    // SIANG
    if (ldr < LDR_THRESHOLD)
    {
    set_LED(LED_OFF);
    }
    else
    {
    // MALAM
    if (pir == GPIO_PIN_SET)
    {
    last_motion_time = HAL_GetTick();
    }
    if (HAL_GetTick() - last_motion_time < MOTION_TIMEOUT)
    {
    set_LED(LED_FULL);
    }
    else
    {
    set_LED(LED_DIM);
    }
    }
    HAL_Delay(100);
    }
  }

Listing Program:

#include "stm32f1xx_hal.h"

/* ================= HANDLE ================= */
ADC_HandleTypeDef hadc1;

/* ================= VARIABLE ================= */
uint32_t adcValue = 0;
uint32_t filteredValue = 0;

uint8_t beatDetected = 0;
uint32_t BPM = 0;

uint32_t lastBeatTime = 0;
uint32_t interval = 0;

uint8_t buzzerOff = 0;

/* ================= FILTER ================= */
#define FILTER_SIZE 10
uint16_t buffer[FILTER_SIZE];
uint8_t indexBuf = 0;

uint16_t moving_average(uint16_t val)
{
    buffer[indexBuf++] = val;
    if(indexBuf >= FILTER_SIZE) indexBuf = 0;

    uint32_t sum = 0;
    for(int i=0;i<FILTER_SIZE;i++) sum += buffer[i];

    return sum / FILTER_SIZE;
}

/* ================= LED ================= */
void LED_Hijau() {
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);

}

void LED_Kuning() {
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);
}

void LED_Merah() {
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);
}

void LED_Mati() {
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_10, GPIO_PIN_RESET);
}

/* ================= BUZZER ================= */
void Buzzer_On()  { HAL_GPIO_WritePin(GPIOB, GPIO_PIN_11, GPIO_PIN_SET); }
void Buzzer_Off() { HAL_GPIO_WritePin(GPIOB, GPIO_PIN_11, GPIO_PIN_RESET); }

/* ================= INTERRUPT ================= */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if(GPIO_Pin == GPIO_PIN_1) // PA1
    {
        buzzerOff = !buzzerOff;
    }
}

/* ================= PROTOTYPE ================= */
void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_ADC1_Init(void);

/* ================= MAIN ================= */
int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_ADC1_Init();

  uint32_t baseline = 0;

  while (1)
  {
    /* ==== BACA ADC ==== */
    HAL_ADC_Start(&hadc1);
    HAL_ADC_PollForConversion(&hadc1, 10);
    adcValue = HAL_ADC_GetValue(&hadc1);

    /* ==== FILTER ==== */
    filteredValue = moving_average(adcValue);

    /* ==== BASELINE (ADAPTIF) ==== */
    baseline = (baseline * 9 + filteredValue) / 10;
    uint32_t threshold = baseline + 50;

    /* ==== DETEKSI DETAK + INTERVAL ==== */
    if(filteredValue > threshold && beatDetected == 0)
    {
        beatDetected = 1;

        uint32_t now = HAL_GetTick();

        if(lastBeatTime != 0)
        {
            interval = now - lastBeatTime;

                BPM = 60000 / interval;

        }

        lastBeatTime = now;
    }

    if(filteredValue < threshold)
    {
        beatDetected = 0;
    }

    /* ==== TIMEOUT (TIDAK ADA DETAK) ==== */
    if(HAL_GetTick() - lastBeatTime > 2000)
    {
        BPM = 0;
    }

    /* ==== OUTPUT ==== */
    if(BPM > 0)
    {
        if(BPM >30 && BPM < 60)
        {
            LED_Kuning();
            Buzzer_Off();
            buzzerOff = 0;
        }
        else if(BPM <= 80)
        {
            LED_Hijau();
            Buzzer_Off();
            buzzerOff = 0;
        }
        else
        {
            LED_Merah();
            if(!buzzerOff)
                Buzzer_On();
            else
                Buzzer_Off();
        }
    }
    else
    {
        LED_Mati();
        Buzzer_Off();
    }

    HAL_Delay(5);
  }
}

/* ================= CLOCK ================= */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  HAL_RCC_OscConfig(&RCC_OscInitStruct);

  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;

  HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
}

/* ================= ADC ================= */
void MX_ADC1_Init(void)
{
  ADC_ChannelConfTypeDef sConfig = {0};

  __HAL_RCC_ADC1_CLK_ENABLE();

  hadc1.Instance = ADC1;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 1;

  HAL_ADC_Init(&hadc1);

  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;

  HAL_ADC_ConfigChannel(&hadc1, &sConfig);
}

/* ================= GPIO ================= */
void MX_GPIO_Init(void)
{
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* PA0 = ADC */
  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* PA1 = BUTTON */
  GPIO_InitStruct.Pin = GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  HAL_NVIC_SetPriority(EXTI1_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI1_IRQn);

  /* LED + BUZZER */
  GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_10 | GPIO_PIN_11;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_10 | GPIO_PIN_11, GPIO_PIN_RESET);