Learn Rust Coding · บทเรียน

HAL และไดรเวอร์อุปกรณ์

เรียนรู้การใช้ชั้นนามธรรมของฮาร์ดแวร์ (HAL) และเขียนไดรเวอร์อุปกรณ์อย่างง่ายเพื่อโต้ตอบกับอุปกรณ์ต่อพ่วงบนไมโครคอนโทรลเลอร์

HAL และไดรเวอร์อุปกรณ์ เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 3 บทเรียน

ชั้นนามธรรมฮาร์ดแวร์ (HAL)

ยินดีต้อนรับสู่โลกของ Rust แบบฝังตัว! เมื่อทำงานกับไมโครคอนโทรลเลอร์ คุณจะได้พบกับแนวคิดสำคัญอย่างหนึ่ง นั่นคือ ชั้นนามธรรมฮาร์ดแวร์ (HAL)

HAL คือชั้นซอฟต์แวร์ที่มีอินเทอร์เฟซมาตรฐานสำหรับอุปกรณ์ต่อพ่วงของไมโครคอนโทรลเลอร์ เช่น ขา GPIO, I2C, SPI และ UART โดยซ่อนรายละเอียดซับซ้อนของการจัดการรีจิสเตอร์โดยตรง

เหตุผลที่เราต้องใช้ HAL

ลองนึกภาพว่าคุณต้องการทำให้ LED กะพริบ บนไมโครคอนโทรลเลอร์เครื่องหนึ่ง คุณอาจตั้งค่าบิตในรีจิสเตอร์ GPIO_PORTA_DR แต่อีกเครื่องหนึ่งอาจใช้ PIND_OUT

ความซับซ้อน: การเข้าถึงรีจิสเตอร์โดยตรงยุ่งยากและเกิดข้อผิดพลาดได้ง่าย
ความสามารถในการย้ายโค้ด: หากไม่มี HAL โค้ดที่เขียนสำหรับชิปหนึ่งจะใช้กับอีกชิปหนึ่งไม่ได้ แม้จะอยู่ในตระกูลเดียวกัน

HAL แก้ปัญหานี้ด้วยการมอบวิธีโต้ตอบกับฮาร์ดแวร์ที่สม่ำเสมอ โดยไม่ขึ้นกับชิปที่อยู่เบื้องหลัง

ระบบนิเวศ HAL สำหรับระบบฝังตัวของ Rust

ใน Rust กล่อง embedded-hal กำหนดชุดคุณลักษณะ (คล้ายอินเทอร์เฟซ) สำหรับการทำงานกับอุปกรณ์ต่อพ่วงทั่วไป คุณลักษณะเหล่านี้ทำหน้าที่เป็นสัญญาที่ HAL เฉพาะของไมโครคอนโทรลเลอร์ต้องนำไปใช้

embedded-hal: มีคุณลักษณะทั่วไป เช่น DigitalOutputPin และ I2c
HAL เฉพาะชิป: กล่องอย่าง rp-hal (สำหรับ Raspberry Pi Pico) หรือ stm32f4xx-hal นำคุณลักษณะเหล่านี้ไปใช้กับฮาร์ดแวร์ของตน

การแยกส่วนเช่นนี้ทำให้สามารถเขียนไดรเวอร์อุปกรณ์แบบทั่วไปได้!

การใช้งาน HAL เบื้องต้น: GPIO

มาดูกันว่า HAL จะสร้างชั้นนามธรรมให้ขาอินพุต/เอาต์พุตใช้งานทั่วไป (GPIO) ได้อย่างไร ในโค้ดระบบฝังตัวจริง คุณจะรับออบเจ็กต์ขาจาก HAL ของชิป แล้วกำหนดค่าให้ขานั้น

ตัวอย่างนี้จำลองวิธีที่คุณจะโต้ตอบกับออบเจ็กต์ 'ขา' เพื่อควบคุม 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!("-----------------------------");
}

ทำความเข้าใจโหมดของขา GPIO

ขา GPIO ไม่ได้มีไว้เพียงเปิดและปิดสิ่งต่าง ๆ เท่านั้น แต่ยังมีโหมดต่าง ๆ:

เอาต์พุต: ใช้ควบคุมส่วนประกอบภายนอก เช่น LED
อินพุต: ใช้อ่านสัญญาณจากส่วนประกอบภายนอก เช่น ปุ่มกด
อินพุตพร้อมตัวดึงขึ้น/ตัวดึงลง: ใช้รักษาสถานะให้คงที่เมื่อไม่มีสิ่งใดเชื่อมต่อ เพื่อป้องกันอินพุตที่มีสถานะลอย
แอนะล็อก: ใช้อ่านระดับแรงดันต่อเนื่อง เช่น จากเซ็นเซอร์

HAL มีเมธอดสำหรับกำหนดค่าโหมดเหล่านี้อย่างปลอดภัย

ไดรเวอร์อุปกรณ์คืออะไร

แม้ HAL จะให้คุณควบคุมอุปกรณ์ต่อพ่วงในระดับต่ำได้ แต่ไดรเวอร์อุปกรณ์จะสร้างต่อยอดจาก HAL เพื่อมอบฟังก์ชันการทำงานระดับสูงสำหรับอุปกรณ์ภายนอกเฉพาะชนิด เช่น เซ็นเซอร์อุณหภูมิหรือหน้าจอ LCD

ไดรเวอร์อุปกรณ์สร้างชั้นนามธรรมให้โพรโทคอลการสื่อสาร เช่น I2C หรือ SPI และคำสั่งเฉพาะที่จำเป็นสำหรับชิปแต่ละชนิด โดยเปลี่ยนการถ่ายโอนไบต์ดิบให้เป็นการทำงานที่มีความหมาย เช่น sensor.read_temperature()

การทำให้ไดรเวอร์เป็นมาตรฐานด้วย `embedded-hal`

พลังที่แท้จริงของ embedded-hal จะแสดงออกมาอย่างเต็มที่เมื่อเขียนไดรเวอร์ แทนที่ไดรเวอร์จะต้องรู้จัก HAL เฉพาะของ STM32 หรือ RP2040 ก็เพียงรู้จักคุณลักษณะของ embedded-hal เท่านั้น

ตัวอย่างเช่น ไดรเวอร์สำหรับเซนเซอร์อุณหภูมิ I2C อาจต้องการออบเจ็กต์ที่ใช้งานคุณลักษณะ embedded_hal::i2c::I2c ได้ ซึ่งหมายความว่า โค้ดไดรเวอร์เดียวกัน สามารถทำงานบนไมโครคอนโทรลเลอร์ใด ๆ ที่มี HAL ซึ่งใช้งานคุณลักษณะนี้ได้

ตัวอย่างไดรเวอร์: เซนเซอร์ I2C (เชิงแนวคิด)

สมมติว่าคุณมีเซนเซอร์อุณหภูมิที่สื่อสารผ่าน I2C ไดรเวอร์อุปกรณ์สำหรับเซนเซอร์นี้จะทำสิ่งต่อไปนี้:

รับออบเจ็กต์ embedded_hal::i2c::I2c เป็นอินพุต
ใช้งานเมธอดต่าง ๆ เช่น read_temperature() หรือ set_config()
ภายใน เมธอดเหล่านี้จะใช้เมธอด i2c.write_read() หรือ i2c.write() ที่ HAL พื้นฐานจัดเตรียมไว้ผ่านคุณลักษณะ embedded-hal

วิธีนี้ทำให้ได้ส่วนติดต่อที่เป็นระเบียบและนำกลับมาใช้ซ้ำได้สำหรับเซนเซอร์

ขั้นตอนการสร้างไดรเวอร์พื้นฐาน

หากคุณต้องการเขียนไดรเวอร์อุปกรณ์อย่างง่ายสำหรับองค์ประกอบใหม่ นี่คือโครงร่างเชิงแนวคิด:

กำหนดโครงสร้างไดรเวอร์: เก็บส่วนติดต่ออุปกรณ์ต่อพ่วง เช่น ออบเจ็กต์ I2C ของ HAL และสถานะเฉพาะของไดรเวอร์
ใช้งาน `new()`: เริ่มต้นไดรเวอร์ และอาจกำหนดค่าอุปกรณ์ต่อพ่วงด้วย
เพิ่มเมธอดสำหรับการโต้ตอบ: สร้างฟังก์ชัน เช่น read_data() และ write_config() ที่ใช้เมธอดของ HAL
จัดการข้อผิดพลาด: ใช้ชนิด Result ของ Rust เพื่อจัดการข้อผิดพลาดด้านการสื่อสารหรืออุปกรณ์อย่างเหมาะสม

ตรวจสอบความเข้าใจอย่างรวดเร็ว: HAL และไดรเวอร์

ทดสอบความเข้าใจของคุณเกี่ยวกับชั้นนามธรรมของฮาร์ดแวร์และไดรเวอร์อุปกรณ์

ทบทวน: HAL และไดรเวอร์

ในบทเรียนนี้ เราได้สำรวจว่า ชั้นนามธรรมของฮาร์ดแวร์ (HAL) เป็นชั้นนามธรรมที่สำคัญ ช่วยให้การโต้ตอบกับอุปกรณ์ต่อพ่วงของไมโครคอนโทรลเลอร์ง่ายขึ้น และเพิ่มความสามารถในการย้ายโค้ดไปใช้กับระบบอื่น

เรายังได้เรียนรู้ว่า ไดรเวอร์อุปกรณ์ สร้างต่อยอดจาก HAL และคุณลักษณะของ embedded-hal เพื่อมอบส่วนติดต่อระดับสูงที่นำกลับมาใช้ซ้ำได้สำหรับองค์ประกอบภายนอกแต่ละชนิด ทำให้คุณไม่ต้องจัดการรายละเอียดการสื่อสารระดับต่ำ แนวทางแบบแบ่งชั้นนี้เป็นหัวใจสำคัญของการพัฒนา Rust แบบฝังตัวที่แข็งแกร่ง

คำถามที่พบบ่อย

บทเรียน “HAL และไดรเวอร์อุปกรณ์” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “HAL และไดรเวอร์อุปกรณ์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 3 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “HAL และไดรเวอร์อุปกรณ์”

เรียนรู้การใช้ชั้นนามธรรมของฮาร์ดแวร์ (HAL) และเขียนไดรเวอร์อุปกรณ์อย่างง่ายเพื่อโต้ตอบกับอุปกรณ์ต่อพ่วงบนไมโครคอนโทรลเลอร์ คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน

บทเรียน “HAL และไดรเวอร์อุปกรณ์” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Learn Rust Coding