LAPORAN AKHIR MODUL 2 PERCOBAAN 4 : Sistem Lampu Jalan Otomatis

 

LAPORAN AKHIR MODUL 2 PERCOBAAN 4




1. Prosedur (kembali)

  • Membuka Wokwi dan membuat project baru dengan menggunakan board STM32, kemudian menambahkan komponen berupa sensor LDR sebagai input cahaya, servo sebagai aktuator penggerak jemuran, serta push button sebagai pemilih mode sistem, dan resistor sebagai bagian dari rangkaian pembagi tegangan.
  • Menyusun rangkaian dengan menghubungkan LDR ke pin analog mikrokontroler (PA0) menggunakan konfigurasi pembagi tegangan (LDR + resistor), kemudian menghubungkan servo ke pin PWM (PA6/TIM3), serta push button ke pin input (PB1) dengan konfigurasi pull-up, dan memastikan semua koneksi VCC dan GND terhubung dengan benar.
  • Menuliskan program pada editor Wokwi untuk membaca nilai analog dari LDR menggunakan ADC, dimana nilai tersebut merepresentasikan intensitas cahaya (gelap, sedang, terang), serta membaca input push button untuk mengubah mode sistem.
  • Menambahkan logika kontrol pada program
  • Menjalankan simulasi dengan menekan tombol start pada Wokwi, kemudian melakukan pengujian dengan:
    • Mengubah nilai LDR untuk mensimulasikan kondisi terang dan gelap
    • Menekan push button untuk berpindah antar mode (otomatis dan manual)
  • Mengamati hasil output dimana:
    • Pada mode otomatis, servo akan bergerak sesuai kondisi cahaya lingkungan
    • Pada mode manual, servo tetap pada posisi yang dipilih walaupun kondisi cahaya berubah
    • Sistem dapat mensimulasikan fungsi jemuran otomatis yang dapat bekerja secara otomatis maupun dikontrol manual dengan baik

    • 2. Hardware (kembali)

     1. STM32 Nucleo G474RE

     

    Microcontroller

    STM32G474RE (ARM Cortex-M4F)

    Operating Voltage

    3.3 V

    Input Voltage (recommended)

    5 V via USB (ST-LINK) atau 7–12 V via VIN

    Input Voltage (limit)

    4.5 – 15 V (VIN board Nucleo)

    Digital I/O Pins

    ±51 GPIO pins (tergantung konfigurasi fungsi)

    PWM Digital I/O Pins

    Hingga 24 channel PWM (advanced, general-purpose, dan high- resolution timers)

    Analog Input Pins

    Hingga 24 channel ADC (12-bit / 16-bit dengan oversampling)

    DC Current per I/O Pin

    Maks. 20 mA per pin (disarankan ≤ 8 mA)

    DC Current for 3.3V Pin

    Hingga ±500 mA (tergantung regulator & sumber daya)

    Flash Memory

    512 KB internal Flash

    SRAM

    128 KB SRAM (termasuk CCM RAM)

    Clock Speed

    Hingga 170 MHz

    2. LDR Sensor

    LDR atau Light Dependent Resistor adalah jenis resistor yang nilai hambatannya berubah-ubah sesuai dengan intensitas cahaya yang mengenai permukaannya, di mana prinsip kerjanya didasarkan pada fotokonduktivitas yang menyebabkan resistansi menurun saat terkena cahaya terang dan meningkat saat kondisi gelap. Dalam implementasinya pada mikrokontroler, LDR biasanya disusun menggunakan rangkaian pembagi tegangan agar perubahan intensitas cahaya dapat terbaca sebagai sinyal tegangan analog melalui fitur ADC. Sinyal digital hasil konversi tersebut kemudian digunakan oleh sistem untuk mengambil keputusan otomatis, seperti mengatur tingkat kecerahan lampu melalui PWM atau mendeteksi kondisi siang dan malam pada sistem penerangan pintar.

                                                                  

    3. Push Button 

    Push button adalah komponen sakelar sederhana yang berfungsi untuk menghubungkan atau memutuskan aliran arus listrik dalam suatu rangkaian dengan cara menekan tombolnya. Pada penggunaan mikrokontroler, komponen ini berperan sebagai perangkat input digital yang bekerja berdasarkan prinsip logika high atau low, di mana status penekanannya dapat dibaca oleh pin GPIO atau digunakan untuk memicu mekanisme interrupt eksternal. Agar pembacaan sinyal tetap stabil dan terhindar dari kondisi floating, push button biasanya dikonfigurasi menggunakan resistor pull-up atau pull-down yang memastikan level tegangan input tetap berada pada kondisi logika yang jelas saat tombol tidak sedang ditekan.

                                                            

    4. Motor Servo

    Motor servo adalah perangkat aktuator yang dirancang dengan sistem umpan balik tertutup (closed loop) untuk mengendalikan posisi sudut, kecepatan, dan akselerasi poros secara presisi. Komponen ini bekerja berdasarkan sinyal kontrol PWM (Pulse Width Modulation), di mana lebar pulsa yang diberikan ke pin kontrol akan menentukan posisi derajat putaran porosnya, seperti pulsa 1 ms untuk posisi 0 derajat dan 2 ms untuk 180 derajat. Di dalam motor servo terdapat potensiometer internal yang berfungsi mendeteksi posisi poros saat ini dan mengirimkan informasi tersebut ke rangkaian kontrol untuk memastikan poros berhenti tepat pada sudut yang diinginkan, sehingga sangat ideal digunakan pada sistem robotika, kendali kemudi, maupun penggerak mekanik yang membutuhkan akurasi tinggi.

    5. Breadboard

    Breadboard adalah papan sirkuit tanpa solder yang digunakan sebagai media untuk merakit dan menguji purwarupa rangkaian elektronik secara sementara. Papan ini memiliki lubang- lubang koneksi yang terhubung secara internal (horizontal di bagian tengah dan vertikal di jalur daya samping) sehingga memudahkan pengguna untuk menghubungkan sensor, mikrokontroler, dan komponen lainnya dengan kabel jumper. Penggunaan breadboard sangat efisien dalam tahap pengembangan karena memungkinkan komponen untuk dilepas dan dipasang kembali dengan mudah tanpa merusak jalur sirkuit.                                          

    6. Adaptor

    Adaptor berfungsi sebagai perangkat catu daya yang mengubah tegangan listrik AC dari sumber utama menjadi tegangan DC yang stabil sesuai dengan kebutuhan level tegangan operasional sistem mikrokontroler.

    7. Diagram Blok

    3. Rangkaian Simulasi dan Prinsip Kerja (kembali)

     
    Prinsip Kerja
    Rangkaian ini bekerja dengan memanfaatkan sensor detak jantung yang menghasilkan sinyal analog berdasarkan perubahan aliran darah. Sinyal tersebut dibaca oleh mikrokontroler melalui modul ADC, kemudian dilakukan proses penyaringan menggunakan metode moving average untuk mengurangi noise sehingga sinyal menjadi lebih stabil. Selanjutnya, sistem menentukan nilai ambang (threshold) secara dinamis berdasarkan nilai baseline sinyal. Ketika terjadi kenaikan sinyal yang melewati threshold, sistem mengidentifikasinya sebagai satu detak jantung dan menghitung selang waktu antar detak untuk mendapatkan nilai BPM (Beats Per Minute). Nilai BPM ini kemudian digunakan untuk mengendalikan output berupa LED RGB dan buzzer. Jika BPM berada pada rentang rendah (30–60 BPM), LED kuning menyala sebagai indikator kondisi lambat. Jika BPM berada pada rentang normal (60–80 BPM), LED hijau menyala dan buzzer dalam kondisi mati. Sedangkan jika BPM berada di luar rentang normal (kurang dari 30 atau lebih dari 80 BPM), LED merah menyala dan buzzer aktif sebagai tanda peringatan. Selain itu, terdapat push button yang berfungsi sebagai interrupt untuk mengaktifkan atau menonaktifkan buzzer sesuai kebutuhan pengguna. Dengan demikian, sistem mampu mendeteksi detak jantung dan memberikan indikasi kondisi secara visual dan audio secara real-time.

    4. Flowchart dan Listing Program (kembali)

    Flowchart: 

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

    Main.h:
    #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 

    5. Video Demo (kembali)


    6. Kondisi (kembali)

    Pada percobaan 4, praktikum membahas sistem parkir otomatis 2 pintu menggunakan dua STM32 NUCLEO G474RE yang saling berkomunikasi melalui UART. Sistem memanfaatkan sensor IR untuk mendeteksi kendaraan masuk dan keluar, sedangkan motor servo digunakan sebagai palang parkir yang dikontrol menggunakan sinyal PWM dari timer STM32. Ketika kendaraan terdeteksi, servo akan membuka palang dan data dikirim antar mikrokontroler untuk memperbarui jumlah slot parkir secara otomatis.

    7. Video Simulasi (kembali)

    8. Download File (kembali)

    Soal Analisa Laporan Akhir Modul 1 [Disini] 
    Video Percobaan 4  [Disini]
    Datsheet ST-LINK [Download]
    Datsheet STM32F103C8 (Bluepill) [Download]
    Datsheet STM32 NUCLEO-G474RE [Download]
    Datsheet Buzzer [Download]
    Datsheet LED [Download]
    Datsheet Resistor 220 Ω [Download]
    Datsheet Breadboard [Download]
     
     
     
     
     



     
     
     
     
     
     
     
     
     
     
     
     

    Komentar

    Posting Komentar

    Postingan populer dari blog ini

    Modul 1 : Gerbang Logika

    Gambar
    [KEMBALI KE MENU SEBELUMNYA] DAFTAR ISI 1. Pendahuluan 2. Tujuan 3. Alat dan Bahan 4. Dasar Teori 5. Percobaan Percobaan ... Tugas Pendahuluan Percobaan 1 Tugas Pendahuluan Percobaan 3 Laporan Akhir 1 Laporan Akhir 2 Laporan Akhir 3 MODUL 1 Gerbang logika 1. Pendahuluan [Kembali] Gerbang logika merupakan dasar utama dalam sistem elektronika digital yang berfungsi untuk melakukan operasi logika terhadap satu atau lebih sinyal input guna menghasilkan sebuah output. Pada dasarnya, gerbang logika bekerja berdasarkan prinsip aljabar Boolean yang hanya mengenal dua keadaan, yaitu logika 0 (rendah) dan logika 1 (tinggi). Setiap gerbang memiliki fungsi tertentu sesuai dengan jenisnya, seperti AND, OR, NOT, NAND, NOR, XOR, dan XNOR. Masing-masing gerbang ini digunakan untuk mengolah sinyal digital sehingga membentuk suatu rangkaian yang lebih kompleks. Peran gerbang logika sangat penting dalam kehidupan sehari-hari, karena hampir seluruh perangkat ele...
    Baca selengkapnya

    Modul 3 : Counter dan Shift Register

    Gambar
    [KEMBALI KE MENU SEBELUMNYA] DAFTAR ISI 1. Pendahuluan 2. Tujuan 3. Alat dan Bahan 4. Dasar Teori 5. Percobaan Percobaan ... Tugas Pendahuluan Percobaan 1 Tugas Pendahuluan Percobaan 2 Laporan Akhir Percobaan 1 Laporan Akhir Percobaan 3 MODUL 1 Gerbang logika 1. Pendahuluan [Kembali] Dalam bidang elektronika digital, counter dan shift register merupakan dua jenis rangkaian sekuensial yang banyak digunakan dalam sistem digital. Counter adalah rangkaian logika sekuensial yang berfungsi untuk menghitung pulsa masukan dalam bentuk biner, baik secara naik ( up counter ) maupun turun ( down counter ). Counter sering diaplikasikan pada pengukuran frekuensi, pembagi frekuensi, pewaktu ( timer ), serta pengendali dalam sistem digital. Sementara itu, shift register adalah rangkaian yang berfungsi untuk menyimpan dan memindahkan data biner secara berurutan sesuai dengan pulsa clock. Data dapat digeser ke kanan atau ke kiri, tergantung jenis register ya...
    Baca selengkapnya

    Modul 2 : Flip Flop

    Gambar
    [KEMBALI KE MENU SEBELUMNYA] DAFTAR ISI 1. Pendahuluan 2. Tujuan 3. Alat dan Bahan 4. Dasar Teori 5. Percobaan Percobaan ... Tugas Pendahuluan Percobaan 1 Tugas Pendahuluan Percobaan 2 Laporan Akhir 1 Laporan Akhir 2 MODUL 1 Gerbang logika 1. Pendahuluan [Kembali] Dalam sistem digital, flip-flop merupakan salah satu rangkaian logika sequential yang berfungsi sebagai elemen penyimpan data biner. Berbeda dengan gerbang logika kombinasi yang keluarannya hanya bergantung pada keadaan input saat itu, flip-flop memiliki kemampuan menyimpan keadaan (state) sehingga keluarannya tidak hanya ditentukan oleh input, tetapi juga oleh kondisi sebelumnya. Hal ini menjadikan flip-flop sebagai komponen dasar dalam perancangan sistem memori, register, counter, maupun rangkaian sinkronisasi. Flip-flop pada dasarnya adalah pengembangan dari latch yang ditambahkan sinyal pemicu (clock) sehingga perubahan output terjadi secara terkendali pada saat tertentu. Jenis fl...
    Baca selengkapnya