𝓗𝓐𝓡𝓘𝓢 𝓗𝓔𝓝𝓓𝓡𝓐 𝓤𝓛𝓨𝓐: LAPORAN AKHIR MODUL 3

Fungsi utama STM32 adalah sebagai pengontrol sistem, mampu melakukan pemrosesan data dan menjalankan instruksi untuk berbagai aplikasi, mulai dari perangkat sederhana hingga sistem yang kompleks.

2. Push Button

Gambar Push Botton

Push button adalah sakelar sederhana yang dioperasikan dengan menekan tombolnya. Ini digunakan untuk mengontrol atau memicu suatu tindakan, seperti mengaktifkan atau menonaktifkan perangkat elektronik.

3. Resistor

(a) (b)

Gambar resistor (a) tampilan hardware, (b) tampilan simulasi

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.

4. LED RGB

LED RGB adalah perangkat elektronik yang dapat menghasilkan warna merah,hijau dan biru.

3. Rangkaian Simulasi dan Prinsip Kerja[Kembali]

Gambar Rangkaian Percobaan 1 Modul 3

Prinsip Kerja :

Rangkaian ini terdiri dari dua buah mikrokontroler STM32 yang masing-masing berperan sebagai pengirim (transmitter) dan penerima (receiver) data menggunakan komunikasi UART. Pada sisi transmitter, terdapat empat buah push button yang masing-masing dihubungkan ke pin input digital STM32, yaitu pin A1, A2, A3, dan A4. Tombol-tombol ini berfungsi sebagai masukan yang akan mengirimkan sinyal logika ke mikrokontroler ketika ditekan. Saat salah satu tombol ditekan, STM32 pengirim akan membaca status logika dari pin tersebut dan kemudian mengirimkan data melalui jalur komunikasi UART, berupa karakter yang menunjukkan tombol mana yang ditekan (misalnya ‘1’ untuk tombol pertama, ‘2’ untuk tombol kedua, dan seterusnya).

Data yang dikirimkan oleh transmitter akan diterima oleh STM32 penerima melalui pin RX UART yang terhubung secara langsung dengan pin TX dari STM32 pengirim. Setelah menerima data, STM32 penerima akan memproses karakter tersebut dan menentukan LED mana yang harus dinyalakan berdasarkan tombol yang ditekan pada sisi pengirim. LED-LED tersebut terhubung ke pin A1, A2, A3, dan A4 pada STM32 penerima, dan akan menyala sesuai perintah yang diterima. Sebagai contoh, jika tombol pada pin A1 transmitter ditekan, maka LED pada pin A1 receiver akan menyala.

Seluruh sistem ini bekerja berdasarkan prinsip komunikasi serial UART yang menghubungkan dua mikrokontroler. Kedua STM32 harus memiliki konfigurasi UART yang sesuai, termasuk pengaturan baudrate yang sama, dan harus berbagi ground agar komunikasi berlangsung stabil. Rangkaian ini merupakan implementasi dasar dari sistem kontrol jarak jauh antara dua mikrokontroler melalui komunikasi serial.

4. Flowchart dan Listing Program[Kembali]

a. Flowchart

b. Listing Program

1. STM32 UART 1 pada Tx (Transmitter)

/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2025 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 ---------------------------------------------------------*/
UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */
uint8_t buttonStates[4] = {'0', '0', '0', '0'}; // Status awal: semua button tidak ditekan
/* 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 */
uint8_t charToTransmit[5];
/* USER CODE END 0 */

/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_USART1_UART_Init();

while (1)
{
// Baca status push button (PA1-PA4) dengan pull-up
buttonStates[0] = (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_SET) ? '1' : '0'; // PA1
buttonStates[1] = (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_2) == GPIO_PIN_SET) ? '1' : '0'; // PA2
buttonStates[2] = (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_3) == GPIO_PIN_SET) ? '1' : '0'; // PA3
buttonStates[3] = (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_4) == GPIO_PIN_SET) ? '1' : '0'; // PA4

// Kirim data status tombol via UART
HAL_UART_Transmit(&huart1, buttonStates, 4, 100);

HAL_Delay(100); // Debouncing tombol (perlu menyesuaikan dengan aplikasi)
}
}

/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
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_HSI;
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_0) != HAL_OK)
{
Error_Handler();
}
}

/**
* @brief USART1 Initialization Function
* @param None
* @retval None
*/
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;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
}

/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};

__HAL_RCC_GPIOA_CLK_ENABLE();

// Mengonfigurasi tombol PA1-PA4 sebagai input dengan pull-up
GPIO_InitStruct.Pin = GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP; // Pull-up untuk tombol
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
__disable_irq();
while (1)
{
}
}

#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
/* User can add his own implementation to report the file name and line number */
}
#endif

2. STM 32 UART 2 pada Rx (Receive)

/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2025 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 ---------------------------------------------------------*/
UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */
uint8_t receivedData[4]; // Menyimpan data yang diterima
/* 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)
{

/* MCU Configuration--------------------------------------------------------*/
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_USART1_UART_Init();

/* Infinite loop */
while (1)
{
// Menerima data 4 byte (status button)
if(HAL_UART_Receive(&huart1, receivedData, 4, 100) == HAL_OK)
{
// Kontrol LED berdasarkan status tombol
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, (receivedData[0] == '0') ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, (receivedData[1] == '0') ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, (receivedData[2] == '0') ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, (receivedData[3] == '0') ? GPIO_PIN_SET : GPIO_PIN_RESET);

// Kirim balik data sebagai verifikasi atau debug
HAL_UART_Transmit(&huart1, receivedData, 4, 100);
}
HAL_Delay(50); // Delay untuk stabilitas komunikasi
}
}

/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
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_HSI;
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_0) != HAL_OK)
{
Error_Handler();
}
}

/**
* @brief USART1 Initialization Function
* @param None
* @retval None
*/
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;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
}

/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};

__HAL_RCC_GPIOA_CLK_ENABLE();

HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4, GPIO_PIN_RESET);

GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4;
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);
}

/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
__disable_irq();
while (1)
{
}
}

5. Video Demo[Kembali]

6. Analisa[Kembali]

ANALISA MODUL 3: COMMUNICATION

1. Analisa bagaimana konfigurasi rangkaian dan program dari percobaan yang telah dilakukan!

Jawab :

Dalam percobaan ini, Percobaan yang dilakukan merupakan implementasi komunikasi UART antara dua board mikrokontroler STM32, dengan fungsi utama mengirimkan status tombol dari board pengirim (Tx) ke board penerima (Rx), yang kemudian akan digunakan untuk mengontrol LED. Konfigurasi rangkaian dirancang secara sederhana namun efektif. Pada board pengirim, empat buah tombol push button dihubungkan ke pin PA1 hingga PA4 dengan konfigurasi internal pull-up, sehingga dalam keadaan tidak ditekan, pin akan bernilai logika tinggi. Saat tombol ditekan, pin akan bernilai rendah. Status dari masing-masing tombol dibaca melalui pin GPIO dan dikonversikan menjadi karakter '1' atau '0', yang menunjukkan kondisi ditekan atau tidaknya tombol. Keempat status tersebut kemudian dikirimkan secara serial melalui antarmuka UART dengan baud rate 9600 ke board penerima melalui pin TX (PA9) ke RX (PA10), serta sambungan GND antar kedua board untuk memastikan referensi tegangan yang sama.

Di sisi penerima, board STM32 lainnya dikonfigurasikan untuk menerima data melalui UART. Data yang diterima berupa empat karakter yang masing-masing merepresentasikan kondisi dari satu tombol. Setiap karakter hasil penerimaan dibandingkan; jika karakter bernilai '0', maka pin GPIO yang bersesuaian (PA1 hingga PA4) akan diberi logika tinggi untuk menyalakan LED. Sebaliknya, jika bernilai '1', maka pin akan diberi logika rendah untuk mematikan LED. Logika ini dibuat agar LED menyala saat tombol pada board pengirim ditekan, karena tombol bekerja secara aktif rendah.

Program dikembangkan menggunakan HAL library dari STM32, yang mempermudah inisialisasi dan penggunaan periferal seperti GPIO dan UART. Pada board pengirim, program utama melakukan pembacaan tombol dan pengiriman data secara terus-menerus dalam loop dengan delay 100 milidetik untuk menjaga kestabilan transmisi. Sementara itu, board penerima terus-menerus membaca data UART dan memperbarui kondisi LED berdasarkan data yang diterima.

Secara keseluruhan, percobaan ini menunjukkan konfigurasi perangkat keras dan perangkat lunak yang terintegrasi dengan baik untuk mengimplementasikan komunikasi UART satu arah dengan pengendalian output berdasarkan input digital. Implementasi ini juga dapat menjadi dasar bagi pengembangan sistem kontrol sederhana berbasis mikrokontroler dengan komunikasi serial.

2.⁠ Jelaskan bagaimana proses komunikasi yang terjadi pada percobaan (UART/SPI/ 2C) !

Jawab :

Pada percobaan ini, proses komunikasi yang digunakan adalah UART (Universal Asynchronous Receiver Transmitter). Komunikasi UART bersifat asinkron, artinya tidak membutuhkan sinyal clock eksternal untuk sinkronisasi data antara pengirim (Tx) dan penerima (Rx). Proses komunikasi yang terjadi melibatkan dua buah board STM32 yang saling terhubung melalui pin UART, yaitu pin TX (transmit) dari board pengirim dihubungkan ke pin RX (receive) pada board penerima, serta sambungan GND sebagai referensi tegangan bersama.
Komunikasi dimulai dari board pengirim (Tx), yang secara berkala membaca status empat buah tombol yang terhubung ke pin PA1 hingga PA4. Setiap tombol memberikan nilai logika ‘0’ atau ‘1’ tergantung apakah tombol ditekan atau tidak, kemudian dikonversi ke dalam bentuk karakter dan disusun menjadi array berisi empat karakter ('1' atau '0'). Setelah itu, array tersebut dikirimkan melalui periferal UART menggunakan fungsi HAL_UART_Transmit, yang secara internal akan mengubah data paralel ke bentuk serial dan mengirimkannya byte per byte.
Di sisi penerima (Rx), data serial yang masuk melalui pin RX diterima oleh UART dan dikembalikan ke bentuk paralel oleh modul UART internal. Fungsi HAL_UART_Receive digunakan untuk membaca data tersebut ke dalam array receivedData, yang kemudian digunakan untuk mengatur kondisi pin GPIO yang mengontrol empat buah LED. Jika data yang diterima menyatakan tombol tidak ditekan ('0'), maka LED akan menyala, dan sebaliknya LED akan mati jika tombol ditekan ('1'), sesuai dengan logika pengaturan output.

Karena UART hanya menggunakan dua jalur komunikasi utama (TX dan RX), proses ini sangat efisien dan cocok digunakan untuk komunikasi point-to-point antar dua mikrokontroler. Komunikasi ini juga mendukung kecepatan transmisi yang cukup tinggi dan pengendalian data yang real-time, yang sangat ideal untuk sistem kendali sederhana seperti yang dilakukan dalam percobaan ini.

3. ⁠Jelaskan bagaimana proses inputan dan outputan yang terjadi pada percobaan!

Jawab :

Pada percobaan ini, proses inputan dan outputan terjadi melalui interaksi antara tombol (push button) sebagai input dan LED sebagai output, yang dikendalikan oleh dua buah mikrokontroler STM32 melalui komunikasi UART.
Proses dimulai pada mikrokontroler pengirim (Tx), di mana terdapat empat buah push button yang masing-masing terhubung ke pin PA1 hingga PA4. Setiap tombol tersebut berfungsi sebagai input digital, yang statusnya dibaca menggunakan fungsi HAL_GPIO_ReadPin. Karena tombol dikonfigurasi dengan pull-up internal, maka ketika tombol tidak ditekan, pin akan bernilai logika tinggi (‘1’), dan ketika ditekan, nilainya menjadi logika rendah (‘0’). Nilai ini kemudian dikonversi menjadi karakter (‘1’ atau ‘0’) dan disimpan dalam array buttonStates.
Setelah status tombol dikumpulkan, data dikirim secara serial melalui UART ke mikrokontroler penerima (Rx). Di sisi penerima, data yang diterima melalui pin RX kemudian disimpan dalam array receivedData.
Setiap elemen dari array tersebut mencerminkan kondisi tombol pada sisi pengirim. Nilai-nilai ini selanjutnya digunakan untuk mengontrol empat buah LED yang terhubung ke pin PA1 hingga PA4 pada mikrokontroler penerima. Jika karakter yang diterima adalah ‘0’ (tombol ditekan), maka LED akan dinyalakan dengan memberikan logika tinggi ke pin GPIO yang sesuai. Sebaliknya, jika karakter adalah ‘1’ (tombol tidak ditekan), maka LED akan dimatikan.

Dengan demikian, proses input terjadi saat pengguna menekan tombol pada rangkaian Tx, sedangkan outputnya terlihat dari perubahan status LED pada rangkaian Rx, yang menjadi representasi visual dari input yang diberikan. Proses ini berjalan secara terus-menerus dengan pembaruan data setiap interval delay (misalnya 100 ms), sehingga sistem dapat merespon perubahan input secara real-time.

4. ⁠Jelaskan algoritma percobaan!

jawab:

Algoritma dari percobaan ini melibatkan dua mikrokontroler STM32 yang saling berkomunikasi menggunakan protokol UART, di mana satu bertindak sebagai pengirim (Tx) dan satu lagi sebagai penerima (Rx). Tujuan utama dari algoritma ini adalah mentransfer status tombol dari pengirim ke penerima, dan mengubah status LED berdasarkan informasi tersebut.

Berikut alur algoritma yang terjadi:

Mikrokontroler pengirim (Tx) pertama-tama melakukan inisialisasi sistem, termasuk konfigurasi clock, UART, dan GPIO. Dalam loop utamanya, mikrokontroler membaca status dari empat buah push button yang terhubung ke pin PA1 hingga PA4. Setiap tombol menghasilkan nilai logika ‘0’ atau ‘1’, yang kemudian dikonversi ke karakter ‘0’ atau ‘1’ dan disimpan dalam array buttonStates. Setelah itu, array ini dikirim secara serial menggunakan HAL_UART_Transmit melalui UART1.

Di sisi mikrokontroler penerima (Rx), proses dimulai dengan inisialisasi yang sama seperti pengirim. Pada loop utamanya, mikrokontroler mencoba menerima data sebanyak 4 byte menggunakan HAL_UART_Receive. Jika berhasil, data yang diterima disimpan dalam array receivedData. Setiap elemen dalam array tersebut diperiksa, dan berdasarkan nilainya, LED pada pin PA1 hingga PA4 dinyalakan atau dimatikan. Jika data ‘0’ diterima, LED menyala, dan jika ‘1’, LED padam. Setelah itu, data diterima juga dikirimkan kembali ke pengirim sebagai bentuk verifikasi atau debug.

Dengan algoritma ini, sistem mampu memperlihatkan bagaimana status tombol secara real-time dikirim melalui UART dan diterjemahkan langsung ke dalam aksi fisik berupa nyala atau padamnya LED. Seluruh proses berjalan secara berulang dalam loop dengan sedikit penundaan waktu untuk stabilitas sistem.

KESIMPULAN

Kesimpulan dari percobaan ini menunjukkan bahwa komunikasi serial UART antara dua mikrokontroler STM32 dapat berjalan dengan baik dan stabil. Mikrokontroler pertama berfungsi sebagai pemancar (Tx) yang membaca status empat tombol push button melalui input GPIO, kemudian mengirimkan data status tersebut dalam bentuk karakter '0' dan '1' melalui antarmuka UART. Mikrokontroler kedua sebagai penerima (Rx) menerima data tersebut dan menggunakannya untuk mengatur kondisi LED, menyala atau mati, sesuai status tombol yang diterima. Sistem ini memperlihatkan implementasi komunikasi data secara real-time antara dua perangkat, dengan alur kerja input dan output yang selaras serta algoritma yang sederhana namun efektif. Percobaan ini menjadi dasar penting dalam memahami komunikasi antar mikrokontroler menggunakan UART untuk aplikasi sistem tertanam atau kontrol jarak dekat.

7. Download File[Kembali]

Download file Analisa klik disini
Download video Demo klik disini

Download Datasheet Resistor klik disini

Download Datasheet Push Button klik disini

[menuju awal]

𝓗𝓐𝓡𝓘𝓢 𝓗𝓔𝓝𝓓𝓡𝓐 𝓤𝓛𝓨𝓐

LAPORAN AKHIR MODUL 3

Tidak ada komentar:

Posting Komentar

MEMAHAMI ETIKA DI ERA DIGITAL

Laporkan Penyalahgunaan