Modul 3 Communication






 MODUL III
COMMUNICATION

1. Pendahuluan[Kembali]

   a)     Asistensi dilakukan 1x

   b)     Praktikum dilakukan 1x

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) Mikrokontroler STM32 NUCLEO-G474RE


         b) OLED

         c) Buzzer 



         d) Resistor



         e) LED 

        f) Push Button 
        
        g) Breadboard 

         h) Jamper
  • 4. Dasar Teori[Kembali] 

    4.1 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

    Gambar 1. 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.

                Cara Kerja Komunikasi I2C

    Gambar 2. Cara Kerja Komunikasi I2C

            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

    Cara Kerja Komunikasi SPI

    Gambar 3. Cara Kerja Komunikasi SPI

                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. STM32 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:

    Gambar 2. STM32 Nucleo G474RE


    Gambar 3. PinOut STM32 Nucleo G474RE


            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:

    Gambar 4. STM32F103C8

    Gambar 5. Pinout Stm32 F103C8T6


        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.






















    LA M3

    [menuju akhir]







    1. Prosedur[Kembali]

    Konfigurasi STM32CubeMX 
    1. Buat Buat dua project pada STM32CubeIDE:
        • Project_Nucleo (Transmitter + PIR) 
        • Project_Bluepill (Receiver + LED) 
    2. Konfigurasi Project Nucleo
        a. Konfigurasi GPIO (PIR)
            • Pin PA0 → GPIO Input
            • Mode: Pull-Down
        b. Konfigurasi UART Aktifkan USART1 dengan pengaturan:
            • Mode: Asynchronous
            • Baudrate: 9600
            • Word Length: 8 Bits
            • Stop Bit: 1
            • Parity: None
        c. Konfigurasi Pin UART
            • PC4 → TX (Transmit)
            • PC5 → RX (tidak digunakan)
    3. Konfigurasi Project Bluepill
        a. Konfigurasi GPIO (LED)
            • Pin PA5 → GPIO Output
            • Mode: Push Pull
        b. Konfigurasi UART Aktifkan USART1 dengan pengaturan:
            • Mode: Asynchronous
            • Baudrate: 9600
            • Word Length: 8 Bits
            • Stop Bit: 1
            • Parity: None  

     2. Hardware dan Diagram Blok[Kembali]

    a. Hardware

    1. STM32 NUCLEO-G474RE

    STM32 NUCLEO-G474RE adalah papan pengembangan (development board) berbasis mikrokontroler STM32 yang dirancang oleh STMicroelectronics untuk memudahkan proses pembelajaran, prototyping, dan pengembangan sistem embedded.

    Secara spesifik, board ini menggunakan mikrokontroler STM32G474RE, yang termasuk dalam keluarga STM32 seri G4. Mikrokontroler ini berbasis inti ARM Cortex-M4 dengan kemampuan pemrosesan yang cukup tinggi serta dilengkapi dengan fitur DSP (Digital Signal Processing) dan FPU (Floating Point Unit), sehingga sangat cocok untuk aplikasi yang membutuhkan perhitungan matematis cepat seperti kontrol motor, sistem tenaga, dan pengolahan sinyal.

    2. STM32F103C8

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

    3. PIR Sensor

    PIR sensor (Passive Infrared Sensor) adalah sensor yang digunakan untuk mendeteksi pergerakan manusia atau makhluk hidup berdasarkan perubahan radiasi inframerah di sekitarnya.


    4. Resistor

    Resistor adalah komponen elektronik pasif yang berfungsi untuk membatasi arus listrik dalam suatu rangkaian. Resistor bekerja berdasarkan hukum Ohm, yang menyatakan bahwa tegangan (V) = arus (I) × resistansi (R). Resistor memiliki satuan Ohm (Ω) dan digunakan dalam berbagai aplikasi seperti pembagian tegangan, kontrol arus, dan proteksi rangkaian elektronik.

    5. LED

    LED adalah dioda semikonduktor yang dapat memancarkan cahaya ketika dialiri arus listrik. LED digunakan dalam berbagai aplikasi seperti indikator elektronik, pencahayaan, dan display. LED hanya bekerja pada arah bias maju dan memiliki berbagai warna yang ditentukan oleh material semikonduktornya.


    b. Diagram Blok





    3. Rangkaian Simulasi dan Prinsip Kerja[Kembali]

    Prinsip Kerja :

    Prinsip kerja rangkaian dimulai saat sistem dinyalakan, kemudian mikrokontroler melakukan inisialisasi GPIO dan UART sebagai jalur input/output serta komunikasi data. Setelah itu, sensor PIR membaca adanya gerakan di sekitar sensor secara terus-menerus.

    Jika sensor PIR mendeteksi gerakan, maka mikrokontroler mengirimkan data “1” melalui komunikasi UART ke aplikasi Bluepill. Sebaliknya, jika tidak ada gerakan yang terdeteksi, sistem mengirimkan data “0”. Data yang dikirim kemudian diterima dan diproses untuk menentukan kondisi output LED.

    Ketika data yang diterima bernilai “1”, LED akan menyala terus sebagai indikator adanya gerakan yang terdeteksi oleh sensor PIR. Namun jika data bernilai selain “1” atau “0”, LED akan bekerja dalam mode berkedip (kelap-kelip) sebagai indikator tidak adanya deteksi gerakan. Setelah proses selesai, sistem kembali mengulangi loop pembacaan sensor sehingga monitoring gerakan berlangsung secara kontinu dan real-time.

    4. Flowchart dan Listing Program[Kembali]

    a. Flowchart



    b. Listing Program

    • Nucleo

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

    • Bluepill
    /* 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_5, GPIO_PIN_SET); // LED ON
    } else if (rx_data == '0') { HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, 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) { /** 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. Analisa[Kembali]
















    7. Download File[Kembali]
    [menuju awal]

    Modul 3 Communication

    [KEMBALI KE MENU SEBELUMNYA] DAFTAR ISI 1. Pendahuluan 2. Tujuan 3. Alat dan Bahan 4. Dasar Teori 5. Percobaan ...