LA 1 uP uC M3

 [KEMBALI KE MENU SEBELUMNYA]


LA- Percobaan 7

UART dan I2C


1. Prosedur [Kembali]
1. Rangkai rangkaian sesuai dengan kondisi percobaan.
2. Buat program untuk mikrokontroler STM32F103C8 di software STM32 CubeIDE.
3. Buat program untuk Raspberry pi pico di software ThonyIDE.
4. Jalankan simulasi rangkaian.
5. Selesai. 

2. Hardware dan Diagram Blok[Kembali]

Raspberry Pi Pico 


STM32F103C8 

Push Button



LCD
 
Resistor

3. Rangkaian Simulasi dan Prinsip Kerja[Kembali]


  • Prinsip Kerja

Sistem ini terdiri dari dua mikrokontroler, yaitu STM32F103C8T6 (Blue Pill) dan Raspberry Pi Pico, yang berkomunikasi melalui jalur UART. STM32 berfungsi sebagai pengirim data, sementara Raspberry Pi Pico bertugas sebagai penerima data dan pengendali tampilan LCD I2C. Pada sisi STM32, terdapat tiga tombol yang masing-masing terhubung ke pin PB12, PB13, dan PB14. Saat salah satu tombol ditekan, STM32 akan mendeteksi input tersebut dan mengirimkan data berupa teks “MERAH”, “HIJAU”, atau “BIRU” melalui UART. Data ini dikirim menggunakan fungsi HAL_UART_Transmit dengan kecepatan baud 9600.

Di sisi penerima, Raspberry Pi Pico menggunakan UART0 (pin GP0 dan GP1) untuk membaca data dari STM32. Setelah data diterima, data akan diproses dan ditampilkan ke LCD 16x2 yang terhubung melalui antarmuka I2C menggunakan modul pico_i2c_lcd. Jika data yang diterima adalah “MERAH”, “HIJAU”, atau “BIRU”, maka LCD akan menampilkan pesan sesuai warna tersebut, misalnya “Warna: Merah”. Jika data tidak dikenali atau terjadi error dalam decoding, maka LCD akan menampilkan pesan kesalahan. Dengan demikian, sistem ini membentuk komunikasi antar mikrokontroler secara serial untuk mentransfer status input tombol dari STM32 ke Raspberry Pi Pico, dan menampilkannya secara real-time di layar LCD.


4. Flowchart dan Listing Program[Kembali]
  • Flochart


  • Listing Program
✓ STM32
#include "main.h"
#include <string.h>
UART_HandleTypeDef huart1;
// Fungsi prototipe
void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_USART1_UART_Init(void);
// Fungsi kirim UART
void send_uart(char *text) {
HAL_UART_Transmit(&huart1, (uint8_t *)text, strlen(text), HAL_MAX_DELAY);
}
int main(void) {
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_USART1_UART_Init();
while (1) {
if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_12) == GPIO_PIN_RESET) {
send_uart("MERAH\r\n");
HAL_Delay(300);
while (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_12) == GPIO_PIN_RESET);
} else if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13) == GPIO_PIN_RESET) {
send_uart("HIJAU\r\n");
HAL_Delay(300);
while (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13) == GPIO_PIN_RESET);
} else if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_14) == GPIO_PIN_RESET) {
send_uart("BIRU\r\n");
HAL_Delay(300);
while (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_14) == GPIO_PIN_RESET);
}
}
}
// Konfigurasi clock standar STM32F1
void SystemClock_Config(void) {
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
__HAL_RCC_AFIO_CLK_ENABLE();
__HAL_RCC_PWR_CLK_ENABLE();
__HAL_AFIO_REMAP_SWJ_NOJTAG(); // Bebaskan PB3-PB4
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
HAL_RCC_OscConfig(&RCC_OscInitStruct);
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_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2);
}
// Inisialisasi UART1 (TX: PA9, RX: PA10)
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;
HAL_UART_Init(&huart1);
}
// Inisialisasi GPIO PB12, PB13, PB14 sebagai input pull-up
void MX_GPIO_Init(void) {
GPIO_InitTypeDef GPIO_InitStruct = {0};
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
// Konfigurasi input tombol dengan Pull-Up
GPIO_InitStruct.Pin = GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}

✓ Raspberry Pi Pico
from machine import I2C, Pin, UART
import utime
from pico_i2c_lcd import I2cLcd
# Inisialisasi UART
uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))
# Inisialisasi LCD I2C
i2c = I2C(0, scl=Pin(5), sda=Pin(4), freq=400000)
I2C_ADDR = 0x27 # Ganti dengan alamat LCD Anda
I2C_NUM_ROWS = 2
I2C_NUM_COLS = 16
lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)
# Tunggu LCD siap
utime.sleep_ms(100)
lcd.clear()
lcd.putstr("Menunggu input...")
def process_uart_data(data):
try:
decoded = data.decode('utf-8').strip()
lcd.clear()
if decoded == "MERAH":
lcd.putstr("Warna: Merah")
elif decoded == "HIJAU":
lcd.putstr("Warna: Hijau")
elif decoded == "BIRU":
lcd.putstr("Warna: Biru")
else:
lcd.putstr(f"Data: {decoded}")
except Exception as e:
lcd.clear()
lcd.putstr(f"Error: {str(e)}")
while True:
if uart.any():
data = uart.readline()
if data:
process_uart_data(data)
utime.sleep_ms(100) # Beri sedikit jeda

5. Video Demo[Kembali]



6. Analisa[Kembali]

1. Jelaskan bagaimana proses komunikasi yang terjadi pada percobaan (UART dan I2C) !
Jawab:
    Percobaan ini menunjukkan sistem komunikasi antar dua mikrokontroler, yaitu STM32 dan Raspberry Pi Pico, menggunakan protokol UART (Universal Asynchronous Receiver Transmitter), serta komunikasi antara Raspberry Pi Pico dengan LCD I2C menggunakan protokol I2C (Inter-Integrated Circuit).

    Pertama, mikrokontroler STM32 terhubung dengan tiga buah push button pada pin GPIOB (PB12, PB13, PB14) yang dikonfigurasi sebagai input pull-up. Ketika salah satu tombol ditekan, STM32 akan membaca kondisi pin yang berubah menjadi logika LOW (karena pull-up), lalu mengirimkan data berupa string (misalnya “MERAH”, “HIJAU”, atau “BIRU”) melalui UART1 (TX: PA9, RX: PA10) ke Raspberry Pi Pico.

    Raspberry Pi Pico menerima data tersebut melalui UART0 (TX: GP0, RX: GP1), memproses string yang diterima, lalu menampilkannya di LCD I2C. Protokol I2C digunakan oleh Raspberry Pi Pico untuk mengendalikan LCD 16x2, di mana jalur komunikasi dilakukan melalui pin SCL (GP5) dan SDA (GP4). Setelah data diterima dari STM32, Pico mendekode isi data dan mencetak hasilnya di layar LCD sesuai dengan perintah—misalnya menampilkan “Warna: Merah” jika string yang diterima adalah “MERAH”.

2. Jelaskan bagaimana proses data analog dikirimkan antara kedua Dev.board !
Jawab:
    Dalam sistem komunikasi antar dua development board ini, yaitu STM32 dan Raspberry Pi Pico, proses pengiriman data dilakukan melalui komunikasi digital menggunakan UART (Universal Asynchronous Receiver Transmitter), bukan secara langsung dalam bentuk sinyal analog. Namun, proses ini tetap berkaitan dengan pemrosesan input analog yang telah dikonversi atau ditentukan secara logika pada STM32. Tiga buah tombol (push button) terhubung ke pin GPIOB (PB12, PB13, dan PB14) pada STM32 yang dikonfigurasi sebagai input dengan pull-up, dan meskipun tombol ini bekerja dalam bentuk logika digital (HIGH atau LOW), pada dasarnya tombol-tombol ini merepresentasikan pemicu dari kondisi yang bisa dianalogikan seperti warna yang dipilih.

    Saat salah satu tombol ditekan, STM32 membaca kondisi pin menjadi logika LOW (karena konfigurasi pull-up), dan kemudian mengirimkan string data (seperti "MERAH", "HIJAU", atau "BIRU") melalui pin TX dari UART1 (PA9) ke Raspberry Pi Pico yang menerima melalui pin RX pada UART0. Jadi, meskipun input tombol bersifat digital, ia merupakan representasi dari sebuah nilai atau kondisi analog dalam bentuk label teks.

    Setelah Raspberry Pi Pico menerima data tersebut, ia memproses string yang diterima dan menampilkannya di LCD I2C (16x2) menggunakan protokol komunikasi I2C melalui pin GP4 (SDA) dan GP5 (SCL). Setiap string yang diterima akan diproses dan ditampilkan sebagai informasi warna yang sesuai. Proses ini menunjukkan bagaimana data “analog” dalam bentuk makna atau simbolis (warna yang dipilih) dapat diubah menjadi data digital, dikirimkan antar perangkat menggunakan UART, dan kemudian divisualisasikan kembali sebagai teks oleh Raspberry Pi Pico.

    
3. Jelaskan bagaimana proses data yang dikirimkan menampilkan karakter pada LCD !
Jawab:
    Pada sistem ini, proses pengiriman dan penampilan data pada LCD dilakukan melalui komunikasi serial UART antara dua mikrokontroler, yaitu STM32 dan Raspberry Pi Pico, serta penggunaan modul LCD I2C pada sisi penerima. STM32 berfungsi sebagai pengirim data, sementara Raspberry Pi Pico bertindak sebagai penerima sekaligus pengendali tampilan LCD.

    Proses dimulai ketika salah satu dari tiga tombol yang terhubung ke pin GPIOB (PB12, PB13, atau PB14) pada STM32 ditekan. Tombol-tombol ini dikonfigurasi sebagai input dengan pull-up resistor, sehingga saat ditekan, nilainya terbaca sebagai logika LOW (GPIO\_PIN\_RESET). Ketika kondisi ini terdeteksi dalam loop utama (`while(1)`), STM32 akan mengirimkan string karakter melalui USART1 menggunakan fungsi `HAL_UART_Transmit()`. Data yang dikirim berupa teks sederhana seperti `"MERAH\r\n"`, `"HIJAU\r\n"`, atau `"BIRU\r\n"` tergantung tombol yang ditekan.

    Data ini ditransmisikan secara serial (UART) melalui pin TX dari STM32 ke pin RX Raspberry Pi Pico. Di sisi Pico, UART diinisialisasi pada baud rate yang sama yaitu 9600 bps, dan Pico terus memantau apakah ada data yang masuk (`uart.any()`). Ketika data diterima, program membaca baris data (`uart.readline()`), mendekodenya dari byte menjadi string UTF-8, lalu memproses isi string tersebut dalam fungsi `process_uart_data()`.

    Dalam fungsi ini, jika data cocok dengan salah satu kata kunci seperti `"MERAH"`, `"HIJAU"`, atau `"BIRU"`, maka LCD akan dibersihkan (`lcd.clear()`) dan menampilkan karakter sesuai perintah, misalnya: `"Warna: Merah"`. Jika data tidak sesuai dengan ketiga kondisi tersebut, maka string yang diterima tetap akan ditampilkan sebagai data mentah di LCD. Modul LCD yang digunakan terhubung ke Raspberry Pi Pico melalui protokol I2C, memanfaatkan pin GP4 sebagai SDA dan GP5 sebagai SCL.


4. Analisa kenapa saat percobaan tadi tidak sesuai kondisi
Jawab: 
Hal ini dapat disebabkan oleh :
  1. Pemasangan konfigurasi pin antara Rx dan Tx pada STM32 dan Raspberry pi pico terpasang secara terbalik dan tidak terhubung dengan benar.
  2. Kesalahan dalam perangkaian rangkaian percobaan 7 yang mana wire terpasang pada tempat yang tidak semestinya.
  3. Ketidaksinkronan inisialisas UART ( Baud Rate , Parity Bit dan Stop Bit ) yang terkonfigurasi pada aplikasi STM32cubeIDE dengan yang ada pada Raspberry Pi Pico dengan nilai yang tidak sama.
  4. Kesalahan praktikan dalam pemasangan komponen

7. Download File[Kembali]