LAPORAN AKHIR MODUL III

← Kembali ke Halaman 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. Kondisi
7. Video Simulasi
8. Download File

 LAPORAN AKHIR 

MODUL 3 COMMUNICATTION 

1. Prosedur [Kembali]

1. Siapkan alat dan bahan seperti STM32 NUCLEO G474RE, STM32 Bluepill, PIR Sensor, LED, resistor, breadboard, dan jumper.
2. Rangkai komponen sesuai gambar rangkaian pada modul serta hubungkan komunikasi UART antara NUCLEO dan Bluepill.
3. Buka STM32CubeIDE lalu buat dua project yaitu Project_Nucleo dan Project_Bluepill.
4. Lakukan konfigurasi GPIO dan USART1 sesuai pengaturan pada modul kemudian Generate Code.
5. Masukkan listing program transmitter pada project NUCLEO dan listing program receiver pada project Bluepill sesuai modul.
6. Hubungkan kedua board STM32 ke laptop menggunakan kabel USB.
7. Build dan Run program pada STM32CubeIDE.
8. Uji PIR Sensor dan amati kondisi LED apakah bekerja sesuai program.

2. Hardware dan Diagram Blok [Kembali]

Hardware :

• ST-LINK 

• STM32 NUCLEO-G474RE

• Buzzer 

• LED

• Resistor

• 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.

• 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.

• PIR Sensor

Sensor PIR (Passive Infrared Receiver) adalah perangkat elektronik yang berfungsi sebagai pendeteksi gerakan dengan cara menangkap perubahan radiasi sinar inframerah panas yang dipancarkan secara alami oleh objek seperti manusia atau hewan di area cakupannya. Karena sifatnya yang pasif, sensor ini tidak memancarkan energi sendiri melainkan hanya merespons fluktuasi suhu lingkungan yang terjadi saat ada objek bergerak.

• 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.

Diagram Blok

3. Rangkaian Simulasi dan Prinsip Kerja [Kembali]

• Rangkaian 

• Prinsip Kerja 

Berdasarkan flowchart pada percobaan 3 Smart Entry Indicator, sistem bekerja dimulai dari proses inisialisasi GPIO dan UART pada kedua mikrokontroler. Setelah sistem aktif, STM32 Nucleo sebagai transmitter akan membaca kondisi sensor PIR secara terus-menerus. Sensor PIR berfungsi untuk mendeteksi adanya gerakan manusia di area tertentu.

Jika sensor PIR mendeteksi gerakan, maka STM32 Nucleo akan mengirim data karakter ‘1’ melalui komunikasi UART ke STM32 Bluepill. Setelah data diterima oleh Bluepill, mikrokontroler akan memproses data tersebut dan memberikan respon berupa LED menyala terus sebagai indikator bahwa ada gerakan yang terdeteksi.

Sebaliknya, jika sensor PIR tidak mendeteksi gerakan, maka STM32 Nucleo akan mengirim data karakter ‘0’ melalui UART. Bluepill kemudian menerima data tersebut dan memberikan respon output berupa LED berkedip sebagai tanda bahwa tidak ada gerakan yang terdeteksi.

Setelah proses selesai, sistem akan kembali mengulangi pembacaan sensor PIR secara terus-menerus sehingga sistem dapat bekerja secara otomatis dan real-time. Dengan adanya komunikasi UART antara transmitter dan receiver, data dari sensor dapat dikirim dan diproses dengan baik untuk mengontrol output LED sesuai kondisi yang terdeteksi.

4. Flowchart dan Listing Program [Kembali]

Flowchart program :

                                 

• Listing Program

1. Nucleo (Transmitter)

/* USER CODE BEGIN Header */ /** ************************************************************* ***************** * @file : main.c * @brief : Main program body ************************************************************* ***************** * @attention * * Copyright (c) 2026 STMicroelectronics. * All rights reserved. * * This software is licensed under terms that can be found in the LICENSE file * in the root directory of this software component. * If no LICENSE file comes with this software, it is provided AS-IS. * ************************************************************* ***************** */ /* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ #include "main.h" /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ /* 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; UART_HandleTypeDef huart1; /* USER CODE BEGIN PV */ uint8_t pir_state; uint8_t data; /* USER CODE END PV */ /* Private function prototypes -----------------------------------------------*/ void SystemClock_Config(void); static void MX_GPIO_Init(void); static void MX_USART1_UART_Init(void); /* USER CODE BEGIN PFP */ /* USER CODE END PFP */ /* Private user code ---------------------------------------------------------*/ /* USER CODE BEGIN 0 */ /* USER CODE END 0 */ /** * @brief The application entry point. * @retval int */ int main(void) { /* USER CODE BEGIN 1 */ /* USER CODE END 1 */ /* MCU Configuration--------------------------------------------------------*/ /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ HAL_Init(); /* USER CODE BEGIN Init */ /* USER CODE END Init */ /* Configure the system clock */ SystemClock_Config(); /* USER CODE BEGIN SysInit */ /* USER CODE END SysInit */ /* Initialize all configured peripherals */ MX_GPIO_Init(); MX_USART1_UART_Init(); /* USER CODE BEGIN 2 */ /* USER CODE END 2 */ /* Initialize led */ BSP_LED_Init(LED_GREEN); /* Initialize USER push-button, will be used to trigger an interrupt each time it's pressed.*/ BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI); /* Initialize COM1 port (115200, 8 bits (7-bit data + 1 stop bit), no parity */ 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(); /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { } } /** pir_state = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0); if (pir_state == GPIO_PIN_SET) data = '1'; else data = '0'; HAL_UART_Transmit(&huart1, &data, 1, 100); HAL_Delay(500); * @brief System Clock Configuration * @retval None */ void SystemClock_Config(void) { RCC_OscInitTypeDef RCC_OscInitStruct = {0}; RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; /** Configure the main internal regulator output voltage */ HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1_ BOOST); /** Initializes the RCC Oscillators according to the specified parameters * in the RCC_OscInitTypeDef structure. */ 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(); } /** Initializes the CPU, AHB and APB buses clocks */ 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(); } } /** * @brief USART1 Initialization Function * @param None * @retval None */ static void MX_USART1_UART_Init(void) { /* USER CODE BEGIN USART1_Init 0 */ /* USER CODE END USART1_Init 0 */ /* USER CODE BEGIN USART1_Init 1 */ /* USER CODE END USART1_Init 1 */ 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(); } /* USER CODE BEGIN USART1_Init 2 */ /* USER CODE END USART1_Init 2 */ } /** * @brief GPIO Initialization Function * @param None * @retval None */ static void MX_GPIO_Init(void) { } GPIO_InitTypeDef GPIO_InitStruct = {0}; /* USER CODE BEGIN MX_GPIO_Init_1 */ /* USER CODE END MX_GPIO_Init_1 */ /* GPIO Ports Clock Enable */ __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_GPIOF_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); /*Configure GPIO pin : PA0 */ GPIO_InitStruct.Pin = GPIO_PIN_0; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USER CODE BEGIN MX_GPIO_Init_2 */ /* USER CODE END MX_GPIO_Init_2 */ /* USER CODE BEGIN 4 */ /* USER CODE END 4 */ /** * @brief This function is executed in case of error occurrence. * @retval None */ void Error_Handler(void) { /* USER CODE BEGIN Error_Handler_Debug */ /* User can add his own implementation to report the HAL error return state */ __disable_irq(); while (1) { } /* USER CODE END Error_Handler_Debug */ } #ifdef USE_FULL_ASSERT /** * @brief Reports the name of the source file and the source line number * where the assert_param error has occurred. * @param file: pointer to the source file name * @param line: assert_param error line source number * @retval None */ void assert_failed(uint8_t *file, uint32_t line) { /* USER CODE BEGIN 6 */ /* User can add his own implementation to report the file name and line number, ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */ /* USER CODE END 6 */ } #endif /* USE_FULL_ASSERT */

2. Bluepill (receiver)

/* USER CODE BEGIN Header */ /* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ #include "main.h" /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ /* 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 ---------------------------------------------------------*/ UART_HandleTypeDef huart1; /* USER CODE BEGIN PV */ uint8_t rx_data; /* USER CODE END PV */ /* Private function prototypes -----------------------------------------------*/ void SystemClock_Config(void); static void MX_GPIO_Init(void); static void MX_USART1_UART_Init(void); /* USER CODE BEGIN PFP */ /* USER CODE END PFP */ /* Private user code ---------------------------------------------------------*/ /* USER CODE BEGIN 0 */ /* USER CODE END 0 */ /** * @brief The application entry point. * @retval int */ int main(void) { /* USER CODE BEGIN 1 */ /* USER CODE END 1 */ /* MCU Configuration--------------------------------------------------------*/ /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ HAL_Init(); /* USER CODE BEGIN Init */ /* USER CODE END Init */ /* Configure the system clock */ SystemClock_Config(); /* USER CODE BEGIN SysInit */ /* USER CODE END SysInit */ /* Initialize all configured peripherals */ MX_GPIO_Init(); MX_USART1_UART_Init(); /* USER CODE BEGIN 2 */ /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { // Coba terima data (tidak blocking lama) if (HAL_UART_Receive(&huart1, &rx_data, 1, 10) == HAL_OK) { if (rx_data == '1') { HAL_GPIO_WritePin(GPIOA, GPIO_PIN_SET); // LED ON } else if (rx_data == '0') { HAL_GPIO_WritePin(GPIOA, GPIO_PIN_RESET); // LED OFF } } else { } } // Kalau tidak ada data → LED kedip HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); HAL_Delay(200); /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ /* USER CODE END 3 */ } /** * @brief System Clock Configuration * @retval None */ void SystemClock_Config(void) GPIO_PIN_5, GPIO_PIN_5 { /** Initializes the RCC Oscillators according to the specified parameters * in the RCC_OscInitTypeDef structure. */ RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI; RCC_OscInitStruct.HSIState = RCC_HSI_ON; RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT; RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE; if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) { Error_Handler(); } /** Initializes the CPU, AHB and APB buses clocks */ 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; if RCC_OscInitTypeDef RCC_OscInitStruct = {0}; RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK) { } } /** Error_Handler(); * @brief USART1 Initialization Function * @param None * @retval None */ static void MX_USART1_UART_Init(void) { /* USER CODE BEGIN USART1_Init 0 */ /* USER CODE END USART1_Init 0 */ /* USER CODE BEGIN USART1_Init 1 */ /* USER CODE END USART1_Init 1 */ 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; if (HAL_UART_Init(&huart1) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN USART1_Init 2 */ /* USER CODE END USART1_Init 2 */ } /** * @brief GPIO Initialization Function * @param None * @retval None */ static void MX_GPIO_Init(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; /* USER CODE BEGIN MX_GPIO_Init_1 */ /* USER CODE END MX_GPIO_Init_1 */ /* GPIO Ports Clock Enable */ __HAL_RCC_GPIOA_CLK_ENABLE(); /*Configure GPIO pin Output Level */ HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET); /*Configure GPIO pin : PA5 */ GPIO_InitStruct.Pin = GPIO_PIN_5; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USER CODE BEGIN MX_GPIO_Init_2 */ /* USER CODE END MX_GPIO_Init_2 */ } /* USER CODE BEGIN 4 */ /* USER CODE END 4 */ /** * @brief occurrence. This function is executed in case of error * @retval None */ void Error_Handler(void) { } /* USER CODE BEGIN Error_Handler_Debug */ /* USER CODE END Error_Handler_Debug */ #ifdef USE_FULL_ASSERT /** * @brief Reports the name of the source file and the source line number * where the assert_param error has occurred. * @param file: pointer to the source file name * @param line: assert_param error line source number * @retval None */ void assert_failed(uint8_t *file, uint32_t line) { } /* USER CODE BEGIN 6 */ /* USER CODE END 6 */ #endif /* USE_FULL_ASSERT */

5. Video Demo [Kembali]

                                                

6. Kondisi [Kembali]

Percobaan 3 

Buatlah rangkaian seperti pada gambar percobaan 3 Smart Entry Indicator sesuai dengan modul

7. Video Simulasi [Kembali]

                                                   

ANALISA DAN PEMBASAHAN

8. Download File [Kembali]

• Download File Laporan Akhir (klik disini)
• Download Datasheet PIR Sensor (klik disini)
• Download Datasheet Resistor (klik disini)
• Download Datasheet LED (klik disini)
• Download Datasheet Buzzer (klik disini)

Read More

MODUL III COMMUNICATION

DAFTAR ISI

1. Pendahuluan
2. Tujuan
3. Alat dan Bahan
4. Dasar Teori

5. Percobaan 

                               

Tugas Pendahuluan

laporan Akhir 

MODUL 3

COMMUNICATION

1. Pendahuluan [Kembali]

      Pada percobaan ini difokuskan pada implementasi sistem komunikasi antar-perangkat menggunakan protokol UART (Universal Asynchronous Receiver-Transmitter) dan I2C (Inter-Integrated Circuit). Sistem ini dirancang untuk mendemonstrasikan bagaimana dua buah mikrokontroler Nucleo dapat saling bertukar informasi secara asinkron, di mana satu unit berfungsi sebagai pengolah input dan unit lainnya sebagai eksekutor output. Penggunaan protokol komunikasi ini menjadi sangat krusial dalam sistem tertanam modern karena memungkinkan integrasi berbagai periferal, seperti sensor dan display, tanpa memerlukan jumlah kabel yang banyak, sehingga meningkatkan efisiensi arsitektur rangkaian.

    Khusus pada Percobaan 3, fokus utama terletak pada mekanisme transmisi data digital yang dikonversi menjadi aksi nyata berupa pengaturan sinyal PWM (Pulse Width Modulation). Proses diawali dengan pembacaan status input pada Nucleo 1 yang kemudian dikirimkan secara serial menuju Nucleo 2 untuk mengontrol visualisasi LED, baik dalam kondisi menyala kontinu maupun berkedip. Selain itu, integrasi layar OLED berbasis I2C berfungsi sebagai antarmuka pemantauan secara real-time, sehingga praktikan dapat memahami alur data yang kompleks mulai dari deteksi input, pengiriman pesan melalui jalur TX/RX, hingga dihasilkannya output spesifik pada aktuator.

2. Tujuan [Kembali]

1. Memahami cara penggunaan protokol komunikasi UART, SPI, dan I2C pada Development Board yang digunakan.
2. Memahami cara penggunaan komponen input dan output yang berkomunikasi secara UART, SPI, dan I2C pada Development Board yang digunakan

3. Alat dan Bahan [Kembali]

a.) STM32 NUCLEO-G474RE

b.) STM32F103C8

c.) LED

d.) Push Button 

e.) LDR Sensor 

f.) PIR Sensor

g.) Buzzer

h.) Resistor

i.) Breadboard

k.) Oled

l.) Adaptor/Sumber Tegangan

m.) Kabel Jumper

4. Dasar Teori [Kembali]

4.1 UART (Universal Asynchronous Receiver Transmitter)

UART (Universal Asynchronous Receiver Transmitter) UART (Universal Asynchronous Receiver-Transmitter) adalah bagian perangkat keras komputer yang menerjemahkan antara bit-bit paralel data dan bit-bit serial. UART biasanya berupa sirkuit terintegrasi yang digunakan untuk komunikasi serial pada komputer atau port serial perangkat periperal. Cara Kerja Komunikasi UART 

4.2 I2C (Inter-Intergrated Circuit)

       Inter Integrated Circuit atau sering disebut I2C adalah standar komunikasi serial dua arah menggunakan dua saluran yang didisain khusus untuk mengirim maupun menerima data. Sistem I2C terdiri dari saluran SCL (Serial Clock) dan SDA (Serial Data) yang membawa informasi data antara I2C dengan pengontrolnya.

Pada I2C, data ditransfer dalam bentuk message yang terdiri dari kondisi start, Address Frame, R/W bit, ACK/NACK bit, Data Frame 1, Data Frame 2, dan kondisi Stop. Kondisi start dimana saat pada SDA beralih dari logika high ke low sebelum SCL. Kondisi stop dimana saat pada SDA beralih dari logika low ke high sebelum SCL. R/W bit berfungsi untuk menentukan apakah master mengirim data ke slave atau meminta data dari slave. (logika 0 = mengirim data ke slave, logika 1 = meminta data dari slave) ACK/NACK bit berfungsi sebagai pemberi kabar jika data frame ataupun address frame telah diterima receiver.

4.3 SPI (Series Peripheral Interface)

Serial Peripheral Interface (SPI) merupakan salah satu mode komunikasi serial synchronous berkecepatan tinggi yang dimiliki oleh STM32F407VGT6 dan Raspberry Pi Pico. Komunikasi SPI membutuhkan 3 jalur utama yaitu MOSI, MISO, dan SCK, serta jalur tambahan SS/CS. Melalui komunikasi ini, data dapat saling dikirimkan baik antara mikrokontroler maupun antara mikrokontroler dengan perangkat periferal lainnya. 

 • MOSI (Master Output Slave Input) Jika dikonfigurasi sebagai master, maka pin MOSI berfungsi sebagai output. Sebaliknya, jika dikonfigurasi sebagai slave, maka pin MOSI berfungsi sebagai input. 

 • MISO (Master Input Slave Output) Jika dikonfigurasi sebagai master, maka pin MISO berfungsi sebagai input. Sebaliknya, jika dikonfigurasi sebagai slave, maka pin MISO berfungsi sebagai output.

• SCLK (Serial Clock) Jika dikonfigurasi sebagai master, maka pin SCLK bertindak sebagai output untuk memberikan sinyal clock ke slave. Sebaliknya, jika dikonfigurasi sebagai slave, maka pin SCLK berfungsi sebagai input untuk menerima sinyal clock dari master. 

 • SS/CS (Slave Select/Chip Select) Jalur ini digunakan oleh master untuk memilih slave yang akan dikomunikasikan. Pin SS/CS harus dalam keadaan aktif (umumnya logika rendah) agar komunikasi dengan slave dapat berlangsung

Sinyal clock dialirkan dari master ke slave yang berfungsi untuk sinkronisasi. Master dapat memilih slave mana yang akan dikirimkan data melalui slave select, kemudian data dikirimkan dari master ke slave melalui MOSI. Jika master butuh respon data maka slave akan mentransfer data ke master melalui MISO.

4.4 STM 32 NUCLEO G474RE

STM32 NUCLEO-G474RE merupakan papan pengembangan (development board) berbasis mikrokontroler STM32G474RET6 yang dikembangkan oleh STMicroelectronics. Board ini dirancang untuk memudahkan proses pembelajaran, pengujian, dan pengembangan aplikasi sistem tertanam (embedded system), baik untuk pemula maupun tingkat lanjut. STM32 Nucleo-G474RE mengintegrasikan antarmuka ST-LINK debugger/programmer secara onboard sehingga pengguna dapat langsung melakukan pemrograman dan debugging tanpa perangkat tambahan. Adapun spesifikasi dari STM32 NUCLEO-G474RE adalah sebagai berikut:

4.5 STM32F103C8

STM32F103C8 adalah mikrokontroler berbasis ARM Cortex-M3 yang dikembangkan oleh STMicroelectronics. Mikrokontroler ini sering digunakan dalam pengembangan sistem tertanam karena kinerjanya yang baik, konsumsi daya yang rendah, dan kompatibilitas dengan berbagai protokol komunikasi. Pada praktikum ini, kita menggunakan STM32F103C8 yang dapat diprogram menggunakan berbagai metode, termasuk komunikasi serial (USART), SWD (Serial Wire Debug), atau JTAG untuk berhubungan dengan komputer maupun perangkat lain. Adapun spesifikasi dari STM32F4 yang digunakan dalam praktikum ini adalah sebagai berikut:

 

A. BAGIAN-BAGIAN PENDUKUNG

1) STM32 NUCLEO-G474RE

1. RAM (Random Access Memory) RAM (Random Access Memory) pada STM32 NUCLEO-G474RE digunakan sebagai memori sementara untuk menyimpan data selama program berjalan. Mikrokontroler STM32G474RET6 memiliki RAM sebesar 128 KB yang berfungsi untuk menyimpan variabel, buffer data, stack, dan heap.

2. Memori Flash Eksternal STM32 NUCLEO-G474RE tidak menggunakan memori flash eksternal. Seluruh program dan data permanen disimpan pada memori Flash internal mikrokontroler STM32G474RET6 dengan kapasitas 512 KB. Memori flash ini bersifat non-volatile, sehingga data dan program tetap tersimpan meskipun catu daya dimatikan.

3. Crystal Oscillator STM32 NUCLEO-G474RE menggunakan osilator internal (HSI – High Speed Internal) sebagai sumber clock utama secara default. Penggunaan clock internal ini membuat board dapat beroperasi tanpa memerlukan crystal oscillator eksternal. Clock berfungsi sebagai sumber waktu untuk mengatur kecepatan kerja CPU dan seluruh peripheral.

4. Regulator Tegangan Untuk memastikan pasokan tegangan yang stabil ke mikrokontroler.

5. Pin GPIO (General Purpose Input/Output): Pin GPIO pada STM32 NUCLEO-G474RE digunakan sebagai antarmuka input dan output digital yang fleksibel.

2) STM32F103C8

1. RAM (Random Access Memory)

STM32F103C8 dilengkapi dengan 20KB SRAM on-chip. Kapasitas RAM ini memungkinkan mikrokontroler menjalankan berbagai aplikasi serta menyimpan data sementara selama eksekusi program.

2. Memori Flash Internal STM32F103C8 memiliki memori flash internal sebesar 64KB atau 128KB, yang digunakan untuk menyimpan firmware dan program pengguna. Memori ini memungkinkan penyimpanan kode program secara permanen tanpa memerlukan media penyimpanan eksternal.

3. Crystal Oscillator STM32F103C8 menggunakan crystal oscillator eksternal (biasanya 8MHz) yang bekerja dengan PLL untuk meningkatkan frekuensi clock hingga 72MHz. Sinyal clock yang stabil ini penting untuk mengatur kecepatan operasi mikrokontroler dan komponen lainnya.

4. Regulator Tegangan STM32F103C8 memiliki sistem pengaturan tegangan internal yang memastikan pasokan daya stabil ke mikrokontroler. Tegangan operasi yang didukung berkisar antara 2.0V hingga 3.6V.

5. Pin GPIO (General Purpose Input/Output) STM32F103C8 memiliki hingga 37 pin GPIO yang dapat digunakan untuk menghubungkan berbagai perangkat eksternal seperti sensor, motor, LED, serta komunikasi dengan antarmuka seperti UART, SPI, dan I²C.

Read More