Laporan Akhir 2

[KEMBALI KE MENU SEBELUMNYA]

DAFTAR ISI

1. Prosedur

2. Hardware dan Diagram Blok

3. Rangkaian Simulasi dan Prinsip Kerja

4. Flowchart dan Listing Program

MODUL 2 PERCOBAAN 4

1. Prosedur [Kembali]

Buka web WOKWI.COM dan cari STM 32 NUCLEO C031C6
Rangkai komponen sesuai dengan gambar rangkaian di modul
Klik pada Library Manager untuk membuat file baru yang bernama main.h dan main.c
Masukan program yang telah di buat sesuai kondisi pada kedua file tersebut
Simulasikan

2. Hardware dan Diagram Blok [Kembali]

Hardware

1. STM32 NUCLEO-G474RE

2. PIR Sensor

3. LDR Sensor

4. Driver Motor L298

5. Resistor 1k ohm

6. LED

7. Push Button

Diagram Blog

3. Rangkaian Simulasi dan Prinsip Kerja [Kembali]

Rangkaian pada percobaan ini bekerja sebagai sistem lampu jalan otomatis yang memanfaatkan sensor cahaya (LDR), sensor gerak PIR, dan push button sebagai kontrol manual. Sistem dirancang agar lampu hanya menyala pada kondisi tertentu sehingga penggunaan energi menjadi lebih efisien. Mikrokontroler STM32 NUCLEO-C031C6 berfungsi sebagai pusat pengendali yang memproses seluruh data dari sensor dan menentukan kondisi output LED.

Prinsip kerja sistem dimulai dari pembacaan push button sebagai kontrol utama. Ketika tombol ditekan, sistem dapat mengubah kondisi lampu secara manual sesuai program yang digunakan, misalnya untuk mematikan atau menonaktifkan sistem sementara. Setelah itu, mikrokontroler membaca nilai sensor LDR melalui pin ADC. Sensor LDR digunakan untuk mendeteksi intensitas cahaya lingkungan. Saat kondisi lingkungan masih terang, nilai pembacaan LDR menunjukkan bahwa cahaya masih mencukupi sehingga LED akan tetap dalam keadaan mati walaupun sensor PIR mendeteksi adanya gerakan.

Ketika lingkungan mulai gelap, sistem akan mengaktifkan pemantauan sensor PIR. Sensor PIR berfungsi mendeteksi adanya gerakan manusia atau objek di sekitar area lampu. Jika pada kondisi gelap PIR mendeteksi gerakan, maka mikrokontroler akan memberikan sinyal output untuk menyalakan LED sebagai simulasi lampu jalan otomatis. Sebaliknya, apabila tidak ada gerakan yang terdeteksi, lampu akan tetap mati untuk menghemat energi listrik.

Sistem juga menerapkan delay atau waktu tunda setelah gerakan terakhir terdeteksi. LED akan tetap menyala selama beberapa detik sebelum akhirnya dimatikan kembali secara otomatis apabila tidak ada pergerakan lanjutan. Dengan prinsip kerja tersebut, sistem mampu mengontrol lampu jalan secara otomatis berdasarkan kondisi cahaya dan keberadaan objek di sekitar lingkungan.

4. Flowchart dan Listing Program [Kembali]

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




#ifndef __MAIN_H 
#define __MAIN_H 
 
#include "stm32c0xx_hal.h" 
 
// ================= PIN DEFINITIONS ================= 
 
// LDR (ADC) 
#define LDR_PORT GPIOA 
#define LDR_PIN  GPIO_PIN_0   // PA0 
 
// PIR SENSOR 
#define PIR_PORT GPIOA 
#define PIR_PIN  GPIO_PIN_1   // PA1 
 
// PUSH BUTTON (INTERRUPT) 
#define BUTTON_PORT GPIOB 
#define BUTTON_PIN  GPIO_PIN_1  // PB1 
 
// LED PWM 
#define LED_PORT GPIOA 
#define LED_PIN  GPIO_PIN_6   // PA6 (TIM3_CH1) 
 
// ================= FUNCTION PROTOTYPES ================= 
 
void SystemClock_Config(void); 
void MX_GPIO_Init(void); 
void MX_ADC1_Init(void); 
void MX_TIM3_Init(void); 
 
#endif