Learn Rust Coding · Pelajaran

HAL dan Pengandar Perangkat

Pelajari cara menggunakan Lapisan Abstraksi Perangkat Keras (HAL) dan menulis pengandar perangkat sederhana untuk berinteraksi dengan periferal pada mikrokontroler.

HAL dan Pengandar Perangkat adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Lapisan Abstraksi Perangkat Keras (HAL)

Selamat datang di dunia Embedded Rust! Saat bekerja dengan mikrokontroler, Anda akan menjumpai konsep penting: Lapisan Abstraksi Perangkat Keras (HAL).

HAL adalah lapisan perangkat lunak yang menyediakan antarmuka standar ke periferal mikrokontroler, seperti pin GPIO, I2C, SPI, dan UART. HAL menyembunyikan detail rumit manipulasi register secara langsung.

Mengapa Kita Membutuhkan HAL

Bayangkan Anda mencoba membuat LED berkedip. Pada satu mikrokontroler, Anda mungkin menetapkan sebuah bit dalam register GPIO_PORTA_DR. Pada mikrokontroler lain, register tersebut mungkin berupa PIND_OUT.

Kerumitan: Akses register secara langsung merepotkan dan rentan terhadap kesalahan.
Portabilitas: Tanpa HAL, kode yang ditulis untuk satu chip tidak akan berfungsi pada chip lain, meskipun keduanya berasal dari keluarga yang sama.

HAL mengatasi hal ini dengan memberi Anda cara yang konsisten untuk berinteraksi dengan perangkat keras, terlepas dari chip yang digunakan.

Ekosistem Embedded HAL Rust

Dalam Rust, crate embedded-hal mendefinisikan sekumpulan trait (seperti antarmuka) untuk operasi periferal yang umum. Trait ini berfungsi sebagai kontrak yang harus diterapkan oleh HAL mikrokontroler tertentu.

embedded-hal: Menyediakan trait umum (misalnya, DigitalOutputPin, I2c).
HAL khusus chip: Crate seperti rp-hal (untuk Raspberry Pi Pico) atau stm32f4xx-hal menerapkan trait ini untuk perangkat kerasnya masing-masing.

Pemisahan ini memungkinkan driver perangkat ditulis secara generik!

Interaksi HAL Dasar: GPIO

Mari kita lihat bagaimana HAL dapat mengabstraksikan pin General Purpose Input/Output (GPIO). Dalam kode tertanam nyata, Anda akan mendapatkan objek pin dari HAL chip Anda lalu mengonfigurasinya.

Contoh ini menyimulasikan cara berinteraksi dengan objek 'pin' untuk mengendalikan LED.

struct GpioPin {
    name: String,
    state: bool,
}

impl GpioPin {
    fn new(name: &str) -> Self {
        println!("Configuring {} as output...", name);
        GpioPin { name: name.to_string(), state: false }
    }
    fn set_high(&mut self) {
        self.state = true;
        println!("{} set to HIGH (LED ON)", self.name);
    }
    fn set_low(&mut self) {
        self.state = false;
        println!("{} set to LOW (LED OFF)", self.name);
    }
    fn toggle(&mut self) {
        if self.state { self.set_low(); } else { self.set_high(); }
    }
}

fn main() {
    let mut led_pin = GpioPin::new("LED_GPIO_PIN");
    println!("\n--- Blinking LED Simulation ---");
    led_pin.set_high();
    led_pin.set_low();
    led_pin.toggle();
    led_pin.toggle();
    println!("-----------------------------");
}

Memahami Mode Pin GPIO

Pin GPIO bukan hanya untuk menyalakan dan mematikan sesuatu! Pin GPIO memiliki beberapa mode:

Output: Untuk mengendalikan komponen eksternal (seperti LED).
Input: Untuk membaca sinyal dari komponen eksternal (seperti tombol).
Input dengan Pull-up/Pull-down: Untuk memastikan keadaan yang stabil saat tidak ada yang terhubung, sehingga mencegah input 'mengambang'.
Analog: Untuk membaca tingkat tegangan berkelanjutan (misalnya, dari sensor).

HAL menyediakan metode untuk mengonfigurasi mode-mode ini dengan aman.

Apa Itu Driver Perangkat?

Jika HAL memberi Anda kendali tingkat rendah atas periferal, driver perangkat dibangun di atas HAL untuk menyediakan fungsionalitas tingkat lebih tinggi bagi perangkat eksternal tertentu (misalnya, sensor suhu atau layar LCD).

Driver perangkat mengabstraksikan protokol komunikasi (seperti I2C atau SPI) dan perintah khusus yang diperlukan oleh chip tertentu. Driver mengubah transfer byte mentah menjadi operasi bermakna seperti sensor.read_temperature().

Menstandarkan Driver dengan `embedded-hal`

Kekuatan sejati embedded-hal terlihat saat menulis pengandar. Alih-alih pengandar mengetahui HAL tertentu untuk STM32 atau RP2040, pengandar hanya perlu mengetahui sifat-sifat embedded-hal.

Misalnya, pengandar untuk sensor suhu I2C mungkin memerlukan objek yang mengimplementasikan sifat embedded_hal::i2c::I2c. Artinya, kode pengandar yang sama dapat digunakan pada mikrokontroler apa pun yang memiliki HAL yang mengimplementasikan sifat tersebut!

Contoh Pengandar: Sensor I2C (Konseptual)

Bayangkan Anda memiliki sensor suhu yang berkomunikasi melalui I2C. Pengandar perangkat untuk sensor tersebut akan:

Menerima objek embedded_hal::i2c::I2c sebagai masukan.
Mengimplementasikan metode seperti read_temperature() atau set_config().
Secara internal, metode-metode ini akan menggunakan metode i2c.write_read() atau i2c.write() yang disediakan oleh HAL yang mendasarinya melalui sifat embedded-hal.

Dengan demikian, tercipta antarmuka yang rapi dan dapat digunakan kembali untuk sensor tersebut.

Langkah-Langkah Membuat Pengandar Dasar

Jika Anda ingin menulis pengandar perangkat sederhana untuk komponen baru, berikut gambaran konseptualnya:

Definisikan Struktur Pengandar: Simpan antarmuka periferal (misalnya, objek I2C dari HAL Anda) dan status khusus pengandar.
Implementasikan `new()`: Inisialisasi pengandar, mungkin sekaligus mengonfigurasi periferal.
Tambahkan Metode Interaksi: Buat fungsi seperti read_data() dan write_config() yang menggunakan metode HAL.
Tangani Kesalahan: Gunakan tipe Result Rust untuk menangani kesalahan komunikasi atau perangkat dengan baik.

Pemeriksaan Singkat HAL dan Pengandar

Uji pemahaman Anda tentang Lapisan Abstraksi Perangkat Keras dan pengandar perangkat.

Rangkuman: HAL dan Pengandar

Dalam pelajaran ini, kita mempelajari bagaimana Lapisan Abstraksi Perangkat Keras (HAL) menyediakan lapisan abstraksi yang penting, menyederhanakan interaksi dengan periferal mikrokontroler, dan meningkatkan portabilitas kode.

Kita juga mempelajari bagaimana pengandar perangkat dibangun di atas HAL dan sifat-sifat embedded-hal untuk menyediakan antarmuka tingkat tinggi yang dapat digunakan kembali bagi komponen eksternal tertentu, sehingga Anda tidak perlu menangani detail komunikasi tingkat rendah. Pendekatan berlapis ini merupakan kunci pengembangan Rust tertanam yang andal!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “HAL dan Pengandar Perangkat” gratis?

Ya — teks lengkap “HAL dan Pengandar Perangkat” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “HAL dan Pengandar Perangkat”?

Pelajari cara menggunakan Lapisan Abstraksi Perangkat Keras (HAL) dan menulis pengandar perangkat sederhana untuk berinteraksi dengan periferal pada mikrokontroler. Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 3.

Berapa lama pelajaran “HAL dan Pengandar Perangkat” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding