Panduan Lengkap Setup STM32 Blue Pill (STM32F103C8) dengan Rust di Linux untuk Pemula

Persiapan Hardware

Hardware yang diperlukan dalam tutorial ini adalah STM32F103C8 (tentunya sudah pasti), ST-LINK USB Downloader Debuger, dan beberapa kabel (Kabel jumper female to female) untuk menghubungkan STM32F103C8 ke ST-LINK USB Downloader Debuger.

Mikrokontroler STM32F103C8

STM32F103C8 (Blue Pill) merupakan mikrokontroler yang menggunakan CPU 32 bit ARM Cortex-M3, dengan frekuensi CPU sampai 72MHZ, memiliki memori SRAM 20KB, dan varian memory flash 64KB. Spesifikasi lebih lengkap mengenai STM32F103C8 dapat dilihat pada halaman STM32F103C8. Pada tutorial ini kami akan menggunakan sistem minimum modul board STM32F103C8T6 Blue Pill. Anda dapat menggunakan board lain dengan mikrokontroler STM32F103C8 seperti black pill lama atau maple mini.

1.2 ST-LINK USB Downloader Debuger

ST-LINK USB Downloader Debuger berfungsi sebagai penghubung antara PC/laptop dengan STM32F103C8, sehingga kita bisa memprogram STM32F103C8 dari PC/laptop. ST-LINK USB Downloader Debuger menggunakan antarmuka Single Wire Interface Module (SWIM), Serial Wire Debugging (SWD), dan JTAG untuk terhubung ke STM32F103C8. Namun ST-LINK USB Downloader Debuger yang kami gunakan kali ini hanya mendukung antarmuka SWIM dan SWD, sehingga kita akan menggunakan antarmuka SWD.

Setup Software

Untuk memprogram STM32F103C8 menggunakan bahasa Pemrograman Rust di linux, kita perlu menginstall beberapa software yang diperlukan seperti Rust toolchain untuk mengkompilasi kode Rust ke binary, VSCode sebagai editor untuk mengedit kode Rust, dan probe-rs untuk men-load binary hasil kompilasi ke STM32F103C8.

Instalasi Rust Toolchain di linux

Rust toolchain berfungsi sebagai compiler yang akan mengubah baris kode Rust yang ditulis menjadi file binary yang dapat dijalankan di STM32F103C8. Untuk menginstall Rust toolchain di linux bisa dengan menggunakan perintah berikut:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Perintah tersebut akan menginstall rustup, cargo, rustc, dan komponen lain yang diperlukan untuk mengkompilasi kode Rust ke binary. Untuk mengecek apakah proses instalasi berhasil gunakan perintah berikut:

rustup --version

rustup 1.28.2 (e4f3ad6f8 2025-04-28)

info: This is the version for the rustup toolchain manager, not the rustc compiler.

info: The currently active `rustc` version is `rustc 1.90.0 (1159e78c4 2025-09-14)` 

Karena kita akan memprogram STM32F103C8 yang menggunakan chip ARM Cortex-M3, maka Rust toolchain perlu melakukan crosss-compilation agar binary hasil kompilasi dapat dijalankan di STM32F103C8. Untuk melakukan cross-compilation, Rust toolchain membutuhkan target compiler yang sesuai dengan CPU STM32F103C8 yang dapat diinstall dengan perintah berikut:

rustup target add thumbv7m-none-eabi

Mengecek target apakah berhasil terinstal dengan menggunakan perintah berikut:

rustup target list --installed

thumbv7m-none-eabi

x86_64-unknown-linux-gnu

Catatan: Berikut merupakan daftar Rust target compiler sesuai dengan 32 bit CPU ARM yang didukung:

• thumbv6m-none-eabi: Cortex-M0, Cortex-M0+
• thumbv7m-none-eabi: Cortex-M3
• thumbv7em-none-eabi: Cortex-M4, Cortex-M7 (tanpa FPU)
• thumbv7em-none-eabihf: Cortex-M4F, Cortex-M7F (dengan FPU)

Instalasi VSCode di linux

Untuk menulis dan mengedit kode Kita akan menggunakan Visual Studio Code (VSCode). Anda juga dapat menggunakan code editor yang lain sesuai dengan keinginan anda. Untuk instalasi VSCode di Fedora bisa menggunakan perintah berikut, jika anda menggunakan distro yang lain anda dapat melihat cara instalasi pada halaman Install VSCode.

sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc && \

echo -e "[code]\nname=Visual Studio Code\n\

baseurl=https://packages.microsoft.com/yumrepos/vscode\n\

enabled=1\n\

autorefresh=1\n\

type=rpm-md\n\

gpgcheck=1\n\

gpgkey=https://packages.microsoft.com/keys/microsoft.asc" \

| sudo tee /etc/yum.repos.d/vscode.repo > /dev/null

dnf check-update && sudo dnf install code

Selanjutnya menginstall extension Rust Analyzer untuk memudahkan kita nanti dalam menulis kode Rust di VSCode. Extension ini akan otomatis menampilkan autocomplete dan autoimport ketika kita menulis kode Rust.

• Buka Program VSCode
• Pilih tab Extenstion
• Cari Rust Analyzer
• Klik Install

Instalasi probe-rs di Linux

probe-rs merupakan program yang digunakan untuk mentransfer binary hasil kompilasi kode program Rust ke STM32F103C8. Untuk menginstall probe-rs di Linux bisa menggunakan perintah berikut:

curl -LsSf https://github.com/probe-rs/probe-rs/releases/latest/download/probe-rs-tools-installer.sh | sh

Instalasi Flip-Link di Linux

FLip-Link berfungsi mencegah kerusakan memori akibat stack overflow dengan cara membalikkan layout memori pada SRAM. Pada layout SRAM standar jika terjadi stack overflow (penggunaan memori stack yang melebihi kapasitas), stack akan menimpa variabel statis. Hal ini menyebabkan mikrokontroler mengalami undefined behavior. Dengan menggunakan Flip-Link hal ini dapat dihindari. Untuk menginstall Flip-Link di Linux bisa menggunakan perintah berikut:

cargo install flip-link

Memprogram STM32F103C8 dengan Rust

Berikut merupakan langkah-langkah yang akan kita lakukan untuk memprogram STM32F103C8 dengan Rust.

• Buat/edit kode sumber Rust
• Compile kode Rust ke binary
• Flash/load binary ke STM32F103C8

Setiap anda mengedit kode program Rust pastikan untuk selalu mengulangi langkah-langkah tersebut.

Membuat Program Pertama dengan Rust

Pertama kita akan membuat project Rust baru. Buat folder baru dengan nama “hello-stm32”. Kemudian buka program VSCode, pada VSCode pilih menu “File” klik “Open Folder”, lalu pilih folder “hello-stm32”. Selanjutnya pada VSCode pilih menu “Terminal” klik “New Terminal”. Pada terminal yang baru dibuat ketika perintah berikut untuk membuat project baru Rust:

cargo init --bin

Pada tab “Explorer” akan muncul file project Rust yang akan kita edit nanti. Selanjutnya pada folder “hello-stm32” buat file baru bernama “memory.x” lalu isi dengan kode berikut:

1//* memory.x - Linker script for the STM32F103C8T6 */
2MEMORY
3{
4  /* Flash memory begins at 0x80000000 and has a size of 64kB or 128kB*/
5  FLASH : ORIGIN = 0x08000000, LENGTH = 64K
6  /* RAM begins at 0x20000000 and has a size of 20kB*/
7  RAM : ORIGIN = 0x20000000, LENGTH = 20K
8}

File tersebut memberitahu linker mengenai lokasi dan ukuran memori Flash dan RAM pada mikrokontroler STM32F103C8.

Catatan: Kami menggunakan STM32F103C8T6 dengan ukuran flash 64kB, jika Anda menggunakan mikrokontroler STM32F103 variant lain silakan ubah FLASH LENGTH dan RAM LENGTH sesuai dengan datasheet yang dapat dilihat di bagian Memory Mapping.

Berikut adalah beberapa varian STM32F103C:

Selanjutnya kita akan mengonfigurasi project Rust agar melakukan cross-compilation ke CPU ARM Cortex M-3 sehingga bisa dijalankan di STM32F103C8. Di folder hello-tsm32 buat folder baru bernama “.cargo” kemudian di dalamnya buat file baru bernama “config.toml” lalu isi dengan kode berikut:

 1# Menentukan target CPU
 2[build]
 3target = "thumbv7m-none-eabi"
 4
 5# Otomatis load program ke STM32F103C8 ketika menjalankan perintah "cargo run"
 6[target.thumbv7m-none-eabi]
 7runner = ["probe-rs", "run", "--chip", "STM32F103C8Tx", "--log-format=oneline"]
 8
 9rustflags = [
10    "-C",
11    "linker=flip-link",   # Menggunakan linker flip-link untuk menghindari undefined behavior ketik stackoverflow
12    "-C",
13    "link-arg=-Tlink.x",  # Memberitahu linker untuk menggunakan Tlink.x yang disediakan oleh crate "cortex-m-rt"
14    "-C",
15    "link-arg=-Tdefmt.x", # Menggunakan Instruksi linker khusus yang dibutuhkan oleh crate "defmt"
16    "-C",
17    "link-arg=--nmagic",  # Menonaktifkan Page Alignment untuk menghemat memory flash
18]

Sekarang struktur project Rust kita akan terlihat seperti berikut:

Selanjutnya kita akan menambahkan library yang kita butuhkan pada project Rust. Buka file “Cargo.toml” dan tambahkan kode berikut:

 1[[bin]]
 2name = "hello-stm32"
 3path = "src/main.rs"
 4test = false # Untuk menghilangkan error akibat tidak ada modul test
 5bench = false # Untuk menghilangkan error akibat tidak ada modul test
 6
 7[dependencies]
 8# Mengakses fitur-fitur inti dari prosesor ARM Cortex-M.
 9cortex-m = { version = "0.7.7", features = ["critical-section-single-core"] }
10# Menyiapkan titik awal program, dan menangani error sistem.
11cortex-m-rt = "0.7.5"
12# Harware Abstraction Layer untuk memudahkan mengakses fitur-fitur STM32F103C8
13stm32f1xx-hal = { version = "0.11.0", features = ["stm32f103", "medium"] }
14# Untuk melakukan debugging ke terminal PC/laptop
15semihosting = { version = "0.1.21", features = ["stdio"] }
16# Panic handler khusus yang dirancang untuk probe-rs
17panic-probe = { version = "1.0", features = ["print-defmt"] }
18# Memformat pesan agar rapi
19defmt = "1.0.1"
20# Mengirim pesan ke terminal PC/laptop
21defmt-rtt = "1.1.0"
22
23[profile.dev]
24opt-level = 's'
25codegen-units = 1
26
27[profile.release]
28opt-level = 'z'
29lto = true

Selanjutnya bagian yang paling kita tunggu yaitu mengedit kode program Rust. Buka file “src/main.rs” lalu isi dengan kode berikut:

 1// Jangan gunakan library standard Rust
 2#![no_std]
 3// Memberitahu Rust toolchain bahwa program ini tidak dijalankan di OS
 4#![no_main]
 5
 6use defmt_rtt as _; 
 7use panic_probe as _; 
 8use stm32f1xx_hal as _; 
 9use cortex_m_rt::entry; 
10use defmt:: Format; 
11
12// Membuat struct baru yang mengimpementasikan trait "Format" dari crate/library "defmt" 
13#[derive(Format)]
14struct Person {
15    name: &'static str,
16    age: u8,
17}
18
19// Fungsi main sebagai entry program
20#[entry]
21fn main() -> ! {
22
23    // Mengirim pesan ke terminal PC/laptop
24    defmt::println!("Hello dari STM32F103C8T6");
25
26    let yogi = Person {
27        name: "Yogi Astawan",
28        age: 20,
29    };
30    // Mengirim pesan yang diformat ke terminal PC/laptop
31    defmt::println!("{:?}", yogi);
32    // Menghentikan semihosting diakhir program
33    semihosting::process::exit(0);
34
35}

Menjalankan Kode Program Rust di STM32F103C8

Sebelum menjalankan program yang sudah kita buat, kita harus menghubungkan ST-LINK USB Downloader Debuger ke STM32F103C8 dengan antarmuka SWD. Disini saya menggunakan kabel jumper female to female dengan koneksi pin ST-LINK ke pin STM32F103C8 sebagai berikut:

Pasang ST-Link USB Downloader Debuger ke port USB pada PC/laptop. selanjutnya untuk menjalankan program ketik perintah berikut di terminal VSCode:

cargo run

Berikut merupakan hasil dari program yang kita buat:

Pada post selanjutnya kita akan mencoba mengakses pin Input dan Output STM32F103C8 menggunakan bahasa Rust.

Permasalahan yang Ditemui

Permasalahan yang kami temui ketika membuat tutorial ini antara lain:

• Error: No connected probes were found ketika menjalankan cargo run. Cara penanganannya dengan memastikan ST-Link terhubung ke PC/laptop, dapat dilihat dari indikator power pada ST-Link dan STM32F103C8 yang menyala. Kadang kami juga mencoba memasang ulang ST-Link ke PC/laptop.

Jika Anda memiliki pertanyaan, kritik, dan saran silakan hubungi kami melalui halaman kontak.