Laporan Akhir

[KEMBALI KE MENU SEBELUMNYA]

DAFTAR ISI

1. Prosedur

2. Hardware dan Diagram Blok

3. Rangkaian Simulasi Dan Prinsip Kerja

4. Flowchart dan Listing Program

5. Video Demo

6. Analisa

7. Download File

 1. Prosedur[kembali]

Prosedur Percobaan Parkir Otomatis (UART)

1. Menyiapkan alat dan bahan seperti STM32 Nucleo G474RE, STM32 Bluepill, sensor PIR, LED, resistor, breadboard, dan kabel jumper.
2. Merangkai komponen sesuai diagram rangkaian, dimana sensor PIR dihubungkan ke mikrokontroler pengirim dan LED dihubungkan ke mikrokontroler penerima.
3. Menghubungkan jalur komunikasi UART antara kedua mikrokontroler melalui pin TX dan RX serta menghubungkan GND kedua board.
4. Membuat project pada STM32CubeIDE dan melakukan konfigurasi UART pada kedua mikrokontroler dengan baudrate yang sama.
5. Mengisi program pada mikrokontroler pengirim untuk membaca data sensor PIR dan mengirimkan data melalui UART.
6. Mengisi program pada mikrokontroler penerima untuk menerima data UART dan mengontrol LED sesuai data yang diterima.
7. Melakukan compile dan upload program ke masing-masing mikrokontroler.
8. Menjalankan sistem dan mengamati respon LED saat sensor PIR mendeteksi objek atau tidak mendeteksi objek.
9. Mencatat hasil percobaan dan menganalisa proses komunikasi data yang terjadi.

 2. Hardware dan Diagram Blok [kembali]

Hardware :

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. Infrared Sensor

3. Motor Servo

4. OLED

Layar OLED pada rangkaian ini adalah sebagai antarmuka visual (HMI) yang menampilkan status sistem secara real-time melalui protokol komunikasi I2C. Dalam percobaan ini, OLED berperan untuk memberikan konfirmasi visual kepada pengguna mengenai data yang sedang diproses atau dikirim oleh Nucleo 1, seperti menampilkan indikator logika input dari push button atau status transmisi UART, sehingga memudahkan proses pemantauan arus kerja sistem tanpa harus bergantung pada serial monitor di komputer.

                                                    

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.

                                                            

Diagram Blok

 3. Rangkaian Simulasi Dan Prinsip Kerja [kembali]

Prinsip Kerja:

Sistem parkir otomatis bekerja menggunakan sensor PIR, dua mikrokontroler, dan komunikasi UART sebagai media pertukaran data. Sensor PIR berfungsi mendeteksi adanya pergerakan atau keberadaan objek seperti kendaraan yang masuk ke area parkir. Saat sensor mendeteksi objek, sensor akan menghasilkan sinyal logika HIGH yang kemudian dibaca oleh mikrokontroler STM32 Nucleo sebagai data input.

Mikrokontroler pengirim akan memproses data dari sensor PIR dan mengubahnya menjadi data digital berupa karakter ‘1’ ketika objek terdeteksi dan karakter ‘0’ ketika tidak ada objek. Data tersebut kemudian dikirimkan secara serial melalui komunikasi UART menggunakan jalur TX dan RX menuju mikrokontroler STM32 Bluepill sebagai penerima. Pada komunikasi UART, proses pengiriman data dilakukan tanpa sinyal clock sehingga kedua mikrokontroler harus menggunakan baudrate yang sama agar data dapat diterima dengan benar.

Setelah data diterima oleh mikrokontroler penerima, data akan diproses untuk mengontrol output sistem. Jika data yang diterima adalah ‘1’, maka LED indikator akan menyala sebagai tanda adanya kendaraan atau area parkir terisi. Sebaliknya, jika data yang diterima adalah ‘0’, maka LED akan mati atau berkedip sebagai tanda tidak ada kendaraan yang terdeteksi.

Proses pembacaan sensor, pengiriman data, dan pengontrolan output berlangsung secara terus-menerus sehingga sistem dapat bekerja otomatis dan real-time. Dengan adanya komunikasi UART antar mikrokontroler, sistem parkir otomatis mampu melakukan pemantauan kondisi parkir dengan lebih cepat dan efisien.

 4. Flowchart dan Listing Program [kembali]

• Flowchart

• 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 ------------------------------------------------------------*/ /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ #define SSD1306_INCLUDE_FONT_7x10 #include "ssd1306.h" #include "ssd1306_fonts.h" #include #include /* USER CODE END Includes */ /* Private typedef -----------------------------------------------------------*/ /* USER CODE BEGIN PTD */ /* USER CODE END PTD */

/* 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

• 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 #include /* 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);

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. Analisa [kembali]

 7. Download File [kembali]

• Download Analisa disini
• Download Datasheet IR Sensor disini
• Download Datasheet LED disini
• Download Datsheet STM32 Nucleo disini
• Download Datasheet LED disini