Laporan Akhir M3


1. Prosedur [Kembali]

  1. Siapkan alat dan bahan yang terdiri dari dua buah STM32 NUCLEO G474RE, dua sensor IR, dua motor servo, OLED SSD1306, breadboard, dan kabel jumper.

  2. Menentukan fungsi masing-masing mikrokontroler:

    • STM32 Nucleo 1 sebagai master yang mengatur sistem parkir utama, jumlah slot parkir, OLED display, servo pintu masuk, dan komunikasi UART.

    • STM32 Nucleo 2 sebagai slave yang bertugas mendeteksi kendaraan keluar dan mengirimkan data ke master melalui UART.

  3. Menghubungkan sensor IR pintu masuk ke pin GPIO pada STM32 master. Berdasarkan listing program, sensor dibaca menggunakan fungsi HAL_GPIO_ReadPin() sehingga pin dikonfigurasi sebagai GPIO Input untuk mendeteksi keberadaan kendaraan.

  4. Menghubungkan motor servo pintu masuk ke pin timer PWM pada STM32 master. Pada program digunakan TIM2 PWM Channel 1 dengan perubahan nilai CCR1 untuk mengatur sudut servo:

    • CCR1 = 2000 → palang terbuka

    • CCR1 = 1000 → palang tertutup

  5. Menghubungkan OLED SSD1306 ke jalur I2C pada STM32 master menggunakan pin:

    • PB6 → SCL

    • PB7 → SDA
      Konfigurasi ini digunakan untuk menampilkan informasi jumlah slot parkir secara real-time melalui fungsi ssd1306_WriteString().

  6. Menghubungkan komunikasi UART antar kedua STM32:

    • TX master → RX slave

    • TX slave → RX master

    • GND kedua board disatukan

    Berdasarkan program, komunikasi menggunakan USART1 dengan baudrate 9600 bps dan mode asynchronous.

  7. Mengonfigurasi STM32 master pada STM32CubeIDE dengan mengaktifkan:

    • GPIO Input untuk sensor IR

    • USART1 sebagai komunikasi UART

    • TIM2 PWM untuk servo

    • I2C1 untuk OLED SSD1306

  8. Mengonfigurasi STM32 slave pada STM32CubeIDE dengan mengaktifkan:

    • GPIO Input untuk sensor IR pintu keluar

    • USART1 untuk komunikasi UART

    • Timer PWM untuk servo pintu keluar

  9. Meng-generate code dari STM32CubeMX kemudian menambahkan listing program sesuai modul praktikum.

  10. Melakukan analisis program pada STM32 master:

  • Variabel sisa_parkir digunakan untuk menyimpan jumlah slot parkir tersedia.

  • Sensor IR dipantau secara terus-menerus menggunakan looping while(1).

  • Ketika sensor mendeteksi kendaraan dan slot masih tersedia, fungsi Servo_Buka() dijalankan untuk membuka palang.

  • Sistem kemudian mengurangi jumlah slot parkir dan mengirim data karakter 'M' melalui UART sebagai indikator kendaraan masuk.

  • Setelah kendaraan melewati sensor, fungsi Servo_Tutup() dijalankan untuk menutup palang kembali.

  1. Melakukan analisis program pada STM32 slave:

  • Slave menerima data UART menggunakan HAL_UART_Receive().

  • Ketika kendaraan keluar terdeteksi sensor IR, slave mengirim karakter 'K' ke master menggunakan HAL_UART_Transmit().

  • Data tersebut menandakan bahwa satu slot parkir kembali tersedia.

  1. Menganalisis komunikasi UART antar mikrokontroler:

  • Master menggunakan interrupt UART HAL_UART_Receive_IT() untuk menerima data tanpa menghentikan proses utama sistem.

  • Ketika karakter 'K' diterima dari slave, master akan menambah jumlah slot parkir dan memperbarui tampilan OLED.

  1. Meng-compile seluruh program untuk memastikan tidak terdapat error pada konfigurasi maupun listing program.

  2. Meng-upload program ke masing-masing STM32 NUCLEO G474RE menggunakan ST-Link.

  3. Menyalakan sistem dan melakukan pengujian pintu masuk dengan mendekatkan objek pada sensor IR master.

  4. Mengamati servo pintu masuk yang terbuka otomatis ketika kendaraan terdeteksi dan slot parkir masih tersedia.

  5. Mengamati tampilan OLED yang menunjukkan perubahan jumlah slot parkir secara real-time sesuai kondisi kendaraan masuk dan keluar.

  6. Melakukan pengujian pintu keluar dengan mendekatkan objek pada sensor IR slave sehingga data kendaraan keluar dikirim ke master melalui UART.

  7. Mengamati bahwa jumlah slot parkir pada master bertambah kembali setelah data diterima dari slave.

  8. Menguji kondisi parkir penuh dengan mengisi seluruh slot parkir hingga nilai sisa_parkir = 0, kemudian mengamati bahwa palang tidak terbuka dan sistem menampilkan kondisi parkir penuh pada OLED.


2. Hardware dan Diagram Blok [Kembali]





A. Hardware

Rangkaian ini terdiri dari beberapa komponen esensial yang saling terintegrasi:

  1. STM32 NUCLEO G474RE (2 buah)
    Mikrokontroler ini berfungsi sebagai pusat pengendali sistem parkir otomatis. Pada percobaan digunakan dua board STM32 NUCLEO G474RE, yaitu:

    • Master → mengatur jumlah slot parkir, membaca sensor IR pintu masuk, mengendalikan servo palang masuk, menampilkan data pada OLED, dan menerima data dari slave melalui UART.

    • Slave → mendeteksi kendaraan keluar menggunakan sensor IR dan mengirimkan data ke master melalui komunikasi UART.

    Mikrokontroler ini dipilih karena memiliki fitur GPIO, UART, I2C, dan Timer PWM yang mendukung sistem komunikasi dan kontrol otomatis.

  2. Sensor IR (Infrared Sensor) – 2 buah
    Sensor IR digunakan untuk mendeteksi keberadaan kendaraan pada pintu masuk dan pintu keluar parkir. Sensor bekerja dengan memanfaatkan pantulan cahaya inframerah dari objek yang berada di depannya.

    • Sensor IR pada master mendeteksi kendaraan masuk.

    • Sensor IR pada slave mendeteksi kendaraan keluar.

    Output sensor akan dibaca oleh GPIO mikrokontroler sebagai logika HIGH atau LOW.

  3. Motor Servo – 2 buah
    Motor servo digunakan sebagai aktuator palang parkir otomatis. Servo dikendalikan menggunakan sinyal PWM dari timer STM32.

    • Servo akan bergerak membuka palang ketika kendaraan terdeteksi.

    • Servo akan menutup kembali setelah kendaraan melewati sensor.

    Sudut servo diatur melalui perubahan duty cycle PWM pada timer mikrokontroler.

  4. OLED SSD1306
    OLED SSD1306 digunakan sebagai media tampilan informasi sistem parkir. Display ini menampilkan:

    • Jumlah slot parkir tersedia

    • Status parkir penuh atau tersedia

    • Informasi kondisi sistem secara real-time

    OLED berkomunikasi dengan STM32 menggunakan protokol I2C sehingga hanya memerlukan jalur SDA dan SCL.

  5. Breadboard
    Breadboard digunakan sebagai media perakitan rangkaian sementara tanpa perlu proses penyolderan. Komponen seperti sensor IR, servo, dan koneksi UART dipasang pada breadboard agar lebih mudah dalam pengujian dan modifikasi rangkaian.

  6. Kabel Jumper
    Kabel jumper digunakan untuk menghubungkan antar komponen pada breadboard dengan pin-pin GPIO mikrokontroler STM32. Kabel ini digunakan pada:

    • Jalur sensor IR

    • Jalur UART TX/RX

    • Jalur I2C OLED

    • Jalur PWM servo

    • Jalur VCC dan GND

  7. ST-Link (Built-in pada NUCLEO Board)
    ST-Link digunakan untuk proses upload program dan debugging pada STM32 NUCLEO G474RE. Fitur ini memungkinkan program hasil konfigurasi STM32CubeIDE dapat langsung ditanamkan ke mikrokontroler melalui koneksi USB.

  8. Kabel USB
    Kabel USB digunakan untuk:

    • Memberikan catu daya pada board STM32

    • Menghubungkan STM32 dengan komputer

    • Upload program melalui ST-Link

    • Monitoring serial komunikasi melalui serial monitor STM32CubeIDE.

B. Diagram Blok 


  • Sensor IR Pintu Masuk (Input):
    Sensor infrared (IR) dipasang pada pintu masuk area parkir. Sensor berfungsi untuk mendeteksi keberadaan kendaraan yang akan memasuki area parkir. Ketika kendaraan melewati sensor, cahaya inframerah akan terhalang atau dipantulkan sehingga menghasilkan perubahan logika pada output sensor. Sinyal tersebut kemudian dibaca oleh mikrokontroler STM32 master melalui pin GPIO input sebagai data pendeteksian kendaraan masuk.
  • Mikrokontroler STM32 (Master):
    Master merupakan pusat pengendalian utama sistem parkir otomatis. Mikrokontroler STM32 NUCLEO G474RE pada bagian ini bertugas untuk:
    • Membaca data dari sensor IR pintu masuk
    • Mengendalikan motor servo palang masuk menggunakan sinyal PWM
    • Menghitung jumlah slot parkir yang tersedia
    • Menampilkan informasi kapasitas parkir pada OLED display
    • Menerima data kendaraan keluar dari slave melalui komunikasi UART

    Program pada master bekerja secara terus-menerus dalam loop utama untuk memonitor kondisi sensor dan memperbarui sistem secara real-time.

  • Motor Servo Pintu Masuk (Aktuator):

    Motor servo digunakan sebagai aktuator mekanik yang berfungsi membuka dan menutup palang parkir pada pintu masuk. Servo dikendalikan oleh sinyal PWM (Pulse Width Modulation) dari timer STM32 master. Perubahan duty cycle PWM menentukan posisi sudut servo:

    • Duty cycle tertentu digunakan untuk posisi palang terbuka
    • Duty cycle lainnya digunakan untuk posisi palang tertutup

    Servo akan membuka palang ketika kendaraan terdeteksi dan slot parkir masih tersedia.

  • OLED SSD1306 (Display):

    OLED SSD1306 berfungsi sebagai media tampilan informasi sistem parkir. Display ini menampilkan:

    • Jumlah slot parkir tersedia
    • Status parkir penuh atau tersedia
    • Informasi kondisi sistem secara real-time

    Komunikasi antara OLED dan STM32 master menggunakan protokol I2C melalui jalur SDA dan SCL sehingga pertukaran data tampilan dapat dilakukan secara efisien dengan jumlah pin yang sedikit.

  • Komunikasi UART (USART1):

    Komunikasi UART digunakan untuk pertukaran data antara STM32 master dan STM32 slave. Komunikasi dilakukan secara serial asynchronous menggunakan jalur:

    • TX (Transmit)
    • RX (Receive)

    Pada sistem ini:

    • Master mengirim dan menerima data terkait kondisi kendaraan
    • Slave mengirimkan informasi kendaraan keluar ke master

    Protokol UART dipilih karena sederhana, stabil, dan mudah diimplementasikan pada komunikasi antar mikrokontroler.

  • Mikrokontroler STM32 (Slave):

    Slave berfungsi sebagai pengendali pintu keluar area parkir. Mikrokontroler ini bertugas:

    • Membaca sensor IR pintu keluar
    • Mengendalikan servo palang keluar
    • Mengirim data kendaraan keluar ke master melalui UART

    Ketika kendaraan keluar terdeteksi, slave akan mengirimkan karakter data tertentu melalui UART agar master dapat memperbarui jumlah slot parkir yang tersedia.

  • Input Sensor IR Pintu Keluar (Input):
    Sensor IR pada pintu keluar digunakan untuk mendeteksi kendaraan yang meninggalkan area parkir. Sensor menghasilkan sinyal logika digital yang dibaca oleh STM32 slave melalui GPIO input. Data pendeteksian ini menjadi dasar proses pembukaan palang keluar dan pengiriman informasi ke master.

  • Motor Servo Pintu Keluar
    Motor servo pada pintu keluar berfungsi membuka dan menutup palang otomatis saat kendaraan keluar terdeteksi. Servo dikendalikan menggunakan sinyal PWM dari STM32 slave. Setelah kendaraan melewati area sensor, servo akan kembali ke posisi awal sehingga palang tertutup kembali secara otomatis.

  • Power Supply

    Power supply menyediakan sumber tegangan untuk seluruh rangkaian sistem parkir otomatis. Tegangan 5V dan 3.3V digunakan untuk mensuplai:

    • Mikrokontroler STM32
    • Sensor IR
    • OLED display
    • Motor servo

    Catu daya yang stabil sangat penting agar komunikasi UART, pembacaan sensor, dan pengendalian servo dapat bekerja dengan baik tanpa gangguan sistem.


3. Rangkaian Simulasi dan Prinsip Kerja [Kembali]


    Sistem bekerja dengan memanfaatkan dua buah mikrokontroler STM32 NUCLEO G474RE yang saling berkomunikasi menggunakan protokol UART untuk mengatur proses kendaraan masuk dan keluar area parkir. Mikrokontroler utama (master) bertugas mengelola jumlah slot parkir yang tersedia, membaca kondisi sensor IR pada pintu masuk, mengendalikan motor servo sebagai palang otomatis, serta menampilkan informasi kapasitas parkir pada OLED display. Ketika sensor IR mendeteksi adanya kendaraan di pintu masuk dan slot parkir masih tersedia, maka sistem akan membuka palang masuk menggunakan motor servo, kemudian jumlah slot parkir akan dikurangi satu. Setelah kendaraan melewati sensor, palang akan kembali ditutup secara otomatis. Informasi jumlah slot yang tersisa juga diperbarui secara real-time pada display OLED.

    Pada sisi pintu keluar, mikrokontroler kedua (slave) berfungsi untuk mendeteksi kendaraan yang keluar menggunakan sensor IR. Ketika kendaraan keluar terdeteksi, slave akan mengirimkan data karakter melalui komunikasi UART ke master sebagai tanda bahwa satu slot parkir kembali tersedia. Setelah data diterima, master akan menambah jumlah slot parkir dan memperbarui tampilan informasi pada OLED. Selain itu, sistem juga dilengkapi indikator kondisi parkir penuh, dimana apabila seluruh slot telah terisi maka palang tidak akan terbuka dan indikator akan memberikan peringatan bahwa area parkir sudah penuh. Dengan demikian, percobaan ini menunjukkan implementasi sistem parkir otomatis berbasis komunikasi UART yang mampu melakukan monitoring kapasitas parkir, pengendalian akses kendaraan, serta pertukaran data antar mikrokontroler secara sinkron dan otomatis.






Listing Program Nucleo 1 :

/* USER CODE BEGIN Header */ 
/** 
************************************************************
****************** 
* @file           : main.c 
* @brief          : Master Parking System - STM32G474RE 
************************************************************
****************** 
*/ 
/* USER CODE END Header */ 
/* Includes ------------------------------------------------------------------*/ 
#include "main.h" 
/* Private define ------------------------------------------------------------*/ 
/* USER CODE BEGIN PD */ 
#define MAX_PARKIR 10 
/* USER CODE END PD */ 
 
/* Private macro -------------------------------------------------------------*/ 
/* USER CODE BEGIN PM */ 
/* USER CODE END PM */ 
 
/* Private variables ---------------------------------------------------------*/ 
COM_InitTypeDef BspCOMInit; 
I2C_HandleTypeDef hi2c1; 
TIM_HandleTypeDef htim2; 
UART_HandleTypeDef huart1; // komunikasi ke slave (PC4/PC5) 
UART_HandleTypeDef huart2; // serial monitor via BSP COM1 
(PA2/PA3) 
 
/* USER CODE BEGIN PV */ 
uint8_t sisa_parkir     = MAX_PARKIR; 
uint8_t kendaraan_masuk = 0; 
uint8_t uart_rx_buffer[1]; 
/* USER CODE END PV */ 
 
/* Private function prototypes -----------------------------------------------*/ 
void SystemClock_Config(void); 
static void MX_GPIO_Init(void); 
static void MX_I2C1_Init(void); 
static void MX_TIM2_Init(void); 
static void MX_USART1_UART_Init(void); 
static void MX_USART2_UART_Init(void); 
 
/* USER CODE BEGIN PFP */ 
void Update_Display(void); 
void Servo_Buka(void); 
void Servo_Tutup(void); 
/* USER CODE END PFP */ 
 
/* USER CODE BEGIN 0 */ 
/* USER CODE END 0 */ 
 
int main(void) 
{ 
  /* USER CODE BEGIN 1 */ 
  /* USER CODE END 1 */ 
 
  HAL_Init(); 
 
  /* USER CODE BEGIN Init */ 
  /* USER CODE END Init */ 
 
  SystemClock_Config(); 
 
  /* USER CODE BEGIN SysInit */ 
  /* USER CODE END SysInit */ 
 
  MX_GPIO_Init(); 
  MX_I2C1_Init(); 
  MX_TIM2_Init(); 
  MX_USART1_UART_Init(); 
  MX_USART2_UART_Init(); 
 
  /* USER CODE BEGIN 2 */ 
  BSP_LED_Init(LED_GREEN); 
  BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI); 
 
  // Serial monitor via BSP COM1 (USART2 PA2/PA3) 
  BspCOMInit.BaudRate   = 115200; 
  BspCOMInit.WordLength = COM_WORDLENGTH_8B; 
  BspCOMInit.StopBits   = COM_STOPBITS_1; 
  BspCOMInit.Parity     = COM_PARITY_NONE; 
  BspCOMInit.HwFlowCtl  = COM_HWCONTROL_NONE; 
  if (BSP_COM_Init(COM1, &BspCOMInit) != BSP_ERROR_NONE) { 
  Error_Handler(); 
  } 
 
  ssd1306_Init(); 
 
  HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1); 
  htim2.Instance->CCR1 = 1000; 
 
  // USART1 untuk komunikasi ke slave (PC4=TX, PC5=RX) 
  HAL_UART_Receive_IT(&huart1, uart_rx_buffer, 1); 
 
  printf("=== MASTER PARKING READY ===\r\n"); 
  printf("Slot tersedia: %d/%d\r\n", sisa_parkir, 
MAX_PARKIR); 
  Update_Display(); 
  /* USER CODE END 2 */ 
 
  /* USER CODE BEGIN WHILE */ 
  while (1) 
  { 
    /* USER CODE END WHILE */ 
 
    /* USER CODE BEGIN 3 */ 
    uint8_t ir = 
!HAL_GPIO_ReadPin(MASTER_IR_SENSOR_GPIO_Port, 
MASTER_IR_SENSOR_Pin); 
 
    printf("IR: %d | Sisa: %d\r\n", ir, sisa_parkir); 
 
    // DETEKSI MASUK 
    if (ir && sisa_parkir > 0 && !kendaraan_masuk) { 
      HAL_Delay(50); 
      ir = !HAL_GPIO_ReadPin(MASTER_IR_SENSOR_GPIO_Port, 
MASTER_IR_SENSOR_Pin); 
      if (ir) { 
        Servo_Buka(); 
        sisa_parkir--; 
kendaraan_masuk = 1; 
Update_Display(); 
printf(">> MASUK! Sisa: %d/%d\r\n", sisa_parkir, 
MAX_PARKIR); 
HAL_UART_Transmit(&huart1, (uint8_t*)"M", 1, 100); 
} 
} 
// PARKIR PENUH 
if (ir && sisa_parkir == 0 && !kendaraan_masuk) { 
printf(">> PARKIR PENUH!\r\n"); 
BSP_LED_Toggle(LED_GREEN); 
HAL_Delay(200); 
} 
void Update_Display(void) { 
char buf[25]; 
ssd1306_Fill(Black); 
// KENDARAAN SUDAH LEWAT 
if (!ir && kendaraan_masuk) { 
HAL_Delay(50); 
ir = !HAL_GPIO_ReadPin(MASTER_IR_SENSOR_GPIO_Port, 
MASTER_IR_SENSOR_Pin); 
if (!ir) { 
Servo_Tutup(); 
kendaraan_masuk = 0; 
printf(">> Palang ditutup\r\n"); 
} 
} 
HAL_Delay(100); 
} 
/* USER CODE END 3 */ 
} 
/* USER CODE BEGIN 4 */
 ssd1306_SetCursor(2, 0); 
  ssd1306_WriteString("SISTEM PARKIR", Font_7x10, White); 
 
  ssd1306_SetCursor(2, 14); 
  sprintf(buf, "Slot: %d/%d", sisa_parkir, MAX_PARKIR); 
  ssd1306_WriteString(buf, Font_7x10, White); 
 
  ssd1306_SetCursor(2, 28); 
  if (sisa_parkir == 0) { 
    ssd1306_WriteString(">> PENUH <<", Font_7x10, White); 
  } else { 
    ssd1306_WriteString(">> TERSEDIA <<", Font_7x10, White); 
  } 
  ssd1306_UpdateScreen(); 
} 
 
void Servo_Buka(void) { 
  htim2.Instance->CCR1 = 2000; 
  HAL_Delay(600); 
} 
 
void Servo_Tutup(void) { 
  htim2.Instance->CCR1 = 1000; 
  HAL_Delay(600); 
} 
 
// Terima dari slave via USART1 (PC5=RX) 
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) 
{ 
  if (huart->Instance == USART1) 
  { 
    if (uart_rx_buffer[0] == 'K') 
    { 
      if(sisa_parkir < MAX_PARKIR) sisa_parkir++; 
 
      printf(">> KENDARAAN KELUAR (SLAVE)\r\n");
       printf(">> Sisa: %d/%d\r\n", sisa_parkir, MAX_PARKIR); 
 
      Update_Display(); 
    } 
    HAL_UART_Receive_IT(&huart1, uart_rx_buffer, 1); 
  } 
} 
 
/* USER CODE END 4 */ 
 
void SystemClock_Config(void) 
{ 
  RCC_OscInitTypeDef RCC_OscInitStruct = {0}; 
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; 
 
  
HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1
_BOOST); 
  RCC_OscInitStruct.OscillatorType      = 
RCC_OSCILLATORTYPE_HSI; 
  RCC_OscInitStruct.HSIState            = RCC_HSI_ON; 
  RCC_OscInitStruct.HSICalibrationValue = 
RCC_HSICALIBRATION_DEFAULT; 
  RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_ON; 
  RCC_OscInitStruct.PLL.PLLSource       = RCC_PLLSOURCE_HSI; 
  RCC_OscInitStruct.PLL.PLLM            = RCC_PLLM_DIV4; 
  RCC_OscInitStruct.PLL.PLLN            = 85; 
  RCC_OscInitStruct.PLL.PLLP            = RCC_PLLP_DIV2; 
  RCC_OscInitStruct.PLL.PLLQ            = RCC_PLLQ_DIV2; 
  RCC_OscInitStruct.PLL.PLLR            = RCC_PLLR_DIV2; 
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) 
Error_Handler(); 
 
  RCC_ClkInitStruct.ClockType      = RCC_CLOCKTYPE_HCLK | 
RCC_CLOCKTYPE_SYSCLK 
                                   | RCC_CLOCKTYPE_PCLK1 | 
RCC_CLOCKTYPE_PCLK2; 
 RCC_ClkInitStruct.SYSCLKSource   = 
RCC_SYSCLKSOURCE_PLLCLK; 
  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_4) != HAL_OK) Error_Handler(); 
} 
 
static void MX_I2C1_Init(void) 
{ 
  hi2c1.Instance                     = I2C1; 
  hi2c1.Init.Timing                  = 0x40B285C2; 
  hi2c1.Init.OwnAddress1             = 0; 
  hi2c1.Init.AddressingMode          = 
I2C_ADDRESSINGMODE_7BIT; 
  hi2c1.Init.DualAddressMode         = 
I2C_DUALADDRESS_DISABLE; 
  hi2c1.Init.OwnAddress2             = 0; 
  hi2c1.Init.OwnAddress2Masks        = I2C_OA2_NOMASK; 
  hi2c1.Init.GeneralCallMode         = 
I2C_GENERALCALL_DISABLE; 
  hi2c1.Init.NoStretchMode           = 
I2C_NOSTRETCH_DISABLE; 
  if (HAL_I2C_Init(&hi2c1) != HAL_OK) Error_Handler(); 
  if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, 
I2C_ANALOGFILTER_ENABLE) != HAL_OK) Error_Handler(); 
  if (HAL_I2CEx_ConfigDigitalFilter(&hi2c1, 0) != HAL_OK) 
Error_Handler(); 
} 
 
static void MX_TIM2_Init(void) 
{ 
  TIM_ClockConfigTypeDef  sClockSourceConfig = {0}; 
  TIM_MasterConfigTypeDef sMasterConfig      = {0}; 
  TIM_OC_InitTypeDef      sConfigOC          = {0};
   htim2.Instance               = TIM2; 
  htim2.Init.Prescaler         = 169; 
  htim2.Init.CounterMode       = TIM_COUNTERMODE_UP; 
  htim2.Init.Period            = 19999; 
  htim2.Init.ClockDivision     = TIM_CLOCKDIVISION_DIV1; 
  htim2.Init.AutoReloadPreload = 
TIM_AUTORELOAD_PRELOAD_DISABLE; 
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK) Error_Handler(); 
 
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL; 
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) 
!= HAL_OK) Error_Handler(); 
  if (HAL_TIM_PWM_Init(&htim2) != HAL_OK) Error_Handler(); 
 
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; 
  sMasterConfig.MasterSlaveMode     = 
TIM_MASTERSLAVEMODE_DISABLE; 
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, 
&sMasterConfig) != HAL_OK) Error_Handler(); 
 
  sConfigOC.OCMode     = TIM_OCMODE_PWM1; 
  sConfigOC.Pulse      = 1000; 
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; 
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; 
  if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, 
TIM_CHANNEL_1) != HAL_OK) Error_Handler(); 
  HAL_TIM_MspPostInit(&htim2); 
} 
 
static void MX_USART1_UART_Init(void) 
{ 
  // USART1 - komunikasi ke slave (PC4=TX, PC5=RX) 9600 baud 
  huart1.Instance                    = USART1; 
  huart1.Init.BaudRate               = 9600; 
  huart1.Init.WordLength             = UART_WORDLENGTH_8B; 
  huart1.Init.StopBits               = UART_STOPBITS_1; 
  huart1.Init.Parity                 = UART_PARITY_NONE;
    huart1.Init.Mode                   = UART_MODE_TX_RX; 
  huart1.Init.HwFlowCtl              = UART_HWCONTROL_NONE; 
  huart1.Init.OverSampling           = UART_OVERSAMPLING_16; 
  huart1.Init.OneBitSampling         = 
UART_ONE_BIT_SAMPLE_DISABLE; 
  huart1.Init.ClockPrescaler         = UART_PRESCALER_DIV1; 
  huart1.AdvancedInit.AdvFeatureInit = 
UART_ADVFEATURE_NO_INIT; 
  if (HAL_UART_Init(&huart1) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_SetTxFifoThreshold(&huart1, 
UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_SetRxFifoThreshold(&huart1, 
UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK) 
Error_Handler(); 
} 
 
static void MX_USART2_UART_Init(void) 
{ 
  // USART2 - serial monitor via BSP COM1 (PA2=TX, PA3=RX) 
  huart2.Instance                    = USART2; 
  huart2.Init.BaudRate               = 115200; 
  huart2.Init.WordLength             = UART_WORDLENGTH_8B; 
  huart2.Init.StopBits               = UART_STOPBITS_1; 
  huart2.Init.Parity                 = UART_PARITY_NONE; 
  huart2.Init.Mode                   = UART_MODE_TX_RX; 
  huart2.Init.HwFlowCtl              = UART_HWCONTROL_NONE; 
  huart2.Init.OverSampling           = UART_OVERSAMPLING_16; 
  huart2.Init.OneBitSampling         = 
UART_ONE_BIT_SAMPLE_DISABLE; 
  huart2.Init.ClockPrescaler         = UART_PRESCALER_DIV1; 
  huart2.AdvancedInit.AdvFeatureInit = 
UART_ADVFEATURE_NO_INIT; 
  if (HAL_UART_Init(&huart2) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_SetTxFifoThreshold(&huart2, 
UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_SetRxFifoThreshold(&huart2,
  UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_DisableFifoMode(&huart2) != HAL_OK) 
Error_Handler(); 
} 
 
static void MX_GPIO_Init(void) 
{ 
  GPIO_InitTypeDef GPIO_InitStruct = {0}; 
 
  __HAL_RCC_GPIOC_CLK_ENABLE(); 
  __HAL_RCC_GPIOF_CLK_ENABLE(); 
  __HAL_RCC_GPIOA_CLK_ENABLE(); 
  __HAL_RCC_GPIOB_CLK_ENABLE(); 
 
  // IR sensor PA1 - aktif LOW ? PULLUP 
  GPIO_InitStruct.Pin  = MASTER_IR_SENSOR_Pin; 
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT; 
  GPIO_InitStruct.Pull = GPIO_PULLUP; 
  HAL_GPIO_Init(MASTER_IR_SENSOR_GPIO_Port, 
&GPIO_InitStruct); 
 
  // USART1 TX=PC4, RX=PC5 untuk komunikasi ke slave 
  GPIO_InitStruct.Pin       = MASTER_TX_Pin | MASTER_RX_Pin; 
  GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP; 
  GPIO_InitStruct.Pull      = GPIO_NOPULL; 
  GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW; 
  GPIO_InitStruct.Alternate = GPIO_AF7_USART1; 
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); 
} 
void Error_Handler(void) 
{ 
  __disable_irq(); 
  while (1) {} 
} 
#ifdef USE_FULL_ASSERT 
void assert_failed(uint8_t *file, uint32_t line) {} 
#endif


Listing Program Nucleo 2 :

/* USER CODE BEGIN Header */ 
/** 
  
**************************************************************
**************** 
  * @file           : main.c 
  * @brief          : Slave Parking System - STM32G474RE 
(Pintu Keluar) 
  
**************************************************************
**************** 
  */ 
/* USER CODE END Header */ 
 
/* Includes ------------------------------------------------------------------*/ 
#include "main.h" 
 
/* Private includes ----------------------------------------------------------*/ 
/* USER CODE BEGIN Includes */ 
#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 ---------------------------------------------------------*/ 
COM_InitTypeDef BspCOMInit; 
TIM_HandleTypeDef htim2; 
UART_HandleTypeDef huart1; 
UART_HandleTypeDef huart2; 
 
/* USER CODE BEGIN PV */ 
uint8_t kendaraan_keluar = 0; 
uint8_t uart_rx_buffer[1]; 
/* USER CODE END PV */ 
 
/* Private function prototypes -----------------------------------------------*/ 
void SystemClock_Config(void); 
static void MX_GPIO_Init(void); 
static void MX_TIM2_Init(void); 
static void MX_USART1_UART_Init(void); 
static void MX_USART2_UART_Init(void); 
 
/* USER CODE BEGIN PFP */ 
void Servo_Buka(void); 
void Servo_Tutup(void); 
/* USER CODE END PFP */ 
 
/* USER CODE BEGIN 0 */ 
/* USER CODE END 0 */ 
 
int main(void) 
{ 
  /* USER CODE BEGIN 1 */ 
  /* USER CODE END 1 */ 
HAL_Init(); 
/* USER CODE BEGIN Init */ 
/* USER CODE END Init */ 
SystemClock_Config(); 
/* USER CODE BEGIN SysInit */ 
/* USER CODE END SysInit */ 
MX_GPIO_Init(); 
MX_TIM2_Init(); 
MX_USART1_UART_Init(); 
MX_USART2_UART_Init(); 
/* USER CODE BEGIN 2 */ 
BSP_LED_Init(LED_GREEN); 
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI); 
HAL_GPIO_WritePin(LED_GREEN_GPIO_Port, LED_GREEN_Pin, 
GPIO_PIN_RESET); 
BspCOMInit.BaudRate   = 115200; 
BspCOMInit.WordLength = COM_WORDLENGTH_8B; 
BspCOMInit.StopBits   = COM_STOPBITS_1; 
BspCOMInit.Parity     = COM_PARITY_NONE; 
BspCOMInit.HwFlowCtl  = COM_HWCONTROL_NONE; 
if (BSP_COM_Init(COM1, &BspCOMInit) != BSP_ERROR_NONE) { 
Error_Handler(); 
} 
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1); 
htim2.Instance->CCR1 = 1000; 
// USART2 RX interrupt - terima dari master 
HAL_UART_Receive_IT(&huart1, uart_rx_buffer, 1); 
HAL_GPIO_WritePin(LED_GREEN_GPIO_Port, LED_GREEN_Pin, 
GPIO_PIN_RESET);
 printf("=== SLAVE READY - Pintu Keluar ===\r\n"); 
  /* USER CODE END 2 */ 
 
  /* USER CODE BEGIN WHILE */ 
  while (1) 
  { 
    /* USER CODE END WHILE */ 
 
    /* USER CODE BEGIN 3 */ 
    uint8_t ir = !HAL_GPIO_ReadPin(SLAVE_IR_SENSOR_GPIO_Port, 
SLAVE_IR_SENSOR_Pin); 
 
    printf("IR: %d\r\n", ir); 
 
    // === DETEKSI KENDARAAN KELUAR === 
    if (ir && !kendaraan_keluar) { 
      HAL_Delay(50); 
      ir = !HAL_GPIO_ReadPin(SLAVE_IR_SENSOR_GPIO_Port, 
SLAVE_IR_SENSOR_Pin); 
      if (ir) { 
        Servo_Buka();                                        
// 1. buka palang 
        kendaraan_keluar = 1;                                
// 2. set flag 
        HAL_UART_Transmit(&huart1, (uint8_t*)"K", 1, 100); // 
3. kirim ke master 
        HAL_GPIO_WritePin(LED_GREEN_GPIO_Port, LED_GREEN_Pin, 
GPIO_PIN_SET); 
        printf(">> KELUAR! Kuota +1 dikirim ke master\r\n"); 
      } 
    } 
 
    // === KENDARAAN SUDAH LEWAT === 
    if (!ir && kendaraan_keluar) { 
      HAL_Delay(50); 
      ir = !HAL_GPIO_ReadPin(SLAVE_IR_SENSOR_GPIO_Port, 
SLAVE_IR_SENSOR_Pin); 
      if (!ir) { 
        Servo_Tutup(); 
        kendaraan_keluar = 0; 
        HAL_GPIO_WritePin(LED_GREEN_GPIO_Port, LED_GREEN_Pin, 
GPIO_PIN_RESET); 
        printf(">> Palang ditutup, siap kendaraan 
berikutnya\r\n"); 
      } 
    } 
 
    HAL_Delay(100); 
  } 
  /* USER CODE END 3 */ 
} 
 
/* USER CODE BEGIN 4 */ 
 
void Servo_Buka(void) { 
  htim2.Instance->CCR1 = 2000; 
  HAL_Delay(600); 
} 
 
void Servo_Tutup(void) {  
  htim2.Instance->CCR1 = 1000; 
  HAL_Delay(600); 
} 
 
// Terima info dari master via USART2 
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) 
{ 
  if (huart->Instance == USART1) 
  { 
    if (uart_rx_buffer[0] == 'M') 
    { 
      printf(">> INFO: KENDARAAN MASUK (MASTER)\r\n"); 
    }
      HAL_UART_Receive_IT(&huart1, uart_rx_buffer, 1); 
  } 
} 
 
/* USER CODE END 4 */ 
 
void SystemClock_Config(void) 
{ 
  RCC_OscInitTypeDef RCC_OscInitStruct = {0}; 
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; 
 
  
HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1_B
OOST); 
  RCC_OscInitStruct.OscillatorType      = 
RCC_OSCILLATORTYPE_HSI; 
  RCC_OscInitStruct.HSIState            = RCC_HSI_ON; 
  RCC_OscInitStruct.HSICalibrationValue = 
RCC_HSICALIBRATION_DEFAULT; 
  RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_ON; 
  RCC_OscInitStruct.PLL.PLLSource       = RCC_PLLSOURCE_HSI; 
  RCC_OscInitStruct.PLL.PLLM            = RCC_PLLM_DIV4; 
  RCC_OscInitStruct.PLL.PLLN            = 85; 
  RCC_OscInitStruct.PLL.PLLP            = RCC_PLLP_DIV2; 
  RCC_OscInitStruct.PLL.PLLQ            = RCC_PLLQ_DIV2; 
  RCC_OscInitStruct.PLL.PLLR            = RCC_PLLR_DIV2; 
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) 
Error_Handler(); 
 
  RCC_ClkInitStruct.ClockType      = RCC_CLOCKTYPE_HCLK | 
RCC_CLOCKTYPE_SYSCLK 
                                   | RCC_CLOCKTYPE_PCLK1 | 
RCC_CLOCKTYPE_PCLK2; 
  RCC_ClkInitStruct.SYSCLKSource   = RCC_SYSCLKSOURCE_PLLCLK; 
  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_4) 
!= HAL_OK) Error_Handler(); 
} 
 
static void MX_TIM2_Init(void) 
{ 
  TIM_ClockConfigTypeDef  sClockSourceConfig = {0}; 
  TIM_MasterConfigTypeDef sMasterConfig      = {0}; 
  TIM_OC_InitTypeDef      sConfigOC          = {0}; 
 
  htim2.Instance               = TIM2; 
  htim2.Init.Prescaler         = 169; 
  htim2.Init.CounterMode       = TIM_COUNTERMODE_UP; 
  htim2.Init.Period            = 19999; 
  htim2.Init.ClockDivision     = TIM_CLOCKDIVISION_DIV1; 
  htim2.Init.AutoReloadPreload = 
TIM_AUTORELOAD_PRELOAD_DISABLE; 
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK) Error_Handler(); 
 
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL; 
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) 
!= HAL_OK) Error_Handler(); 
  if (HAL_TIM_PWM_Init(&htim2) != HAL_OK) Error_Handler(); 
 
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; 
  sMasterConfig.MasterSlaveMode     = 
TIM_MASTERSLAVEMODE_DISABLE; 
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, 
&sMasterConfig) != HAL_OK) Error_Handler(); 
 
  sConfigOC.OCMode     = TIM_OCMODE_PWM1; 
  sConfigOC.Pulse      = 1000; 
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; 
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; 
  if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, 
TIM_CHANNEL_1) != HAL_OK) Error_Handler(); 
  HAL_TIM_MspPostInit(&htim2);
  } 
 
static void MX_USART1_UART_Init(void) 
{ 
  huart1.Instance                    = USART1; 
  huart1.Init.BaudRate               = 9600; 
  huart1.Init.WordLength             = UART_WORDLENGTH_8B; 
  huart1.Init.StopBits               = UART_STOPBITS_1; 
  huart1.Init.Parity                 = UART_PARITY_NONE; 
  huart1.Init.Mode                   = UART_MODE_TX_RX; 
  huart1.Init.HwFlowCtl              = UART_HWCONTROL_NONE; 
  huart1.Init.OverSampling           = UART_OVERSAMPLING_16; 
  huart1.Init.OneBitSampling         = 
UART_ONE_BIT_SAMPLE_DISABLE; 
  huart1.Init.ClockPrescaler         = UART_PRESCALER_DIV1; 
  huart1.AdvancedInit.AdvFeatureInit = 
UART_ADVFEATURE_NO_INIT; 
  if (HAL_UART_Init(&huart1) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_SetTxFifoThreshold(&huart1, 
UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_SetRxFifoThreshold(&huart1, 
UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK) 
Error_Handler(); 
} 
 
static void MX_USART2_UART_Init(void) 
{ 
  huart2.Instance                    = USART2; 
  huart2.Init.BaudRate               = 115200; 
  huart2.Init.WordLength             = UART_WORDLENGTH_8B; 
  huart2.Init.StopBits               = UART_STOPBITS_1; 
  huart2.Init.Parity                 = UART_PARITY_NONE; 
  huart2.Init.Mode                   = UART_MODE_TX_RX; 
  huart2.Init.HwFlowCtl              = UART_HWCONTROL_NONE; 
  huart2.Init.OverSampling           = UART_OVERSAMPLING_16; 
  huart2.Init.OneBitSampling         =
  UART_ONE_BIT_SAMPLE_DISABLE; 
  huart2.Init.ClockPrescaler         = UART_PRESCALER_DIV1; 
  huart2.AdvancedInit.AdvFeatureInit = 
UART_ADVFEATURE_NO_INIT; 
  if (HAL_UART_Init(&huart2) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_SetTxFifoThreshold(&huart2, 
UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_SetRxFifoThreshold(&huart2, 
UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) Error_Handler(); 
  if (HAL_UARTEx_DisableFifoMode(&huart2) != HAL_OK) 
Error_Handler(); 
} 
 
static void MX_GPIO_Init(void) 
{ 
  GPIO_InitTypeDef GPIO_InitStruct = {0}; 
 
  __HAL_RCC_GPIOC_CLK_ENABLE(); 
  __HAL_RCC_GPIOF_CLK_ENABLE(); 
  __HAL_RCC_GPIOA_CLK_ENABLE(); 
  __HAL_RCC_GPIOB_CLK_ENABLE(); 
 
  // LED GREEN PB7 - output 
  HAL_GPIO_WritePin(LED_GREEN_GPIO_Port, LED_GREEN_Pin, 
GPIO_PIN_RESET); 
  GPIO_InitStruct.Pin   = LED_GREEN_Pin; 
  GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP; 
  GPIO_InitStruct.Pull  = GPIO_NOPULL; 
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; 
  HAL_GPIO_Init(LED_GREEN_GPIO_Port, &GPIO_InitStruct); 
 
  // IR sensor PA1 - aktif LOW ? PULLUP 
  GPIO_InitStruct.Pin  = SLAVE_IR_SENSOR_Pin; 
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT; 
  GPIO_InitStruct.Pull = GPIO_PULLUP; 
  HAL_GPIO_Init(SLAVE_IR_SENSOR_GPIO_Port, &GPIO_InitStruct);
  // USART2 PA2=TX, PA3=RX untuk komunikasi ke master 
GPIO_InitStruct.Pin       = SLAVE_USART1_TX_Pin | 
SLAVE_USART1_RX_Pin; 
GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP; 
GPIO_InitStruct.Pull      = GPIO_NOPULL; 
GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW; 
GPIO_InitStruct.Alternate = GPIO_AF7_USART1; 
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); 
} 
void Error_Handler(void) 
{ 
__disable_irq(); 
while (1) {} 
} 
#ifdef USE_FULL_ASSERT 
void assert_failed(uint8_t *file, uint32_t line) {} 
#endif


5. Video Demo [Kembali]



6. Soal Analisa [Kembali]








7. Video Simulasi [Kembali]



8. Download File [Kembali]

Download File Laporan Akhir klik disini

Tidak ada komentar:

Posting Komentar

Langganan: Postingan (Atom)

  BAHAN PRESENTASI UNTUK MATAKULIAH ELEKTRONIKA 2024 Oleh : MUHAMMAD FADLI NIM. 2310952007   Dosen Pengampu : Dr. Darwison, S. T., M. T. NID...

  • (tanpa judul)
      BAHAN PRESENTASI UNTUK MATAKULIAH ELEKTRONIKA 2024 Oleh : MUHAMMAD FADLI NIM. 2310952007   Dosen Pengampu : Dr. Darwison, S. T., M. T. NID...