1. Sediakan alat dan bahan percobaan
2. Rangkailah rangkaian di breadboard sesuai modul
3. Buka aplikasi thonny dan masukkan listing program library dan program utama ke dalam aplikasi tersebut
4. Buka aplikasi STM32 IDE dan masukkan listing program library dan program utama ke dalam aplikasi tersebut
5. Hubungkan rangkaian dengan software dengan kabel USB dan STM link
6. Jalankan program
1. Rasberry Pi Pico
.jpeg)
.jpeg)
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.
.jpeg)
Percobaan ini bertujuan untuk menghubungkan dua mikrokontroler, yaitu STM32F103C8 dan Raspberry Pi Pico, menggunakan komunikasi SPI (Serial Peripheral Interface). Dalam rangkaian ini, STM32 bertindak sebagai master, sementara Raspberry Pi Pico sebagai slave. Komunikasi ini digunakan untuk mengirimkan informasi status dari tiga buah push button yang terhubung ke STM32, dan hasilnya ditampilkan pada layar OLED yang dikendalikan oleh Pi Pico.
Pertama, STM32 akan menginisialisasi tiga buah tombol yang terhubung ke pin PB12, PB13, dan PB14. Masing-masing tombol mewakili warna tertentu, yaitu tombol pertama untuk "Merah", tombol kedua untuk "Hijau", dan tombol ketiga untuk "Biru". Ketika salah satu tombol ditekan, STM32 akan membaca status tombol tersebut (aktif rendah, artinya tombol dianggap ditekan saat bernilai logika 0) dan menyimpannya dalam bentuk data array berisi tiga byte.
Setelah membaca status tombol, STM32 akan mengaktifkan komunikasi SPI dengan menurunkan sinyal CS (chip select), lalu mengirimkan ketiga byte data tersebut melalui pin MOSI (Master Out Slave In) ke Pi Pico. Setelah transmisi selesai, sinyal CS dikembalikan ke keadaan semula (HIGH). Hal ini menunjukkan bahwa pengiriman data sudah berakhir.
Di sisi lain, Raspberry Pi Pico menggunakan fitur PIO (Programmable I/O) untuk membaca data SPI sebagai slave. Pi Pico akan menunggu data dari STM32, dan setelah menerima tiga byte data, ia akan menampilkannya di layar OLED melalui komunikasi I2C. Jika tombol pertama ditekan, OLED akan menampilkan teks "Kata Merah". Jika tombol kedua ditekan, akan muncul "Kata Hijau", dan jika tombol ketiga ditekan, muncul "Kata Biru".
1. Pi Pico
import machine
from machine import Pin, SoftI2C
import ssd1306
from rp2 import PIO, StateMachine, asm_pio
from time import sleep
# ------ OLED Setup ------
i2c = SoftI2C(scl=Pin(5), sda=Pin(4)) # GP5 = SCL, GP4 = SDA
oled = ssd1306.SSD1306_I2C(128, 64, i2c)
oled.fill(0)
oled.text("SPI SLAVE READY", 0, 20)
oled.show()
# ------ SPI Slave PIO ------
@asm_pio(autopush=True, push_thresh=8)
def spi_slave():
wait(0, pin, 0) # Tunggu CS LOW (aktif)
set(x, 7) # Siapkan penghitung 8 bit (x = 7)
label("bitloop")
in_(pins, 1) # Baca 1 bit dari MOSI (GP3)
jmp(x_dec, "bitloop") # Ulangi 8 kali
push(block) # Dorong byte ke RX FIFO
wait(1, pin, 0) # Tunggu CS HIGH (selesai)
# ------ Setup StateMachine SPI ------
sm = StateMachine(0, spi_slave,
freq=4_500_000,
in_base=Pin(3), # GP3 = MOSI
jmp_pin=Pin(1)) # GP1 = CS
sm.active(1)
# ------ Main Loop ------
while True:
if sm.rx_fifo() >= 3:
data = [sm.get() for _ in range(3)]
print("SLAVE:", data) # Contoh output: [1, 2, 3]
# Tampilkan pesan di OLED
oled.fill(0)
oled.text("Data diterima", 0, 20)
oled.show()
sleep(0.1)
2. STM 32
#include "stm32f1xx_hal.h"
// Deklarasi handle SPI
SPI_HandleTypeDef hspi1;
// Prototipe fungsi
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_SPI1_Init(void);
int main(void) {
// Inisialisasi HAL
HAL_Init();
// Konfigurasi sistem clock dan periferal
SystemClock_Config();
MX_GPIO_Init();
MX_SPI1_Init();
// Array untuk menyimpan status tombol: [Merah, Hijau, Biru]
uint8_t button_states[3] = {0};
while (1) {
// Baca status tombol (aktif LOW karena pull-up)
button_states[0] = !HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_12); // Merah
button_states[1] = !HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13); // Hijau
button_states[2] = !HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_14); // Biru
// Kirim data via SPI
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET); // CS LOW
HAL_SPI_Transmit(&hspi1, button_states, 3, 100); // Kirim data
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET); // CS HIGH
HAL_Delay(100); // Delay untuk stabilitas
}
}
// Konfigurasi clock sistem
void SystemClock_Config(void) {
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9; // 8 MHz x 9 = 72 MHz
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 SPI1
void MX_SPI1_Init(void) {
hspi1.Instance = SPI1;
hspi1.Init.Mode = SPI_MODE_MASTER;
hspi1.Init.Direction = SPI_DIRECTION_1LINE; // Hanya MOSI
hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
hspi1.Init.NSS = SPI_NSS_SOFT;
hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; // ~4.5 MHz @ 72 MHz
hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
HAL_SPI_Init(&hspi1);
}
// Inisialisasi GPIO
void MX_GPIO_Init(void) {
GPIO_InitTypeDef GPIO_InitStruct = {0};
// Aktifkan clock GPIO
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
// Konfigurasi tombol input: PB12, PB13, PB14
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);
// Konfigurasi SPI1: PA5 (SCK), PA7 (MOSI)
GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
// Konfigurasi CS manual: PA4
GPIO_InitStruct.Pin = GPIO_PIN_4;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET); // Default CS HIGH
}
5. Video Demo[Kembali]
1. Jelaskan bagaimana proses komunikasi yang terjadi pada percobaan (SPI dan I2C)!
Jawab :
Dalam percobaan ini, digunakan dua jenis komunikasi data digital, yaitu SPI (Serial Peripheral Interface) dan I2C (Inter-Integrated Circuit).
SPI digunakan untuk komunikasi antara dua papan mikrokontroler: STM32F103C8 dan Raspberry Pi Pico. Pada SPI, STM32 bertindak sebagai master, sedangkan Pi Pico sebagai slave. Komunikasi SPI bekerja berdasarkan empat jalur utama: MOSI (Master Out Slave In), MISO (Master In Slave Out), SCK (Clock), dan CS/SS (Chip Select). Namun, dalam percobaan ini, hanya jalur MOSI, SCK, dan CS yang digunakan karena arah komunikasi hanya satu arah — dari STM32 ke Pi Pico.
Sementara itu, I2C digunakan oleh Raspberry Pi Pico untuk berkomunikasi dengan layar OLED. I2C merupakan protokol komunikasi dua kabel yang menggunakan pin SDA (Serial Data) dan SCL (Serial Clock). Dalam hal ini, Pi Pico berfungsi sebagai master I2C, dan OLED sebagai slave. Data ditransmisikan secara serial melalui dua pin tersebut untuk menampilkan informasi dalam bentuk teks.
2. Jelaskan bagaimana proses data digital dikirimkan antara kedua Dev.board !
Jawab :
Data digital dalam percobaan ini berasal dari tiga buah push button yang terhubung ke papan STM32. Ketika pengguna menekan salah satu tombol, STM32 membaca status tombol sebagai logika LOW (0) karena tombol dikonfigurasi menggunakan pull-up resistor.
Setelah membaca status ketiga tombol, STM32 mengubahnya menjadi array berisi tiga angka (misalnya: [1, 0, 0] jika tombol pertama ditekan). Array ini lalu dikirimkan melalui jalur MOSI menggunakan fungsi HAL_SPI_Transmit(). Sebelum mengirimkan data, STM32 menurunkan pin CS (Chip Select) untuk memberi tahu Pi Pico bahwa data akan dikirim, lalu mengembalikannya ke HIGH setelah selesai.
Di sisi lain, Pi Pico yang telah diprogram sebagai SPI slave menggunakan PIO (Programmable I/O) akan menunggu sinyal CS LOW, dan mulai membaca bit data dari pin MOSI. Setelah menerima tiga byte data, Pi Pico menyimpannya dalam FIFO (First In First Out) dan siap untuk diproses lebih lanjut.
3. Jelaskan bagaimana proses data yang dikirimkan menampilkan karakter pada LCD !
Jawab :
Setelah Raspberry Pi Pico menerima data dari STM32, data tersebut diubah menjadi bentuk informasi yang dapat dipahami manusia, yaitu teks warna yang ditampilkan di layar OLED. Pi Pico terlebih dahulu mengecek isi data. Misalnya:
a. Jika data adalah [1, 0, 0], artinya tombol 1 ditekan → tampilkan “Kata Merah”
b. Jika data adalah [0, 1, 0] → tampilkan “Kata Hijau”
c. Jika data adalah [0, 0, 1] → tampilkan “Kata Biru”
Untuk menampilkan teks ini, Pi Pico menggunakan komunikasi I2C ke OLED. Melalui fungsi dari pustaka ssd1306, Pi Pico mengirimkan perintah ke OLED untuk menampilkan teks yang sesuai pada koordinat tertentu di layar. Fungsi seperti oled.text() digunakan untuk menulis teks, dan oled.show() digunakan untuk menampilkan hasilnya di layar.
Dengan demikian, informasi dari tombol fisik pada STM32 berhasil diterjemahkan menjadi pesan visual pada OLED melalui rangkaian komunikasi yang melibatkan SPI dan I2C secara terintegrasi.
KESIMPULAN
Dalam percobaan ini, menggunakan protocol komunikasi data seperti SPI (Serial Peripheral Interface) yang merupakan protokol komunikasi sinkron antara dua perangkat, dalam hal ini STM32 sebagai pengirim (master) dan Raspberry Pi Pico sebagai penerima (slave). I2C (Inter-Integrated Circuit) digunakan oleh Pi Pico untuk mengontrol layar OLED, yang berfungsi menampilkan informasi. Push button digunakan sebagai input digital pada STM32, sedangkan resistor berfungsi sebagai penarik arus agar tombol bekerja dengan stabil (pull-up). Prinsip kerja percobaan secara sederhana adalah: saat tombol ditekan, STM32 membaca tombol tersebut dan mengirimkan datanya dalam bentuk digital melalui SPI ke Pi Pico. Selanjutnya, Pi Pico mengolah data ini dan menampilkan informasi sesuai tombol yang ditekan dalam bentuk kata berwarna (Merah, Hijau, Biru) pada layar OLED melalui komunikasi I2C.
Download HTML klik disini
Download file Analisa klik disini
Download Datasheet Resistor klik disini
Download Datasheet IC Rasberry Pi Pico klik disini
Download Datasheet Push Button klik disini
Download Datasheet OLED klik disini
Tidak ada komentar:
Posting Komentar